shelving 1.76.2 → 1.79.0

package/{provider → modules/provider}/CacheProvider.d.ts

@@ -2,7 +2,7 @@ import type { Datas, Key } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../db/Item.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Unsubscribe } from "../observe/Observable.js";
-import type { DataUpdate } from "../update/DataUpdate.js";
+import type { Updates } from "../update/DataUpdate.js";
 import type { AsyncProvider } from "./Provider.js";
 import type { AsyncThroughProvider } from "./ThroughProvider.js";
 import { MemoryProvider } from "./MemoryProvider.js";
@@ -15,11 +15,11 @@ export declare class CacheProvider<T extends Datas> implements AsyncThroughProvi
     subscribeItem<K extends Key<T>>(collection: K, id: string, observer: PartialObserver<ItemValue<T[K]>>): Unsubscribe;
     addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
     setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): Promise<void>;
+    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
     deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
     subscribeQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, observer: PartialObserver<ItemArray<T[K]>>): Unsubscribe;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): Promise<number>;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
 }

package/{provider → modules/provider}/CacheProvider.js

@@ -24,11 +24,11 @@ export class CacheProvider {
         await this.source.setItem(collection, id, data);
         this.memory.getTable(collection).setItem(id, data);
     }
-    async updateItem(collection, id, update) {
-        await this.source.updateItem(collection, id, update);
+    async updateItem(collection, id, updates) {
+        await this.source.updateItem(collection, id, updates);
         const table = this.memory.getTable(collection);
         if (table.getItem(id))
-            table.updateItem(id, update);
+            table.updateItem(id, updates);
     }
     async deleteItem(collection, id) {
         await this.source.deleteItem(collection, id);
@@ -49,9 +49,9 @@ export class CacheProvider {
         this.memory.getTable(collection).setQuery(constraints, data);
         return count;
     }
-    async updateQuery(collection, constraints, update) {
-        const count = await this.source.updateQuery(collection, constraints, update);
-        this.memory.getTable(collection).updateQuery(constraints, update);
+    async updateQuery(collection, constraints, updates) {
+        const count = await this.source.updateQuery(collection, constraints, updates);
+        this.memory.getTable(collection).updateQuery(constraints, updates);
         return count;
     }
     async deleteQuery(collection, constraints) {

package/{provider → modules/provider}/DebugProvider.d.ts

@@ -1,6 +1,6 @@
 import type { Datas, Key } from "../util/data.js";
 import type { ItemArray, ItemConstraints, ItemValue } from "../db/Item.js";
-import type { DataUpdate } from "../update/DataUpdate.js";
+import type { Updates } from "../update/DataUpdate.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Unsubscribe } from "../observe/Observable.js";
 import { Provider, AsyncProvider } from "./Provider.js";
@@ -18,11 +18,11 @@ export declare class DebugProvider<T extends Datas> extends AbstractDebugProvide
     getItem<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
     addItem<K extends Key<T>>(collection: K, data: T[K]): string;
     setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): void;
+    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
     deleteItem<K extends Key<T>>(collection: K, id: string): void;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): number;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
 }
 /** Provider that logs operations to a synchronous source provider to the console. */
@@ -32,11 +32,11 @@ export declare class AsyncDebugProvider<T extends Datas> extends AbstractDebugPr
     getItem<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
     addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
     setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): Promise<void>;
+    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
     deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): Promise<number>;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
 }
 export {};

package/{provider → modules/provider}/DebugProvider.js

@@ -64,11 +64,11 @@ export class DebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    updateItem(collection, id, update) {
+    updateItem(collection, id, updates) {
         const key = _getItemKey(collection, id);
-        console.log(`Update: ${key}:`, update.updates);
+        console.log(`Update: ${key}:`, updates.updates);
         try {
-            return this.source.updateItem(collection, id, update);
+            return this.source.updateItem(collection, id, updates);
         }
         catch (reason) {
             console.error(`Error: Update: ${key}:`, reason);
@@ -108,11 +108,11 @@ export class DebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    updateQuery(collection, constraints, update) {
+    updateQuery(collection, constraints, updates) {
         const key = _getQueryKey(collection, constraints);
-        console.log(`Update: ${key}:`, update.updates);
+        console.log(`Update: ${key}:`, updates.updates);
         try {
-            return this.source.updateQuery(collection, constraints, update);
+            return this.source.updateQuery(collection, constraints, updates);
         }
         catch (reason) {
             console.error(`Error: Update: ${key}:`, reason);
@@ -170,11 +170,11 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    async updateItem(collection, id, update) {
+    async updateItem(collection, id, updates) {
         const key = _getItemKey(collection, id);
-        console.log(`Update: ${key}:`, update.updates);
+        console.log(`Update: ${key}:`, updates.updates);
         try {
-            return await this.source.updateItem(collection, id, update);
+            return await this.source.updateItem(collection, id, updates);
         }
         catch (reason) {
             console.error(`Error: Update: ${key}:`, reason);
@@ -214,11 +214,11 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
             throw reason;
         }
     }
-    async updateQuery(collection, constraints, update) {
+    async updateQuery(collection, constraints, updates) {
         const key = _getQueryKey(collection, constraints);
-        console.log(`Update: ${key}:`, update.updates);
+        console.log(`Update: ${key}:`, updates.updates);
         try {
-            return await this.source.updateQuery(collection, constraints, update);
+            return await this.source.updateQuery(collection, constraints, updates);
         }
         catch (reason) {
             console.error(`Error: Update: ${key}:`, reason);

package/{provider → modules/provider}/MemoryProvider.d.ts

@@ -1,6 +1,6 @@
 import type { Data, Datas, Key } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemData, ItemConstraints } from "../db/Item.js";
-import type { DataUpdate } from "../update/DataUpdate.js";
+import type { Updates } from "../update/DataUpdate.js";
 import type { Dispatch } from "../util/function.js";
 import type { Unsubscribe } from "../observe/Observable.js";
 import { Subject } from "../observe/Subject.js";
@@ -21,13 +21,13 @@ export declare class MemoryProvider<T extends Datas> implements Provider<T> {
     subscribeItem<K extends Key<T>>(collection: K, id: string, observer: PartialObserver<ItemValue<T[K]>>): Unsubscribe;
     addItem<K extends Key<T>>(collection: K, data: T[K]): string;
     setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): void;
+    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
     deleteItem<K extends Key<T>>(collection: K, id: string): void;
     getQueryTime<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number | null;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
     subscribeQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, observer: PartialObserver<ItemArray<T[K]>>): Unsubscribe;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): number;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
 }
 /**
@@ -48,7 +48,7 @@ export declare class MemoryTable<T extends Data> extends Subject<void> {
     addItem(data: T): string;
     setItemData(data: ItemData<T>): void;
     setItem(id: string, data: T): void;
-    updateItem(id: string, update: DataUpdate<T>): void;
+    updateItem(id: string, updates: Updates<T>): void;
     deleteItem(id: string): void;
     getQueryTime(query: ItemConstraints<T>): number | null;
     setQueryTime(query: ItemConstraints<T>): void;
@@ -58,6 +58,6 @@ export declare class MemoryTable<T extends Data> extends Subject<void> {
     subscribeCachedQuery(query: ItemConstraints<T>, observer: PartialObserver<ItemArray<T>>): Unsubscribe;
     setItems(items: ItemArray<T>): number;
     setQuery(constraints: ItemConstraints<T>, data: T): number;
-    updateQuery(constraints: ItemConstraints<T>, update: DataUpdate<T>): number;
+    updateQuery(constraints: ItemConstraints<T>, updates: Updates<T>): number;
     deleteQuery(constraints: ItemConstraints<T>): number;
 }

package/{provider → modules/provider}/MemoryProvider.js

@@ -5,6 +5,7 @@ import { RequiredError } from "../error/RequiredError.js";
 import { Subject } from "../observe/Subject.js";
 import { dispatchNext } from "../observe/Observer.js";
 import { getArray } from "../util/array.js";
+import { transformData } from "../util/transform.js";
 /**
  * Fast in-memory store for data.
  * - Extremely fast (ideal for caching!), but does not persist data after the browser window is closed.
@@ -34,8 +35,8 @@ export class MemoryProvider {
     setItem(collection, id, data) {
         return this.getTable(collection).setItem(id, data);
     }
-    updateItem(collection, id, update) {
-        return this.getTable(collection).updateItem(id, update);
+    updateItem(collection, id, updates) {
+        return this.getTable(collection).updateItem(id, updates);
     }
     deleteItem(collection, id) {
         return this.getTable(collection).deleteItem(id);
@@ -52,8 +53,8 @@ export class MemoryProvider {
     setQuery(collection, constraints, data) {
         return this.getTable(collection).setQuery(constraints, data);
     }
-    updateQuery(collection, constraints, update) {
-        return this.getTable(collection).updateQuery(constraints, update);
+    updateQuery(collection, constraints, updates) {
+        return this.getTable(collection).updateQuery(constraints, updates);
     }
     deleteQuery(collection, constraints) {
         return this.getTable(collection).deleteQuery(constraints);
@@ -126,11 +127,11 @@ export class MemoryTable extends Subject {
     setItem(id, data) {
         this.setItemData({ ...data, id });
     }
-    updateItem(id, update) {
+    updateItem(id, updates) {
         const item = this._data.get(id);
         if (!item)
             throw new RequiredError(`Document "${id}" does not exist`);
-        this.setItemData({ ...update.transform(item), id });
+        this.setItemData({ ...transformData(item, updates), id });
     }
     deleteItem(id) {
         this._data.delete(id);
@@ -197,11 +198,11 @@ export class MemoryTable extends Subject {
         this.next();
         return count;
     }
-    updateQuery(constraints, update) {
+    updateQuery(constraints, updates) {
         const now = Date.now();
         let count = 0;
         for (const item of _getWriteConstraints(constraints).transform(this._data.values())) {
-            this.setItemData({ ...update.transform(item), id: item.id });
+            this.setItemData({ ...transformData(item, updates), id: item.id });
             count++;
         }
         this._times.set(_getQueryKey(constraints), now);

package/{provider → modules/provider}/Provider.d.ts

@@ -1,6 +1,6 @@
 import type { Unsubscribe } from "../observe/Observable.js";
 import type { PartialObserver } from "../observe/Observer.js";
-import type { DataUpdate } from "../update/DataUpdate.js";
+import type { Updates } from "../update/DataUpdate.js";
 import type { Datas, Key } from "../util/data.js";
 import type { ItemArray, ItemConstraints, ItemValue } from "../db/Item.js";
 /** Provides access to data (e.g. IndexedDB, Firebase, or in-memory cache providers). */
@@ -43,7 +43,7 @@ declare abstract class AbstractProvider<T extends Datas = Datas> {
      * @param update Update instance to set the document to.
      * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): void | PromiseLike<void>;
+    abstract updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void | PromiseLike<void>;
     /**
      * Delete a specified document.
      */
@@ -75,7 +75,7 @@ declare abstract class AbstractProvider<T extends Datas = Datas> {
      * @param update Update instance to set the document to.
      * @return Number of documents that were updated.
      */
-    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): number | PromiseLike<number>;
+    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number | PromiseLike<number>;
     /**
      * Delete all matching documents.
      * @return Number of documents that were deleted.
@@ -88,12 +88,12 @@ export declare abstract class Provider<T extends Datas = Datas> extends Abstract
     abstract subscribeItem<K extends Key<T>>(collection: K, id: string, observer: PartialObserver<ItemValue<T[K]>>): Unsubscribe;
     abstract addItem<K extends Key<T>>(collection: K, data: T[K]): string;
     abstract setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    abstract updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): void;
+    abstract updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
     abstract deleteItem<K extends Key<T>>(collection: K, id: string): void;
     abstract getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
     abstract subscribeQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, observer: PartialObserver<ItemArray<T[K]>>): Unsubscribe;
     abstract setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): number;
+    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
     abstract deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
 }
 /** Provider with a fully asynchronous interface */
@@ -102,12 +102,12 @@ export declare abstract class AsyncProvider<T extends Datas = Datas> extends Abs
     abstract subscribeItem<K extends Key<T>>(collection: K, id: string, observer: PartialObserver<ItemValue<T[K]>>): Unsubscribe;
     abstract addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
     abstract setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    abstract updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): Promise<void>;
+    abstract updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
     abstract deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
     abstract getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
     abstract subscribeQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, observer: PartialObserver<ItemArray<T[K]>>): Unsubscribe;
     abstract setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): Promise<number>;
+    abstract updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
     abstract deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
 }
 export {};

package/{provider → modules/provider}/ThroughProvider.d.ts

@@ -1,7 +1,7 @@
 import type { Datas, Key } from "../util/data.js";
 import type { Sourceable } from "../util/source.js";
 import type { ItemArray, ItemConstraints, ItemValue } from "../db/Item.js";
-import type { DataUpdate } from "../update/DataUpdate.js";
+import type { Updates } from "../update/DataUpdate.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Unsubscribe } from "../observe/Observable.js";
 import type { Provider, AsyncProvider } from "./Provider.js";
@@ -13,12 +13,12 @@ export declare class ThroughProvider<T extends Datas = Datas> implements Provide
     subscribeItem<K extends Key<T>>(collection: K, id: string, observer: PartialObserver<ItemValue<T[K]>>): Unsubscribe;
     addItem<K extends Key<T>>(collection: K, data: T[K]): string;
     setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): void;
+    updateItem<K extends Key<T>>(collection: K, id: string, update: Updates<T[K]>): void;
     deleteItem<K extends Key<T>>(collection: K, id: string): void;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
     subscribeQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, observer: PartialObserver<ItemArray<T[K]>>): Unsubscribe;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): number;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: Updates<T[K]>): number;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): number;
 }
 /** A provider that passes through to an asynchronous source. */
@@ -29,11 +29,11 @@ export declare class AsyncThroughProvider<T extends Datas = Datas> implements As
     subscribeItem<K extends Key<T>>(collection: K, id: string, observer: PartialObserver<ItemValue<T[K]>>): Unsubscribe;
     addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
     setItem<K extends Key<T>>(collection: K, id: string, data: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): Promise<void>;
+    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
     deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
     subscribeQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, observer: PartialObserver<ItemArray<T[K]>>): Unsubscribe;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, data: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): Promise<number>;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
 }

package/{provider → modules/provider}/ThroughProvider.js

@@ -54,8 +54,8 @@ export class AsyncThroughProvider {
     setItem(collection, id, data) {
         return this.source.setItem(collection, id, data);
     }
-    updateItem(collection, id, update) {
-        return this.source.updateItem(collection, id, update);
+    updateItem(collection, id, updates) {
+        return this.source.updateItem(collection, id, updates);
     }
     deleteItem(collection, id) {
         return this.source.deleteItem(collection, id);
@@ -69,8 +69,8 @@ export class AsyncThroughProvider {
     setQuery(collection, constraints, data) {
         return this.source.setQuery(collection, constraints, data);
     }
-    updateQuery(collection, constraints, update) {
-        return this.source.updateQuery(collection, constraints, update);
+    updateQuery(collection, constraints, updates) {
+        return this.source.updateQuery(collection, constraints, updates);
     }
     deleteQuery(collection, constraints) {
         return this.source.deleteQuery(collection, constraints);

package/{provider → modules/provider}/ValidationProvider.d.ts

@@ -1,46 +1,46 @@
 import type { Key, Datas } from "../util/data.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../db/Item.js";
-import type { DataUpdate } from "../update/DataUpdate.js";
+import type { DataSchemas, DataSchema } from "../schema/DataSchema.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Unsubscribe } from "../observe/Observable.js";
-import { Validator, Validators } from "../util/validate.js";
+import { Updates } from "../update/DataUpdate.js";
 import { Sourceable } from "../util/source.js";
 import { Provider, AsyncProvider } from "./Provider.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;
-    readonly validators: Validators<T>;
-    constructor(validators: Validators<T>);
-    getValidator<K extends Key<T>>(collection: K): Validator<T[K]>;
+    readonly schemas: DataSchemas<T>;
+    constructor(schemas: DataSchemas<T>);
+    getSchema<K extends Key<T>>(collection: K): DataSchema<T[K]>;
     subscribeItem<K extends Key<T>>(collection: K, id: string, observer: PartialObserver<ItemValue<T[K]>>): Unsubscribe;
     subscribeQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, observer: PartialObserver<ItemArray<T[K]>>): Unsubscribe;
 }
 /** 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<T>, Sourceable<Provider> {
     readonly source: Provider;
-    constructor(source: Provider, validators: Validators<T>);
+    constructor(source: Provider, schemas: DataSchemas<T>);
     getItem<K extends Key<T>>(collection: K, id: string): ItemValue<T[K]>;
     addItem<K extends Key<T>>(collection: K, data: T[K]): string;
     setItem<K extends Key<T>>(collection: K, id: string, value: T[K]): void;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): void;
+    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): void;
     deleteItem<K extends Key<T>>(collection: K, id: string): void;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): ItemArray<T[K]>;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, value: T[K]): number;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): number;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): number;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<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<T>, Sourceable<AsyncProvider> {
     readonly source: AsyncProvider;
-    constructor(source: AsyncProvider, validators: Validators<T>);
+    constructor(source: AsyncProvider, schemas: DataSchemas<T>);
     getItem<K extends Key<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
     addItem<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
     setItem<K extends Key<T>>(collection: K, id: string, value: T[K]): Promise<void>;
-    updateItem<K extends Key<T>>(collection: K, id: string, update: DataUpdate<T[K]>): Promise<void>;
+    updateItem<K extends Key<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
     deleteItem<K extends Key<T>>(collection: K, id: string): Promise<void>;
     getQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<ItemArray<T[K]>>;
     setQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, value: T[K]): Promise<number>;
-    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, update: DataUpdate<T[K]>): Promise<number>;
+    updateQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>, updates: Updates<T[K]>): Promise<number>;
     deleteQuery<K extends Key<T>>(collection: K, constraints: ItemConstraints<T[K]>): Promise<number>;
 }
 export {};

package/{provider → modules/provider}/ValidationProvider.js

@@ -1,3 +1,4 @@
+import { validateUpdates } from "../update/DataUpdate.js";
 import { validate } from "../util/validate.js";
 import { Feedback } from "../feedback/Feedback.js";
 import { ValidationError } from "../error/ValidationError.js";
@@ -5,48 +6,48 @@ import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { TransformableObserver } from "../observe/TransformableObserver.js";
 /** Validate a source provider (source can have any type because validation guarantees the type). */
 class BaseValidationProvider {
-    constructor(validators) {
-        this.validators = validators;
+    constructor(schemas) {
+        this.schemas = schemas;
     }
-    getValidator(collection) {
-        return this.validators[collection];
+    getSchema(collection) {
+        return this.schemas[collection];
     }
     subscribeItem(collection, id, observer) {
-        return this.source.subscribeItem(collection, id, new _ValidateEntityObserver(collection, this.getValidator(collection), observer));
+        return this.source.subscribeItem(collection, id, new _ValidateEntityObserver(collection, this.getSchema(collection), observer));
     }
     subscribeQuery(collection, constraints, observer) {
-        return this.source.subscribeQuery(collection, constraints, new _ValidateEntitiesObserver(collection, this.getValidator(collection), observer));
+        return this.source.subscribeQuery(collection, constraints, new _ValidateEntitiesObserver(collection, this.getSchema(collection), observer));
     }
 }
 /** Validate a synchronous source provider (source can have any type because validation guarantees the type). */
 export class ValidationProvider extends BaseValidationProvider {
-    constructor(source, validators) {
-        super(validators);
+    constructor(source, schemas) {
+        super(schemas);
         this.source = source;
     }
     getItem(collection, id) {
-        return _validateEntity(collection, this.source.getItem(collection, id), this.getValidator(collection));
+        return _validateEntity(collection, this.source.getItem(collection, id), this.getSchema(collection));
     }
     addItem(collection, data) {
-        return this.source.addItem(collection, validate(data, this.getValidator(collection)));
+        return this.source.addItem(collection, validate(data, this.getSchema(collection)));
     }
     setItem(collection, id, value) {
-        return this.source.setItem(collection, id, validate(value, this.getValidator(collection)));
+        return this.source.setItem(collection, id, validate(value, this.getSchema(collection)));
     }
-    updateItem(collection, id, update) {
-        return this.source.updateItem(collection, id, update.validate(this.getValidator(collection)));
+    updateItem(collection, id, updates) {
+        return this.source.updateItem(collection, id, validateUpdates(updates, this.getSchema(collection).props));
     }
     deleteItem(collection, id) {
         return this.source.deleteItem(collection, id);
     }
     getQuery(collection, constraints) {
-        return _validateEntities(collection, this.source.getQuery(collection, constraints), this.getValidator(collection));
+        return _validateEntities(collection, this.source.getQuery(collection, constraints), this.getSchema(collection));
     }
     setQuery(collection, constraints, value) {
-        return this.source.setQuery(collection, constraints, validate(value, this.getValidator(collection)));
+        return this.source.setQuery(collection, constraints, validate(value, this.getSchema(collection)));
     }
-    updateQuery(collection, constraints, update) {
-        return this.source.updateQuery(collection, constraints, update.validate(this.getValidator(collection)));
+    updateQuery(collection, constraints, updates) {
+        return this.source.updateQuery(collection, constraints, validateUpdates(updates, this.getSchema(collection).props));
     }
     deleteQuery(collection, constraints) {
         return this.source.deleteQuery(collection, constraints);
@@ -54,33 +55,33 @@ export class ValidationProvider extends BaseValidationProvider {
 }
 /** Validate an asynchronous source provider (source can have any type because validation guarantees the type). */
 export class AsyncValidationProvider extends BaseValidationProvider {
-    constructor(source, validators) {
-        super(validators);
+    constructor(source, schemas) {
+        super(schemas);
         this.source = source;
     }
     async getItem(collection, id) {
-        return _validateEntity(collection, await this.source.getItem(collection, id), this.getValidator(collection));
+        return _validateEntity(collection, await this.source.getItem(collection, id), this.getSchema(collection));
     }
     addItem(collection, data) {
-        return this.source.addItem(collection, validate(data, this.getValidator(collection)));
+        return this.source.addItem(collection, validate(data, this.getSchema(collection)));
     }
     setItem(collection, id, value) {
-        return this.source.setItem(collection, id, validate(value, this.getValidator(collection)));
+        return this.source.setItem(collection, id, validate(value, this.getSchema(collection)));
     }
-    updateItem(collection, id, update) {
-        return this.source.updateItem(collection, id, update.validate(this.getValidator(collection)));
+    updateItem(collection, id, updates) {
+        return this.source.updateItem(collection, id, validateUpdates(updates, this.getSchema(collection).props));
     }
     deleteItem(collection, id) {
         return this.source.deleteItem(collection, id);
     }
     async getQuery(collection, constraints) {
-        return _validateEntities(collection, await this.source.getQuery(collection, constraints), this.getValidator(collection));
+        return _validateEntities(collection, await this.source.getQuery(collection, constraints), this.getSchema(collection));
     }
     setQuery(collection, constraints, value) {
-        return this.source.setQuery(collection, constraints, validate(value, this.getValidator(collection)));
+        return this.source.setQuery(collection, constraints, validate(value, this.getSchema(collection)));
     }
-    updateQuery(collection, constraints, update) {
-        return this.source.updateQuery(collection, constraints, update.validate(this.getValidator(collection)));
+    updateQuery(collection, constraints, updates) {
+        return this.source.updateQuery(collection, constraints, validateUpdates(updates, this.getSchema(collection).props));
     }
     deleteQuery(collection, constraints) {
         return this.source.deleteQuery(collection, constraints);