shelving 1.91.2 → 1.92.0

package/db/ItemState.d.ts

@@ -1,17 +1,17 @@
-import type { AsyncItem, Item, ItemData, ItemValue } from "./Item.js";
+import type { AsyncItemReference, ItemData, ItemReference, ItemValue } from "./ItemReference.js";
 import type { Data } from "../util/data.js";
 import type { Dispatch } from "../util/function.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
 /** Hold the current state of a item. */
 export declare class ItemState<T extends Data = Data> extends State<ItemValue<T>> {
-    readonly ref: Item<T> | AsyncItem<T>;
+    readonly ref: ItemReference<T> | AsyncItemReference<T>;
     readonly busy: BooleanState;
     /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
     get data(): ItemData<T>;
     /** Does the item exist (i.e. its value isn't `null`)? */
     get exists(): boolean;
-    constructor(ref: Item<T> | AsyncItem<T>);
+    constructor(ref: ItemReference<T> | AsyncItemReference<T>);
     /** Refresh this state from the source provider. */
     readonly refresh: () => void;
     private _refresh;

package/db/{Query.d.ts → QueryReference.d.ts}

@@ -1,20 +1,21 @@
-import type { ItemArray, ItemData, ItemValue } from "./Item.js";
-import type { PossibleFilters } from "../constraint/Filters.js";
-import type { PossibleSorts } from "../constraint/Sorts.js";
+import type { ItemArray, ItemData, ItemQuery, ItemValue } from "./ItemReference.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { Updates } from "../update/DataUpdate.js";
 import type { Data } from "../util/data.js";
 import type { Dispatch, Handler, Stop } from "../util/function.js";
-import { Statement } from "../constraint/Statement.js";
+import type { Updates } from "../util/update.js";
 /** Reference to a set of items in a sync or async provider. */
-declare abstract class BaseQuery<T extends Data = Data> extends Statement<ItemData<T>> implements AsyncIterable<ItemArray<T>> {
+declare abstract class AbstractQueryReference<T extends Data = Data> implements AsyncIterable<ItemArray<T>> {
     abstract readonly provider: Provider | AsyncProvider;
-    abstract readonly collection: string;
+    readonly collection: string;
+    readonly query: ItemQuery<T>;
+    constructor(collection: string, query?: ItemQuery<T>);
+    /** Get a copy of this query reference with additional query props. */
+    with(query: ItemQuery<T>): this;
     /**
      * Get array of entities for this query.
      * @return Array of entities.
      */
-    abstract value: ItemArray<T> | PromiseLike<ItemArray<T>>;
+    abstract items: ItemArray<T> | PromiseLike<ItemArray<T>>;
     /**
      * Count the number of results of this set of items.
      * @return Number of items matching the query (possibly promised).
@@ -29,22 +30,17 @@ declare abstract class BaseQuery<T extends Data = Data> extends Statement<ItemDa
      * Get the first item matched by this query or `null` if this query has no results.
      * @throws RequiredError if there were no results for this query.
      */
-    abstract firstValue: ItemValue<T> | PromiseLike<ItemValue<T>>;
-    /**
-     * Get the first item matched by this query.
-     * @throws RequiredError if there were no results for this query.
-     */
-    abstract firstData: ItemData<T> | PromiseLike<ItemData<T>>;
+    abstract first: ItemValue<T> | PromiseLike<ItemValue<T>>;
     /**
      * Get the last item matched by this query or `null` if this query has no results.
      * @throws RequiredError if there were no results for this query.
      */
-    abstract lastValue: ItemValue<T> | PromiseLike<ItemValue<T>>;
+    abstract last: ItemValue<T> | PromiseLike<ItemValue<T>>;
     /**
-     * Get the last item matched by this query.
+     * Get the first item matched by this query.
      * @throws RequiredError if there were no results for this query.
      */
-    abstract lastData: ItemData<T> | PromiseLike<ItemData<T>>;
+    abstract data: ItemData<T> | PromiseLike<ItemData<T>>;
     /**
      * Set all matching items to the same exact value.
      *
@@ -70,33 +66,29 @@ declare abstract class BaseQuery<T extends Data = Data> extends Statement<ItemDa
     [Symbol.asyncIterator](): AsyncIterator<ItemArray<T>>;
 }
 /** Reference to a set of items in a provider. */
-export declare class Query<T extends Data = Data> extends BaseQuery<T> {
+export declare class QueryReference<T extends Data = Data> extends AbstractQueryReference<T> {
     readonly provider: Provider;
-    readonly collection: string;
-    constructor(provider: Provider, collection: string, filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null);
-    get value(): ItemArray<T>;
+    constructor(provider: Provider, collection: string, query?: ItemQuery<T>);
+    get items(): ItemArray<T>;
     get count(): number;
     get exists(): boolean;
-    get firstValue(): ItemValue<T>;
-    get firstData(): ItemData<T>;
-    get lastValue(): ItemValue<T>;
-    get lastData(): ItemData<T>;
+    get first(): ItemValue<T>;
+    get last(): ItemValue<T>;
+    get data(): ItemData<T>;
     set(data: T): number;
     update(updates: Updates<T>): number;
     delete(): number;
 }
 /** Reference to a set of items in a provider. */
-export declare class AsyncQuery<T extends Data = Data> extends BaseQuery<T> {
+export declare class AsyncQueryReference<T extends Data = Data> extends AbstractQueryReference<T> {
     readonly provider: AsyncProvider;
-    readonly collection: string;
-    constructor(provider: AsyncProvider, collection: string, filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null);
-    get value(): Promise<ItemArray<T>>;
+    constructor(provider: AsyncProvider, collection: string, query?: ItemQuery<T>);
+    get items(): Promise<ItemArray<T>>;
     get count(): Promise<number>;
     get exists(): Promise<boolean>;
-    get firstValue(): Promise<ItemValue<T>>;
-    get firstData(): Promise<ItemData<T>>;
-    get lastValue(): Promise<ItemValue<T>>;
-    get lastData(): Promise<ItemData<T>>;
+    get first(): Promise<ItemValue<T>>;
+    get last(): Promise<ItemValue<T>>;
+    get data(): Promise<ItemData<T>>;
     set(data: T): Promise<number>;
     update(updates: Updates<T>): PromiseLike<number>;
     delete(): PromiseLike<number>;

package/db/QueryReference.js

@@ -0,0 +1,101 @@
+import { countArray, getOptionalFirstItem, getOptionalLastItem, isArrayLength } from "../util/array.js";
+import { getData } from "../util/data.js";
+import { cloneObjectWith } from "../util/object.js";
+import { runSequence } from "../util/sequence.js";
+/** Reference to a set of items in a sync or async provider. */
+class AbstractQueryReference {
+    constructor(collection, query = {}) {
+        this.collection = collection;
+        this.query = query;
+    }
+    /** Get a copy of this query reference with additional query props. */
+    with(query) {
+        return cloneObjectWith(this, "query", { ...this.query, query });
+    }
+    // Implement toString()
+    toString() {
+        return `${this.collection}?{${JSON.stringify(this.query)}`;
+    }
+    /** Subscribe to this item. */
+    subscribe(onNext, onError) {
+        return runSequence(this, onNext, onError);
+    }
+    // Implement AsyncIterable
+    [Symbol.asyncIterator]() {
+        return this.provider.getQuerySequence(this.collection, this.query)[Symbol.asyncIterator]();
+    }
+}
+/** Reference to a set of items in a provider. */
+export class QueryReference extends AbstractQueryReference {
+    constructor(provider, collection, query) {
+        super(collection, query);
+        this.provider = provider;
+    }
+    get items() {
+        return _getItemArray(this);
+    }
+    get count() {
+        return this.items.length;
+    }
+    get exists() {
+        return !!_getSingleItemArray(this).length;
+    }
+    get first() {
+        return getOptionalFirstItem(_getSingleItemArray(this));
+    }
+    get last() {
+        return getOptionalLastItem(this.items);
+    }
+    get data() {
+        return getData(this.first);
+    }
+    set(data) {
+        return this.provider.setQuery(this.collection, this.query, data);
+    }
+    update(updates) {
+        return this.provider.updateQuery(this.collection, this.query, updates);
+    }
+    delete() {
+        return this.provider.deleteQuery(this.collection, this.query);
+    }
+}
+/** Reference to a set of items in a provider. */
+export class AsyncQueryReference extends AbstractQueryReference {
+    constructor(provider, collection, query) {
+        super(collection, query);
+        this.provider = provider;
+    }
+    get items() {
+        return _getItemArray(this);
+    }
+    get count() {
+        return this.items.then(countArray);
+    }
+    get exists() {
+        return _getSingleItemArray(this).then(isArrayLength);
+    }
+    get first() {
+        return _getSingleItemArray(this).then(getOptionalFirstItem);
+    }
+    get last() {
+        return this.items.then(getOptionalLastItem);
+    }
+    get data() {
+        return this.first.then(getData);
+    }
+    set(data) {
+        return this.provider.setQuery(this.collection, this.query, data);
+    }
+    update(updates) {
+        return this.provider.updateQuery(this.collection, this.query, updates);
+    }
+    delete() {
+        return this.provider.deleteQuery(this.collection, this.query);
+    }
+}
+function _getItemArray({ provider, collection, query }) {
+    return provider.getQuery(collection, query);
+}
+function _getSingleItemArray({ provider, collection, query }) {
+    return provider.getQuery(collection, { ...query, $limit: 1 });
+}

package/db/QueryState.d.ts

@@ -1,30 +1,30 @@
-import type { ItemArray, ItemData, ItemValue } from "../db/Item.js";
-import type { AsyncQuery, Query } from "../db/Query.js";
+import type { ItemArray, ItemData, ItemValue } from "./ItemReference.js";
+import type { AsyncQueryReference, QueryReference } from "./QueryReference.js";
 import type { Data } from "../util/data.js";
 import type { Stop } from "../util/function.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
 /** Hold the current state of a query. */
 export declare class QueryState<T extends Data = Data> extends State<ItemArray<T>> implements Iterable<ItemData<T>> {
-    readonly ref: Query<T> | AsyncQuery<T>;
+    readonly ref: QueryReference<T> | AsyncQueryReference<T>;
     readonly busy: BooleanState;
     readonly limit: number;
     /** Can more items be loaded after the current result. */
     get hasMore(): boolean;
     private _hasMore;
+    /** Get the items currently stored in this query. */
+    get items(): ItemArray<T>;
     /** Get the first document matched by this query or `null` if this query has no items. */
-    get firstValue(): ItemValue<T>;
-    /** Get the first document matched by this query. */
-    get firstData(): ItemData<T>;
+    get first(): ItemValue<T>;
     /** Get the last document matched by this query or `null` if this query has no items. */
-    get lastValue(): ItemValue<T>;
-    /** Get the last document matched by this query. */
-    get lastData(): ItemData<T>;
+    get last(): ItemValue<T>;
+    /** Get the first document matched by this query. */
+    get data(): ItemData<T>;
     /** Does the document have at least one result. */
     get exists(): boolean;
     /** Get the number of items matching this query. */
     get count(): number;
-    constructor(ref: Query<T> | AsyncQuery<T>);
+    constructor(ref: QueryReference<T> | AsyncQueryReference<T>);
     /** Refresh this state from the source provider. */
     readonly refresh: () => void;
     private _refresh;

package/db/QueryState.js

@@ -2,7 +2,9 @@ import { CacheProvider } from "../provider/CacheProvider.js";
 import { LazyDeferredSequence } from "../sequence/LazyDeferredSequence.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { State } from "../state/State.js";
-import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
+import { getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
+import { getData } from "../util/data.js";
+import { getAfterQuery, getLimit } from "../util/query.js";
 import { getOptionalSource } from "../util/source.js";
 /** Hold the current state of a query. */
 export class QueryState extends State {
@@ -10,21 +12,21 @@ export class QueryState extends State {
     get hasMore() {
         return this._hasMore;
     }
+    /** Get the items currently stored in this query. */
+    get items() {
+        return this.value;
+    }
     /** Get the first document matched by this query or `null` if this query has no items. */
-    get firstValue() {
+    get first() {
         return getOptionalFirstItem(this.value);
     }
-    /** Get the first document matched by this query. */
-    get firstData() {
-        return getFirstItem(this.value);
-    }
     /** Get the last document matched by this query or `null` if this query has no items. */
-    get lastValue() {
+    get last() {
         return getOptionalLastItem(this.value);
     }
-    /** Get the last document matched by this query. */
-    get lastData() {
-        return getLastItem(this.value);
+    /** Get the first document matched by this query. */
+    get data() {
+        return getData(this.first);
     }
     /** Does the document have at least one result. */
     get exists() {
@@ -35,8 +37,8 @@ export class QueryState extends State {
         return this.value.length;
     }
     constructor(ref) {
-        var _a;
-        const { provider, collection, limit } = ref;
+        var _a, _b;
+        const { provider, collection, query } = ref;
         const table = (_a = getOptionalSource(CacheProvider, provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
         const time = table ? table.getQueryTime(ref) : null;
         const isCached = typeof time === "number";
@@ -58,7 +60,7 @@ export class QueryState extends State {
         };
         this._time = time;
         this.ref = ref;
-        this.limit = limit !== null && limit !== void 0 ? limit : Infinity;
+        this.limit = (_b = getLimit(query)) !== null && _b !== void 0 ? _b : Infinity;
         // Queue a request to refresh the value if it doesn't exist.
         if (this.loading)
             this.refresh();
@@ -66,7 +68,7 @@ export class QueryState extends State {
     async _refresh() {
         this.busy.set(true);
         try {
-            const items = await this.ref.value;
+            const items = await this.ref.items;
             this._hasMore = items.length >= this.limit; // If the query returned {limit} or more items, we can assume there are more items waiting to be queried.
             this.set(items);
         }
@@ -89,10 +91,10 @@ export class QueryState extends State {
     async _loadMore() {
         this.busy.set(true);
         try {
-            const last = this.lastValue;
-            const query = last ? this.ref.after(last) : this.ref;
-            const items = await query.value;
-            this.set([...this.value, ...items]);
+            const last = this.last;
+            const ref = last ? this.ref.with(getAfterQuery(this.ref.query, last)) : this.ref;
+            const items = await ref.items;
+            this.set([...this.items, ...items]);
             this._hasMore = items.length >= this.limit; // If the query returned {limit} or more items, we can assume there are more items waiting to be queried.
         }
         catch (thrown) {

package/db/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./Database.js";
-export * from "./Collection.js";
-export * from "./Item.js";
+export * from "./CollectionReference.js";
+export * from "./ItemReference.js";
 export * from "./ItemState.js";
-export * from "./Query.js";
+export * from "./QueryReference.js";
 export * from "./QueryState.js";
 export * from "./Change.js";

package/db/index.js

@@ -1,7 +1,7 @@
 export * from "./Database.js";
-export * from "./Collection.js";
-export * from "./Item.js";
+export * from "./CollectionReference.js";
+export * from "./ItemReference.js";
 export * from "./ItemState.js";
-export * from "./Query.js";
+export * from "./QueryReference.js";
 export * from "./QueryState.js";
 export * from "./Change.js";

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,7 +1,7 @@
-import type { ItemArray, ItemStatement, ItemValue } from "../../db/Item.js";
+import type { ItemArray, ItemQuery, ItemValue } from "../../db/ItemReference.js";
 import type { AsyncProvider } from "../../provider/Provider.js";
-import type { Updates } from "../../update/DataUpdate.js";
 import type { Data } from "../../util/data.js";
+import type { Updates } from "../../util/update.js";
 import type { Firestore } from "firebase/firestore";
 /**
  * Firestore client database provider.
@@ -12,15 +12,15 @@ import type { Firestore } from "firebase/firestore";
 export declare class FirestoreClientProvider implements AsyncProvider {
     private readonly _firestore;
     constructor(firestore: Firestore);
-    getItem(collection: string, id: string): Promise<ItemValue>;
-    getItemSequence(collection: string, id: string): AsyncIterable<ItemValue>;
-    addItem(collection: string, data: Data): Promise<string>;
-    setItem(collection: string, id: string, data: Data): Promise<void>;
-    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
-    deleteItem(collection: string, id: string): Promise<void>;
-    getQuery(collection: string, constraints: ItemStatement): Promise<ItemArray>;
-    getQuerySequence(collection: string, constraints: ItemStatement): AsyncIterable<ItemArray>;
-    setQuery(collection: string, constraints: ItemStatement, data: Data): Promise<number>;
-    updateQuery(collection: string, constraints: ItemStatement, updates: Updates): Promise<number>;
-    deleteQuery(collection: string, constraints: ItemStatement): Promise<number>;
+    getItem(c: string, id: string): Promise<ItemValue>;
+    getItemSequence(c: string, id: string): AsyncIterable<ItemValue>;
+    addItem(c: string, data: Data): Promise<string>;
+    setItem(c: string, id: string, data: Data): Promise<void>;
+    updateItem(c: string, id: string, updates: Updates): Promise<void>;
+    deleteItem(c: string, id: string): Promise<void>;
+    getQuery(c: string, q: ItemQuery): Promise<ItemArray>;
+    getQuerySequence(c: string, q: ItemQuery): AsyncIterable<ItemArray>;
+    setQuery(c: string, q: ItemQuery, data: Data): Promise<number>;
+    updateQuery(c: string, q: ItemQuery, updates: Updates): Promise<number>;
+    deleteQuery(c: string, q: ItemQuery): Promise<number>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -1,41 +1,38 @@
-import { addDoc, deleteDoc, arrayRemove as firestoreArrayRemove, arrayUnion as firestoreArrayUnion, collection as firestoreCollection, deleteField as firestoreDeleteField, doc as firestoreDocument, documentId as firestoreDocumentId, increment as firestoreIncrement, limit as firestoreLimit, orderBy as firestoreOrderBy, query as firestoreQuery, where as firestoreWhere, getDoc, getDocs, onSnapshot, setDoc, updateDoc, } from "firebase/firestore";
+import { addDoc, collection, deleteDoc, doc, documentId, getDoc, getDocs, increment, limit, onSnapshot, orderBy, query, setDoc, updateDoc, where } from "firebase/firestore";
 import { LazyDeferredSequence } from "../../sequence/LazyDeferredSequence.js";
-import { ArrayUpdate } from "../../update/ArrayUpdate.js";
-import { DataUpdate } from "../../update/DataUpdate.js";
-import { Delete } from "../../update/Delete.js";
-import { DictionaryUpdate } from "../../update/DictionaryUpdate.js";
-import { Increment } from "../../update/Increment.js";
-import { Update } from "../../update/Update.js";
+import { getObject } from "../../util/object.js";
+import { getFilters, getSorts } from "../../util/query.js";
+import { mapItems } from "../../util/transform.js";
+import { getUpdates } from "../../util/update.js";
 // Constants.
-const ID = firestoreDocumentId();
+const ID = documentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
-    IS: "==",
-    NOT: "!=",
-    IN: "in",
-    OUT: "not-in",
-    CONTAINS: "array-contains",
-    GT: ">",
-    GTE: ">=",
-    LT: "<",
-    LTE: "<=",
-};
-// Map `Filter.types` to `OrderByDirection`
-const DIRECTIONS = {
-    ASC: "asc",
-    DESC: "desc",
+    is: "==",
+    not: "!=",
+    in: "in",
+    out: "not-in",
+    contains: "array-contains",
+    gt: ">",
+    gte: ">=",
+    lt: "<",
+    lte: "<=",
 };
 /** Get a Firestore QueryReference for a given query. */
-function _getQuery(firestore, collection, constraints) {
-    return firestoreQuery(firestoreCollection(firestore, collection), ..._yieldConstraints(constraints));
+function _getQuery(firestore, c, q) {
+    return query(collection(firestore, c), ..._getConstraints(q));
 }
-function* _yieldConstraints({ sorts, filters, limit }) {
-    for (const { key, direction } of sorts)
-        yield firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
-    for (const { operator, key, value } of filters)
-        yield firestoreWhere(key, OPERATORS[operator], value);
-    if (typeof limit === "number")
-        yield firestoreLimit(limit);
+function* _getConstraints(q) {
+    for (const { keys, direction } of getSorts(q)) {
+        const key = keys.join(".");
+        yield orderBy(key === "id" ? ID : key, direction);
+    }
+    for (const { keys, operator, value } of getFilters(q)) {
+        const key = keys.join(".");
+        yield where(key === "id" ? ID : key, OPERATORS[operator], value);
+    }
+    if (typeof q.$limit === "number")
+        yield limit(q.$limit);
 }
 function _getItems(snapshot) {
     return snapshot.docs.map(_getItemData);
@@ -48,35 +45,9 @@ function _getItemValue(snapshot) {
     const data = snapshot.data();
     return data ? { ...data, id: snapshot.id } : null;
 }
-/** Convert `Update` instances into corresponding Firestore `FieldValue` instances. */
-function* _getFieldValues(updates, prefix = "") {
-    for (const [key, update] of updates) {
-        if (update instanceof DataUpdate || update instanceof DictionaryUpdate) {
-            yield* _getFieldValues(update, `${prefix}${key}.`);
-        }
-        else if (update instanceof ArrayUpdate) {
-            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();
-        }
-    }
-}
+/** Convert `Updates` object into corresponding Firestore `FieldValue` instances. */
+const _getFieldValues = (updates) => getObject(mapItems(getUpdates(updates), _getFieldValue));
+const _getFieldValue = ({ keys, action, value }) => [keys.join("."), action === "sum" ? increment(value) : action === "set" ? value : action];
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
@@ -87,48 +58,48 @@ export class FirestoreClientProvider {
     constructor(firestore) {
         this._firestore = firestore;
     }
-    async getItem(collection, id) {
-        return _getItemValue(await getDoc(firestoreDocument(this._firestore, collection, id)));
+    async getItem(c, id) {
+        return _getItemValue(await getDoc(doc(this._firestore, c, id)));
     }
-    getItemSequence(collection, id) {
-        return new LazyDeferredSequence(({ resolve, reject }) => onSnapshot(firestoreDocument(this._firestore, collection, id), //
+    getItemSequence(c, id) {
+        return new LazyDeferredSequence(({ resolve, reject }) => onSnapshot(doc(this._firestore, c, id), //
         //
         snapshot => resolve(_getItemValue(snapshot)), reject));
     }
-    async addItem(collection, data) {
-        const reference = await addDoc(firestoreCollection(this._firestore, collection), data);
+    async addItem(c, data) {
+        const reference = await addDoc(collection(this._firestore, c), data);
         return reference.id;
     }
-    async setItem(collection, id, data) {
-        await setDoc(firestoreDocument(this._firestore, collection, id), data);
+    async setItem(c, id, data) {
+        await setDoc(doc(this._firestore, c, id), data);
     }
-    async updateItem(collection, id, updates) {
-        await updateDoc(firestoreDocument(this._firestore, collection, id), ..._getFieldValues(Object.entries(updates)));
+    async updateItem(c, id, updates) {
+        await updateDoc(doc(this._firestore, c, id), _getFieldValues(updates));
     }
-    async deleteItem(collection, id) {
-        await deleteDoc(firestoreDocument(this._firestore, collection, id));
+    async deleteItem(c, id) {
+        await deleteDoc(doc(this._firestore, c, id));
     }
-    async getQuery(collection, constraints) {
-        return _getItems(await getDocs(_getQuery(this._firestore, collection, constraints)));
+    async getQuery(c, q) {
+        return _getItems(await getDocs(_getQuery(this._firestore, c, q)));
     }
-    getQuerySequence(collection, constraints) {
-        return new LazyDeferredSequence(({ resolve, reject }) => onSnapshot(_getQuery(this._firestore, collection, constraints), //
+    getQuerySequence(c, q) {
+        return new LazyDeferredSequence(({ resolve, reject }) => onSnapshot(_getQuery(this._firestore, c, q), //
         //
         snapshot => resolve(_getItems(snapshot)), reject));
     }
-    async setQuery(collection, constraints, data) {
-        const snapshot = await getDocs(_getQuery(this._firestore, collection, constraints));
+    async setQuery(c, q, data) {
+        const snapshot = await getDocs(_getQuery(this._firestore, c, q));
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
         return snapshot.size;
     }
-    async updateQuery(collection, constraints, updates) {
-        const snapshot = await getDocs(_getQuery(this._firestore, collection, constraints));
-        const fieldValues = Array.from(_getFieldValues(Object.entries(updates)));
-        await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, ...fieldValues)));
+    async updateQuery(c, q, updates) {
+        const snapshot = await getDocs(_getQuery(this._firestore, c, q));
+        const fieldValues = _getFieldValues(updates);
+        await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, fieldValues)));
         return snapshot.size;
     }
-    async deleteQuery(collection, constraints) {
-        const snapshot = await getDocs(_getQuery(this._firestore, collection, constraints));
+    async deleteQuery(c, q) {
+        const snapshot = await getDocs(_getQuery(this._firestore, c, q));
         await Promise.all(snapshot.docs.map(s => deleteDoc(s.ref)));
         return snapshot.size;
     }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,7 +1,7 @@
-import type { ItemArray, ItemStatement, ItemValue } from "../../db/Item.js";
+import type { ItemArray, ItemQuery, ItemValue } from "../../db/ItemReference.js";
 import type { AsyncProvider } from "../../provider/Provider.js";
-import type { Updates } from "../../update/DataUpdate.js";
 import type { Data } from "../../util/data.js";
+import type { Updates } from "../../util/update.js";
 import type { Firestore } from "firebase/firestore/lite";
 /**
  * Firestore Lite client database provider.
@@ -12,15 +12,15 @@ import type { Firestore } from "firebase/firestore/lite";
 export declare class FirestoreLiteProvider implements AsyncProvider {
     private readonly _firestore;
     constructor(firestore: Firestore);
-    getItem(collection: string, id: string): Promise<ItemValue>;
+    getItem(c: string, id: string): Promise<ItemValue>;
     getItemSequence(): AsyncIterableIterator<ItemValue>;
-    addItem(collection: string, data: Data): Promise<string>;
-    setItem(collection: string, id: string, data: Data): Promise<void>;
-    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
-    deleteItem(collection: string, id: string): Promise<void>;
-    getQuery(collection: string, constraints: ItemStatement): Promise<ItemArray>;
+    addItem(c: string, data: Data): Promise<string>;
+    setItem(c: string, id: string, data: Data): Promise<void>;
+    updateItem(c: string, id: string, updates: Updates): Promise<void>;
+    deleteItem(c: string, id: string): Promise<void>;
+    getQuery(c: string, q: ItemQuery): Promise<ItemArray>;
     getQuerySequence(): AsyncIterableIterator<ItemArray>;
-    setQuery(collection: string, constraints: ItemStatement, data: Data): Promise<number>;
-    updateQuery(collection: string, constraints: ItemStatement, updates: Updates): Promise<number>;
-    deleteQuery(collection: string, constraints: ItemStatement): Promise<number>;
+    setQuery(c: string, q: ItemQuery, data: Data): Promise<number>;
+    updateQuery(c: string, q: ItemQuery, updates: Updates): Promise<number>;
+    deleteQuery(c: string, q: ItemQuery): Promise<number>;
 }