shelving 1.181.2 → 1.182.0

package/db/provider/SQLProvider.d.ts

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../../util/array.js";
 import type { Data, DataPath } from "../../util/data.js";
-import type { Items, OptionalItem } from "../../util/item.js";
-import { type ItemQuery, type QueryFilter, type QueryOrder } from "../../util/query.js";
+import type { Identifier, Item, Items, OptionalItem } from "../../util/item.js";
+import { type Query, type QueryFilter, type QueryOrder } from "../../util/query.js";
 import { type Update, type Updates } from "../../util/update.js";
 import type { Collection } from "../collection/Collection.js";
 import { DBProvider } from "./DBProvider.js";
@@ -11,20 +11,20 @@ export interface SQLFragment {
     readonly values: ImmutableArray<unknown>;
 }
 /** Shared SQL execution and CRUD/query behavior. */
-export declare abstract class SQLProvider extends DBProvider<number> {
-    abstract exec<T extends Data = Data>(strings: TemplateStringsArray, ...values: ImmutableArray<unknown>): Promise<ImmutableArray<T>>;
-    getItem<T extends Data>({ name }: Collection<string, number, T>, id: number): Promise<OptionalItem<number, T>>;
-    getItemSequence<T extends Data>(_collection: Collection<string, number, T>, _id: number): AsyncIterable<OptionalItem<number, T>>;
-    addItem<T extends Data>({ name }: Collection<string, number, T>, data: T): Promise<number>;
-    setItem<T extends Data>({ name }: Collection<string, number, T>, id: number, data: T): Promise<void>;
-    updateItem<T extends Data>({ name }: Collection<string, number, T>, id: number, updates: Updates<T>): Promise<void>;
-    deleteItem<T extends Data>({ name }: Collection<string, number, T>, id: number): Promise<void>;
-    countQuery<T extends Data>({ name }: Collection<string, number, T>, query?: ItemQuery<number, T>): Promise<number>;
-    getQuery<T extends Data>({ name }: Collection<string, number, T>, query?: ItemQuery<number, T>): Promise<Items<number, T>>;
-    getQuerySequence<T extends Data>(_c: Collection<string, number, T>, _q?: ItemQuery<number, T>): AsyncIterable<Items<number, T>>;
-    setQuery<T extends Data>({ name }: Collection<string, number, T>, query: ItemQuery<number, T>, data: T): Promise<void>;
-    updateQuery<T extends Data>({ name }: Collection<string, number, T>, query: ItemQuery<number, T>, updates: Updates<T>): Promise<void>;
-    deleteQuery<T extends Data>({ name }: Collection<string, number, T>, query: ItemQuery<number, T>): Promise<void>;
+export declare abstract class SQLProvider<I extends Identifier = Identifier, T extends Data = Data> extends DBProvider<I, T> {
+    abstract exec<X extends Data>(strings: TemplateStringsArray, ...values: ImmutableArray<unknown>): Promise<ImmutableArray<X>>;
+    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>;
     /**
      * Define an SQL fragment using Javascript template literal format.
      * @example this.sql`SELECT * FROM ${table}`; // SQLFragment
@@ -37,9 +37,9 @@ export declare abstract class SQLProvider extends DBProvider<number> {
     /** Define an SQL fragment to generate a series of values with a separator, e.g. `"a" = 1 AND "b" = 2` */
     sqlConcat(values: ImmutableArray<SQLFragment>, separator?: string, before?: string, after?: string): SQLFragment;
     /** Define an SQL fragment for setting a list of values, e.g. `"a" = 1, "b" = 2` */
-    sqlSetters<T extends Data>(data: T): SQLFragment;
+    sqlSetters<TT extends Data>(data: TT): SQLFragment;
     /** Define an SQL fragment for updates, e.g. `"a" = 1, "b" = "b" + 5` */
-    sqlUpdates<T extends Data>(updates: Updates<T>): SQLFragment;
+    sqlUpdates<TT extends Data>(updates: Updates<TT>): SQLFragment;
     /**
      * Define an SQL fragment for a single update action.
      * - Handles flat `set` and `sum` only (single-segment key).
@@ -48,11 +48,11 @@ export declare abstract class SQLProvider extends DBProvider<number> {
      */
     sqlUpdate({ action, key, value }: Update): SQLFragment;
     /** Define an SQL fragment for `VALUES` syntax, e.g. `("a", "b") VALUES (1, 2)` */
-    sqlValues<T extends Data>(data: T): SQLFragment;
+    sqlValues(data: Data): SQLFragment;
     /** Define an SQL for the `WHERE`, `ORDER BY` and `LIMIT` clauses of an SQL query, e.g. e.g. ` WHERE x = 1 ORDER BY "name" LIMIT 0, 50` */
-    sqlClauses<T extends Data>(query: ItemQuery<number, T>): SQLFragment;
+    sqlClauses(query: Query<Item>): SQLFragment;
     /** Define an SQL fragment for a `WHERE` clause, e.g. ` WHERE x = 1 AND y <= 100` */
-    sqlWhere<T extends Data>(query: ItemQuery<number, T>): SQLFragment;
+    sqlWhere(query: Query<Item>): SQLFragment;
     /**
      * Define an SQL fragment for a filter clause on a column.
      */
@@ -61,9 +61,9 @@ export declare abstract class SQLProvider extends DBProvider<number> {
      * Define an SQL fragment for an `ORDER BY` clause, e.g. ` ORDER BY "a" ASC, "b" DESC`
      * - Nested keys (multi-segment) throw `UnimplementedError`.
      */
-    sqlOrder<T extends Data>(query: ItemQuery<number, T>): SQLFragment;
+    sqlOrder(query: Query<Item>): SQLFragment;
     /** Define an SQL fragment for an individual column in an `ORDER BY`, e.g. `"a" ASC` */
     sqlSort({ key, direction }: QueryOrder): SQLFragment;
     /** Define an SQL fragment for an `LIMIT` clause, e.g. ` LIMIT 50, 100` */
-    sqlLimit<T extends Data>(query: ItemQuery<number, T>): SQLFragment;
+    sqlLimit(query: Query<Item>): SQLFragment;
 }

package/db/provider/SQLProvider.js

@@ -1,13 +1,13 @@
+import { RequiredError } from "../../error/RequiredError.js";
 import { UnimplementedError } from "../../error/UnimplementedError.js";
-import { assertNumber } from "../../util/number.js";
 import { getQueryFilters, getQueryLimit, getQueryOrders } from "../../util/query.js";
 import { getUpdates } from "../../util/update.js";
 import { DBProvider } from "./DBProvider.js";
 /** Shared SQL execution and CRUD/query behavior. */
 export class SQLProvider extends DBProvider {
-    async getItem({ name }, id) {
+    async getItem(collection, id) {
         const rows = await this.exec `
-			SELECT * FROM ${this.sqlIdentifier(name)}
+			SELECT * FROM ${this.sqlIdentifier(collection.name)}
 			WHERE ${this.sqlIdentifier("id")} = ${id}
 			LIMIT 1
 		`;
@@ -16,55 +16,56 @@ export class SQLProvider extends DBProvider {
     getItemSequence(_collection, _id) {
         throw new UnimplementedError(`SQLProvider does not support realtime subscriptions`);
     }
-    async addItem({ name }, data) {
+    async addItem(collection, data) {
         const rows = await this.exec `
-			INSERT INTO ${this.sqlIdentifier(name)} ${this.sqlValues(data)}
+			INSERT INTO ${this.sqlIdentifier(collection.name)} ${this.sqlValues(data)}
 			RETURNING ${this.sqlIdentifier("id")}
 		`;
         const id = rows[0]?.id;
-        assertNumber(id);
+        if (id === undefined)
+            throw new RequiredError(`No id returned from INSERT into "${collection.name}"`, { provider: this });
         return id;
     }
-    async setItem({ name }, id, data) {
+    async setItem(collection, id, data) {
         await this.exec `
-			INSERT INTO ${this.sqlIdentifier(name)} ${this.sqlValues({ id, ...data })}
+			INSERT INTO ${this.sqlIdentifier(collection.name)} ${this.sqlValues({ id, ...data })}
 			ON CONFLICT (${this.sqlIdentifier("id")}) DO UPDATE SET ${this.sqlSetters(data)}
 		`;
     }
-    async updateItem({ name }, id, updates) {
+    async updateItem(collection, id, updates) {
         await this.exec `
-			UPDATE ${this.sqlIdentifier(name)}
+			UPDATE ${this.sqlIdentifier(collection.name)}
 			SET ${this.sqlUpdates(updates)}
 			WHERE ${this.sqlIdentifier("id")} = ${id}
 		`;
     }
-    async deleteItem({ name }, id) {
-        await this.exec `DELETE FROM ${this.sqlIdentifier(name)} WHERE ${this.sqlIdentifier("id")} = ${id}`;
+    async deleteItem(collection, id) {
+        await this.exec `DELETE FROM ${this.sqlIdentifier(collection.name)} WHERE ${this.sqlIdentifier("id")} = ${id}`;
     }
-    async countQuery({ name }, query) {
+    async countQuery(collection, query) {
         const rows = await this.exec `
-			SELECT COUNT(*) AS "count" FROM ${this.sqlIdentifier(name)}
+			SELECT COUNT(*) AS "count" FROM ${this.sqlIdentifier(collection.name)}
 			${query ? this.sqlClauses(query) : this.sql ``}
 		`;
         return rows[0]?.count ?? 0;
     }
-    async getQuery({ name }, query) {
+    async getQuery(collection, query) {
         return this.exec `
-			SELECT * FROM ${this.sqlIdentifier(name)}
+			SELECT * FROM ${this.sqlIdentifier(collection.name)}
 			${query ? this.sqlClauses(query) : this.sql ``}
 		`;
     }
-    getQuerySequence(_c, _q) {
+    getQuerySequence(_collection, _query) {
         throw new UnimplementedError(`SQLProvider does not support realtime subscriptions`);
     }
-    async setQuery({ name }, query, data) {
-        await this.exec `UPDATE ${this.sqlIdentifier(name)} SET ${this.sqlSetters(data)}${this.sqlClauses(query)}`;
+    async setQuery(collection, query, data) {
+        await this.exec `UPDATE ${this.sqlIdentifier(collection.name)} SET ${this.sqlSetters(data)}${this.sqlClauses(query)}`;
     }
-    async updateQuery({ name }, query, updates) {
-        await this.exec `UPDATE ${this.sqlIdentifier(name)} SET ${this.sqlUpdates(updates)}${this.sqlClauses(query)}`;
+    async updateQuery(collection, query, updates) {
+        await this.exec `UPDATE ${this.sqlIdentifier(collection.name)} SET ${this.sqlUpdates(updates)}${this.sqlClauses(query)}`;
     }
-    async deleteQuery({ name }, query) {
-        await this.exec `DELETE FROM ${this.sqlIdentifier(name)}${this.sqlClauses(query)}`;
+    async deleteQuery(collection, query) {
+        await this.exec `DELETE FROM ${this.sqlIdentifier(collection.name)}${this.sqlClauses(query)}`;
     }
     /**
      * Define an SQL fragment using Javascript template literal format.

package/db/provider/SQLiteProvider.d.ts

@@ -1,6 +1,8 @@
-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 { Collection } from "../collection/Collection.js";
 import { type SQLFragment, SQLProvider } from "./SQLProvider.js";
 /**
  * Abstract SQLite provider with JSON1 function support for nested keys, array containment, and array mutations.
@@ -9,9 +11,11 @@ import { type SQLFragment, SQLProvider } from "./SQLProvider.js";
  * - For `with` and `omit` updates this does not preserve ordering of the original array.
  * - For `with` and `omit` updates this does not guarantee equality for de-duplication when working with nested objects or arrays.
  */
-export declare abstract class SQLiteProvider extends SQLProvider {
+export declare abstract class SQLiteProvider<I extends Identifier = Identifier, T extends Data = Data> extends SQLProvider<I, T> {
+    addItem<II extends I, TT extends T>(collection: Collection<string, II, TT>, data: TT): Promise<II>;
     /** Get the SQLite JSON path for the nested segments of a key (everything after the column name), e.g. `$.b.c` */
     private sqlPath;
+    /** Get the SQLite JSON extract syntax, e.g. `json_extract("a", $.b.c)` */
     sqlExtract(key: DataPath): SQLFragment;
     sqlUpdate(update: Update): SQLFragment;
     sqlFilter(filter: QueryFilter): SQLFragment;

package/db/provider/SQLiteProvider.js

@@ -1,3 +1,4 @@
+import { StringSchema } from "../../schema/StringSchema.js";
 import { SQLProvider } from "./SQLProvider.js";
 /**
  * Abstract SQLite provider with JSON1 function support for nested keys, array containment, and array mutations.
@@ -7,11 +8,23 @@ import { SQLProvider } from "./SQLProvider.js";
  * - For `with` and `omit` updates this does not guarantee equality for de-duplication when working with nested objects or arrays.
  */
 export class SQLiteProvider extends SQLProvider {
+    // Override `addItem` to support string (UUID) IDs in SQLite.
+    // SQLite has no native UUID generation, so when the collection uses a `StringSchema` ID
+    // we generate the UUID client-side and delegate to `setItem`.
+    // Note: `as II` is required here because TypeScript cannot narrow the generic `II` from `instanceof StringSchema`.
+    async addItem(collection, data) {
+        if (collection.id instanceof StringSchema) {
+            const id = crypto.randomUUID(); // `as II` needed: TypeScript can't narrow II from instanceof check.
+            await this.setItem(collection, id, data);
+            return id;
+        }
+        return super.addItem(collection, data);
+    }
     /** Get the SQLite JSON path for the nested segments of a key (everything after the column name), e.g. `$.b.c` */
     sqlPath(key) {
         return this.sqlConcat(key.slice(1).map(k => this.sqlIdentifier(k)), ".", "$.");
     }
-    // Override to support nested JSON extract syntax, e.g. `json_extract("a", $.b.c)`
+    /** Get the SQLite JSON extract syntax, e.g. `json_extract("a", $.b.c)` */
     sqlExtract(key) {
         const column = this.sqlIdentifier(key[0]);
         if (key.length > 1) {

package/db/provider/ThroughDBProvider.d.ts

@@ -1,27 +1,27 @@
 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 { Sourceable } from "../../util/source.js";
 import type { Updates } from "../../util/update.js";
 import type { Collection } from "../collection/Collection.js";
 import type { DBProvider } from "./DBProvider.js";
 /** A provider that passes through to an asynchronous source. */
-export declare class ThroughDBProvider<I extends Identifier = Identifier> implements DBProvider<I>, Sourceable<DBProvider<I>> {
-    readonly source: DBProvider<I>;
-    constructor(source: DBProvider<I>);
-    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>>;
-    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>;
-    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 class ThroughDBProvider<I extends Identifier, T extends Data> implements DBProvider<I, T>, Sourceable<DBProvider<I, T>> {
+    readonly source: DBProvider<I, T>;
+    constructor(source: DBProvider<I, T>);
+    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>>;
+    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>;
+    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/ValidationDBProvider.d.ts

@@ -1,20 +1,20 @@
 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";
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
-export declare class ValidationDBProvider<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): 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>;
-    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 ValidationDBProvider<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): 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>;
+    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/ValidationDBProvider.js

@@ -53,8 +53,7 @@ function _validateIdentifier(collection, id, caller) {
         throw new ValueError(`Invalid identifier for "${collection}"\n${thrown}`, { received: id, caller });
     }
 }
-function _validateItem(collection, //
-item, caller) {
+function _validateItem(collection, item, caller) {
     if (!item)
         return undefined;
     try {
@@ -70,12 +69,10 @@ item, caller) {
  * Validate a set of entities for this query reference.
  * @throws `ValueError` if one or more items did not validate (conflict because the program is not in an expected state).
  */
-function _validateItems(collection, //
-items, caller) {
+function _validateItems(collection, items, caller) {
     return Array.from(_yieldValidItems(collection, items, caller));
 }
-function* _yieldValidItems(collection, //
-items, caller) {
+function* _yieldValidItems(collection, items, caller) {
     const messages = [];
     for (const item of items) {
         try {
@@ -90,8 +87,7 @@ items, caller) {
     if (messages.length)
         throw new ValueError(`Invalid data for "${collection}"\n${messages.join("\n")}`, { received: items, caller });
 }
-function _validateUpdates(collection, //
-updates, caller) {
+function _validateUpdates(collection, updates, caller) {
     try {
         return PARTIAL(collection).validate(updates);
     }

package/db/store/QueryStore.d.ts

@@ -2,7 +2,7 @@ import { ArrayStore } from "../../store/ArrayStore.js";
 import { BooleanStore } from "../../store/BooleanStore.js";
 import type { Data } from "../../util/data.js";
 import type { Identifier, Item } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.js";
+import { type Query } from "../../util/query.js";
 import type { StopCallback } from "../../util/start.js";
 import type { Collection } from "../collection/Collection.js";
 import type { DBProvider } from "../provider/DBProvider.js";
@@ -11,7 +11,7 @@ import type { MemoryDBProvider } from "../provider/MemoryDBProvider.js";
 export declare class QueryStore<I extends Identifier, T extends Data> extends ArrayStore<Item<I, T>> {
     readonly provider: DBProvider<I>;
     readonly collection: Collection<string, I, T>;
-    readonly query: ItemQuery<I, T>;
+    readonly query: Query<Item<I, T>>;
     readonly busy: BooleanStore;
     readonly limit: number;
     /** Can more items be loaded after the current result. */
@@ -21,7 +21,7 @@ export declare class QueryStore<I extends Identifier, T extends Data> extends Ar
     get first(): Item<I, T>;
     /** Get the last item in this store. */
     get last(): Item<I, T>;
-    constructor(collection: Collection<string, I, T>, query: ItemQuery<I, T>, provider: DBProvider<I>, memory?: MemoryDBProvider<I>);
+    constructor(collection: Collection<string, I, T>, query: Query<Item<I, T>>, provider: DBProvider<I>, memory?: MemoryDBProvider<I>);
     /** Refresh this store from the source provider. */
     refresh(provider?: DBProvider<I>): void;
     private _refresh;

package/firestore/client/FirestoreClientProvider.d.ts

@@ -2,8 +2,8 @@ import type { Firestore } from "firebase/firestore";
 import type { Collection } from "../../db/collection/Collection.js";
 import { DBProvider } from "../../db/provider/DBProvider.js";
 import type { Data } from "../../util/data.js";
-import type { Items, OptionalItem } from "../../util/item.js";
-import type { ItemQuery } from "../../util/query.js";
+import type { Item, Items, OptionalItem } from "../../util/item.js";
+import { type Query } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";
 /**
  * Firestore client database provider.
@@ -11,19 +11,25 @@ import type { Updates } from "../../util/update.js";
  * - Supports offline mode.
  * - Supports realtime subscriptions.
  */
-export declare class FirestoreClientProvider extends DBProvider<string> {
+export declare class FirestoreClientProvider<I extends string = string, T extends Data = Data> extends DBProvider<I, T> {
     private readonly _firestore;
     constructor(firestore: Firestore);
-    getItem<T extends Data>({ name }: Collection<string, string, T>, id: string): Promise<OptionalItem<string, T>>;
-    getItemSequence<T extends Data>({ name }: Collection<string, string, T>, id: string): AsyncIterable<OptionalItem<string, T>>;
-    addItem<T extends Data>({ name }: Collection<string, string, T>, data: T): Promise<string>;
-    setItem<T extends Data>({ name }: Collection<string, string, T>, id: string, data: T): Promise<void>;
-    updateItem<T extends Data>({ name }: Collection<string, string, T>, id: string, updates: Updates<T>): Promise<void>;
-    deleteItem<T extends Data>({ name }: Collection<string, string, T>, id: string): Promise<void>;
-    countQuery<T extends Data>({ name }: Collection<string, string, T>, q?: ItemQuery<string, T>): Promise<number>;
-    getQuery<T extends Data>({ name }: Collection<string, string, T>, q?: ItemQuery<string, T>): Promise<Items<string, T>>;
-    getQuerySequence<T extends Data>({ name }: Collection<string, string, T>, q?: ItemQuery<string, T>): AsyncIterable<Items<string, T>>;
-    setQuery<T extends Data>({ name }: Collection<string, string, T>, q: ItemQuery<string, T>, data: T): Promise<void>;
-    updateQuery<T extends Data>({ name }: Collection<string, string, T>, q: ItemQuery<string, T>, updates: Updates<T>): Promise<void>;
-    deleteQuery<T extends Data>({ name }: Collection<string, string, T>, q: ItemQuery<string, T>): Promise<void>;
+    /** Get a Firestore CollectionReference for a given collection. */
+    private _collection;
+    /** Get a Firestore DocumentReference for a given document. */
+    private _doc;
+    /** Get a Firestore QueryReference for a given query. */
+    private _query;
+    getItem<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II): Promise<OptionalItem<II, TT>>;
+    getItemSequence<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II): AsyncIterable<OptionalItem<II, TT>>;
+    addItem<II extends I, TT extends T>(c: Collection<string, II, TT>, data: TT): Promise<II>;
+    setItem<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II, data: TT): Promise<void>;
+    updateItem<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II, updates: Updates<Item<II, TT>>): Promise<void>;
+    deleteItem<II extends I, TT extends T>(c: Collection<string, II, TT>, id: II): Promise<void>;
+    countQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q?: Query<Item<II, TT>>): Promise<number>;
+    getQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q?: Query<Item<II, TT>>): Promise<Items<II, TT>>;
+    getQuerySequence<II extends I, TT extends T>(c: Collection<string, II, TT>, q?: Query<Item<II, TT>>): AsyncIterable<Items<II, TT>>;
+    setQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q: Query<Item<II, TT>>, data: TT): Promise<void>;
+    updateQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q: Query<Item<II, TT>>, updates: Updates<TT>): Promise<void>;
+    deleteQuery<II extends I, TT extends T>(c: Collection<string, II, TT>, q: Query<Item<II, TT>>): Promise<void>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -21,10 +21,6 @@ const OPERATORS = {
     lt: "<",
     lte: "<=",
 };
-/** Get a Firestore QueryReference for a given query. */
-function _getQuery(firestore, c, q) {
-    return q ? query(collection(firestore, c), ..._getConstraints(q)) : collection(firestore, c);
-}
 function* _getConstraints(q) {
     for (const { key, direction } of getQueryOrders(q)) {
         const k = joinDataKey(key);
@@ -39,16 +35,15 @@ function* _getConstraints(q) {
         yield limit(l);
 }
 function _getItems(snapshot) {
-    return snapshot.docs.map(_getItem);
+    return snapshot.docs.map(s => _getItem(s));
 }
 function _getItem(snapshot) {
-    const data = snapshot.data();
-    return getItem(snapshot.id, data);
+    return getItem(snapshot.id, snapshot.data()); // `as II` needed: Firestore snapshot.id is always string, not II.
 }
 function _getOptionalItem(snapshot) {
     const data = snapshot.data();
     if (data)
-        return getItem(snapshot.id, data);
+        return getItem(snapshot.id, data); // `as II` needed: Firestore snapshot.id is always string, not II.
 }
 /** Convert `Updates` object into corresponding Firestore `FieldValue` instances. */
 function _getFieldValues(updates) {
@@ -78,51 +73,59 @@ export class FirestoreClientProvider extends DBProvider {
         super();
         this._firestore = firestore;
     }
-    async getItem({ name }, id) {
-        const snapshot = await getDoc(doc(this._firestore, name, id));
+    /** Get a Firestore CollectionReference for a given collection. */
+    _collection({ name }) {
+        return collection(this._firestore, name);
+    }
+    /** Get a Firestore DocumentReference for a given document. */
+    _doc(c, id) {
+        return doc(this._collection(c), id);
+    }
+    /** Get a Firestore QueryReference for a given query. */
+    _query(c, q) {
+        return q ? query(this._collection(c), ..._getConstraints(q)) : this._collection(c);
+    }
+    async getItem(c, id) {
+        const snapshot = await getDoc(this._doc(c, id));
         return _getOptionalItem(snapshot);
     }
-    getItemSequence({ name }, id) {
-        return new LazyDeferredSequence(sequence => onSnapshot(doc(this._firestore, name, id), //
-        //
-        snapshot => sequence.resolve(_getOptionalItem(snapshot)), reason => sequence.reject(reason)));
+    getItemSequence(c, id) {
+        return new LazyDeferredSequence(sequence => onSnapshot(this._doc(c, id), snapshot => sequence.resolve(_getOptionalItem(snapshot)), reason => sequence.reject(reason)));
     }
-    async addItem({ name }, data) {
-        const reference = await addDoc(collection(this._firestore, name), data);
-        return reference.id;
+    async addItem(c, data) {
+        const reference = await addDoc(this._collection(c), data);
+        return reference.id; // `as II` needed: Firestore returns string, not II.
     }
-    async setItem({ name }, id, data) {
-        await setDoc(doc(this._firestore, name, id), data);
+    async setItem(c, id, data) {
+        await setDoc(this._doc(c, id), data);
     }
-    async updateItem({ name }, id, updates) {
-        await updateDoc(doc(this._firestore, name, id), _getFieldValues(updates));
+    async updateItem(c, id, updates) {
+        await updateDoc(this._doc(c, id), _getFieldValues(updates));
     }
-    async deleteItem({ name }, id) {
-        await deleteDoc(doc(this._firestore, name, id));
+    async deleteItem(c, id) {
+        await deleteDoc(this._doc(c, id));
     }
-    async countQuery({ name }, q) {
-        const snapshot = await getCountFromServer(_getQuery(this._firestore, name, q));
+    async countQuery(c, q) {
+        const snapshot = await getCountFromServer(this._query(c, q));
         return snapshot.data().count;
     }
-    async getQuery({ name }, q) {
-        return _getItems(await getDocs(_getQuery(this._firestore, name, q)));
+    async getQuery(c, q) {
+        return _getItems(await getDocs(this._query(c, q)));
     }
-    getQuerySequence({ name }, q) {
-        return new LazyDeferredSequence(sequence => onSnapshot(_getQuery(this._firestore, name, q), //
-        //
-        snapshot => sequence.resolve(_getItems(snapshot)), reason => sequence.reject(reason)));
+    getQuerySequence(c, q) {
+        return new LazyDeferredSequence(sequence => onSnapshot(this._query(c, q), snapshot => sequence.resolve(_getItems(snapshot)), reason => sequence.reject(reason)));
     }
-    async setQuery({ name }, q, data) {
-        const snapshot = await getDocs(_getQuery(this._firestore, name, q));
+    async setQuery(c, q, data) {
+        const snapshot = await getDocs(this._query(c, q));
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
     }
-    async updateQuery({ name }, q, updates) {
-        const snapshot = await getDocs(_getQuery(this._firestore, name, q));
+    async updateQuery(c, q, updates) {
+        const snapshot = await getDocs(this._query(c, q));
         const fieldValues = _getFieldValues(updates);
         await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
     }
-    async deleteQuery({ name }, q) {
-        const snapshot = await getDocs(_getQuery(this._firestore, name, q));
+    async deleteQuery(c, q) {
+        const snapshot = await getDocs(this._query(c, q));
         await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
     }
 }