shelving/db/MemoryProvider.d.ts

Toolkit for using data in JavaScript.

import { DeferredSequence } from "../sequence/DeferredSequence.js";
import type { Data, Database, DataKey } from "../util/data.js";
import type { Identifier, Item, Items, OptionalItem } from "../util/item.js";
import type { ItemQuery } from "../util/query.js";
import type { Updates } from "../util/update.js";
import { Provider } from "./Provider.js";
/**
 * Fast in-memory store for data.
 * - Extremely fast (ideal for caching!), but does not persist data after the browser window is closed.
 * - `get()` etc return the exact same instance of an object that's passed into `set()`
 */
export declare class MemoryProvider<I extends Identifier, T extends Database> extends Provider<I, T> {
    /** List of tables in `{ collection: Table }` format. */
    private _tables;
    /** Get a table for a collection. */
    getTable<K extends DataKey<T>>(collection: K): MemoryTable<I, T[K]>;
    getItemTime<K extends DataKey<T>>(collection: K, id: I): number | undefined;
    getItem<K extends DataKey<T>>(collection: K, id: I): OptionalItem<I, T[K]>;
    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
    getCachedItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
    addItem<K extends DataKey<T>>(collection: K, data: T[K]): I;
    setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): void;
    setItemSequence<K extends DataKey<T>>(collection: K, id: I, sequence: AsyncIterable<OptionalItem<I, T[K]>>): AsyncIterable<OptionalItem<I, T[K]>>;
    updateItem<K extends DataKey<T>>(collection: K, id: I, updates: Updates<T[K]>): void;
    deleteItem<K extends DataKey<T>>(collection: K, id: I): void;
    getQueryTime<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): number | undefined;
    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): number;
    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Items<I, T[K]>;
    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
    getCachedQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): void;
    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, updates: Updates<T[K]>): void;
    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): void;
    setItems<K extends DataKey<T>>(collection: K, items: Items<I, T[K]>, query?: ItemQuery<I, T[K]>): void;
    setItemsSequence<K extends DataKey<T>>(collection: K, sequence: AsyncIterable<Items<I, T[K]>>, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
}
/** An individual table of data. */
export declare class MemoryTable<I extends Identifier, T extends Data> {
    /** Actual data in this table. */
    protected readonly _data: Map<Identifier, Item<I, T>>;
    /** Times data was last updated. */
    protected readonly _times: Map<Identifier, number>;
    /** Deferred sequence of next values. */
    readonly next: DeferredSequence<void>;
    getItemTime(id: I): number | undefined;
    getItem(id: I): OptionalItem<I, T>;
    getItemSequence(id: I): AsyncIterable<OptionalItem<I, T>>;
    getCachedItemSequence(id: I): AsyncIterable<OptionalItem<I, T>>;
    /** Function to generate a random ID for 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<T>): void;
    deleteItem(id: I): void;
    getQueryTime(query?: ItemQuery<I, T>): number | undefined;
    countQuery(query?: ItemQuery<I, T>): number;
    getQuery(query?: ItemQuery<I, T>): Items<I, T>;
    getQuerySequence(query?: ItemQuery<I, T>): AsyncIterable<Items<I, T>>;
    getCachedQuerySequence(query?: ItemQuery<I, T>): AsyncIterable<Items<I, T>>;
    setQuery(query: ItemQuery<I, T>, data: T): void;
    updateQuery(query: ItemQuery<I, T>, updates: Updates<T>): void;
    deleteQuery(query: ItemQuery<I, T>): void;
    setItems(items: Items<I, T>, query?: ItemQuery<I, T>): void;
    setItemsSequence(sequence: AsyncIterable<Items<I, T>>, query?: ItemQuery<I, T>): AsyncIterable<Items<I, T>>;
}