shelving 1.96.1 → 1.97.0

package/db/ItemReference.d.ts

@@ -1,8 +1,9 @@
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
+import type { Stop } from "../util/activity.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Data } from "../util/data.js";
-import type { Dispatch, Handler, Stop } from "../util/function.js";
+import type { Dispatch, Handler } 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 +11,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 +62,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?: Dispatch<ItemValue<T>>, onError?: Handler): Stop;
     [Symbol.asyncIterator](): AsyncIterator<ItemValue<T>>;
 }
 /** Reference to an item in a synchronous database. */

package/db/ItemState.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 LazyDeferredSequence(() => this.from(table.getCachedItemSequence(id), () => typeof table.getItemTime(id) === "number")) : 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,8 @@
 import type { ItemArray, ItemData, ItemQuery, ItemValue } from "./ItemReference.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
+import type { Stop } from "../util/activity.js";
 import type { Data } from "../util/data.js";
-import type { Dispatch, Handler, Stop } from "../util/function.js";
+import type { Dispatch, Handler } 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 +63,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?: Dispatch<ItemArray<T>>, onError?: Handler): Stop;
     [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 { Stop } from "../util/activity.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. */

package/db/QueryState.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 LazyDeferredSequence(() => this.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

@@ -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));

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

@@ -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));

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.96.1",
+	"version": "1.97.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)}`;

package/provider/MemoryProvider.d.ts

@@ -13,14 +13,14 @@ export declare class MemoryProvider implements Provider {
     private _tables;
     /** Get a table for a collection. */
     getTable(collection: string): MemoryTable;
-    getDocumentTime(collection: string, id: string): number | null;
+    getItemTime(collection: string, id: string): number | undefined;
     getItem(collection: string, id: string): ItemValue;
     getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
     addItem(collection: string, data: Data): string;
-    setItem(collection: string, id: string, data: Data): void;
-    updateItem(collection: string, id: string, updates: Updates): void;
-    deleteItem(collection: string, id: string): void;
-    getQueryTime(collection: string, query: ItemQuery): number | null;
+    setItem(collection: string, id: string, data: Data): boolean;
+    updateItem(collection: string, id: string, updates: Updates): boolean;
+    deleteItem(collection: string, id: string): boolean;
+    getQueryTime(collection: string, query: ItemQuery): number | undefined;
     getQuery(collection: string, query: ItemQuery): ItemArray;
     getQuerySequence(collection: string, query: ItemQuery): AsyncIterable<ItemArray>;
     setQuery(collection: string, query: ItemQuery, data: Data): number;
@@ -35,28 +35,27 @@ export declare class MemoryTable<T extends Data = Data> {
     protected readonly _times: Map<string, number>;
     /** Deferred sequence of next values. */
     readonly _changed: DeferredSequence<void, void>;
-    getItemTime(id: string): number | null;
+    getItemTime(id: string): number | undefined;
     getItem(id: string): ItemValue<T>;
     getItemSequence(id: string): AsyncIterable<ItemValue<T>>;
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
     getCachedItemSequence(id: string): AsyncIterable<ItemValue<T>>;
     addItem(data: T): string;
-    private _setItemData;
-    setItem(id: string, item: ItemData<T> | T): void;
-    setItemValue(id: string, value: ItemData<T> | T | null): void;
+    setItemData(item: ItemData<T>): boolean;
+    setItem(id: string, item: ItemData<T> | T): boolean;
+    setItemValue(id: string, value: ItemData<T> | T | undefined): boolean;
     setItemValueSequence(id: string, sequence: AsyncIterable<ItemValue<T>>): AsyncIterable<ItemValue>;
-    updateItem(id: string, updates: Updates<T>): void;
-    deleteItem(id: string): void;
-    getQueryTime(query: ItemQuery<T>): number | null;
+    updateItem(id: string, updates: Updates<T>): boolean;
+    deleteItem(id: string): boolean;
+    getQueryTime(query: ItemQuery<T>): number | undefined;
     getQuery(query: ItemQuery<T>): ItemArray<T>;
     getQuerySequence(query: ItemQuery<T>): AsyncIterable<ItemArray<T>>;
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
     getCachedQuerySequence(query: ItemQuery<T>): AsyncIterable<ItemArray<T>>;
-    private _setItems;
-    setItems(items: ItemArray<T>): void;
-    setItemsSequence(sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
-    setQueryItems(query: ItemQuery<T>, items: ItemArray<T>): void;
-    setQueryItemsSequence(query: ItemQuery<T>, sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
+    setItemArray(items: ItemArray<T>): number;
+    setItemArraySequence(sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
+    setQueryArray(query: ItemQuery<T>, items: ItemArray<T>): void;
+    setQueryArraySequence(query: ItemQuery<T>, sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
     setQuery(query: ItemQuery<T>, data: T): number;
     updateQuery(query: ItemQuery<T>, updates: Updates<T>): number;
     deleteQuery(query: ItemQuery<T>): number;