shelving 1.181.2 → 1.182.0

package/db/cache/DBCache.d.ts

@@ -0,0 +1,38 @@
+import type { Data } from "../../util/data.js";
+import type { Identifier, Item } from "../../util/item.js";
+import type { Query } from "../../util/query.js";
+import type { Collection } from "../collection/Collection.js";
+import type { DBProvider } from "../provider/DBProvider.js";
+import type { MemoryDBProvider } from "../provider/MemoryDBProvider.js";
+import type { ItemStore } from "../store/ItemStore.js";
+import type { QueryStore } from "../store/QueryStore.js";
+import { CollectionCache } from "./CollectionCache.js";
+/**
+ * Cache of `CollectionCache` objects for multiple collections.
+ * - Use `get(collection)` to retrieve or create the `CollectionCache` for a given collection,
+ *   then `getItem(id)` / `getQuery(query)` on that to get a specific store.
+ */
+export declare class DBCache<I extends Identifier = Identifier, T extends Data = Data> implements Disposable {
+    private readonly _caches;
+    readonly provider: DBProvider<I, T>;
+    readonly memory: MemoryDBProvider<I, T> | undefined;
+    constructor(provider: DBProvider<I, T>);
+    private _get;
+    /** Get (or create) the `CollectionCache` for the given collection. */
+    get<II extends I, TT extends T>(collection: Collection<string, II, TT>): CollectionCache<II, TT>;
+    /** Get (or create) an `ItemStore` for a collection/id in one hop. */
+    getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): ItemStore<II, TT>;
+    /** Get (or create) a `QueryStore` for a collection/query in one hop. */
+    getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): QueryStore<II, TT>;
+    /** Refresh a specific item store for a collection. */
+    refreshItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): void;
+    /** Refresh every cached item store for a collection. */
+    refreshItems<II extends I, TT extends T>(collection: Collection<string, II, TT>): void;
+    /** Refresh a specific query store for a collection. */
+    refreshQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): void;
+    /** Refresh every cached query store for a collection. */
+    refreshQueries<II extends I, TT extends T>(collection: Collection<string, II, TT>): void;
+    /** Refresh every cached store (items and queries) for a collection. */
+    refreshAll<II extends I, TT extends T>(collection: Collection<string, II, TT>): void;
+    [Symbol.dispose](): void;
+}

package/db/cache/DBCache.js

@@ -0,0 +1,59 @@
+import { setMapItem } from "../../util/map.js";
+import { getSource } from "../../util/source.js";
+import { CacheDBProvider } from "../provider/CacheDBProvider.js";
+import { CollectionCache } from "./CollectionCache.js";
+/**
+ * Cache of `CollectionCache` objects for multiple collections.
+ * - Use `get(collection)` to retrieve or create the `CollectionCache` for a given collection,
+ *   then `getItem(id)` / `getQuery(query)` on that to get a specific store.
+ */
+export class DBCache {
+    _caches = new Map();
+    provider;
+    memory;
+    constructor(provider) {
+        this.provider = provider;
+        // If the provider chain contains a `CacheDBProvider`, reuse its memory so we can seed stores synchronously.
+        this.memory = getSource(CacheDBProvider, provider)?.memory;
+    }
+    _get(collection) {
+        return this._caches.get(collection);
+    }
+    get(collection) {
+        return this._get(collection) || setMapItem(this._caches, collection, new CollectionCache(collection, this.provider, this.memory));
+    }
+    /** Get (or create) an `ItemStore` for a collection/id in one hop. */
+    getItem(collection, id) {
+        return this.get(collection).getItem(id);
+    }
+    /** Get (or create) a `QueryStore` for a collection/query in one hop. */
+    getQuery(collection, query) {
+        return this.get(collection).getQuery(query);
+    }
+    /** Refresh a specific item store for a collection. */
+    refreshItem(collection, id) {
+        this._get(collection)?.refreshItem(id);
+    }
+    /** Refresh every cached item store for a collection. */
+    refreshItems(collection) {
+        this._get(collection)?.refreshItems();
+    }
+    /** Refresh a specific query store for a collection. */
+    refreshQuery(collection, query) {
+        this._get(collection)?.refreshQuery(query);
+    }
+    /** Refresh every cached query store for a collection. */
+    refreshQueries(collection) {
+        this._get(collection)?.refreshQueries();
+    }
+    /** Refresh every cached store (items and queries) for a collection. */
+    refreshAll(collection) {
+        this._get(collection)?.refreshAll();
+    }
+    // Implement Disposable.
+    [Symbol.dispose]() {
+        for (const cache of this._caches.values())
+            cache[Symbol.dispose]();
+        this._caches.clear();
+    }
+}

package/db/collection/Collection.d.ts

@@ -3,11 +3,11 @@ import { NumberSchema } from "../../schema/NumberSchema.js";
 import type { Schema, Schemas } from "../../schema/Schema.js";
 import type { ImmutableArray } from "../../util/array.js";
 import type { Data } from "../../util/data.js";
-import type { Identifier, Item } from "../../util/item.js";
+import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
 /** Default identifier schema (integer). */
 export declare const ID: NumberSchema;
 /** Declarative definition of a database collection/table. */
-export declare class Collection<N extends string, I extends Identifier, T extends Data> extends DataSchema<T> {
+export declare class Collection<N extends string = string, I extends Identifier = Identifier, T extends Data = Data> extends DataSchema<T> {
     /** Collection name (used as the table/collection key). */
     readonly name: N;
     /** Schema for the identifier type. */
@@ -18,18 +18,20 @@ export declare class Collection<N extends string, I extends Identifier, T extend
 }
 /** Shortcut factory for creating a Collection. */
 export declare function COLLECTION<K extends string, I extends Identifier, T extends Data>(name: K, id: Schema<I>, data: Schemas<T> | DataSchema<T>): Collection<K, I, T>;
-/** Any collection object, possibly with a standardised `Identifier` type. */
-export type AnyCollection<I extends Identifier = Identifier> = Collection<string, I, Data>;
 /** Extract the string name from a `Collection` instance. */
-export type CollectionName<C extends AnyCollection> = C extends Collection<infer N, infer _I, infer _T> ? N : never;
+export type CollectionName<C extends Collection> = C extends Collection<infer N, infer _I, infer _T> ? N : never;
 /** Extract the `Identifier` type from a `Collection` instance. */
-export type CollectionIdentifier<C extends AnyCollection> = C extends Collection<infer _N, infer I, infer _T> ? I : never;
+export type CollectionIdentifier<C extends Collection> = C extends Collection<infer _N, infer I, infer _T> ? I : never;
 /** Extract the `Data` type from a `Collection` instance. */
-export type CollectionData<C extends AnyCollection> = C extends Collection<infer _N, infer _I, infer T> ? T : never;
+export type CollectionData<C extends Collection> = C extends Collection<infer _N, infer _I, infer T> ? T : never;
 /** Extract the `Item` type from a `Collection` instance. */
-export type CollectionItem<C extends AnyCollection> = C extends Collection<infer _N, infer I, infer T> ? Item<I, T> : never;
-/** A readonly array of Collection instances, possibly with a standardised `Identifier` type. */
-export type Collections<I extends Identifier = Identifier> = ImmutableArray<AnyCollection<I>>;
+export type CollectionItem<C extends Collection> = Item<CollectionIdentifier<C>, CollectionData<C>>;
+/** Extract the optional (possibly undefined) `Item` type from a `Collection` instance. */
+export type OptionalCollectionItem<C extends Collection> = OptionalItem<CollectionIdentifier<C>, CollectionData<C>>;
+/** Extract the array of `Item` types from a `Collection` instance. */
+export type CollectionItems<C extends Collection> = Items<CollectionIdentifier<C>, CollectionData<C>>;
+/** A readonly array of Collection instances, possibly with a standardised `Identifier` and `Data` types. */
+export type Collections<I extends Identifier = Identifier, D extends Data = Data> = ImmutableArray<Collection<string, I, D>>;
 /** Extract the union of string collection names from a `Collections` type. */
 export type CollectionNames<C extends Collections> = C[number]["name"];
 /** Convert a `Collections` array type to a Database-style object mapping in `{ name: data }` format. */

package/db/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./cache/CollectionCache.js";
+export * from "./cache/DBCache.js";
 export * from "./collection/Collection.js";
 export * from "./migrate/DBMigrator.js";
 export * from "./migrate/PostgreSQLMigrator.js";

package/db/index.js

@@ -1,3 +1,5 @@
+export * from "./cache/CollectionCache.js";
+export * from "./cache/DBCache.js";
 export * from "./collection/Collection.js";
 export * from "./migrate/DBMigrator.js";
 export * from "./migrate/PostgreSQLMigrator.js";

package/db/provider/CacheDBProvider.d.ts

@@ -1,26 +1,26 @@
 import type { Data } from "../../util/data.js";
-import type { Identifier, Items, OptionalItem } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.js";
+import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
+import type { Query } from "../../util/query.js";
 import type { Sourceable } from "../../util/source.js";
 import type { Updates } from "../../util/update.js";
 import type { Collection } from "../collection/Collection.js";
 import { DBProvider } from "./DBProvider.js";
 import { MemoryDBProvider } from "./MemoryDBProvider.js";
 /** Keep a copy of asynchronous remote data in a local synchronous cache. */
-export declare class CacheDBProvider<I extends Identifier = Identifier> extends DBProvider<I> implements Sourceable<DBProvider<I>> {
-    readonly source: DBProvider<I>;
-    readonly memory: MemoryDBProvider<I>;
-    constructor(source: DBProvider<I>, cache?: MemoryDBProvider<I>);
-    getItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<OptionalItem<I, T>>;
-    getItemSequence<T extends Data>(collection: Collection<string, I, T>, id: I): AsyncIterable<OptionalItem<I, T>>;
-    addItem<T extends Data>(collection: Collection<string, I, T>, data: T): Promise<I>;
-    setItem<T extends Data>(collection: Collection<string, I, T>, id: I, data: T): Promise<void>;
-    updateItem<T extends Data>(collection: Collection<string, I, T>, id: I, updates: Updates<T>): Promise<void>;
-    deleteItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<void>;
-    countQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<number>;
-    getQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<Items<I, T>>;
-    getQuerySequence<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): AsyncIterable<Items<I, T>>;
-    setQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, updates: Updates<T>): Promise<void>;
-    deleteQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<void>;
+export declare class CacheDBProvider<I extends Identifier, T extends Data> extends DBProvider<I, T> implements Sourceable<DBProvider<I, T>> {
+    readonly source: DBProvider<I, T>;
+    readonly memory: MemoryDBProvider<I, T>;
+    constructor(source: DBProvider<I, T>, cache?: MemoryDBProvider<I, T>);
+    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): AsyncIterable<OptionalItem<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>>): AsyncIterable<Items<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>;
 }

package/db/provider/ChangesDBProvider.d.ts

@@ -1,12 +1,12 @@
 import type { MutableArray } from "../../util/array.js";
 import type { Data } from "../../util/data.js";
-import type { Identifier } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.js";
+import type { Identifier, Item } 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 { ThroughDBProvider } from "./ThroughDBProvider.js";
 /** A structured log entry for a database change. */
-export type DBChange<I extends Identifier = Identifier> = {
+export type DBChange<I extends Identifier> = {
     readonly action: "add" | "set" | "update" | "delete";
     readonly collection: string;
     readonly id?: I | undefined;
@@ -15,14 +15,14 @@ export type DBChange<I extends Identifier = Identifier> = {
     readonly updates?: unknown;
 };
 /** Asynchronous provider that keeps a log of any written changes to its `.changes` property. */
-export declare class ChangesDBProvider<I extends Identifier = Identifier> extends ThroughDBProvider<I> {
+export declare class ChangesDBProvider<I extends Identifier, T extends Data> extends ThroughDBProvider<I, T> {
     get changes(): ReadonlyArray<DBChange<I>>;
     readonly _changes: MutableArray<DBChange<I>>;
-    addItem<T extends Data>(collection: Collection<string, I, T>, data: T): Promise<I>;
-    setItem<T extends Data>(collection: Collection<string, I, T>, id: I, data: T): Promise<void>;
-    updateItem<T extends Data>(collection: Collection<string, I, T>, id: I, updates: Updates<T>): Promise<void>;
-    deleteItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<void>;
-    setQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, updates: Updates<T>): Promise<void>;
-    deleteQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<void>;
+    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>;
+    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>;
 }

package/db/provider/DBProvider.d.ts

@@ -1,23 +1,23 @@
 import type { Data } from "../../util/data.js";
 import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.js";
+import type { Query } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";
 import type { Collection } from "../collection/Collection.js";
 /** Provider with a fully asynchronous interface for database access. */
-export declare abstract class DBProvider<I extends Identifier = Identifier> {
-    abstract getItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<OptionalItem<I, T>>;
-    requireItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<Item<I, T>>;
-    abstract getItemSequence<T extends Data>(collection: Collection<string, I, T>, id: I): AsyncIterable<OptionalItem<I, T>>;
-    abstract addItem<T extends Data>(collection: Collection<string, I, T>, data: T): Promise<I>;
-    abstract setItem<T extends Data>(collection: Collection<string, I, T>, id: I, data: T): Promise<void>;
-    abstract updateItem<T extends Data>(collection: Collection<string, I, T>, id: I, updates: Updates<T>): Promise<void>;
-    abstract deleteItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<void>;
-    countQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<number>;
-    abstract getQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<Items<I, T>>;
-    abstract getQuerySequence<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): AsyncIterable<Items<I, T>>;
-    abstract setQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, data: T): Promise<void>;
-    abstract updateQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, updates: Updates<T>): Promise<void>;
-    abstract deleteQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<void>;
-    getFirst<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<OptionalItem<I, T>>;
-    requireFirst<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<Item<I, T>>;
+export declare abstract class DBProvider<I extends Identifier = Identifier, T extends Data = Data> {
+    abstract getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
+    requireItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<Item<II, TT>>;
+    abstract getItemSequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): AsyncIterable<OptionalItem<II, TT>>;
+    abstract addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
+    abstract setItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
+    abstract updateItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II, updates: Updates<Item<II, TT>>): Promise<void>;
+    abstract 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>;
+    abstract getQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
+    abstract getQuerySequence<II extends I, TT extends T>(collection: Collection<string, II, TT>, query?: Query<Item<II, TT>>): AsyncIterable<Items<II, TT>>;
+    abstract setQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, data: TT): Promise<void>;
+    abstract updateQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;
+    abstract deleteQuery<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<void>;
+    getFirst<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<OptionalItem<II, TT>>;
+    requireFirst<II extends I, TT extends T>(collection: Collection<string, II, TT>, query: Query<Item<II, TT>>): Promise<Item<II, TT>>;
 }

package/db/provider/DBProvider.js

@@ -7,7 +7,7 @@ export class DBProvider {
         if (!item)
             throw new RequiredError(`Item does not exist in collection "${collection.name}"`, {
                 provider: this,
-                collection: collection.name,
+                collection,
                 id,
                 caller: this.requireItem,
             });
@@ -24,7 +24,7 @@ export class DBProvider {
         if (!first)
             throw new RequiredError(`First item does not exist in collection "${collection.name}"`, {
                 provider: this,
-                collection: collection.name,
+                collection,
                 query,
                 caller: this.requireFirst,
             });

package/db/provider/DebugDBProvider.d.ts

@@ -1,21 +1,21 @@
 import type { Data } from "../../util/data.js";
-import type { Identifier, Items, OptionalItem } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.js";
+import type { Identifier, Item, Items, OptionalItem } 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 { ThroughDBProvider } from "./ThroughDBProvider.js";
 /** Provider that logs operations to the console. */
-export declare class DebugDBProvider<I extends Identifier = Identifier> extends ThroughDBProvider<I> {
-    getItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<OptionalItem<I, T>>;
-    getItemSequence<T extends Data>(collection: Collection<string, I, T>, id: I): AsyncIterableIterator<OptionalItem<I, T>>;
-    addItem<T extends Data>(collection: Collection<string, I, T>, data: T): Promise<I>;
-    setItem<T extends Data>(collection: Collection<string, I, T>, id: I, data: T): Promise<void>;
-    updateItem<T extends Data>(collection: Collection<string, I, T>, id: I, updates: Updates<T>): Promise<void>;
-    deleteItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<void>;
-    countQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<number>;
-    getQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<Items<I, T>>;
-    getQuerySequence<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): AsyncIterableIterator<Items<I, T>>;
-    setQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, updates: Updates<T>): Promise<void>;
-    deleteQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<void>;
+export declare class DebugDBProvider<I extends Identifier, T extends Data> extends ThroughDBProvider<I, T> {
+    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): AsyncIterableIterator<OptionalItem<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>>): AsyncIterableIterator<Items<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>;
 }

package/db/provider/MemoryDBProvider.d.ts

@@ -1,7 +1,7 @@
 import { DeferredSequence } from "../../sequence/DeferredSequence.js";
 import type { Data } from "../../util/data.js";
 import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.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";
@@ -10,31 +10,33 @@ import { DBProvider } from "./DBProvider.js";
  * - 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 MemoryDBProvider<I extends Identifier = Identifier> extends DBProvider<I> {
-    /** List of tables in `{ collection: Table }` format. */
+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<T extends Data>({ name }: Collection<string, I, T>): MemoryTable<I, T>;
-    getItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<OptionalItem<I, T>>;
-    getItemSequence<T extends Data>(collection: Collection<string, I, T>, id: I): AsyncIterable<OptionalItem<I, T>>;
-    addItem<T extends Data>(collection: Collection<string, I, T>, data: T): Promise<I>;
-    setItem<T extends Data>(collection: Collection<string, I, T>, id: I, data: T): Promise<void>;
-    updateItem<T extends Data>(collection: Collection<string, I, T>, id: I, updates: Updates<T>): Promise<void>;
-    deleteItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<void>;
-    countQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<number>;
-    getQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<Items<I, T>>;
-    getQuerySequence<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): AsyncIterable<Items<I, T>>;
-    setQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, updates: Updates<T>): Promise<void>;
-    deleteQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<void>;
-    setItems<T extends Data>(collection: Collection<string, I, T>, items: Items<I, T>): void;
+    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): AsyncIterable<OptionalItem<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>>): AsyncIterable<Items<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<Identifier, Item<I, T>>;
+    protected readonly _data: Map<I, Item<I, T>>;
     /** Deferred sequence of next values. */
     readonly next: DeferredSequence<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.
@@ -42,24 +44,24 @@ export declare class MemoryTable<I extends Identifier, T extends Data> {
      * - Wakes on every table change, but only yields when this item's value actually changed.
      */
     getItemSequence(id: I): AsyncIterable<OptionalItem<I, T>>;
-    /** Function to generate a random ID for this table. */
+    /** 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<T>): void;
+    updateItem(id: I, updates: Updates<Item<I, T>>): void;
     deleteItem(id: I): void;
-    countQuery(query?: ItemQuery<I, T>): number;
-    getQuery(query?: ItemQuery<I, T>): Items<I, T>;
+    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?: 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;
+    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>>;
 }

package/db/provider/MemoryDBProvider.js

@@ -1,3 +1,4 @@
+import { StringSchema } from "../../schema/StringSchema.js";
 import { DeferredSequence } from "../../sequence/DeferredSequence.js";
 import { requireArray } from "../../util/array.js";
 import { isArrayEqual } from "../../util/equal.js";
@@ -13,12 +14,11 @@ import { DBProvider } from "./DBProvider.js";
  * - `get()` etc return the exact same instance of an object that's passed into `set()`
  */
 export class MemoryDBProvider extends DBProvider {
-    /** List of tables in `{ collection: Table }` format. */
-    // biome-ignore lint/suspicious/noExplicitAny: Internal storage erases T; getTable<T> restores it per-call.
+    /** List of tables in `{ name: MemoryTable }` format. */
     _tables = {};
     /** Get a table for a collection. */
-    getTable({ name }) {
-        return (this._tables[name] ||= new MemoryTable());
+    getTable(collection) {
+        return (this._tables[collection.name] ||= new MemoryTable(collection));
     }
     async getItem(collection, id) {
         return this.getTable(collection).getItem(id);
@@ -66,6 +66,10 @@ export class MemoryTable {
     _data = new Map();
     /** Deferred sequence of next values. */
     next = new DeferredSequence();
+    collection;
+    constructor(collection) {
+        this.collection = collection;
+    }
     getItem(id) {
         return this._data.get(id);
     }
@@ -86,8 +90,9 @@ export class MemoryTable {
             }
         }
     }
+    /** Generate a unique ID for a new item in this table. */
     generateUniqueID() {
-        const gen = typeof this._data.keys().next().value === "number" ? getRandom : getRandomKey;
+        const gen = (this.collection.id instanceof StringSchema ? getRandomKey : getRandom);
         let id = gen();
         while (this._data.has(id))
             id = gen(); // Regenerate ID until unique.

package/db/provider/MockDBProvider.d.ts

@@ -1,30 +1,30 @@
 import type { Data } from "../../util/data.js";
-import type { Identifier, Items, OptionalItem } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.js";
+import type { Identifier, Item, Items, OptionalItem } 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 { MemoryDBProvider } from "./MemoryDBProvider.js";
 /** A structured log entry emitted by `MockDBProvider` for one of its provider operations. */
-export type MockDBCall<I extends Identifier = Identifier> = {
+export type MockDBCall = {
     readonly type: "getItem" | "addItem" | "setItem" | "updateItem" | "deleteItem" | "countQuery" | "getQuery" | "setQuery" | "updateQuery" | "deleteQuery";
     readonly collection: string;
-    readonly id?: I | undefined;
+    readonly id?: Identifier | undefined;
     readonly query?: unknown;
-    readonly data?: unknown;
+    readonly data?: Data;
     readonly updates?: unknown;
     readonly result?: unknown;
 };
 /** Provider that logs database operations for testing purposes. */
-export declare class MockDBProvider<I extends Identifier = Identifier> extends MemoryDBProvider<I> {
-    readonly calls: MockDBCall<I>[];
-    getItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<OptionalItem<I, T>>;
-    addItem<T extends Data>(collection: Collection<string, I, T>, data: T): Promise<I>;
-    setItem<T extends Data>(collection: Collection<string, I, T>, id: I, data: T): Promise<void>;
-    updateItem<T extends Data>(collection: Collection<string, I, T>, id: I, updates: Updates<T>): Promise<void>;
-    deleteItem<T extends Data>(collection: Collection<string, I, T>, id: I): Promise<void>;
-    countQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<number>;
-    getQuery<T extends Data>(collection: Collection<string, I, T>, query?: ItemQuery<I, T>): Promise<Items<I, T>>;
-    setQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>, updates: Updates<T>): Promise<void>;
-    deleteQuery<T extends Data>(collection: Collection<string, I, T>, query: ItemQuery<I, T>): Promise<void>;
+export declare class MockDBProvider<I extends Identifier = Identifier, T extends Data = Data> extends MemoryDBProvider<I, T> {
+    readonly calls: MockDBCall[];
+    getItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, id: II): Promise<OptionalItem<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>>;
+    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>;
 }

package/db/provider/PostgreSQLProvider.d.ts

@@ -1,11 +1,13 @@
-import type { DataPath } from "../../util/data.js";
+import type { Data, DataPath } from "../../util/data.js";
+import type { Identifier } from "../../util/item.js";
 import type { QueryFilter } from "../../util/query.js";
 import type { Update } from "../../util/update.js";
 import { type SQLFragment, SQLProvider } from "./SQLProvider.js";
 /** Abstract PostgreSQL provider with JSONB function support for nested keys, array containment, and array mutations. */
-export declare abstract class PostgreSQLProvider extends SQLProvider {
+export declare abstract class PostgreSQLProvider<I extends Identifier = Identifier, T extends Data = Data> extends SQLProvider<I, T> {
     /** Get the Postgres JSONB path for the nested segments of a key, e.g. `{"b","c"}`. */
     private sqlPath;
+    /** Get the Postgres JSONB extract syntax, e.g. `"a" #>> {"b","c"}` */
     sqlExtract(key: DataPath): SQLFragment;
     sqlUpdate(update: Update): SQLFragment;
     sqlFilter(filter: QueryFilter): SQLFragment;

package/db/provider/PostgreSQLProvider.js

@@ -5,7 +5,7 @@ export class PostgreSQLProvider extends SQLProvider {
     sqlPath(key) {
         return this.sqlConcat(key.slice(1).map(k => this.sqlIdentifier(k)), ",", "{", "}");
     }
-    // Override to support nested JSONB extract syntax, e.g. `"a" #>> {"b","c"}`
+    /** Get the Postgres JSONB extract syntax, e.g. `"a" #>> {"b","c"}` */
     sqlExtract(key) {
         const column = this.sqlIdentifier(key[0]);
         if (key.length > 1) {