shelving 1.23.2 → 1.26.1

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,5 +1,5 @@
 import { orderBy as firestoreOrderBy, where as firestoreWhere, limit as firestoreLimit, increment as firestoreIncrement, arrayUnion as firestoreArrayUnion, arrayRemove as firestoreArrayRemove, deleteField as firestoreDeleteField, collection as firestoreCollection, doc as firestoreDocument, query as firestoreQuery, setDoc, addDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore/lite";
-import { Provider, Transform, AddItemsTransform, AddEntriesTransform, IncrementTransform, RemoveItemsTransform, RemoveEntriesTransform, AssertionError, DataTransform, } from "../../index.js";
+import { Provider, Update, EntriesUpdate, Increment, AssertionError, DataUpdate, ItemsUpdate, UnsupportedError, } from "../../index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -44,32 +44,30 @@ function* getResults(snapshot) {
     for (const s of snapshot.docs)
         yield [s.id, s.data()];
 }
-/** Convert `Transform` instances into corresponding Firestore `FieldValue` instances. */
-function getFieldValues(transform) {
-    if (transform instanceof DataTransform)
-        return Object.fromEntries(yieldFieldValues(transform));
-    throw new AssertionError("Unsupported transform", transform);
+/** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
+function getFieldValues(update) {
+    if (update instanceof DataUpdate)
+        return Object.fromEntries(yieldFieldValues(update));
+    throw new AssertionError("Unsupported transform", update);
 }
-function* yieldFieldValues(transforms, prefix = "") {
-    for (const [key, transform] of transforms) {
-        if (!(transform instanceof Transform))
-            yield [`${prefix}${key}`, transform];
-        if (transform instanceof IncrementTransform)
-            yield [`${prefix}${key}`, firestoreIncrement(transform.amount)];
-        else if (transform instanceof AddItemsTransform)
-            yield [`${prefix}${key}`, firestoreArrayUnion(...transform)];
-        else if (transform instanceof RemoveItemsTransform)
-            yield [`${prefix}${key}`, firestoreArrayRemove(...transform)];
-        else if (transform instanceof AddEntriesTransform)
-            for (const [k, v] of transform)
-                yield [`${prefix}${key}.${k}`, v];
-        else if (transform instanceof RemoveEntriesTransform)
-            for (const k of transform)
-                yield [`${prefix}${key}.${k}`, firestoreDeleteField()];
-        else if (transform instanceof DataTransform)
-            yield* yieldFieldValues(transform, `${prefix}${key}.`);
+function* yieldFieldValues(updates, prefix = "") {
+    for (const [key, update] of updates) {
+        if (!(update instanceof Update))
+            yield [`${prefix}${key}`, update !== undefined ? update : firestoreDeleteField()];
+        else if (update instanceof Increment)
+            yield [`${prefix}${key}`, firestoreIncrement(update.amount)];
+        else if (update instanceof DataUpdate || update instanceof EntriesUpdate)
+            yield* yieldFieldValues(update, `${prefix}${key}.`);
+        else if (update instanceof ItemsUpdate) {
+            if (update.adds.length && update.deletes.length)
+                throw new UnsupportedError("Cannot add/delete array items in one update");
+            if (update.adds.length)
+                yield [`${prefix}${key}`, firestoreArrayUnion(...update.adds)];
+            else if (update.deletes.length)
+                yield [`${prefix}${key}`, firestoreArrayRemove(...update.deletes)];
+        }
         else
-            throw new AssertionError("Unsupported transform", transform);
+            throw new AssertionError("Unsupported transform", update);
     }
 }
 /**
@@ -94,13 +92,14 @@ export class FirestoreClientProvider extends Provider {
         const reference = await addDoc(getCollection(this.firestore, ref), data); // eslint-disable-line @typescript-eslint/no-explicit-any
         return reference.id;
     }
-    async write(ref, value) {
-        if (value instanceof Transform)
-            await updateDoc(getDocument(this.firestore, ref), getFieldValues(value));
-        else if (value)
-            await setDoc(getDocument(this.firestore, ref), value);
-        else
-            await deleteDoc(getDocument(this.firestore, ref));
+    async set(ref, data) {
+        await setDoc(getDocument(this.firestore, ref), data);
+    }
+    async update(ref, updates) {
+        await updateDoc(getDocument(this.firestore, ref), getFieldValues(updates));
+    }
+    async delete(ref) {
+        await deleteDoc(getDocument(this.firestore, ref));
     }
     async getQuery(ref) {
         return getResults(await getDocs(getQuery(this.firestore, ref)));
@@ -108,14 +107,17 @@ export class FirestoreClientProvider extends Provider {
     subscribeQuery() {
         throw new Error("FirestoreLiteProvider does not support realtime subscriptions");
     }
-    async writeQuery(ref, value) {
+    async setQuery(ref, data) {
         const snapshot = await getDocs(getQuery(this.firestore, ref));
-        const updates = value instanceof Transform && getFieldValues(value);
-        if (updates)
-            await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, updates)));
-        else if (value)
-            await Promise.all(snapshot.docs.map(s => setDoc(s.ref, value)));
-        else
-            await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
+        await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
+    }
+    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)));
+    }
+    async deleteQuery(ref) {
+        const snapshot = await getDocs(getQuery(this.firestore, ref));
+        await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
     }
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,5 +1,5 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Provider, DataDocument, DataQuery, Observer, Result, Transform, Data, AsynchronousProvider, Entry, Results, Unsubscriber } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Observer, Result, Update, Data, AsynchronousProvider, Entry, Results, Unsubscriber } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -10,8 +10,12 @@ export declare class FirestoreServerProvider extends Provider implements Asynchr
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
     subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
-    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
+    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
+    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;
-    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
+    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>;
 }

package/firestore/server/FirestoreServerProvider.js

@@ -1,5 +1,5 @@
 import { Firestore, FieldValue } from "@google-cloud/firestore";
-import { Provider, dispatchNext, dispatchError, Transform, IncrementTransform, AddItemsTransform, RemoveItemsTransform, AddEntriesTransform, RemoveEntriesTransform, DataTransform, AssertionError, } from "../../index.js";
+import { Provider, dispatchNext, dispatchError, Update, Increment, DataUpdate, AssertionError, ItemsUpdate, UnsupportedError, EntriesUpdate, } from "../../index.js";
 // Constants.
 // const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
 const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
@@ -44,32 +44,30 @@ function* getResults(snapshot) {
     for (const s of snapshot.docs)
         yield [s.id, s.data()];
 }
-/** Convert a `Transform` instances into corresponding Firestore `FieldValue` instances. */
-function getFieldValues(transform) {
-    if (transform instanceof DataTransform)
-        return Object.fromEntries(yieldFieldValues(transform));
-    throw new AssertionError("Unsupported transform", transform);
+/** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
+function getFieldValues(update) {
+    if (update instanceof DataUpdate)
+        return Object.fromEntries(yieldFieldValues(update));
+    throw new AssertionError("Unsupported transform", update);
 }
-function* yieldFieldValues(transforms, prefix = "") {
-    for (const [key, transform] of transforms) {
-        if (!(transform instanceof Transform))
-            yield [`${prefix}${key}`, transform];
-        if (transform instanceof IncrementTransform)
-            yield [`${prefix}${key}`, FieldValue.increment(transform.amount)];
-        else if (transform instanceof AddItemsTransform)
-            yield [`${prefix}${key}`, FieldValue.arrayUnion(...transform)];
-        else if (transform instanceof RemoveItemsTransform)
-            yield [`${prefix}${key}`, FieldValue.arrayRemove(...transform)];
-        else if (transform instanceof AddEntriesTransform)
-            for (const [k, v] of transform)
-                yield [`${prefix}${key}.${k}`, v];
-        else if (transform instanceof RemoveEntriesTransform)
-            for (const k of transform)
-                yield [`${prefix}${key}.${k}`, FieldValue.delete()];
-        else if (transform instanceof DataTransform)
-            yield* yieldFieldValues(transform, `${prefix}${key}.`);
+function* yieldFieldValues(updates, prefix = "") {
+    for (const [key, update] of updates) {
+        if (!(update instanceof Update))
+            yield [`${prefix}${key}`, update !== undefined ? update : FieldValue.delete()];
+        if (update instanceof Increment)
+            yield [`${prefix}${key}`, FieldValue.increment(update.amount)];
+        else if (update instanceof DataUpdate || update instanceof EntriesUpdate)
+            yield* yieldFieldValues(update, `${prefix}${key}.`);
+        else if (update instanceof ItemsUpdate) {
+            if (update.adds.length && update.deletes.length)
+                throw new UnsupportedError("Cannot add/delete array items in one update");
+            if (update.adds.length)
+                yield [`${prefix}${key}`, FieldValue.arrayUnion(...update.adds)];
+            else if (update.deletes.length)
+                yield [`${prefix}${key}`, FieldValue.arrayRemove(...update.deletes)];
+        }
         else
-            throw new AssertionError("Unsupported transform", transform);
+            throw new AssertionError("Unsupported transform", update);
     }
 }
 /**
@@ -90,13 +88,14 @@ export class FirestoreServerProvider extends Provider {
     async add(ref, data) {
         return (await getCollection(this.firestore, ref).add(data)).id;
     }
-    async write(ref, value) {
-        if (value instanceof Transform)
-            await getDocument(this.firestore, ref).update(getFieldValues(value));
-        else if (value)
-            await getDocument(this.firestore, ref).set(value);
-        else
-            await getDocument(this.firestore, ref).delete();
+    async set(ref, data) {
+        await getDocument(this.firestore, ref).set(data);
+    }
+    async update(ref, updates) {
+        await getDocument(this.firestore, ref).update(getFieldValues(updates));
+    }
+    async delete(ref) {
+        await getDocument(this.firestore, ref).delete();
     }
     async getQuery(ref) {
         return getResults(await getQuery(this.firestore, ref).get());
@@ -104,26 +103,29 @@ export class FirestoreServerProvider extends Provider {
     subscribeQuery(ref, observer) {
         return getQuery(this.firestore, ref).onSnapshot(snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
-    async writeQuery(ref, value) {
-        const writer = this.firestore.bulkWriter();
-        const query = getQuery(this.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.
-        const updates = value instanceof Transform ? getFieldValues(value) : undefined;
-        let current = query;
-        while (current) {
-            const snapshot = await current.get();
-            if (updates)
-                for (const s of snapshot.docs)
-                    void writer.update(s.ref, updates);
-            else if (value)
-                for (const s of snapshot.docs)
-                    void writer.set(s.ref, value);
-            else
-                for (const s of snapshot.docs)
-                    void writer.delete(s.ref);
-            current = snapshot.size >= BATCH_SIZE && query.startAfter(snapshot.docs.pop()).select();
-            void writer.flush();
-        }
-        await writer.close();
+    async setQuery(ref, data) {
+        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));
+    }
+    async deleteQuery(ref) {
+        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) {
+    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)
+            callback(writer, s);
+        current = snapshot.size >= BATCH_SIZE && query.startAfter(snapshot.docs.pop()).select();
+        void writer.flush();
     }
+    await writer.close();
 }
 const BATCH_SIZE = 1000;

package/index.d.ts

@@ -8,9 +8,9 @@ export * from "./db/index.js";
 export * from "./provider/index.js";
 export * from "./query/index.js";
 export * from "./api/index.js";
-export * from "./util/index.js";
-export * from "./stream/index.js";
-export * from "./feedback/index.js";
 export * from "./error/index.js";
-export * from "./transform/index.js";
+export * from "./feedback/index.js";
 export * from "./markup/index.js";
+export * from "./stream/index.js";
+export * from "./update/index.js";
+export * from "./util/index.js";

package/index.js

@@ -10,12 +10,12 @@ export * from "./provider/index.js";
 export * from "./query/index.js";
 export * from "./api/index.js";
 // Utilities.
-export * from "./util/index.js";
-export * from "./stream/index.js";
-export * from "./feedback/index.js";
 export * from "./error/index.js";
-export * from "./transform/index.js";
+export * from "./feedback/index.js";
 export * from "./markup/index.js";
+export * from "./stream/index.js";
+export * from "./update/index.js";
+export * from "./util/index.js";
 // Integrations.
 // export * from "./react/index.js"; // Not exported.
 // Testing.

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.23.2",
+	"version": "1.26.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -23,6 +23,7 @@
 		".": "./index.js",
 		"./api": "./api/index.js",
 		"./db": "./db/index.js",
+		"./error": "./error/index.js",
 		"./feedback": "./feedback/index.js",
 		"./firestore/client": "./firestore-client/index.js",
 		"./firestore/lite": "./firestore-lite/index.js",
@@ -34,6 +35,7 @@
 		"./schema": "./schema/index.js",
 		"./stream": "./stream/index.js",
 		"./test": "./test/index.js",
+		"./update": "./update/index.js",
 		"./util": "./util/index.js"
 	},
 	"sideEffects": false,

package/provider/CacheProvider.d.ts

@@ -1,5 +1,5 @@
 import type { DataDocument, DataQuery } from "../db/index.js";
-import { Transform } from "../transform/index.js";
+import { Update } from "../update/index.js";
 import { Result, Unsubscriber, Observer, Results, Data } from "../util/index.js";
 import type { Provider, AsynchronousProvider } from "./Provider.js";
 import { MemoryProvider } from "./MemoryProvider.js";
@@ -20,12 +20,16 @@ export declare class CacheProvider extends ThroughProvider implements Asynchrono
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
     subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): Promise<string>;
-    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): Promise<void>;
+    set<T extends Data>(ref: DataDocument<T>, data: T): Promise<void>;
+    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): Promise<void>;
+    delete<T extends Data>(ref: DataDocument<T>): Promise<void>;
     /** Cache a set of document results. */
     private _cacheResults;
     getQuery<T extends Data>(ref: DataQuery<T>): Promise<Results<T>>;
     subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
-    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): Promise<void>;
+    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>;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/CacheProvider.js

@@ -1,4 +1,3 @@
-import { Transform } from "../transform/index.js";
 import { TransformObserver } from "../util/index.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 import { ThroughProvider } from "./ThroughProvider.js";
@@ -23,7 +22,7 @@ export class CacheProvider extends ThroughProvider {
     }
     /** Cache an individual document result. */
     _cacheResult(ref, result) {
-        this.cache.write(ref, result);
+        result ? this.cache.set(ref, result) : this.cache.delete(ref);
         this._times[ref.toString()] = Date.now();
         return result;
     }
@@ -37,17 +36,22 @@ export class CacheProvider extends ThroughProvider {
     }
     async add(ref, data) {
         const id = await super.add(ref, data);
-        this.cache.write(ref.doc(id), data);
+        this.cache.set(ref.doc(id), data);
         return id;
     }
-    async write(ref, value) {
-        await super.write(ref, value);
+    async set(ref, data) {
+        await super.set(ref, data);
+        this.cache.set(ref, data);
+    }
+    async update(ref, updates) {
+        await super.update(ref, updates);
         // 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.
-        if (value instanceof Transform)
-            this.cache.writeQuery(ref.optional, value);
-        else
-            this.cache.write(ref, value);
+        this.cache.updateQuery(ref.optional, updates);
+    }
+    async delete(ref) {
+        await super.delete(ref);
+        this.cache.delete(ref);
     }
     /** Cache a set of document results. */
     *_cacheResults(ref, results) {
@@ -57,10 +61,10 @@ export class CacheProvider extends ThroughProvider {
         if (!ref.limit)
             for (const id of Object.keys(this.cache.getQuery(ref)))
                 if (!(id in results))
-                    this.cache.write(ref.doc(id), undefined);
+                    this.cache.delete(ref.doc(id));
         // Save new results to the cache.
         for (const [id, data] of results) {
-            this.cache.write(ref.doc(id), data);
+            this.cache.set(ref.doc(id), data);
             yield [id, data];
         }
         // Save the last-cached time.
@@ -74,9 +78,17 @@ export class CacheProvider extends ThroughProvider {
     subscribeQuery(ref, observer) {
         return super.subscribeQuery(ref, new TransformObserver(results => this._cacheResults(ref, results), observer));
     }
-    async writeQuery(ref, value) {
-        await super.writeQuery(ref, value);
-        this.cache.writeQuery(ref, value);
+    async setQuery(ref, data) {
+        await super.setQuery(ref, data);
+        this.cache.setQuery(ref, data);
+    }
+    async updateQuery(ref, updates) {
+        await super.updateQuery(ref, updates);
+        this.cache.updateQuery(ref, updates);
+    }
+    async deleteQuery(ref) {
+        await super.deleteQuery(ref);
+        this.cache.deleteQuery(ref);
     }
     /** Reset this provider and clear all data. */
     reset() {

package/provider/MemoryProvider.d.ts

@@ -1,5 +1,5 @@
 import { Data, Result, Results, Unsubscriber, Observer } from "../util/index.js";
-import { Transform } from "../transform/index.js";
+import { Update } from "../update/index.js";
 import { DataQuery, DataDocument } from "../db/index.js";
 import { Provider, SynchronousProvider } from "./Provider.js";
 /**
@@ -14,10 +14,14 @@ export declare class MemoryProvider extends Provider implements SynchronousProvi
     get<T extends Data>(ref: DataDocument<T>): Result<T>;
     subscribe<T extends Data>(ref: DataDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
     add<T extends Data>(ref: DataQuery<T>, data: T): string;
-    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void;
+    set<T extends Data>(ref: DataDocument<T>, data: T): void;
+    update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void;
+    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;
-    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void;
+    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;
     /** Reset this provider and clear all data. */
     reset(): void;
 }

package/provider/MemoryProvider.js

@@ -1,5 +1,4 @@
 import { randomId, dispatchNext, isMapEqual, } from "../util/index.js";
-import { Transform } from "../transform/index.js";
 import { DocumentRequiredError } from "../db/index.js";
 import { Provider } from "./Provider.js";
 /**
@@ -39,18 +38,23 @@ export class MemoryProvider extends Provider {
         table.write(id, data);
         return id;
     }
-    write(ref, value) {
+    set(ref, data) {
         const table = this._table(ref);
         const id = ref.id;
-        if (value instanceof Transform) {
-            const existing = table.data.get(id);
-            if (!existing)
-                throw new DocumentRequiredError(ref);
-            table.write(id, value.transform(existing));
-        }
-        else {
-            table.write(id, value);
-        }
+        table.write(id, data);
+    }
+    update(ref, updates) {
+        const table = this._table(ref);
+        const id = ref.id;
+        const existing = table.data.get(id);
+        if (!existing)
+            throw new DocumentRequiredError(ref);
+        table.write(id, updates.transform(existing));
+    }
+    delete(ref) {
+        const table = this._table(ref);
+        const id = ref.id;
+        table.write(id, undefined);
     }
     getQuery(ref) {
         return ref.transform(this._table(ref).data);
@@ -78,12 +82,26 @@ export class MemoryProvider extends Provider {
             }
         });
     }
-    writeQuery(ref, value) {
+    setQuery(ref, data) {
+        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))
+            table.write(id, data);
+    }
+    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))
-            table.write(id, value instanceof Transform ? value.transform(existing) : value);
+            table.write(id, updates.transform(existing));
+    }
+    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))
+            table.write(id, undefined);
     }
     /** Reset this provider and clear all data. */
     reset() {

package/provider/Provider.d.ts

@@ -1,6 +1,6 @@
 import type { Observer, Unsubscriber, Result, Results, Data } from "../util/index.js";
 import type { DataDocument, DataQuery } from "../db/Database.js";
-import type { Transform } from "../transform/index.js";
+import type { Update } from "../update/index.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
 export declare abstract class Provider {
     /**
@@ -31,20 +31,30 @@ export declare abstract class Provider {
      */
     abstract add<T extends Data>(ref: DataQuery<T>, data: T): string | PromiseLike<string>;
     /**
-     * Write to a document.
+     * Set the data a document.
      * - If the document exists, set the value of it.
      * - If the document doesn't exist, set it at path.
      *
      * @param ref Document reference specifying which document to set.
-     * @param value Value to set the document to.
-     * - If an object is provided, set the document to the value.
-     * - If a `Transform` instance is provided, ensure the document exists and transform it.
-     * - If `undefined` is provided, delete the document.
+     * @param data Data to set the document to.
+     *
+     * @throws Error If a `Update` was provided but the document does not exist (ideally a `RequiredError` but may be provider-specific).
+     */
+    abstract set<T extends Data>(ref: DataDocument<T>, value: T): void | PromiseLike<void>;
+    /**
+     * Update the data an existing document.
+     *
+     * @param ref Document reference specifying which document to update.
+     * @param updates Update instance to set the document to.
      *
-     * @return Nothing (possibly promised).
-     * @throws Error If a `Transform` was provided but the document does not exist (ideally a `RequiredError` but may be provider-specific).
+     * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
+     */
+    abstract update<T extends Data>(ref: DataDocument<T>, updates: Update<T>): void | PromiseLike<void>;
+    /**
+     * Delete a specified document.
+     * @param ref Document reference specifying which document to delete.
      */
-    abstract write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void | PromiseLike<void>;
+    abstract delete<T extends Data>(ref: DataDocument<T>): void | PromiseLike<void>;
     /**
      * Get all matching documents.
      *
@@ -63,31 +73,46 @@ export declare abstract class Provider {
      */
     abstract subscribeQuery<T extends Data>(ref: DataQuery<T>, observer: Observer<Results<T>>): Unsubscriber;
     /**
-     * Write to all matching documents.
+     * Set the data of all matching documents.
      *
      * @param ref Documents reference specifying which collection to set.
      * @param value Value to set the document to.
-     * - If an object is provided, set the document to the value.
-     * - If a `Transform` instance is provided, ensure the document exists and transform it.
-     * - If `undefined` is provided, delete the document.
+     */
+    abstract setQuery<T extends Data>(ref: DataQuery<T>, data: T): void | PromiseLike<void>;
+    /**
+     * Update the data of all matching documents.
      *
-     * @return Nothing (possibly promised).
+     * @param ref Documents reference specifying which collection to set.
+     * @param updates Update instance to set the document to.
+     */
+    abstract updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): void | PromiseLike<void>;
+    /**
+     * Delete all matching documents.
+     * @param ref Document reference specifying which document to delete.
      */
-    abstract writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void | PromiseLike<void>;
+    abstract deleteQuery<T extends Data>(ref: DataQuery<T>): void | PromiseLike<void>;
 }
 /** Provider with a fully synchronous interface */
 export interface SynchronousProvider extends Provider {
     get<T extends Data>(ref: DataDocument<T>): Result<T>;
     add<T extends Data>(ref: DataQuery<T>, data: T): string;
-    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): void;
+    set<T extends Data>(ref: DataDocument<T>, value: T): void;
+    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>;
-    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): void;
+    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;
 }
 /** Provider with a fully asynchronous interface */
 export interface AsynchronousProvider extends Provider {
     get<T extends Data>(ref: DataDocument<T>): PromiseLike<Result<T>>;
     add<T extends Data>(ref: DataQuery<T>, data: T): PromiseLike<string>;
-    write<T extends Data>(ref: DataDocument<T>, value: T | Transform<T> | undefined): PromiseLike<void>;
+    set<T extends Data>(ref: DataDocument<T>, value: T): PromiseLike<void>;
+    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>>;
-    writeQuery<T extends Data>(ref: DataQuery<T>, value: T | Transform<T> | undefined): PromiseLike<void>;
+    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>;
 }