shelving 1.89.6 → 1.91.0

package/api/Resource.d.ts

@@ -15,7 +15,7 @@ export declare class Resource<P = unknown, R = void> implements Validatable<R> {
      * Validate a payload for this resource.
      *
      * @returns The validated payload for this resource.
-     * @throws InvalidFeedback if the payload could not be validated.
+     * @throws Feedback if the payload could not be validated.
      */
     prepare(unsafePayload: unknown): P;
     /**

package/api/Resource.js

@@ -17,7 +17,7 @@ export class Resource {
      * Validate a payload for this resource.
      *
      * @returns The validated payload for this resource.
-     * @throws InvalidFeedback if the payload could not be validated.
+     * @throws Feedback if the payload could not be validated.
      */
     prepare(unsafePayload) {
         return validate(unsafePayload, this.payload);

package/constraint/Constraints.js

@@ -1,4 +1,4 @@
-import { getPrototype } from "../util/object.js";
+import { cloneObjectWith } from "../util/object.js";
 import { withArrayItems, omitArrayItems } 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). */
@@ -21,13 +21,11 @@ export class Constraints extends Constraint {
     }
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints) {
-        const _constraints = withArrayItems(this._constraints, ...constraints);
-        return _constraints !== this._constraints ? { __proto__: getPrototype(this), ...this, _constraints: _constraints } : this;
+        return cloneObjectWith(this, "_constraints", withArrayItems(this._constraints, ...constraints));
     }
     /** Clone this set of constraints but remove specific constraints. */
     omit(...constraints) {
-        const _constraints = omitArrayItems(this._constraints, ...constraints);
-        return _constraints !== this._constraints ? { __proto__: getPrototype(this), ...this, _constraints: _constraints } : this;
+        return cloneObjectWith(this, "_constraints", omitArrayItems(this._constraints, ...constraints));
     }
     /** Iterate over the constraints. */
     [Symbol.iterator]() {

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

@@ -1,5 +1,4 @@
 import { Data, FlatDataKey } from "../util/data.js";
-import type { Nullish } from "../util/null.js";
 import { ImmutableArray } from "../util/array.js";
 import type { Matchable } from "../util/match.js";
 import type { Constraint } from "./Constraint.js";
@@ -15,8 +14,6 @@ export type FilterProps<T extends Data> = {
 };
 /** 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` */
 export type FilterKey<T extends Data> = keyof FilterProps<T>;
-/** List of filters in a flexible format. */
-export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> | Iterable<Nullish<FilterProps<T> | FilterConstraint<T>>>;
 /**
  * Filter: filters a list of data.
  *
@@ -24,7 +21,7 @@ export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> |
  * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
-export declare class FilterConstraint<T extends Data = Data> implements Constraint<T>, Matchable<[T]> {
+export declare class Filter<T extends Data = Data> implements Constraint<T>, Matchable<[T]> {
     readonly keys: readonly [string, ...string[]];
     readonly operator: FilterOperator;
     readonly value: unknown;
@@ -35,5 +32,3 @@ export declare class FilterConstraint<T extends Data = Data> implements Constrai
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }
-/** Turn `FilterList` into a list of `FilterConstraint` instances. */
-export declare function getFilters<T extends Data>(list: FilterList<T> | FilterList<T>[]): Iterable<FilterConstraint<T>>;

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

@@ -1,7 +1,6 @@
-import { getDataProps } from "../util/data.js";
 import { isArray } from "../util/array.js";
 import { isArrayWith, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notInArray, isEqual, notEqual } from "../util/equal.js";
-import { filterItems, isIterable } from "../util/iterate.js";
+import { filterItems } from "../util/iterate.js";
 import { getProp } from "../util/object.js";
 import { splitString } from "../util/string.js";
 /** Map `FilterOperator` to its corresponding `Match` function. */
@@ -23,7 +22,7 @@ const MATCHERS = {
  * @param operator FilterOperator, e.g. `IS` or `CONTAINS`
  * @param value Value the specified property should be matched against.
  */
-export class FilterConstraint {
+export class Filter {
     get key() {
         return this.keys.join(".");
     }
@@ -86,18 +85,3 @@ export class FilterConstraint {
         return `"${this.filterKey}":${JSON.stringify(this.value)}`;
     }
 }
-/** Turn `FilterList` into a list of `FilterConstraint` instances. */
-export function* getFilters(list) {
-    if (list instanceof FilterConstraint) {
-        yield list;
-    }
-    else if (isIterable(list)) {
-        for (const filter of list)
-            if (filter)
-                yield* getFilters(filter);
-    }
-    else {
-        for (const [key, value] of getDataProps(list))
-            yield new FilterConstraint(key, value);
-    }
-}

package/constraint/Filters.d.ts

@@ -0,0 +1,26 @@
+import type { Matchable } from "../util/match.js";
+import { Data } from "../util/data.js";
+import { Filter, FilterProps } from "./Filter.js";
+import { Constraints } from "./Constraints.js";
+/** A possible set of filters. */
+export type PossibleFilters<T extends Data> = Filters<T> | FilterProps<T>;
+/** Turn `FilterProps` into a list of `Filter` instances. */
+export declare function getFilters<T extends Data>(filters: PossibleFilters<T>): Iterable<Filter<T>>;
+/** An object that is filterable. */
+export interface Filterable<T extends Data> extends Matchable<[T]> {
+    /** Add a filter to this filterable. */
+    filter(filters: PossibleFilters<T>): this;
+    /** Return a new instance of this class with no filters specified. */
+    unfiltered: this;
+    /** Match an item against the filters specified for this object. */
+    match(item: T): boolean;
+}
+/** A set of filters. */
+export declare class Filters<T extends Data = Data> extends Constraints<T, Filter<T>> implements Filterable<T> {
+    static from<X extends Data = Data>(filters: PossibleFilters<X>): Filters<X>;
+    filter(filters: PossibleFilters<T>): this;
+    get unfiltered(): this;
+    match(item: T): boolean;
+    transform(items: Iterable<T>): Iterable<T>;
+    toString(): string;
+}

package/constraint/Filters.js

@@ -0,0 +1,41 @@
+import { getDataProps } from "../util/data.js";
+import { filterItems } from "../util/iterate.js";
+import { cloneObjectWith } from "../util/object.js";
+import { clearArray } from "../util/array.js";
+import { Filter } from "./Filter.js";
+import { Constraints } from "./Constraints.js";
+/** Turn `FilterProps` into a list of `Filter` instances. */
+export function* getFilters(filters) {
+    if (filters instanceof Filters)
+        yield* filters;
+    else
+        for (const [key, value] of getDataProps(filters))
+            yield new Filter(key, value);
+}
+/** A set of filters. */
+export class Filters extends Constraints {
+    static from(filters) {
+        return filters instanceof Filters ? filters : new Filters(...getFilters(filters));
+    }
+    // Implement `Filterable`
+    filter(filters) {
+        return this.with(...getFilters(filters));
+    }
+    get unfiltered() {
+        return cloneObjectWith(this, "_constraints", clearArray(this._constraints));
+    }
+    match(item) {
+        for (const rule of this._constraints)
+            if (!rule.match(item))
+                return false;
+        return true;
+    }
+    // Implement `Rule`
+    transform(items) {
+        return this._constraints.length ? filterItems(items, this) : items;
+    }
+    // Stringify as object syntax.
+    toString() {
+        return this._constraints.length ? `"filters":{${this._constraints.map(String).join(",")}}` : "";
+    }
+}

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

@@ -1,18 +1,12 @@
-import type { ImmutableArray } from "../util/array.js";
 import type { Data, FlatDataKey } from "../util/data.js";
-import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.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 type SortKey<T extends Data> = FlatDataKey<T> | `${FlatDataKey<T>}` | `!${FlatDataKey<T>}`;
-/** One or more sort keys. */
-export type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */
 export type SortDirection = "ASC" | "DESC";
-/** List of sorts in a flexible format. */
-export type SortList<T extends Data> = SortKey<T> | SortConstraint<T> | Iterable<Nullish<SortKey<T> | SortConstraint<T>>>;
 /** Sort a list of values. */
-export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
+export declare class Sort<T extends Data = Data> implements Constraint<T>, Rankable<T> {
     readonly keys: readonly [string, ...string[]];
     readonly direction: SortDirection;
     get key(): string;
@@ -22,5 +16,3 @@ export declare class SortConstraint<T extends Data = Data> implements Constraint
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;
 }
-/** Turn `SortList` into array of list of `SortConstraint` instances. */
-export declare function getSorts<T extends Data>(list: SortList<T> | SortList<T>[]): Iterable<SortConstraint<T>>;

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

@@ -2,7 +2,7 @@ import { getProp } from "../util/object.js";
 import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
 import { splitString } from "../util/string.js";
 /** Sort a list of values. */
-export class SortConstraint {
+export class Sort {
     get key() {
         return this.keys.join(".");
     }
@@ -29,17 +29,3 @@ export class SortConstraint {
         return this.sortKey;
     }
 }
-/** Turn `SortList` into array of list of `SortConstraint` instances. */
-export function* getSorts(list) {
-    if (typeof list === "string") {
-        yield new SortConstraint(list);
-    }
-    else if (list instanceof SortConstraint) {
-        yield list;
-    }
-    else {
-        for (const sort of list)
-            if (sort)
-                yield* getSorts(sort);
-    }
-}

package/constraint/Sorts.d.ts

@@ -0,0 +1,25 @@
+import type { Data } from "../util/data.js";
+import { ImmutableArray } from "../util/array.js";
+import { Rankable } from "../util/sort.js";
+import { Constraints } from "./Constraints.js";
+import { Sort, SortKey } from "./Sort.js";
+/** A possible set of sorts. */
+export type PossibleSorts<T extends Data> = Sorts<T> | SortKey<T> | Iterable<SortKey<T>> | ImmutableArray<SortKey<T>>;
+/** Turn `SortList` into array of list of `Sort` instances. */
+export declare function getSorts<T extends Data>(sorts: PossibleSorts<T>): Iterable<Sort<T>>;
+/** An object that is sortable. */
+export interface Sortable<T extends Data> extends Rankable<T> {
+    /** Add one or more sorts to this sortable. */
+    sort(sorts: PossibleSorts<T>): this;
+    /** Return a new instance of this class with no sorts specified. */
+    unsorted: this;
+}
+/** A set of sorts. */
+export declare class Sorts<T extends Data = Data> extends Constraints<T, Sort<T>> implements Sortable<T> {
+    static from<X extends Data>(sorts: PossibleSorts<X>): Sorts<X>;
+    sort(sorts: PossibleSorts<T>): this;
+    get unsorted(): this;
+    rank(left: T, right: T): number;
+    transform(items: Iterable<T>): Iterable<T>;
+    toString(): string;
+}

package/constraint/Sorts.js

@@ -0,0 +1,47 @@
+import { clearArray } from "../util/array.js";
+import { cloneObjectWith } from "../util/object.js";
+import { sortItems } from "../util/sort.js";
+import { Constraints } from "./Constraints.js";
+import { Sort } from "./Sort.js";
+/** Turn `SortList` into array of list of `Sort` instances. */
+export function* getSorts(sorts) {
+    if (sorts instanceof Sorts) {
+        yield* sorts;
+    }
+    else if (typeof sorts === "string") {
+        yield new Sort(sorts);
+    }
+    else {
+        for (const sort of sorts)
+            yield new Sort(sort);
+    }
+}
+/** A set of sorts. */
+export class Sorts extends Constraints {
+    static from(sorts) {
+        return sorts instanceof Sorts ? sorts : new Sorts(...getSorts(sorts));
+    }
+    // Implement `Sortable`
+    sort(sorts) {
+        return this.with(...getSorts(sorts));
+    }
+    get unsorted() {
+        return cloneObjectWith(this, "_constraints", clearArray(this._constraints));
+    }
+    rank(left, right) {
+        for (const rule of this._constraints) {
+            const l = rule.rank(left, right);
+            if (l !== 0)
+                return l;
+        }
+        return 0;
+    }
+    // Implement `Rule`
+    transform(items) {
+        return this._constraints.length ? sortItems(items, this) : items;
+    }
+    // Stringify as array syntax.
+    toString() {
+        return this._constraints.length ? `"sorts":[${this._constraints.map(String).join(",")}]` : "";
+    }
+}

package/constraint/{QueryConstraints.d.ts → Statement.d.ts}

@@ -1,9 +1,7 @@
 import type { Data } from "../util/data.js";
-import { Filterable, FilterConstraints } from "./FilterConstraints.js";
-import { Sortable, SortConstraints } from "./SortConstraints.js";
+import { Filterable, Filters, PossibleFilters } from "./Filters.js";
+import { PossibleSorts, Sortable, Sorts } from "./Sorts.js";
 import { Constraint } from "./Constraint.js";
-import { FilterList } from "./FilterConstraint.js";
-import { SortList } from "./SortConstraint.js";
 /** Interface that combines Filterable, Sortable, Sliceable. */
 export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     /**
@@ -17,29 +15,28 @@ export interface Queryable<T extends Data> extends Filterable<T>, Sortable<T> {
     after(item: T): this;
     /** Return a new instance of this class with a before offset defined. */
     before(item: T): this;
-    /** Return a new instance of this class with no filters specified. */
-    readonly unfilter: this;
-    /** Return a new instance of this class with no sorts specified. */
-    readonly unsort: this;
     /** The maximum number of items allowed by the limit. */
     readonly limit: number | null;
+    /** Return a new instance of this class with no limit specified. */
+    readonly unlimited: this;
     /** Return a new instance of this class with a limit set. */
     max(max: number | null): this;
 }
 /** Allows filtering, sorting, and limiting on a set of results. */
-export declare class QueryConstraints<T extends Data = Data> extends Constraint<T> implements Queryable<T> {
-    readonly filters: FilterConstraints<T>;
-    readonly sorts: SortConstraints<T>;
+export declare class Statement<T extends Data = Data> extends Constraint<T> implements Queryable<T> {
+    readonly filters: Filters<T>;
+    readonly sorts: Sorts<T>;
     readonly limit: number | null;
-    constructor(filters?: FilterList<T> | FilterConstraints<T>, sorts?: SortList<T> | SortConstraints<T>, limit?: number | null);
-    filter(...filters: FilterList<T>[]): this;
-    get unfilter(): this;
+    constructor(filters?: PossibleFilters<T>, sorts?: PossibleSorts<T>, limit?: number | null);
+    filter(filters: PossibleFilters<T>): this;
+    get unfiltered(): this;
     match(item: T): boolean;
-    sort(...sorts: SortList<T>[]): this;
-    get unsort(): this;
+    sort(sorts: PossibleSorts<T>): this;
+    get unsorted(): this;
     rank(left: T, right: T): number;
     after(item: T): this;
     before(item: T): this;
+    get unlimited(): this;
     max(limit: number | null): this;
     transform(items: Iterable<T>): Iterable<T>;
     toString(): string;

package/constraint/Statement.js

@@ -0,0 +1,79 @@
+import { cloneObjectWith, getProp } from "../util/object.js";
+import { assert } from "../util/assert.js";
+import { limitArray } from "../util/array.js";
+import { Filters } from "./Filters.js";
+import { Sorts } from "./Sorts.js";
+import { Constraint } from "./Constraint.js";
+import { Filter } from "./Filter.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
+/** Allows filtering, sorting, and limiting on a set of results. */
+export class Statement extends Constraint {
+    constructor(filters = EMPTY_FILTERS, sorts = EMPTY_SORTS, limit = null) {
+        super();
+        this.filters = Filters.from(filters);
+        this.sorts = Sorts.from(sorts);
+        this.limit = limit;
+    }
+    // Implement `Filterable`
+    filter(filters) {
+        return cloneObjectWith(this, "filters", this.filters.filter(filters));
+    }
+    get unfiltered() {
+        return cloneObjectWith(this, "filters", this.filters.unfiltered);
+    }
+    match(item) {
+        return this.filters.match(item);
+    }
+    // Implement `Sortable`
+    sort(sorts) {
+        return cloneObjectWith(this, "sorts", this.sorts.sort(sorts));
+    }
+    get unsorted() {
+        return cloneObjectWith(this, "sorts", this.sorts.unsorted);
+    }
+    rank(left, right) {
+        return this.sorts.rank(left, right);
+    }
+    // Implement `Queryable`
+    after(item) {
+        return cloneObjectWith(this, "filters", this.filters.with(..._getAfterFilters(this.sorts, item)));
+    }
+    before(item) {
+        return cloneObjectWith(this, "filters", this.filters.with(..._getBeforeFilters(this.sorts, item)));
+    }
+    get unlimited() {
+        return this.max(null);
+    }
+    max(limit) {
+        return cloneObjectWith(this, "limit", limit);
+    }
+    // Implement `Rule`
+    transform(items) {
+        const sorted = this.sorts.transform(this.filters.transform(items));
+        return typeof this.limit === "number" ? limitArray(sorted, this.limit) : sorted;
+    }
+    // Implement toString()
+    toString() {
+        return [this.filters.toString(), this.sorts.toString(), typeof this.limit === "number" ? `"limit":${this.limit}` : null].filter(Boolean).join(",");
+    }
+}
+function* _getAfterFilters(sorts, item) {
+    const lastSort = sorts.last;
+    assert(lastSort);
+    for (const sort of sorts) {
+        const { key, keys, direction } = sort;
+        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`);
+        yield new Filter(filterKey, getProp(item, ...keys));
+    }
+}
+function* _getBeforeFilters(sorts, item) {
+    const lastSort = sorts.last;
+    assert(lastSort);
+    for (const sort of sorts) {
+        const { key, keys, direction } = sort;
+        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`);
+        yield new Filter(filterKey, getProp(item, ...keys));
+    }
+}

package/constraint/index.d.ts

@@ -1,7 +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";
+export * from "./Filter.js";
+export * from "./Filters.js";
+export * from "./Sort.js";
+export * from "./Sorts.js";
+export * from "./Statement.js";

package/constraint/index.js

@@ -1,7 +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";
+export * from "./Filter.js";
+export * from "./Filters.js";
+export * from "./Sort.js";
+export * from "./Sorts.js";
+export * from "./Statement.js";

package/db/Change.js

@@ -1,5 +1,5 @@
 import { notNullish } from "../util/null.js";
-import { getItemConstraints } from "./Item.js";
+import { getItemStatement } from "./Item.js";
 /** Apply a set of changes to a synchronous provider. */
 export function changeProvider(provider, ...changes) {
     return changes.filter(notNullish).map(_changeItem, provider);
@@ -11,7 +11,7 @@ function _changeItem(change) {
     else if (action === "SET")
         this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        this.updateQuery(collection, getItemConstraints(change.id), change.updates);
+        this.updateQuery(collection, getItemStatement(change.id), change.updates);
     else if (action === "DELETE")
         this.deleteItem(collection, change.id);
     return change;
@@ -27,7 +27,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, getItemConstraints(change.id), change.updates);
+        await this.updateQuery(collection, getItemStatement(change.id), change.updates);
     else if (action === "DELETE")
         await this.deleteItem(collection, change.id);
     return change;

package/db/Collection.d.ts

@@ -1,6 +1,6 @@
 import type { Data } from "../util/data.js";
-import type { FilterList } from "../constraint/FilterConstraint.js";
-import type { SortList } from "../constraint/SortConstraint.js";
+import type { PossibleFilters } from "../constraint/Filters.js";
+import type { PossibleSorts } from "../constraint/Sorts.js";
 import type { Updates } from "../update/DataUpdate.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import { ItemData, AsyncItem, Item, ItemValue } from "./Item.js";
@@ -11,7 +11,7 @@ declare abstract class BaseCollection<T extends Data = Data> {
     abstract readonly provider: Provider | AsyncProvider;
     abstract readonly collection: string;
     /** Create a query on this item's collection. */
-    abstract query(filters?: FilterList<Partial<ItemData<T>>>, sorts?: SortList<Partial<ItemData<T>>>, limit?: number | null): Query<T> | AsyncQuery<T>;
+    abstract query(filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null): Query<T> | AsyncQuery<T>;
     /** Create a query on this item's collection. */
     abstract item(id: string): Item<T> | AsyncItem<T>;
     /** Get an item from this collection. */
@@ -39,7 +39,7 @@ export declare class Collection<T extends Data = Data> extends BaseCollection<T>
     readonly provider: Provider;
     readonly collection: string;
     constructor(provider: Provider, collection: string);
-    query(filters?: FilterList<ItemData<T>>, sorts?: SortList<ItemData<T>>, limit?: number | null): Query<T>;
+    query(filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null): Query<T>;
     item(id: string): Item<T>;
     get(id: string): ItemValue<T>;
     add(data: T): string;
@@ -52,7 +52,7 @@ export declare class AsyncCollection<T extends Data = Data> extends BaseCollecti
     readonly provider: AsyncProvider;
     readonly collection: string;
     constructor(provider: AsyncProvider, collection: string);
-    query(filters?: FilterList<ItemData<T>>, sorts?: SortList<ItemData<T>>, limit?: number | null): AsyncQuery<T>;
+    query(filters?: PossibleFilters<ItemData<T>>, sorts?: PossibleSorts<ItemData<T>>, limit?: number | null): AsyncQuery<T>;
     item(id: string): AsyncItem<T>;
     get(id: string): Promise<ItemValue<T>>;
     add(data: T): Promise<string>;

package/db/Database.d.ts

@@ -1,8 +1,8 @@
 import type { DataKey, Datas } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { FilterList } from "../constraint/FilterConstraint.js";
-import type { SortList } from "../constraint/SortConstraint.js";
+import type { PossibleFilters } from "../constraint/Filters.js";
+import type { PossibleSorts } from "../constraint/Sorts.js";
 import type { ItemData, ItemValue } from "../db/Item.js";
 import type { Updates } from "../update/DataUpdate.js";
 import { Item, AsyncItem } from "./Item.js";
@@ -15,7 +15,7 @@ declare abstract class BaseDatabase<T extends Datas> {
     /** Create a query on a collection in this database. */
     abstract collection<K extends DataKey<T>>(collection: K): Collection<T[K]> | AsyncCollection<T[K]>;
     /** Create a query on a collection in this database. */
-    abstract query<K extends DataKey<T>>(collection: K, filters?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T[K]> | AsyncQuery<T[K]>;
+    abstract query<K extends DataKey<T>>(collection: K, filters?: PossibleFilters<Partial<ItemData<T[K]>>>, sorts?: PossibleSorts<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 DataKey<T>>(collection: K, id: string): Item<T[K]> | AsyncItem<T[K]>;
     /** Run a set of changes in this database. */
@@ -44,7 +44,7 @@ export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
     readonly provider: Provider;
     constructor(provider: Provider);
     collection<K extends DataKey<T>>(collection: K): Collection<T[K]>;
-    query<K extends DataKey<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T[K]>;
+    query<K extends DataKey<T>>(collection: K, filters?: PossibleFilters<ItemData<T[K]>>, sorts?: PossibleSorts<ItemData<T[K]>>, limit?: number | null): Query<T[K]>;
     item<K extends DataKey<T>>(collection: K, id: string): Item<T[K]>;
     change(...changes: Nullish<WriteChange>[]): ItemChanges;
     get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
@@ -58,7 +58,7 @@ export declare class AsyncDatabase<T extends Datas = Datas> extends BaseDatabase
     readonly provider: AsyncProvider;
     constructor(provider: AsyncProvider);
     collection<K extends DataKey<T>>(collection: K): AsyncCollection<T[K]>;
-    query<K extends DataKey<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T[K]>;
+    query<K extends DataKey<T>>(collection: K, filters?: PossibleFilters<ItemData<T[K]>>, sorts?: PossibleSorts<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T[K]>;
     item<K extends DataKey<T>>(collection: K, id: string): AsyncItem<T[K]>;
     change(...changes: Nullish<WriteChange>[]): Promise<ItemChanges>;
     get<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;

package/db/Item.d.ts

@@ -1,9 +1,9 @@
 import type { ImmutableArray } from "../util/array.js";
 import type { Stop, Handler, Dispatch } from "../util/function.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
-import { QueryConstraints } from "../constraint/QueryConstraints.js";
+import type { Updates } from "../update/DataUpdate.js";
+import { Statement } from "../constraint/Statement.js";
 import { Data } from "../util/data.js";
-import { DataUpdate, Updates } from "../update/DataUpdate.js";
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 /** Item data with a string ID that uniquely identifies it. */
 export type ItemData<T extends Data = Data> = T & {
@@ -18,9 +18,9 @@ export declare function getIDs<T extends Data>(entities: Iterable<ItemData<T>>):
 /** An array of item data. */
 export type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T>>;
 /** A set of query constraints for item data. */
-export type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
-/** Get a `FilterConstraints` instance that targets a single item by its ID. */
-export declare const getItemConstraints: <T extends Data>(id: string) => QueryConstraints<ItemData<T>>;
+export type ItemStatement<T extends Data = Data> = Statement<ItemData<T>>;
+/** Get a `Filter` instance that targets a single item by its ID. */
+export declare const getItemStatement: <T extends Data>(id: string) => Statement<ItemData<T>>;
 /** Reference to an item in a synchronous or asynchronous database. */
 declare abstract class BaseItem<T extends Data = Data> implements AsyncIterable<ItemValue<T>> {
     abstract readonly provider: Provider | AsyncProvider;
@@ -47,7 +47,7 @@ declare abstract class BaseItem<T extends Data = Data> implements AsyncIterable<
     /** Set the complete data of this item. */
     abstract set(data: T): void | PromiseLike<void>;
     /** Update this item. */
-    abstract update(updates: DataUpdate<T> | Updates<T>): void | PromiseLike<void>;
+    abstract update(updates: Updates<T>): void | PromiseLike<void>;
     /** Delete this item. */
     abstract delete(): void | PromiseLike<void>;
     /** Get a set change for this item. */

package/db/Item.js

@@ -1,6 +1,6 @@
-import { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { FilterConstraint } from "../constraint/FilterConstraint.js";
-import { FilterConstraints } from "../constraint/FilterConstraints.js";
+import { Statement } from "../constraint/Statement.js";
+import { Filter } from "../constraint/Filter.js";
+import { Filters } from "../constraint/Filters.js";
 import { getData } from "../util/data.js";
 import { runSequence } from "../util/sequence.js";
 /** Get the ID from item data. */
@@ -10,8 +10,8 @@ export function* getIDs(entities) {
     for (const { id } of entities)
         yield id;
 }
-/** Get a `FilterConstraints` instance that targets a single item by its ID. */
-export const getItemConstraints = (id) => new QueryConstraints(new FilterConstraints(new FilterConstraint("id", id)), undefined, 1);
+/** Get a `Filter` instance that targets a single item by its ID. */
+export const getItemStatement = (id) => new Statement(new Filters(new Filter("id", id)), undefined, 1);
 /** Reference to an item in a synchronous or asynchronous database. */
 class BaseItem {
     /** Get a set change for this item. */

package/db/ItemState.d.ts

@@ -1,5 +1,5 @@
+import type { Dispatch } from "../util/function.js";
 import { Data } from "../util/data.js";
-import { Dispatch } from "../util/function.js";
 import { State } from "../state/State.js";
 import { BooleanState } from "../state/BooleanState.js";
 import { ItemValue, Item, AsyncItem, ItemData } from "./Item.js";