shelving 1.18.0 → 1.20.2

package/db/Pagination.js

@@ -1,60 +1,77 @@
-import { getFirstItem, getLastItem, assertLength, assertNumber, yieldMerged } from "../util/index.js";
-import { AbstractState, StreamClosedError } from "../stream/index.js";
+import { getFirstItem, getLastItem, assertLength, assertNumber, yieldMerged, toMap } from "../util/index.js";
+import { State } from "../stream/index.js";
+import { ConditionError } from "../index.js";
 /**
  * State that wraps a `Documents` reference to enable pagination.
  * - If you pass in initial values, it will use that as the first page.
  * - If you don't pass in initial values, it will autoload the first page.
  */
-export class Pagination extends AbstractState {
+export class Pagination extends State {
     constructor(ref) {
         super();
-        this._pending = false;
+        this.startLoading = false;
+        this.startDone = false;
+        this.endLoading = false;
+        this.endDone = false;
         /**
          * Load more results before the start.
          * - Promise that needs to be handled.
          */
-        this.backward = async () => {
+        this.loadStart = async () => {
             if (this.closed)
-                throw new StreamClosedError();
-            if (!this._pending) {
-                const entry = getFirstItem(this.value);
-                this._pending = true;
-                this.next(await (entry ? this.ref.before(entry[0], entry[1]).results : this.ref.results));
+                throw new ConditionError();
+            if (!this.startLoading) {
+                this.startLoading = true;
+                if (!this.loading) {
+                    const firstItem = getFirstItem(this.value);
+                    if (firstItem) {
+                        const next = await this.ref.after(firstItem[0], firstItem[1]).resultsMap;
+                        this.startDone = next.size < this.limit;
+                        this.startLoading = false;
+                        return this.merge(next);
+                    }
+                }
+                const next = await this.ref.resultsMap;
+                this.startDone = next.size < this.limit;
+                this.startLoading = false;
+                return this.next(next);
             }
         };
         /**
          * Load more results after the end.
          * - Promise that needs to be handled.
          */
-        this.forward = async () => {
+        this.loadEnd = async () => {
             if (this.closed)
-                throw new StreamClosedError();
-            if (!this._pending) {
-                const entry = getLastItem(this.value);
-                this._pending = true;
-                this.next(await (entry ? this.ref.after(entry[0], entry[1]).results : this.ref.results));
+                throw new ConditionError();
+            if (!this.endLoading) {
+                this.endLoading = true;
+                if (!this.loading) {
+                    const lastItem = getLastItem(this.value);
+                    if (lastItem) {
+                        const next = await this.ref.after(lastItem[0], lastItem[1]).resultsMap;
+                        this.endDone = next.size < this.limit;
+                        this.endLoading = false;
+                        return this.merge(next);
+                    }
+                }
+                const next = await this.ref.resultsMap;
+                this.endDone = next.size < this.limit;
+                this.endLoading = false;
+                return this.next(next);
             }
         };
         this.ref = ref;
         assertNumber(ref.limit); // Collection must have a numeric limit to paginate (otherwise you'd be retrieving the entire set of documents).
         assertLength(ref.sorts, 1, Infinity); // Collection must have at least one sort order to paginate.
+        this.limit = ref.limit;
     }
-    // Dispatch doesn't just dispatch the next value, it merges it into the current results and dispatches the combined results.
-    _derive(results) {
-        this._pending = false;
-        if (this.loading) {
-            // Merge the results into the existing results.
-            const current = this.value;
-            const next = new Map(this.ref.sorts.derive(yieldMerged(this.value, results)));
-            const change = next.size - current.size;
-            super._dispatch(next);
-            // Automatically complete the pagination if there are fewer entries than the slice limit.
-            if (typeof this.ref.limit === "number" && change < this.ref.limit)
-                this.complete();
-        }
-        else {
-            super._dispatch(new Map(results));
-        }
+    /**
+     * Merge more results into this pagination.
+     * @return The change in the number of results.
+     */
+    merge(more) {
+        this.next(toMap(this.ref.sorts.derive(yieldMerged(more, this.value))));
     }
     /** Iterate over the entries of the values currently in the pagination. */
     [Symbol.iterator]() {

package/db/errors.d.ts

@@ -1,19 +1,19 @@
-import type { Datas, Key } from "../util/index.js";
+import type { Data } from "../util/index.js";
 import { RequiredError, ValidationError } from "../error/index.js";
-import { Feedback } from "../feedback/index.js";
-import type { DatabaseDocument, DatabaseQuery } from "./Database.js";
+import type { Feedback } from "../feedback/index.js";
+import type { DataDocument, DataQuery } from "./Database.js";
 /** Thrown if a document doesn't exist. */
-export declare class DocumentRequiredError<D extends Datas, C extends Key<D>> extends RequiredError {
-    ref: DatabaseDocument<D, C>;
-    constructor(ref: DatabaseDocument<D, C>);
+export declare class DocumentRequiredError<T extends Data> extends RequiredError {
+    ref: DataDocument<T>;
+    constructor(ref: DataDocument<T>);
 }
 /** Thrown if a document can't validate. */
-export declare class DocumentValidationError<D extends Datas, C extends Key<D>> extends ValidationError {
-    ref: DatabaseDocument<D, C>;
-    constructor(ref: DatabaseDocument<D, C>, feedback: Feedback);
+export declare class DocumentValidationError<T extends Data> extends ValidationError {
+    ref: DataDocument<T>;
+    constructor(ref: DataDocument<T>, feedback: Feedback);
 }
 /** Thrown if a query can't validate a set of results. */
-export declare class QueryValidationError<D extends Datas, C extends Key<D>> extends ValidationError {
-    ref: DatabaseQuery<D, C>;
-    constructor(ref: DatabaseQuery<D, C>, feedback: Feedback);
+export declare class QueryValidationError<T extends Data> extends ValidationError {
+    ref: DataQuery<T>;
+    constructor(ref: DataQuery<T>, feedback: Feedback);
 }

package/error/ConditionError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Thrown if the program is in a condition it shouldn't have reached.
+ * e.g. writing to a stream that's already closed
+ */
+export declare class ConditionError extends Error {
+    constructor(message?: string);
+}

package/error/ConditionError.js

@@ -0,0 +1,10 @@
+/**
+ * Thrown if the program is in a condition it shouldn't have reached.
+ * e.g. writing to a stream that's already closed
+ */
+export class ConditionError extends Error {
+    constructor(message = "Invalid condition") {
+        super(message);
+    }
+}
+ConditionError.prototype.name = "ConditionError";

package/error/index.d.ts

@@ -3,3 +3,4 @@ export * from "./PermissionError.js";
 export * from "./RequiredError.js";
 export * from "./UnsupportedError.js";
 export * from "./ValidationError.js";
+export * from "./ConditionError.js";

package/error/index.js

@@ -3,3 +3,4 @@ export * from "./PermissionError.js";
 export * from "./RequiredError.js";
 export * from "./UnsupportedError.js";
 export * from "./ValidationError.js";
+export * from "./ConditionError.js";

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,19 +1,19 @@
 import type { Firestore } from "firebase/firestore";
-import { Results, Provider, DatabaseDocument, DatabaseQuery, Result, Observer, Transform, AsynchronousProvider, Datas, Key } from "../../index.js";
+import { Results, Provider, DataDocument, DataQuery, Result, Observer, Transform, AsynchronousProvider, Data } from "../../index.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
  * - Supports offline mode.
  * - Supports realtime subscriptions.
  */
-export declare class FirestoreClientProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
+export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<D, C>, observer: Observer<Result<D[C]>>): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Promise<Results<D[C]>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, observer: Observer<Results<D[C]>>): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,19 +1,19 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Results, Provider, DatabaseDocument, DatabaseQuery, Result, Transform, AsynchronousProvider, Datas, Key } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Result, Transform, AsynchronousProvider, Data, Results } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
  * - Does not support offline mode.
  * - Does not support realtime subscriptions.
  */
-export declare class FirestoreClientProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
+export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Promise<Result<D[C]>>;
+    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
     subscribe(): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Promise<Results<D[C]>>;
+    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery(): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,17 +1,17 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Results, Provider, DatabaseDocument, DatabaseQuery, Observer, Result, Transform, AsynchronousProvider, Datas, Key, Entry } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Observer, Result, Transform, Data, AsynchronousProvider, Entry, Results } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
  */
-export declare class FirestoreServerProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
+export declare class FirestoreServerProvider extends Provider implements AsynchronousProvider {
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<D, C>, observer: Observer<Result<D[C]>>): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Promise<Iterable<Entry<D[C]>>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, observer: Observer<Results<D[C]>>): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): () => void;
+    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): () => void;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
 }

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.18.0",
+	"version": "1.20.2",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -61,18 +61,18 @@
 		"@types/jest": "^27.0.3",
 		"@types/react": "^17.0.37",
 		"@types/react-dom": "^17.0.11",
-		"@typescript-eslint/eslint-plugin": "^5.4.0",
-		"@typescript-eslint/parser": "^5.4.0",
+		"@typescript-eslint/eslint-plugin": "^5.5.0",
+		"@typescript-eslint/parser": "^5.5.0",
+		"eslint": "^8.4.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-import": "^2.25.3",
 		"eslint-plugin-prettier": "^4.0.0",
-		"eslint": "^8.3.0",
-		"firebase": "^9.5.0",
+		"firebase": "^9.6.0",
+		"jest": "^27.4.3",
 		"jest-ts-webcompat-resolver": "^1.0.0",
-		"jest": "^27.3.1",
-		"prettier": "^2.5.0",
-		"react-dom": "^17.0.2",
+		"prettier": "^2.5.1",
 		"react": "^17.0.2",
+		"react-dom": "^17.0.2",
 		"ts-jest": "^27.0.7",
 		"typescript": "^4.5.2"
 	},

package/provider/BatchProvider.d.ts

@@ -1,5 +1,5 @@
-import { MutableObject, Result, Results, Observer, Unsubscriber, Observable, Datas, Key } from "../util/index.js";
-import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
+import { MutableObject, Result, Observer, Unsubscriber, Observable, Results, ResultsMap, Data } from "../util/index.js";
+import type { DataDocument, DataQuery } from "../db/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /**
  * Provider that batches multiple database reads from a source provider together, for efficiency.
@@ -10,17 +10,17 @@ import { ThroughProvider } from "./ThroughProvider.js";
  *
  * Basically makes any provider under it more efficient.
  */
-export declare class BatchProvider<D extends Datas> extends ThroughProvider<D> {
+export declare class BatchProvider extends ThroughProvider {
     /** List of currently ongoing get requests. */
     protected readonly _gets: MutableObject<Promise<any>>;
     /** List of currently ongoing subscription streams. */
     protected readonly _subs: MutableObject<Observable<any>>;
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Result<D[C]> | Promise<Result<D[C]>>;
+    get<T extends Data>(ref: DataDocument<T>): Result<T> | Promise<Result<T>>;
     /** Await a result and delete it from get requests when done. */
     private _awaitDocument;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<D, C>, observer: Observer<Result<D[C]>>): Unsubscriber;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Results<D[C]> | Promise<Results<D[C]>>;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | Promise<Results<T>>;
     /** Await a set of results and delete from get requests when done. */
     private _awaitDocuments;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, observer: Observer<Results<D[C]>>): Unsubscriber;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<ResultsMap<T>>): Unsubscriber;
 }

package/provider/BatchProvider.js

@@ -1,5 +1,5 @@
-import { isAsync } from "../util/index.js";
-import { getNextValue, LazyState, subscribeState } from "../stream/index.js";
+import { isAsync, toMap, DeriveObserver, awaitNext, } from "../util/index.js";
+import { LazyState } from "../stream/index.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** How long to wait after all subscriptions have ended to close the source subscription. */
 const STOP_DELAY = 2000;
@@ -42,15 +42,16 @@ export class BatchProvider extends ThroughProvider {
         const key = ref.toString();
         // TidyState completes itself `STOP_DELAY` milliseconds after its last observer unsubscribes.
         // States also send their most recently received value to any new observers.
-        const sub = ((_a = this._subs)[key] || (_a[key] = subscribeState(s => {
+        const sub = ((_a = this._subs)[key] || (_a[key] = new LazyState(STOP_DELAY).from(s => {
             var _a;
             const stop = super.subscribe(ref, s);
-            (_a = this._gets)[key] || (_a[key] = this._awaitDocument(ref, getNextValue(sub))); // The first value from the new subscription can be reused for any concurrent get requests.
+            // The first value from the new subscription can be reused for any concurrent get requests.
+            (_a = this._gets)[key] || (_a[key] = this._awaitDocument(ref, awaitNext(sub)));
             return () => {
                 delete this._subs[key];
                 stop();
             };
-        }, new LazyState(STOP_DELAY))));
+        })));
         return sub.subscribe(observer);
     }
     // Override to combine multiple requests into one.
@@ -63,11 +64,12 @@ export class BatchProvider extends ThroughProvider {
         return isAsync(result) ? (this._gets[key] = this._awaitDocuments(ref, result)) : result;
     }
     /** Await a set of results and delete from get requests when done. */
-    async _awaitDocuments(ref, asyncResult) {
-        const result = await asyncResult;
+    async _awaitDocuments(ref, asyncResults) {
+        // Convert the iterable to a map because it might be read multiple times.
+        const results = toMap(await asyncResults);
         const key = ref.toString();
         delete this._gets[key];
-        return result;
+        return results;
     }
     // Override to combine multiple subscriptions into one.
     subscribeQuery(ref, observer) {
@@ -75,15 +77,17 @@ export class BatchProvider extends ThroughProvider {
         const key = ref.toString();
         // TidyState completes itself `STOP_DELAY` milliseconds after its last observer unsubscribes.
         // States also send their most recently received value to any new observers.
-        const sub = ((_a = this._subs)[key] || (_a[key] = subscribeState(s => {
+        const sub = ((_a = this._subs)[key] || (_a[key] = new LazyState(STOP_DELAY).from(o => {
             var _a;
-            const stop = super.subscribeQuery(ref, s);
-            (_a = this._gets)[key] || (_a[key] = this._awaitDocuments(ref, getNextValue(sub))); // The first value from the subscription can be reused for any concurrent get requests.
+            // Convert the iterable to a map because it might be read multiple times.
+            const stop = super.subscribeQuery(ref, new DeriveObserver(toMap, o));
+            // The first value from the subscription can be reused for any concurrent get requests.
+            (_a = this._gets)[key] || (_a[key] = this._awaitDocuments(ref, awaitNext(sub)));
             return () => {
                 delete this._subs[key];
                 stop();
             };
-        }, new LazyState(STOP_DELAY))));
+        })));
         return sub.subscribe(observer);
     }
 }

package/provider/CacheProvider.d.ts

@@ -1,31 +1,31 @@
-import type { DatabaseDocument, DatabaseQuery } from "../db/index.js";
+import type { DataDocument, DataQuery } from "../db/index.js";
 import { Transform } from "../transform/index.js";
-import type { Result, Results, Unsubscriber, Observer, Datas, Key } from "../util/index.js";
+import { Result, Unsubscriber, Observer, Results, Data } from "../util/index.js";
 import type { Provider, AsynchronousProvider } from "./Provider.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Keep a copy of received data in a local cache. */
-export declare class CacheProvider<D extends Datas> extends ThroughProvider<D> implements AsynchronousProvider<D> {
+export declare class CacheProvider extends ThroughProvider implements AsynchronousProvider {
     /** The local cache provider. */
-    readonly cache: MemoryProvider<D>;
+    readonly cache: MemoryProvider;
     /** Last-known-correct time for data, indexed by key to power `getCachedAge()` etc. */
     private _times;
-    constructor(source: Provider<D>, cache?: MemoryProvider<D>);
+    constructor(source: Provider, cache?: MemoryProvider);
     /** Is a given document or query in the cache? */
-    isCached<C extends Key<D>>(ref: DatabaseDocument<D, C> | DatabaseQuery<D, C>): boolean;
+    isCached<T extends Data>(ref: DataDocument<T> | DataQuery<T>): boolean;
     /** Get the cache age for a given document or query reference. */
-    getCachedAge<C extends Key<D>>(ref: DatabaseDocument<D, C> | DatabaseQuery<D, C>): number;
+    getCachedAge<T extends Data>(ref: DataDocument<T> | DataQuery<T>): number;
     /** Cache an individual document result. */
     private _cacheResult;
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<D, C>, observer: Observer<Result<D[C]>>): Unsubscriber;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
     /** Cache a set of document results. */
     private _cacheResults;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Promise<Results<D[C]>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, observer: Observer<Results<D[C]>>): Unsubscriber;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/CacheProvider.js

@@ -1,5 +1,5 @@
 import { Transform } from "../transform/index.js";
-import { Stream } from "../stream/index.js";
+import { DeriveObserver } from "../util/index.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Keep a copy of received data in a local cache. */
@@ -23,23 +23,17 @@ export class CacheProvider extends ThroughProvider {
     }
     /** Cache an individual document result. */
     _cacheResult(ref, result) {
-        // Set or delete the result in the cache.
         this.cache.write(ref, result);
-        // Save the last-cached time.
         this._times[ref.toString()] = Date.now();
+        return result;
     }
     // Override to cache any got result.
     async get(ref) {
-        const result = await super.get(ref);
-        this._cacheResult(ref, result);
-        return result;
+        return this._cacheResult(ref, await super.get(ref));
     }
     // Override to cache any got results.
     subscribe(ref, observer) {
-        const stream = new Stream();
-        stream.on({ next: r => this._cacheResult(ref, r) });
-        stream.on(observer);
-        return super.subscribe(ref, stream);
+        return super.subscribe(ref, new DeriveObserver(result => this._cacheResult(ref, result), observer));
     }
     async add(ref, data) {
         const id = await super.add(ref, data);
@@ -56,7 +50,7 @@ export class CacheProvider extends ThroughProvider {
             this.cache.write(ref, value);
     }
     /** Cache a set of document results. */
-    _cacheResults(ref, results) {
+    *_cacheResults(ref, results) {
         // We know the received set of results is the 'complete' set of results for this query.
         // So for correctness any documents matching this query that aren't in the new set of results should be deleted.
         // None of this applies if there's a query limit, because the document could have been moved to a different page so shouldn't be deleted.
@@ -64,24 +58,21 @@ export class CacheProvider extends ThroughProvider {
             for (const id of Object.keys(this.cache.getQuery(ref)))
                 if (!(id in results))
                     this.cache.write(ref.doc(id), undefined);
-        // Save the new results to the cache.
-        for (const [id, data] of Object.entries(results))
+        // Save new results to the cache.
+        for (const [id, data] of results) {
             this.cache.write(ref.doc(id), data);
+            yield [id, data];
+        }
         // Save the last-cached time.
         this._times[ref.toString()] = Date.now();
     }
     // Override to cache any got results.
     async getQuery(ref) {
-        const results = await super.getQuery(ref);
-        this._cacheResults(ref, results);
-        return results;
+        return this._cacheResults(ref, await super.getQuery(ref));
     }
     // Override to cache any got results.
     subscribeQuery(ref, observer) {
-        const stream = new Stream();
-        stream.on({ next: r => this._cacheResults(ref, r) });
-        stream.on(observer);
-        return super.subscribeQuery(ref, stream);
+        return super.subscribeQuery(ref, new DeriveObserver(results => this._cacheResults(ref, results), observer));
     }
     async writeQuery(ref, value) {
         await super.writeQuery(ref, value);

package/provider/MemoryProvider.d.ts

@@ -1,23 +1,23 @@
-import { Result, Results, Unsubscriber, Observer, Datas, Key } from "../util/index.js";
+import { Data, Result, Results, Unsubscriber, Observer } from "../util/index.js";
 import { Transform } from "../transform/index.js";
-import { DatabaseQuery, DatabaseDocument } from "../db/index.js";
+import { DataQuery, DataDocument } from "../db/index.js";
 import { Provider, SynchronousProvider } from "./Provider.js";
 /**
  * Fast in-memory store for data.
  * - 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<D extends Datas> extends Provider<D> implements SynchronousProvider<D> {
+export declare class MemoryProvider extends Provider implements SynchronousProvider {
     /** List of tables in `{ path: Table }` format. */
     private _tables;
     private _table;
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Result<D[C]>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<D, C>, observer: Observer<Result<D[C]>>): Unsubscriber;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): string;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): void;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Results<D[C]>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, observer: Observer<Results<D[C]>>): Unsubscriber;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): void;
+    get<T extends Data>(ref: DataDocument<T>): Result<T>;
+    subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DataQuery<T>, data: T): string;
+    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void;
+    getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
+    subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
+    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/MemoryProvider.js

@@ -11,7 +11,7 @@ export class MemoryProvider extends Provider {
     constructor() {
         super(...arguments);
         /** List of tables in `{ path: Table }` format. */
-        this._tables = {};
+        this._tables = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
     }
     // Get a named collection (or create a new one).
     _table({ collection }) {