shelving 1.25.0 → 1.28.0

package/db/Database.d.ts

@@ -1,8 +1,8 @@
-import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType, Dispatcher } from "../util/index.js";
-import { Transform, Transforms } from "../transform/index.js";
+import { Entry, Observable, Observer, Result, Unsubscriber, ResultsMap, Validatable, Validator, Key, Data, Results, Datas, Validators, ValidatorType, Dispatcher, Nullish } from "../util/index.js";
+import { PropUpdates, Update } from "../update/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
-import { DocumentWrite, Write, Writes } from "./Write.js";
+import { DocumentDelete, DocumentSet, DocumentUpdate, Write } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -18,10 +18,10 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DataQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DataDocument<ValidatorType<V[K]>>;
-    /** Perform a write on this database and return the `Write` instance representing the changes. */
-    write(write: Write): Promise<Write>;
-    /** Perform multiple writes on this database by combining them into a single `Writes` instance representing the changes. */
-    writes(...writes: (Write | undefined)[]): Promise<Writes>;
+    /** Create a writer for this database from a set of separate writes. */
+    writer(...writes: Nullish<Write>[]): Write;
+    /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
+    write(...writes: Nullish<Write>[]): Promise<Write>;
 }
 /** A documents reference within a specific database. */
 export declare class DataQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Results<T>>, Iterable<Entry<T>> {
@@ -81,26 +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 transform `Transform` instance or set of transforms to apply to every matching document.
-     * - Not all transforms may be supported by all providers.
-     *
+     * @param updates `Update` instance or set of updates to apply to every matching document.
      * @return Nothing (possibly promised).
      */
-    update(transform: Transform<T> | Transforms<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>;
-    /**
-     * Combine `set()`, `update()`, `delete()` into a single method.
-     * @return Nothing (possibly promised).
-     */
-    write(value: Result<T> | Transform<T>): 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. */
@@ -149,19 +142,15 @@ export declare class DataDocument<T extends Data = Data> implements Observable<R
     /** Set the complete data of this document. */
     set(data: T): void | PromiseLike<void>;
     /** Update this document. */
-    update(transforms: Transform<T> | Transforms<T>): void | PromiseLike<void>;
+    update(updates: Update<T> | PropUpdates<T>): void | PromiseLike<void>;
     /** Delete this document. */
     delete(): void | PromiseLike<void>;
-    /** Set, update, or delete this document. */
-    write(value: Result<T> | Transform<T>): void | PromiseLike<void>;
     /** Represent a write that sets the complete data of this document in a database. */
-    setter(data: T): DocumentWrite<T>;
+    setter(data: T): DocumentSet<T>;
     /** Represent a write that updates this document in a database. */
-    updater(transforms: Transform<T> | Transforms<T>): DocumentWrite<T>;
+    updater(updates: Update<T> | PropUpdates<T>): DocumentUpdate<T>;
     /** Represent a write that deletes this document in a database. */
-    deleter(): DocumentWrite<T>;
-    /** Represent a write that sets, updates, or deletes this document in a database. */
-    writer(value: Result<T> | Transform<T>): DocumentWrite<T>;
+    deleter(): DocumentDelete<T>;
     /** Validate data for this query reference. */
     validate(unsafeData: Data): T;
     toString(): string;

package/db/Database.js

@@ -1,9 +1,9 @@
-import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, TransformObserver, } from "../util/index.js";
-import { DataTransform, Transform } from "../transform/index.js";
+import { callAsync, getFirstItem, throwAsync, validate, toMap, countItems, TransformObserver, NOT_NULLISH, } from "../util/index.js";
+import { DataUpdate, Update } from "../update/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
 import { DocumentRequiredError, DocumentValidationError, QueryValidationError } from "./errors.js";
-import { DocumentWrite, Writes } from "./Write.js";
+import { DocumentDelete, DocumentSet, DocumentUpdate, Writes } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -25,14 +25,13 @@ export class Database {
     doc(collection, id) {
         return new DataDocument(this.provider, this.validators[collection], collection, id);
     }
-    /** Perform a write on this database and return the `Write` instance representing the changes. */
-    async write(write) {
-        await write.transform(this);
-        return write;
+    /** Create a writer for this database from a set of separate writes. */
+    writer(...writes) {
+        return new Writes(...writes.filter(NOT_NULLISH));
     }
-    /** Perform multiple writes on this database by combining them into a single `Writes` instance representing the changes. */
-    async writes(...writes) {
-        const write = new Writes(...writes);
+    /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
+    async write(...writes) {
+        const write = new Writes(...writes.filter(NOT_NULLISH));
         await write.transform(this);
         return write;
     }
@@ -114,32 +113,23 @@ export class DataQuery extends Query {
      * @return Nothing (possibly promised).
      */
     set(data) {
-        return this.write(data);
+        return this.provider.setQuery(this, data);
     }
     /**
      * Update all matching documents with the same partial value.
      *
-     * @param transform `Transform` instance or set of transforms to apply to every matching document.
-     * - Not all transforms may be supported by all providers.
-     *
+     * @param updates `Update` instance or set of updates to apply to every matching document.
      * @return Nothing (possibly promised).
      */
-    update(transform) {
-        return this.write(transform instanceof Transform ? transform : new DataTransform(transform));
+    update(updates) {
+        return this.provider.updateQuery(this, updates instanceof Update ? updates : new DataUpdate(updates));
     }
     /**
      * Delete all matching documents.
      * @return Nothing (possibly promised).
      */
     delete() {
-        return this.write(undefined);
-    }
-    /**
-     * Combine `set()`, `update()`, `delete()` into a single method.
-     * @return Nothing (possibly promised).
-     */
-    write(value) {
-        return this.provider.writeQuery(this, value);
+        return this.provider.deleteQuery(this);
     }
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator]() {
@@ -222,35 +212,27 @@ export class DataDocument {
     }
     /** Set the complete data of this document. */
     set(data) {
-        return this.write(data);
+        return this.provider.set(this, data);
     }
     /** Update this document. */
-    update(transforms) {
-        return this.write(transforms instanceof Transform ? transforms : new DataTransform(transforms));
+    update(updates) {
+        return this.provider.update(this, updates instanceof Update ? updates : new DataUpdate(updates));
     }
     /** Delete this document. */
     delete() {
-        return this.write(undefined);
-    }
-    /** Set, update, or delete this document. */
-    write(value) {
-        return this.provider.write(this, value);
+        return this.provider.delete(this);
     }
     /** Represent a write that sets the complete data of this document in a database. */
     setter(data) {
-        return this.writer(data);
+        return new DocumentSet(this, data);
     }
     /** Represent a write that updates this document in a database. */
-    updater(transforms) {
-        return this.writer(transforms instanceof Transform ? transforms : new DataTransform(transforms));
+    updater(updates) {
+        return new DocumentUpdate(this, updates);
     }
     /** Represent a write that deletes this document in a database. */
     deleter() {
-        return this.writer(undefined);
-    }
-    /** Represent a write that sets, updates, or deletes this document in a database. */
-    writer(value) {
-        return new DocumentWrite(this, value);
+        return new DocumentDelete(this);
     }
     /** Validate data for this query reference. */
     validate(unsafeData) {

package/db/Pagination.d.ts

@@ -7,23 +7,15 @@ import { DataQuery } from "./Database.js";
  * - If you don't pass in initial values, it will autoload the first page.
  */
 export declare class Pagination<T extends Data> extends State<ResultsMap<T>> implements Iterable<Entry<T>> {
+    protected _pending: boolean;
     readonly ref: DataQuery<T>;
     readonly limit: number;
-    readonly startLoading: boolean;
-    readonly startDone: boolean;
-    readonly endLoading: boolean;
-    readonly endDone: boolean;
     constructor(ref: DataQuery<T>);
-    /**
-     * Load more results before the start.
-     * - Promise that needs to be handled.
-     */
-    loadStart: () => Promise<void>;
     /**
      * Load more results after the end.
      * - Promise that needs to be handled.
      */
-    loadEnd: () => Promise<void>;
+    more: () => Promise<void>;
     /**
      * Merge more results into this pagination.
      * @return The change in the number of results.

package/db/Pagination.js

@@ -1,4 +1,4 @@
-import { getFirstItem, getLastItem, assertLength, assertNumber, yieldMerged, toMap } from "../util/index.js";
+import { getLastItem, assertLength, assertNumber, yieldMerged, toMap, LOADING } from "../util/index.js";
 import { State } from "../stream/index.js";
 import { ConditionError } from "../index.js";
 /**
@@ -9,56 +9,33 @@ import { ConditionError } from "../index.js";
 export class Pagination extends State {
     constructor(ref) {
         super();
-        this.startLoading = false;
-        this.startDone = false;
-        this.endLoading = false;
-        this.endDone = false;
-        /**
-         * Load more results before the start.
-         * - Promise that needs to be handled.
-         */
-        this.loadStart = async () => {
-            if (this.closed)
-                throw new ConditionError();
-            if (!this.startLoading) {
-                this.startLoading = true;
-                if (!this.loading) {
-                    const firstItem = getFirstItem(this.value);
-                    if (firstItem) {
-                        const next = await this.ref.after(firstItem[0], firstItem[1]).resultsMap;
-                        this.startDone = next.size < this.limit;
-                        this.startLoading = false;
-                        return this.merge(next);
-                    }
-                }
-                const next = await this.ref.resultsMap;
-                this.startDone = next.size < this.limit;
-                this.startLoading = false;
-                return this.next(next);
-            }
-        };
+        this._pending = false; // Prevents double-loading.
         /**
          * Load more results after the end.
          * - Promise that needs to be handled.
          */
-        this.loadEnd = async () => {
+        this.more = async () => {
             if (this.closed)
-                throw new ConditionError();
-            if (!this.endLoading) {
-                this.endLoading = true;
+                throw new ConditionError("Pagination is closed");
+            if (!this._pending) {
+                this._pending = true;
                 if (!this.loading) {
                     const lastItem = getLastItem(this.value);
                     if (lastItem) {
                         const next = await this.ref.after(lastItem[0], lastItem[1]).resultsMap;
-                        this.endDone = next.size < this.limit;
-                        this.endLoading = false;
-                        return this.merge(next);
+                        this.merge(next);
+                        if (next.size < this.limit)
+                            this.complete();
+                        this._pending = false;
+                        return;
                     }
                 }
+                this._value === LOADING;
                 const next = await this.ref.resultsMap;
-                this.endDone = next.size < this.limit;
-                this.endLoading = false;
-                return this.next(next);
+                this.next(next);
+                if (next.size < this.limit)
+                    this.complete();
+                this._pending = false;
             }
         };
         this.ref = ref;

package/db/Write.d.ts

@@ -1,18 +1,10 @@
-import { Transform } from "../transform/index.js";
+import { PropUpdates, Update } from "../update/index.js";
 import { ImmutableArray, Data, Transformable } from "../util/index.js";
 import type { Database, DataDocument } from "./Database.js";
-/** Write to a database. */
+/** Represent a write made to a database. */
 export declare abstract class Write implements Transformable<Database, void | PromiseLike<void>> {
     abstract transform(db: Database): void | PromiseLike<void>;
 }
-/** Represent a write made to a single document in a database. */
-export declare class DocumentWrite<T extends Data> extends Write {
-    readonly collection: string;
-    readonly id: string;
-    readonly value: Data | Transform<Data> | undefined;
-    constructor({ collection, id }: DataDocument<T>, value: T | Transform<T> | undefined);
-    transform(db: Database): Promise<void>;
-}
 /**
  * Represent a list of writes made to a database.
  * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
@@ -20,11 +12,35 @@ export declare class DocumentWrite<T extends Data> extends Write {
  */
 export declare class Writes extends Write {
     readonly writes: ImmutableArray<Write>;
-    constructor(...writes: (Write | undefined)[]);
+    constructor(...writes: Write[]);
+    transform(db: Database): Promise<void>;
+}
+/** Represent a write made to a single document in a database. */
+export declare abstract class DocumentWrite<T extends Data> extends Write {
+    readonly collection: string;
+    readonly id: string;
+    constructor({ collection, id }: DataDocument<T>);
+}
+/** Represent a set operation made to a single document in a database. */
+export declare class DocumentSet<T extends Data> extends DocumentWrite<T> {
+    readonly data: T;
+    constructor(ref: DataDocument<T>, data: T);
+    transform(db: Database): Promise<void>;
+}
+/** Represent an update operation made to a single document in a database. */
+export declare class DocumentUpdate<T extends Data> extends DocumentWrite<T> {
+    readonly updates: Update<T>;
+    constructor(ref: DataDocument<T>, updates: Update<T> | PropUpdates<T>);
+    transform(db: Database): Promise<void>;
+}
+/** Represent a delete operation made to a single document in a database. */
+export declare class DocumentDelete<T extends Data> extends DocumentWrite<T> {
     transform(db: Database): Promise<void>;
 }
 /** Set of hydrations for all change classes. */
 export declare const WRITE_HYDRATIONS: {
-    writes: typeof Writes;
-    write: typeof DocumentWrite;
+    Writes: typeof Writes;
+    DocumentSet: typeof DocumentSet;
+    DocumentUpdate: typeof DocumentUpdate;
+    DocumentDelete: typeof DocumentDelete;
 };

package/db/Write.js

@@ -1,19 +1,8 @@
-import { transform, IS_DEFINED } from "../util/index.js";
-/** Write to a database. */
+import { DataUpdate, Update } from "../update/index.js";
+import { transform } from "../util/index.js";
+/** Represent a write made to a database. */
 export class Write {
 }
-/** Represent a write made to a single document in a database. */
-export class DocumentWrite extends Write {
-    constructor({ collection, id }, value) {
-        super();
-        this.collection = collection;
-        this.id = id;
-        this.value = value;
-    }
-    async transform(db) {
-        await db.doc(this.collection, this.id).write(this.value);
-    }
-}
 /**
  * Represent a list of writes made to a database.
  * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
@@ -22,16 +11,52 @@ export class DocumentWrite extends Write {
 export class Writes extends Write {
     constructor(...writes) {
         super();
-        this.writes = writes.filter(IS_DEFINED);
+        this.writes = writes;
     }
     async transform(db) {
         for (const writes of this.writes)
             await transform(db, writes);
     }
 }
+/** Represent a write made to a single document in a database. */
+export class DocumentWrite extends Write {
+    constructor({ collection, id }) {
+        super();
+        this.collection = collection;
+        this.id = id;
+    }
+}
+/** Represent a set operation made to a single document in a database. */
+export class DocumentSet extends DocumentWrite {
+    constructor(ref, data) {
+        super(ref);
+        this.data = data;
+    }
+    async transform(db) {
+        await db.doc(this.collection, this.id).set(this.data);
+    }
+}
+/** Represent an update operation made to a single document in a database. */
+export class DocumentUpdate extends DocumentWrite {
+    constructor(ref, updates) {
+        super(ref);
+        this.updates = updates instanceof Update ? updates : new DataUpdate(updates);
+    }
+    async transform(db) {
+        await db.doc(this.collection, this.id).update(this.updates);
+    }
+}
+/** Represent a delete operation made to a single document in a database. */
+export class DocumentDelete extends DocumentWrite {
+    async transform(db) {
+        await db.doc(this.collection, this.id).delete();
+    }
+}
 /** Set of hydrations for all change classes. */
 export const WRITE_HYDRATIONS = {
-    writes: Writes,
-    write: DocumentWrite,
+    Writes,
+    DocumentSet,
+    DocumentUpdate,
+    DocumentDelete,
 };
 WRITE_HYDRATIONS;

package/feedback/hydrations.d.ts

@@ -5,9 +5,9 @@ import { ErrorFeedback } from "./ErrorFeedback.js";
 import { InvalidFeedback } from "./InvalidFeedback.js";
 /** Set of hydrations for all feedback classes. */
 export declare const FEEDBACK_HYDRATIONS: {
-    success: typeof SuccessFeedback;
-    warning: typeof WarningFeedback;
-    invalid: typeof InvalidFeedback;
-    error: typeof ErrorFeedback;
-    feedback: typeof Feedback;
+    SuccessFeedback: typeof SuccessFeedback;
+    WarningFeedback: typeof WarningFeedback;
+    InvalidFeedback: typeof InvalidFeedback;
+    ErrorFeedback: typeof ErrorFeedback;
+    Feedback: typeof Feedback;
 };

package/feedback/hydrations.js

@@ -5,10 +5,10 @@ import { ErrorFeedback } from "./ErrorFeedback.js";
 import { InvalidFeedback } from "./InvalidFeedback.js";
 /** Set of hydrations for all feedback classes. */
 export const FEEDBACK_HYDRATIONS = {
-    success: SuccessFeedback,
-    warning: WarningFeedback,
-    invalid: InvalidFeedback,
-    error: ErrorFeedback,
-    feedback: Feedback,
+    SuccessFeedback,
+    WarningFeedback,
+    InvalidFeedback,
+    ErrorFeedback,
+    Feedback,
 };
 FEEDBACK_HYDRATIONS;

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore";
-import { Results, Provider, DataDocument, DataQuery, Result, Observer, Transform, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
+import { Results, Provider, DataDocument, DataQuery, Result, Observer, Update, AsynchronousProvider, Data, Unsubscriber } from "../../index.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
@@ -12,8 +12,12 @@ export declare class FirestoreClientProvider 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<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<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

@@ -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, onSnapshot, addDoc, setDoc, updateDoc, deleteDoc, getDoc, getDocs, } from "firebase/firestore";
-import { Provider, dispatchNext, dispatchError, Transform, AddItemsTransform, AddEntriesTransform, IncrementTransform, RemoveItemsTransform, RemoveEntriesTransform, DataTransform, AssertionError, } from "../../index.js";
+import { Provider, dispatchNext, dispatchError, Update, EntriesUpdate, Increment, DataUpdate, AssertionError, 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);
     }
 }
 /**
@@ -91,16 +89,17 @@ export class FirestoreClientProvider extends Provider {
         return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(observer, snapshot.data()), thrown => dispatchError(observer, thrown));
     }
     async add(ref, data) {
-        const reference = await addDoc(getCollection(this.firestore, ref), data); // eslint-disable-line @typescript-eslint/no-explicit-any
+        const reference = await addDoc(getCollection(this.firestore, ref), data);
         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,20 @@ export class FirestoreClientProvider extends Provider {
     subscribeQuery(ref, observer) {
         return onSnapshot(getQuery(this.firestore, ref), snapshot => dispatchNext(observer, getResults(snapshot)), thrown => dispatchError(observer, thrown));
     }
-    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)));
+        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

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Provider, DataDocument, DataQuery, Result, Transform, AsynchronousProvider, Data, Results, Unsubscriber } from "../../index.js";
+import { Provider, DataDocument, DataQuery, Result, Update, AsynchronousProvider, Data, Results, Unsubscriber } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -12,8 +12,12 @@ export declare class FirestoreClientProvider extends Provider implements Asynchr
     get<T extends Data>(ref: DataDocument<T>): Promise<Result<T>>;
     subscribe(): 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<Results<T>>;
     subscribeQuery(): 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<number>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<number>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<number>;
 }