shelving 1.72.0 → 1.73.2

package/{query/Rule.d.ts → constraint/Constraint.d.ts}

@@ -1,7 +1,7 @@
 import type { Data } from "../util/data.js";
 import type { Transformable } from "../util/transform.js";
-/** Something that can be used to query against a result set or an array of entries. */
-export declare abstract class Rule<T extends Data> implements Transformable<Iterable<T>, Iterable<T>> {
+/** Something that can be used to constrain a query. */
+export declare abstract class Constraint<T extends Data> implements Transformable<Iterable<T>, Iterable<T>> {
     abstract transform(items: Iterable<T>): Iterable<T>;
     abstract toString(): string;
 }

package/constraint/Constraint.js

@@ -0,0 +1,3 @@
+/** Something that can be used to constrain a query. */
+export class Constraint {
+}

package/constraint/Constraints.d.ts

@@ -0,0 +1,20 @@
+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> {
+    protected readonly _constraints: ImmutableArray<C>;
+    /** Get the first constraint. */
+    get first(): C | undefined;
+    /** Get the last constraint. */
+    get last(): C | undefined;
+    /** Get the number of constraints. */
+    get size(): number;
+    constructor(...constraints: C[]);
+    /** Clone this set of constraints but add additional constraints. */
+    with(...constraints: C[]): this;
+    /** Clone this set of constraints but remove specific constraints. */
+    without(...constraints: C[]): this;
+    /** Iterate over the constraints. */
+    [Symbol.iterator](): Iterator<C, void>;
+}

package/constraint/Constraints.js

@@ -0,0 +1,35 @@
+import { withItems, withoutItems } 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 class Constraints extends Constraint {
+    constructor(...constraints) {
+        super();
+        this._constraints = constraints;
+    }
+    /** Get the first constraint. */
+    get first() {
+        return this._constraints[0];
+    }
+    /** Get the last constraint. */
+    get last() {
+        return this._constraints[this._constraints.length - 1];
+    }
+    /** Get the number of constraints. */
+    get size() {
+        return this._constraints.length;
+    }
+    /** Clone this set of constraints but add additional constraints. */
+    with(...constraints) {
+        const _constraints = withItems(this._constraints, constraints);
+        return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
+    }
+    /** Clone this set of constraints but remove specific constraints. */
+    without(...constraints) {
+        const _constraints = withoutItems(this._constraints, constraints);
+        return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
+    }
+    /** Iterate over the constraints. */
+    [Symbol.iterator]() {
+        return this._constraints.values();
+    }
+}

package/{query/Filter.d.ts → constraint/FilterConstraint.d.ts}

@@ -2,7 +2,7 @@ import { ArrayType, ImmutableArray } from "../util/array.js";
 import { Data, Key } from "../util/data.js";
 import { Matchable } from "../util/match.js";
 import { NotString } from "../util/string.js";
-import { Rule } from "./Rule.js";
+import { 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` */
@@ -16,16 +16,16 @@ export declare type FilterProps<T extends Data> = {
     [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> | Filter<T> | Iterable<FilterList<T> & NotString>;
+export declare type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> | Iterable<FilterList<T> & NotString>;
 /**
- * Filter: filters a list of documents.
+ * Filter: filters a list of data.
  *
- * @param key The name of a property that might exist on documents in the collection.
+ * @param key The name of a property that might exist on data in the collection.
  * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
-export declare class Filter<T extends Data> extends Rule<T> implements Matchable<T, void> {
-    readonly key: Key<T>;
+export declare class FilterConstraint<T extends Data = Data> implements Constraint<T>, Matchable<T, void> {
+    readonly key: string;
     readonly operator: FilterOperator;
     readonly value: unknown;
     get filterKey(): string;
@@ -35,4 +35,4 @@ export declare class Filter<T extends Data> extends Rule<T> implements Matchable
     toString(): string;
 }
 /** Get the separate filters generated from a list of filters. */
-export declare function getFilters<T extends Data>(filters: FilterList<T>): Iterable<Filter<T>>;
+export declare function getFilters<T extends Data>(filters: FilterList<T>): Iterable<FilterConstraint<T>>;

package/{query/Filter.js → constraint/FilterConstraint.js}

@@ -1,9 +1,7 @@
 import { isArray } from "../util/array.js";
-import { getProp } from "../util/data.js";
 import { isArrayWith, isEqual, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notEqual, notInArray } from "../util/match.js";
 import { filterItems } from "../util/filter.js";
 import { isIterable } from "../util/iterate.js";
-import { Rule } from "./Rule.js";
 /** Map `FilterOperator` to its corresponding `Match` function. */
 const MATCHERS = {
     IS: isEqual,
@@ -17,15 +15,14 @@ const MATCHERS = {
     GTE: isEqualGreater,
 };
 /**
- * Filter: filters a list of documents.
+ * Filter: filters a list of data.
  *
- * @param key The name of a property that might exist on documents in the collection.
+ * @param key The name of a property that might exist on data in the collection.
  * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
-export class Filter extends Rule {
+export class FilterConstraint {
     constructor(filterKey, value) {
-        super();
         if (filterKey.startsWith("!")) {
             this.key = filterKey.slice(1);
             this.operator = isArray(value) ? "OUT" : "NOT";
@@ -74,7 +71,7 @@ export class Filter extends Rule {
             return key;
     }
     match(item) {
-        return MATCHERS[this.operator](getProp(item, this.key), this.value);
+        return MATCHERS[this.operator](item[this.key], this.value);
     }
     transform(items) {
         return filterItems(items, this);
@@ -85,7 +82,7 @@ export class Filter extends Rule {
 }
 /** Get the separate filters generated from a list of filters. */
 export function* getFilters(filters) {
-    if (filters instanceof Filter) {
+    if (filters instanceof FilterConstraint) {
         yield filters;
     }
     else if (isIterable(filters)) {
@@ -94,6 +91,6 @@ export function* getFilters(filters) {
     }
     else {
         for (const [key, value] of Object.entries(filters))
-            yield new Filter(key, value);
+            yield new FilterConstraint(key, value);
     }
 }

package/{query/Filters.d.ts → constraint/FilterConstraints.d.ts}

@@ -1,7 +1,7 @@
 import type { Data } from "../util/data.js";
 import type { Matchable } from "../util/match.js";
-import { FilterList, FilterProps, Filter } from "./Filter.js";
-import { Rules } from "./Rules.js";
+import { FilterList, FilterProps, FilterConstraint } from "./FilterConstraint.js";
+import { Constraints } from "./Constraints.js";
 /**
  * Interface to make sure an object implements all matchers.
  * - Extends `Matchable` so this object itself can be directly be used in `filterItems()` and `filterEntries()`
@@ -13,7 +13,7 @@ export interface Filterable<T extends Data> extends Matchable<T, void> {
     match(item: T): boolean;
 }
 /** A set of filters. */
-export declare class Filters<T extends Data> extends Rules<T, Filter<T>> implements Filterable<T> {
+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;
     match(item: T): boolean;

package/{query/Filters.js → constraint/FilterConstraints.js}

@@ -1,8 +1,8 @@
 import { filterItems } from "../util/filter.js";
-import { getFilters } from "./Filter.js";
-import { Rules } from "./Rules.js";
+import { getFilters } from "./FilterConstraint.js";
+import { Constraints } from "./Constraints.js";
 /** A set of filters. */
-export class Filters extends Rules {
+export class FilterConstraints extends Constraints {
     constructor(...filters) {
         super(...getFilters(filters));
     }
@@ -11,17 +11,17 @@ export class Filters extends Rules {
         return this.with(...getFilters(filters));
     }
     match(item) {
-        for (const rule of this._rules)
+        for (const rule of this._constraints)
             if (!rule.match(item))
                 return false;
         return true;
     }
     // Implement `Rule`
     transform(items) {
-        return this._rules.length ? filterItems(items, this) : items;
+        return this._constraints.length ? filterItems(items, this) : items;
     }
     // Stringify as object syntax.
     toString() {
-        return `{${this._rules.map(String).join(",")}`;
+        return `{${this._constraints.map(String).join(",")}`;
     }
 }

package/{query/Query.d.ts → constraint/QueryConstraints.d.ts}

@@ -1,15 +1,9 @@
 import { Data } from "../util/data.js";
-import { Filterable, Filters } from "./Filters.js";
-import { Sortable, Sorts } from "./Sorts.js";
-import { Rule } from "./Rule.js";
-import { FilterList } from "./Filter.js";
-import { SortKeys, SortList } from "./Sort.js";
-/** Set of props for a query defined as an object. */
-export declare type QueryProps<T extends Data> = {
-    readonly filter?: FilterList<T>;
-    readonly sort?: SortList<T>;
-    readonly limit?: number | null;
-};
+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";
 /** Interface that combines Filterable, Sortable, Sliceable. */
 export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     /**
@@ -31,15 +25,13 @@ export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     readonly limit: number | null;
     /** Return a new instance of this class with a limit set. */
     max(max: number | null): this;
-    /** Return a new instance of this class with new filters, sorts, limits set. */
-    query(query: QueryProps<T>): this;
 }
 /** Allows filtering, sorting, and limiting on a set of results. */
-export declare class Query<T extends Data> extends Rule<T> implements Queryable<T> {
-    readonly filters: Filters<T>;
-    readonly sorts: Sorts<T>;
+export declare class QueryConstraints<T extends Data = Data> extends Constraint<T> implements Queryable<T> {
+    readonly filters: FilterConstraints<T>;
+    readonly sorts: SortConstraints<T>;
     readonly limit: number | null;
-    constructor({ filter, sort, limit }?: QueryProps<T>);
+    constructor(filters?: FilterList<T>, sorts?: SortList<T>, limit?: number | null);
     filter(...filters: FilterList<T>[]): this;
     get unfilter(): this;
     match(item: T): boolean;
@@ -49,7 +41,6 @@ export declare class Query<T extends Data> extends Rule<T> implements Queryable<
     after(item: T): this;
     before(item: T): this;
     max(limit: number | null): this;
-    query({ sort, limit, filter }: QueryProps<T>): this;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }

package/{query/Query.js → constraint/QueryConstraints.js}

@@ -1,20 +1,19 @@
 import { getProp } from "../util/data.js";
 import { assert } from "../util/assert.js";
 import { limitItems } from "../util/iterate.js";
-import { Filters } from "./Filters.js";
-import { Sorts } from "./Sorts.js";
-import { Rule } from "./Rule.js";
-import { Filter } from "./Filter.js";
+import { FilterConstraints } from "./FilterConstraints.js";
+import { SortConstraints } from "./SortConstraints.js";
+import { Constraint } from "./Constraint.js";
+import { FilterConstraint } from "./FilterConstraint.js";
 // Instances to save resources for the default case (empty query).
-const EMPTY_FILTERS = new Filters(); // eslint-disable-line @typescript-eslint/no-explicit-any
-const EMPTY_SORTS = new Sorts(); // eslint-disable-line @typescript-eslint/no-explicit-any
-const EMPTY_PROPS = { filter: EMPTY_FILTERS, sort: EMPTY_SORTS, limit: null }; // eslint-disable-line @typescript-eslint/no-explicit-any
+const EMPTY_FILTERS = new FilterConstraints(); // eslint-disable-line @typescript-eslint/no-explicit-any
+const EMPTY_SORTS = new SortConstraints(); // eslint-disable-line @typescript-eslint/no-explicit-any
 /** Allows filtering, sorting, and limiting on a set of results. */
-export class Query extends Rule {
-    constructor({ filter = EMPTY_FILTERS, sort = EMPTY_SORTS, limit = null } = EMPTY_PROPS) {
+export class QueryConstraints extends Constraint {
+    constructor(filters = EMPTY_FILTERS, sorts = EMPTY_SORTS, limit = null) {
         super();
-        this.filters = filter instanceof Filters ? filter : new Filters(filter);
-        this.sorts = sort instanceof Sorts ? sort : new Sorts(sort);
+        this.filters = filters instanceof FilterConstraints ? filters : new FilterConstraints(filters);
+        this.sorts = sorts instanceof SortConstraints ? sorts : new SortConstraints(sorts);
         this.limit = limit;
     }
     // Implement `Filterable`
@@ -26,6 +25,8 @@ export class Query extends Rule {
         };
     }
     get unfilter() {
+        if (!this.filters.size)
+            return this;
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
@@ -44,6 +45,8 @@ export class Query extends Rule {
         };
     }
     get unsort() {
+        if (!this.sorts.size)
+            return this;
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
@@ -69,21 +72,14 @@ export class Query extends Rule {
         };
     }
     max(limit) {
+        if (this.limit === limit)
+            return this;
         return {
             __proto__: Object.getPrototypeOf(this),
             ...this,
             limit,
         };
     }
-    query({ sort, limit, filter }) {
-        return {
-            __proto__: Object.getPrototypeOf(this),
-            ...this,
-            filters: filter ? this.filters.filter(filter) : this.filters,
-            sorts: sort ? this.sorts.sort(sort) : this.sorts,
-            limit: limit !== undefined ? limit : this.limit,
-        };
-    }
     // Implement `Rule`
     transform(items) {
         const sorted = this.sorts.transform(this.filters.transform(items));
@@ -91,7 +87,7 @@ export class Query extends Rule {
     }
     // Implement toString()
     toString() {
-        return `{"filter":${this.filters.toString()}},"sort":${this.sorts.toString()},"limit":${this.limit}}`;
+        return `{"filters":${this.filters.toString()}},"sorts":${this.sorts.toString()},"limit":${this.limit}}`;
     }
 }
 function* _getAfterFilters(sorts, item) {
@@ -100,7 +96,7 @@ function* _getAfterFilters(sorts, item) {
     for (const sort of sorts) {
         const { key, direction } = sort;
         const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`;
-        yield new Filter(filterKey, getProp(item, key));
+        yield new FilterConstraint(filterKey, getProp(item, key));
     }
 }
 function* _getBeforeFilters(sorts, item) {
@@ -109,6 +105,6 @@ function* _getBeforeFilters(sorts, item) {
     for (const sort of sorts) {
         const { key, direction } = sort;
         const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`;
-        yield new Filter(filterKey, getProp(item, key));
+        yield new FilterConstraint(filterKey, getProp(item, key));
     }
 }

package/{query/Sort.d.ts → constraint/SortConstraint.d.ts}

@@ -1,7 +1,7 @@
 import type { ImmutableArray } from "../util/array.js";
 import { Data, Key } from "../util/data.js";
 import { Rankable } from "../util/sort.js";
-import { Rule } from "./Rule.js";
+import { 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,10 +9,10 @@ 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> | Sort<T> | Iterable<SortList<T>>;
+export declare type SortList<T extends Data> = SortKeys<T> | SortConstraint<T> | Iterable<SortList<T>>;
 /** Sort a list of values. */
-export declare class Sort<T extends Data> extends Rule<T> implements Rankable<T> {
-    readonly key: Key<T>;
+export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
+    readonly key: string;
     readonly direction: SortDirection;
     get sortKey(): string;
     constructor(sortKey: SortKey<T>);
@@ -21,4 +21,4 @@ export declare class Sort<T extends Data> extends Rule<T> implements Rankable<T>
     toString(): string;
 }
 /** Get the separate sorts generated from a list of sorts. */
-export declare function getSorts<T extends Data>(sorts: SortList<T>): Iterable<Sort<T>>;
+export declare function getSorts<T extends Data>(sorts: SortList<T>): Iterable<SortConstraint<T>>;

package/{query/Sort.js → constraint/SortConstraint.js}

@@ -1,10 +1,8 @@
 import { getProp } from "../util/data.js";
 import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
-import { Rule } from "./Rule.js";
 /** Sort a list of values. */
-export class Sort extends Rule {
+export class SortConstraint {
     constructor(sortKey) {
-        super();
         if (sortKey.startsWith("!")) {
             this.key = sortKey.slice(1);
             this.direction = "DESC";
@@ -30,9 +28,9 @@ export class Sort extends Rule {
 /** Get the separate sorts generated from a list of sorts. */
 export function* getSorts(sorts) {
     if (typeof sorts === "string") {
-        yield new Sort(sorts);
+        yield new SortConstraint(sorts);
     }
-    else if (sorts instanceof Sort) {
+    else if (sorts instanceof SortConstraint) {
         yield sorts;
     }
     else {

package/{query/Sorts.d.ts → constraint/SortConstraints.d.ts}

@@ -1,7 +1,7 @@
 import type { Data } from "../util/data.js";
 import { Rankable } from "../util/sort.js";
-import { Rules } from "./Rules.js";
-import { Sort, SortKeys, SortList } from "./Sort.js";
+import { Constraints } from "./Constraints.js";
+import { SortConstraint, SortKeys, 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()`
@@ -11,7 +11,7 @@ export interface Sortable<T extends Data> extends Rankable<T> {
     sort(...keys: SortKeys<T>[]): this;
 }
 /** A set of sorts. */
-export declare class Sorts<T extends Data> extends Rules<T, Sort<T>> implements Sortable<T> {
+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;
     rank(left: T, right: T): number;

package/{query/Sorts.js → constraint/SortConstraints.js}

@@ -1,8 +1,8 @@
 import { sortItems } from "../util/sort.js";
-import { Rules } from "./Rules.js";
-import { getSorts } from "./Sort.js";
+import { Constraints } from "./Constraints.js";
+import { getSorts } from "./SortConstraint.js";
 /** A set of sorts. */
-export class Sorts extends Rules {
+export class SortConstraints extends Constraints {
     constructor(...sorts) {
         super(...getSorts(sorts));
     }
@@ -11,7 +11,7 @@ export class Sorts extends Rules {
         return this.with(...getSorts(sorts));
     }
     rank(left, right) {
-        for (const rule of this._rules) {
+        for (const rule of this._constraints) {
             const l = rule.rank(left, right);
             if (l !== 0)
                 return l;
@@ -20,10 +20,10 @@ export class Sorts extends Rules {
     }
     // Implement `Rule`
     transform(items) {
-        return this._rules.length ? sortItems(items, this) : items;
+        return this._constraints.length ? sortItems(items, this) : items;
     }
     // Stringify as array syntax.
     toString() {
-        return `[${this._rules.map(String).join(",")}]`;
+        return `[${this._constraints.map(String).join(",")}]`;
     }
 }

package/constraint/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./Constraint.js";
+export * from "./Constraints.js";
+export * from "./FilterConstraint.js";
+export * from "./FilterConstraints.js";
+export * from "./SortConstraint.js";
+export * from "./SortConstraints.js";
+export * from "./QueryConstraints.js";

package/constraint/index.js

@@ -0,0 +1,7 @@
+export * from "./Constraint.js";
+export * from "./Constraints.js";
+export * from "./FilterConstraint.js";
+export * from "./FilterConstraints.js";
+export * from "./SortConstraint.js";
+export * from "./SortConstraints.js";
+export * from "./QueryConstraints.js";

package/db/Changes.d.ts

@@ -1,21 +1,22 @@
 import type { Datas, Key } from "../util/data.js";
 import { DataUpdate } from "../update/DataUpdate.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
-import type { SynchronousDatabase, AsynchronousDatabase } from "./Database.js";
+import type { Database, AsyncDatabase } from "./Database.js";
 /**
  * Change set of operations to run against a database in `{ "collection/id": data | DataUpdate | null }`  format.
- * - If data is an object, sets the document.
- * - If data is a `DataUpdate` instance, updates the document.
- * - If data is null, deletes the document.
+ * - If data is an object, sets the item.
+ * - If data is a `DataUpdate` instance, updates the item.
+ * - If data is null, deletes the item.
+ * - If data is undefined, skip the item.
  */
 export declare type Changes<DB extends Datas> = {
-    [K in Key<DB> as `${K}/${string}`]: DB[K] | DataUpdate<DB[K]> | null;
+    [K in Key<DB> as `${K}/${string}`]: DB[K] | DataUpdate<DB[K]> | null | undefined;
 };
 /** Apply a set of changes to a synchronous database. */
-export declare function changeSynchronousDatabase<T extends Datas>({ provider }: SynchronousDatabase<T>, changes: Changes<T>): Changes<T>;
+export declare function changeDatabase<T extends Datas>({ provider }: Database<T>, changes: Changes<T>): Changes<T>;
 /** Apply a set of changes to an asynchronous database. */
-export declare function changeAsynchronousDatabase<T extends Datas>({ provider }: AsynchronousDatabase<T>, changes: Changes<T>): Promise<Changes<T>>;
+export declare function changeAsyncDatabase<T extends Datas>({ provider }: AsyncDatabase<T>, changes: Changes<T>): Promise<Changes<T>>;
 /** Apply a set of changes to a synchronous provider. */
-export declare function changeSynchronousProvider<T extends Datas>(provider: Provider<T>, changes: Changes<T>): Changes<T>;
+export declare function changeProvider<T extends Datas>(provider: Provider<T>, changes: Changes<T>): Changes<T>;
 /** Apply a set of changes to an asynchronous provider. */
-export declare function changeAsynchronousProvider<T extends Datas>(provider: AsyncProvider<T>, changes: Changes<T>): Promise<Changes<T>>;
+export declare function changeAsyncProvider<T extends Datas>(provider: AsyncProvider<T>, changes: Changes<T>): Promise<Changes<T>>;

package/db/Changes.js

@@ -1,36 +1,40 @@
 import { splitString } from "../util/string.js";
 import { DataUpdate } from "../update/DataUpdate.js";
 /** Apply a set of changes to a synchronous database. */
-export function changeSynchronousDatabase({ provider }, changes) {
-    return changeSynchronousProvider(provider, changes);
+export function changeDatabase({ provider }, changes) {
+    return changeProvider(provider, changes);
 }
 /** Apply a set of changes to an asynchronous database. */
-export function changeAsynchronousDatabase({ provider }, changes) {
-    return changeAsynchronousProvider(provider, changes);
+export function changeAsyncDatabase({ provider }, changes) {
+    return changeAsyncProvider(provider, changes);
 }
 /** Apply a set of changes to a synchronous provider. */
-export function changeSynchronousProvider(provider, changes) {
+export function changeProvider(provider, changes) {
     for (const [key, change] of Object.entries(changes)) {
         const [collection, id] = splitString(key, "/", 2);
-        if (!change)
-            provider.deleteDocument({ collection, id });
+        if (change === undefined)
+            continue;
+        else if (change === null)
+            provider.deleteItem(collection, id);
         else if (change instanceof DataUpdate)
-            provider.updateDocument({ collection, id }, change);
+            provider.updateItem(collection, id, change);
         else
-            provider.setDocument({ collection, id }, change);
+            provider.setItem(collection, id, change);
     }
     return changes;
 }
 /** Apply a set of changes to an asynchronous provider. */
-export async function changeAsynchronousProvider(provider, changes) {
+export async function changeAsyncProvider(provider, changes) {
     for (const [key, change] of Object.entries(changes)) {
         const [collection, id] = splitString(key, "/", 2);
-        if (!change)
-            await provider.deleteDocument({ collection, id });
+        if (change === undefined)
+            continue;
+        else if (change === null)
+            await provider.deleteItem(collection, id);
         else if (change instanceof DataUpdate)
-            await provider.updateDocument({ collection, id }, change);
+            await provider.updateItem(collection, id, change);
         else
-            await provider.setDocument({ collection, id }, change);
+            await provider.setItem(collection, id, change);
     }
     return changes;
 }

package/db/Changes.test.d.ts

@@ -0,0 +1 @@
+export {};

package/db/Changes.test.js

@@ -0,0 +1,11 @@
+import { DataUpdate } from "../index.js";
+test("Typescript", () => {
+    const operations = {
+        "collection1/a1": { a: 1, one: false },
+        "collection1/b2": null,
+        "collection1/b3": new DataUpdate({ one: true }),
+        "collection2/a1": { b: 1, one: false },
+        "collection2/b2": null,
+        "collection2/c3": new DataUpdate({ one: true }),
+    };
+});

package/db/Collection.d.ts

@@ -0,0 +1,39 @@
+import type { Datas, Key } from "../util/data.js";
+import type { FilterList } from "../constraint/FilterConstraint.js";
+import type { SortList } from "../constraint/SortConstraint.js";
+import type { ItemData, AsyncItem, Item } from "./Item.js";
+import type { AsyncDatabase, Database } from "./Database.js";
+import type { AsyncQuery, Query } from "./Query.js";
+/** Reference to a collection in a synchronous or asynchronous provider. */
+interface CollectionInterface<T extends Datas = Datas, K extends Key<T> = Key<T>> {
+    readonly db: Database<T> | AsyncDatabase<T>;
+    readonly collection: K;
+    /** Create a query on this item's collection. */
+    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
+    /** Create a query on this item's collection. */
+    item(id: string): Item<T, K> | AsyncItem<T, K>;
+    /** Add an item to this collection. */
+    add(data: T[K]): string | Promise<string>;
+    toString(): K;
+}
+/** Reference to a collection in a synchronous provider. */
+export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<T>> implements CollectionInterface<T, K> {
+    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>;
+    item(id: string): Item<T, K>;
+    add(data: T[K]): string;
+    toString(): K;
+}
+/** Reference to a collection in an asynchronous provider. */
+export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> implements CollectionInterface<T, K> {
+    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>;
+    item(id: string): AsyncItem<T, K>;
+    add(data: T[K]): Promise<string>;
+    toString(): K;
+}
+export {};