shelving 1.150.15 → 1.151.0

package/db/Provider.d.ts

@@ -1,20 +1,21 @@
 import type { DataKey, Database } from "../util/data.js";
-import type { Item, ItemQuery, Items, OptionalItem } from "../util/item.js";
+import type { Identifier, Item, Items, OptionalItem } from "../util/item.js";
+import type { ItemQuery } from "../util/query.js";
 import type { Updates } from "../util/update.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
-export interface AbstractProvider<T extends Database> {
+export interface AbstractProvider<I extends Identifier, T extends Database> {
     /**
      * Get an item.
      */
-    getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]> | PromiseLike<OptionalItem<T[K]>>;
+    getItem<K extends DataKey<T>>(collection: K, id: I): OptionalItem<I, T[K]> | PromiseLike<OptionalItem<I, T[K]>>;
     /**
      * Require an item.
      */
-    requireItem<K extends DataKey<T>>(collection: K, id: string): Item<T[K]> | PromiseLike<Item<T[K]>>;
+    requireItem<K extends DataKey<T>>(collection: K, id: I): Item<I, T[K]> | PromiseLike<Item<I, T[K]>>;
     /**
      * Subscribe to the value of this item with an async iterator.
      */
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
     /**
      * Create a new item with a random ID.
      * - Created item is guaranteed to have a unique ID.
@@ -22,98 +23,98 @@ export interface AbstractProvider<T extends Database> {
      * @param data Complete data to set the item to.
      * @return String ID for the created item (possibly promised).
      */
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string | PromiseLike<string>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): I | PromiseLike<I>;
     /**
      * Set an item.
      *
      * @param data Data to set the item to.
      */
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void | PromiseLike<void>;
+    setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): void | PromiseLike<void>;
     /**
      * Update an item.
      * - Should not throw if the item doesn't exist.
      *
      * @param updates Set of property updates to apply to the item.
      */
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void | PromiseLike<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: I, updates: Updates<T[K]>): void | PromiseLike<void>;
     /**
      * Delete a specified item.
      * - Should not throw if the item doesn't exist.
      */
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): void | PromiseLike<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: I): void | PromiseLike<void>;
     /**
      * Count number of items in a query.
      *
      * @return Number of items the query matches.
      */
-    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): number | PromiseLike<number>;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): number | PromiseLike<number>;
     /**
      * Get all matching items.
      *
      * @return Set of values in `id: data` format.
      */
-    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Items<T[K]> | PromiseLike<Items<T[K]>>;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Items<I, T[K]> | PromiseLike<Items<I, T[K]>>;
     /**
      * Subscribe to all matching items with an async iterator.
      */
-    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
     /**
      * Set the data of all matching items.
      *
      * @param data Data to set matching items to.
      * @return Number of items that were set.
      */
-    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): void | PromiseLike<void>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): void | PromiseLike<void>;
     /**
      * Update the data of all matching items.
      *
      * @param updates Set of property updates to apply to matching items.
      * @return Number of items that were updated.
      */
-    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): void | PromiseLike<void>;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, updates: Updates<T[K]>): void | PromiseLike<void>;
     /**
      * Delete all matching items.
      * @return Number of items that were deleted.
      */
-    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void | PromiseLike<void>;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): void | PromiseLike<void>;
     /** Get the first matching item. */
-    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): OptionalItem<T[K]> | PromiseLike<OptionalItem<T[K]>>;
+    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): OptionalItem<I, T[K]> | PromiseLike<OptionalItem<I, T[K]>>;
     /** Require the first matching item. */
-    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Item<T[K]> | PromiseLike<Item<T[K]>>;
+    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Item<I, T[K]> | PromiseLike<Item<I, T[K]>>;
 }
 /** Provider with a fully synchronous interface */
-export declare abstract class Provider<T extends Database> implements AbstractProvider<T> {
-    abstract getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
-    requireItem<K extends DataKey<T>>(collection: K, id: string): Item<T[K]>;
-    abstract getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
-    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
-    abstract setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
-    abstract updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
-    abstract deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
-    abstract getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Items<T[K]>;
-    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): number;
-    abstract getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
-    abstract setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): void;
-    abstract updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): void;
-    abstract deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void;
-    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): OptionalItem<T[K]>;
-    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Item<T[K]>;
+export declare abstract class Provider<I extends Identifier, T extends Database> implements AbstractProvider<I, T> {
+    abstract getItem<K extends DataKey<T>>(collection: K, id: I): OptionalItem<I, T[K]>;
+    requireItem<K extends DataKey<T>>(collection: K, id: I): Item<I, T[K]>;
+    abstract getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
+    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): I;
+    abstract setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): void;
+    abstract updateItem<K extends DataKey<T>>(collection: K, id: I, updates: Updates<T[K]>): void;
+    abstract deleteItem<K extends DataKey<T>>(collection: K, id: I): void;
+    abstract getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Items<I, T[K]>;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): number;
+    abstract getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
+    abstract setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): void;
+    abstract updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, updates: Updates<T[K]>): void;
+    abstract deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): void;
+    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): OptionalItem<I, T[K]>;
+    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Item<I, T[K]>;
 }
 /** Provider with a fully asynchronous interface */
-export declare abstract class AsyncProvider<T extends Database> implements AbstractProvider<T> {
-    abstract getItem<K extends DataKey<T>>(collection: K, id: string): Promise<OptionalItem<T[K]>>;
-    requireItem<K extends DataKey<T>>(collection: K, id: string): Promise<Item<T[K]>>;
-    abstract getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
-    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
-    abstract setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    abstract updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
-    abstract deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
-    abstract getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Promise<Items<T[K]>>;
-    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Promise<number>;
-    abstract getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
-    abstract setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): Promise<void>;
-    abstract updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): Promise<void>;
-    abstract deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<void>;
-    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<OptionalItem<T[K]>>;
-    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<Item<T[K]>>;
+export declare abstract class AsyncProvider<I extends Identifier, T extends Database> implements AbstractProvider<I, T> {
+    abstract getItem<K extends DataKey<T>>(collection: K, id: I): Promise<OptionalItem<I, T[K]>>;
+    requireItem<K extends DataKey<T>>(collection: K, id: I): Promise<Item<I, T[K]>>;
+    abstract getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
+    abstract addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<I>;
+    abstract setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): Promise<void>;
+    abstract updateItem<K extends DataKey<T>>(collection: K, id: I, updates: Updates<T[K]>): Promise<void>;
+    abstract deleteItem<K extends DataKey<T>>(collection: K, id: I): Promise<void>;
+    abstract getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Promise<Items<I, T[K]>>;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Promise<number>;
+    abstract getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
+    abstract setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): Promise<void>;
+    abstract updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, updates: Updates<T[K]>): Promise<void>;
+    abstract deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<void>;
+    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<OptionalItem<I, T[K]>>;
+    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<Item<I, T[K]>>;
 }

package/db/QueryStore.d.ts

@@ -1,37 +1,38 @@
 import { ArrayStore } from "../store/ArrayStore.js";
 import { BooleanStore } from "../store/BooleanStore.js";
 import type { DataKey, Database } from "../util/data.js";
-import type { Item, ItemQuery } from "../util/item.js";
+import type { Identifier, Item } from "../util/item.js";
+import type { ItemQuery } from "../util/query.js";
 import type { StopCallback } from "../util/start.js";
 import type { MemoryProvider } from "./MemoryProvider.js";
 import type { AbstractProvider } from "./Provider.js";
 /** Store a set of multiple items. */
-export declare class QueryStore<T extends Database, K extends DataKey<T>> extends ArrayStore<Item<T[K]>> {
-    readonly provider: AbstractProvider<T>;
+export declare class QueryStore<I extends Identifier, T extends Database, K extends DataKey<T>> extends ArrayStore<Item<I, T[K]>> {
+    readonly provider: AbstractProvider<I, T>;
     readonly collection: K;
-    readonly query: ItemQuery<T[K]>;
+    readonly query: ItemQuery<I, T[K]>;
     readonly busy: BooleanStore;
     readonly limit: number;
     /** Can more items be loaded after the current result. */
     get hasMore(): boolean;
     private _hasMore;
     /** Get the first item in this store. */
-    get first(): Item<T[K]>;
+    get first(): Item<I, T[K]>;
     /** Get the last item in this store. */
-    get last(): Item<T[K]>;
-    constructor(collection: K, query: ItemQuery<T[K]>, provider: AbstractProvider<T>, memory?: MemoryProvider<T>);
+    get last(): Item<I, T[K]>;
+    constructor(collection: K, query: ItemQuery<I, T[K]>, provider: AbstractProvider<I, T>, memory?: MemoryProvider<I, T>);
     /** Refresh this store from the source provider. */
-    refresh(provider?: AbstractProvider<T>): void;
+    refresh(provider?: AbstractProvider<I, T>): void;
     private _refresh;
     /** Refresh this store if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number): void;
     /** Subscribe this store to a provider. */
-    connect(provider?: AbstractProvider<T>): StopCallback;
+    connect(provider?: AbstractProvider<I, T>): StopCallback;
     /**
      * Load more items after the last once.
      * - Promise that needs to be handled.
      */
     loadMore(): void;
     private _loadMore;
-    [Symbol.iterator](): Iterator<Item<T[K]>>;
+    [Symbol.iterator](): Iterator<Item<I, T[K]>>;
 }

package/db/ThroughProvider.d.ts

@@ -1,45 +1,46 @@
 import type { DataKey, Database } from "../util/data.js";
-import type { Item, ItemQuery, Items, OptionalItem } from "../util/item.js";
+import type { Identifier, Item, Items, OptionalItem } from "../util/item.js";
+import type { ItemQuery } from "../util/query.js";
 import type { Sourceable } from "../util/source.js";
 import type { Updates } from "../util/update.js";
 import type { AsyncProvider, Provider } from "./Provider.js";
 /** A provider that passes through to a synchronous source. */
-export declare class ThroughProvider<T extends Database> implements Provider<T>, Sourceable<Provider<T>> {
-    readonly source: Provider<T>;
-    constructor(source: Provider<T>);
-    getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
-    requireItem<K extends DataKey<T>>(collection: K, id: string): Item<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;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, update: Updates<T[K]>): 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]>;
-    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]>, update: Updates<T[K]>): void;
-    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void;
-    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): OptionalItem<T[K]>;
-    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Item<T[K]>;
+export declare class ThroughProvider<I extends Identifier, T extends Database> implements Provider<I, T>, Sourceable<Provider<I, T>> {
+    readonly source: Provider<I, T>;
+    constructor(source: Provider<I, T>);
+    getItem<K extends DataKey<T>>(collection: K, id: I): OptionalItem<I, T[K]>;
+    requireItem<K extends DataKey<T>>(collection: K, id: I): Item<I, T[K]>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): I;
+    setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): void;
+    updateItem<K extends DataKey<T>>(collection: K, id: I, update: Updates<T[K]>): void;
+    deleteItem<K extends DataKey<T>>(collection: K, id: I): void;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): number;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Items<I, T[K]>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): void;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, update: Updates<T[K]>): void;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): void;
+    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): OptionalItem<I, T[K]>;
+    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Item<I, T[K]>;
 }
 /** A provider that passes through to an asynchronous source. */
-export declare class AsyncThroughProvider<T extends Database> implements AsyncProvider<T>, Sourceable<AsyncProvider<T>> {
-    readonly source: AsyncProvider<T>;
-    constructor(source: AsyncProvider<T>);
-    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<OptionalItem<T[K]>>;
-    requireItem<K extends DataKey<T>>(collection: K, id: string): Promise<Item<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>;
-    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<OptionalItem<T[K]>>;
-    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<Item<T[K]>>;
+export declare class AsyncThroughProvider<I extends Identifier, T extends Database> implements AsyncProvider<I, T>, Sourceable<AsyncProvider<I, T>> {
+    readonly source: AsyncProvider<I, T>;
+    constructor(source: AsyncProvider<I, T>);
+    getItem<K extends DataKey<T>>(collection: K, id: I): Promise<OptionalItem<I, T[K]>>;
+    requireItem<K extends DataKey<T>>(collection: K, id: I): Promise<Item<I, T[K]>>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<I>;
+    setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): Promise<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: I, updates: Updates<T[K]>): Promise<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: I): Promise<void>;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Promise<number>;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Promise<Items<I, T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): Promise<void>;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, updates: Updates<T[K]>): Promise<void>;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<void>;
+    getFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<OptionalItem<I, T[K]>>;
+    requireFirst<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<Item<I, T[K]>>;
 }

package/db/ValidationProvider.d.ts

@@ -1,45 +1,49 @@
 import type { DataSchema, DataSchemas } from "../schema/DataSchema.js";
+import type { Schema } from "../schema/Schema.js";
 import type { DataKey, Database } from "../util/data.js";
-import type { ItemQuery, Items, OptionalItem } from "../util/item.js";
+import type { Identifier, Items, OptionalItem } from "../util/item.js";
+import type { ItemQuery } from "../util/query.js";
 import type { Sourceable } from "../util/source.js";
 import type { Updates } from "../util/update.js";
 import type { AsyncProvider, Provider } from "./Provider.js";
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
-export declare class ValidationProvider<T extends Database> extends ThroughProvider<T> implements Provider<T>, Sourceable<Provider<T>> {
+export declare class ValidationProvider<I extends Identifier, T extends Database> extends ThroughProvider<I, T> implements Provider<I, T>, Sourceable<Provider<I, T>> {
+    readonly identifier: Schema<I>;
     readonly schemas: DataSchemas<T>;
-    constructor(schemas: DataSchemas<T>, source: Provider<T>);
+    constructor(id: Schema<I>, schemas: DataSchemas<T>, source: Provider<I, T>);
     /** Get a named schema. */
     getSchema<K extends DataKey<T>>(collection: K): DataSchema<T[K]>;
-    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;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): 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<T[K]>): void;
-    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void;
-    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+    getItem<K extends DataKey<T>>(collection: K, id: I): OptionalItem<I, T[K]>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): I;
+    setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): void;
+    updateItem<K extends DataKey<T>>(collection: K, id: I, updates: Updates<T[K]>): void;
+    deleteItem<K extends DataKey<T>>(collection: K, id: I): void;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): number;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Items<I, T[K]>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): void;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, updates: Updates<T[K]>): void;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): void;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
-export declare class AsyncValidationProvider<T extends Database> extends AsyncThroughProvider<T> implements AsyncProvider<T>, Sourceable<AsyncProvider<T>> {
+export declare class AsyncValidationProvider<I extends Identifier, T extends Database> extends AsyncThroughProvider<I, T> implements AsyncProvider<I, T>, Sourceable<AsyncProvider<I, T>> {
+    readonly identifier: Schema<I>;
     readonly schemas: DataSchemas<T>;
-    constructor(schemas: DataSchemas<T>, source: AsyncProvider<T>);
+    constructor(id: Schema<I>, schemas: DataSchemas<T>, source: AsyncProvider<I, T>);
     /** Get a named data schema for this database. */
     getSchema<K extends DataKey<T>>(collection: K): DataSchema<T[K]>;
-    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>;
+    getItem<K extends DataKey<T>>(collection: K, id: I): Promise<OptionalItem<I, T[K]>>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterable<OptionalItem<I, T[K]>>;
+    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<I>;
+    setItem<K extends DataKey<T>>(collection: K, id: I, data: T[K]): Promise<void>;
+    updateItem<K extends DataKey<T>>(collection: K, id: I, updates: Updates<T[K]>): Promise<void>;
+    deleteItem<K extends DataKey<T>>(collection: K, id: I): Promise<void>;
+    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Promise<number>;
+    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): Promise<Items<I, T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<I, T[K]>): AsyncIterable<Items<I, T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, data: T[K]): Promise<void>;
+    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>, updates: Updates<T[K]>): Promise<void>;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<void>;
 }

package/db/ValidationProvider.js

@@ -1,14 +1,16 @@
 import { ValueError } from "../error/ValueError.js";
 import { Feedback } from "../feedback/Feedback.js";
-import { KEY } from "../schema/KeySchema.js";
+import { getNamedMessage } from "../index.js";
 import { updateData } from "../util/update.js";
 import { validateData } from "../util/validate.js";
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
 export class ValidationProvider extends ThroughProvider {
+    identifier;
     schemas;
-    constructor(schemas, source) {
+    constructor(id, schemas, source) {
         super(source);
+        this.identifier = id;
         this.schemas = schemas;
     }
     /** Get a named schema. */
@@ -16,12 +18,12 @@ export class ValidationProvider extends ThroughProvider {
         return this.schemas[collection];
     }
     getItem(collection, id) {
-        return _validateItem(collection, super.getItem(collection, id), this.getSchema(collection), this.getItem);
+        return _validateItem(collection, super.getItem(collection, id), this.identifier, this.getSchema(collection), this.getItem);
     }
     async *getItemSequence(collection, id) {
         const schema = this.getSchema(collection);
         for await (const item of super.getItemSequence(collection, id))
-            yield _validateItem(collection, item, schema, this.getItemSequence);
+            yield _validateItem(collection, item, this.identifier, schema, this.getItemSequence);
     }
     addItem(collection, data) {
         return super.addItem(collection, validateData(data, this.getSchema(collection).props));
@@ -40,7 +42,7 @@ export class ValidationProvider extends ThroughProvider {
         return super.countQuery(collection, query);
     }
     getQuery(collection, query) {
-        return _validateItems(collection, super.getQuery(collection, query), this.getSchema(collection), this.getQuery);
+        return _validateItems(collection, super.getQuery(collection, query), this.identifier, this.getSchema(collection), this.getQuery);
     }
     setQuery(collection, query, data) {
         super.setQuery(collection, query, this.getSchema(collection).validate(data));
@@ -55,14 +57,16 @@ export class ValidationProvider extends ThroughProvider {
     async *getQuerySequence(collection, query) {
         const schema = this.getSchema(collection);
         for await (const items of super.getQuerySequence(collection, query))
-            yield _validateItems(collection, items, schema, this.getQuerySequence);
+            yield _validateItems(collection, items, this.identifier, schema, this.getQuerySequence);
     }
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export class AsyncValidationProvider extends AsyncThroughProvider {
+    identifier;
     schemas;
-    constructor(schemas, source) {
+    constructor(id, schemas, source) {
         super(source);
+        this.identifier = id;
         this.schemas = schemas;
     }
     /** Get a named data schema for this database. */
@@ -70,12 +74,12 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
         return this.schemas[collection];
     }
     async getItem(collection, id) {
-        return _validateItem(collection, await super.getItem(collection, id), this.getSchema(collection), this.getItem);
+        return _validateItem(collection, await super.getItem(collection, id), this.identifier, this.getSchema(collection), this.getItem);
     }
     async *getItemSequence(collection, id) {
         const schema = this.getSchema(collection);
         for await (const item of super.getItemSequence(collection, id))
-            yield _validateItem(collection, item, schema, this.getItemSequence);
+            yield _validateItem(collection, item, this.identifier, schema, this.getItemSequence);
     }
     addItem(collection, data) {
         return super.addItem(collection, validateData(data, this.getSchema(collection).props));
@@ -94,12 +98,12 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
         return super.countQuery(collection, query);
     }
     async getQuery(collection, query) {
-        return _validateItems(collection, await super.getQuery(collection, query), this.getSchema(collection), this.getQuery);
+        return _validateItems(collection, await super.getQuery(collection, query), this.identifier, this.getSchema(collection), this.getQuery);
     }
     async *getQuerySequence(collection, query) {
         const schema = this.getSchema(collection);
         for await (const items of super.getQuerySequence(collection, query))
-            yield _validateItems(collection, items, schema, this.getQuerySequence);
+            yield _validateItems(collection, items, this.identifier, schema, this.getQuerySequence);
     }
     setQuery(collection, query, data) {
         return super.setQuery(collection, query, validateData(data, this.getSchema(collection).props));
@@ -112,28 +116,27 @@ export class AsyncValidationProvider extends AsyncThroughProvider {
         return super.deleteQuery(collection, query);
     }
 }
-function _validateItem(collection, item, schema, caller) {
+function _validateItem(collection, item, identifier, schema, caller) {
     if (!item)
         return undefined;
     try {
-        return validateData(item, { id: KEY, ...schema.props });
+        return validateData(item, { id: identifier, ...schema.props });
     }
     catch (thrown) {
         if (!(thrown instanceof Feedback))
             throw thrown;
-        throw new ValueError(`Invalid data for "${collection}"`, { collection, item, cause: thrown, caller });
+        throw new ValueError(`Invalid data for "${collection}"\n${thrown.message}`, { 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, schema, caller) {
-    return Array.from(_yieldValidItems(collection, items, { id: KEY, ...schema.props }, caller));
+function _validateItems(collection, items, identifier, schema, caller) {
+    return Array.from(_yieldValidItems(collection, items, { id: identifier, ...schema.props }, caller));
 }
 function* _yieldValidItems(collection, items, validators, caller) {
-    let invalid = false;
-    const feedbacks = {};
+    const messages = [];
     for (const item of items) {
         try {
             yield validateData(item, validators);
@@ -141,10 +144,9 @@ function* _yieldValidItems(collection, items, validators, caller) {
         catch (thrown) {
             if (!(thrown instanceof Feedback))
                 throw thrown;
-            invalid = true;
-            feedbacks[item.id] = thrown;
+            messages.push(getNamedMessage(item.id, thrown.message));
         }
     }
-    if (invalid)
-        throw new ValueError(`Invalid data for "${collection}"`, { collection, items, cause: feedbacks, caller });
+    if (messages.length)
+        throw new ValueError(`Invalid data for "${collection}"\n${messages.join("\n")}`, { items, caller });
 }

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,7 +1,8 @@
 import type { Firestore } from "firebase/firestore";
 import { AsyncProvider } from "../../db/Provider.js";
 import type { Data, DataKey, Database } from "../../util/data.js";
-import type { ItemQuery, Items, OptionalItem } from "../../util/item.js";
+import type { Items, OptionalItem } from "../../util/item.js";
+import type { ItemQuery } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";
 /**
  * Firestore client database provider.
@@ -9,19 +10,19 @@ import type { Updates } from "../../util/update.js";
  * - Supports offline mode.
  * - Supports realtime subscriptions.
  */
-export declare class FirestoreClientProvider<T extends Database> extends AsyncProvider<T> {
+export declare class FirestoreClientProvider<T extends Database> extends AsyncProvider<string, T> {
     private readonly _firestore;
     constructor(firestore: Firestore);
-    getItem<K extends DataKey<T>>(c: K, id: string): Promise<OptionalItem<T[K]>>;
-    getItemSequence<K extends DataKey<T>>(c: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
+    getItem<K extends DataKey<T>>(c: K, id: string): Promise<OptionalItem<string, T[K]>>;
+    getItemSequence<K extends DataKey<T>>(c: K, id: string): AsyncIterable<OptionalItem<string, T[K]>>;
     addItem<K extends DataKey<T>>(c: K, data: Data): Promise<string>;
     setItem<K extends DataKey<T>>(c: K, id: string, data: Data): Promise<void>;
     updateItem<K extends DataKey<T>>(c: K, id: string, updates: Updates<T[K]>): Promise<void>;
     deleteItem<K extends DataKey<T>>(c: K, id: string): Promise<void>;
-    countQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<T[K]>): Promise<number>;
-    getQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<T[K]>): Promise<Items<T[K]>>;
-    getQuerySequence<K extends DataKey<T>>(c: K, q?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
-    setQuery<K extends DataKey<T>>(c: K, q: ItemQuery<T[K]>, data: Data): Promise<void>;
-    updateQuery<K extends DataKey<T>>(c: K, q: ItemQuery<T[K]>, updates: Updates<T[K]>): Promise<void>;
-    deleteQuery<K extends DataKey<T>>(c: K, q: ItemQuery<T[K]>): Promise<void>;
+    countQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<string, T[K]>): Promise<number>;
+    getQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<string, T[K]>): Promise<Items<string, T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(c: K, q?: ItemQuery<string, T[K]>): AsyncIterable<Items<string, T[K]>>;
+    setQuery<K extends DataKey<T>>(c: K, q: ItemQuery<string, T[K]>, data: Data): Promise<void>;
+    updateQuery<K extends DataKey<T>>(c: K, q: ItemQuery<string, T[K]>, updates: Updates<T[K]>): Promise<void>;
+    deleteQuery<K extends DataKey<T>>(c: K, q: ItemQuery<string, T[K]>): Promise<void>;
 }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,7 +1,8 @@
 import type { Firestore } from "firebase/firestore/lite";
 import { AsyncProvider } from "../../db/Provider.js";
 import type { Data, DataKey, Database } from "../../util/data.js";
-import type { ItemQuery, Items, OptionalItem } from "../../util/item.js";
+import type { Items, OptionalItem } from "../../util/item.js";
+import type { ItemQuery } from "../../util/query.js";
 import type { Updates } from "../../util/update.js";
 /**
  * Firestore Lite client database provider.
@@ -9,19 +10,19 @@ import type { Updates } from "../../util/update.js";
  * - Does not support offline mode.
  * - Does not support realtime subscriptions.
  */
-export declare class FirestoreLiteProvider<T extends Database> extends AsyncProvider<T> {
+export declare class FirestoreLiteProvider<T extends Database> extends AsyncProvider<string, T> {
     private readonly _firestore;
     constructor(firestore: Firestore);
-    getItem<K extends DataKey<T>>(c: K, id: string): Promise<OptionalItem<T[K]>>;
-    getItemSequence<K extends DataKey<T>>(): AsyncIterableIterator<OptionalItem<T[K]>>;
+    getItem<K extends DataKey<T>>(c: K, id: string): Promise<OptionalItem<string, T[K]>>;
+    getItemSequence<K extends DataKey<T>>(): AsyncIterableIterator<OptionalItem<string, T[K]>>;
     addItem<K extends DataKey<T>>(c: K, data: Data): Promise<string>;
     setItem<K extends DataKey<T>>(c: K, id: string, data: Data): Promise<void>;
     updateItem<K extends DataKey<T>>(c: K, id: string, updates: Updates): Promise<void>;
     deleteItem<K extends DataKey<T>>(c: K, id: string): Promise<void>;
-    countQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<T[K]>): Promise<number>;
-    getQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<T[K]>): Promise<Items<T[K]>>;
-    getQuerySequence<K extends DataKey<T>>(): AsyncIterableIterator<Items<T[K]>>;
-    setQuery<K extends DataKey<T>>(c: K, q: ItemQuery<T[K]>, data: Data): Promise<void>;
-    updateQuery<K extends DataKey<T>>(c: K, q: ItemQuery<T[K]>, updates: Updates): Promise<void>;
-    deleteQuery<K extends DataKey<T>>(c: K, q: ItemQuery<T[K]>): Promise<void>;
+    countQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<string, T[K]>): Promise<number>;
+    getQuery<K extends DataKey<T>>(c: K, q?: ItemQuery<string, T[K]>): Promise<Items<string, T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(): AsyncIterableIterator<Items<string, T[K]>>;
+    setQuery<K extends DataKey<T>>(c: K, q: ItemQuery<string, T[K]>, data: Data): Promise<void>;
+    updateQuery<K extends DataKey<T>>(c: K, q: ItemQuery<string, T[K]>, updates: Updates): Promise<void>;
+    deleteQuery<K extends DataKey<T>>(c: K, q: ItemQuery<string, T[K]>): Promise<void>;
 }