shelving 1.64.0 → 1.65.0

package/provider/MemoryProvider.d.ts

@@ -1,8 +1,11 @@
 import type { DocumentReference, QueryReference } from "../db/Reference.js";
-import type { Data, Result, Entity } from "../util/data.js";
+import type { Data, Entity, Entities, OptionalEntity } from "../util/data.js";
 import type { DataUpdate } from "../update/DataUpdate.js";
-import type { Dispatcher } from "../util/function.js";
-import { Observer, Unsubscriber } from "../util/observe.js";
+import type { Dispatch } from "../util/function.js";
+import type { Unsubscribe } from "../observe/Observable.js";
+import { Query } from "../query/Query.js";
+import { Subject } from "../observe/Subject.js";
+import { PartialObserver } from "../observe/Observer.js";
 import { Provider, SynchronousProvider } from "./Provider.js";
 /**
  * Fast in-memory store for data.
@@ -12,15 +15,17 @@ import { Provider, SynchronousProvider } from "./Provider.js";
 export declare class MemoryProvider extends Provider implements SynchronousProvider {
     /** List of tables in `{ path: Table }` format. */
     private _tables;
-    table<T extends Data>({ collection }: DocumentReference<T> | QueryReference<T>): Table<T>;
-    get<T extends Data>(ref: DocumentReference<T>): Result<Entity<T>>;
-    subscribe<T extends Data>(ref: DocumentReference<T>, observer: Observer<Result<Entity<T>>>): Unsubscriber;
-    add<T extends Data>(ref: QueryReference<T>, data: T): string;
-    set<T extends Data>(ref: DocumentReference<T>, data: T): void;
-    update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void;
-    delete<T extends Data>(ref: DocumentReference<T>): void;
-    getQuery<T extends Data>(ref: QueryReference<T>): Iterable<Entity<T>>;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Iterable<Entity<T>>>): Unsubscriber;
+    getTable<T extends Data>({ collection }: DocumentReference<T> | QueryReference<T>): MemoryTable<T>;
+    getDocumentTime<T extends Data>(ref: DocumentReference<T>): number | undefined;
+    getDocument<T extends Data>(ref: DocumentReference<T>): OptionalEntity<T>;
+    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: PartialObserver<OptionalEntity<T>>): Unsubscribe;
+    addDocument<T extends Data>(ref: QueryReference<T>, data: T): string;
+    setDocument<T extends Data>(ref: DocumentReference<T>, data: T): void;
+    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void;
+    deleteDocument<T extends Data>(ref: DocumentReference<T>): void;
+    getQueryTime<T extends Data>(ref: QueryReference<T>): number | undefined;
+    getQuery<T extends Data>(ref: QueryReference<T>): Entities<T>;
+    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: PartialObserver<Entities<T>>): Unsubscribe;
     setQuery<T extends Data>(ref: QueryReference<T>, data: T): number;
     updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): number;
     deleteQuery<T extends Data>(ref: QueryReference<T>): number;
@@ -29,16 +34,25 @@ export declare class MemoryProvider extends Provider implements SynchronousProvi
  * An individual table of data.
  * - Fires with an array of string IDs.
  */
-declare class Table<T extends Data> {
-    protected data: Map<string, Entity<T>>;
-    protected changes: Set<string>;
-    protected listeners: Set<Dispatcher<[Set<string>]>>;
-    get(id: string): Result<Entity<T>>;
-    get entities(): Iterable<Entity<T>>;
-    set(entity: Entity<T>): void;
-    delete(id: string): void;
-    fire: () => void;
-    on(listener: Dispatcher<[Set<string>]>): Unsubscriber;
-    off(listener: Dispatcher<[Set<string>]>): void;
+export declare class MemoryTable<T extends Data> extends Subject<void> {
+    protected _data: Map<string, Entity<T>>;
+    protected _times: Map<string, number>;
+    protected _listeners: Set<Dispatch<[]>>;
+    protected _firing: boolean;
+    getDocumentTime(id: string): number | undefined;
+    getDocument(id: string): OptionalEntity<T>;
+    subscribeDocument(id: string, observer: PartialObserver<OptionalEntity<T>>): Unsubscribe;
+    addDocument(data: T): string;
+    setEntity(entity: Entity<T>): void;
+    setDocument(id: string, data: T): void;
+    updateDocument(id: string, update: DataUpdate<T>): void;
+    deleteDocument(id: string): void;
+    getQueryTime(query: Query<Entity<T>>): number | undefined;
+    getQuery(query: Query<Entity<T>>): Entities<T>;
+    subscribeQuery(query: Query<Entity<T>>, observer: PartialObserver<Entities<T>>): Unsubscribe;
+    protected _getWrites(query: Query<Entity<T>>): Iterable<Entity<T>>;
+    setEntities(query: Query<Entity<T>>, entities: Entities<T>): number;
+    setQuery(query: Query<Entity<T>>, data: T): number;
+    updateQuery(query: Query<Entity<T>>, update: DataUpdate<T>): number;
+    deleteQuery(query: Query<Entity<T>>): number;
 }
-export {};

package/provider/MemoryProvider.js

@@ -1,8 +1,11 @@
-import { dispatchNext } from "../util/observe.js";
 import { getRandomKey } from "../util/random.js";
 import { isArrayEqual } from "../util/equal.js";
-import { DocumentRequiredError } from "../db/errors.js";
 import { transformProps } from "../util/transform.js";
+import { Query } from "../query/Query.js";
+import { RequiredError } from "../error/RequiredError.js";
+import { Subject } from "../observe/Subject.js";
+import { dispatchNext } from "../observe/Observer.js";
+import { getArray } from "../util/array.js";
 import { Provider } from "./Provider.js";
 /**
  * Fast in-memory store for data.
@@ -16,146 +19,182 @@ export class MemoryProvider extends Provider {
         this._tables = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
     }
     // Get a named collection (or create a new one).
-    table({ collection }) {
+    getTable({ collection }) {
         var _a;
-        return ((_a = this._tables)[collection] || (_a[collection] = new Table()));
+        return ((_a = this._tables)[collection] || (_a[collection] = new MemoryTable()));
     }
-    get(ref) {
-        return this.table(ref).get(ref.id);
+    getDocumentTime(ref) {
+        return this.getTable(ref).getDocumentTime(ref.id);
     }
-    subscribe(ref, observer) {
-        const table = this.table(ref);
-        const id = ref.id;
+    getDocument(ref) {
+        return this.getTable(ref).getDocument(ref.id);
+    }
+    subscribeDocument(ref, observer) {
+        return this.getTable(ref).subscribeDocument(ref.id, observer);
+    }
+    addDocument(ref, data) {
+        return this.getTable(ref).addDocument(data);
+    }
+    setDocument(ref, data) {
+        return this.getTable(ref).setDocument(ref.id, data);
+    }
+    updateDocument(ref, update) {
+        return this.getTable(ref).updateDocument(ref.id, update);
+    }
+    deleteDocument(ref) {
+        return this.getTable(ref).deleteDocument(ref.id);
+    }
+    getQueryTime(ref) {
+        return this.getTable(ref).getQueryTime(ref);
+    }
+    getQuery(ref) {
+        return this.getTable(ref).getQuery(ref);
+    }
+    subscribeQuery(ref, observer) {
+        return this.getTable(ref).subscribeQuery(ref, observer);
+    }
+    setQuery(ref, data) {
+        return this.getTable(ref).setQuery(ref, data);
+    }
+    updateQuery(ref, update) {
+        return this.getTable(ref).updateQuery(ref, update);
+    }
+    deleteQuery(ref) {
+        return this.getTable(ref).deleteQuery(ref);
+    }
+}
+/**
+ * An individual table of data.
+ * - Fires with an array of string IDs.
+ */
+export class MemoryTable extends Subject {
+    constructor() {
+        super(...arguments);
+        this._data = new Map();
+        this._times = new Map();
+        this._listeners = new Set();
+        this._firing = false;
+    }
+    getDocumentTime(id) {
+        return this._times.get(id);
+    }
+    getDocument(id) {
+        return this._data.get(id) || null;
+    }
+    subscribeDocument(id, observer) {
         // Call next() immediately with initial results.
-        dispatchNext(observer, table.get(id));
+        let last = this.getDocument(id);
+        dispatchNext(observer, last);
         // Call next() every time the collection changes.
-        return table.on(changes => {
-            changes.has(id) && dispatchNext(observer, table.get(id));
+        return this.subscribe(() => {
+            const next = this.getDocument(id);
+            if (next !== last) {
+                last = next;
+                dispatchNext(observer, last);
+            }
         });
     }
-    add(ref, data) {
-        const table = this.table(ref);
+    addDocument(data) {
         let id = getRandomKey();
-        while (table.get(id))
+        while (this._data.has(id))
             id = getRandomKey(); // Regenerate ID until unique.
-        table.set({ ...data, id });
+        this.setEntity({ ...data, id });
         return id;
     }
-    set(ref, data) {
-        const table = this.table(ref);
-        const id = ref.id;
-        table.set({ ...data, id });
+    setEntity(entity) {
+        const id = entity.id;
+        this._data.set(id, entity);
+        this._times.set(id, Date.now());
+        this.next();
     }
-    update(ref, update) {
-        const table = this.table(ref);
-        const id = ref.id;
-        const entity = table.get(id);
+    setDocument(id, data) {
+        this.setEntity({ ...data, id });
+    }
+    updateDocument(id, update) {
+        const entity = this._data.get(id);
         if (!entity)
-            throw new DocumentRequiredError(ref);
-        table.set({ ...entity, ...Object.fromEntries(transformProps(entity, update.updates)), id: entity.id });
+            throw new RequiredError(`Document "${id}" does not exist`);
+        this.setEntity({ ...entity, ...Object.fromEntries(transformProps(entity, update.updates)), id });
     }
-    delete(ref) {
-        const table = this.table(ref);
-        const id = ref.id;
-        table.delete(id);
+    deleteDocument(id) {
+        this._data.delete(id);
+        this._times.set(id, Date.now());
+        this.next();
     }
-    getQuery(ref) {
-        return ref.transform(this.table(ref).entities);
+    getQueryTime(query) {
+        return this._times.get(_getQueryReference(query));
     }
-    subscribeQuery(ref, observer) {
-        const table = this.table(ref);
+    getQuery(query) {
+        return getArray(query.transform(this._data.values()));
+    }
+    subscribeQuery(query, observer) {
         // Call `next()` immediately with the initial results.
-        let last = Array.from(ref.transform(table.entities));
+        let last = this.getQuery(query);
         dispatchNext(observer, last);
         // Possibly call `next()` when the collection changes if any changes affect the subscription.
-        return table.on(() => {
-            const next = Array.from(ref.transform(table.entities));
+        return this.subscribe(() => {
+            const next = this.getQuery(query);
             if (!isArrayEqual(last, next)) {
                 last = next;
                 dispatchNext(observer, last);
             }
         });
     }
-    setQuery(ref, data) {
-        const table = this.table(ref);
-        // If there's a limit set: run the full query.
-        // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
+    _getWrites(query) {
+        // Queries that have no limit don't care about sorting either.
+        // So sorting can be skipped for performance.
+        return query.limit ? query.transform(this._data.values()) : query.filters.transform(this._data.values());
+    }
+    setEntities(query, entities) {
+        const now = Date.now();
         let count = 0;
-        for (const { id } of ref.limit ? ref.transform(table.entities) : ref.filters.transform(table.entities)) {
-            table.set({ ...data, id });
+        for (const entity of entities) {
+            const id = entity.id;
+            this._data.set(id, entity);
+            this._times.set(id, now);
             count++;
         }
+        this._times.set(_getQueryReference(query), now);
         return count;
     }
-    updateQuery(ref, update) {
-        const table = this.table(ref);
-        // If there's a limit set: run the full query.
-        // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
+    setQuery(query, data) {
+        const now = Date.now();
         let count = 0;
-        for (const entity of ref.limit ? ref.transform(table.entities) : ref.filters.transform(table.entities)) {
-            table.set({ ...entity, ...Object.fromEntries(transformProps(entity, update.updates)), id: entity.id });
+        for (const { id } of this._getWrites(query)) {
+            this._data.set(id, { ...data, id });
+            this._times.set(id, now);
             count++;
         }
+        this._times.set(_getQueryReference(query), now);
+        this.next();
         return count;
     }
-    deleteQuery(ref) {
-        const table = this.table(ref);
-        // If there's a limit set: run the full query.
-        // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
+    updateQuery(query, update) {
+        const now = Date.now();
         let count = 0;
-        for (const { id } of ref.limit ? ref.transform(table.entities) : ref.filters.transform(table.entities)) {
-            table.delete(id);
+        for (const entity of this._getWrites(query)) {
+            const id = entity.id;
+            this._data.set(id, { ...entity, ...Object.fromEntries(transformProps(entity, update.updates)), id });
+            this._times.set(id, now);
             count++;
         }
+        this._times.set(_getQueryReference(query), now);
+        this.next();
         return count;
     }
-}
-/**
- * An individual table of data.
- * - Fires with an array of string IDs.
- */
-class Table {
-    constructor() {
-        this.data = new Map();
-        this.changes = new Set();
-        this.listeners = new Set();
-        this.fire = () => {
-            if (this.changes.size) {
-                for (const dispatcher of this.listeners)
-                    dispatcher(this.changes);
-                this.changes.clear();
-            }
-        };
-    }
-    get(id) {
-        return this.data.get(id) || null;
-    }
-    get entities() {
-        return this.data.values();
-    }
-    set(entity) {
-        if (entity !== this.get(entity.id)) {
-            this.data.set(entity.id, entity);
-            // Queue `this.fire()` if we've created a change.
-            if (!this.changes.size)
-                queueMicrotask(this.fire);
-            this.changes.add(entity.id);
-        }
-    }
-    delete(id) {
-        if (this.data.has(id)) {
-            this.data.delete(id);
-            // Queue `this.fire()` if we've created a change.
-            if (!this.changes.size)
-                queueMicrotask(this.fire);
-            this.changes.add(id);
+    deleteQuery(query) {
+        let count = 0;
+        for (const { id } of this._getWrites(query)) {
+            this._data.delete(id);
+            this._times.set(id, Date.now());
+            count++;
         }
+        this._times.set(_getQueryReference(query), Date.now());
+        this.next();
+        return count;
     }
-    on(listener) {
-        this.listeners.add(listener);
-        return this.off.bind(this, listener);
-    }
-    off(listener) {
-        this.listeners.delete(listener);
-    }
+}
+function _getQueryReference(query) {
+    // Queries that have no limit don't care about sorting either.
+    return query.limit ? `filters=${query.filters.toString()}` : Query.prototype.toString.call(query);
 }

package/provider/Provider.d.ts

@@ -1,7 +1,8 @@
 import type { DocumentReference, QueryReference } from "../db/Reference.js";
+import type { Unsubscribe } from "../observe/Observable.js";
+import type { PartialObserver } from "../observe/Observer.js";
 import type { DataUpdate } from "../update/DataUpdate.js";
-import type { Data, Result, Entity } from "../util/data.js";
-import type { Observer, Unsubscriber } from "../util/observe.js";
+import type { Data, Entities, OptionalEntity } from "../util/data.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
 export declare abstract class Provider {
     /**
@@ -10,7 +11,7 @@ export declare abstract class Provider {
      * @param ref Document reference specifying which document to get.
      * @return The document object, or `undefined` if it doesn't exist.
      */
-    abstract get<T extends Data>(ref: DocumentReference<T>): Result<Entity<T>> | PromiseLike<Result<Entity<T>>>;
+    abstract getDocument<T extends Data>(ref: DocumentReference<T>): OptionalEntity<T> | PromiseLike<OptionalEntity<T>>;
     /**
      * Subscribe to the result of a document.
      * - `next()` is called once with the initial result, and again any time the result changes.
@@ -20,7 +21,7 @@ export declare abstract class Provider {
      *
      * @return Function that ends the subscription.
      */
-    abstract subscribe<T extends Data>(ref: DocumentReference<T>, observer: Observer<Result<Entity<T>>>): Unsubscriber;
+    abstract subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: PartialObserver<OptionalEntity<T>>): Unsubscribe;
     /**
      * Create a new document with a random ID.
      * - Created document is guaranteed to have a unique ID.
@@ -30,7 +31,7 @@ export declare abstract class Provider {
      *
      * @return String ID for the created document (possibly promised).
      */
-    abstract add<T extends Data>(ref: QueryReference<T>, data: T): string | PromiseLike<string>;
+    abstract addDocument<T extends Data>(ref: QueryReference<T>, data: T): string | PromiseLike<string>;
     /**
      * Set the data a document.
      * - If the document exists, set the value of it.
@@ -41,7 +42,7 @@ export declare abstract class Provider {
      *
      * @throws Error If a `Update` was provided but the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract set<T extends Data>(ref: DocumentReference<T>, data: T): void | PromiseLike<void>;
+    abstract setDocument<T extends Data>(ref: DocumentReference<T>, data: T): void | PromiseLike<void>;
     /**
      * Update the data an existing document.
      *
@@ -50,19 +51,19 @@ export declare abstract class Provider {
      *
      * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void | PromiseLike<void>;
+    abstract updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void | PromiseLike<void>;
     /**
      * Delete a specified document.
      * @param ref Document reference specifying which document to delete.
      */
-    abstract delete<T extends Data>(ref: DocumentReference<T>): void | PromiseLike<void>;
+    abstract deleteDocument<T extends Data>(ref: DocumentReference<T>): void | PromiseLike<void>;
     /**
      * Get all matching documents.
      *
      * @param ref Documents reference specifying which collection to get documents from.
      * @return Set of results in `id: data` format.
      */
-    abstract getQuery<T extends Data>(ref: QueryReference<T>): Iterable<Entity<T>> | PromiseLike<Iterable<Entity<T>>>;
+    abstract getQuery<T extends Data>(ref: QueryReference<T>): Entities<T> | PromiseLike<Entities<T>>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -72,7 +73,7 @@ export declare abstract class Provider {
      *
      * @return Function that ends the subscription.
      */
-    abstract subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Iterable<Entity<T>>>): Unsubscriber;
+    abstract subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: PartialObserver<Entities<T>>): Unsubscribe;
     /**
      * Set the data of all matching documents.
      *
@@ -98,24 +99,24 @@ export declare abstract class Provider {
 }
 /** Provider with a fully synchronous interface */
 export interface SynchronousProvider extends Provider {
-    get<T extends Data>(ref: DocumentReference<T>): Result<Entity<T>>;
-    add<T extends Data>(ref: QueryReference<T>, data: T): string;
-    set<T extends Data>(ref: DocumentReference<T>, value: T): void;
-    update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void;
-    delete<T extends Data>(ref: DocumentReference<T>): void;
-    getQuery<T extends Data>(ref: QueryReference<T>): Iterable<Entity<T>>;
+    getDocument<T extends Data>(ref: DocumentReference<T>): OptionalEntity<T>;
+    addDocument<T extends Data>(ref: QueryReference<T>, data: T): string;
+    setDocument<T extends Data>(ref: DocumentReference<T>, value: T): void;
+    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void;
+    deleteDocument<T extends Data>(ref: DocumentReference<T>): void;
+    getQuery<T extends Data>(ref: QueryReference<T>): Entities<T>;
     setQuery<T extends Data>(ref: QueryReference<T>, value: T): number;
     updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): number;
     deleteQuery<T extends Data>(ref: QueryReference<T>): number;
 }
 /** Provider with a fully asynchronous interface */
 export interface AsynchronousProvider extends Provider {
-    get<T extends Data>(ref: DocumentReference<T>): PromiseLike<Result<Entity<T>>>;
-    add<T extends Data>(ref: QueryReference<T>, data: T): PromiseLike<string>;
-    set<T extends Data>(ref: DocumentReference<T>, value: T): PromiseLike<void>;
-    update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): PromiseLike<void>;
-    delete<T extends Data>(ref: DocumentReference<T>): PromiseLike<void>;
-    getQuery<T extends Data>(ref: QueryReference<T>): PromiseLike<Iterable<Entity<T>>>;
+    getDocument<T extends Data>(ref: DocumentReference<T>): PromiseLike<OptionalEntity<T>>;
+    addDocument<T extends Data>(ref: QueryReference<T>, data: T): PromiseLike<string>;
+    setDocument<T extends Data>(ref: DocumentReference<T>, value: T): PromiseLike<void>;
+    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): PromiseLike<void>;
+    deleteDocument<T extends Data>(ref: DocumentReference<T>): PromiseLike<void>;
+    getQuery<T extends Data>(ref: QueryReference<T>): PromiseLike<Entities<T>>;
     setQuery<T extends Data>(ref: QueryReference<T>, value: T): PromiseLike<number>;
     updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): PromiseLike<number>;
     deleteQuery<T extends Data>(ref: QueryReference<T>): PromiseLike<number>;

package/provider/ThroughProvider.d.ts

@@ -1,26 +1,35 @@
-import type { Data, Result, Entity } from "../util/data.js";
+import type { Data, Entities, OptionalEntity } from "../util/data.js";
 import type { DocumentReference, QueryReference } from "../db/Reference.js";
 import type { DataUpdate } from "../update/DataUpdate.js";
-import type { Observer, Unsubscriber } from "../util/observe.js";
 import type { Class } from "../util/class.js";
-import { Provider } from "./Provider.js";
+import type { PartialObserver } from "../observe/Observer.js";
+import type { Unsubscribe } from "../observe/Observable.js";
+import { AsynchronousProvider, Provider, SynchronousProvider } from "./Provider.js";
 /**
  * Pass all reads and writes through to a source provider.
  */
 export declare class ThroughProvider extends Provider {
     readonly source: Provider;
     constructor(source: Provider);
-    get<T extends Data>(ref: DocumentReference<T>): Result<Entity<T>> | PromiseLike<Result<Entity<T>>>;
-    subscribe<T extends Data>(ref: DocumentReference<T>, observer: Observer<Result<Entity<T>>>): Unsubscriber;
-    add<T extends Data>(ref: QueryReference<T>, data: T): string | PromiseLike<string>;
-    set<T extends Data>(ref: DocumentReference<T>, data: T): void | PromiseLike<void>;
-    update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void | PromiseLike<void>;
-    delete<T extends Data>(ref: DocumentReference<T>): void | PromiseLike<void>;
-    getQuery<T extends Data>(ref: QueryReference<T>): Iterable<Entity<T>> | PromiseLike<Iterable<Entity<T>>>;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Iterable<Entity<T>>>): Unsubscriber;
+    getDocument<T extends Data>(ref: DocumentReference<T>): OptionalEntity<T> | PromiseLike<OptionalEntity<T>>;
+    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: PartialObserver<OptionalEntity<T>>): Unsubscribe;
+    addDocument<T extends Data>(ref: QueryReference<T>, data: T): string | PromiseLike<string>;
+    setDocument<T extends Data>(ref: DocumentReference<T>, data: T): void | PromiseLike<void>;
+    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void | PromiseLike<void>;
+    deleteDocument<T extends Data>(ref: DocumentReference<T>): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: QueryReference<T>): Entities<T> | PromiseLike<Entities<T>>;
+    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: PartialObserver<Entities<T>>): Unsubscribe;
     setQuery<T extends Data>(ref: QueryReference<T>, data: T): number | PromiseLike<number>;
     updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): number | PromiseLike<number>;
     deleteQuery<T extends Data>(ref: QueryReference<T>): number | PromiseLike<number>;
 }
+/** Synchronous through provider must have synchronous source provider. */
+export interface SynchronousThroughProvider extends SynchronousProvider {
+    new (source: SynchronousProvider): SynchronousProvider;
+}
+/** Asynchronous through provider must have asynchronous source provider. */
+export interface AsynchronousThroughProvider extends AsynchronousProvider {
+    new (source: AsynchronousProvider): AsynchronousProvider;
+}
 /** Find a specific source provider in a database's provider stack. */
 export declare function findSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P;

package/provider/ThroughProvider.js

@@ -8,23 +8,23 @@ export class ThroughProvider extends Provider {
         super();
         this.source = source;
     }
-    get(ref) {
-        return this.source.get(ref);
+    getDocument(ref) {
+        return this.source.getDocument(ref);
     }
-    subscribe(ref, observer) {
-        return this.source.subscribe(ref, observer);
+    subscribeDocument(ref, observer) {
+        return this.source.subscribeDocument(ref, observer);
     }
-    add(ref, data) {
-        return this.source.add(ref, data);
+    addDocument(ref, data) {
+        return this.source.addDocument(ref, data);
     }
-    set(ref, data) {
-        return this.source.set(ref, data);
+    setDocument(ref, data) {
+        return this.source.setDocument(ref, data);
     }
-    update(ref, update) {
-        return this.source.update(ref, update);
+    updateDocument(ref, update) {
+        return this.source.updateDocument(ref, update);
     }
-    delete(ref) {
-        return this.source.delete(ref);
+    deleteDocument(ref) {
+        return this.source.deleteDocument(ref);
     }
     getQuery(ref) {
         return this.source.getQuery(ref);

package/provider/ValidationProvider.d.ts

@@ -1,17 +1,18 @@
 import type { DocumentReference, QueryReference } from "../db/Reference.js";
-import type { Data, Result, Entity } from "../util/data.js";
+import type { Data, OptionalData, OptionalEntity, Entities } from "../util/data.js";
 import type { DataUpdate } from "../update/DataUpdate.js";
-import { Observer, Unsubscriber } from "../util/observe.js";
+import type { PartialObserver } from "../observe/Observer.js";
+import type { Unsubscribe } from "../observe/Observable.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Validates any values that are read from or written to a source provider. */
 export declare class ValidationProvider extends ThroughProvider {
-    get<T extends Data>(ref: DocumentReference<T>): Result<Entity<T>> | PromiseLike<Result<Entity<T>>>;
-    subscribe<T extends Data>(ref: DocumentReference<T>, observer: Observer<Result>): Unsubscriber;
-    add<T extends Data>(ref: QueryReference<T>, data: T): string | PromiseLike<string>;
-    set<T extends Data>(ref: DocumentReference<T>, value: T): void | PromiseLike<void>;
-    update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void | PromiseLike<void>;
-    getQuery<T extends Data>(ref: QueryReference<T>): Iterable<Entity<T>> | PromiseLike<Iterable<Entity<T>>>;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Iterable<Entity<T>>>): Unsubscriber;
+    getDocument<T extends Data>(ref: DocumentReference<T>): OptionalEntity<T> | PromiseLike<OptionalEntity<T>>;
+    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: PartialObserver<OptionalData>): Unsubscribe;
+    addDocument<T extends Data>(ref: QueryReference<T>, data: T): string | PromiseLike<string>;
+    setDocument<T extends Data>(ref: DocumentReference<T>, value: T): void | PromiseLike<void>;
+    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: QueryReference<T>): Entities<T> | PromiseLike<Entities<T>>;
+    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: PartialObserver<Entities<T>>): Unsubscribe;
     setQuery<T extends Data>(ref: QueryReference<T>, value: T): number | PromiseLike<number>;
     updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): number | PromiseLike<number>;
 }