An embedded collection delta contains delta source objects that can be compared against other objects inside a base embedded collection, and generate new embedded Documents by combining them.

Hierarchy (view full)

Constructors

  • Parameters

    • name: string

      The name of this collection in the parent Document.

    • parent: DataModel

      The parent DataModel instance to which this collection belongs.

    • sourceArray: object[]

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

    Returns EmbeddedCollectionDelta

Properties

documentClass: typeof Document

The Document implementation used to construct instances within this collection.

name: string

The name of this collection in the parent Document.

model: DataModel

The parent DataModel to which this EmbeddedCollection instance belongs.

invalidDocumentIds: Set<string> = ...

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

_initialized: boolean = false

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

#managedIds: Set<string> = ...

Maintain a list of IDs that are managed by this collection delta to distinguish from those IDs that are inherited from the base collection.

#tombstones: Set<string> = ...

Maintain a list of IDs that are tombstone Documents.

Accessors

  • get contents(): V[]
  • Return an Array of all the entry values in the Collection

    Returns V[]

Methods

  • Parameters

    • __namedParameters: {
          full: boolean;
      } = {}
      • full: boolean

    Returns void

  • Determine whether a given ID is managed directly by this collection delta or inherited from the base collection.

    Parameters

    • key: string

      The Document ID.

    Returns boolean

  • Determine whether a given ID exists as a tombstone Document in the collection delta.

    Parameters

    • key: string

      The Document ID.

    Returns boolean

  • Restore a Document so that it is no longer managed by the collection delta and instead inherits from the base Document.

    Parameters

    • id: string

      The Document ID.

    Returns Promise<Document>

    The restored Document.

  • Restore the given Documents so that they are no longer managed by the collection delta and instead inherit directly from their counterparts in the base Actor.

    Parameters

    • ids: string[]

      The IDs of the Documents to restore.

    Returns Promise<Document[]>

    An array of updated Document instances.

  • Add an item to the collection.

    Parameters

    • key: any

      The embedded Document ID.

    • value: any

      The embedded Document instance.

    • options: {} = {}

      Additional options to the set operation.

      Returns void

    • Parameters

      • key: any
      • value: any
      • __namedParameters: {
            restoreDelta: boolean;
        } = {}
        • restoreDelta: boolean

      Returns void

    • Parameters

      • key: any

        The embedded Document ID.

      • options: {} = {}

        Additional options to the delete operation.

        Returns void

      • Parameters

        • key: any
        • __namedParameters: {
              restoreDelta: boolean;
          } = {}
          • restoreDelta: boolean

        Returns void

      • Get an element from the EmbeddedCollection by its ID.

        Parameters

        • id: string

          The ID of the Embedded Document to retrieve.

        • Optional options: {
              strict: boolean;
              invalid: boolean;
          } = {}

          Additional options to configure retrieval.

          • strict: boolean

            Throw an Error if the requested Embedded Document does not exist.

          • invalid: boolean

            Allow retrieving an invalid Embedded Document.

        Returns Document

        Throws

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

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

        Parameters

        • changes: DataModel[]

          An array of provided Document data

        • Optional options: object = {}

          Additional options which modify how the collection is updated

        Returns void

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

        Parameters

        • id: string

          A document ID with invalid source data.

        • Optional options: {
              strict: boolean;
          } = {}

          Additional options to configure retrieval.

          • strict: boolean

            Throw an Error if the requested ID is not in the set of invalid IDs for this collection.

        Returns Document

        An in-memory instance for the invalid Document

        Throws

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

      • Convert the EmbeddedCollection to an array of simple objects.

        Parameters

        • Optional source: boolean = true

          Draw data for contained Documents from the underlying data source?

        Returns object[]

        The extracted array of primitive objects

      • Internal

        Follow-up actions to take when a database operation modifies Documents in this EmbeddedCollection.

        Parameters

        • action: DatabaseAction

          The database action performed

        • documents: Document[]

          The array of modified Documents

        • result: any[]

          The result of the database operation

        • operation: DatabaseOperation

          Database operation details

        • user: BaseUser

          The User who performed the operation

        Returns void

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

        Parameters

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

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

            • (arg0, arg1, arg2): boolean
            • Parameters

              Returns boolean

        Returns any

        The value, if found, otherwise undefined

        See

        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
      • Filter the Collection, returning an Array of entries which match a functional condition.

        Parameters

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

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

            • (arg0, arg1, arg2): boolean
            • Parameters

              Returns boolean

        Returns any[]

        An Array of matched values

        See

        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");
      • Apply a function to each element of the collection

        Parameters

        • fn: ((arg0) => void)

          A function to apply to each element

            • (arg0): void
            • Parameters

              • arg0: any

              Returns void

        Returns void

        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);
      • Get an entry from the Collection by name. Use of this method assumes that the objects stored in the collection have a "name" attribute.

        Parameters

        • name: string

          The name of the entry to retrieve

        • Optional options: {
              strict: boolean;
          } = {}

          Additional options that affect how entries are retrieved

          • strict: boolean

            Throw an Error if the requested name does not exist. Default false.

        Returns any

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

        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
      • Transform each element of the Collection into a new form, returning an Array of transformed values

        Parameters

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

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

            • (arg0, arg1, arg2): any
            • Parameters

              Returns any

        Returns any[]

        An Array of transformed values

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

        Parameters

        • reducer: ((arg0, arg1, arg2, arg3) => 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, arg1, arg2, arg3): any
            • Parameters

              • arg0: any
              • arg1: any
              • arg2: number
              • arg3: Collection<any, any>

              Returns any

        • initial: any

          An initial value which accumulates with each iteration

        Returns any

        The accumulated result

        See

        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"
      • Test whether a condition is met by some entry in the Collection.

        Parameters

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

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

            • (arg0, arg1, arg2): boolean
            • Parameters

              Returns boolean

        Returns boolean

        Was the test condition passed by at least one entry?

        See

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

        Returns object[]

        An array of contained values

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

        Returns IterableIterator<any>

      • Protected

        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.

        • Optional options: {
              strict: boolean;
          } = {}

          Options to configure invalid Document handling.

          • strict: boolean

            Whether to throw an error or only log a warning.

        Returns void