Options
All
  • Public
  • Public/Protected
  • All
Menu

Class EmbeddedCollection

An extension of the Collection. Used for the specific task of containing embedded Document instances within a parent Document.

Hierarchy

Index

Constructors

Properties

Methods

Accessors

Constructors

constructor

  • new EmbeddedCollection(name: string, parent: DataModel, sourceArray: any[]): EmbeddedCollection

  • Parameters

    • name: string

      The name of this collection in the parent Document.

    • parent: DataModel

      The parent DataModel instance to which this collection belongs.

    • sourceArray: any[]

      The source data array for the collection in the parent Document data.

    Returns EmbeddedCollection

Properties

documentClass

documentClass: typeof Document

The Document implementation used to construct instances within this collection.

name

name: string

The name of this collection in the parent Document.

model

model: DataModel

The parent DataModel to which this EmbeddedCollection instance belongs.

invalidDocumentIds

invalidDocumentIds: Set<string> = ...

Record the set of document ids where the Document was not initialized because of invalid source data

Protected _initialized

_initialized: boolean = false

Has this embedded collection been initialized as a one-time workflow?

Private _source

_source: any[]

The source data array from which the embedded collection is created

Methods

createDocument

  • createDocument(data: any, context?: any): Document

  • Instantiate a Document for inclusion in the Collection.

    Parameters

    • data: any

      The Document data.

    • context: any = {}

    Returns Document

initialize

  • initialize([options]?: { strict: boolean }): void

  • Initialize the EmbeddedCollection object by constructing its contained Document instances

    Parameters

    • [options]: { strict: boolean } = {}

      Initialization options.

      • strict: boolean

    Returns void

get

  • get(id: string, [options]?: { strict: boolean; invalid: boolean }): Document

  • Get an element from the EmbeddedCollection by its ID.

    throws

    If strict is true and the Embedded Document cannot be found.

    Parameters

    • id: string

      The ID of the Embedded Document to retrieve.

    • [options]: { strict: boolean; invalid: boolean } = {}

      Additional options to configure retrieval.

      • strict: boolean
      • invalid: boolean

    Returns Document

set

  • set(key: string, value: Document, [options]?: { modifySource: boolean }): EmbeddedCollection

  • Add an item to the collection.

    Parameters

    • key: string

      The embedded Document ID.

    • value: Document

      The embedded Document instance.

    • [options]: { modifySource: boolean } = {}

      Additional options to the set operation.

      • modifySource: boolean

    Returns EmbeddedCollection

delete

  • delete(key: string, [options]?: { modifySource: boolean }): boolean

  • Parameters

    • key: string

      The embedded Document ID.

    • [options]: { modifySource: boolean } = {}

      Additional options to the delete operation.

      • modifySource: boolean

    Returns boolean

update

  • update(changes: DataModel[], options?: any): void

  • Update an EmbeddedCollection using an array of provided document data.

    Parameters

    • changes: DataModel[]

      An array of provided Document data

    • options: any = {}

    Returns void

getInvalid

  • getInvalid(id: string, [options]?: { strict: boolean }): Document

  • Obtain a temporary Document instance for a document id which currently has invalid source data.

    throws

    If strict is true and the requested ID is not in the set of invalid IDs for this collection.

    Parameters

    • id: string

      A document ID with invalid source data.

    • [options]: { strict: boolean } = {}

      Additional options to configure retrieval.

      • strict: boolean

    Returns Document

    An in-memory instance for the invalid Document

toObject

  • toObject(source?: boolean): any[]

  • Convert the EmbeddedCollection to an array of simple objects.

    Parameters

    • source: boolean = true

    Returns any[]

    The extracted array of primitive objects

find

  • find(condition: ((arg0: any, arg1: number, arg2: Collection) => boolean)): any

  • Find an entry in the Map using a functional condition.

    see

    {Array#find}

    example

    Create a new Collection and reference its contents

    let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
    c.get("a") === c.find(entry => entry === "A"); // true

    Parameters

    • condition: ((arg0: any, arg1: number, arg2: Collection) => boolean)

      The functional condition to test. Positional arguments are the value, the index of iteration, and the collection being searched.

        • (arg0: any, arg1: number, arg2: Collection): boolean

        • Parameters

          Returns boolean

    Returns any

    The value, if found, otherwise undefined

filter

  • filter(condition: ((arg0: any, arg1: number, arg2: Collection) => boolean)): any[]

  • Filter the Collection, returning an Array of entries which match a functional condition.

    see

    {Array#filter}

    example

    Filter the Collection for specific entries

    let c = new Collection([["a", "AA"], ["b", "AB"], ["c", "CC"]]);
    let hasA = c.filters(entry => entry.slice(0) === "A");

    Parameters

    • condition: ((arg0: any, arg1: number, arg2: Collection) => boolean)

      The functional condition to test. Positional arguments are the value, the index of iteration, and the collection being filtered.

        • (arg0: any, arg1: number, arg2: Collection): boolean

        • Parameters

          Returns boolean

    Returns any[]

    An Array of matched values

forEach

  • forEach(fn: ((arg0: any) => void)): void

  • Apply a function to each element of the collection

    see

    Array#forEach

    example

    Apply a function to each value in the collection

    let c = new Collection([["a", {active: false}], ["b", {active: false}], ["c", {active: false}]]);
    c.forEach(e => e.active = true);

    Parameters

    • fn: ((arg0: any) => void)

      A function to apply to each element

        • (arg0: any): void

        • Parameters

          • arg0: any

          Returns void

    Returns void

getName

  • getName(name: string, [options]?: { strict: boolean }): any

  • Get an entry from the Collection by name. Use of this method assumes that the objects stored in the collection have a "name" attribute.

    example

    Get an element from the Collection by name (if applicable)

    let c = new Collection([["a", "Alfred"], ["b", "Bob"], ["c", "Cynthia"]]);
    c.getName("Alfred"); // "Alfred"
    c.getName("D"); // undefined
    c.getName("D", {strict: true}); // throws Error

    Parameters

    • name: string

      The name of the entry to retrieve

    • [options]: { strict: boolean } = {}

      Additional options that affect how entries are retrieved

      • strict: boolean

    Returns any

    The retrieved entry value, if one was found, otherwise undefined

map

  • map(transformer: ((arg0: any, arg1: number, arg2: Collection) => any)): any[]

  • Transform each element of the Collection into a new form, returning an Array of transformed values

    Parameters

    • transformer: ((arg0: any, arg1: number, arg2: Collection) => any)

      A transformation function applied to each entry value. Positional arguments are the value, the index of iteration, and the collection being mapped.

        • Parameters

          Returns any

    Returns any[]

    An Array of transformed values

reduce

  • reduce(reducer: ((arg0: any, arg1: any, arg2: number, arg3: Collection) => any), initial: any): any

  • Reduce the Collection by applying an evaluator function and accumulating entries

    see

    {Array#reduce}

    example

    Reduce a collection to an array of transformed values

    let c = new Collection([["a", "A"], ["b", "B"], ["c", "C"]]);
    let letters = c.reduce((s, l) => {
      return s + l;
    }, ""); // "ABC"

    Parameters

    • reducer: ((arg0: any, arg1: any, arg2: number, arg3: Collection) => any)

      A reducer function applied to each entry value. Positional arguments are the accumulator, the value, the index of iteration, and the collection being reduced.

        • (arg0: any, arg1: any, arg2: number, arg3: Collection): any

        • Parameters

          Returns any

    • initial: any

      An initial value which accumulates with each iteration

    Returns any

    The accumulated result

some

  • some(condition: ((arg0: any, arg1: number, arg2: Collection) => boolean)): boolean

  • Test whether a condition is met by some entry in the Collection.

    see

    {Array#some}

    Parameters

    • condition: ((arg0: any, arg1: number, arg2: Collection) => boolean)

      The functional condition to test. Positional arguments are the value, the index of iteration, and the collection being tested.

        • (arg0: any, arg1: number, arg2: Collection): boolean

        • Parameters

          Returns boolean

    Returns boolean

    Was the test condition passed by at least one entry?

toJSON

  • toJSON(): any[]

  • Convert the Collection to a primitive array of its contents.

    Returns any[]

    An array of contained values

[iterator]

  • [iterator](): IterableIterator<any>

  • When iterating over a Collection, we should iterate over its values instead of over its entries

    Returns IterableIterator<any>

Protected _initializeDocument

  • _initializeDocument(data: any, [options]: { strict: boolean }): void

  • Initialize an embedded document and store it in the collection.

    Parameters

    • data: any

      The Document data.

    • [options]: { strict: boolean }

      Options to configure Document initialization.

      • strict: boolean

    Returns void

Protected _handleInvalidDocument

  • _handleInvalidDocument(id: string, err: Error, [options]?: { strict: boolean }): void

  • Log warnings or errors when a Document is found to be invalid.

    Parameters

    • id: string

      The invalid Document's ID.

    • err: Error

      The validation error.

    • [options]: { strict: boolean } = {}

      Options to configure invalid Document handling.

      • strict: boolean

    Returns void

Protected _set

  • _set(key: string, value: Document): void

  • Modify the underlying source array to include the Document.

    Parameters

    • key: string

      The Document ID key.

    • value: Document

      The Document.

    Returns void

Protected _delete

  • _delete(key: string, options?: any): void

  • Remove the value from the underlying source array.

    Parameters

    • key: string

      The Document ID key.

    • options: any = {}

    Returns void

Protected _createOrUpdate

  • _createOrUpdate(data: DataModel, options: any): void

  • Create or update an embedded Document in this collection.

    Parameters

    • data: DataModel

      The update delta.

    • options: any

    Returns void

Accessors

contents

  • get contents(): any[]

  • Return an Array of all the entry values in the Collection

    Returns any[]