Skip to main content

Version: 6.2

LoadedCollection <T>

Hierarchy

Collection<T>
- LoadedCollection

Index

Properties

$
owner

Accessors

length

Properties

$

$: Collection<T, object>

readonlyowner

owner: object

Accessors

length

get length(): number

Inherited from Collection.length
Returns number

Methods

[iterator]

[iterator](): IterableIterator<T>

Inherited from Collection.[iterator]
Returns IterableIterator<T>

add

add<TT>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>, ...entities: (TT | Reference<TT>)[]): void

Inherited from Collection.add
Type parameters
- TT: object
Parameters
- entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>
- rest...entities: (TT | Reference<TT>)[]
Returns void

contains

contains<TT>(item: TT | Reference<TT>, check?: boolean): boolean

Inherited from Collection.contains
Type parameters
- TT: object
Parameters
- item: TT | Reference<TT>
- check: boolean = true
Returns boolean

count

count(): number

Inherited from Collection.count
Returns number

exists

exists(cb: (item: T) => boolean): boolean

Inherited from Collection.exists
Tests for the existence of an element that satisfies the given predicate.
Parameters
- cb: (item: T) => boolean
Returns boolean

filter

filter(cb: (item: T, index: number) => boolean): T[]

Inherited from Collection.filter
Extracts a subset of the collection items.
Parameters
- cb: (item: T, index: number) => boolean
Returns T[]

find

find(cb: (item: T, index: number) => boolean): undefined | T

Inherited from Collection.find
Returns the first element of this collection that satisfies the predicate.
Parameters
- cb: (item: T, index: number) => boolean
Returns undefined | T

get

get(): Collection<T, object>

Returns Collection<T, object>

getIdentifiers

getIdentifiers<U>(field?: string): U[]

Inherited from Collection.getIdentifiers
Type parameters
- U: IPrimaryKeyValue = (T extends { [PrimaryKeyProp]?: PK } ? PK extends keyof T ? ReadonlyPrimary<UnwrapPrimary<T[PK]>> : PK extends keyof T[] ? ReadonlyPrimary<PrimaryPropToType<T, PK>> : PK : T extends { _id?: PK } ? string | ReadonlyPrimary<PK> : T extends { uuid?: PK } ? ReadonlyPrimary<PK> : T extends { id?: PK } ? ReadonlyPrimary<PK> : T) & IPrimaryKeyValue
Parameters
- optionalfield: string
Returns U[]

getItems

getItems(check?: boolean): T[]

Overrides Collection.getItems
Returns the items (the collection must be initialized)
Parameters
- optionalcheck: boolean
Returns T[]

indexBy

indexBy<K1, K2>(key: K1): Record<T[K1] & PropertyKey, T>
indexBy<K1, K2>(key: K1, valueKey: K2): Record<T[K1] & PropertyKey, T[K2]>

Inherited from Collection.indexBy
Maps the collection items to a dictionary, indexed by the key you specify. If there are more items with the same key, only the first one will be present.
Type parameters
- K1: string | number | symbol
- K2: string | number | symbol = never
Parameters
- key: K1
Returns Record<T[K1] & PropertyKey, T>

init

init<TT, P>(options?: InitCollectionOptions<TT, P, *, never>): Promise<LoadedCollection<Loaded<TT, P>>>

Inherited from Collection.init
Type parameters
- TT: object
- P: string = never
Parameters
- options: InitCollectionOptions<TT, P, *, never> = {}
Returns Promise<LoadedCollection<Loaded<TT, P>>>

isDirty

isDirty(): boolean

Inherited from Collection.isDirty
Returns boolean

isEmpty

isEmpty(): boolean

Inherited from Collection.isEmpty
Returns boolean

isInitialized

isInitialized(fully?: boolean): boolean

Inherited from Collection.isInitialized
Parameters
- fully: boolean = false
Returns boolean

load

load<TT, P>(options?: InitCollectionOptions<TT, P, *, never>): Promise<LoadedCollection<Loaded<TT, P>>>

Inherited from Collection.load
Ensures the collection is loaded first (without reloading it if it already is loaded). Returns the Collection instance (itself), works the same as Reference.load().
Type parameters
- TT: object
- P: string = never
Parameters
- options: InitCollectionOptions<TT, P, *, never> = {}
Returns Promise<LoadedCollection<Loaded<TT, P>>>

loadCount

loadCount(options?: boolean | LoadCountOptions<T>): Promise<number>

Inherited from Collection.loadCount
Gets the count of collection items from database instead of counting loaded items. The value is cached (unless you use the where option), use refresh: true to force reload it.
Parameters
- options: boolean | LoadCountOptions<T> = {}
Returns Promise<number>

loadItems

loadItems<TT, P>(options?: InitCollectionOptions<TT, P, *, never>): Promise<Loaded<TT, P>[]>

Inherited from Collection.loadItems
Initializes the collection and returns the items
Type parameters
- TT: object
- P: string = never
Parameters
- optionaloptions: InitCollectionOptions<TT, P, *, never>
Returns Promise<Loaded<TT, P>[]>

map

map<R>(mapper: (item: T, index: number) => R): R[]

Inherited from Collection.map
Maps the collection items based on your provided mapper function.
Type parameters
- R
Parameters
- mapper: (item: T, index: number) => R
Returns R[]

matching

matching<TT, P>(options: MatchingOptions<T, P>): Promise<Loaded<TT, P>[]>

Inherited from Collection.matching
Type parameters
- TT: object
- P: string = never
Parameters
- options: MatchingOptions<T, P>
Returns Promise<Loaded<TT, P>[]>

populated

populated(populated?: undefined | boolean): void

Inherited from Collection.populated
Parameters
- populated: undefined | boolean = true
Returns void

reduce

reduce<R>(cb: (obj: R, item: T, index: number) => R, initial?: R): R

Inherited from Collection.reduce
Maps the collection items based on your provided mapper function to a single object.
Type parameters
- R
Parameters
- cb: (obj: R, item: T, index: number) => R
- initial: R = ...
Returns R

remove

remove<TT>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | (item: TT) => boolean, ...entities: (TT | Reference<TT>)[]): void

Inherited from Collection.remove
Remove specified item(s) from the collection. Note that removing item from collection does not necessarily imply deleting the target entity, it means we are disconnecting the relation - removing items from collection, not removing entities from database - Collection.remove() is not the same as em.remove(). If we want to delete the entity by removing it from collection, we need to enable orphanRemoval: true, which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
Type parameters
- TT: object
Parameters
- entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | (item: TT) => boolean
- rest...entities: (TT | Reference<TT>)[]
Returns void

removeAll

removeAll(): void

Inherited from Collection.removeAll
Remove all items from the collection. Note that removing items from collection does not necessarily imply deleting the target entity, it means we are disconnecting the relation - removing items from collection, not removing entities from database - Collection.remove() is not the same as em.remove(). If we want to delete the entity by removing it from collection, we need to enable orphanRemoval: true, which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
Returns void

set

set(items: Iterable<T | Reference<T>>): void

Inherited from Collection.set
Parameters
- items: Iterable<T | Reference<T>>
Returns void

setDirty

setDirty(dirty?: boolean): void

Inherited from Collection.setDirty
Parameters
- dirty: boolean = true
Returns void

shouldPopulate

shouldPopulate(populated?: boolean): boolean

Inherited from Collection.shouldPopulate
Parameters
- optionalpopulated: boolean
Returns boolean

slice

slice(start?: number, end?: number): T[]

Inherited from Collection.slice
Extracts a slice of the collection items starting at position start to end (exclusive) of the collection. If end is null it returns all elements from start to the end of the collection.
Parameters
- optionalstart: number
- optionalend: number
Returns T[]

toArray

toArray<TT>(): EntityDTO<TT>[]

Inherited from Collection.toArray
Type parameters
- TT: object
Returns EntityDTO<TT>[]

toJSON

toJSON<TT>(): EntityDTO<TT>[]

Inherited from Collection.toJSON
Type parameters
- TT: object
Returns EntityDTO<TT>[]