shelving 1.64.0 → 1.65.0

package/observe/util.d.ts

@@ -0,0 +1,24 @@
+import type { Transformer } from "../util/transform.js";
+import { Unsubscribe, Subscribable } from "./Observable.js";
+import { ConnectableObserver } from "./Observer.js";
+import { Subject } from "./Subject.js";
+/** Get a promise that resolves to the next value of a source subscribable. */
+export declare function awaitNext<T>(source: Subscribable<T>): Promise<T>;
+/** Get a promise that resolves when a source subscribable is complete. */
+export declare function awaitComplete<T>(source: Subscribable<T>): Promise<void>;
+/** Connect a connectable to a source subscribable but transform the value using a transform. */
+export declare function connectDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, TT>, target: ConnectableObserver<TT>): Unsubscribe;
+/** Connect a connectable to a source subscribable but transform the value using an async transform. */
+export declare function connectAsyncDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>, target: ConnectableObserver<TT>): Unsubscribe;
+/** Connect a connectable to a source subscribable, and return the connected connectable. */
+export declare function connected<T, C extends ConnectableObserver<T>>(source: Subscribable<T>, target: C): C;
+export declare function connected<T>(source: Subscribable<T>, target: ConnectableObserver<T>): Subject<T>;
+export declare function connected<T>(source: Subscribable<T>): Subject<T>;
+/** Connect a connectable to a source subscribable but transform the value using a transform, and return the connected connectable. */
+export declare function connectedDerived<T, TT, C extends ConnectableObserver<T>>(source: Subscribable<T>, transformer: Transformer<T, TT>, target: C): C;
+export declare function connectedDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, TT>, target: ConnectableObserver<T>): ConnectableObserver<TT>;
+export declare function connectedDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, TT>): Subject<TT>;
+/** Connect a connectable to a source subscribable but transform the value using an async transform, and return the connected connectable. */
+export declare function connectedAsyncDerived<T, TT, C extends ConnectableObserver<TT>>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>, target: C): C;
+export declare function connectedAsyncDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>, target: ConnectableObserver<T>): ConnectableObserver<TT>;
+export declare function connectedAsyncDerived<T, TT>(source: Subscribable<T>, transformer: Transformer<T, PromiseLike<TT>>): Subject<TT>;

package/observe/util.js

@@ -0,0 +1,34 @@
+import { subscribe } from "./Observable.js";
+import { TransformObserver } from "./TransformObserver.js";
+import { AsyncObserver } from "./AsyncObserver.js";
+import { OnceObserver } from "./OnceObserver.js";
+import { ThroughObserver } from "./ThroughObserver.js";
+import { Subject } from "./Subject.js";
+/** Get a promise that resolves to the next value of a source subscribable. */
+export function awaitNext(source) {
+    return new Promise((next, error) => new OnceObserver({ next, error }).connect(source));
+}
+/** Get a promise that resolves when a source subscribable is complete. */
+export function awaitComplete(source) {
+    return new Promise((complete, error) => new ThroughObserver({ complete, error }).connect(source));
+}
+/** Connect a connectable to a source subscribable but transform the value using a transform. */
+export function connectDerived(source, transformer, target) {
+    return target.connect(() => subscribe(source, new TransformObserver(transformer, target)));
+}
+/** Connect a connectable to a source subscribable but transform the value using an async transform. */
+export function connectAsyncDerived(source, transformer, target) {
+    return target.connect(() => subscribe(source, new TransformObserver(transformer, new AsyncObserver(target))));
+}
+export function connected(source, target = new Subject()) {
+    target.connect(source);
+    return target;
+}
+export function connectedDerived(source, transformer, target = new Subject()) {
+    connectDerived(source, transformer, target);
+    return target;
+}
+export function connectedAsyncDerived(source, transformer, target = new Subject()) {
+    connectAsyncDerived(source, transformer, target);
+    return target;
+}

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.64.0",
+	"version": "1.65.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/provider/BatchProvider.d.ts

@@ -1,8 +1,8 @@
 import type { MutableObject } from "../util/object.js";
 import type { DocumentReference, QueryReference } from "../db/Reference.js";
-import type { Entity, Data, Result } from "../util/data.js";
-import { ImmutableArray } from "../util/array.js";
-import { Observable, Observer, Unsubscriber } from "../util/observe.js";
+import type { Data, Entities, OptionalEntity } from "../util/data.js";
+import type { PartialObserver } from "../observe/Observer.js";
+import { Observable, Unsubscribe } from "../observe/Observable.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /**
  * Provider that batches multiple database reads from a source provider together, for efficiency.
@@ -18,12 +18,12 @@ export declare class BatchProvider extends ThroughProvider {
     protected readonly _gets: MutableObject<Promise<any>>;
     /** List of currently ongoing subscription streams. */
     protected readonly _subs: MutableObject<Observable<any>>;
-    get<T extends Data>(ref: DocumentReference<T>): Result<Entity<T>> | Promise<Result<Entity<T>>>;
+    getDocument<T extends Data>(ref: DocumentReference<T>): OptionalEntity<T> | Promise<OptionalEntity<T>>;
     /** Await a result and delete it from get requests when done. */
     private _awaitDocument;
-    subscribe<T extends Data>(ref: DocumentReference<T>, observer: Observer<Result<Entity<T>>>): Unsubscriber;
-    getQuery<T extends Data>(ref: QueryReference<T>): Iterable<Entity<T>> | Promise<Iterable<Entity<T>>>;
+    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: PartialObserver<OptionalEntity<T>>): Unsubscribe;
+    getQuery<T extends Data>(ref: QueryReference<T>): Entities<T> | Promise<Entities<T>>;
     /** Await a set of results and delete from get requests when done. */
-    private _awaitResults;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<ImmutableArray<Entity<T>>>): Unsubscriber;
+    private _awaitEntities;
+    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: PartialObserver<Entities<T>>): Unsubscribe;
 }

package/provider/BatchProvider.js

@@ -1,7 +1,6 @@
-import { getArray } from "../util/array.js";
-import { ArrayObserver, awaitNext } from "../util/observe.js";
 import { isAsync } from "../util/async.js";
-import { LazyState } from "../stream/LazyState.js";
+import { DelayedSelfClosingState } from "../state/SelfClosingState.js";
+import { awaitNext, connected } from "../observe/util.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** How long to wait after all subscriptions have ended to close the source subscription. */
 const STOP_DELAY = 2000;
@@ -23,38 +22,37 @@ export class BatchProvider extends ThroughProvider {
         this._subs = {}; // eslint-disable-line @typescript-eslint/no-explicit-any
     }
     // Override to combine multiple requests into one.
-    get(ref) {
+    getDocument(ref) {
         const key = ref.toString();
         const get = this._gets[key];
         if (get)
             return get;
-        const result = super.get(ref);
+        const result = super.getDocument(ref);
         return isAsync(result) ? (this._gets[key] = this._awaitDocument(ref, result)) : result;
     }
     /** Await a result and delete it from get requests when done. */
-    async _awaitDocument(ref, asyncResult) {
-        const result = await asyncResult;
+    async _awaitDocument(ref, asyncEntity) {
+        const result = await asyncEntity;
         const key = ref.toString();
         delete this._gets[key];
         return result;
     }
     // Override to combine multiple subscriptions into one.
-    subscribe(ref, observer) {
+    subscribeDocument(ref, observer) {
         var _a;
         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] = new LazyState(STOP_DELAY).from(s => {
+        // Subscribe a new `DelayedSelfClosingState` to the source.
+        // Self-closing state closes itself when it's not being used for `STOP_DELAY` milliseconds, which ends the source subscription too.
+        return ((_a = this._subs)[key] || (_a[key] = connected(s => {
             var _a;
-            const stop = super.subscribe(ref, s);
-            // 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)));
+            const stop = super.subscribeDocument(ref, s);
+            if (s instanceof DelayedSelfClosingState)
+                (_a = this._gets)[key] || (_a[key] = this._awaitDocument(ref, awaitNext(s))); // The first value from the new subscription can also power any concurrent get requests (which saves that separate request).
             return () => {
-                delete this._subs[key];
+                delete this._subs[key]; // Delete this subscription from subs to allow a new subscription to be made in future.
                 stop();
             };
-        })));
-        return sub.subscribe(observer);
+        }, new DelayedSelfClosingState(STOP_DELAY)))).subscribe(observer);
     }
     // Override to combine multiple requests into one.
     getQuery(ref) {
@@ -63,12 +61,11 @@ export class BatchProvider extends ThroughProvider {
         if (get)
             return get;
         const result = super.getQuery(ref);
-        return isAsync(result) ? (this._gets[key] = this._awaitResults(ref, result)) : result;
+        return isAsync(result) ? (this._gets[key] = this._awaitEntities(ref, result)) : result;
     }
     /** Await a set of results and delete from get requests when done. */
-    async _awaitResults(ref, asyncResults) {
-        // Convert the iterable to a map because it might be read multiple times.
-        const results = getArray(await asyncResults);
+    async _awaitEntities(ref, asyncEntities) {
+        const results = await asyncEntities;
         const key = ref.toString();
         delete this._gets[key];
         return results;
@@ -77,19 +74,17 @@ export class BatchProvider extends ThroughProvider {
     subscribeQuery(ref, observer) {
         var _a;
         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] = new LazyState(STOP_DELAY).from(o => {
+        // Subscribe a new `DelayedSelfClosingState` to the source.
+        // Self-closing state closes itself when it's not being used for `STOP_DELAY` milliseconds, which ends the source subscription too.
+        return ((_a = this._subs)[key] || (_a[key] = connected(s => {
             var _a;
-            // Convert the iterable to an array because it might be read multiple times.
-            const stop = super.subscribeQuery(ref, new ArrayObserver(o));
-            // The first value from the subscription can be reused for any concurrent get requests.
-            (_a = this._gets)[key] || (_a[key] = this._awaitResults(ref, awaitNext(sub)));
+            const stop = super.subscribeQuery(ref, s);
+            if (s instanceof DelayedSelfClosingState)
+                (_a = this._gets)[key] || (_a[key] = this._awaitEntities(ref, awaitNext(s))); // The first value from the subscription can also power any concurrent get requests (which saves that separate request).
             return () => {
-                delete this._subs[key];
+                delete this._subs[key]; // Delete this subscription from subs to allow a new subscription to be made in future.
                 stop();
             };
-        })));
-        return sub.subscribe(observer);
+        }, new DelayedSelfClosingState(STOP_DELAY)))).subscribe(observer);
     }
 }

package/provider/CacheProvider.d.ts

@@ -1,6 +1,7 @@
 import type { DocumentReference, QueryReference } from "../db/Reference.js";
-import type { Data, Result, Entity } from "../util/data.js";
-import { Observer, Unsubscriber } from "../util/observe.js";
+import type { Data, Entities, OptionalEntity } from "../util/data.js";
+import type { PartialObserver } from "../observe/Observer.js";
+import type { Unsubscribe } from "../observe/Observable.js";
 import { DataUpdate } from "../update/DataUpdate.js";
 import type { Provider, AsynchronousProvider } from "./Provider.js";
 import { MemoryProvider } from "./MemoryProvider.js";
@@ -8,26 +9,16 @@ import { ThroughProvider } from "./ThroughProvider.js";
 /** Keep a copy of received data in a local cache. */
 export declare class CacheProvider extends ThroughProvider implements AsynchronousProvider {
     /** The local cache provider. */
-    readonly cache: MemoryProvider;
-    /** Last-known-correct time for data, indexed by key to power `getCachedAge()` etc. */
-    private _times;
+    readonly memory: MemoryProvider;
     constructor(source: Provider, cache?: MemoryProvider);
-    /** Is a given document or query in the cache? */
-    isCached<T extends Data>(ref: DocumentReference<T> | QueryReference<T>): boolean;
-    /** Get the cache age for a given document or query reference. */
-    getCachedAge<T extends Data>(ref: DocumentReference<T> | QueryReference<T>): number;
-    /** Cache an individual document result. */
-    private _cacheResult;
-    get<T extends Data>(ref: DocumentReference<T>): Promise<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): Promise<string>;
-    set<T extends Data>(ref: DocumentReference<T>, data: T): Promise<void>;
-    update<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): Promise<void>;
-    delete<T extends Data>(ref: DocumentReference<T>): Promise<void>;
-    /** Cache a set of document entries. */
-    private _cacheEntities;
-    getQuery<T extends Data>(ref: QueryReference<T>): Promise<Iterable<Entity<T>>>;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Iterable<Entity<T>>>): Unsubscriber;
+    getDocument<T extends Data>(ref: DocumentReference<T>): Promise<OptionalEntity<T>>;
+    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: PartialObserver<OptionalEntity<T>>): Unsubscribe;
+    addDocument<T extends Data>(ref: QueryReference<T>, data: T): Promise<string>;
+    setDocument<T extends Data>(ref: DocumentReference<T>, data: T): Promise<void>;
+    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): Promise<void>;
+    deleteDocument<T extends Data>(ref: DocumentReference<T>): Promise<void>;
+    getQuery<T extends Data>(ref: QueryReference<T>): Promise<Entities<T>>;
+    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: PartialObserver<Entities<T>>): Unsubscribe;
     setQuery<T extends Data>(ref: QueryReference<T>, data: T): Promise<number>;
     updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): Promise<number>;
     deleteQuery<T extends Data>(ref: QueryReference<T>): Promise<number>;

package/provider/CacheProvider.js

@@ -1,108 +1,74 @@
-import { TransformObserver } from "../util/observe.js";
+import { TransformObserver } from "../observe/TransformObserver.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
 /** Keep a copy of received data in a local cache. */
 export class CacheProvider extends ThroughProvider {
     constructor(source, cache = new MemoryProvider()) {
         super(source);
-        /** Last-known-correct time for data, indexed by key to power `getCachedAge()` etc. */
-        this._times = {};
-        this.cache = cache;
-    }
-    /** Is a given document or query in the cache? */
-    isCached(ref) {
-        const key = ref.toString();
-        return typeof this._times[key] === "number";
-    }
-    /** Get the cache age for a given document or query reference. */
-    getCachedAge(ref) {
-        const key = ref.toString();
-        const time = this._times[key];
-        return typeof time !== "number" ? Infinity : Date.now() - time;
-    }
-    /** Cache an individual document result. */
-    _cacheResult(ref, result) {
-        result ? this.cache.table(ref).set(result) : this.cache.table(ref).delete(ref.id);
-        this._times[`${ref.collection}.${ref.id}`] = Date.now();
-        return result;
+        this.memory = cache;
     }
     // Override to cache any got result.
-    async get(ref) {
-        return this._cacheResult(ref, await super.get(ref));
+    async getDocument(ref) {
+        const table = this.memory.getTable(ref);
+        const result = await super.getDocument(ref);
+        result ? table.setEntity(result) : table.deleteDocument(ref.id);
+        return result;
     }
     // Override to cache any got results.
-    subscribe(ref, observer) {
-        return super.subscribe(ref, new TransformObserver(result => this._cacheResult(ref, result), observer));
-    }
-    async add(ref, data) {
-        const id = await super.add(ref, data);
-        const { collection } = ref;
-        this.cache.table(ref).set({ id, ...data });
-        this._times[`${collection}.${id}`] = Date.now();
+    subscribeDocument(ref, observer) {
+        const table = this.memory.getTable(ref);
+        return super.subscribeDocument(ref, new TransformObserver((result) => {
+            result ? table.setEntity(result) : table.deleteDocument(ref.id);
+            return result;
+        }, observer));
+    }
+    async addDocument(ref, data) {
+        const id = await super.addDocument(ref, data);
+        this.memory.getTable(ref).setDocument(id, data);
         return id;
     }
-    async set(ref, data) {
-        await super.set(ref, data);
-        const { collection, id } = ref;
-        this.cache.table(ref).set({ id, ...data });
-        this._times[`${collection}.${id}`] = Date.now();
-    }
-    async update(ref, update) {
-        await super.update(ref, update);
-        // Update the document in the cache if it exists using `updateDocuments()` and an `id` query.
-        // Using `updateDocument()` would throw `RequiredError` if the document didn't exist.
-        this.cache.updateQuery(ref.optional, update);
-        // Don't update `_times` because we're not refreshing all the data.
+    async setDocument(ref, data) {
+        await super.setDocument(ref, data);
+        this.memory.getTable(ref).setDocument(ref.id, data);
     }
-    async delete(ref) {
-        await super.delete(ref);
-        const { collection, id } = ref;
-        this.cache.delete(ref);
-        this._times[`${collection}.${id}`] = Date.now();
+    async updateDocument(ref, update) {
+        await super.updateDocument(ref, update);
+        // Update the cache but only if the document exists.
+        const table = this.memory.getTable(ref);
+        if (table.getDocument(ref.id))
+            table.updateDocument(ref.id, update);
     }
-    /** Cache a set of document entries. */
-    *_cacheEntities(ref, entities) {
-        // 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.
-        if (!ref.limit)
-            for (const id of Object.keys(this.cache.getQuery(ref)))
-                if (!(id in entities))
-                    this.cache.delete(ref.doc(id));
-        // Save new results to the cache.
-        const { collection } = ref;
-        const now = Date.now();
-        const table = this.cache.table(ref);
-        for (const entity of entities) {
-            const { id } = entity;
-            table.set(entity);
-            this._times[`${collection}.${id}`] = now;
-            yield entity;
-        }
-        // Save the last-cached time.
-        this._times[ref.toString()] = now;
+    async deleteDocument(ref) {
+        await super.deleteDocument(ref);
+        this.memory.deleteDocument(ref);
     }
     // Override to cache any got results.
     async getQuery(ref) {
-        return this._cacheEntities(ref, await super.getQuery(ref));
+        const entities = await super.getQuery(ref);
+        this.memory.getTable(ref).setEntities(ref, entities);
+        return entities;
     }
     // Override to cache any got results.
     subscribeQuery(ref, observer) {
-        return super.subscribeQuery(ref, new TransformObserver(entries => this._cacheEntities(ref, entries), observer));
+        const table = this.memory.getTable(ref);
+        return super.subscribeQuery(ref, new TransformObserver((entities) => {
+            table.setEntities(ref, entities);
+            return entities;
+        }, observer));
     }
     async setQuery(ref, data) {
         const count = await super.setQuery(ref, data);
-        this.cache.setQuery(ref, data);
+        this.memory.setQuery(ref, data);
         return count;
     }
     async updateQuery(ref, update) {
         const count = await super.updateQuery(ref, update);
-        this.cache.updateQuery(ref, update);
+        this.memory.updateQuery(ref, update);
         return count;
     }
     async deleteQuery(ref) {
         const count = await super.deleteQuery(ref);
-        this.cache.deleteQuery(ref);
+        this.memory.deleteQuery(ref);
         return count;
     }
 }

package/provider/DebugProvider.d.ts

@@ -0,0 +1,20 @@
+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 { PartialObserver } from "../observe/Observer.js";
+import type { Unsubscribe } from "../observe/Observable.js";
+import { ThroughProvider } from "./ThroughProvider.js";
+/** Provider that logs its operations to the console for debugging purposes. */
+export declare class DebugProvider extends ThroughProvider {
+    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>;
+}

package/provider/DebugProvider.js

@@ -0,0 +1,170 @@
+/* eslint-disable no-console */
+import { isAsync } from "../util/async.js";
+import { ThroughObserver } from "../observe/ThroughObserver.js";
+import { ThroughProvider } from "./ThroughProvider.js";
+/** Provider that logs its operations to the console for debugging purposes. */
+export class DebugProvider extends ThroughProvider {
+    getDocument(ref) {
+        console.log(`Get "${ref}"`);
+        try {
+            const result = super.getDocument(ref);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error getting "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error getting "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    subscribeDocument(ref, observer) {
+        console.log(`Subscribe "${ref}"`);
+        return super.subscribeDocument(ref, new DatabaseDebugObserver(ref, observer));
+    }
+    addDocument(ref, data) {
+        console.log(`Add to "${ref}"`, data);
+        try {
+            const result = super.addDocument(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error adding to "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error adding to "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    setDocument(ref, data) {
+        console.log(`Set "${ref}"`, data);
+        try {
+            const result = super.setDocument(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error setting "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error setting "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    updateDocument(ref, update) {
+        console.log(`Update "${ref}"`, update.updates);
+        try {
+            const result = super.updateDocument(ref, update);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error updating "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error updating "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    deleteDocument(ref) {
+        console.log(`Delete "${ref}"`);
+        try {
+            const result = super.deleteDocument(ref);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error deleting "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error deleting "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    getQuery(ref) {
+        console.log(`Get "${ref}"`);
+        try {
+            const results = super.getQuery(ref);
+            return isAsync(results)
+                ? results.then(undefined, reason => {
+                    console.error(`Error getting "${ref}"`, reason);
+                    throw reason;
+                })
+                : results;
+        }
+        catch (reason) {
+            console.error(`Error getting "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    subscribeQuery(ref, observer) {
+        console.log(`Subscribe "${ref}"`);
+        return super.subscribeQuery(ref, new DatabaseDebugObserver(ref, observer));
+    }
+    setQuery(ref, data) {
+        console.log(`Set "${ref}"`, data);
+        try {
+            const result = super.setQuery(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error setting "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error setting "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    updateQuery(ref, update) {
+        console.log(`Update "${ref}"`, update.updates);
+        try {
+            const result = super.updateQuery(ref, update);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error updating "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error updating "${ref}"`, reason);
+            throw reason;
+        }
+    }
+    deleteQuery(ref) {
+        console.log(`Delete "${ref}"`);
+        try {
+            const result = super.deleteQuery(ref);
+            return isAsync(result)
+                ? result.then(undefined, reason => {
+                    console.error(`Error writing "${ref}"`, reason);
+                    throw reason;
+                })
+                : result;
+        }
+        catch (reason) {
+            console.error(`Error writing "${ref}"`, reason);
+            throw reason;
+        }
+    }
+}
+/** Observer that wraps errors in subscriptions in `ReferenceReadError` */
+class DatabaseDebugObserver extends ThroughObserver {
+    constructor(ref, target) {
+        super(target);
+        this.ref = ref;
+    }
+    error(reason) {
+        console.log(`Error in subscription to ${this.ref}`, reason);
+        super.error(reason);
+    }
+}