Skip to main content

Version: 6.2

Collection <T, O>

Hierarchy

ArrayCollection<T, O>
- Collection
  - LoadedCollection

Index

Constructors

constructor

Properties

owner

Accessors

length

Constructors

constructor

new Collection<T, O>(owner, items, initialized): Collection<T, O>

Overrides ArrayCollection.constructor
Type parameters
- T: object
- O: object = object
Parameters
- owner: O
- optionalitems: T[]
- initialized: boolean = true
Returns Collection<T, O>

Properties

readonlyowner

owner: O

Accessors

length

get length(): number

Inherited from ArrayCollection.length
Returns number

Methods

[iterator]

[iterator](): IterableIterator<T>

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

add

add<TT>(entity, ...entities): void

Overrides ArrayCollection.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, check): boolean

Overrides ArrayCollection.contains
Type parameters
- TT: object
Parameters
- item: TT | Reference<TT>
- check: boolean = true
Returns boolean

count

count(): number

Overrides ArrayCollection.count
Returns number

exists

exists(cb): boolean

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

filter

filter(cb): T[]

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

find

find(cb): undefined | T

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

getIdentifiers

getIdentifiers<U>(field): U[]

Inherited from ArrayCollection.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): T[]

Overrides ArrayCollection.getItems
Returns the items (the collection must be initialized)
Parameters
- check: boolean = true
Returns T[]

indexBy

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

Overrides ArrayCollection.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): Promise<LoadedCollection<Loaded<TT, P>>>

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

isDirty

isDirty(): boolean

Inherited from ArrayCollection.isDirty
Returns boolean

isEmpty

isEmpty(): boolean

Overrides ArrayCollection.isEmpty
Returns boolean

isInitialized

isInitialized(fully): boolean

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

load

load<TT, P>(options): Promise<LoadedCollection<Loaded<TT, P>>>

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): Promise<number>

Overrides ArrayCollection.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): Promise<Loaded<TT, P>[]>

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): R[]

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

matching

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

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

populated

populated(populated): void

Parameters
- populated: undefined | boolean = true
Returns void

reduce

reduce<R>(cb, initial): R

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

remove

remove<TT>(entity, ...entities): void

Overrides ArrayCollection.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) => boolean
- rest...entities: (TT | Reference<TT>)[]
Returns void

removeAll

removeAll(): void

Inherited from ArrayCollection.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): void

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

setDirty

setDirty(dirty): void

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

shouldPopulate

shouldPopulate(populated): boolean

Parameters
- optionalpopulated: boolean
Returns boolean

slice

slice(start, end): T[]

Overrides ArrayCollection.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 ArrayCollection.toArray
Type parameters
- TT: object
Returns EntityDTO<TT>[]

toJSON

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

Overrides ArrayCollection.toJSON
Type parameters
- TT: object
Returns EntityDTO<TT>[]

staticcreate

create<T, O>(owner, prop, items, initialized): Collection<T, O>

Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)
Type parameters
- T: object
- O: object = object
Parameters
- owner: O
- prop: EntityKey<O>
- items: undefined | T[]
- initialized: boolean
Returns Collection<T, O>

Page Options

Hide Inherited