Collection <T, O>

Hierarchy

• ArrayCollection<T, O>
  • Collection
    • LoadedCollection

Index

Constructors

• constructor

Properties

• owner

Accessors

• length

Methods

• [iterator]
• add
• contains
• count
• exists
• filter
• find
• getIdentifiers
• getItems
• indexBy
• init
• isDirty
• isEmpty
• isInitialized
• load
• loadCount
• loadItems
• map
• matching
• populated
• reduce
• remove
• removeAll
• set
• setDirty
• shouldPopulate
• slice
• toArray
• toJSON
• create

Constructors

constructor

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

• Overrides ArrayCollection.constructor

  Parameters

  • owner: O

  • optionalitems: T[]

  • initialized: boolean = true

  Returns Collection<T, O>

Properties

readonlyinheritedowner

owner: O

Inherited from ArrayCollection.owner

Accessors

inheritedlength

• get length(): number

• Inherited from ArrayCollection.length

  Returns number

Methods

inherited[iterator]

• [iterator](): IterableIterator<T, any, any>

• Inherited from ArrayCollection.[iterator]

  Returns IterableIterator<T, any, any>

add

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

• Overrides ArrayCollection.add

  Parameters

  • entity: TT | Reference<TT> | Iterable<TT | Reference<TT>, any, any>

  • rest...entities: (TT | Reference<TT>)[]

  Returns void

contains

• contains<TT>(item, check): boolean

• Overrides ArrayCollection.contains

  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

inheritedgetIdentifiers

• getIdentifiers<U>(field): U[]

• Inherited from ArrayCollection.getIdentifiers

  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.

  ---

  Parameters

  • key: K1

  Returns Record<T[K1] & PropertyKey, T>

init

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

• Parameters

  • options: InitCollectionOptions<TT, P, *, never> = {}

  Returns Promise<LoadedCollection<Loaded<TT, P>>>

inheritedisDirty

• isDirty(): boolean

• Inherited from ArrayCollection.isDirty

  Returns boolean

isEmpty

• isEmpty(): boolean

• Overrides ArrayCollection.isEmpty

  Returns boolean

inheritedisInitialized

• 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().

  ---

  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

  ---

  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.

  ---

  Parameters

  • mapper: (item, index) => R

  Returns R[]

matching

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

• Parameters

  • options: MatchingOptions<T, P>

  Returns Promise<Loaded<TT, P>[]>

populated

• populated(populated): void

• Parameters

  • populated: undefined | boolean = true

  Returns void

inheritedreduce

• reduce<R>(cb, initial): R

• Inherited from ArrayCollection.reduce

  Maps the collection items based on your provided mapper function to a single object.

  ---

  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.

  ---

  Parameters

  • entity: TT | Reference<TT> | Iterable<TT | Reference<TT>, any, any> | (item) => boolean

  • rest...entities: (TT | Reference<TT>)[]

  Returns void

inheritedremoveAll

• 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

inheritedset

• set(items): void

• Inherited from ArrayCollection.set

  Parameters

  • items: Iterable<T | Reference<T>, any, any>

  Returns void

inheritedsetDirty

• 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[]

inheritedtoArray

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

• Inherited from ArrayCollection.toArray

  Returns EntityDTO<TT>[]

toJSON

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

• Overrides ArrayCollection.toJSON

  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)

  ---

  Parameters

  • owner: O

  • prop: EntityKey<O>

  • items: undefined | T[]

  • initialized: boolean

  Returns Collection<T, O>