Class DocumentCollection<TDocument>`Abstract`

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

Template: TDocument

Type Parameters

TDocument extends Document

Hierarchy (View Summary)

Collection
- DocumentCollection

Index

Constructors

constructor

new DocumentCollection<
TDocument extends Document<object, DocumentConstructionContext>,
>(
data?: object[],
): DocumentCollection<TDocument>
Type Parameters
- TDocument extends Document<object, DocumentConstructionContext>
Parameters
- data: object[] = []
  An array of data objects from which to create document instances
Returns DocumentCollection<TDocument>
Overrides Collection.constructor

Properties

`Internal`_source

_source: object[]

The source data array from which the Documents in the WorldCollection are created

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

`Static`documentName

documentName: string

The base Document type which is contained within this DocumentCollection

Accessors

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

Returns V[]
Inherited from Collection.contents

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: TDocument[],
    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: TDocument[]
  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<TDocument>
Then iterating over a Collection, we should iterate over its values instead of over its entries

Returns MapIterator<TDocument>
Inherited from Collection.[iterator]

createDocument

createDocument(data: object, context?: object): TDocument
Instantiate a Document for inclusion in the Collection.
Parameters
- data: object
  The Document data.
- Optionalcontext: object = {}
  Document creation context.
Returns TDocument

delete

delete(id: any): boolean
Parameters
- id: any
Returns boolean
Inherit Doc
Overrides Collection.delete

every

every(
    condition: (
        element: TDocument,
        index: number,
        set: Collection<string, TDocument>,
    ) => boolean,
): boolean
Test whether a condition is met by every entry in the Collection.
Parameters
- condition: (
      element: TDocument,
      index: number,
      set: Collection<string, TDocument>,
  ) => boolean
  The functional condition to test.
Returns boolean
True if the test condition was truthy for every entry.

See
Inherited from Collection.every

filter

filter(
    condition: (
        value: TDocument,
        index: number,
        collection: Collection<string, TDocument>,
    ) => unknown,
): TDocument[]
Filter the Collection, returning an Array of entries which match a functional condition.
Parameters
- condition: (
      value: TDocument,
      index: number,
      collection: Collection<string, TDocument>,
  ) => unknown
  The functional condition to test.
Returns TDocument[]
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");
```
Inherited from Collection.filter

find

find(
    condition: (
        value: TDocument,
        index: number,
        collection: Collection<string, TDocument>,
    ) => unknown,
): TDocument | undefined
Find an entry in the Map using a functional condition.
Parameters
- condition: (
      value: TDocument,
      index: number,
      collection: Collection<string, TDocument>,
  ) => unknown
  The functional condition to test.
Returns TDocument | undefined
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
```
Inherited from Collection.find

forEach

forEach(fn: (value: TDocument, index: number) => void): void
Apply a function to each element of the collection
Parameters
- fn: (value: TDocument, index: number) => 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);
```
Inherited from Collection.forEach

get

get(id: string, options?: { invalid?: boolean; strict?: boolean }): TDocument
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 TDocument
Throws
If strict is true and the Document cannot be found.

Overrides Collection.get

getInvalid

getInvalid(id: string, options?: { strict?: boolean }): void | TDocument
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 | TDocument
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 }): TDocument | undefined
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 TDocument | undefined
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
```
Inherited from Collection.getName

importDocument

importDocument(
document: Document<object, DocumentConstructionContext>,
options: FromCompendiumOptions | ToCompendiumOptions,
): Promise<Document<object, DocumentConstructionContext> | undefined>
Import a Document into this collection, persisting the result. If the document ID already exists in the collection, it should be replaced with an optional confirmation dialog. If the document ID is undefined or does not already exist, a new Document will be created in the collection.
Parameters
- document: Document<object, DocumentConstructionContext>
  A source Document to be imported. The document will be safely copied.
- options: FromCompendiumOptions | ToCompendiumOptions
  Options which modify import behavior
Returns Promise<Document<object, DocumentConstructionContext> | undefined>
The imported Document instance

map

map<U>(
    transformer: (
        element: TDocument,
        index: number,
        collection: Collection<string, TDocument>,
    ) => U,
): U[]
Transform each element of the Collection into a new form, returning an Array of transformed values
Type Parameters
- U
Parameters
- transformer: (
      element: TDocument,
      index: number,
      collection: Collection<string, TDocument>,
  ) => U
  A transformation function applied to each entry value.
Returns U[]
An Array of transformed values

See
Inherited from Collection.map

reduce

reduce<U>(
    reducer: (
        accum: U,
        element: T,
        index: number,
        collection: Collection<string, TDocument>,
    ) => U,
    initial: U,
): U
Reduce the Collection by applying an evaluator function and accumulating entries
Type Parameters
- U
Parameters
- reducer: (
      accum: U,
      element: T,
      index: number,
      collection: Collection<string, TDocument>,
  ) => U
  A reducer function applied to each entry value.
- initial: U
  An initial value which accumulates with each iteration
Returns U
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"
```
Inherited from Collection.reduce

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

set

set(id: string, document: TDocument): DocumentCollection<TDocument>
Parameters
- id: string
- document: TDocument
Returns DocumentCollection<TDocument>
Overrides Collection.set

some

some(
    condition: (
        element: TDocument,
        index: number,
        set: Collection<string, TDocument>,
    ) => boolean,
): boolean
Test whether a condition is met by some entry in the Collection.
Parameters
- condition: (
      element: TDocument,
      index: number,
      set: Collection<string, TDocument>,
  ) => boolean
  The functional condition to test.
Returns boolean
Was the test condition passed by at least one entry?

See
Inherited from Collection.some

toJSON

toJSON(): object[]
Convert the Collection to a primitive array of its contents.

Returns object[]
An array of contained values

Inherited from Collection.toJSON

updateAll

updateAll(
    transformation: object | Function,
    condition?: Function | null,
    options?: object,
): Promise<TDocument[]>
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: Function | null = null
  A function which tests whether to target each object
- Optionaloptions: object = {}
  Additional options passed to Document.updateDocuments
Returns Promise<TDocument[]>
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

`Protected`_prepareImportDocument

_prepareImportDocument(
document: Document<object, DocumentConstructionContext>,
options: object,
): object
Protected
Translate a provided Document into data ready for import into this collection.
Parameters
- document: Document<object, DocumentConstructionContext>
  A source Document to be imported. The document should be safely copied.
- options: object
  Options which modify import behavior
Returns object
Data ready for import

Throws
An error if the import should be disallowed

`Static`getSearchableFields

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

Class DocumentCollection<TDocument>Abstract

Template: TDocument

Type Parameters

Hierarchy (View Summary)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns DocumentCollection<TDocument>

Properties

Internal_source

apps

invalidDocumentIds

StaticdocumentName

Accessors

contents

Returns V[]

documentClass

Returns typeof Document

documentName

Returns any

Inherit Doc

name

Returns string

Methods

_onModifyContents

Parameters

Returns void

[iterator]

Returns MapIterator<TDocument>

createDocument

Parameters

Returns TDocument

delete

Parameters

Returns boolean

Inherit Doc

every

Parameters

Returns boolean

See

filter

Parameters

Returns TDocument[]

See

Example: Filter the Collection for specific entries

find

Parameters

Returns TDocument | undefined

See

Example: Create a new Collection and reference its contents

forEach

Parameters

Returns void

See

Example: Apply a function to each value in the collection

get

Parameters

Optionalinvalid?: boolean

Optionalstrict?: boolean

Returns TDocument

Throws

getInvalid

Parameters

Optionalstrict?: boolean

Returns void | TDocument

Throws

getName

Parameters

Optionalstrict?: boolean

Returns TDocument | undefined

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

importDocument

Parameters

Returns Promise<Document<object, DocumentConstructionContext> | undefined>

Class DocumentCollection<TDocument>`Abstract`

`Internal`_source

`Static`documentName

`Optional`invalid?: boolean

`Optional`strict?: boolean

`Optional`strict?: boolean

`Optional`strict?: boolean

`Optional`exclude?: string[]

`Optional`filters?: FieldFilter[]

`Optional`query?: string

`Protected`_initialize

`Protected`_prepareImportDocument

`Static`getSearchableFields