Class DocumentCollectionAbstract

An abstract subclass of the Collection container which defines a collection of Document instances.

Hierarchy (View Summary)

Constructors

constructor

Properties

apps invalidDocumentIds documentName

Accessors

contents documentClass documentName name

Methods

_onModifyContents [iterator] createDocument delete filter find forEach get getInvalid getName map reduce render search set some toJSON updateAll _initialize getSearchableFields

Constructors

constructor

  • new DocumentCollection(data?: object[]): DocumentCollection

    Parameters

    • data: object[] = []

      An array of data objects from which to create document instances

    Returns DocumentCollection

Properties

apps

apps: ApplicationV2<ApplicationConfiguration, ApplicationRenderOptions>[]

An Array of application references which will be automatically updated when the collection content changes

invalidDocumentIds

invalidDocumentIds: Set<string> = ...

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

StaticdocumentName

documentName: string

The base Document type which is contained within this DocumentCollection

Accessors

contents

  • get contents(): V[]

    Return an Array of all the entry values in the Collection

    Returns V[]

documentClass

  • get documentClass(): typeof Document

    A reference to the Document class definition which is contained within this DocumentCollection.

    Returns typeof Document

documentName

  • get documentName(): any

    Returns any

    Inherit Doc

name

  • get name(): string

    The Collection class name

    Returns string

Methods

_onModifyContents

  • _onModifyContents(
        action: DatabaseAction,
        documents: ClientDocument[],
        result: any[],
        operation: DatabaseOperation,
        user: documents.User,
    ): void
    Internal

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

    Parameters

    • action: DatabaseAction

      The database action performed

    • documents: ClientDocument[]

      The array of modified Documents

    • result: any[]

      The result of the database operation

    • operation: DatabaseOperation

      Database operation details

    • user: documents.User

      The User who performed the operation

    Returns void

[iterator]

  • "[iterator]"(): MapIterator<any>

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

    Returns MapIterator<any>

createDocument

delete

  • delete(id: any): boolean

    Parameters

    • id: any

    Returns boolean

    Inherit Doc

filter

  • filter(
        condition: (
            value: any,
            index: number,
            collection: Collection<any, any>,
        ) => unknown,
    ): any[]

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

    Parameters

    • condition: (value: any, index: number, collection: Collection<any, any>) => unknown

      The functional condition to test.

    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");

find

  • find(
        condition: (
            value: any,
            index: number,
            collection: Collection<any, any>,
        ) => unknown,
    ): any

    Find an entry in the Map using a functional condition.

    Parameters

    • condition: (value: any, index: number, collection: Collection<any, any>) => unknown

      The functional condition to test.

    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

forEach

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

    Apply a function to each element of the collection

    Parameters

    • fn: (value: any) => void

      A function to apply to each element

    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

  • get(
        id: string,
        options?: { invalid?: boolean; strict?: boolean },
    ): Document<object, DocumentConstructionContext>

    Get an element from the DocumentCollection by its ID.

    Parameters

    • id: string

      The ID of the Document to retrieve.

    • Optionaloptions: { invalid?: boolean; strict?: boolean } = {}

      Additional options to configure retrieval.

      • Optionalinvalid?: boolean

        Allow retrieving an invalid Document.

      • Optionalstrict?: boolean

        Throw an Error if the requested Document does not exist.

    Returns Document<object, DocumentConstructionContext>

    Throws

    If strict is true and the Document cannot be found.

getInvalid

  • getInvalid(
        id: string,
        options?: { strict?: boolean },
    ): void | Document<object, DocumentConstructionContext>

    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.

    • Optionaloptions: { strict?: boolean } = {}

      Additional options to configure retrieval.

      • Optionalstrict?: boolean

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

    Returns void | Document<object, DocumentConstructionContext>

    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.

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.

    Parameters

    • name: string

      The name of the entry to retrieve

    • Optionaloptions: { strict?: boolean } = {}

      Additional options that affect how entries are retrieved

      • Optionalstrict?: 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

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.

    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

    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.

    • 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"

render

  • render(force?: boolean, options?: object): void

    Render any Applications associated with this DocumentCollection.

    Parameters

    • Optionalforce: boolean = false

      Force rendering

    • Optionaloptions: object = {}

      Optional options

    Returns void

search

  • search(
        search: { exclude?: string[]; filters?: FieldFilter[]; query?: string },
    ): object[] | Document<object, DocumentConstructionContext>[]

    Find all Documents which match a given search term using a full-text search against their indexed HTML fields and their name. If filters are provided, results are filtered to only those that match the provided values.

    Parameters

    • search: { exclude?: string[]; filters?: FieldFilter[]; query?: string }

      An object configuring the search

      • Optionalexclude?: string[]

        An array of document IDs to exclude from search results

      • Optionalfilters?: FieldFilter[]

        An array of filters to apply

      • Optionalquery?: string

        A case-insensitive search string

    Returns object[] | Document<object, DocumentConstructionContext>[]

set

  • set(id: any, document: any): void

    Parameters

    • id: any
    • document: any

    Returns void

    Inherit Doc

some

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

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

    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.

    Returns boolean

    Was the test condition passed by at least one entry?

    See

toJSON

  • toJSON(): object[]

    Convert the Collection to a primitive array of its contents.

    Returns object[]

    An array of contained values

updateAll

  • updateAll(
        transformation: object | Function,
        condition?: null | Function,
        options?: object,
    ): Promise<Document<object, DocumentConstructionContext>[]>

    Update all objects in this DocumentCollection with a provided transformation. Conditionally filter to only apply to Entities which match a certain condition.

    Parameters

    • transformation: object | Function

      An object of data or function to apply to all matched objects

    • condition: null | Function = null

      A function which tests whether to target each object

    • Optionaloptions: object = {}

      Additional options passed to Document.updateDocuments

    Returns Promise<Document<object, DocumentConstructionContext>[]>

    An array of updated data once the operation is complete

Protected_initialize

  • _initialize(): void
    Protected

    Initialize the DocumentCollection by constructing any initially provided Document instances

    Returns void

StaticgetSearchableFields

  • getSearchableFields(
        documentName: string,
        type?: string,
    ): Record<string, SearchableField>

    Get the searchable fields for a given document or index, based on its data model

    Parameters

    • documentName: string

      The document name

    • Optionaltype: string

      A document subtype

    Returns Record<string, SearchableField>

    A record of searchable DataField definitions

Settings

Member Visibility

On This Page

Constructors
Properties
Accessors
Methods