@orbit/memory/dist/commonjs/memory-source.d.ts

Orbit source for managing in-memory records.

import { DefaultRequestOptions, FullRequestOptions, FullResponse, RequestOptions, Resettable, ResponseHints } from '@orbit/data';
import { RecordCacheUpdateDetails } from '@orbit/record-cache';
import { RecordOperation, RecordOperationResult, RecordQuery, RecordQueryable, RecordQueryBuilder, RecordQueryExpressionResult, RecordQueryResult, RecordSource, RecordSourceQueryOptions, RecordSourceSettings, RecordSyncable, RecordTransform, RecordTransformBuilder, RecordTransformResult, RecordUpdatable } from '@orbit/records';
import { Dict } from '@orbit/utils';
import { MemoryCache, MemoryCacheClass, MemoryCacheSettings } from './memory-cache';
export interface MemorySourceSettings<QO extends RequestOptions = RecordSourceQueryOptions, TO extends RequestOptions = RequestOptions, QB = RecordQueryBuilder, TB = RecordTransformBuilder, QRD = unknown, TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails> extends RecordSourceSettings<QO, TO, QB, TB> {
    base?: MemorySource<QO, TO, QB, TB, QRD, TRD>;
    cacheClass?: MemoryCacheClass<QO, TO, QB, TB, QRD, TRD>;
    cacheSettings?: Partial<MemoryCacheSettings<QO, TO, QB, TB, QRD, TRD>>;
}
export interface MemorySourceMergeOptions {
    coalesce?: boolean;
    /**
     * @deprecated since v0.17
     */
    sinceTransformId?: string;
    /**
     * @deprecated since v0.17, include transform options alongside merge options instead
     */
    transformOptions?: RequestOptions;
}
export interface MemorySource<QO extends RequestOptions = RecordSourceQueryOptions, TO extends RequestOptions = RequestOptions, QB = RecordQueryBuilder, TB = RecordTransformBuilder, QRD = unknown, TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails> extends RecordSource<QO, TO, QB, TB>, RecordSyncable, RecordQueryable<QRD, QB, QO>, RecordUpdatable<TRD, TB, TO> {
}
export declare class MemorySource<QO extends RequestOptions = RecordSourceQueryOptions, TO extends RequestOptions = RequestOptions, QB = RecordQueryBuilder, TB = RecordTransformBuilder, QRD = unknown, TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails> extends RecordSource<QO, TO, QB, TB> implements RecordSyncable, RecordQueryable<QRD, QB, QO>, RecordUpdatable<TRD, TB, TO>, Resettable {
    protected _cache: MemoryCache<QO, TO, QB, TB, QRD, TRD>;
    protected _base?: MemorySource<QO, TO, QB, TB, QRD, TRD>;
    protected _forkPoint?: string;
    protected _transforms: Dict<RecordTransform>;
    protected _transformInverses: Dict<RecordOperation[]>;
    constructor(settings: MemorySourceSettings<QO, TO, QB, TB, QRD, TRD>);
    get cache(): MemoryCache<QO, TO, QB, TB, QRD, TRD>;
    get base(): MemorySource<QO, TO, QB, TB, QRD, TRD> | undefined;
    get forkPoint(): string | undefined;
    upgrade(): Promise<void>;
    _sync(transform: RecordTransform): Promise<void>;
    _update(transform: RecordTransform, hints?: ResponseHints<RecordTransformResult, TRD>): Promise<FullResponse<RecordTransformResult, TRD, RecordOperation>>;
    _query(query: RecordQuery, hints?: ResponseHints<RecordQueryResult, QRD>): Promise<FullResponse<RecordQueryResult, QRD, RecordOperation>>;
    /**
     * Create a clone, or "fork", from a "base" source.
     *
     * The forked source will have the same `schema` and `keyMap` as its base source.
     * The forked source's cache will start with the same immutable document as
     * the base source. Its contents and log will evolve independently.
     *
     * @returns The forked source.
     */
    fork(settings?: Partial<MemorySourceSettings<QO, TO, QB, TB, QRD, TRD>>): MemorySource<QO, TO, QB, TB, QRD, TRD>;
    /**
     * Merge transforms from a forked source back into a base source.
     *
     * By default, all of the operations from all of the transforms in the forked
     * source's history will be reduced into a single transform. A subset of
     * operations can be selected by specifying the `sinceTransformId` option.
     *
     * The `coalesce` option controls whether operations are coalesced into a
     * minimal equivalent set before being reduced into a transform.
     *
     * @param forkedSource - The source to merge.
     * @param options - Merge options
     * @returns The result of calling `update()` with the forked transforms.
     */
    merge<RequestData extends RecordTransformResult = RecordTransformResult>(forkedSource: MemorySource<QO, TO, QB, TB, QRD, TRD>, options?: DefaultRequestOptions<TO> & MemorySourceMergeOptions): Promise<RequestData>;
    merge<RequestData extends RecordTransformResult = RecordTransformResult>(forkedSource: MemorySource<QO, TO, QB, TB, QRD, TRD>, options: FullRequestOptions<TO> & MemorySourceMergeOptions): Promise<FullResponse<RequestData, TRD, RecordOperation>>;
    /**
     * Rebase works similarly to a git rebase:
     *
     * After a source is forked, there is a parent- and a child-source. Both may
     * be updated with transforms. When `childSource.rebase()` is called, the
     * child source's state will be reset to match the current state of its
     * parent, and then any locally made transforms will be replayed on the child
     * source.
     */
    rebase(): void;
    /**
     * Reset the source's cache and transform log to its initial state, which will
     * be either empty or a matching its `base`, if it has one.
     */
    reset(): Promise<void>;
    /**
     * Rolls back the source to a particular `transformId`.
     *
     * `relativePosition` can be a positive or negative integer used to specify a
     * position relative to `transformId`.
     */
    rollback(transformId: string, relativePosition?: number): Promise<void>;
    /**
     * Returns all logged transforms since a particular `transformId`.
     */
    getTransformsSince(transformId: string): RecordTransform[];
    /**
     * @deprecated since v0.17, call `getTransformsSince` instead
     */
    transformsSince(transformId: string): RecordTransform[];
    /**
     * Returns all logged transforms.
     */
    getAllTransforms(): RecordTransform[];
    /**
     * @deprecated since v0.17, call `getAllTransforms` instead
     */
    allTransforms(): RecordTransform[];
    getTransform(transformId: string): RecordTransform;
    getInverseOperations(transformId: string): RecordOperation[];
    get defaultQueryOptions(): DefaultRequestOptions<QO> | undefined;
    set defaultQueryOptions(options: DefaultRequestOptions<QO> | undefined);
    get defaultTransformOptions(): DefaultRequestOptions<TO> | undefined;
    set defaultTransformOptions(options: DefaultRequestOptions<TO> | undefined);
    protected _retrieveQueryExpressionResult(result: RecordQueryExpressionResult): RecordQueryExpressionResult;
    protected _retrieveOperationResult(result: RecordOperationResult): RecordOperationResult;
    protected _applyTransform(transform: RecordTransform): RecordTransformResult;
    protected _clearTransformFromHistory(transformId: string): void;
    protected _logCleared(): void;
    protected _logTruncated(transformId: string, relativePosition: number, removed: string[]): void;
    protected _logRolledback(transformId: string, relativePosition: number, removed: string[]): void;
}