shelving 1.96.2 → 1.98.0

package/db/ItemReference.d.ts

@@ -1,8 +1,8 @@
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
 import type { ImmutableArray } from "../util/array.js";
+import type { Callback, ErrorCallback, StopCallback } from "../util/callback.js";
 import type { Data } from "../util/data.js";
-import type { Dispatch, Handler, Stop } from "../util/function.js";
 import type { Query } from "../util/query.js";
 import type { Updates } from "../util/update.js";
 /** Item data with a string ID that uniquely identifies it. */
@@ -10,7 +10,7 @@ export type ItemData<T extends Data = Data> = T & {
     id: string;
 };
 /** Entity or `null` to indicate the item doesn't exist. */
-export type ItemValue<T extends Data = Data> = ItemData<T> | null;
+export type ItemValue<T extends Data = Data> = ItemData<T> | undefined;
 /** Get the ID from item data. */
 export declare const getID: <T extends Data>({ id }: ItemData<T>) => string;
 /** Get the IDs of an iterable set item data. */
@@ -61,7 +61,7 @@ declare abstract class AbstractItemReference<T extends Data = Data> implements A
     getDelete(): DeleteChange;
     toString(): string;
     /** Subscribe to this item. */
-    subscribe(onNext?: Dispatch<[ItemValue<T>]>, onError?: Handler): Stop;
+    subscribe(onNext?: Callback<ItemValue<T>>, onError?: ErrorCallback): StopCallback;
     [Symbol.asyncIterator](): AsyncIterator<ItemValue<T>>;
 }
 /** Reference to an item in a synchronous database. */

package/db/ItemState.d.ts

@@ -1,6 +1,6 @@
 import type { AsyncItemReference, ItemData, ItemReference, ItemValue } from "./ItemReference.js";
+import type { StopCallback } from "../util/callback.js";
 import type { Data } from "../util/data.js";
-import type { Dispatch } from "../util/function.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
 /** Hold the current state of a item. */
@@ -18,5 +18,5 @@ export declare class ItemState<T extends Data = Data> extends State<ItemValue<T>
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number): void;
     /** Subscribe this state to the source provider. */
-    connectSource(): Dispatch;
+    connectSource(): StopCallback;
 }

package/db/ItemState.js

@@ -1,5 +1,5 @@
 import { CacheProvider } from "../provider/CacheProvider.js";
-import { LazyDeferredSequence } from "../sequence/LazyDeferredSequence.js";
+import { SwitchingDeferredSequence } from "../sequence/SwitchingDeferredSequence.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
 import { getRequired } from "../util/null.js";
@@ -18,16 +18,15 @@ export class ItemState extends State {
         var _a;
         const { provider, collection, id } = ref;
         const table = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
-        const time = table ? table.getItemTime(id) : null;
-        const isCached = typeof time === "number";
-        super(table && isCached ? table.getItem(id) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedItemSequence(id))) : undefined);
+        const time = table ? table.getQueryTime(ref) : null;
+        const next = table ? new SwitchingDeferredSequence(sequence => sequence.from(table.getCachedItemSequence(id))) : undefined;
+        super(table && typeof time === "number" ? { value: table.getItem(id), time, next } : { next });
         this.busy = new BooleanState();
         /** Refresh this state from the source provider. */
         this.refresh = () => {
             if (!this.busy.value)
                 void this._refresh();
         };
-        this._time = time;
         this.ref = ref;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
@@ -35,11 +34,12 @@ export class ItemState extends State {
     }
     async _refresh() {
         this.busy.set(true);
+        this.error(undefined); // Optimistically clear the error.
         try {
             this.set(await this.ref.value);
         }
         catch (thrown) {
-            this.next.reject(thrown);
+            this.error(thrown);
         }
         finally {
             this.busy.set(false);

package/db/QueryReference.d.ts

@@ -1,7 +1,7 @@
 import type { ItemArray, ItemData, ItemQuery, ItemValue } from "./ItemReference.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
+import type { Callback, ErrorCallback, StopCallback } from "../util/callback.js";
 import type { Data } from "../util/data.js";
-import type { Dispatch, Handler, Stop } from "../util/function.js";
 import type { Updates } from "../util/update.js";
 /** Reference to a set of items in a sync or async provider. */
 declare abstract class AbstractQueryReference<T extends Data = Data> implements AsyncIterable<ItemArray<T>> {
@@ -62,7 +62,7 @@ declare abstract class AbstractQueryReference<T extends Data = Data> implements
     abstract delete(): number | PromiseLike<number>;
     toString(): string;
     /** Subscribe to this item. */
-    subscribe(onNext?: Dispatch<[ItemArray<T>]>, onError?: Handler): Stop;
+    subscribe(onNext?: Callback<ItemArray<T>>, onError?: ErrorCallback): StopCallback;
     [Symbol.asyncIterator](): AsyncIterator<ItemArray<T>>;
 }
 /** Reference to a set of items in a provider. */

package/db/QueryState.d.ts

@@ -1,7 +1,7 @@
 import type { ItemArray, ItemData, ItemValue } from "./ItemReference.js";
 import type { AsyncQueryReference, QueryReference } from "./QueryReference.js";
+import type { StopCallback } from "../util/callback.js";
 import type { Data } from "../util/data.js";
-import type { Stop } from "../util/function.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
 /** Hold the current state of a query. */
@@ -31,7 +31,7 @@ export declare class QueryState<T extends Data = Data> extends State<ItemArray<T
     /** Refresh this state if data in the cache is older than `maxAge` (in milliseconds). */
     refreshStale(maxAge: number): void;
     /** Subscribe this state to the source provider. */
-    connectSource(): Stop;
+    connectSource(): StopCallback;
     /**
      * Load more items after the last once.
      * - Promise that needs to be handled.

package/db/QueryState.js

@@ -1,5 +1,5 @@
 import { CacheProvider } from "../provider/CacheProvider.js";
-import { LazyDeferredSequence } from "../sequence/LazyDeferredSequence.js";
+import { SwitchingDeferredSequence } from "../sequence/SwitchingDeferredSequence.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
 import { getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
@@ -41,8 +41,8 @@ export class QueryState extends State {
         const { provider, collection, query } = ref;
         const table = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
         const time = table ? table.getQueryTime(ref) : null;
-        const isCached = typeof time === "number";
-        super(table && isCached ? table.getQuery(ref) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedQuerySequence(ref))) : undefined);
+        const next = table ? new SwitchingDeferredSequence(sequence => sequence.from(table.getCachedQuerySequence(ref))) : undefined;
+        super(table && typeof time === "number" ? { value: table.getQuery(ref), time, next } : { next });
         this.busy = new BooleanState();
         this._hasMore = false;
         /** Refresh this state from the source provider. */
@@ -58,7 +58,6 @@ export class QueryState extends State {
             if (!this.busy.value)
                 void this._loadMore();
         };
-        this._time = time;
         this.ref = ref;
         this.limit = (_b = getLimit(query)) !== null && _b !== void 0 ? _b : Infinity;
         // Queue a request to refresh the value if it doesn't exist.
@@ -67,6 +66,7 @@ export class QueryState extends State {
     }
     async _refresh() {
         this.busy.set(true);
+        this.error(undefined); // Optimistically clear the error.
         try {
             const items = await this.ref.items;
             this._hasMore = items.length >= this.limit; // If the query returned {limit} or more items, we can assume there are more items waiting to be queried.
@@ -90,6 +90,7 @@ export class QueryState extends State {
     }
     async _loadMore() {
         this.busy.set(true);
+        this.error(undefined); // Optimistically clear the error.
         try {
             const last = this.last;
             const ref = last ? this.ref.with(getAfterQuery(this.ref.query, last)) : this.ref;
@@ -98,7 +99,7 @@ export class QueryState extends State {
             this._hasMore = items.length >= this.limit; // If the query returned {limit} or more items, we can assume there are more items waiting to be queried.
         }
         catch (thrown) {
-            this.next.reject(thrown);
+            this.error(thrown);
         }
         finally {
             this.busy.set(false);

package/firestore/client/FirestoreClientProvider.js

@@ -1,5 +1,5 @@
 import { addDoc, collection, deleteDoc, doc, documentId, getDoc, getDocs, increment, limit, onSnapshot, orderBy, query, setDoc, updateDoc, where } from "firebase/firestore";
-import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
+import { SwitchingDeferredSequence } from "../../sequence/SwitchingDeferredSequence.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
 import { mapItems } from "../../util/transform.js";
@@ -40,7 +40,8 @@ function _getItemData(snapshot) {
 }
 function _getItemValue(snapshot) {
     const data = snapshot.data();
-    return data ? { ...data, id: snapshot.id } : null;
+    if (data)
+        return { ...data, id: snapshot.id };
 }
 /** Convert `Updates` object into corresponding Firestore `FieldValue` instances. */
 const _getFieldValues = (updates) => getObject(mapItems(getUpdates(updates), _getFieldValue));
@@ -59,9 +60,9 @@ export class FirestoreClientProvider {
         return _getItemValue(await getDoc(doc(this._firestore, c, id)));
     }
     getItemSequence(c, id) {
-        return new LazyDeferredSequence(({ resolve, reject }) => onSnapshot(doc(this._firestore, c, id), //
+        return new SwitchingDeferredSequence(sequence => onSnapshot(doc(this._firestore, c, id), //
         //
-        snapshot => resolve(_getItemValue(snapshot)), reject));
+        snapshot => sequence.resolve(_getItemValue(snapshot)), reason => sequence.reject(reason)));
     }
     async addItem(c, data) {
         const reference = await addDoc(collection(this._firestore, c), data);
@@ -80,9 +81,9 @@ export class FirestoreClientProvider {
         return _getItems(await getDocs(_getQuery(this._firestore, c, q)));
     }
     getQuerySequence(c, q) {
-        return new LazyDeferredSequence(({ resolve, reject }) => onSnapshot(_getQuery(this._firestore, c, q), //
+        return new SwitchingDeferredSequence(sequence => onSnapshot(_getQuery(this._firestore, c, q), //
         //
-        snapshot => resolve(_getItems(snapshot)), reject));
+        snapshot => sequence.resolve(_getItems(snapshot)), reason => sequence.reject(reason)));
     }
     async setQuery(c, q, data) {
         const snapshot = await getDocs(_getQuery(this._firestore, c, q));

package/firestore/lite/FirestoreLiteProvider.js

@@ -37,7 +37,8 @@ function _getItemData(snapshot) {
 }
 function _getItemValue(snapshot) {
     const data = snapshot.data();
-    return data ? { ...data, id: snapshot.id } : null;
+    if (data)
+        return { ...data, id: snapshot.id };
 }
 /** Convert `Updates` object into corresponding Firestore `FieldValue` instances. */
 const _getFieldValues = (updates) => getObject(mapItems(getUpdates(updates), _getFieldValue));

package/firestore/server/FirestoreServerProvider.js

@@ -1,5 +1,5 @@
 import { FieldPath, FieldValue, Firestore } from "@google-cloud/firestore";
-import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
+import { SwitchingDeferredSequence } from "../../sequence/SwitchingDeferredSequence.js";
 import { getObject } from "../../util/object.js";
 import { getFilters, getLimit, getOrders } from "../../util/query.js";
 import { mapItems } from "../../util/transform.js";
@@ -39,7 +39,8 @@ function _getItemData(snapshot) {
 }
 function _getItemValue(snapshot) {
     const data = snapshot.data();
-    return data ? { ...data, id: snapshot.id } : null;
+    if (data)
+        return { ...data, id: snapshot.id };
 }
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
 const _getFieldValues = (updates) => getObject(mapItems(getUpdates(updates), _getFieldValue));
@@ -57,8 +58,8 @@ export class FirestoreServerProvider {
     }
     getItemSequence(c, id) {
         const ref = this._firestore.collection(c).doc(id);
-        return new LazyDeferredSequence(({ resolve, reject }) => ref.onSnapshot(snapshot => resolve(_getItemValue(snapshot)), //
-        reject));
+        return new SwitchingDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getItemValue(snapshot)), //
+        sequence.reject));
     }
     async addItem(c, data) {
         return (await this._firestore.collection(c).add(data)).id;
@@ -77,8 +78,8 @@ export class FirestoreServerProvider {
     }
     getQuerySequence(c, q) {
         const ref = _getQuery(this._firestore, c, q);
-        return new LazyDeferredSequence(({ resolve, reject }) => ref.onSnapshot(snapshot => resolve(_getItemArray(snapshot)), //
-        reject));
+        return new SwitchingDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getItemArray(snapshot)), //
+        sequence.reject));
     }
     async setQuery(c, q, data) {
         return await bulkWrite(this._firestore, c, q, (w, s) => void w.set(s.ref, data));

package/iterate/AbstractGenerator.d.ts

@@ -1,6 +1,6 @@
 /** Abstract generator designed to be extended that implements the full generator protocol. */
 export declare abstract class AbstractGenerator<T, R, N> implements Generator<T, R, N> {
-    readonly [Symbol.toStringTag]: string;
+    readonly [Symbol.toStringTag] = "Generator";
     abstract next(value: N): IteratorResult<T, R>;
     throw(thrown: Error | unknown): IteratorResult<T, R>;
     return(value: R): IteratorResult<T, R>;

package/iterate/AbstractGenerator.js

@@ -1,13 +1,9 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 var _a;
-import { setPrototype } from "../util/class.js";
 /** Abstract generator designed to be extended that implements the full generator protocol. */
 export class AbstractGenerator {
+    constructor() {
+        this[_a] = "Generator";
+    }
     throw(thrown) {
         // Default behaviour for a generator is to throw the error back out of the iterator and not continue.
         throw thrown;
@@ -21,6 +17,3 @@ export class AbstractGenerator {
         return this;
     }
 }
-__decorate([
-    setPrototype(Symbol.toStringTag, "Generator")
-], AbstractGenerator.prototype, _a, void 0);

package/package.json

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

package/provider/CacheProvider.js

@@ -37,12 +37,12 @@ export class CacheProvider {
     async getQuery(collection, query) {
         const items = await this.source.getQuery(collection, query);
         const table = this.memory.getTable(collection);
-        table.setQueryItems(query, items);
+        table.setQueryArray(query, items);
         return items;
     }
     async *getQuerySequence(collection, query) {
         const table = this.memory.getTable(collection);
-        yield* table.setQueryItemsSequence(query, this.source.getQuerySequence(collection, query));
+        yield* table.setQueryArraySequence(query, this.source.getQuerySequence(collection, query));
     }
     async setQuery(collection, query, data) {
         const count = await this.source.setQuery(collection, query, data);

package/provider/DebugProvider.js

@@ -2,31 +2,29 @@
 /** Provider that logs operations to a source provider to the console. */
 class AbstractDebugProvider {
     async *getItemSequence(collection, id) {
-        const key = _getItemKey(collection, id);
         try {
-            console.log("ITERATE", key, "DATA:");
+            console.debug("✔ ITERATE", collection, id);
             for await (const item of this.source.getItemSequence(collection, id)) {
-                console.log("ITERATE", key, "GOT:", item);
+                console.debug("✔ ITERATE", collection, id, "GOT", item);
                 yield item;
             }
-            console.log("ITERATE", key, "DONE");
+            console.debug("✔ ITERATE", collection, id);
         }
         catch (thrown) {
-            console.error("ITERATE", key, thrown);
+            console.error("✘ ITERATE", collection, id, thrown);
         }
     }
     async *getQuerySequence(collection, query) {
-        const key = _getQueryKey(collection, query);
         try {
-            console.log("ITERATE", key, "DATA:");
+            console.debug("✔ ITERATE", collection, query);
             for await (const items of this.source.getQuerySequence(collection, query)) {
-                console.log("ITERATE", key, "ITEMS:", items);
+                console.debug("✔ ITERATE", collection, query, items);
                 yield items;
             }
-            console.log("ITERATE", key, "DONE");
+            console.debug("✔ ITERATE", collection, query);
         }
         catch (thrown) {
-            console.error("ITERATE", key, thrown);
+            console.error("✘ ITERATE", collection, query, thrown);
         }
     }
 }
@@ -37,107 +35,98 @@ export class DebugProvider extends AbstractDebugProvider {
         this.source = source;
     }
     getItem(collection, id) {
-        const key = _getItemKey(collection, id);
         try {
             const item = this.source.getItem(collection, id);
-            console.log("GET:", key, "ITEM:", item);
+            console.debug("✔ GET", collection, id, "ITEM", item);
             return item;
         }
         catch (reason) {
-            console.error("GET:", key, "ERROR:", reason);
+            console.error("✘ GET", collection, id, reason);
             throw reason;
         }
     }
     addItem(collection, data) {
-        const key = collection;
         try {
             const id = this.source.addItem(collection, data);
-            console.log("ADD", key, "DATA:", data, "ID", id);
+            console.debug("✔ ADD", collection, data, "ID", id);
             return id;
         }
         catch (reason) {
-            console.error("ADD", key, "DATA:", data, "ERROR:", reason);
+            console.error("✘ ADD", collection, data, reason);
             throw reason;
         }
     }
     setItem(collection, id, data) {
-        const key = _getItemKey(collection, id);
         try {
             this.source.setItem(collection, id, data);
-            console.log("SET:", key, "DATA:", data);
+            console.debug("✔ SET", collection, id, data);
         }
         catch (reason) {
-            console.error("SET:", key, "DATA:", data, "ERROR:", reason);
+            console.error("✘ SET", collection, id, data, reason);
             throw reason;
         }
     }
     updateItem(collection, id, updates) {
-        const key = _getItemKey(collection, id);
         try {
-            console.log("UPDATE:", key, "UPDATES:", updates);
+            console.debug("✔ UPDATE", collection, id, updates);
             return this.source.updateItem(collection, id, updates);
         }
         catch (reason) {
-            console.error("UPDATE:", key, "UPDATES:", updates, "ERROR:", reason);
+            console.error("✘ UPDATE", collection, id, updates, reason);
             throw reason;
         }
     }
     deleteItem(collection, id) {
-        const key = _getItemKey(collection, id);
         try {
             this.source.deleteItem(collection, id);
-            console.log("DELETE:", key);
+            console.debug("✔ DELETE", collection, id);
         }
         catch (reason) {
-            console.error("DELETE:", key, "ERROR:", reason);
+            console.error("✘ DELETE", collection, id, reason);
             throw reason;
         }
     }
     getQuery(collection, query) {
-        const key = _getQueryKey(collection, query);
         try {
             const items = this.source.getQuery(collection, query);
-            console.log("GET:", key, "ITEMS:", items);
+            console.debug("✔ ✅ GET", collection, query, "ITEMS", items);
             return items;
         }
         catch (reason) {
-            console.error("GET:", key, "ERROR:", reason);
+            console.error("✘ GET", collection, query, reason);
             throw reason;
         }
     }
     setQuery(collection, query, data) {
-        const key = _getQueryKey(collection, query);
         try {
             const num = this.source.setQuery(collection, query, data);
-            console.log("SET:", key, "DATA:", data, "DONE:", num);
+            console.debug("✔ SET", collection, query, data, num);
             return num;
         }
         catch (reason) {
-            console.error("SET:", key, "DATA:", data, "ERROR:", reason);
+            console.error("✘ SET", collection, query, data, reason);
             throw reason;
         }
     }
     updateQuery(collection, query, updates) {
-        const key = _getQueryKey(collection, query);
         try {
             const num = this.source.updateQuery(collection, query, updates);
-            console.log("UPDATE:", key, "UPDATES:", updates, "DONE:", num);
+            console.debug("✔ UPDATE", collection, query, updates, num);
             return num;
         }
         catch (reason) {
-            console.error("UPDATE:", key, "UPDATES:", updates, "ERROR:", reason);
+            console.error("✘ UPDATE", collection, query, updates, reason);
             throw reason;
         }
     }
     deleteQuery(collection, query) {
-        const key = _getQueryKey(collection, query);
         try {
             const num = this.source.deleteQuery(collection, query);
-            console.log("DELETE:", key, "DONE:", num);
+            console.debug("✔ DELETE", collection, query, num);
             return num;
         }
         catch (reason) {
-            console.error("DELETE:", key, "ERROR:", reason);
+            console.error("✘ DELETE", collection, query, reason);
             throw reason;
         }
     }
@@ -149,119 +138,108 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
         this.source = source;
     }
     async getItem(collection, id) {
-        const key = _getItemKey(collection, id);
         try {
-            console.log("GET:", key);
+            console.debug("⋯ GET", collection, id);
             const item = await this.source.getItem(collection, id);
-            console.log("GET:", key, "ITEM:", item);
+            console.debug("✔ GET", collection, id, "ITEM", item);
             return item;
         }
         catch (reason) {
-            console.error("GET:", key, "ERROR:", reason);
+            console.error("✘ GET", collection, id, reason);
             throw reason;
         }
     }
     async addItem(collection, data) {
-        const key = collection;
         try {
-            console.log("ADD", key, "DATA:", data);
+            console.debug("⋯ ADD", collection, data);
             const id = await this.source.addItem(collection, data);
-            console.log("ADD", key, "DATA:", data, "ID:", id);
+            console.debug("✔ ADD", collection, id, data);
             return id;
         }
         catch (reason) {
-            console.error("ADD", key, "DATA:", data, "ERROR:", reason);
+            console.error("✘ ADD", collection, data, reason);
             throw reason;
         }
     }
     async setItem(collection, id, data) {
-        const key = _getItemKey(collection, id);
         try {
-            console.log("SET:", key, "DATA:", data);
+            console.debug("⋯ SET", collection, id, data);
             await this.source.setItem(collection, id, data);
-            console.log("SET:", key, "DATA:", data, "DONE:", 1);
+            console.debug("✔ SET", collection, id, data, 1);
         }
         catch (reason) {
-            console.error("SET:", key, "DATA:", data, "ERROR:", reason);
+            console.error("✘ SET", collection, id, data, reason);
             throw reason;
         }
     }
     async updateItem(collection, id, updates) {
-        const key = _getItemKey(collection, id);
         try {
-            console.log("UPDATE:", key, "UPDATES:", updates);
+            console.debug("⋯ UPDATE", collection, id, updates);
             await this.source.updateItem(collection, id, updates);
-            console.log("UPDATE:", key, "UPDATES:", updates, "DONE:", 1);
+            console.debug("✔ UPDATE", collection, id, updates, 1);
         }
         catch (reason) {
-            console.error("UPDATE:", key, "UPDATES:", updates, "ERROR:", reason);
+            console.error("✘ UPDATE", collection, id, updates, reason);
             throw reason;
         }
     }
     async deleteItem(collection, id) {
-        const key = _getItemKey(collection, id);
         try {
-            console.log("DELETE:", key);
+            console.debug("⋯ DELETE", collection, id);
             await this.source.deleteItem(collection, id);
-            console.log("DELETE:", key, "DONE:", 1);
+            console.debug("✔ DELETE", collection, id, 1);
         }
         catch (reason) {
-            console.error("DELETE:", key, "ERROR:", reason);
+            console.error("✘ DELETE", collection, id, reason);
             throw reason;
         }
     }
     async getQuery(collection, query) {
-        const key = _getQueryKey(collection, query);
         try {
-            console.log("GET:", key);
+            console.debug("⋯ GET", collection, query);
             const items = await this.source.getQuery(collection, query);
-            console.log("GET:", key, "ITEMS:", items);
+            console.debug("✔ GET", collection, query, "ITEMS", items);
             return items;
         }
         catch (reason) {
-            console.error("GET:", key, "ERROR:", reason);
+            console.error("✘ GET", collection, query, reason);
             throw reason;
         }
     }
     async setQuery(collection, query, data) {
-        const key = _getQueryKey(collection, query);
         try {
-            console.log("SET:", key, "DATA:", data);
+            console.debug("⋯ SET", collection, query, data);
             const num = await this.source.setQuery(collection, query, data);
-            console.log("SET:", key, "DATA:", data, "DONE:", num);
+            console.debug("✔ SET", collection, query, data, num);
             return num;
         }
         catch (reason) {
-            console.error("SET:", key, "DATA:", data, "ERROR:", reason);
+            console.error("✘ SET", collection, query, data, reason);
             throw reason;
         }
     }
     async updateQuery(collection, query, updates) {
-        const key = _getQueryKey(collection, query);
         try {
-            console.log("UPDATE:", key, "UPDATES:", updates);
+            console.debug("⋯ UPDATE", collection, query, updates);
             const num = await this.source.updateQuery(collection, query, updates);
-            console.log("UPDATE:", key, "UPDATES:", updates, "DONE:", num);
+            console.debug("✔ UPDATE", collection, query, updates, num);
             return num;
         }
         catch (reason) {
-            console.error("UPDATE:", key, "UPDATES:", updates, "ERROR:", reason);
+            console.error("✘ UPDATE", collection, query, updates, reason);
             throw reason;
         }
     }
     async deleteQuery(collection, query) {
-        const key = _getQueryKey(collection, query);
         try {
-            console.log("DELETE:", key);
+            console.debug("⋯ DELETE", collection, query);
             const num = await this.source.deleteQuery(collection, query);
-            console.log("DELETE:", key, "DONE:", num);
+            console.debug("✔ DELETE", collection, query, num);
             return num;
         }
         catch (reason) {
-            console.error("DELETE:", key, "ERROR:", reason);
+            console.error("✘ DELETE", collection, query, reason);
             throw reason;
         }
     }
 }
-const _getItemKey = (collection, id) => `${collection}/${id}`;
-const _getQueryKey = (collection, query) => `${collection}?${JSON.stringify(query)}`;