shelving 1.91.2 → 1.92.0

package/provider/DebugProvider.js

@@ -1,5 +1,4 @@
 /* eslint-disable no-console */
-import { Statement } from "../constraint/Statement.js";
 /** Provider that logs operations to a source provider to the console. */
 class AbstractDebugProvider {
     async *getItemSequence(collection, id) {
@@ -16,11 +15,11 @@ class AbstractDebugProvider {
             console.error("ITERATE", key, thrown);
         }
     }
-    async *getQuerySequence(collection, constraints) {
-        const key = _getQueryKey(collection, constraints);
+    async *getQuerySequence(collection, query) {
+        const key = _getQueryKey(collection, query);
         try {
             console.log("ITERATE", key, "DATA:");
-            for await (const items of this.source.getQuerySequence(collection, constraints)) {
+            for await (const items of this.source.getQuerySequence(collection, query)) {
                 console.log("ITERATE", key, "ITEMS:", items);
                 yield items;
             }
@@ -94,10 +93,10 @@ export class DebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    getQuery(collection, constraints) {
-        const key = _getQueryKey(collection, constraints);
+    getQuery(collection, query) {
+        const key = _getQueryKey(collection, query);
         try {
-            const items = this.source.getQuery(collection, constraints);
+            const items = this.source.getQuery(collection, query);
             console.log("GET:", key, "ITEMS:", items);
             return items;
         }
@@ -106,10 +105,10 @@ export class DebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    setQuery(collection, constraints, data) {
-        const key = _getQueryKey(collection, constraints);
+    setQuery(collection, query, data) {
+        const key = _getQueryKey(collection, query);
         try {
-            const num = this.source.setQuery(collection, constraints, data);
+            const num = this.source.setQuery(collection, query, data);
             console.log("SET:", key, "DATA:", data, "DONE:", num);
             return num;
         }
@@ -118,10 +117,10 @@ export class DebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    updateQuery(collection, constraints, updates) {
-        const key = _getQueryKey(collection, constraints);
+    updateQuery(collection, query, updates) {
+        const key = _getQueryKey(collection, query);
         try {
-            const num = this.source.updateQuery(collection, constraints, updates);
+            const num = this.source.updateQuery(collection, query, updates);
             console.log("UPDATE:", key, "UPDATES:", updates, "DONE:", num);
             return num;
         }
@@ -130,10 +129,10 @@ export class DebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    deleteQuery(collection, constraints) {
-        const key = _getQueryKey(collection, constraints);
+    deleteQuery(collection, query) {
+        const key = _getQueryKey(collection, query);
         try {
-            const num = this.source.deleteQuery(collection, constraints);
+            const num = this.source.deleteQuery(collection, query);
             console.log("DELETE:", key, "DONE:", num);
             return num;
         }
@@ -211,11 +210,11 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    async getQuery(collection, constraints) {
-        const key = _getQueryKey(collection, constraints);
+    async getQuery(collection, query) {
+        const key = _getQueryKey(collection, query);
         try {
             console.log("GET:", key);
-            const items = await this.source.getQuery(collection, constraints);
+            const items = await this.source.getQuery(collection, query);
             console.log("GET:", key, "ITEMS:", items);
             return items;
         }
@@ -224,11 +223,11 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    async setQuery(collection, constraints, data) {
-        const key = _getQueryKey(collection, constraints);
+    async setQuery(collection, query, data) {
+        const key = _getQueryKey(collection, query);
         try {
             console.log("SET:", key, "DATA:", data);
-            const num = await this.source.setQuery(collection, constraints, data);
+            const num = await this.source.setQuery(collection, query, data);
             console.log("SET:", key, "DATA:", data, "DONE:", num);
             return num;
         }
@@ -237,11 +236,11 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    async updateQuery(collection, constraints, updates) {
-        const key = _getQueryKey(collection, constraints);
+    async updateQuery(collection, query, updates) {
+        const key = _getQueryKey(collection, query);
         try {
             console.log("UPDATE:", key, "UPDATES:", updates);
-            const num = await this.source.updateQuery(collection, constraints, updates);
+            const num = await this.source.updateQuery(collection, query, updates);
             console.log("UPDATE:", key, "UPDATES:", updates, "DONE:", num);
             return num;
         }
@@ -250,11 +249,11 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    async deleteQuery(collection, constraints) {
-        const key = _getQueryKey(collection, constraints);
+    async deleteQuery(collection, query) {
+        const key = _getQueryKey(collection, query);
         try {
             console.log("DELETE:", key);
-            const num = await this.source.deleteQuery(collection, constraints);
+            const num = await this.source.deleteQuery(collection, query);
             console.log("DELETE:", key, "DONE:", num);
             return num;
         }
@@ -265,4 +264,4 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
     }
 }
 const _getItemKey = (collection, id) => `${collection}/${id}`;
-const _getQueryKey = (collection, statement) => `${collection}?${Statement.prototype.toString.call(statement)}`;
+const _getQueryKey = (collection, query) => `${collection}?${JSON.stringify(query)}`;

package/provider/MemoryProvider.d.ts

@@ -1,7 +1,7 @@
 import type { Provider } from "./Provider.js";
-import type { ItemArray, ItemData, ItemStatement, ItemValue } from "../db/Item.js";
-import type { Updates } from "../update/DataUpdate.js";
+import type { ItemArray, ItemData, ItemQuery, ItemValue } from "../db/ItemReference.js";
 import type { Data } from "../util/data.js";
+import type { Updates } from "../util/update.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 /**
  * Fast in-memory store for data.
@@ -20,12 +20,12 @@ export declare class MemoryProvider implements Provider {
     setItem(collection: string, id: string, data: Data): void;
     updateItem(collection: string, id: string, updates: Updates): void;
     deleteItem(collection: string, id: string): void;
-    getQueryTime(collection: string, constraints: ItemStatement): number | null;
-    getQuery(collection: string, constraints: ItemStatement): ItemArray;
-    getQuerySequence(collection: string, constraints: ItemStatement): AsyncIterable<ItemArray>;
-    setQuery(collection: string, constraints: ItemStatement, data: Data): number;
-    updateQuery(collection: string, constraints: ItemStatement, updates: Updates): number;
-    deleteQuery(collection: string, constraints: ItemStatement): number;
+    getQueryTime(collection: string, query: ItemQuery): number | null;
+    getQuery(collection: string, query: ItemQuery): ItemArray;
+    getQuerySequence(collection: string, query: ItemQuery): AsyncIterable<ItemArray>;
+    setQuery(collection: string, query: ItemQuery, data: Data): number;
+    updateQuery(collection: string, query: ItemQuery, updates: Updates): number;
+    deleteQuery(collection: string, query: ItemQuery): number;
 }
 /** An individual table of data. */
 export declare class MemoryTable<T extends Data = Data> {
@@ -47,17 +47,17 @@ export declare class MemoryTable<T extends Data = Data> {
     setItemValueSequence(id: string, sequence: AsyncIterable<ItemValue<T>>): AsyncIterable<ItemValue>;
     updateItem(id: string, updates: Updates<T>): void;
     deleteItem(id: string): void;
-    getQueryTime(constraints: ItemStatement<T>): number | null;
-    getQuery(constraints: ItemStatement<T>): ItemArray<T>;
-    getQuerySequence(constraints: ItemStatement<T>): AsyncIterable<ItemArray<T>>;
+    getQueryTime(query: ItemQuery<T>): number | null;
+    getQuery(query: ItemQuery<T>): ItemArray<T>;
+    getQuerySequence(query: ItemQuery<T>): AsyncIterable<ItemArray<T>>;
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
-    getCachedQuerySequence(constraints: ItemStatement<T>): AsyncIterable<ItemArray<T>>;
+    getCachedQuerySequence(query: ItemQuery<T>): AsyncIterable<ItemArray<T>>;
     private _setItems;
     setItems(items: ItemArray<T>): void;
     setItemsSequence(sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
-    setQueryItems(constraints: ItemStatement<T>, items: ItemArray<T>): void;
-    setQueryItemsSequence(constraints: ItemStatement<T>, sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
-    setQuery(constraints: ItemStatement<T>, data: T): number;
-    updateQuery(constraints: ItemStatement<T>, updates: Updates<T>): number;
-    deleteQuery(constraints: ItemStatement<T>): number;
+    setQueryItems(query: ItemQuery<T>, items: ItemArray<T>): void;
+    setQueryItemsSequence(query: ItemQuery<T>, sequence: AsyncIterable<ItemArray<T>>): AsyncIterable<ItemArray<T>>;
+    setQuery(query: ItemQuery<T>, data: T): number;
+    updateQuery(query: ItemQuery<T>, updates: Updates<T>): number;
+    deleteQuery(query: ItemQuery<T>): number;
 }

package/provider/MemoryProvider.js

@@ -1,10 +1,10 @@
-import { Statement } from "../constraint/Statement.js";
 import { RequiredError } from "../error/RequiredError.js";
 import { DeferredSequence } from "../sequence/DeferredSequence.js";
 import { getArray } from "../util/array.js";
 import { isArrayEqual } from "../util/equal.js";
+import { queryItems, queryWritableItems } from "../util/query.js";
 import { getRandomKey } from "../util/random.js";
-import { transformObject } from "../util/transform.js";
+import { updateData } from "../util/update.js";
 /**
  * Fast in-memory store for data.
  * - Extremely fast (ideal for caching!), but does not persist data after the browser window is closed.
@@ -40,23 +40,23 @@ export class MemoryProvider {
     deleteItem(collection, id) {
         return this.getTable(collection).deleteItem(id);
     }
-    getQueryTime(collection, constraints) {
-        return this.getTable(collection).getQueryTime(constraints);
+    getQueryTime(collection, query) {
+        return this.getTable(collection).getQueryTime(query);
     }
-    getQuery(collection, constraints) {
-        return this.getTable(collection).getQuery(constraints);
+    getQuery(collection, query) {
+        return this.getTable(collection).getQuery(query);
     }
-    getQuerySequence(collection, constraints) {
-        return this.getTable(collection).getQuerySequence(constraints);
+    getQuerySequence(collection, query) {
+        return this.getTable(collection).getQuerySequence(query);
     }
-    setQuery(collection, constraints, data) {
-        return this.getTable(collection).setQuery(constraints, data);
+    setQuery(collection, query, data) {
+        return this.getTable(collection).setQuery(query, data);
     }
-    updateQuery(collection, constraints, updates) {
-        return this.getTable(collection).updateQuery(constraints, updates);
+    updateQuery(collection, query, updates) {
+        return this.getTable(collection).updateQuery(query, updates);
     }
-    deleteQuery(collection, constraints) {
-        return this.getTable(collection).deleteQuery(constraints);
+    deleteQuery(collection, query) {
+        return this.getTable(collection).deleteQuery(query);
     }
 }
 /** An individual table of data. */
@@ -132,7 +132,7 @@ export class MemoryTable {
         const oldItem = this._data.get(id);
         if (!oldItem)
             throw new RequiredError(`Document "${id}" does not exist`);
-        const newItem = transformObject(oldItem, updates);
+        const newItem = updateData(oldItem, updates);
         if (oldItem !== newItem) {
             this._data.set(id, newItem);
             this._times.set(id, Date.now());
@@ -146,34 +146,34 @@ export class MemoryTable {
             this._changed.resolve();
         }
     }
-    getQueryTime(constraints) {
-        return this._times.get(_getQueryKey(constraints)) || null;
+    getQueryTime(query) {
+        return this._times.get(_getQueryKey(query)) || null;
     }
-    getQuery(constraints) {
-        return getArray(constraints.transform(this._data.values()));
+    getQuery(query) {
+        return getArray(queryItems(this._data.values(), query));
     }
-    async *getQuerySequence(constraints) {
-        let last = this.getQuery(constraints);
+    async *getQuerySequence(query) {
+        let last = this.getQuery(query);
         yield last;
         while (true) {
             await this._changed;
-            const next = this.getQuery(constraints);
+            const next = this.getQuery(query);
             if (!isArrayEqual(last, next))
                 yield (last = next);
         }
     }
     /** Subscribe to a query in this table, but only if the query has been explicitly set (i.e. has a time). */
-    async *getCachedQuerySequence(constraints) {
-        const key = _getQueryKey(constraints);
+    async *getCachedQuerySequence(query) {
+        const key = _getQueryKey(query);
         let last = undefined;
         if (this._times.has(key)) {
-            last = this.getQuery(constraints);
+            last = this.getQuery(query);
             yield last;
         }
         while (true) {
             await this._changed;
             if (this._times.has(key)) {
-                const next = this.getQuery(constraints);
+                const next = this.getQuery(query);
                 if (!last || !isArrayEqual(last, next))
                     yield (last = next);
             }
@@ -194,15 +194,15 @@ export class MemoryTable {
             yield items;
         }
     }
-    setQueryItems(constraints, items) {
-        const key = _getQueryKey(constraints);
+    setQueryItems(query, items) {
+        const key = _getQueryKey(query);
         const now = Date.now();
         this._times.set(key, now);
         this._setItems(items, now);
         this._changed.resolve();
     }
-    async *setQueryItemsSequence(constraints, sequence) {
-        const key = _getQueryKey(constraints);
+    async *setQueryItemsSequence(query, sequence) {
+        const key = _getQueryKey(query);
         for await (const items of sequence) {
             const now = Date.now();
             this._times.set(key, now);
@@ -211,26 +211,26 @@ export class MemoryTable {
             yield items;
         }
     }
-    setQuery(constraints, data) {
+    setQuery(query, data) {
         const now = Date.now();
         let count = 0;
-        for (const { id } of _getWriteConstraints(constraints).transform(this._data.values())) {
+        for (const { id } of queryWritableItems(this._data.values(), query)) {
             this._data.set(id, { ...data, id });
             this._times.set(id, now);
             count++;
         }
         if (count) {
-            const key = _getQueryKey(constraints);
+            const key = _getQueryKey(query);
             this._times.set(key, now);
             this._changed.resolve();
         }
         return count;
     }
-    updateQuery(constraints, updates) {
+    updateQuery(query, updates) {
         const now = Date.now();
         let count = 0;
-        for (const oldItem of _getWriteConstraints(constraints).transform(this._data.values())) {
-            const newItem = transformObject(oldItem, updates);
+        for (const oldItem of queryWritableItems(this._data.values(), query)) {
+            const newItem = updateData(oldItem, updates);
             if (oldItem !== newItem) {
                 const id = oldItem.id;
                 this._data.set(id, newItem);
@@ -239,29 +239,27 @@ export class MemoryTable {
             }
         }
         if (count) {
-            const key = _getQueryKey(constraints);
+            const key = _getQueryKey(query);
             this._times.set(key, now);
             this._changed.resolve();
         }
         return count;
     }
-    deleteQuery(constraints) {
+    deleteQuery(query) {
         const now = Date.now();
         let count = 0;
-        for (const { id } of _getWriteConstraints(constraints).transform(this._data.values())) {
+        for (const { id } of queryWritableItems(this._data.values(), query)) {
             this._data.delete(id);
             this._times.set(id, now);
             count++;
         }
         if (count) {
-            const key = _getQueryKey(constraints);
+            const key = _getQueryKey(query);
             this._times.set(key, now);
             this._changed.resolve();
         }
         return count;
     }
 }
-// When we're writing data, if there's no limit set the results don't need to be sorted (for performance).
-const _getWriteConstraints = (statement) => (statement.limit ? statement : statement.filters);
 // Queries that have no limit don't care about sorting either.
-const _getQueryKey = (statement) => (statement.limit ? `"filters":${statement.filters.toString()}}` : Statement.prototype.toString.call(statement));
+const _getQueryKey = (query) => JSON.stringify(query);

package/provider/Provider.d.ts

@@ -1,6 +1,6 @@
-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";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
 declare abstract class AbstractProvider {
     /**
@@ -42,30 +42,30 @@ declare abstract class AbstractProvider {
      *
      * @return Set of values in `id: data` format.
      */
-    abstract getQuery(collection: string, constraints: ItemStatement): ItemArray | PromiseLike<ItemArray>;
+    abstract getQuery(collection: string, query: ItemQuery): ItemArray | PromiseLike<ItemArray>;
     /**
      * Subscribe to all matching items with an async iterator.
      */
-    abstract getQuerySequence(collection: string, constraints: ItemStatement): AsyncIterable<ItemArray>;
+    abstract getQuerySequence(collection: string, query: ItemQuery): AsyncIterable<ItemArray>;
     /**
      * Set the data of all matching items.
      *
      * @param data Data to set matching items to.
      * @return Number of items that were set.
      */
-    abstract setQuery(collection: string, constraints: ItemStatement, data: Data): number | PromiseLike<number>;
+    abstract setQuery(collection: string, query: ItemQuery, data: Data): number | PromiseLike<number>;
     /**
      * Update the data of all matching items.
      *
      * @param updates Set of property updates to apply to matching items.
      * @return Number of items that were updated.
      */
-    abstract updateQuery(collection: string, constraints: ItemStatement, updates: Updates): number | PromiseLike<number>;
+    abstract updateQuery(collection: string, query: ItemQuery, updates: Updates): number | PromiseLike<number>;
     /**
      * Delete all matching items.
      * @return Number of items that were deleted.
      */
-    abstract deleteQuery(collection: string, constraints: ItemStatement): number | PromiseLike<number>;
+    abstract deleteQuery(collection: string, query: ItemQuery): number | PromiseLike<number>;
 }
 /** Provider with a fully synchronous interface */
 export declare abstract class Provider extends AbstractProvider {
@@ -74,10 +74,10 @@ export declare abstract class Provider extends AbstractProvider {
     abstract setItem(collection: string, id: string, data: Data): void;
     abstract updateItem(collection: string, id: string, updates: Updates): void;
     abstract deleteItem(collection: string, id: string): void;
-    abstract getQuery(collection: string, constraints: ItemStatement): ItemArray;
-    abstract setQuery(collection: string, constraints: ItemStatement, data: Data): number;
-    abstract updateQuery(collection: string, constraints: ItemStatement, updates: Updates): number;
-    abstract deleteQuery(collection: string, constraints: ItemStatement): number;
+    abstract getQuery(collection: string, query: ItemQuery): ItemArray;
+    abstract setQuery(collection: string, query: ItemQuery, data: Data): number;
+    abstract updateQuery(collection: string, query: ItemQuery, updates: Updates): number;
+    abstract deleteQuery(collection: string, query: ItemQuery): number;
 }
 /** Provider with a fully asynchronous interface */
 export declare abstract class AsyncProvider extends AbstractProvider {
@@ -86,9 +86,9 @@ export declare abstract class AsyncProvider extends AbstractProvider {
     abstract setItem(collection: string, id: string, data: Data): Promise<void>;
     abstract updateItem(collection: string, id: string, updates: Updates): Promise<void>;
     abstract deleteItem(collection: string, id: string): Promise<void>;
-    abstract getQuery(collection: string, constraints: ItemStatement): Promise<ItemArray>;
-    abstract setQuery(collection: string, constraints: ItemStatement, data: Data): Promise<number>;
-    abstract updateQuery(collection: string, constraints: ItemStatement, updates: Updates): Promise<number>;
-    abstract deleteQuery(collection: string, constraints: ItemStatement): Promise<number>;
+    abstract getQuery(collection: string, query: ItemQuery): Promise<ItemArray>;
+    abstract setQuery(collection: string, query: ItemQuery, data: Data): Promise<number>;
+    abstract updateQuery(collection: string, query: ItemQuery, updates: Updates): Promise<number>;
+    abstract deleteQuery(collection: string, query: ItemQuery): Promise<number>;
 }
 export {};

package/provider/ThroughProvider.d.ts

@@ -1,8 +1,8 @@
 import type { AsyncProvider, Provider } from "./Provider.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 { Sourceable } from "../util/source.js";
+import type { Updates } from "../util/update.js";
 /** A provider that passes through to a synchronous source. */
 export declare class ThroughProvider implements Provider, Sourceable<Provider> {
     readonly source: Provider;
@@ -13,11 +13,11 @@ export declare class ThroughProvider implements Provider, Sourceable<Provider> {
     setItem(collection: string, id: string, data: Data): void;
     updateItem(collection: string, id: string, update: Updates): void;
     deleteItem(collection: string, id: string): void;
-    getQuery(collection: string, constraints: ItemStatement): ItemArray;
-    getQuerySequence(collection: string, constraints: ItemStatement): AsyncIterable<ItemArray>;
-    setQuery(collection: string, constraints: ItemStatement, data: Data): number;
-    updateQuery(collection: string, constraints: ItemStatement, update: Updates): number;
-    deleteQuery(collection: string, constraints: ItemStatement): number;
+    getQuery(collection: string, query: ItemQuery): ItemArray;
+    getQuerySequence(collection: string, query: ItemQuery): AsyncIterable<ItemArray>;
+    setQuery(collection: string, query: ItemQuery, data: Data): number;
+    updateQuery(collection: string, query: ItemQuery, update: Updates): number;
+    deleteQuery(collection: string, query: ItemQuery): number;
 }
 /** A provider that passes through to an asynchronous source. */
 export declare class AsyncThroughProvider implements AsyncProvider, Sourceable<AsyncProvider> {
@@ -29,9 +29,9 @@ export declare class AsyncThroughProvider implements AsyncProvider, Sourceable<A
     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>;
+    getQuery(collection: string, query: ItemQuery): Promise<ItemArray>;
+    getQuerySequence(collection: string, query: ItemQuery): AsyncIterable<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/ThroughProvider.js

@@ -21,20 +21,20 @@ export class ThroughProvider {
     deleteItem(collection, id) {
         return this.source.deleteItem(collection, id);
     }
-    getQuery(collection, constraints) {
-        return this.source.getQuery(collection, constraints);
+    getQuery(collection, query) {
+        return this.source.getQuery(collection, query);
     }
-    getQuerySequence(collection, constraints) {
-        return this.source.getQuerySequence(collection, constraints);
+    getQuerySequence(collection, query) {
+        return this.source.getQuerySequence(collection, query);
     }
-    setQuery(collection, constraints, data) {
-        return this.source.setQuery(collection, constraints, data);
+    setQuery(collection, query, data) {
+        return this.source.setQuery(collection, query, data);
     }
-    updateQuery(collection, constraints, update) {
-        return this.source.updateQuery(collection, constraints, update);
+    updateQuery(collection, query, update) {
+        return this.source.updateQuery(collection, query, update);
     }
-    deleteQuery(collection, constraints) {
-        return this.source.deleteQuery(collection, constraints);
+    deleteQuery(collection, query) {
+        return this.source.deleteQuery(collection, query);
     }
 }
 /** A provider that passes through to an asynchronous source. */
@@ -60,19 +60,19 @@ export class AsyncThroughProvider {
     deleteItem(collection, id) {
         return this.source.deleteItem(collection, id);
     }
-    getQuery(collection, constraints) {
-        return this.source.getQuery(collection, constraints);
+    getQuery(collection, query) {
+        return this.source.getQuery(collection, query);
     }
-    getQuerySequence(collection, constraints) {
-        return this.source.getQuerySequence(collection, constraints);
+    getQuerySequence(collection, query) {
+        return this.source.getQuerySequence(collection, query);
     }
-    setQuery(collection, constraints, data) {
-        return this.source.setQuery(collection, constraints, data);
+    setQuery(collection, query, data) {
+        return this.source.setQuery(collection, query, data);
     }
-    updateQuery(collection, constraints, updates) {
-        return this.source.updateQuery(collection, constraints, updates);
+    updateQuery(collection, query, updates) {
+        return this.source.updateQuery(collection, query, updates);
     }
-    deleteQuery(collection, constraints) {
-        return this.source.deleteQuery(collection, constraints);
+    deleteQuery(collection, query) {
+        return this.source.deleteQuery(collection, query);
     }
 }

package/provider/ValidationProvider.d.ts

@@ -1,9 +1,9 @@
 import type { AsyncProvider, Provider } from "./Provider.js";
-import type { ItemArray, ItemStatement, ItemValue } from "../db/Item.js";
+import type { ItemArray, ItemQuery, ItemValue } from "../db/ItemReference.js";
 import type { DataSchema, DataSchemas } from "../schema/DataSchema.js";
-import type { Updates } from "../update/DataUpdate.js";
 import type { DataKey, Datas } from "../util/data.js";
 import type { Sourceable } from "../util/source.js";
+import type { Updates } from "../util/update.js";
 /** Validate a source provider (source can have any type because validation guarantees the type). */
 declare abstract class BaseValidationProvider<T extends Datas> {
     abstract source: Provider | AsyncProvider;
@@ -11,7 +11,7 @@ declare abstract class BaseValidationProvider<T extends Datas> {
     constructor(schemas: DataSchemas<T>);
     getSchema<K extends DataKey<T>>(collection: K): DataSchema<T[K]>;
     getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<ItemValue<T[K]>>;
-    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>): AsyncIterable<ItemArray<T[K]>>;
+    getQuerySequence<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>): AsyncIterable<ItemArray<T[K]>>;
 }
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
 export declare class ValidationProvider<T extends Datas> extends BaseValidationProvider<T> implements Provider, Sourceable<Provider> {
@@ -22,10 +22,10 @@ export declare class ValidationProvider<T extends Datas> extends BaseValidationP
     setItem<K extends DataKey<T>>(collection: K, id: string, value: T[K]): void;
     updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
     deleteItem<K extends DataKey<T>>(collection: K, id: string): void;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>): ItemArray<T[K]>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>, value: T[K]): number;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>, updates: Updates<T[K]>): number;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>): number;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>): ItemArray<T[K]>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>, value: T[K]): number;
+    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>, updates: Updates<T[K]>): number;
+    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>): number;
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export declare class AsyncValidationProvider<T extends Datas> extends BaseValidationProvider<T> implements AsyncProvider, Sourceable<AsyncProvider> {
@@ -36,9 +36,9 @@ export declare class AsyncValidationProvider<T extends Datas> extends BaseValida
     setItem<K extends DataKey<T>>(collection: K, id: string, value: T[K]): Promise<void>;
     updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
     deleteItem<K extends DataKey<T>>(collection: K, id: string): Promise<void>;
-    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>): Promise<ItemArray<T[K]>>;
-    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>, value: T[K]): Promise<number>;
-    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>, updates: Updates<T[K]>): Promise<number>;
-    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemStatement<T[K]>): Promise<number>;
+    getQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>): Promise<ItemArray<T[K]>>;
+    setQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>, value: T[K]): Promise<number>;
+    updateQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>, updates: Updates<T[K]>): Promise<number>;
+    deleteQuery<K extends DataKey<T>>(collection: K, constraints: ItemQuery<T[K]>): Promise<number>;
 }
 export {};