shelving 1.23.1 → 1.26.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 { PropUpdates, Update } from "../update/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
-import { DocumentWrite, Write } from "./Write.js";
+import { DocumentDelete, DocumentSet, DocumentUpdate, Write, Writes } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -18,8 +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. */
-    write(write: Write): void | PromiseLike<void>;
+    /** 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>;
 }
 /** 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>> {
@@ -83,22 +85,15 @@ export declare class DataQuery<T extends Data = Data> extends Query<T> implement
     /**
      * 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>): void | PromiseLike<void>;
     /**
      * 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>;
     /** 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. */
@@ -147,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 { 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 } from "./Write.js";
+import { DocumentDelete, DocumentSet, DocumentUpdate, Writes } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -25,9 +25,16 @@ export class Database {
     doc(collection, id) {
         return new DataDocument(this.provider, this.validators[collection], collection, id);
     }
-    /** Perform a write on this database. */
-    write(write) {
-        return write.transform(this);
+    /** Perform a write on this database and return the `Write` instance representing the changes. */
+    async write(write) {
+        await write.transform(this);
+        return write;
+    }
+    /** 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);
+        await write.transform(this);
+        return write;
     }
 }
 /** A documents reference within a specific database. */
@@ -107,32 +114,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]() {
@@ -215,35 +213,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/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[]);
+    constructor(...writes: (Write | undefined)[]);
+    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 DATABASE_HYDRATIONS: {
-    writes: typeof Writes;
-    write: typeof DocumentWrite;
+export declare const WRITE_HYDRATIONS: {
+    Writes: typeof Writes;
+    DocumentSet: typeof DocumentSet;
+    DocumentUpdate: typeof DocumentUpdate;
+    DocumentDelete: typeof DocumentDelete;
 };

package/db/Write.js

@@ -1,19 +1,8 @@
-import { transform } from "../util/index.js";
-/** Write to a database. */
+import { DataUpdate, Update } from "../update/index.js";
+import { transform, IS_DEFINED } 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;
+        this.writes = writes.filter(IS_DEFINED);
     }
     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 DATABASE_HYDRATIONS = {
-    writes: Writes,
-    write: DocumentWrite,
+export const WRITE_HYDRATIONS = {
+    Writes,
+    DocumentSet,
+    DocumentUpdate,
+    DocumentDelete,
 };
-DATABASE_HYDRATIONS;
+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<void>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
 }

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,24 @@ 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)
+        if (data instanceof Update) {
+            const updates = getFieldValues(data);
             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 if (data)
+            await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
         else
             await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
     }
+    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/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<void>;
+    updateQuery<T extends Data>(ref: DataQuery<T>, updates: Update<T>): Promise<void>;
+    deleteQuery<T extends Data>(ref: DataQuery<T>): Promise<void>;
 }

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