shelving 1.71.1 → 1.72.0

package/feedback/Feedback.d.ts

@@ -1,4 +1,4 @@
-import type { ImmutableObject } from "../util/object.js";
+import { ImmutableObject } from "../util/object.js";
 /**
  * The `Feedback` class represents a feedback message that should be shown to the user.
  * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
@@ -10,18 +10,21 @@ import type { ImmutableObject } from "../util/object.js";
  * @param feedback String feedback message that is safe to show to users.
  * @param details Set of other `Feedback` instances describing the issue in further detail.
  */
-export declare class Feedback {
+export interface Feedback {
+    /** Name of the class (same as `Error`). */
+    name: string;
+}
+export declare class Feedback<T = unknown> {
     /** String feedback message that is safe to show to a user. */
     readonly message: string;
     /** Nested details providing deeper feedback. */
-    readonly details: ImmutableObject;
-    constructor(feedback: string, details?: ImmutableObject);
-    /**
-     * Map details to a set of string messages.
-     * - If a detail is another `Feedback` instance, return its `.message` string.
-     * - If a detail is anything else, convert it to string using `toString()`
-     */
-    get messages(): ImmutableObject<string>;
+    readonly value: T;
+    constructor(feedback: string, value?: T);
 }
-/** Is an unknown value a `Feedback` instance? */
-export declare const isFeedback: <T extends Feedback>(v: unknown) => v is Feedback;
+/** Is an unknown value a `Feedback` object. */
+export declare const isFeedback: <T extends Feedback<unknown>>(v: unknown) => v is Feedback<unknown>;
+/**
+ * Get an object of sub-messages in `{ key: message }` format from a feedback's value.
+ * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.
+ */
+export declare const getFeedbackMessages: ({ value }: Feedback) => ImmutableObject<string>;

package/feedback/Feedback.js

@@ -1,30 +1,22 @@
-import { getString } from "../util/string.js";
-import { mapObject } from "../util/transform.js";
-/**
- * The `Feedback` class represents a feedback message that should be shown to the user.
- * - Basic `Feedback` is neither good nor bad, `SuccessFeedback` indicates good news, and `ErrorFeedback` indicates bad news.
- *
- * Conceptually different to a Javascript `Error`...
- * - `Error`: a program error designed to help developers fix an issue in their code.
- * - `Feedback`: generated in reaction to something a user did, and helps them understand what to do next.
- *
- * @param feedback String feedback message that is safe to show to users.
- * @param details Set of other `Feedback` instances describing the issue in further detail.
- */
+import { getEntries } from "../util/entry.js";
+import { isObject } from "../util/object.js";
 export class Feedback {
-    constructor(feedback, details = {}) {
+    constructor(feedback, value) {
         this.message = feedback;
-        this.details = details;
-    }
-    /**
-     * Map details to a set of string messages.
-     * - If a detail is another `Feedback` instance, return its `.message` string.
-     * - If a detail is anything else, convert it to string using `toString()`
-     */
-    get messages() {
-        return mapObject(this.details, _getMessage);
+        this.value = value;
     }
 }
-const _getMessage = (v) => (isFeedback(v) ? v.message : getString(v));
-/** Is an unknown value a `Feedback` instance? */
-export const isFeedback = (v) => v instanceof Feedback;
+Feedback.prototype.name = "Feedback";
+/** Is an unknown value a `Feedback` object. */
+export const isFeedback = (v) => isObject(v) && typeof v.name === "string" && v.name.endsWith("Feedback") && typeof v.message === "string";
+/**
+ * Get an object of sub-messages in `{ key: message }` format from a feedback's value.
+ * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.
+ */
+export const getFeedbackMessages = ({ value }) => Object.fromEntries(_yieldFeedbackMessages(value));
+function* _yieldFeedbackMessages(value) {
+    if (isObject(value))
+        for (const [k, v] of getEntries(value))
+            if (isFeedback(v))
+                yield [k, v.message];
+}

package/feedback/InvalidFeedback.d.ts

@@ -1,4 +1,4 @@
 import { ErrorFeedback } from "./ErrorFeedback.js";
 /** Specific type of `ErrorFeedback` returned from `validate()` when a value is invalid. */
-export declare class InvalidFeedback extends ErrorFeedback {
+export declare class InvalidFeedback<T = unknown> extends ErrorFeedback<T> {
 }

package/feedback/InvalidFeedback.js

@@ -2,3 +2,4 @@ import { ErrorFeedback } from "./ErrorFeedback.js";
 /** Specific type of `ErrorFeedback` returned from `validate()` when a value is invalid. */
 export class InvalidFeedback extends ErrorFeedback {
 }
+InvalidFeedback.prototype.name = "InvalidFeedback";

package/feedback/SuccessFeedback.d.ts

@@ -1,4 +1,4 @@
 import { Feedback } from "./Feedback.js";
 /** Specific type of `Feedback` to indicate success (something went right!). */
-export declare class SuccessFeedback extends Feedback {
+export declare class SuccessFeedback<T = unknown> extends Feedback<T> {
 }

package/feedback/SuccessFeedback.js

@@ -2,3 +2,4 @@ import { Feedback } from "./Feedback.js";
 /** Specific type of `Feedback` to indicate success (something went right!). */
 export class SuccessFeedback extends Feedback {
 }
+SuccessFeedback.prototype.name = "SuccessFeedback";

package/feedback/WarningFeedback.d.ts

@@ -1,4 +1,4 @@
 import { Feedback } from "./Feedback.js";
 /** Specific type of `Feedback` to indicate warning (something might go wrong soon). */
-export declare class WarningFeedback extends Feedback {
+export declare class WarningFeedback<T = unknown> extends Feedback<T> {
 }

package/feedback/WarningFeedback.js

@@ -2,3 +2,4 @@ import { Feedback } from "./Feedback.js";
 /** Specific type of `Feedback` to indicate warning (something might go wrong soon). */
 export class WarningFeedback extends Feedback {
 }
+WarningFeedback.prototype.name = "WarningFeedback";

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,9 +1,8 @@
 import type { Firestore } from "firebase/firestore";
-import type { DocumentReference, QueryReference } from "../../db/Reference.js";
-import type { Data, Entities, OptionalEntity } from "../../util/data.js";
+import type { Entities, OptionalEntity, Datas, Key } from "../../util/data.js";
 import type { Unsubscribe } from "../../observe/Observable.js";
+import type { AsyncProvider, ProviderCollection, ProviderDocument, ProviderQuery } from "../../provider/Provider.js";
 import { Observer } from "../../observe/Observer.js";
-import { AsynchronousProvider, Provider } from "../../provider/Provider.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 /**
  * Firestore client database provider.
@@ -11,18 +10,18 @@ import { DataUpdate } from "../../update/DataUpdate.js";
  * - Supports offline mode.
  * - Supports realtime subscriptions.
  */
-export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
+export declare class FirestoreClientProvider<T extends Datas> implements AsyncProvider<T> {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    getDocument<T extends Data>(ref: DocumentReference<T>): Promise<OptionalEntity<T>>;
-    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: Observer<OptionalEntity<T>>): Unsubscribe;
-    addDocument<T extends Data>(ref: QueryReference<T>, data: T): Promise<string>;
-    setDocument<T extends Data>(ref: DocumentReference<T>, data: T): Promise<void>;
-    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): Promise<void>;
-    deleteDocument<T extends Data>(ref: DocumentReference<T>): Promise<void>;
-    getQuery<T extends Data>(ref: QueryReference<T>): Promise<Entities<T>>;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Entities<T>>): Unsubscribe;
-    setQuery<T extends Data>(ref: QueryReference<T>, data: T): Promise<number>;
-    updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): Promise<number>;
-    deleteQuery<T extends Data>(ref: QueryReference<T>): Promise<number>;
+    getDocument<K extends Key<T>>(ref: ProviderDocument<T, K>): Promise<OptionalEntity<T[K]>>;
+    subscribeDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, observer: Observer<OptionalEntity<T[K]>>): Unsubscribe;
+    addDocument<K extends Key<T>>(ref: ProviderCollection<T, K>, data: T[K]): Promise<string>;
+    setDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, data: T[K]): Promise<void>;
+    updateDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, update: DataUpdate<T[K]>): Promise<void>;
+    deleteDocument<K extends Key<T>>(ref: ProviderDocument<T, K>): Promise<void>;
+    getQuery<K extends Key<T>>(ref: ProviderQuery<T, K>): Promise<Entities<T[K]>>;
+    subscribeQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, observer: Observer<Entities<T[K]>>): Unsubscribe;
+    setQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, data: T[K]): Promise<number>;
+    updateQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, update: DataUpdate<T[K]>): Promise<number>;
+    deleteQuery<K extends Key<T>>(ref: ProviderQuery<T, K>): Promise<number>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -1,7 +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 { dispatchError, dispatchNext } from "../../observe/Observer.js";
-import { UnsupportedError } from "../../error/UnsupportedError.js";
-import { Provider } from "../../provider/Provider.js";
 import { ArrayUpdate } from "../../update/ArrayUpdate.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 import { Increment } from "../../update/Increment.js";
@@ -28,19 +26,19 @@ const DIRECTIONS = {
     ASC: "asc",
     DESC: "desc",
 };
-/** Get a Firestore DocumentReference for a given document. */
-function getDocument(firestore, { collection, id }) {
+/** Get a Firestore DatabaseDocument for a given document. */
+function _getDocument(firestore, { collection, id }) {
     return firestoreDocument(firestore, collection, id);
 }
 /** Get a Firestore CollectionReference for a given query. */
-function getCollection(firestore, { collection }) {
+function _getCollection(firestore, { collection }) {
     return firestoreCollection(firestore, collection);
 }
-/** Create a corresponding `QueryReference` from a Query. */
-function getQuery(firestore, ref) {
-    return firestoreQuery(getCollection(firestore, ref), ...yieldQueryConstraints(ref));
+/** Get a Firestore QueryReference for a given query. */
+function _getQuery(firestore, ref) {
+    return firestoreQuery(_getCollection(firestore, ref), ..._yieldQueryConstraints(ref));
 }
-function* yieldQueryConstraints({ sorts, filters, limit }) {
+function* _yieldQueryConstraints({ sorts, filters, limit }) {
     for (const { key, direction } of sorts)
         yield firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
     for (const { operator, key, value } of filters)
@@ -48,38 +46,44 @@ function* yieldQueryConstraints({ sorts, filters, limit }) {
     if (typeof limit === "number")
         yield firestoreLimit(limit);
 }
-function getEntities(snapshot) {
-    return snapshot.docs.map(getEntity);
+function _getEntities(snapshot) {
+    return snapshot.docs.map(_getEntity);
 }
-function getEntity(snapshot) {
+function _getEntity(snapshot) {
     const data = snapshot.data();
     return { ...data, id: snapshot.id };
 }
-function getOptionalEntity(snapshot) {
+function _getOptionalEntity(snapshot) {
     const data = snapshot.data();
     return data ? { ...data, id: snapshot.id } : null;
 }
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
-function* yieldFieldValues(updates, prefix = "") {
+function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (!(update instanceof Update))
-            yield [`${prefix}${key}`, update];
-        else if (update instanceof Delete)
-            yield [`${prefix}${key}`, firestoreDeleteField()];
-        else if (update instanceof Increment)
-            yield [`${prefix}${key}`, firestoreIncrement(update.amount)];
-        else if (update instanceof DataUpdate || update instanceof ObjectUpdate)
-            yield* yieldFieldValues(update, `${prefix}${key}.`);
+        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+            yield* _getFieldValues(update, `${prefix}${key}.`);
+        }
         else if (update instanceof ArrayUpdate) {
-            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)];
+            if (update.adds.length) {
+                yield `${prefix}${key}`;
+                yield firestoreArrayUnion(...update.adds);
+            }
+            if (update.deletes.length) {
+                yield `${prefix}${key}`;
+                yield firestoreArrayRemove(...update.deletes);
+            }
+        }
+        else {
+            yield `${prefix}${key}`;
+            if (!(update instanceof Update))
+                yield update;
+            else if (update instanceof Delete)
+                yield firestoreDeleteField();
+            else if (update instanceof Increment)
+                yield firestoreIncrement(update.amount);
+            else
+                yield update.transform();
         }
-        else
-            yield [`${prefix}${key}`, update.transform()];
     }
 }
 /**
@@ -88,50 +92,48 @@ function* yieldFieldValues(updates, prefix = "") {
  * - Supports offline mode.
  * - Supports realtime subscriptions.
  */
-export class FirestoreClientProvider extends Provider {
+export class FirestoreClientProvider {
     constructor(firestore) {
-        super();
         this.firestore = firestore;
     }
     async getDocument(ref) {
-        return getOptionalEntity(await getDoc(getDocument(this.firestore, ref)));
+        return _getOptionalEntity(await getDoc(_getDocument(this.firestore, ref)));
     }
     subscribeDocument(ref, observer) {
-        return onSnapshot(getDocument(this.firestore, ref), snapshot => dispatchNext(observer, getOptionalEntity(snapshot)), thrown => dispatchError(observer, thrown));
+        return onSnapshot(_getDocument(this.firestore, ref), snapshot => dispatchNext(observer, _getOptionalEntity(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async addDocument(ref, data) {
-        const reference = await addDoc(getCollection(this.firestore, ref), data);
+        const reference = await addDoc(_getCollection(this.firestore, ref), data);
         return reference.id;
     }
     async setDocument(ref, data) {
-        await setDoc(getDocument(this.firestore, ref), data);
+        await setDoc(_getDocument(this.firestore, ref), data);
     }
     async updateDocument(ref, update) {
-        const fieldValues = Object.fromEntries(yieldFieldValues(update));
-        await updateDoc(getDocument(this.firestore, ref), fieldValues);
+        await updateDoc(_getDocument(this.firestore, ref), ..._getFieldValues(update));
     }
     async deleteDocument(ref) {
-        await deleteDoc(getDocument(this.firestore, ref));
+        await deleteDoc(_getDocument(this.firestore, ref));
     }
     async getQuery(ref) {
-        return getEntities(await getDocs(getQuery(this.firestore, ref)));
+        return _getEntities(await getDocs(_getQuery(this.firestore, ref)));
     }
     subscribeQuery(ref, observer) {
-        return onSnapshot(getQuery(this.firestore, ref), snapshot => dispatchNext(observer, getEntities(snapshot)), thrown => dispatchError(observer, thrown));
+        return onSnapshot(_getQuery(this.firestore, ref), snapshot => dispatchNext(observer, _getEntities(snapshot)), thrown => dispatchError(observer, thrown));
     }
     async setQuery(ref, data) {
-        const snapshot = await getDocs(getQuery(this.firestore, ref));
+        const snapshot = await getDocs(_getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
         return snapshot.size;
     }
     async updateQuery(ref, update) {
-        const snapshot = await getDocs(getQuery(this.firestore, ref));
-        const fieldValues = Object.fromEntries(yieldFieldValues(update));
-        await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
+        const snapshot = await getDocs(_getQuery(this.firestore, ref));
+        const fieldValues = Array.from(_getFieldValues(update));
+        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));
+        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,8 +1,7 @@
 import type { Firestore } from "firebase/firestore/lite";
-import type { DocumentReference, QueryReference } from "../../db/Reference.js";
-import type { Data, Entities, OptionalEntity } from "../../util/data.js";
+import type { Entities, OptionalEntity, Datas, Key } from "../../util/data.js";
 import type { Unsubscribe } from "../../observe/Observable.js";
-import { AsynchronousProvider, Provider } from "../../provider/Provider.js";
+import type { AsyncProvider, ProviderCollection, ProviderDocument, ProviderQuery } from "../../provider/Provider.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 /**
  * Firestore Lite client database provider.
@@ -10,18 +9,18 @@ import { DataUpdate } from "../../update/DataUpdate.js";
  * - Does not support offline mode.
  * - Does not support realtime subscriptions.
  */
-export declare class FirestoreClientProvider extends Provider implements AsynchronousProvider {
+export declare class FirestoreLiteProvider<T extends Datas> implements AsyncProvider<T> {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    getDocument<T extends Data>(ref: DocumentReference<T>): Promise<OptionalEntity<T>>;
+    getDocument<K extends Key<T>>(ref: ProviderDocument<T, K>): Promise<OptionalEntity<T[K]>>;
     subscribeDocument(): Unsubscribe;
-    addDocument<T extends Data>(ref: QueryReference<T>, data: T): Promise<string>;
-    setDocument<T extends Data>(ref: DocumentReference<T>, data: T): Promise<void>;
-    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): Promise<void>;
-    deleteDocument<T extends Data>(ref: DocumentReference<T>): Promise<void>;
-    getQuery<T extends Data>(ref: QueryReference<T>): Promise<Entities<T>>;
+    addDocument<K extends Key<T>>(ref: ProviderCollection<T, K>, data: T[K]): Promise<string>;
+    setDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, data: T[K]): Promise<void>;
+    updateDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, update: DataUpdate<T[K]>): Promise<void>;
+    deleteDocument<K extends Key<T>>(ref: ProviderDocument<T, K>): Promise<void>;
+    getQuery<K extends Key<T>>(ref: ProviderQuery<T, K>): Promise<Entities<T[K]>>;
     subscribeQuery(): Unsubscribe;
-    setQuery<T extends Data>(ref: QueryReference<T>, data: T): Promise<number>;
-    updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): Promise<number>;
-    deleteQuery<T extends Data>(ref: QueryReference<T>): Promise<number>;
+    setQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, data: T[K]): Promise<number>;
+    updateQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, update: DataUpdate<T[K]>): Promise<number>;
+    deleteQuery<K extends Key<T>>(ref: ProviderQuery<T, K>): Promise<number>;
 }

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,6 +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 { UnsupportedError } from "../../error/UnsupportedError.js";
-import { Provider } from "../../provider/Provider.js";
 import { ArrayUpdate } from "../../update/ArrayUpdate.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 import { Increment } from "../../update/Increment.js";
@@ -28,18 +27,18 @@ const DIRECTIONS = {
     DESC: "desc",
 };
 /** Get a Firestore DocumentReference for a given document. */
-function getDocument(firestore, { collection, id }) {
+function _getDocument(firestore, { collection, id }) {
     return firestoreDocument(firestore, collection, id);
 }
 /** Get a Firestore CollectionReference for a given query. */
-function getCollection(firestore, { collection }) {
+function _getCollection(firestore, { collection }) {
     return firestoreCollection(firestore, collection);
 }
 /** Create a corresponding `QueryReference` from a Query. */
-function getQuery(firestore, ref) {
-    return firestoreQuery(getCollection(firestore, ref), ...yieldQueryConstraints(ref));
+function _getQuery(firestore, ref) {
+    return firestoreQuery(_getCollection(firestore, ref), ..._yieldQueryConstraints(ref));
 }
-function* yieldQueryConstraints({ sorts, filters, limit }) {
+function* _yieldQueryConstraints({ sorts, filters, limit }) {
     for (const { key, direction } of sorts)
         yield firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
     for (const { operator, key, value } of filters)
@@ -47,38 +46,44 @@ function* yieldQueryConstraints({ sorts, filters, limit }) {
     if (typeof limit === "number")
         yield firestoreLimit(limit);
 }
-function getEntities(snapshot) {
-    return snapshot.docs.map(getEntity);
+function _getEntities(snapshot) {
+    return snapshot.docs.map(_getEntity);
 }
-function getEntity(snapshot) {
+function _getEntity(snapshot) {
     const data = snapshot.data();
     return { ...data, id: snapshot.id };
 }
-function getOptionalData(snapshot) {
+function _getOptionalData(snapshot) {
     const data = snapshot.data();
     return data ? { ...data, id: snapshot.id } : null;
 }
 /** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
-function* yieldFieldValues(updates, prefix = "") {
+function* _getFieldValues(updates, prefix = "") {
     for (const [key, update] of updates) {
-        if (!(update instanceof Update))
-            yield [`${prefix}${key}`, update];
-        else if (update instanceof Delete)
-            yield [`${prefix}${key}`, firestoreDeleteField()];
-        else if (update instanceof Increment)
-            yield [`${prefix}${key}`, firestoreIncrement(update.amount)];
-        else if (update instanceof DataUpdate || update instanceof ObjectUpdate)
-            yield* yieldFieldValues(update, `${prefix}${key}.`);
+        if (update instanceof DataUpdate || update instanceof ObjectUpdate) {
+            yield* _getFieldValues(update, `${prefix}${key}.`);
+        }
         else if (update instanceof ArrayUpdate) {
-            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)];
+            if (update.adds.length) {
+                yield `${prefix}${key}`;
+                yield firestoreArrayUnion(...update.adds);
+            }
+            if (update.deletes.length) {
+                yield `${prefix}${key}`;
+                yield firestoreArrayRemove(...update.deletes);
+            }
+        }
+        else {
+            yield `${prefix}${key}`;
+            if (!(update instanceof Update))
+                yield update;
+            else if (update instanceof Delete)
+                yield firestoreDeleteField();
+            else if (update instanceof Increment)
+                yield firestoreIncrement(update.amount);
+            else
+                yield update.transform();
         }
-        else
-            yield [`${prefix}${key}`, update.transform()];
     }
 }
 /**
@@ -87,50 +92,48 @@ function* yieldFieldValues(updates, prefix = "") {
  * - Does not support offline mode.
  * - Does not support realtime subscriptions.
  */
-export class FirestoreClientProvider extends Provider {
+export class FirestoreLiteProvider {
     constructor(firestore) {
-        super();
         this.firestore = firestore;
     }
     async getDocument(ref) {
-        return getOptionalData(await getDoc(getDocument(this.firestore, ref)));
+        return _getOptionalData(await getDoc(_getDocument(this.firestore, ref)));
     }
     subscribeDocument() {
         throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async addDocument(ref, data) {
-        const reference = await addDoc(getCollection(this.firestore, ref), data);
+        const reference = await addDoc(_getCollection(this.firestore, ref), data);
         return reference.id;
     }
     async setDocument(ref, data) {
-        await setDoc(getDocument(this.firestore, ref), data);
+        await setDoc(_getDocument(this.firestore, ref), data);
     }
     async updateDocument(ref, update) {
-        const fieldValues = Object.fromEntries(yieldFieldValues(update));
-        await updateDoc(getDocument(this.firestore, ref), fieldValues);
+        await updateDoc(_getDocument(this.firestore, ref), ..._getFieldValues(update));
     }
     async deleteDocument(ref) {
-        await deleteDoc(getDocument(this.firestore, ref));
+        await deleteDoc(_getDocument(this.firestore, ref));
     }
     async getQuery(ref) {
-        return getEntities(await getDocs(getQuery(this.firestore, ref)));
+        return _getEntities(await getDocs(_getQuery(this.firestore, ref)));
     }
     subscribeQuery() {
         throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
     async setQuery(ref, data) {
-        const snapshot = await getDocs(getQuery(this.firestore, ref));
+        const snapshot = await getDocs(_getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
         return snapshot.size;
     }
     async updateQuery(ref, update) {
-        const snapshot = await getDocs(getQuery(this.firestore, ref));
-        const fieldValues = Object.fromEntries(yieldFieldValues(update));
-        await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
+        const snapshot = await getDocs(_getQuery(this.firestore, ref));
+        const fieldValues = Array.from(_getFieldValues(update));
+        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));
+        const snapshot = await getDocs(_getQuery(this.firestore, ref));
         await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
         return snapshot.size;
     }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,26 +1,25 @@
 import { Firestore } from "@google-cloud/firestore";
-import type { DocumentReference, QueryReference } from "../../db/Reference.js";
-import type { Data, Entities, OptionalEntity } from "../../util/data.js";
+import type { Entities, OptionalEntity, Datas, Key } from "../../util/data.js";
 import type { Unsubscribe } from "../../observe/Observable.js";
+import type { AsyncProvider, ProviderCollection, ProviderDocument, ProviderQuery } from "../../provider/Provider.js";
 import { Observer } from "../../observe/Observer.js";
-import { AsynchronousProvider, Provider } from "../../provider/Provider.js";
 import { DataUpdate } from "../../update/DataUpdate.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
  */
-export declare class FirestoreServerProvider extends Provider implements AsynchronousProvider {
+export declare class FirestoreServerProvider<T extends Datas> implements AsyncProvider<T> {
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
-    getDocument<T extends Data>(ref: DocumentReference<T>): Promise<OptionalEntity<T>>;
-    subscribeDocument<T extends Data>(ref: DocumentReference<T>, observer: Observer<OptionalEntity<T>>): Unsubscribe;
-    addDocument<T extends Data>(ref: QueryReference<T>, data: T): Promise<string>;
-    setDocument<T extends Data>(ref: DocumentReference<T>, data: T): Promise<void>;
-    updateDocument<T extends Data>(ref: DocumentReference<T>, update: DataUpdate<T>): Promise<void>;
-    deleteDocument<T extends Data>(ref: DocumentReference<T>): Promise<void>;
-    getQuery<T extends Data>(ref: QueryReference<T>): Promise<Entities<T>>;
-    subscribeQuery<T extends Data>(ref: QueryReference<T>, observer: Observer<Entities<T>>): Unsubscribe;
-    setQuery<T extends Data>(ref: QueryReference<T>, data: T): Promise<number>;
-    updateQuery<T extends Data>(ref: QueryReference<T>, update: DataUpdate<T>): Promise<number>;
-    deleteQuery<T extends Data>(ref: QueryReference<T>): Promise<number>;
+    getDocument<K extends Key<T>>(ref: ProviderDocument<T, K>): Promise<OptionalEntity<T[K]>>;
+    subscribeDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, observer: Observer<OptionalEntity<T[K]>>): Unsubscribe;
+    addDocument<K extends Key<T>>(ref: ProviderCollection<T, K>, data: T[K]): Promise<string>;
+    setDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, data: T[K]): Promise<void>;
+    updateDocument<K extends Key<T>>(ref: ProviderDocument<T, K>, update: DataUpdate<T[K]>): Promise<void>;
+    deleteDocument<K extends Key<T>>(ref: ProviderDocument<T, K>): Promise<void>;
+    getQuery<K extends Key<T>>(ref: ProviderQuery<T, K>): Promise<Entities<T[K]>>;
+    subscribeQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, observer: Observer<Entities<T[K]>>): Unsubscribe;
+    setQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, data: T[K]): Promise<number>;
+    updateQuery<K extends Key<T>>(ref: ProviderQuery<T, K>, update: DataUpdate<T[K]>): Promise<number>;
+    deleteQuery<K extends Key<T>>(ref: ProviderQuery<T, K>): Promise<number>;
 }