shelving/db/provider/MemoryDBProvider.d.ts

Toolkit for using data in JavaScript.

import { DeferredSequence } from "../../sequence/DeferredSequence.js";
import type { Data } from "../../util/data.js";
import type { Identifier, Item, Items, ItemsSequence, OptionalItem, OptionalItemSequence } from "../../util/item.js";
import type { Query } from "../../util/query.js";
import type { Updates } from "../../util/update.js";
import type { Collection } from "../collection/Collection.js";
import { DBProvider } from "./DBProvider.js";
/**
 * Fast in-memory store for data.
 * - Extremely fast (ideal for caching!), but does not persist data after the browser window is closed.
 * - `getItem()` etc return the exact same instance of an object that's passed into `setItem()`
 */
export declare class MemoryDBProvider<I extends Identifier = Identifier, T extends Data = Data> extends DBProvider<I, T> {
    /** List of tables in `{ name: MemoryTable }` format. */
    private _tables;
    /** Get a table for a collection. */
    getTable<II extends I, TT extends T>(collection: Collection<string, II, TT>): MemoryTable<II, TT>;
    getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
    getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): OptionalItemSequence<II, TT>;
    addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
    setItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
    updateItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, updates: Updates<Item<II, TT>>): Promise<void>;
    deleteItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<void>;
    countQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<number>;
    getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
    getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): ItemsSequence<II, TT>;
    setQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, data: TT): Promise<void>;
    updateQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;
    deleteQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<void>;
    setItems<II extends I, TT extends T>(collection: Collection<string, II, TT>, items: Items<II, TT>): void;
}
/** An individual table of data. */
export declare class MemoryTable<I extends Identifier, T extends Data> {
    /** Actual data in this table. */
    protected readonly _data: Map<I, Item<I, T>>;
    /** Deferred sequence of next values. */
    readonly next: DeferredSequence<void, void, void>;
    readonly collection: Collection<string, I, T>;
    constructor(collection: Collection<string, I, T>);
    getItem(id: I): OptionalItem<I, T>;
    /**
     * Subscribe to all changes for this item key.
     * - Emits the current item immediately, including `undefined` when absent.
     * - Wakes on every table change, but only yields when this item's value actually changed.
     */
    getItemSequence(id: I): AsyncIterable<OptionalItem<I, T>>;
    /** Generate a unique ID for a new item in this table. */
    generateUniqueID(): I;
    addItem(data: T): I;
    setItem(id: I, data: Item<I, T> | T): void;
    setItemSequence(id: I, sequence: AsyncIterable<OptionalItem<I, T>>): AsyncIterable<OptionalItem<I, T>>;
    updateItem(id: I, updates: Updates<Item<I, T>>): void;
    deleteItem(id: I): void;
    countQuery(query?: Query<Item<I, T>>): number;
    getQuery(query?: Query<Item<I, T>>): Items<I, T>;
    /**
     * Subscribe to the live result of a query.
     * - Emits the current query result immediately, even if empty.
     * - Wakes on every table change, but only yields when the computed query result changed.
     */
    getQuerySequence(query?: Query<Item<I, T>>): AsyncIterable<Items<I, T>>;
    setQuery(query: Query<Item<I, T>>, data: T): void;
    updateQuery(query: Query<Item<I, T>>, updates: Updates<T>): void;
    deleteQuery(query: Query<Item<I, T>>): void;
    setItems(items: Items<I, T>): void;
    setItemsSequence(sequence: AsyncIterable<Items<I, T>>): AsyncIterable<Items<I, T>>;
}