@orbit/memory/dist/modules/memory-cache.d.ts

Orbit source for managing in-memory records.

import { DefaultRequestOptions, FullRequestOptions, FullResponse, RequestOptions } from '@orbit/data';
import { ImmutableMap } from '@orbit/immutable';
import { RecordCacheQueryOptions, RecordCacheTransformOptions, RecordCacheUpdateDetails, RecordRelationshipIdentity, RecordTransformBuffer, SyncRecordCache, SyncRecordCacheSettings } from '@orbit/record-cache';
import { InitializedRecord, RecordIdentity, RecordOperation, RecordQueryBuilder, RecordTransform, RecordTransformBuilder, RecordTransformResult } from '@orbit/records';
import { Dict } from '@orbit/utils';
export interface MemoryCacheMergeOptions {
    coalesce?: boolean;
}
export interface MemoryCacheSettings<QO extends RequestOptions = RecordCacheQueryOptions, TO extends RequestOptions = RecordCacheTransformOptions, QB = RecordQueryBuilder, TB = RecordTransformBuilder, QRD = unknown, TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails> extends SyncRecordCacheSettings<QO, TO, QB, TB> {
    base?: MemoryCache<QO, TO, QB, TB, QRD, TRD>;
    trackUpdateOperations?: boolean;
}
export interface MemoryCacheClass<QO extends RequestOptions = RecordCacheQueryOptions, TO extends RequestOptions = RecordCacheTransformOptions, QB = RecordQueryBuilder, TB = RecordTransformBuilder, QRD = unknown, TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails> {
    new (settings: MemoryCacheSettings<QO, TO, QB, TB, QRD, TRD>): MemoryCache<QO, TO, QB, TB, QRD, TRD>;
}
/**
 * A cache used to access records in memory.
 *
 * Because data is stored in immutable maps, this type of cache can be forked
 * efficiently.
 */
export declare class MemoryCache<QO extends RequestOptions = RecordCacheQueryOptions, TO extends RequestOptions = RecordCacheTransformOptions, QB = RecordQueryBuilder, TB = RecordTransformBuilder, QRD = unknown, TRD extends RecordCacheUpdateDetails = RecordCacheUpdateDetails> extends SyncRecordCache<QO, TO, QB, TB, QRD, TRD> {
    protected _base?: MemoryCache<QO, TO, QB, TB, QRD, TRD>;
    protected _records: Dict<ImmutableMap<string, InitializedRecord>>;
    protected _inverseRelationships: Dict<ImmutableMap<string, RecordRelationshipIdentity[]>>;
    protected _updateOperations?: RecordOperation[];
    protected _isTrackingUpdateOperations: boolean;
    constructor(settings: MemoryCacheSettings<QO, TO, QB, TB, QRD, TRD>);
    get base(): MemoryCache<QO, TO, QB, TB, QRD, TRD> | undefined;
    /**
     * Create a clone, or "fork", from a "base" cache.
     *
     * The forked cache will have the same `schema` and `keyMap` as its base
     * source. The forked cache will start with the same immutable document as the
     * base source. Its contents and log will evolve independently.
     *
     * @returns the forked cache
     */
    fork(settings?: Partial<MemoryCacheSettings<QO, TO, QB, TB, QRD, TRD>>): MemoryCache<QO, TO, QB, TB, QRD, TRD>;
    /**
     * Merges the operations from a forked cache back to this cache.
     *
     * @returns the result of calling `update` with the operations
     */
    merge<RequestData extends RecordTransformResult = RecordTransformResult>(forkedCache: MemoryCache<QO, TO, QB, TB, QRD, TRD>, options?: DefaultRequestOptions<TO> & MemoryCacheMergeOptions): RequestData;
    merge<RequestData extends RecordTransformResult = RecordTransformResult>(forkedCache: MemoryCache<QO, TO, QB, TB, QRD, TRD>, options: FullRequestOptions<TO> & MemoryCacheMergeOptions): FullResponse<RequestData, TRD, RecordOperation>;
    /**
     * Rebase resets this cache's state to that of its base cache, then re-applies
     * any tracked update operations.
     *
     * Rebasing requires both a `base` cache as well as tracking of update
     * operations (which is enabled by default when a `base` cache is assigned).
     */
    rebase(): void;
    getRecordSync(identity: RecordIdentity): InitializedRecord | undefined;
    getRecordsSync(typeOrIdentities?: string | RecordIdentity[]): InitializedRecord[];
    setRecordSync(record: InitializedRecord): void;
    setRecordsSync(records: InitializedRecord[]): void;
    removeRecordSync(recordIdentity: RecordIdentity): InitializedRecord | undefined;
    removeRecordsSync(recordIdentities: RecordIdentity[]): InitializedRecord[];
    getInverseRelationshipsSync(recordIdentityOrIdentities: RecordIdentity | RecordIdentity[]): RecordRelationshipIdentity[];
    addInverseRelationshipsSync(relationships: RecordRelationshipIdentity[]): void;
    removeInverseRelationshipsSync(relationships: RecordRelationshipIdentity[]): void;
    /**
     * Resets the cache's to its initial state, which will be either empty or a
     * clone of its `base` cache, if it has one.
     */
    reset(): void;
    /**
     * Upgrade the cache based on the current state of the schema.
     */
    upgrade(): void;
    get isTrackingUpdateOperations(): boolean;
    getAllUpdateOperations(): RecordOperation[];
    protected _update<RequestData extends RecordTransformResult = RecordTransformResult>(transform: RecordTransform, options?: TO): FullResponse<RequestData, TRD, RecordOperation>;
    /**
     * Override `_getTransformBuffer` on base `SyncRecordCache` to provide a
     * `transformBuffer` if a custom one hasn't been provided via the constructor
     * setting.
     */
    protected _getTransformBuffer(): RecordTransformBuffer;
    protected _resetInverseRelationships(base?: MemoryCache<QO, TO, QB, TB, QRD, TRD>): void;
}