shelving 1.91.2 → 1.92.0

package/firestore/lite/FirestoreLiteProvider.js

@@ -1,44 +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, setDoc, updateDoc, } from "firebase/firestore/lite";
+import { addDoc, collection, deleteDoc, doc, documentId, getDoc, getDocs, increment, limit, orderBy, query, setDoc, updateDoc, where } from "firebase/firestore/lite";
 import { UnsupportedError } from "../../error/UnsupportedError.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: "<=",
 };
 /** Create a corresponding `QueryReference` from a Query. */
-function _getQuery(firestore, collection, constraints) {
-    return firestoreQuery(firestoreCollection(firestore, collection), ..._yieldConstraints(constraints));
-}
-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 === "id" ? ID : key, OPERATORS[operator], value);
-    if (typeof limit === "number")
-        yield firestoreLimit(limit);
+function _getQuery(firestore, c, q) {
+    return query(collection(firestore, c), ..._getConstraints(q));
 }
-function _getItems(snapshot) {
-    return snapshot.docs.map(_getItemData);
+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 _getItemData(snapshot) {
     const data = snapshot.data();
@@ -48,35 +42,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 Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -87,44 +55,45 @@ export class FirestoreLiteProvider {
     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() {
         throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
-    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) {
+        const snapshot = await getDocs(_getQuery(this._firestore, c, q));
+        return snapshot.docs.map(_getItemData);
     }
     getQuerySequence() {
         throw new UnsupportedError("FirestoreLiteProvider does not support realtime subscriptions");
     }
-    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/server/FirestoreServerProvider.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 { Firestore } from "@google-cloud/firestore";
 /**
  * Firestore server database provider.
@@ -10,15 +10,15 @@ import { Firestore } from "@google-cloud/firestore";
 export declare class FirestoreServerProvider 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<K extends string>(collection: K, 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<K extends string>(c: K, 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/server/FirestoreServerProvider.js

@@ -1,40 +1,36 @@
 import { FieldPath, FieldValue, Firestore } from "@google-cloud/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 = FieldPath.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: "<=",
 };
 /** Create a corresponding `QueryReference` from a Query. */
-function _getQuery(firestore, collection, constraints) {
-    const { sorts, filters, limit } = constraints;
-    let query = firestore.collection(collection);
-    for (const { key, direction } of sorts)
-        query = query.orderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
-    for (const { operator, key, value } of filters)
+function _getQuery(firestore, c, q) {
+    let query = firestore.collection(c);
+    for (const { keys, direction } of getSorts(q)) {
+        const key = keys.join(".");
+        query = query.orderBy(key === "id" ? ID : key, direction);
+    }
+    for (const { keys, operator, value } of getFilters(q)) {
+        const key = keys.join(".");
         query = query.where(key === "id" ? ID : key, OPERATORS[operator], value);
-    if (typeof limit === "number")
-        query = query.limit(limit);
+    }
+    if (typeof q.$limit === "number")
+        query = query.limit(q.$limit);
     return query;
 }
 function _getItemArray(snapshot) {
@@ -49,34 +45,8 @@ function _getItemValue(snapshot) {
     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 FieldValue.arrayUnion(...update.adds);
-            }
-            if (update.deletes.length) {
-                yield `${prefix}${key}`;
-                yield FieldValue.arrayRemove(...update.deletes);
-            }
-        }
-        else {
-            yield `${prefix}${key}`;
-            if (!(update instanceof Update))
-                yield update;
-            else if (update instanceof Delete)
-                yield FieldValue.delete();
-            else if (update instanceof Increment)
-                yield FieldValue.increment(update.amount);
-            else
-                yield update.transform();
-        }
-    }
-}
+const _getFieldValues = (updates) => getObject(mapItems(getUpdates(updates), _getFieldValue));
+const _getFieldValue = ({ keys, action, value }) => [keys.join("."), action === "sum" ? FieldValue.increment(value) : action === "set" ? value : action];
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -85,53 +55,50 @@ export class FirestoreServerProvider {
     constructor(firestore = new Firestore()) {
         this._firestore = firestore;
     }
-    async getItem(collection, id) {
-        return _getItemValue(await this._firestore.collection(collection).doc(id).get());
+    async getItem(c, id) {
+        return _getItemValue(await this._firestore.collection(c).doc(id).get());
     }
-    getItemSequence(collection, id) {
-        const ref = this._firestore.collection(collection).doc(id);
+    getItemSequence(c, id) {
+        const ref = this._firestore.collection(c).doc(id);
         return new LazyDeferredSequence(({ resolve, reject }) => ref.onSnapshot(snapshot => resolve(_getItemValue(snapshot)), //
         reject));
     }
-    async addItem(collection, data) {
-        return (await this._firestore.collection(collection).add(data)).id;
+    async addItem(c, data) {
+        return (await this._firestore.collection(c).add(data)).id;
     }
-    async setItem(collection, id, data) {
-        await this._firestore.collection(collection).doc(id).set(data);
+    async setItem(c, id, data) {
+        await this._firestore.collection(c).doc(id).set(data);
     }
-    async updateItem(collection, id, updates) {
-        await this._firestore
-            .collection(collection)
-            .doc(id)
-            .update(..._getFieldValues(Object.entries(updates)));
+    async updateItem(c, id, updates) {
+        await this._firestore.collection(c).doc(id).update(_getFieldValues(updates));
     }
-    async deleteItem(collection, id) {
-        await this._firestore.collection(collection).doc(id).delete();
+    async deleteItem(c, id) {
+        await this._firestore.collection(c).doc(id).delete();
     }
-    async getQuery(collection, constraints) {
-        return _getItemArray(await _getQuery(this._firestore, collection, constraints).get());
+    async getQuery(c, q) {
+        return _getItemArray(await _getQuery(this._firestore, c, q).get());
     }
-    getQuerySequence(collection, constraints) {
-        const ref = _getQuery(this._firestore, collection, constraints);
+    getQuerySequence(c, q) {
+        const ref = _getQuery(this._firestore, c, q);
         return new LazyDeferredSequence(({ resolve, reject }) => ref.onSnapshot(snapshot => resolve(_getItemArray(snapshot)), //
         reject));
     }
-    async setQuery(collection, constraints, data) {
-        return await bulkWrite(this._firestore, collection, constraints, (w, s) => void w.set(s.ref, data));
+    async setQuery(c, q, data) {
+        return await bulkWrite(this._firestore, c, q, (w, s) => void w.set(s.ref, data));
     }
-    async updateQuery(collection, constraints, updates) {
-        const fieldValues = _getFieldValues(Object.entries(updates));
-        return await bulkWrite(this._firestore, collection, constraints, (w, s) => void w.update(s.ref, ...fieldValues));
+    async updateQuery(c, q, updates) {
+        const fieldValues = _getFieldValues(updates);
+        return await bulkWrite(this._firestore, c, q, (w, s) => void w.update(s.ref, fieldValues));
     }
-    async deleteQuery(collection, constraints) {
-        return await bulkWrite(this._firestore, collection, constraints, (w, s) => void w.delete(s.ref));
+    async deleteQuery(c, q) {
+        return await bulkWrite(this._firestore, c, q, (w, s) => void w.delete(s.ref));
     }
 }
 /** Perform a bulk update on a set of documents using a `BulkWriter` */
-async function bulkWrite(firestore, collection, constraints, callback) {
+async function bulkWrite(firestore, c, q, callback) {
     let count = 0;
     const writer = firestore.bulkWriter();
-    const query = _getQuery(firestore, collection, constraints).limit(BATCH_SIZE).select(); // `select()` turs the query into a field mask query (with no field masks) which saves data transfer and memory.
+    const query = _getQuery(firestore, c, q).limit(BATCH_SIZE).select(); // `select()` turs the query into a field mask query (with no field masks) which saves data transfer and memory.
     let current = query;
     while (current) {
         const { docs, size } = await current.get();

package/index.d.ts

@@ -4,7 +4,6 @@
  * - Modules that are for internal use, like `shelving/test`
  */
 export * from "./api/index.js";
-export * from "./constraint/index.js";
 export * from "./db/index.js";
 export * from "./error/index.js";
 export * from "./feedback/index.js";
@@ -14,5 +13,4 @@ export * from "./provider/index.js";
 export * from "./schema/index.js";
 export * from "./sequence/index.js";
 export * from "./state/index.js";
-export * from "./update/index.js";
 export * from "./util/index.js";

package/index.js

@@ -4,7 +4,6 @@
  * - Modules that are for internal use, like `shelving/test`
  */
 export * from "./api/index.js";
-export * from "./constraint/index.js";
 export * from "./db/index.js";
 export * from "./error/index.js";
 export * from "./feedback/index.js";
@@ -19,5 +18,4 @@ export * from "./schema/index.js";
 export * from "./sequence/index.js";
 export * from "./state/index.js";
 // export * from "./test/index.js"; // Not exported.
-export * from "./update/index.js";
 export * from "./util/index.js";

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.91.2",
+	"version": "1.92.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -22,7 +22,6 @@
 	"exports": {
 		".": "./index.js",
 		"./api": "./api/index.js",
-		"./constraint": "./constraint/index.js",
 		"./db": "./db/index.js",
 		"./error": "./error/index.js",
 		"./feedback": "./feedback/index.js",
@@ -37,7 +36,6 @@
 		"./sequence": "./sequence/index.js",
 		"./state": "./state/index.js",
 		"./test": "./test/index.js",
-		"./update": "./update/index.js",
 		"./util": "./util/index.js"
 	},
 	"sideEffects": false,

package/provider/CacheProvider.d.ts

@@ -1,8 +1,8 @@
 import type { AsyncProvider } from "./Provider.js";
 import type { AsyncThroughProvider } from "./ThroughProvider.js";
-import type { ItemArray, ItemStatement, ItemValue } from "../db/Item.js";
-import type { Updates } from "../update/DataUpdate.js";
+import type { ItemArray, ItemQuery, ItemValue } from "../db/ItemReference.js";
 import type { Data } from "../util/data.js";
+import type { Updates } from "../util/update.js";
 import { MemoryProvider } from "./MemoryProvider.js";
 /** Keep a copy of asynchronous remote data in a local synchronous cache. */
 export declare class CacheProvider implements AsyncThroughProvider {
@@ -15,9 +15,9 @@ export declare class CacheProvider implements AsyncThroughProvider {
     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): 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>;
+    getQuery(collection: string, query: ItemQuery): Promise<ItemArray>;
+    getQuerySequence(collection: string, query: ItemQuery): AsyncIterableIterator<ItemArray>;
+    setQuery(collection: string, query: ItemQuery, data: Data): Promise<number>;
+    updateQuery(collection: string, query: ItemQuery, updates: Updates): Promise<number>;
+    deleteQuery(collection: string, query: ItemQuery): Promise<number>;
 }

package/provider/CacheProvider.js

@@ -34,29 +34,29 @@ export class CacheProvider {
         await this.source.deleteItem(collection, id);
         this.memory.getTable(collection).deleteItem(id);
     }
-    async getQuery(collection, constraints) {
-        const items = await this.source.getQuery(collection, constraints);
+    async getQuery(collection, query) {
+        const items = await this.source.getQuery(collection, query);
         const table = this.memory.getTable(collection);
-        table.setQueryItems(constraints, items);
+        table.setQueryItems(query, items);
         return items;
     }
-    async *getQuerySequence(collection, constraints) {
+    async *getQuerySequence(collection, query) {
         const table = this.memory.getTable(collection);
-        yield* table.setQueryItemsSequence(constraints, this.source.getQuerySequence(collection, constraints));
+        yield* table.setQueryItemsSequence(query, this.source.getQuerySequence(collection, query));
     }
-    async setQuery(collection, constraints, data) {
-        const count = await this.source.setQuery(collection, constraints, data);
-        this.memory.getTable(collection).setQuery(constraints, data);
+    async setQuery(collection, query, data) {
+        const count = await this.source.setQuery(collection, query, data);
+        this.memory.getTable(collection).setQuery(query, data);
         return count;
     }
-    async updateQuery(collection, constraints, updates) {
-        const count = await this.source.updateQuery(collection, constraints, updates);
-        this.memory.getTable(collection).updateQuery(constraints, updates);
+    async updateQuery(collection, query, updates) {
+        const count = await this.source.updateQuery(collection, query, updates);
+        this.memory.getTable(collection).updateQuery(query, updates);
         return count;
     }
-    async deleteQuery(collection, constraints) {
-        const count = await this.source.deleteQuery(collection, constraints);
-        this.memory.getTable(collection).deleteQuery(constraints);
+    async deleteQuery(collection, query) {
+        const count = await this.source.deleteQuery(collection, query);
+        this.memory.getTable(collection).deleteQuery(query);
         return count;
     }
 }

package/provider/DebugProvider.d.ts

@@ -1,13 +1,13 @@
 import type { AsyncProvider, Provider } from "./Provider.js";
 import type { AsyncThroughProvider, ThroughProvider } from "./ThroughProvider.js";
-import type { ItemArray, ItemStatement, ItemValue } from "../db/Item.js";
-import type { Updates } from "../update/DataUpdate.js";
+import type { ItemArray, ItemQuery, ItemValue } from "../db/ItemReference.js";
 import type { Data } from "../util/data.js";
+import type { Updates } from "../util/update.js";
 /** Provider that logs operations to a source provider to the console. */
 declare abstract class AbstractDebugProvider {
     abstract readonly source: Provider | AsyncProvider;
     getItemSequence(collection: string, id: string): AsyncIterableIterator<ItemValue>;
-    getQuerySequence(collection: string, constraints: ItemStatement): AsyncIterableIterator<ItemArray>;
+    getQuerySequence(collection: string, query: ItemQuery): AsyncIterableIterator<ItemArray>;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
 export declare class DebugProvider extends AbstractDebugProvider implements ThroughProvider {
@@ -18,10 +18,10 @@ export declare class DebugProvider extends AbstractDebugProvider implements Thro
     setItem(collection: string, id: string, data: Data): void;
     updateItem(collection: string, id: string, updates: Updates): void;
     deleteItem(collection: string, id: string): void;
-    getQuery(collection: string, constraints: ItemStatement): ItemArray;
-    setQuery(collection: string, constraints: ItemStatement, data: Data): number;
-    updateQuery(collection: string, constraints: ItemStatement, updates: Updates): number;
-    deleteQuery(collection: string, constraints: ItemStatement): number;
+    getQuery(collection: string, query: ItemQuery): ItemArray;
+    setQuery(collection: string, query: ItemQuery, data: Data): number;
+    updateQuery(collection: string, query: ItemQuery, updates: Updates): number;
+    deleteQuery(collection: string, query: ItemQuery): number;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
 export declare class AsyncDebugProvider extends AbstractDebugProvider implements AsyncThroughProvider {
@@ -32,9 +32,9 @@ export declare class AsyncDebugProvider extends AbstractDebugProvider implements
     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>;
-    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>;
+    getQuery(collection: string, query: ItemQuery): Promise<ItemArray>;
+    setQuery(collection: string, query: ItemQuery, data: Data): Promise<number>;
+    updateQuery(collection: string, query: ItemQuery, updates: Updates): Promise<number>;
+    deleteQuery(collection: string, query: ItemQuery): Promise<number>;
 }
 export {};