Interface Collection<T>

A collection supplied by the compatible Kubator host. The open surface retains its generic item type so Kubator can recover model schemas.

interface Collection<T extends object> {
    autoPermissions?: Record<string, string>;
    excludeFromAutoMenu?: boolean;
    excludeFromGlobalSearch?: boolean;
    menuIndex?: number;
    menuParent?: Collection<object>;
    addIndex(
        name: string,
        expression: (item: T) => unknown,
        options?: IndexOptions<T>,
    ): void;
    addUniqueConstraint(
        name: string,
        expression: (item: T) => unknown,
        options?: UniqueConstraintOptions<T>,
    ): void;
    canUpdate(oldDocument?: T, newDocument?: T): boolean;
    count(predicate?: FilterPredicate<T>): number;
    countAsync(): Promise<number>;
    filter(predicate?: FilterPredicate<T>): Query<T>;
    filterAsync(predicate?: FilterPredicate<T>): Promise<T[]>;
    findAsync(predicate: FilterPredicate<T>): Promise<T>;
    findAsync<TResult>(
        predicate: FilterPredicate<T>,
        mapper: (item: T) => TResult,
    ): Promise<TResult>;
    flatMap<TOut extends object>(
        mapper: (item: T) => Iterable<TOut>,
    ): Query<TOut>;
    insertAsync(doc: T): Promise<T>;
    insertManyAsync(docs: T[], options?: InsertManyOptions): Promise<T[]>;
    join<TJoin extends object, TResult extends object>(
        other: Query<TJoin>,
        predicate: (left: T, right: TJoin) => boolean,
        selector: (left: T, right: TJoin) => TResult,
    ): Query<TResult>;
    join<TJoin extends object, TResult extends object>(
        other: Query<TJoin>,
        predicate: (left: T, right: TJoin) => boolean,
        selector: (left: T, right: TJoin) => TResult,
        joinType: "INNER",
    ): Query<TResult>;
    join<TJoin extends object, TResult extends object>(
        other: Query<TJoin>,
        predicate: (left: T, right: TJoin) => boolean,
        selector: (left: T, right: TJoin) => TResult,
        joinType: "LEFT",
    ): Query<TResult>;
    join<TJoin extends object, TResult extends object>(
        other: Query<TJoin>,
        predicate: (left: T, right: TJoin) => boolean,
        selector: (left: T, right: TJoin) => TResult,
        joinType: "RIGHT",
    ): Query<TResult>;
    join<TJoin extends object, TResult extends object>(
        other: Query<TJoin>,
        predicate: (left: T, right: TJoin) => boolean,
        selector: (left: T, right: TJoin) => TResult,
        joinType: "OUTER",
    ): Query<TResult>;
    map<TOut extends object>(mapper: (item: T) => TOut): Query<TOut>;
    orderBy(
        selector: keyof T | ((item: T) => unknown),
        mode?: "ascending" | "descending",
    ): Query<T>;
    reset(mode?: "fast" | "full"): Promise<void>;
    skip(count: number): Query<T>;
    someAsync(filter?: FilterPredicate<T>): Promise<boolean>;
    sumAsync(
        selector: (item: T) => number,
        defaultValue?: number,
    ): Promise<number>;
    take(count: number): Query<T>;
    toArray(): T[];
    toArrayAsync(): Promise<T[]>;
    tryDeleteOneAsync(filter: FilterPredicate<T>): Promise<boolean>;
    tryFindAsync(predicate: FilterPredicate<T>): Promise<T>;
    tryFirst(): T;
    tryFirstAsync(): Promise<T>;
    tryInsertAsync(doc: T): Promise<T>;
    updateAllAsync(
        filter: FilterPredicate<T>,
        update: (entry: T) => void,
        options: UpdateOptions & { returning: true },
    ): Promise<T[]>;
    updateAllAsync(
        filter: FilterPredicate<T>,
        update: (entry: T) => void,
        options?: UpdateOptions,
    ): Promise<number>;
    updateOneAsync(
        filter: FilterPredicate<T>,
        update: (entry: T) => void,
        options?: UpdateOptions,
    ): Promise<void>;
}

Type Parameters

T extends object

Hierarchy (View Summary)

Query<T>
- Collection

Methods

addIndex

addIndex(
    name: string,
    expression: (item: T) => unknown,
    options?: IndexOptions<T>,
): void
Adds an expression-based index to the collection.
Parameters
- name: string
- expression: (item: T) => unknown
- Optionaloptions: IndexOptions<T>
Returns void

addUniqueConstraint

addUniqueConstraint(
    name: string,
    expression: (item: T) => unknown,
    options?: UniqueConstraintOptions<T>,
): void
Adds a uniqueness constraint derived from a document expression.
Parameters
- name: string
- expression: (item: T) => unknown
- Optionaloptions: UniqueConstraintOptions<T>
Returns void

canUpdate

canUpdate(oldDocument?: T, newDocument?: T): boolean
Checks whether the current caller may update a document.
Parameters
- OptionaloldDocument: T
- OptionalnewDocument: T
Returns boolean

count

count(predicate?: FilterPredicate<T>): number
Counts documents in this query synchronously.
Parameters
- Optionalpredicate: FilterPredicate<T>
Returns number

Inherited from Query.count

countAsync

countAsync(): Promise<number>

Counts documents in this query.

Returns Promise<number>

Inherited from Query.countAsync

filter

filter(predicate?: FilterPredicate<T>): Query<T>
Narrows this query to documents matching the predicate.
Parameters
- Optionalpredicate: FilterPredicate<T>
Returns Query<T>

Inherited from Query.filter

filterAsync

filterAsync(predicate?: FilterPredicate<T>): Promise<T[]>
Materializes documents matching the predicate.
Parameters
- Optionalpredicate: FilterPredicate<T>
Returns Promise<T[]>

Inherited from Query.filterAsync

findAsync

findAsync(predicate: FilterPredicate<T>): Promise<T>
Finds one matching document, or rejects when none exists.
Parameters
- predicate: FilterPredicate<T>
Returns Promise<T>

Inherited from Query.findAsync
findAsync<TResult>(
predicate: FilterPredicate<T>,
mapper: (item: T) => TResult,
): Promise<TResult>
Finds and transforms one matching document.
Type Parameters
- TResult
Parameters
- predicate: FilterPredicate<T>
- mapper: (item: T) => TResult
Returns Promise<TResult>

Inherited from Query.findAsync

flatMap

flatMap<TOut extends object>(mapper: (item: T) => Iterable<TOut>): Query<TOut>
Projects each document to zero or more output documents.
Type Parameters
- TOut extends object
Parameters
- mapper: (item: T) => Iterable<TOut>
Returns Query<TOut>

Inherited from Query.flatMap

insertAsync

insertAsync(doc: T): Promise<T>
Inserts a document and returns it, including generated values.
Parameters
- doc: T
Returns Promise<T>

insertManyAsync

insertManyAsync(docs: T[], options?: InsertManyOptions): Promise<T[]>
Inserts documents in batches.
Parameters
- docs: T[]
- Optionaloptions: InsertManyOptions
Returns Promise<T[]>

join

join<TJoin extends object, TResult extends object>(
    other: Query<TJoin>,
    predicate: (left: T, right: TJoin) => boolean,
    selector: (left: T, right: TJoin) => TResult,
): Query<TResult>
Combines matching rows from this query and another query.
Type Parameters
- TJoin extends object
- TResult extends object
Parameters
- other: Query<TJoin>
- predicate: (left: T, right: TJoin) => boolean
- selector: (left: T, right: TJoin) => TResult
Returns Query<TResult>

Inherited from Query.join
join<TJoin extends object, TResult extends object>(
    other: Query<TJoin>,
    predicate: (left: T, right: TJoin) => boolean,
    selector: (left: T, right: TJoin) => TResult,
    joinType: "INNER",
): Query<TResult>
Explicitly combines only rows that match in both queries.
Type Parameters
- TJoin extends object
- TResult extends object
Parameters
- other: Query<TJoin>
- predicate: (left: T, right: TJoin) => boolean
- selector: (left: T, right: TJoin) => TResult
- joinType: "INNER"
Returns Query<TResult>

Inherited from Query.join
join<TJoin extends object, TResult extends object>(
    other: Query<TJoin>,
    predicate: (left: T, right: TJoin) => boolean,
    selector: (left: T, right: TJoin) => TResult,
    joinType: "LEFT",
): Query<TResult>
Includes unmatched rows from this query, with an undefined right row.
Type Parameters
- TJoin extends object
- TResult extends object
Parameters
- other: Query<TJoin>
- predicate: (left: T, right: TJoin) => boolean
- selector: (left: T, right: TJoin) => TResult
- joinType: "LEFT"
Returns Query<TResult>

Inherited from Query.join
join<TJoin extends object, TResult extends object>(
    other: Query<TJoin>,
    predicate: (left: T, right: TJoin) => boolean,
    selector: (left: T, right: TJoin) => TResult,
    joinType: "RIGHT",
): Query<TResult>
Includes unmatched rows from the other query, with an undefined left row.
Type Parameters
- TJoin extends object
- TResult extends object
Parameters
- other: Query<TJoin>
- predicate: (left: T, right: TJoin) => boolean
- selector: (left: T, right: TJoin) => TResult
- joinType: "RIGHT"
Returns Query<TResult>

Inherited from Query.join
join<TJoin extends object, TResult extends object>(
    other: Query<TJoin>,
    predicate: (left: T, right: TJoin) => boolean,
    selector: (left: T, right: TJoin) => TResult,
    joinType: "OUTER",
): Query<TResult>
Includes unmatched rows from either query, with the missing row undefined.
Type Parameters
- TJoin extends object
- TResult extends object
Parameters
- other: Query<TJoin>
- predicate: (left: T, right: TJoin) => boolean
- selector: (left: T, right: TJoin) => TResult
- joinType: "OUTER"
Returns Query<TResult>

Inherited from Query.join

map

map<TOut extends object>(mapper: (item: T) => TOut): Query<TOut>
Projects each document to a new object shape.
Type Parameters
- TOut extends object
Parameters
- mapper: (item: T) => TOut
Returns Query<TOut>

Inherited from Query.map

orderBy

orderBy(
selector: keyof T | ((item: T) => unknown),
mode?: "ascending" | "descending",
): Query<T>
Sorts documents by a property or selector.
Parameters
- selector: keyof T | ((item: T) => unknown)
- Optionalmode: "ascending" | "descending"
Returns Query<T>

Inherited from Query.orderBy

reset

reset(mode?: "fast" | "full"): Promise<void>
Clears collection documents; available in test environments.
Parameters
- Optionalmode: "fast" | "full"
Returns Promise<void>

skip

skip(count: number): Query<T>
Skips the first count documents.
Parameters
- count: number
Returns Query<T>

Inherited from Query.skip

someAsync

someAsync(filter?: FilterPredicate<T>): Promise<boolean>
Returns whether any document matches a filter or predicate.
Parameters
- Optionalfilter: FilterPredicate<T>
Returns Promise<boolean>

sumAsync

sumAsync(selector: (item: T) => number, defaultValue?: number): Promise<number>
Sums values projected from matching documents.
Parameters
- selector: (item: T) => number
- OptionaldefaultValue: number
Returns Promise<number>

Inherited from Query.sumAsync

take

take(count: number): Query<T>
Limits this query to the first count documents.
Parameters
- count: number
Returns Query<T>

Inherited from Query.take

toArray

toArray(): T[]

Materializes this query synchronously.

Returns T[]

Inherited from Query.toArray

toArrayAsync

toArrayAsync(): Promise<T[]>

Materializes this query as an array.

Returns Promise<T[]>

Inherited from Query.toArrayAsync

tryDeleteOneAsync

tryDeleteOneAsync(filter: FilterPredicate<T>): Promise<boolean>
Deletes one matching document, returning whether a document was deleted.
Parameters
- filter: FilterPredicate<T>
Returns Promise<boolean>

tryFindAsync

tryFindAsync(predicate: FilterPredicate<T>): Promise<T>
Finds one matching document, if present.
Parameters
- predicate: FilterPredicate<T>
Returns Promise<T>

Inherited from Query.tryFindAsync

tryFirst

tryFirst(): T

Returns the first document, if present.

Returns T

Inherited from Query.tryFirst

tryFirstAsync

tryFirstAsync(): Promise<T>

Returns the first document asynchronously, if present.

Returns Promise<T>

Inherited from Query.tryFirstAsync

tryInsertAsync

tryInsertAsync(doc: T): Promise<T>
Inserts a document, returning undefined on a uniqueness conflict.
Parameters
- doc: T
Returns Promise<T>

updateAllAsync

updateAllAsync(
    filter: FilterPredicate<T>,
    update: (entry: T) => void,
    options: UpdateOptions & { returning: true },
): Promise<T[]>
Updates matching documents and returns the modified documents.
Parameters
- filter: FilterPredicate<T>
- update: (entry: T) => void
- options: UpdateOptions & { returning: true }
Returns Promise<T[]>
updateAllAsync(
    filter: FilterPredicate<T>,
    update: (entry: T) => void,
    options?: UpdateOptions,
): Promise<number>
Updates matching documents and returns the number of modified documents.
Parameters
- filter: FilterPredicate<T>
- update: (entry: T) => void
- Optionaloptions: UpdateOptions
Returns Promise<number>

updateOneAsync

updateOneAsync(
    filter: FilterPredicate<T>,
    update: (entry: T) => void,
    options?: UpdateOptions,
): Promise<void>
Updates one matching document, rejecting when none exists.
Parameters
- filter: FilterPredicate<T>
- update: (entry: T) => void
- Optionaloptions: UpdateOptions
Returns Promise<void>

Properties

`Optional`autoPermissions

autoPermissions?: Record<string, string>

Automatically grants the named permissions for this collection.

`Optional`excludeFromAutoMenu

excludeFromAutoMenu?: boolean

Omits this collection from automatically generated Studio menus.

`Optional`excludeFromGlobalSearch

excludeFromGlobalSearch?: boolean

Omits this collection from Studio's global search.

`Optional`menuIndex

menuIndex?: number

Controls this collection's position in Studio menus.

`Optional`menuParent

menuParent?: Collection<object>

Places this collection beneath another collection in Studio menus.

Interface Collection<T>

Type Parameters

Hierarchy (View Summary)

Index

Methods

Properties

Methods

addIndex

Parameters

Returns void

addUniqueConstraint

Parameters

Returns void

canUpdate

Parameters

Returns boolean

count

Parameters

Returns number

countAsync

Returns Promise<number>

filter

Parameters

Returns Query<T>

filterAsync

Parameters

Returns Promise<T[]>

findAsync

Parameters

Returns Promise<T>

Type Parameters

Parameters

Returns Promise<TResult>

flatMap

Type Parameters

Parameters

Returns Query<TOut>

insertAsync

Parameters

Returns Promise<T>

insertManyAsync

Parameters

Returns Promise<T[]>

join

Type Parameters

Parameters

Returns Query<TResult>

Type Parameters

Parameters

Returns Query<TResult>

Type Parameters

Parameters

Returns Query<TResult>

Type Parameters

Parameters

Returns Query<TResult>

Type Parameters

Parameters

Returns Query<TResult>

map

Type Parameters

Parameters

Returns Query<TOut>

orderBy

Parameters

Returns Query<T>

reset

Parameters

Returns Promise<void>

skip

Parameters

Returns Query<T>

someAsync

Parameters

Returns Promise<boolean>

sumAsync

Parameters

Returns Promise<number>

take

Parameters

`Optional`autoPermissions

`Optional`excludeFromAutoMenu

`Optional`excludeFromGlobalSearch

`Optional`menuIndex

`Optional`menuParent