shelving 1.107.2 → 1.108.0

package/change/Change.d.ts

@@ -1,6 +1,6 @@
-import type { AsyncProvider, Provider } from "../provider/Provider.js";
+import type { AbstractProvider, AsyncProvider, Provider } from "../db/Provider.js";
 import type { ImmutableArray } from "../util/array.js";
-import type { Data } from "../util/data.js";
+import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
 import type { Updates } from "../util/update.js";
 import { type Optional } from "../util/optional.js";
@@ -9,75 +9,89 @@ export interface Change {
     readonly action: string;
 }
 /** A change to a database collection. */
-export interface CollectionChange<T extends Data> extends Change {
-    readonly collection: string;
+export interface CollectionChange<T extends Database, K extends DataKey<T>> extends Change {
+    readonly collection: K;
     readonly id?: string | never;
-    readonly query?: ItemQuery<T> | never;
+    readonly query?: ItemQuery<T[K]> | never;
 }
 /** Add an item to a database collection. */
-export interface AddItemChange<T extends Data> extends CollectionChange<T> {
+export interface AddItemChange<T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {
     readonly action: "add";
     readonly id?: never;
     readonly query?: never;
-    readonly data: T;
+    readonly data: T[K];
 }
 /** Change an item in a database collection. */
-export interface ItemChange<T extends Data> extends CollectionChange<T> {
+export interface ItemChange<T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {
     readonly id: string;
     readonly query?: never;
 }
 /** Set an item in a database collection. */
-export interface SetItemChange<T extends Data> extends ItemChange<T> {
+export interface ItemSetChange<T extends Database, K extends DataKey<T>> extends ItemChange<T, K> {
     readonly action: "set";
-    readonly data: T;
+    readonly data: T[K];
 }
 /** Update an item in a database collection. */
-export interface UpdateItemChange<T extends Data> extends ItemChange<T> {
+export interface ItemUpdateChange<T extends Database, K extends DataKey<T>> extends ItemChange<T, K> {
     readonly action: "update";
-    readonly updates: Updates<T>;
+    readonly updates: Updates<T[K]>;
 }
 /** Delete an item in a database collection. */
-export interface DeleteItemChange<T extends Data> extends ItemChange<T> {
+export interface ItemDeleteChange<T extends Database, K extends DataKey<T>> extends ItemChange<T, K> {
     readonly action: "delete";
 }
 /** Change multiple items in a database collection. */
-export interface QueryChange<T extends Data> extends CollectionChange<T> {
-    readonly query: ItemQuery<T>;
+export interface QueryChange<T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {
+    readonly query: ItemQuery<T[K]>;
     readonly id?: never;
 }
 /** Set multiple items in a database collection. */
-export interface SetQueryChange<T extends Data> extends QueryChange<T> {
+export interface QuerySetChange<T extends Database, K extends DataKey<T>> extends QueryChange<T, K> {
     readonly action: "set";
-    readonly data: T;
+    readonly data: T[K];
 }
 /** Update multiple items in a database collection. */
-export interface UpdateQueryChange<T extends Data> extends QueryChange<T> {
+export interface QueryUpdateChange<T extends Database, K extends DataKey<T>> extends QueryChange<T, K> {
     readonly action: "update";
-    readonly updates: Updates<T>;
+    readonly updates: Updates<T[K]>;
 }
 /** Delete multiple items in a database collection. */
-export interface DeleteQueryChange<T extends Data> extends QueryChange<T> {
+export interface QueryDeleteChange<T extends Database, K extends DataKey<T>> extends QueryChange<T, K> {
     readonly action: "delete";
 }
-/** Write an item in a database collection. */
-export type WriteItemChange<T extends Data> = SetItemChange<T> | UpdateItemChange<T> | DeleteItemChange<T>;
-/** Write multiple item in a database collection. */
-export type WriteQueryChange<T extends Data> = SetQueryChange<T> | UpdateQueryChange<T> | DeleteQueryChange<T>;
-/** Write an item or multiple items in a database collection. */
-export type WriteChange<T extends Data> = AddItemChange<T> | WriteItemChange<T> | WriteQueryChange<T>;
+/** Write an item in a set of collection. */
+export type DatabaseItemChange<T extends Database> = ItemSetChange<T, DataKey<T>> | ItemUpdateChange<T, DataKey<T>> | ItemDeleteChange<T, DataKey<T>>;
+/** Write multiple item in a set of collection. */
+export type DatabaseQueryChange<T extends Database> = QuerySetChange<T, DataKey<T>> | QueryUpdateChange<T, DataKey<T>> | QueryDeleteChange<T, DataKey<T>>;
+/** Write an item or multiple items in a set of collection. */
+export type DatabaseChange<T extends Database> = AddItemChange<T, DataKey<T>> | DatabaseItemChange<T> | DatabaseQueryChange<T>;
+/** Write an item or multiple items in a set of collection. */
+export type DatabaseChanges<T extends Database> = ImmutableArray<DatabaseChange<T>>;
+/** Get a set change for an item. */
+export declare function getItemSet<T extends Database, K extends DataKey<T>>(provider: AbstractProvider<T>, collection: K, id: string, data: T[K]): ItemSetChange<T, K>;
+/** Get an update change an item. */
+export declare function getItemUpdate<T extends Database, K extends DataKey<T>>(provider: AbstractProvider<T>, collection: K, id: string, updates: Updates<T[K]>): ItemUpdateChange<T, K>;
+/** Get a set change for an item. */
+export declare function getItemDelete<T extends Database, K extends DataKey<T>>(provider: AbstractProvider<T>, collection: K, id: string): ItemDeleteChange<T, K>;
+/** Get a set change for an query. */
+export declare function getQuerySet<T extends Database, K extends DataKey<T>>(provider: AbstractProvider<T>, collection: K, query: ItemQuery<T[K]>, data: T[K]): QuerySetChange<T, K>;
+/** Get an update change an query. */
+export declare function getQueryUpdate<T extends Database, K extends DataKey<T>>(provider: AbstractProvider<T>, collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): QueryUpdateChange<T, K>;
+/** Get a set change for an query. */
+export declare function getQueryDelete<T extends Database, K extends DataKey<T>>(provider: AbstractProvider<T>, collection: K, query: ItemQuery<T[K]>): QueryDeleteChange<T, K>;
 /** Write a set of changes to a synchronous provider. */
-export declare function writeProviderChanges<T extends Data>(provider: Provider, ...changes: Optional<WriteChange<T>>[]): ImmutableArray<WriteChange<T>>;
+export declare function writeProviderChanges<T extends Database>(provider: Provider<T>, ...changes: Optional<DatabaseChange<T>>[]): DatabaseChanges<T>;
 /**
  * Write a single change to a synchronous provider.
  * @param change Change that should be written.
  * @return Change that was written.
  */
-export declare function writeProviderChange<T extends Data>(provider: Provider, change: WriteChange<T>): WriteChange<T>;
+export declare function writeProviderChange<T extends Database>(provider: Provider<T>, change: DatabaseChange<T>): DatabaseChange<T>;
 /** Write a set of changes to an asynchronous provider. */
-export declare function writeAsyncProviderChanges<T extends Data>(provider: AsyncProvider, ...changes: Optional<WriteChange<T>>[]): Promise<ImmutableArray<WriteChange<T>>>;
+export declare function writeAsyncProviderChanges<T extends Database>(provider: AsyncProvider<T>, ...changes: Optional<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;
 /**
  * Write a single change to an asynchronous provider.
  * @param change Change that should be written.
  * @return Change that was written.
  */
-export declare function writeAsyncProviderChange<T extends Data>(provider: AsyncProvider, change: WriteChange<T>): Promise<WriteChange<T>>;
+export declare function writeAsyncProviderChange<T extends Database>(provider: AsyncProvider<T>, change: DatabaseChange<T>): Promise<DatabaseChange<T>>;

package/change/Change.js

@@ -1,4 +1,28 @@
 import { notOptional } from "../util/optional.js";
+/** Get a set change for an item. */
+export function getItemSet(provider, collection, id, data) {
+    return { action: "set", collection, id, data };
+}
+/** Get an update change an item. */
+export function getItemUpdate(provider, collection, id, updates) {
+    return { action: "update", collection, id, updates };
+}
+/** Get a set change for an item. */
+export function getItemDelete(provider, collection, id) {
+    return { action: "delete", collection, id };
+}
+/** Get a set change for an query. */
+export function getQuerySet(provider, collection, query, data) {
+    return { action: "set", collection, query, data };
+}
+/** Get an update change an query. */
+export function getQueryUpdate(provider, collection, query, updates) {
+    return { action: "update", collection, query, updates };
+}
+/** Get a set change for an query. */
+export function getQueryDelete(provider, collection, query) {
+    return { action: "delete", collection, query };
+}
 /** Write a set of changes to a synchronous provider. */
 export function writeProviderChanges(provider, ...changes) {
     return changes.filter(notOptional).map(change => writeProviderChange(provider, change));

package/db/CacheProvider.d.ts

@@ -0,0 +1,24 @@
+import type { AsyncProvider } from "./Provider.js";
+import type { DataKey, Database } from "../util/data.js";
+import type { ItemQuery, Items, OptionalItem } from "../util/item.js";
+import type { Sourceable } from "../util/source.js";
+import type { Updates } from "../util/update.js";
+import { MemoryProvider } from "./MemoryProvider.js";
+/** Keep a copy of asynchronous remote data in a local synchronous cache. */
+export declare class CacheProvider<T extends Database> implements AsyncProvider<T>, Sourceable<AsyncProvider<T>> {
+    readonly source: AsyncProvider<T>;
+    readonly memory: MemoryProvider<T>;
+    constructor(source: AsyncProvider<T>, cache?: MemoryProvider<T>);
+    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<OptionalItem<T[K]>>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Promise<number>;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Promise<Items<T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): Promise<void>;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): Promise<void>;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<void>;
+}

package/db/CacheProvider.js

@@ -0,0 +1,58 @@
+import { MemoryProvider } from "./MemoryProvider.js";
+/** Keep a copy of asynchronous remote data in a local synchronous cache. */
+export class CacheProvider {
+    source;
+    memory;
+    constructor(source, cache = new MemoryProvider()) {
+        this.source = source;
+        this.memory = cache;
+    }
+    async getItem(collection, id) {
+        const item = await this.source.getItem(collection, id);
+        item ? this.memory.setItem(collection, id, item) : this.memory.deleteItem(collection, id);
+        return item;
+    }
+    getItemSequence(collection, id) {
+        return this.memory.setItemSequence(collection, id, this.source.getItemSequence(collection, id));
+    }
+    async addItem(collection, data) {
+        const id = await this.source.addItem(collection, data);
+        this.memory.setItem(collection, id, data);
+        return id;
+    }
+    async setItem(collection, id, data) {
+        await this.source.setItem(collection, id, data);
+        this.memory.setItem(collection, id, data);
+    }
+    async updateItem(collection, id, updates) {
+        await this.source.updateItem(collection, id, updates);
+        this.memory.updateItem(collection, id, updates);
+    }
+    async deleteItem(collection, id) {
+        await this.source.deleteItem(collection, id);
+        this.memory.deleteItem(collection, id);
+    }
+    countQuery(collection, query) {
+        return this.source.countQuery(collection, query);
+    }
+    async getQuery(collection, query) {
+        const items = await this.source.getQuery(collection, query);
+        this.memory.setItems(collection, items, query);
+        return items;
+    }
+    getQuerySequence(collection, query) {
+        return this.memory.setItemsSequence(collection, this.source.getQuerySequence(collection, query), query);
+    }
+    async setQuery(collection, query, data) {
+        await this.source.setQuery(collection, query, data);
+        this.memory.setQuery(collection, query, data);
+    }
+    async updateQuery(collection, query, updates) {
+        await this.source.updateQuery(collection, query, updates);
+        this.memory.updateQuery(collection, query, updates);
+    }
+    async deleteQuery(collection, query) {
+        await this.source.deleteQuery(collection, query);
+        this.memory.deleteQuery(collection, query);
+    }
+}

package/db/ChangeProvider.d.ts

@@ -0,0 +1,26 @@
+import type { DatabaseChange, DatabaseChanges, ItemDeleteChange, ItemSetChange, ItemUpdateChange, QueryDeleteChange, QuerySetChange, QueryUpdateChange } from "../change/Change.js";
+import type { DataKey, Database } from "../util/data.js";
+import type { ItemQuery } from "../util/item.js";
+import type { Optional } from "../util/optional.js";
+import type { Updates } from "../util/update.js";
+import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
+export declare class ChangeProvider<T extends Database> extends ThroughProvider<T> {
+    getItemSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): ItemSetChange<T, K>;
+    getItemUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): ItemUpdateChange<T, K>;
+    getItemDelete<K extends DataKey<T>>(collection: K, id: string): ItemDeleteChange<T, K>;
+    getQuerySet<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): QuerySetChange<T, K>;
+    getQueryUpdate<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): QueryUpdateChange<T, K>;
+    getQueryDelete<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): QueryDeleteChange<T, K>;
+    writeChanges(...changes: Optional<DatabaseChange<T>>[]): DatabaseChanges<T>;
+    writeChange(change: DatabaseChange<T>): DatabaseChange<T>;
+}
+export declare class AsyncChangeProvider<T extends Database> extends AsyncThroughProvider<T> {
+    getItemSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): ItemSetChange<T, K>;
+    getItemUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): ItemUpdateChange<T, K>;
+    getItemDelete<K extends DataKey<T>>(collection: K, id: string): ItemDeleteChange<T, K>;
+    getQuerySet<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): QuerySetChange<T, K>;
+    getQueryUpdate<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): QueryUpdateChange<T, K>;
+    getQueryDelete<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): QueryDeleteChange<T, K>;
+    writeChanges(...changes: Optional<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;
+    writeChange(change: DatabaseChange<T>): Promise<DatabaseChange<T>>;
+}

package/db/ChangeProvider.js

@@ -0,0 +1,54 @@
+import { getItemDelete, getItemSet, getItemUpdate, getQueryDelete, getQuerySet, getQueryUpdate, writeAsyncProviderChange, writeAsyncProviderChanges, writeProviderChange, writeProviderChanges } from "../change/Change.js";
+import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
+export class ChangeProvider extends ThroughProvider {
+    getItemSet(collection, id, data) {
+        return getItemSet(this, collection, id, data);
+    }
+    getItemUpdate(collection, id, updates) {
+        return getItemUpdate(this, collection, id, updates);
+    }
+    getItemDelete(collection, id) {
+        return getItemDelete(this, collection, id);
+    }
+    getQuerySet(collection, query, data) {
+        return getQuerySet(this, collection, query, data);
+    }
+    getQueryUpdate(collection, query, updates) {
+        return getQueryUpdate(this, collection, query, updates);
+    }
+    getQueryDelete(collection, query) {
+        return getQueryDelete(this, collection, query);
+    }
+    writeChanges(...changes) {
+        return writeProviderChanges(this, ...changes);
+    }
+    writeChange(change) {
+        return writeProviderChange(this, change);
+    }
+}
+export class AsyncChangeProvider extends AsyncThroughProvider {
+    getItemSet(collection, id, data) {
+        return getItemSet(this, collection, id, data);
+    }
+    getItemUpdate(collection, id, updates) {
+        return getItemUpdate(this, collection, id, updates);
+    }
+    getItemDelete(collection, id) {
+        return getItemDelete(this, collection, id);
+    }
+    getQuerySet(collection, query, data) {
+        return getQuerySet(this, collection, query, data);
+    }
+    getQueryUpdate(collection, query, updates) {
+        return getQueryUpdate(this, collection, query, updates);
+    }
+    getQueryDelete(collection, query) {
+        return getQueryDelete(this, collection, query);
+    }
+    writeChanges(...changes) {
+        return writeAsyncProviderChanges(this, ...changes);
+    }
+    writeChange(change) {
+        return writeAsyncProviderChange(this, change);
+    }
+}

package/db/DebugProvider.d.ts

@@ -0,0 +1,42 @@
+import type { AbstractProvider, AsyncProvider, Provider } from "./Provider.js";
+import type { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
+import type { DataKey, Database } from "../util/data.js";
+import type { ItemQuery, Items, OptionalItem } from "../util/item.js";
+import type { Updates } from "../util/update.js";
+/** Provider that logs operations to a source provider to the console. */
+declare abstract class AbstractDebugProvider<T extends Database> {
+    abstract readonly source: AbstractProvider<T>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterableIterator<OptionalItem<T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterableIterator<Items<T[K]>>;
+}
+/** Provider that logs operations to a synchronous source provider to the console. */
+export declare class DebugProvider<T extends Database> extends AbstractDebugProvider<T> implements ThroughProvider<T> {
+    readonly source: Provider<T>;
+    constructor(source: Provider<T>);
+    getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates): void;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): number;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Items<T[K]>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): void;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates): void;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void;
+}
+/** Provider that logs operations to a synchronous source provider to the console. */
+export declare class AsyncDebugProvider<T extends Database> extends AbstractDebugProvider<T> implements AsyncThroughProvider<T> {
+    readonly source: AsyncProvider<T>;
+    constructor(source: AsyncProvider<T>);
+    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<OptionalItem<T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates): Promise<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
+    countQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<number>;
+    getQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<Items<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): Promise<void>;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates): Promise<void>;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<void>;
+}
+export {};

package/{provider → db}/DebugProvider.js

@@ -87,6 +87,17 @@ export class DebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
+    countQuery(collection, query) {
+        try {
+            const count = this.source.countQuery(collection, query);
+            console.debug("✔ GET", collection, query, count);
+            return count;
+        }
+        catch (reason) {
+            console.error("✘ GET", collection, query, reason);
+            throw reason;
+        }
+    }
     getQuery(collection, query) {
         try {
             const items = this.source.getQuery(collection, query);
@@ -100,9 +111,8 @@ export class DebugProvider extends AbstractDebugProvider {
     }
     setQuery(collection, query, data) {
         try {
-            const num = this.source.setQuery(collection, query, data);
-            console.debug("✔ SET", collection, query, data, num);
-            return num;
+            this.source.setQuery(collection, query, data);
+            console.debug("✔ SET", collection, query, data);
         }
         catch (reason) {
             console.error("✘ SET", collection, query, data, reason);
@@ -111,9 +121,8 @@ export class DebugProvider extends AbstractDebugProvider {
     }
     updateQuery(collection, query, updates) {
         try {
-            const num = this.source.updateQuery(collection, query, updates);
-            console.debug("✔ UPDATE", collection, query, updates, num);
-            return num;
+            this.source.updateQuery(collection, query, updates);
+            console.debug("✔ UPDATE", collection, query, updates);
         }
         catch (reason) {
             console.error("✘ UPDATE", collection, query, updates, reason);
@@ -122,9 +131,8 @@ export class DebugProvider extends AbstractDebugProvider {
     }
     deleteQuery(collection, query) {
         try {
-            const num = this.source.deleteQuery(collection, query);
-            console.debug("✔ DELETE", collection, query, num);
-            return num;
+            this.source.deleteQuery(collection, query);
+            console.debug("✔ DELETE", collection, query);
         }
         catch (reason) {
             console.error("✘ DELETE", collection, query, reason);
@@ -196,6 +204,18 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
+    async countQuery(collection, query) {
+        try {
+            console.debug("⋯ COUNT", collection, query);
+            const count = await this.source.countQuery(collection, query);
+            console.debug("✔ COUNT", collection, query, count);
+            return count;
+        }
+        catch (reason) {
+            console.error("✘ COUNT", collection, query, reason);
+            throw reason;
+        }
+    }
     async getQuery(collection, query) {
         try {
             console.debug("⋯ GET", collection, query);
@@ -211,9 +231,8 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
     async setQuery(collection, query, data) {
         try {
             console.debug("⋯ SET", collection, query, data);
-            const num = await this.source.setQuery(collection, query, data);
-            console.debug("✔ SET", collection, query, data, num);
-            return num;
+            await this.source.setQuery(collection, query, data);
+            console.debug("✔ SET", collection, query, data);
         }
         catch (reason) {
             console.error("✘ SET", collection, query, data, reason);
@@ -223,9 +242,8 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
     async updateQuery(collection, query, updates) {
         try {
             console.debug("⋯ UPDATE", collection, query, updates);
-            const num = await this.source.updateQuery(collection, query, updates);
-            console.debug("✔ UPDATE", collection, query, updates, num);
-            return num;
+            await this.source.updateQuery(collection, query, updates);
+            console.debug("✔ UPDATE", collection, query, updates);
         }
         catch (reason) {
             console.error("✘ UPDATE", collection, query, updates, reason);
@@ -235,9 +253,8 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
     async deleteQuery(collection, query) {
         try {
             console.debug("⋯ DELETE", collection, query);
-            const num = await this.source.deleteQuery(collection, query);
-            console.debug("✔ DELETE", collection, query, num);
-            return num;
+            await this.source.deleteQuery(collection, query);
+            console.debug("✔ DELETE", collection, query);
         }
         catch (reason) {
             console.error("✘ DELETE", collection, query, reason);

package/db/ItemStore.d.ts

@@ -1,30 +1,30 @@
-import type { AbstractProvider } from "../provider/Provider.js";
+import type { AbstractProvider } from "./Provider.js";
 import type { StopCallback } from "../util/callback.js";
-import type { Data } from "../util/data.js";
-import type { ItemData, ItemValue } from "../util/item.js";
+import type { DataKey, Database } from "../util/data.js";
+import type { Item, OptionalItem } from "../util/item.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import { Store } from "../store/Store.js";
 /** Store a single item. */
-export declare class ItemStore<T extends Data = Data> extends Store<ItemValue<T>> {
-    readonly provider: AbstractProvider;
-    readonly collection: string;
+export declare class ItemStore<T extends Database, K extends DataKey<T>> extends Store<OptionalItem<T[K]>> {
+    readonly provider: AbstractProvider<T>;
+    readonly collection: K;
     readonly id: string;
     readonly busy: BooleanStore;
     /** Get the data of this store (throws `RequiredError` if item doesn't exist). */
-    get data(): ItemData<T>;
+    get data(): Item<T[K]>;
     /** Set the data of this store. */
-    set data(data: T | ItemData<T>);
+    set data(data: T[K] | Item<T[K]>);
     /** Does the item exist? */
     get exists(): boolean;
-    constructor(provider: AbstractProvider, collection: string, id: string);
+    constructor(provider: AbstractProvider<T>, collection: K, id: string);
     /** Refresh this store from the source provider. */
-    refresh(provider?: AbstractProvider): void;
+    refresh(provider?: AbstractProvider<T>): void;
     private _refresh;
     /** Refresh this store if data in the cache is older than `maxAge` (in milliseconds). */
-    refreshStale(maxAge: number, provider?: AbstractProvider): void;
+    refreshStale(maxAge: number, provider?: AbstractProvider<T>): void;
     /** Subscribe this store to a provider. */
-    connect(provider?: AbstractProvider): StopCallback;
-    [Symbol.asyncIterator](): AsyncGenerator<ItemValue<T>, void, void>;
+    connect(provider?: AbstractProvider<T>): StopCallback;
+    [Symbol.asyncIterator](): AsyncGenerator<OptionalItem<T[K]>, void, void>;
     private _iterating;
     /** Start subscription to `MemoryProvider` if there is one. */
     start(): void;

package/db/ItemStore.js

@@ -1,12 +1,12 @@
-import { CacheProvider } from "../provider/CacheProvider.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import { Store } from "../store/Store.js";
 import { call } from "../util/callback.js";
 import { NONE } from "../util/constants.js";
-import { getItemData } from "../util/item.js";
+import { getItem } from "../util/item.js";
 import { getRequired } from "../util/optional.js";
 import { runSequence } from "../util/sequence.js";
 import { getOptionalSource } from "../util/source.js";
+import { CacheProvider } from "./CacheProvider.js";
 /** Store a single item. */
 export class ItemStore extends Store {
     provider;
@@ -19,7 +19,7 @@ export class ItemStore extends Store {
     }
     /** Set the data of this store. */
     set data(data) {
-        this.value = getItemData(this.id, data);
+        this.value = getItem(this.id, data);
     }
     /** Does the item exist? */
     get exists() {
@@ -80,9 +80,9 @@ export class ItemStore extends Store {
     /** Start subscription to `MemoryProvider` if there is one. */
     start() {
         if (!this._stop) {
-            const memory = getOptionalSource(CacheProvider, this.provider)?.memory;
-            if (memory)
-                this._stop = runSequence(this.through(memory.getCachedItemSequence(this.collection, this.id)));
+            const table = getOptionalSource(CacheProvider, this.provider)?.memory.getTable(this.collection);
+            if (table)
+                this._stop = runSequence(this.through(table.getCachedItemSequence(this.id)));
         }
     }
     /** Stop subscription to `MemoryProvider` if there is one. */

package/db/MemoryProvider.d.ts

@@ -0,0 +1,61 @@
+import type { Provider } from "./Provider.js";
+import type { Data, DataKey, Database } from "../util/data.js";
+import type { Item, ItemQuery, Items, OptionalItem } from "../util/item.js";
+import type { Updates } from "../util/update.js";
+import { DeferredSequence } from "../sequence/DeferredSequence.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<T extends Database> implements Provider<T> {
+    /** List of tables in `{ collection: Table }` format. */
+    private _tables;
+    /** Get a table for a collection. */
+    getTable<K extends DataKey<T>>(collection: K): MemoryTable<T[K]>;
+    getItemTime<K extends DataKey<T>>(collection: K, id: string): number | undefined;
+    getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
+    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
+    setItemSequence<K extends DataKey<T>>(collection: K, id: string, sequence: AsyncIterable<OptionalItem<T[K]>>): AsyncIterable<OptionalItem<T[K]>>;
+    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
+    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
+    getQueryTime<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): number | undefined;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): number;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Items<T[K]>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): void;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): void;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void;
+    setItems<K extends DataKey<T>>(collection: K, items: Items<T[K]>, query?: ItemQuery<T[K]>): void;
+    setItemsSequence<K extends DataKey<T>>(collection: K, sequence: AsyncIterable<Items<T[K]>>, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+}
+/** An individual table of data. */
+export declare class MemoryTable<T extends Data> {
+    /** Actual data in this table. */
+    protected readonly _data: Map<string, Item<T>>;
+    /** Times data was last updated. */
+    protected readonly _times: Map<string, number>;
+    /** Deferred sequence of next values. */
+    readonly _changed: DeferredSequence<void>;
+    getItemTime(id: string): number | undefined;
+    getItem(id: string): OptionalItem<T>;
+    getItemSequence(id: string): AsyncIterable<OptionalItem<T>>;
+    getCachedItemSequence(id: string): AsyncIterable<OptionalItem<T>>;
+    addItem(data: T): string;
+    setItem(id: string, data: Item<T> | T): void;
+    setItemSequence(id: string, sequence: AsyncIterable<OptionalItem<T>>): AsyncIterable<OptionalItem<T>>;
+    updateItem(id: string, updates: Updates<T>): void;
+    deleteItem(id: string): void;
+    getQueryTime(query?: ItemQuery<T>): number | undefined;
+    countQuery(query?: ItemQuery<T>): number;
+    getQuery(query?: ItemQuery<T>): Items<T>;
+    getQuerySequence(query?: ItemQuery<T>): AsyncIterable<Items<T>>;
+    getCachedQuerySequence(query?: ItemQuery<T>): AsyncIterable<Items<T>>;
+    setQuery(query: ItemQuery<T>, data: T): void;
+    updateQuery(query: ItemQuery<T>, updates: Updates<T>): void;
+    deleteQuery(query: ItemQuery<T>): void;
+    setItems(items: Items<T>, query?: ItemQuery<T>): void;
+    setItemsSequence(sequence: AsyncIterable<Items<T>>, query?: ItemQuery<T>): AsyncIterable<Items<T>>;
+}