shelving 1.26.1 → 1.27.0

package/db/Database.d.ts

@@ -81,19 +81,19 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
      * @param data Complete data to set the document to.
      * @return Nothing (possibly promised).
      */
-    set(data: T): void | PromiseLike<void>;
+    set(data: T): number | PromiseLike<number>;
     /**
      * Update all matching documents with the same partial value.
      *
      * @param updates `Update` instance or set of updates to apply to every matching document.
      * @return Nothing (possibly promised).
      */
-    update(updates: Update<T> | PropUpdates<T>): void | PromiseLike<void>;
+    update(updates: Update<T> | PropUpdates<T>): number | PromiseLike<number>;
     /**
      * Delete all matching documents.
      * @return Nothing (possibly promised).
      */
-    delete(): void | PromiseLike<void>;
+    delete(): number | PromiseLike<number>;
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator](): Iterator<Entry<T>, void>;
     /** Validate a set of results for this query reference. */

package/firestore/client/FirestoreClientProvider.d.ts

@@ -17,7 +17,7 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -109,22 +109,18 @@ export class FirestoreClientProvider extends Provider {
     }
     async setQuery(ref, data) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
-        if (data instanceof Update) {
-            const updates = getFieldValues(data);
-            await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, updates)));
-        }
-        else if (data)
-            await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
-        else
-            await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
+        await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
+        return snapshot.size;
     }
     async updateQuery(ref, updates) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         const fieldValues = getFieldValues(updates);
         await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
+        return snapshot.size;
     }
     async deleteQuery(ref) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
+        return snapshot.size;
     }
 }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -17,7 +17,7 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery(): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
 }

package/firestore/lite/FirestoreLiteProvider.js

@@ -110,14 +110,17 @@ export class FirestoreClientProvider extends Provider {
     async setQuery(ref, data) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
+        return snapshot.size;
     }
     async updateQuery(ref, updates) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         const fieldValues = getFieldValues(updates);
         await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
+        return snapshot.size;
     }
     async deleteQuery(ref) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
+        return snapshot.size;
     }
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -15,7 +15,7 @@ export declare class FirestoreServerProvider extends Provider implements Asynchr
     delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Iterable<Entry<T>>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T | Update<T> | undefined): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
 }

package/firestore/server/FirestoreServerProvider.js

@@ -104,28 +104,31 @@ export class FirestoreServerProvider extends Provider {
         return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async setQuery(ref, data) {
-        await bulkWrite(this.firestore, ref, (w, s) => void w.set(s.ref, data));
+        return await bulkWrite(this.firestore, ref, (w, s) => void w.set(s.ref, data));
     }
     async updateQuery(ref, updates) {
         const fieldValues = getFieldValues(updates);
-        await bulkWrite(this.firestore, ref, (w, s) => void w.update(s.ref, fieldValues));
+        return await bulkWrite(this.firestore, ref, (w, s) => void w.update(s.ref, fieldValues));
     }
     async deleteQuery(ref) {
-        await bulkWrite(this.firestore, ref, (w, s) => void w.delete(s.ref));
+        return await bulkWrite(this.firestore, ref, (w, s) => void w.delete(s.ref));
     }
 }
 /** Perform a bulk update on a set of documents using a `BulkWriter` */
 async function bulkWrite(firestore, ref, callback) {
+    let count = 0;
     const writer = firestore.bulkWriter();
     const query = getQuery(firestore, ref).limit(BATCH_SIZE).select(); // `select()` turs the query into a field mask query (with no field masks) which saves data transfer and memory.
     let current = query;
     while (current) {
-        const snapshot = await current.get();
-        for (const s of snapshot.docs)
+        const { docs, size } = await current.get();
+        count += size;
+        for (const s of docs)
             callback(writer, s);
-        current = snapshot.size >= BATCH_SIZE && query.startAfter(snapshot.docs.pop()).select();
+        current = size >= BATCH_SIZE && query.startAfter(docs.pop()).select();
         void writer.flush();
     }
     await writer.close();
+    return count;
 }
 const BATCH_SIZE = 1000;

package/package.json

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

package/provider/CacheProvider.d.ts

@@ -27,9 +27,9 @@ export declare class CacheProvider extends ThroughProvider implements Asynchrono
     private _cacheResults;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): Promise<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/CacheProvider.js

@@ -79,16 +79,19 @@ export class CacheProvider extends ThroughProvider {
         return super.subscribeQuery(ref, new TransformObserver(results => this._cacheResults(ref, results), observer));
     }
     async setQuery(ref, data) {
-        await super.setQuery(ref, data);
+        const count = await super.setQuery(ref, data);
         this.cache.setQuery(ref, data);
+        return count;
     }
     async updateQuery(ref, updates) {
-        await super.updateQuery(ref, updates);
+        const count = await super.updateQuery(ref, updates);
         this.cache.updateQuery(ref, updates);
+        return count;
     }
     async deleteQuery(ref) {
-        await super.deleteQuery(ref);
+        const count = await super.deleteQuery(ref);
         this.cache.deleteQuery(ref);
+        return count;
     }
     /** Reset this provider and clear all data. */
     reset() {

package/provider/MemoryProvider.d.ts

@@ -19,9 +19,9 @@ export declare class MemoryProvider extends Provider implements SynchronousProvi
     delete<T extends Data>(ref: DataDocument<T>): void;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): void;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): void;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): number;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): number;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/MemoryProvider.js

@@ -86,22 +86,34 @@ export class MemoryProvider extends Provider {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+        let count = 0;
+        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data)) {
             table.write(id, data);
+            count++;
+        }
+        return count;
     }
     updateQuery(ref, updates) {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id, existing] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+        let count = 0;
+        for (const [id, existing] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data)) {
             table.write(id, updates.transform(existing));
+            count++;
+        }
+        return count;
     }
     deleteQuery(ref) {
         const table = this._table(ref);
         // If there's a limit set: run the full query.
         // If there's no limit set: only need to run the filtering (more efficient because sort order doesn't matter).
-        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data))
+        let count = 0;
+        for (const [id] of ref.limit ? ref.transform(table.data) : ref.filters.transform(table.data)) {
             table.write(id, undefined);
+            count++;
+        }
+        return count;
     }
     /** Reset this provider and clear all data. */
     reset() {

package/provider/Provider.d.ts

@@ -77,20 +77,23 @@ export declare abstract class Provider {
      *
      * @param ref Documents reference specifying which collection to set.
      * @param value Value to set the document to.
+     * @return Number of documents that were set.
      */
-    abstract setQuery<T extends Data>(ref: DataQuery<T>, data: T): void | PromiseLike<void>;
+    abstract setQuery<T extends Data>(ref: DataQuery<T>, data: T): number | PromiseLike<number>;
     /**
      * Update the data of all matching documents.
      *
      * @param ref Documents reference specifying which collection to set.
      * @param updates Update instance to set the document to.
+     * @return Number of documents that were updated.
      */
-    abstract updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void | PromiseLike<void>;
+    abstract updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
     /**
      * Delete all matching documents.
      * @param ref Document reference specifying which document to delete.
+     * @return Number of documents that were deleted.
      */
-    abstract deleteQuery<T extends Data>(ref: DataQuery<T>): void | PromiseLike<void>;
+    abstract deleteQuery<T extends Data>(ref: DataQuery<T>): number | PromiseLike<number>;
 }
 /** Provider with a fully synchronous interface */
 export interface SynchronousProvider extends Provider {
@@ -100,9 +103,9 @@ export interface SynchronousProvider extends Provider {
     update<T extends Data>(ref: DataDocument<T>, value: Update<T>): void;
     delete<T extends Data>(ref: DataDocument<T>): void;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T>;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): void;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): void;
+    setQuery<T extends Data>(ref: DataQuery<T>, value: T): number;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): number;
 }
 /** Provider with a fully asynchronous interface */
 export interface AsynchronousProvider extends Provider {
@@ -112,7 +115,7 @@ export interface AsynchronousProvider extends Provider {
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): PromiseLike<void>;
     delete<T extends Data>(ref: DataDocument<T>): PromiseLike<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<Results<T>>;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): PromiseLike<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): PromiseLike<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, value: T): PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): PromiseLike<number>;
 }

package/provider/ThroughProvider.d.ts

@@ -16,9 +16,9 @@ export declare class ThroughProvider extends Provider {
     delete<T extends Data>(ref: DataDocument<T>): void | PromiseLike<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, data: T): void | PromiseLike<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void | PromiseLike<void>;
-    deleteQuery<T extends Data>(ref: DataQuery<T>): void | PromiseLike<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, data: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): number | PromiseLike<number>;
 }
 /** Find a specific source provider in a database's provider stack. */
 export declare function findSourceProvider<P extends Provider>(provider: Provider, type: Class<P>): P;

package/provider/ValidationProvider.d.ts

@@ -11,6 +11,6 @@ export declare class ValidationProvider extends ThroughProvider {
     update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
     getQuery<T extends Data>(ref: DataQuery<T>): Results<T> | PromiseLike<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    setQuery<T extends Data>(ref: DataQuery<T>, value: T): void | PromiseLike<void>;
-    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void | PromiseLike<void>;
+    setQuery<T extends Data>(ref: DataQuery<T>, value: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): number | PromiseLike<number>;
 }