shelving 1.77.0 → 1.78.0

package/constraint/FilterConstraint.d.ts

@@ -11,7 +11,7 @@ export declare type FilterKey<T extends Data> = Key<T> | `${Key<T>}` | `!${Key<T
 export declare type FilterProps<T extends Data> = {
     [K in Key<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
-    [K in Key<T> as `${K}[]`]?: Required<T>[K] extends ReadonlyArray<infer X> ? X : never;
+    [K in Key<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
 } & {
     [K in Key<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 };

package/db/Change.d.ts

@@ -1,38 +1,35 @@
 import type { Data, Datas, Key } from "../util/data.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
-import { DataUpdate } from "../update/DataUpdate.js";
+import { Updates } from "../update/DataUpdate.js";
 import { Nullish } from "../util/null.js";
 import { DeepIterable } from "../util/iterate.js";
 import type { ItemConstraints, ItemData } from "./Item.js";
-export interface Change<T extends Datas> {
+/** Change on a collection. */
+export interface Change<T extends Datas, K extends Key<T> = Key<T>> {
     readonly action: string;
-    readonly collection: Key<T>;
+    readonly collection: K;
 }
 /** Add on an item. */
-export interface AddChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T> {
+export interface AddChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
     readonly action: "ADD";
-    readonly collection: K;
     readonly data: T[K];
 }
 /** Set on an item. */
-export interface SetChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T> {
+export interface SetChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
     readonly action: "SET";
-    readonly collection: K;
     readonly id: string;
     readonly data: T[K];
 }
 /** Update change on an item. */
-export interface UpdateChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T> {
+export interface UpdateChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
     readonly action: "UPDATE";
-    readonly collection: K;
     readonly id: string;
-    readonly update: DataUpdate<T[K]>;
+    readonly updates: Updates<T[K]>;
 }
 /** Delete change on an item. */
-export interface DeleteChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T> {
+export interface DeleteChange<T extends Datas, K extends Key<T> = Key<T>> extends Change<T, K> {
     readonly action: "DELETE";
-    readonly collection: K;
     readonly id: string;
 }
 /** Set, update, or delete change on an item. */

package/db/Change.js

@@ -13,7 +13,7 @@ function _changeItem(change) {
     else if (action === "SET")
         this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        this.updateQuery(collection, _getItemConstraint(change.id), change.update);
+        this.updateQuery(collection, _getItemConstraint(change.id), change.updates);
     else if (action === "DELETE")
         this.deleteItem(collection, change.id);
     return change;
@@ -29,7 +29,7 @@ async function _changeAsyncItem(change) {
     else if (action === "SET")
         await this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        await this.updateQuery(collection, _getItemConstraint(change.id), change.update);
+        await this.updateQuery(collection, _getItemConstraint(change.id), change.updates);
     else if (action === "DELETE")
         await this.deleteItem(collection, change.id);
     return change;

package/db/Database.d.ts

@@ -19,7 +19,7 @@ declare abstract class BaseDatabase<T extends Datas> {
     /** Reference an item in a collection in this database. */
     abstract item<K extends Key<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
     /** Run a set of changes on this database. */
-    abstract change<K extends Key<T>>(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K> | Promise<ItemChanges<T, K>>;
+    abstract change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T> | Promise<ItemChanges<T>>;
 }
 /** Database with a synchronous provider. */
 export declare class Database<T extends Datas = Datas> implements BaseDatabase<T> {
@@ -28,7 +28,7 @@ export declare class Database<T extends Datas = Datas> implements BaseDatabase<T
     collection<K extends Key<T>>(collection: K): Collection<T, K>;
     query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
     item<K extends Key<T>>(collection: K, id: string): Item<T, K>;
-    change<K extends Key<T>>(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
+    change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T>;
 }
 /** Database with a synchronous provider. */
 export declare class AsyncDatabase<T extends Datas = Datas> implements BaseDatabase<T> {
@@ -37,6 +37,6 @@ export declare class AsyncDatabase<T extends Datas = Datas> implements BaseDatab
     collection<K extends Key<T>>(collection: K): AsyncCollection<T, K>;
     query<K extends Key<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
     item<K extends Key<T>>(collection: K, id: string): AsyncItem<T, K>;
-    change<K extends Key<T>>(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
+    change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): Promise<ItemChanges<T>>;
 }
 export {};

package/db/Item.d.ts

@@ -3,7 +3,7 @@ import type { Dispatch } from "../util/function.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Observable, Unsubscribe } from "../observe/Observable.js";
-import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
+import { DataUpdate, Updates } from "../update/DataUpdate.js";
 import type { QueryConstraints } from "../constraint/QueryConstraints.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 import type { AsyncQuery, Query } from "./Query.js";
@@ -54,13 +54,13 @@ declare abstract class BaseItem<T extends Datas = Datas, K extends Key<T> = Key<
     /** Set the complete data of this item. */
     abstract set(data: T[K]): void | PromiseLike<void>;
     /** Update this item. */
-    abstract update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void | PromiseLike<void>;
+    abstract update(updates: DataUpdate<T[K]> | Updates<T[K]>): void | PromiseLike<void>;
     /** Delete this item. */
     abstract delete(): void | PromiseLike<void>;
     /** Get a set change for this item. */
     getSet(data: T[K]): SetChange<T, K>;
     /** Get an update change for this item. */
-    getUpdate(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): UpdateChange<T, K>;
+    getUpdate(updates: Updates<T[K]>): UpdateChange<T, K>;
     /** Get a delete change for this item. */
     getDelete(): DeleteChange<T, K>;
     toString(): `${K}/${string}`;
@@ -76,7 +76,7 @@ export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> ex
     get value(): ItemValue<T[K]>;
     get data(): ItemData<T[K]>;
     set(data: T[K]): void;
-    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void;
+    update(updates: Updates<T[K]>): void;
     delete(): void;
 }
 /** Reference to an item in an asynchronous provider. */
@@ -90,7 +90,7 @@ export declare class AsyncItem<T extends Datas = Datas, K extends Key<T> = Key<T
     get value(): Promise<ItemValue<T[K]>>;
     get data(): Promise<ItemData<T[K]>>;
     set(data: T[K]): Promise<void>;
-    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): Promise<void>;
+    update(updates: Updates<T[K]>): Promise<void>;
     delete(): Promise<void>;
 }
 /** Get the ID from item data. */

package/db/Item.js

@@ -1,7 +1,5 @@
 import { getData } from "../util/data.js";
 import { FilterConstraint } from "../constraint/FilterConstraint.js";
-import { DataUpdate } from "../update/DataUpdate.js";
-import { isTransformable } from "../util/transform.js";
 /** Reference to an item in a synchronous or asynchronous provider. */
 class BaseItem {
     /**
@@ -20,7 +18,7 @@ class BaseItem {
     }
     /** Get an update change for this item. */
     getUpdate(updates) {
-        return { action: "UPDATE", collection: this.collection, id: this.id, update: updates instanceof DataUpdate ? updates : new DataUpdate(updates) };
+        return { action: "UPDATE", collection: this.collection, id: this.id, updates };
     }
     /** Get a delete change for this item. */
     getDelete() {
@@ -55,7 +53,7 @@ export class Item extends BaseItem {
         return this.db.provider.setItem(this.collection, this.id, data);
     }
     update(updates) {
-        return this.db.provider.updateItem(this.collection, this.id, isTransformable(updates) ? updates : new DataUpdate(updates));
+        return this.db.provider.updateItem(this.collection, this.id, updates);
     }
     delete() {
         return this.db.provider.deleteItem(this.collection, this.id);
@@ -85,7 +83,7 @@ export class AsyncItem extends BaseItem {
         return this.db.provider.setItem(this.collection, this.id, data);
     }
     update(updates) {
-        return this.db.provider.updateItem(this.collection, this.id, isTransformable(updates) ? updates : new DataUpdate(updates));
+        return this.db.provider.updateItem(this.collection, this.id, updates);
     }
     delete() {
         return this.db.provider.deleteItem(this.collection, this.id);

package/db/Query.d.ts

@@ -1,11 +1,11 @@
 import type { Dispatch } from "../util/function.js";
 import type { Key, Datas } from "../util/data.js";
+import type { Updates } from "../update/DataUpdate.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Observable, Unsubscribe } from "../observe/Observable.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
 import type { ItemArray, ItemValue, ItemData } from "./Item.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 /** Reference to a set of items in a sync or async provider. */
@@ -68,7 +68,7 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends Key<T> = Key
      * @param updates `Update` instance or set of updates to apply to every matching item.
      * @return Nothing (possibly promised).
      */
-    abstract update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): number | PromiseLike<number>;
+    abstract update(updates: Updates<T[K]>): number | PromiseLike<number>;
     /**
      * Delete all matching items.
      * @return Nothing (possibly promised).
@@ -89,7 +89,7 @@ export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> e
     get lastValue(): ItemValue<T[K]>;
     get lastData(): ItemData<T[K]>;
     set(data: T[K]): number;
-    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): number;
+    update(updates: Updates<T[K]>): number;
     delete(): number;
 }
 /** Reference to a set of items in a provider. */
@@ -105,7 +105,7 @@ export declare class AsyncQuery<T extends Datas = Datas, K extends Key<T> = Key<
     get lastValue(): Promise<ItemValue<T[K]>>;
     get lastData(): Promise<ItemData<T[K]>>;
     set(data: T[K]): Promise<number>;
-    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): PromiseLike<number>;
+    update(updates: Updates<T[K]>): PromiseLike<number>;
     delete(): PromiseLike<number>;
 }
 export {};

package/db/Query.js

@@ -1,7 +1,6 @@
 import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { countItems, hasItems } from "../util/iterate.js";
-import { DataUpdate } from "../update/DataUpdate.js";
 /** Reference to a set of items in a sync or async provider. */
 class BaseQuery extends QueryConstraints {
     /**
@@ -51,7 +50,7 @@ export class Query extends BaseQuery {
         return this.db.provider.setQuery(this.collection, this, data);
     }
     update(updates) {
-        return this.db.provider.updateQuery(this.collection, this, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+        return this.db.provider.updateQuery(this.collection, this, updates);
     }
     delete() {
         return this.db.provider.deleteQuery(this.collection, this);
@@ -89,7 +88,7 @@ export class AsyncQuery extends BaseQuery {
         return this.db.provider.setQuery(this.collection, this, data);
     }
     update(updates) {
-        return this.db.provider.updateQuery(this.collection, this, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+        return this.db.provider.updateQuery(this.collection, this, updates);
     }
     delete() {
         return this.db.provider.deleteQuery(this.collection, this);

package/firestore/client/FirestoreClientProvider.d.ts

@@ -4,7 +4,7 @@ import type { Unsubscribe } from "../../observe/Observable.js";
 import type { AsyncProvider } from "../../provider/Provider.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../../db/Item.js";
 import { Observer, PartialObserver } from "../../observe/Observer.js";
-import { DataUpdate } from "../../update/DataUpdate.js";
+import { Updates } from "../../update/DataUpdate.js";
 /**
  * Firestore client database provider.
  * - Works with the Firebase JS SDK.
@@ -18,11 +18,11 @@ export declare class FirestoreClientProvider implements AsyncProvider {
     subscribeItem(collection: string, id: string, observer: PartialObserver<ItemValue>): Unsubscribe;
     addItem(collection: string, data: Data): Promise<string>;
     setItem(collection: string, id: string, data: Data): Promise<void>;
-    updateItem(collection: string, id: string, update: DataUpdate): Promise<void>;
+    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
     deleteItem(collection: string, id: string): Promise<void>;
     getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
     subscribeQuery(collection: string, constraints: ItemConstraints, observer: Observer<ItemArray>): Unsubscribe;
     setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
-    updateQuery(collection: string, constraints: ItemConstraints, update: DataUpdate): Promise<number>;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
     deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;
 }

package/firestore/client/FirestoreClientProvider.js

@@ -101,8 +101,8 @@ export class FirestoreClientProvider {
     async setItem(collection, id, data) {
         await setDoc(firestoreDocument(this._firestore, collection, id), data);
     }
-    async updateItem(collection, id, update) {
-        await updateDoc(firestoreDocument(this._firestore, collection, id), ..._getFieldValues(update));
+    async updateItem(collection, id, updates) {
+        await updateDoc(firestoreDocument(this._firestore, collection, id), ..._getFieldValues(Object.entries(updates)));
     }
     async deleteItem(collection, id) {
         await deleteDoc(firestoreDocument(this._firestore, collection, id));
@@ -118,9 +118,9 @@ export class FirestoreClientProvider {
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
         return snapshot.size;
     }
-    async updateQuery(collection, constraints, update) {
+    async updateQuery(collection, constraints, updates) {
         const snapshot = await getDocs(_getQuery(this._firestore, collection, constraints));
-        const fieldValues = Array.from(_getFieldValues(update));
+        const fieldValues = Array.from(_getFieldValues(Object.entries(updates)));
         await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, ...fieldValues)));
         return snapshot.size;
     }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -3,7 +3,7 @@ import type { Data } from "../../util/data.js";
 import type { Unsubscribe } from "../../observe/Observable.js";
 import type { AsyncProvider } from "../../provider/Provider.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../../db/Item.js";
-import { DataUpdate } from "../../update/DataUpdate.js";
+import { Updates } from "../../update/DataUpdate.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -17,11 +17,11 @@ export declare class FirestoreLiteProvider implements AsyncProvider {
     subscribeItem(): Unsubscribe;
     addItem(collection: string, data: Data): Promise<string>;
     setItem(collection: string, id: string, data: Data): Promise<void>;
-    updateItem(collection: string, id: string, update: DataUpdate): Promise<void>;
+    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
     deleteItem(collection: string, id: string): Promise<void>;
     getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
     subscribeQuery(): Unsubscribe;
     setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
-    updateQuery(collection: string, constraints: ItemConstraints, update: DataUpdate): Promise<number>;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
     deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;
 }

package/firestore/lite/FirestoreLiteProvider.js

@@ -101,8 +101,8 @@ export class FirestoreLiteProvider {
     async setItem(collection, id, data) {
         await setDoc(firestoreDocument(this._firestore, collection, id), data);
     }
-    async updateItem(collection, id, update) {
-        await updateDoc(firestoreDocument(this._firestore, collection, id), ..._getFieldValues(update));
+    async updateItem(collection, id, updates) {
+        await updateDoc(firestoreDocument(this._firestore, collection, id), ..._getFieldValues(Object.entries(updates)));
     }
     async deleteItem(collection, id) {
         await deleteDoc(firestoreDocument(this._firestore, collection, id));
@@ -118,9 +118,9 @@ export class FirestoreLiteProvider {
         await Promise.all(snapshot.docs.map(s => setDoc(s.ref, data)));
         return snapshot.size;
     }
-    async updateQuery(collection, constraints, update) {
+    async updateQuery(collection, constraints, updates) {
         const snapshot = await getDocs(_getQuery(this._firestore, collection, constraints));
-        const fieldValues = Array.from(_getFieldValues(update));
+        const fieldValues = Array.from(_getFieldValues(Object.entries(updates)));
         await Promise.all(snapshot.docs.map(s => updateDoc(s.ref, ...fieldValues)));
         return snapshot.size;
     }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -3,7 +3,7 @@ import type { Unsubscribe } from "../../observe/Observable.js";
 import type { AsyncProvider } from "../../provider/Provider.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../../db/Item.js";
 import { Observer } from "../../observe/Observer.js";
-import { DataUpdate } from "../../update/DataUpdate.js";
+import { Updates } from "../../update/DataUpdate.js";
 import { Data } from "../../util/data.js";
 /**
  * Firestore server database provider.
@@ -16,11 +16,11 @@ export declare class FirestoreServerProvider implements AsyncProvider {
     subscribeItem(collection: string, id: string, observer: Observer<ItemValue>): Unsubscribe;
     addItem(collection: string, data: Data): Promise<string>;
     setItem(collection: string, id: string, data: Data): Promise<void>;
-    updateItem(collection: string, id: string, update: DataUpdate): Promise<void>;
+    updateItem(collection: string, id: string, updates: Updates): Promise<void>;
     deleteItem(collection: string, id: string): Promise<void>;
     getQuery(collection: string, constraints: ItemConstraints): Promise<ItemArray>;
     subscribeQuery(collection: string, constraints: ItemConstraints, observer: Observer<ItemArray>): Unsubscribe;
     setQuery(collection: string, constraints: ItemConstraints, data: Data): Promise<number>;
-    updateQuery(collection: string, constraints: ItemConstraints, update: DataUpdate): Promise<number>;
+    updateQuery(collection: string, constraints: ItemConstraints, updates: Updates): Promise<number>;
     deleteQuery(collection: string, constraints: ItemConstraints): Promise<number>;
 }

package/firestore/server/FirestoreServerProvider.js

@@ -101,11 +101,11 @@ export class FirestoreServerProvider {
     async setItem(collection, id, data) {
         await this._firestore.collection(collection).doc(id).set(data);
     }
-    async updateItem(collection, id, update) {
+    async updateItem(collection, id, updates) {
         await this._firestore
             .collection(collection)
             .doc(id)
-            .update(..._getFieldValues(update));
+            .update(..._getFieldValues(Object.entries(updates)));
     }
     async deleteItem(collection, id) {
         await this._firestore.collection(collection).doc(id).delete();
@@ -119,8 +119,8 @@ export class FirestoreServerProvider {
     async setQuery(collection, constraints, data) {
         return await bulkWrite(this._firestore, collection, constraints, (w, s) => void w.set(s.ref, data));
     }
-    async updateQuery(collection, constraints, update) {
-        const fieldValues = _getFieldValues(update);
+    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 deleteQuery(collection, constraints) {

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.77.0",
+	"version": "1.78.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -63,12 +63,12 @@
 	"devDependencies": {
 		"@google-cloud/firestore": "^5.0.2",
 		"@types/jest": "^28.1.6",
-		"@types/react": "^18.0.9",
+		"@types/react": "^18.0.17",
 		"@types/react-dom": "^18.0.4",
-		"@typescript-eslint/eslint-plugin": "^5.32.0",
-		"@typescript-eslint/parser": "^5.32.0",
+		"@typescript-eslint/eslint-plugin": "^5.33.0",
+		"@typescript-eslint/parser": "^5.33.0",
 		"dpdm": "^3.9.0",
-		"eslint": "^8.21.0",
+		"eslint": "^8.22.0",
 		"eslint-config-prettier": "^8.5.0",
 		"eslint-plugin-import": "^2.26.0",
 		"eslint-plugin-prettier": "^4.0.0",

package/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/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/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/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/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/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/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/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/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/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/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);

package/schema/DataSchema.d.ts

@@ -1,4 +1,4 @@
-import type { Data } from "../util/data.js";
+import type { Data, Datas } from "../util/data.js";
 import { Validators } from "../util/validate.js";
 import { OptionalSchema } from "./OptionalSchema.js";
 import { Schema } from "./Schema.js";
@@ -12,6 +12,10 @@ export declare class DataSchema<T extends Data> extends Schema<T> {
     });
     validate(unsafeValue?: unknown): T;
 }
+/** Set of named data schemas. */
+export declare type DataSchemas<T extends Datas> = {
+    [K in keyof T]: DataSchema<T[K]>;
+};
 /** Valid data object with specifed properties. */
 export declare const DATA: <T extends Data>(props: Validators<T>) => DataSchema<T>;
 /** Valid data object with specifed properties, or `null` */

package/state/DataState.d.ts

@@ -1,5 +1,5 @@
 import { Data, Key, OptionalData } from "../util/data.js";
-import { PropTransformers } from "../util/transform.js";
+import { Transformers } from "../util/transform.js";
 import { State } from "./State.js";
 /** State that stores a data object and has additional methods to help with that. */
 export declare class DataState<T extends Data> extends State<T> {
@@ -8,7 +8,7 @@ export declare class DataState<T extends Data> extends State<T> {
     /** Set a prop in this object to a new value. */
     set<K extends Key<T>>(key: K, value: T[K]): void;
     /** Update several props in this object. */
-    update(updates: PropTransformers<T>): void;
+    update(updates: Transformers<T>): void;
 }
 /** State that stores an optional data object and has additional methods to help with that. */
 export declare class OptionalDataState<T extends Data> extends State<OptionalData<T>> {
@@ -19,7 +19,7 @@ export declare class OptionalDataState<T extends Data> extends State<OptionalDat
     /** Set a prop in this object to a new value. */
     set<K extends Key<T>>(key: K, value: T[K]): void;
     /** Update several props in this object. */
-    update(updates: PropTransformers<T>): void;
+    update(updates: Transformers<T>): void;
     /** Delete this result. */
     delete(): void;
 }

package/update/DataUpdate.d.ts

@@ -1,7 +1,7 @@
 import { Data, Key, Prop } from "../util/data.js";
 import { Nullish } from "../util/null.js";
 import { Transformable } from "../util/transform.js";
-import { Validator } from "../util/validate.js";
+import { Validator, Validators } from "../util/validate.js";
 import { Update } from "./Update.js";
 /**
  * Set of named transforms for the props of a data object.
@@ -10,19 +10,27 @@ import { Update } from "./Update.js";
  * - If a prop contains a transform, the existing value is transformed.
  * - This is a subset of `Dispatchers`
  */
-export declare type PropUpdates<T extends Data> = {
+export declare type Updates<T extends Data = Data> = {
     readonly [K in keyof T]?: T[K] | Update<T[K]>;
 };
-/** Update that can be applied to a data object to update its props. */
-export declare class DataUpdate<T extends Data = Data> extends Update<T> implements Iterable<Prop<PropUpdates<T>>>, Transformable<T, T> {
+/**
+ * Validate a set of updates against a set of validators.
+ */
+export declare function validateUpdates<T extends Data>(unsafeUpdates: Updates<T>, validators: Validators<T>): {
+    [k: string]: import("../util/data.js").Value<Updates<T>>;
+};
+/**
+ * Update that can be applied to a data object to update its props.
+ */
+export declare class DataUpdate<T extends Data = Data> extends Update<T> implements Iterable<Prop<Updates<T>>>, Transformable<T, T> {
     /** Return a data update with a specific prop marked for update. */
     static with<X extends Data, K extends Key<X>>(key: Nullish<K>, value: X[K] | Update<X[K]>): DataUpdate<X>;
-    readonly updates: PropUpdates<T>;
-    constructor(props: PropUpdates<T>);
+    readonly updates: Updates<T>;
+    constructor(props: Updates<T>);
     transform(data: T): T;
     validate(validator: Validator<T>): this;
     /** Return a data update with a specific prop marked for update. */
     with<K extends Key<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
     /** Iterate over the transforms in this object. */
-    [Symbol.iterator](): Iterator<Prop<PropUpdates<T>>, void>;
+    [Symbol.iterator](): Iterator<Prop<Updates<T>>, void>;
 }

package/update/DataUpdate.js

@@ -6,7 +6,33 @@ import { isNullish } from "../util/null.js";
 import { transformData } from "../util/transform.js";
 import { validate } from "../util/validate.js";
 import { Update } from "./Update.js";
-/** Update that can be applied to a data object to update its props. */
+/**
+ * Validate a set of updates against a set of validators.
+ */
+export function validateUpdates(unsafeUpdates, validators) {
+    return Object.fromEntries(_validateUpdates(unsafeUpdates, validators));
+}
+function* _validateUpdates(unsafeUpdates, validators) {
+    const feedbacks = new Map();
+    for (const [key, validator] of getProps(validators)) {
+        const unsafeUpdate = unsafeUpdates[key];
+        if (unsafeUpdate !== undefined) {
+            try {
+                yield [key, unsafeUpdate instanceof Update ? unsafeUpdate.validate(validator) : validate(unsafeUpdate, validator)];
+            }
+            catch (thrown) {
+                if (!isFeedback(thrown))
+                    throw thrown;
+                feedbacks.set(key, thrown);
+            }
+        }
+    }
+    if (feedbacks.size)
+        throw new InvalidFeedback("Invalid updates", feedbacks);
+}
+/**
+ * Update that can be applied to a data object to update its props.
+ */
 export class DataUpdate extends Update {
     constructor(props) {
         super();
@@ -25,7 +51,7 @@ export class DataUpdate extends Update {
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
-            updates: Object.fromEntries(_validateUpdates(this.updates, validator.props)),
+            updates: validateUpdates(this.updates, validator.props),
         };
     }
     /** Return a data update with a specific prop marked for update. */
@@ -43,22 +69,3 @@ export class DataUpdate extends Update {
         return Object.entries(this.updates).values();
     }
 }
-/** Validate a set of transforms against a set of validators. */
-function* _validateUpdates(unsafeUpdates, validators) {
-    const feedbacks = new Map();
-    for (const [key, validator] of getProps(validators)) {
-        const unsafeUpdate = unsafeUpdates[key];
-        if (unsafeUpdate !== undefined) {
-            try {
-                yield [key, unsafeUpdate instanceof Update ? unsafeUpdate.validate(validator) : validate(unsafeUpdate, validator)];
-            }
-            catch (thrown) {
-                if (!isFeedback(thrown))
-                    throw thrown;
-                feedbacks.set(key, thrown);
-            }
-        }
-    }
-    if (feedbacks.size)
-        throw new InvalidFeedback("Invalid updates", feedbacks);
-}

package/util/transform.d.ts

@@ -16,19 +16,19 @@ export declare type Transformer<I, O> = Transformable<I, O> | Transform<I, O> |
 export declare function transform<I, O>(input: I, transformer: (v: I) => O): O;
 export declare function transform<I, O>(input: I, transformer: Transformer<I, O>): O;
 /** Set of named transformers for a data object. */
-export declare type PropTransformers<T extends Data> = {
+export declare type Transformers<T extends Data> = {
     readonly [K in keyof T]?: Transformer<T[K], T[K]>;
 };
 /**
  * Transform the props of a data object using a set of transformers for its props.
  * @returns New object with changed props (or the same object if no changes were made).
  */
-export declare function transformData<T extends Data>(data: T, transforms: PropTransformers<T>): T;
+export declare function transformData<T extends Data>(data: T, transforms: Transformers<T>): T;
 /**
  * Transform the props of a data object using a set of prop transformers.
  * @yield Transformed prop entry after calling the corresponding prop transformer.
  */
-export declare function transformProps<T extends Data>(data: T, transforms: PropTransformers<T>): Iterable<Prop<T>>;
+export declare function transformProps<T extends Data>(data: T, transforms: Transformers<T>): Iterable<Prop<T>>;
 /**
  * Transform the _values_ of an iterable set of entries using a transformer.
  * @yield Transformed entry after calling transforming the new value for each entry.