shelving 1.150.15 → 1.152.0

package/db/CacheProvider.d.ts

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

@@ -1,7 +1,8 @@
 import type { ImmutableArray } from "../util/array.js";
 import type { DataKey, Database } from "../util/data.js";
-import type { ItemQuery } from "../util/item.js";
+import type { Identifier } from "../util/item.js";
 import { type Nullish } from "../util/null.js";
+import type { ItemQuery } from "../util/query.js";
 import type { Updates } from "../util/update.js";
 import type { AsyncProvider, Provider } from "./Provider.js";
 /** A change to a database. */
@@ -20,56 +21,56 @@ export interface ItemAddChange<T extends Database, K extends DataKey<T>> extends
     readonly data: T[K];
 }
 /** Change an item in a database collection. */
-export interface ItemChange<T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {
-    readonly id: string;
+export interface ItemChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {
+    readonly id: I;
     readonly query?: never;
 }
 /** Set an item in a database collection. */
-export interface ItemSetChange<T extends Database, K extends DataKey<T>> extends ItemChange<T, K> {
+export interface ItemSetChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends ItemChange<I, T, K> {
     readonly action: "set";
     readonly data: T[K];
 }
 /** Update an item in a database collection. */
-export interface ItemUpdateChange<T extends Database, K extends DataKey<T>> extends ItemChange<T, K> {
+export interface ItemUpdateChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends ItemChange<I, T, K> {
     readonly action: "update";
     readonly updates: Updates<T[K]>;
 }
 /** Delete an item in a database collection. */
-export interface ItemDeleteChange<T extends Database, K extends DataKey<T>> extends ItemChange<T, K> {
+export interface ItemDeleteChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends ItemChange<I, T, K> {
     readonly action: "delete";
 }
 /** Change multiple items in a database collection. */
-export interface QueryChange<T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {
-    readonly query: ItemQuery<T[K]>;
+export interface QueryChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends CollectionChange<T, K> {
+    readonly query: ItemQuery<I, T[K]>;
     readonly id?: never;
 }
 /** Set multiple items in a database collection. */
-export interface QuerySetChange<T extends Database, K extends DataKey<T>> extends QueryChange<T, K> {
+export interface QuerySetChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends QueryChange<I, T, K> {
     readonly action: "set";
     readonly data: T[K];
 }
 /** Update multiple items in a database collection. */
-export interface QueryUpdateChange<T extends Database, K extends DataKey<T>> extends QueryChange<T, K> {
+export interface QueryUpdateChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends QueryChange<I, T, K> {
     readonly action: "update";
     readonly updates: Updates<T[K]>;
 }
 /** Delete multiple items in a database collection. */
-export interface QueryDeleteChange<T extends Database, K extends DataKey<T>> extends QueryChange<T, K> {
+export interface QueryDeleteChange<I extends Identifier, T extends Database, K extends DataKey<T>> extends QueryChange<I, T, K> {
     readonly action: "delete";
 }
 /** Write an item in a set of collection. */
-export type DatabaseItemChange<T extends Database> = ItemSetChange<T, DataKey<T>> | ItemUpdateChange<T, DataKey<T>> | ItemDeleteChange<T, DataKey<T>>;
+export type DatabaseItemChange<I extends Identifier, T extends Database> = ItemSetChange<I, T, DataKey<T>> | ItemUpdateChange<I, T, DataKey<T>> | ItemDeleteChange<I, T, DataKey<T>>;
 /** Write multiple item in a set of collection. */
-export type DatabaseQueryChange<T extends Database> = QuerySetChange<T, DataKey<T>> | QueryUpdateChange<T, DataKey<T>> | QueryDeleteChange<T, DataKey<T>>;
+export type DatabaseQueryChange<I extends Identifier, T extends Database> = QuerySetChange<I, T, DataKey<T>> | QueryUpdateChange<I, T, DataKey<T>> | QueryDeleteChange<I, T, DataKey<T>>;
 /** Write an item or multiple items in a set of collection. */
-export type DatabaseChange<T extends Database> = ItemAddChange<T, DataKey<T>> | DatabaseItemChange<T> | DatabaseQueryChange<T>;
+export type DatabaseChange<I extends Identifier, T extends Database> = ItemAddChange<T, DataKey<T>> | DatabaseItemChange<I, T> | DatabaseQueryChange<I, T>;
 /** Write an item or multiple items in a set of collection. */
-export type DatabaseChanges<T extends Database> = ImmutableArray<DatabaseChange<T>>;
+export type DatabaseChanges<I extends Identifier, T extends Database> = ImmutableArray<DatabaseChange<I, T>>;
 /** Write a single change to a synchronous provider and return an array of the changes that were written. */
-export declare function writeChange<T extends Database>(provider: Provider<T>, change: DatabaseChange<T>): DatabaseChange<T>;
+export declare function writeChange<I extends Identifier, T extends Database>(provider: Provider<I, T>, change: DatabaseChange<I, T>): DatabaseChange<I, T>;
 /** Write a set of changes to a synchronous provider. */
-export declare function writeChanges<T extends Database>(provider: Provider<T>, ...changes: Nullish<DatabaseChange<T>>[]): DatabaseChanges<T>;
+export declare function writeChanges<I extends Identifier, T extends Database>(provider: Provider<I, T>, ...changes: Nullish<DatabaseChange<I, T>>[]): DatabaseChanges<I, T>;
 /** Write a single change to an asynchronous provider and return the change that was written. */
-export declare function writeAsyncChange<T extends Database>(provider: AsyncProvider<T>, change: DatabaseChange<T>): Promise<DatabaseChange<T>>;
+export declare function writeAsyncChange<I extends Identifier, T extends Database>(provider: AsyncProvider<I, T>, change: DatabaseChange<I, T>): Promise<DatabaseChange<I, T>>;
 /** Write a set of changes to an asynchronous provider. */
-export declare function writeAsyncChanges<T extends Database>(provider: AsyncProvider<T>, ...changes: Nullish<DatabaseChange<T>>[]): Promise<DatabaseChanges<T>>;
+export declare function writeAsyncChanges<I extends Identifier, T extends Database>(provider: AsyncProvider<I, T>, ...changes: Nullish<DatabaseChange<I, T>>[]): Promise<DatabaseChanges<I, T>>;

package/db/ChangesProvider.d.ts

@@ -1,30 +1,31 @@
 import type { MutableArray } from "../util/array.js";
 import type { DataKey, Database } from "../util/data.js";
-import type { ItemQuery } from "../util/item.js";
+import type { Identifier } from "../util/item.js";
+import type { ItemQuery } from "../util/query.js";
 import type { Updates } from "../util/update.js";
 import type { DatabaseChange, DatabaseChanges } from "./Change.js";
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
 /** Synchronous provider that keeps a log of any written changes to its `.changes` property. */
-export declare class ChangesProvider<T extends Database> extends ThroughProvider<T> {
-    get changes(): DatabaseChanges<T>;
-    readonly _changes: MutableArray<DatabaseChange<T>>;
-    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;
-    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;
+export declare class ChangesProvider<I extends Identifier, T extends Database> extends ThroughProvider<I, T> {
+    get changes(): DatabaseChanges<I, T>;
+    readonly _changes: MutableArray<DatabaseChange<I, T>>;
+    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;
+    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;
 }
 /** Asynchronous provider that keeps a log of any written changes to its `.written` property. */
-export declare class AsyncLoggedProvider<T extends Database> extends AsyncThroughProvider<T> {
-    get written(): DatabaseChanges<T>;
-    readonly _written: MutableArray<DatabaseChange<T>>;
-    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>;
-    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>;
+export declare class AsyncLoggedProvider<I extends Identifier, T extends Database> extends AsyncThroughProvider<I, T> {
+    get written(): DatabaseChanges<I, T>;
+    readonly _written: MutableArray<DatabaseChange<I, T>>;
+    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>;
+    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/DebugProvider.d.ts

@@ -1,34 +1,35 @@
 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 { Updates } from "../util/update.js";
 import { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
 /** Provider that logs operations to a synchronous source provider to the console. */
-export declare class DebugProvider<T extends Database> extends ThroughProvider<T> {
-    getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterableIterator<OptionalItem<T[K]>>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates): void;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
-    countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): number;
-    getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Items<T[K]>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterableIterator<Items<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): void;
-    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates): void;
-    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void;
+export declare class DebugProvider<I extends Identifier, T extends Database> extends ThroughProvider<I, T> {
+    getItem<K extends DataKey<T>>(collection: K, id: I): OptionalItem<I, T[K]>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterableIterator<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): 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]>): AsyncIterableIterator<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): void;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): void;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
-export declare class AsyncDebugProvider<T extends Database> extends AsyncThroughProvider<T> {
-    getItem<K extends DataKey<T>>(collection: K, id: string): Promise<OptionalItem<T[K]>>;
-    getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterableIterator<OptionalItem<T[K]>>;
-    addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
-    setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates): Promise<void>;
-    deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
-    countQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<number>;
-    getQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<Items<T[K]>>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterableIterator<Items<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): Promise<void>;
-    updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates): Promise<void>;
-    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<void>;
+export declare class AsyncDebugProvider<I extends Identifier, T extends Database> extends AsyncThroughProvider<I, T> {
+    getItem<K extends DataKey<T>>(collection: K, id: I): Promise<OptionalItem<I, T[K]>>;
+    getItemSequence<K extends DataKey<T>>(collection: K, id: I): AsyncIterableIterator<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): 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]>): AsyncIterableIterator<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): Promise<void>;
+    deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<I, T[K]>): Promise<void>;
 }

package/db/ItemStore.d.ts

@@ -1,26 +1,26 @@
 import { BooleanStore } from "../store/BooleanStore.js";
 import { OptionalDataStore } from "../store/DataStore.js";
 import type { DataKey, Database } from "../util/data.js";
-import type { Item } from "../util/item.js";
+import type { Identifier, Item } from "../util/item.js";
 import type { StopCallback } from "../util/start.js";
 import type { MemoryProvider } from "./MemoryProvider.js";
 import type { AbstractProvider } from "./Provider.js";
 /** Store a single item. */
-export declare class ItemStore<T extends Database, K extends DataKey<T>> extends OptionalDataStore<Item<T[K]>> {
-    readonly provider: AbstractProvider<T>;
+export declare class ItemStore<I extends Identifier, T extends Database, K extends DataKey<T>> extends OptionalDataStore<Item<I, T[K]>> {
+    readonly provider: AbstractProvider<I, T>;
     readonly collection: K;
-    readonly id: string;
+    readonly id: I;
     readonly busy: BooleanStore;
     /** Get the data of this store (throws `RequiredError` if item doesn't exist). */
-    get data(): Item<T[K]>;
+    get data(): Item<I, T[K]>;
     /** Set the data of this store. */
-    set data(data: T[K] | Item<T[K]>);
-    constructor(collection: K, id: string, provider: AbstractProvider<T>, memory?: MemoryProvider<T>);
+    set data(data: T[K] | Item<I, T[K]>);
+    constructor(collection: K, id: I, 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, provider?: AbstractProvider<T>): void;
+    refreshStale(maxAge: number, provider?: AbstractProvider<I, T>): void;
     /** Subscribe this store to a provider. */
-    connect(provider?: AbstractProvider<T>): StopCallback;
+    connect(provider?: AbstractProvider<I, T>): StopCallback;
 }

package/db/MemoryProvider.d.ts

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

package/db/MemoryProvider.js

@@ -4,7 +4,7 @@ import { isArrayEqual } from "../util/equal.js";
 import { getItem } from "../util/item.js";
 import { countItems } from "../util/iterate.js";
 import { queryItems, queryWritableItems } from "../util/query.js";
-import { getRandomKey } from "../util/random.js";
+import { getRandom, getRandomKey } from "../util/random.js";
 import { updateData } from "../util/update.js";
 import { Provider } from "./Provider.js";
 /**
@@ -118,10 +118,15 @@ export class MemoryTable {
             }
         }
     }
-    addItem(data) {
-        let id = getRandomKey();
+    generateUniqueID() {
+        const gen = typeof this._data.keys().next().value === "number" ? getRandom : getRandomKey;
+        let id = gen();
         while (this._data.has(id))
-            id = getRandomKey(); // Regenerate ID until unique.
+            id = gen(); // Regenerate ID until unique.
+        return id;
+    }
+    addItem(data) {
+        const id = this.generateUniqueID();
         this.setItem(id, data);
         return id;
     }