shelving 1.76.1 → 1.78.0

package/constraint/Constraints.d.ts

@@ -2,7 +2,7 @@ import type { Data } from "../util/data.js";
 import { ImmutableArray } from "../util/array.js";
 import { Constraint } from "./Constraint.js";
 /** Type of Rule that is powered by several sub-constraints (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
-export declare abstract class Constraints<T extends Data, C extends Constraint<T>> extends Constraint<T> implements Iterable<C> {
+export declare abstract class Constraints<T extends Data, C extends Constraint<Partial<T>>> extends Constraint<T> implements Iterable<C> {
     protected readonly _constraints: ImmutableArray<C>;
     /** Get the first constraint. */
     get first(): C | undefined;

package/constraint/FilterConstraint.d.ts

@@ -1,8 +1,8 @@
-import { ArrayType, ImmutableArray } from "../util/array.js";
-import { Data, Key } from "../util/data.js";
+import type { Data, Key } from "../util/data.js";
+import type { Nullish } from "../util/null.js";
+import { ImmutableArray } from "../util/array.js";
 import { Matchable } from "../util/match.js";
-import { NotString } from "../util/string.js";
-import { Constraint } from "./Constraint.js";
+import type { Constraint } from "./Constraint.js";
 /** Possible operator references. */
 export declare type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
 /** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
@@ -11,12 +11,12 @@ 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}[]`]?: T[K] extends ImmutableArray ? ArrayType<T[K]> : 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];
 };
 /** List of filters in a flexible format. */
-export declare type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> | Iterable<FilterList<T> & NotString>;
+export declare type FilterList<T extends Data> = Nullish<FilterProps<T> | FilterConstraint<T>> | Iterable<FilterList<T>>;
 /**
  * Filter: filters a list of data.
  *

package/constraint/FilterConstraint.js

@@ -89,7 +89,7 @@ export function* getFilters(filters) {
         for (const filter of filters)
             yield* getFilters(filter);
     }
-    else {
+    else if (filters) {
         for (const [key, value] of Object.entries(filters))
             yield new FilterConstraint(key, value);
     }

package/constraint/FilterConstraints.d.ts

@@ -1,6 +1,6 @@
 import type { Data } from "../util/data.js";
 import type { Matchable } from "../util/match.js";
-import { FilterList, FilterProps, FilterConstraint } from "./FilterConstraint.js";
+import { FilterList, FilterConstraint } from "./FilterConstraint.js";
 import { Constraints } from "./Constraints.js";
 /**
  * Interface to make sure an object implements all matchers.
@@ -8,14 +8,14 @@ import { Constraints } from "./Constraints.js";
  */
 export interface Filterable<T extends Data> extends Matchable<T, void> {
     /** Add a filter to this filterable. */
-    filter(props: FilterProps<T>): this;
+    filter(...filters: FilterList<Partial<T>>[]): this;
     /** Match an item against the filters specified for this object. */
     match(item: T): boolean;
 }
 /** A set of filters. */
-export declare class FilterConstraints<T extends Data = Data> extends Constraints<T, FilterConstraint<T>> implements Filterable<T> {
-    constructor(...filters: FilterList<T>[]);
-    filter(...filters: FilterList<T>[]): this;
+export declare class FilterConstraints<T extends Data = Data> extends Constraints<T, FilterConstraint<Partial<T>>> implements Filterable<T> {
+    constructor(...filters: FilterList<Partial<T>>[]);
+    filter(...filters: FilterList<Partial<T>>[]): this;
     match(item: T): boolean;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;

package/constraint/QueryConstraints.d.ts

@@ -3,7 +3,7 @@ import { Filterable, FilterConstraints } from "./FilterConstraints.js";
 import { Sortable, SortConstraints } from "./SortConstraints.js";
 import { Constraint } from "./Constraint.js";
 import { FilterList } from "./FilterConstraint.js";
-import { SortKeys, SortList } from "./SortConstraint.js";
+import { SortList } from "./SortConstraint.js";
 /** Interface that combines Filterable, Sortable, Sliceable. */
 export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     /**
@@ -31,11 +31,11 @@ export declare class QueryConstraints<T extends Data = Data> extends Constraint<
     readonly filters: FilterConstraints<T>;
     readonly sorts: SortConstraints<T>;
     readonly limit: number | null;
-    constructor(filters?: FilterList<T>, sorts?: SortList<T>, limit?: number | null);
-    filter(...filters: FilterList<T>[]): this;
+    constructor(filters?: FilterList<Partial<T>>, sorts?: SortList<Partial<T>>, limit?: number | null);
+    filter(...filters: FilterList<Partial<T>>[]): this;
     get unfilter(): this;
     match(item: T): boolean;
-    sort(...keys: SortKeys<T>[]): this;
+    sort(...sorts: SortList<Partial<T>>[]): this;
     get unsort(): this;
     rank(left: T, right: T): number;
     after(item: T): this;

package/constraint/QueryConstraints.js

@@ -37,11 +37,11 @@ export class QueryConstraints extends Constraint {
         return this.filters.match(item);
     }
     // Implement `Sortable`
-    sort(...keys) {
+    sort(...sorts) {
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
-            sorts: this.sorts.sort(...keys),
+            sorts: this.sorts.sort(...sorts),
         };
     }
     get unsort() {

package/constraint/SortConstraint.d.ts

@@ -1,7 +1,8 @@
 import type { ImmutableArray } from "../util/array.js";
-import { Data, Key } from "../util/data.js";
+import type { Data, Key } from "../util/data.js";
+import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.js";
-import { Constraint } from "./Constraint.js";
+import type { Constraint } from "./Constraint.js";
 /** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
 export declare type SortKey<T extends Data> = Key<T> | `${Key<T>}` | `!${Key<T>}`;
 /** One or more sort keys. */
@@ -9,7 +10,7 @@ export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortK
 /** Possible operator references. */
 export declare type SortDirection = "ASC" | "DESC";
 /** List of sorts in a flexible format. */
-export declare type SortList<T extends Data> = SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>;
+export declare type SortList<T extends Data> = Nullish<SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>>;
 /** Sort a list of values. */
 export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
     readonly key: string;

package/constraint/SortConstraint.js

@@ -1,4 +1,3 @@
-import { getProp } from "../util/data.js";
 import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
 /** Sort a list of values. */
 export class SortConstraint {
@@ -16,7 +15,7 @@ export class SortConstraint {
         return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
     }
     rank(left, right) {
-        return rank(getProp(left, this.key), this.direction === "ASC" ? rankAsc : rankDesc, getProp(right, this.key));
+        return rank(left[this.key], this.direction === "ASC" ? rankAsc : rankDesc, right[this.key]);
     }
     transform(items) {
         return sortItems(items, this);
@@ -33,7 +32,7 @@ export function* getSorts(sorts) {
     else if (sorts instanceof SortConstraint) {
         yield sorts;
     }
-    else {
+    else if (sorts) {
         for (const sort of sorts)
             yield* getSorts(sort);
     }

package/constraint/SortConstraints.d.ts

@@ -1,19 +1,19 @@
 import type { Data } from "../util/data.js";
 import { Rankable } from "../util/sort.js";
 import { Constraints } from "./Constraints.js";
-import { SortConstraint, SortKeys, SortList } from "./SortConstraint.js";
+import { SortConstraint, SortList } from "./SortConstraint.js";
 /**
  * Interface to make sure an object implements all directions.
  * - Extends `Rankable` so this object itself can be directly be used with `filterItems()` and `filterEntries()`
  */
 export interface Sortable<T extends Data> extends Rankable<T> {
     /** Add one or more sorts to this sortable. */
-    sort(...keys: SortKeys<T>[]): this;
+    sort(...keys: SortList<Partial<T>>[]): this;
 }
 /** A set of sorts. */
-export declare class SortConstraints<T extends Data = Data> extends Constraints<T, SortConstraint<T>> implements Sortable<T> {
-    constructor(...sorts: SortList<T>[]);
-    sort(...sorts: SortList<T>[]): this;
+export declare class SortConstraints<T extends Data = Data> extends Constraints<T, SortConstraint<Partial<T>>> implements Sortable<T> {
+    constructor(...sorts: SortList<Partial<T>>[]);
+    sort(...sorts: SortList<Partial<T>>[]): this;
     rank(left: T, right: T): number;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;

package/db/Change.d.ts

@@ -1,38 +1,35 @@
-import type { Data, Datas, Key, Value } from "../util/data.js";
+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<Value<T>>;
+    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/Collection.d.ts

@@ -12,7 +12,7 @@ declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T>
     abstract readonly db: Database<T> | AsyncDatabase<T>;
     abstract readonly collection: K;
     /** Create a query on this item's collection. */
-    abstract query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
+    abstract query(filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
     /** Create a query on this item's collection. */
     abstract item(id: string): Item<T, K> | AsyncItem<T, K>;
     /** Add an item to this collection. */
@@ -28,7 +28,7 @@ export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K);
-    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
+    query(filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K>;
     item(id: string): Item<T, K>;
     add(data: T[K]): string;
     change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
@@ -38,7 +38,7 @@ export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> =
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K);
-    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
+    query(filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): AsyncQuery<T, K>;
     item(id: string): AsyncItem<T, K>;
     add(data: T[K]): Promise<string>;
     change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;

package/db/Database.d.ts

@@ -13,30 +13,30 @@ import { ItemChanges, WriteChange } from "./Change.js";
 declare abstract class BaseDatabase<T extends Datas> {
     abstract readonly provider: Provider<T> | AsyncProvider<T>;
     /** Create a query on a collection in this database. */
-    abstract collection<K extends Key<T>>(collection: K): Collection<Pick<T, K>, K> | AsyncCollection<Pick<T, K>, K>;
+    abstract collection<K extends Key<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
     /** Create a query on a collection in this database. */
-    abstract query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<Pick<T, K>, K> | AsyncQuery<Pick<T, K>, K>;
+    abstract 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> | AsyncQuery<T, K>;
     /** Reference an item in a collection in this database. */
-    abstract item<K extends Key<T>>(collection: K, id: string): Item<Pick<T, K>, K> | AsyncItem<Pick<T, K>, K>;
+    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<Pick<T, K>, K>>>[]): ItemChanges<Pick<T, K>, K> | Promise<ItemChanges<Pick<T, K>, 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> {
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
-    collection<K extends Key<T>>(collection: K): Collection<Pick<T, K>, K>;
-    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<Pick<T, K>, K>;
-    item<K extends Key<T>>(collection: K, id: string): Item<Pick<T, K>, K>;
-    change<K extends Key<T>>(...changes: DeepIterable<Nullish<WriteChange<Pick<T, K>, K>>>[]): ItemChanges<Pick<T, K>, K>;
+    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(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T>;
 }
 /** Database with a synchronous provider. */
 export declare class AsyncDatabase<T extends Datas = Datas> implements BaseDatabase<T> {
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
-    collection<K extends Key<T>>(collection: K): AsyncCollection<Pick<T, K>, K>;
-    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<Pick<T, K>, K>;
-    item<K extends Key<T>>(collection: K, id: string): AsyncItem<Pick<T, K>, K>;
-    change<K extends Key<T>>(...changes: DeepIterable<Nullish<WriteChange<Pick<T, K>, K>>>[]): Promise<ItemChanges<Pick<T, K>, K>>;
+    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(...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).
@@ -80,7 +80,7 @@ declare abstract class BaseQuery<T extends Datas = Datas, K extends Key<T> = Key
 export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseQuery<T, K> implements BaseQuery<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
-    constructor(db: Database<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
+    constructor(db: Database<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
     get value(): ItemArray<T[K]>;
     get count(): number;
     get exists(): boolean;
@@ -89,14 +89,14 @@ 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. */
 export declare class AsyncQuery<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseQuery<T, K> implements BaseQuery<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
-    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
+    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null);
     get value(): Promise<ItemArray<T[K]>>;
     get count(): Promise<number>;
     get exists(): Promise<boolean>;
@@ -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>;
 }