shelving 1.73.1 → 1.74.0

package/constraint/QueryConstraints.d.ts

@@ -4,12 +4,6 @@ import { Sortable, SortConstraints } from "./SortConstraints.js";
 import { Constraint } from "./Constraint.js";
 import { FilterList } from "./FilterConstraint.js";
 import { SortKeys, SortList } from "./SortConstraint.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;
-};
 /** 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 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 QueryConstraints<T extends Data = Data> extends Constraint<
     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/constraint/QueryConstraints.js

@@ -8,13 +8,12 @@ import { FilterConstraint } from "./FilterConstraint.js";
 // Instances to save resources for the default case (empty query).
 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
-const EMPTY_PROPS = { filter: EMPTY_FILTERS, sort: EMPTY_SORTS, limit: null }; // eslint-disable-line @typescript-eslint/no-explicit-any
 /** Allows filtering, sorting, and limiting on a set of results. */
 export class QueryConstraints extends Constraint {
-    constructor({ filter = EMPTY_FILTERS, sort = EMPTY_SORTS, limit = null } = EMPTY_PROPS) {
+    constructor(filters = EMPTY_FILTERS, sorts = EMPTY_SORTS, limit = null) {
         super();
-        this.filters = filter instanceof FilterConstraints ? filter : new FilterConstraints(filter);
-        this.sorts = sort instanceof SortConstraints ? sort : new SortConstraints(sort);
+        this.filters = filters instanceof FilterConstraints ? filters : new FilterConstraints(filters);
+        this.sorts = sorts instanceof SortConstraints ? sorts : new SortConstraints(sorts);
         this.limit = limit;
     }
     // Implement `Filterable`
@@ -81,15 +80,6 @@ export class QueryConstraints extends Constraint {
             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));
@@ -97,7 +87,7 @@ export class QueryConstraints extends Constraint {
     }
     // 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) {

package/db/Changes.d.ts

@@ -1,7 +1,8 @@
-import type { Datas, Key } from "../util/data.js";
+import type { Data, Datas, Key } from "../util/data.js";
 import { DataUpdate } from "../update/DataUpdate.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import type { Database, AsyncDatabase } from "./Database.js";
+import { ItemConstraints, ItemData } from "./Item.js";
 /**
  * Change set of operations to run against a database in `{ "collection/id": data | DataUpdate | null }`  format.
  * - If data is an object, sets the item.
@@ -9,8 +10,8 @@ import type { Database, AsyncDatabase } from "./Database.js";
  * - 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 | undefined;
+export declare type Changes<T extends Datas> = {
+    [K in Key<T> as `${K}/${string}`]: T[K] | DataUpdate<T[K]> | null | undefined;
 };
 /** Apply a set of changes to a synchronous database. */
 export declare function changeDatabase<T extends Datas>({ provider }: Database<T>, changes: Changes<T>): Changes<T>;
@@ -20,3 +21,4 @@ export declare function changeAsyncDatabase<T extends Datas>({ provider }: Async
 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 changeAsyncProvider<T extends Datas>(provider: AsyncProvider<T>, changes: Changes<T>): Promise<Changes<T>>;
+export declare function _getItemConstraint<T extends Data>(id: string): ItemConstraints<ItemData<T>>;

package/db/Changes.js

@@ -1,5 +1,7 @@
 import { splitString } from "../util/string.js";
 import { DataUpdate } from "../update/DataUpdate.js";
+import { QueryConstraints } from "../constraint/QueryConstraints.js";
+import { FilterConstraint } from "../constraint/FilterConstraint.js";
 /** Apply a set of changes to a synchronous database. */
 export function changeDatabase({ provider }, changes) {
     return changeProvider(provider, changes);
@@ -17,7 +19,7 @@ export function changeProvider(provider, changes) {
         else if (change === null)
             provider.deleteItem(collection, id);
         else if (change instanceof DataUpdate)
-            provider.updateItem(collection, id, change);
+            provider.updateQuery(collection, _getItemConstraint(id), change);
         else
             provider.setItem(collection, id, change);
     }
@@ -32,9 +34,12 @@ export async function changeAsyncProvider(provider, changes) {
         else if (change === null)
             await provider.deleteItem(collection, id);
         else if (change instanceof DataUpdate)
-            await provider.updateItem(collection, id, change);
+            await provider.updateQuery(collection, _getItemConstraint(id), change);
         else
             await provider.setItem(collection, id, change);
     }
     return changes;
 }
+export function _getItemConstraint(id) {
+    return new QueryConstraints(new FilterConstraint("id", id), undefined, 1);
+}

package/db/Changes.test.js

@@ -1,11 +1,35 @@
-import { DataUpdate } from "../index.js";
+import { AsyncDatabase, DataUpdate } from "../index.js";
 test("Typescript", () => {
-    const operations = {
-        "collection1/a1": { a: 1, one: false },
+    const operations1 = {
+        "collection1/a1": { one: 1, bool: false },
         "collection1/b2": null,
-        "collection1/b3": new DataUpdate({ one: true }),
-        "collection2/a1": { b: 1, one: false },
+        "collection1/b3": new DataUpdate({ bool: true }),
+        "collection2/a1": { two: 1, bool: false },
         "collection2/b2": null,
-        "collection2/c3": new DataUpdate({ one: true }),
+        "collection2/c3": new DataUpdate({ bool: true }),
     };
+    // Check the keys.
+    const operations2 = {
+        // @ts-expect-error
+        "NOTCOLLECTION/a1": { a: 1, bool: false },
+    };
+    // Check the values.
+    const operations3 = {
+        "collection1/a1": {
+            one: 1,
+            // @ts-expect-error
+            bool: "NOTBOOL",
+        },
+    };
+    // Check some objects.
+    const db = new AsyncDatabase(undefined);
+    const changes = {
+        ...db.item("collection1", "a1").getUpdate({ bool: true }),
+        ...db.item("collection2", "b2").getSet({ two: 123, bool: false }),
+        ...db.item("collection2", "b2").getDelete(),
+    };
+    // Merging changes.
+    const changes1 = {};
+    const changes2 = {};
+    const changes3 = { ...changes1, ...changes2 };
 });

package/db/Collection.d.ts

@@ -1,38 +1,37 @@
-import type { QueryProps } from "../constraint/QueryConstraints.js";
 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;
+declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> {
+    abstract readonly db: Database<T> | AsyncDatabase<T>;
+    abstract readonly collection: K;
     /** Create a query on this item's collection. */
-    query(query?: QueryProps<ItemData<T[K]>>): Query<T, K> | AsyncQuery<T, K>;
+    abstract 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>;
+    abstract item(id: string): Item<T, K> | AsyncItem<T, K>;
     /** Add an item to this collection. */
-    add(data: T[K]): string | Promise<string>;
+    abstract 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> {
+export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseCollection<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
     constructor(db: Database<T>, collection: K);
-    query(query?: QueryProps<ItemData<T[K]>>): Query<T, 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> {
+export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseCollection<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     constructor(db: AsyncDatabase<T>, collection: K);
-    query(query?: QueryProps<ItemData<T[K]>>): AsyncQuery<T, 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 {};

package/db/Collection.js

@@ -1,11 +1,19 @@
+/** Reference to a collection in a synchronous or asynchronous provider. */
+class BaseCollection {
+    // Implement toString()
+    toString() {
+        return this.collection;
+    }
+}
 /** Reference to a collection in a synchronous provider. */
-export class Collection {
+export class Collection extends BaseCollection {
     constructor(db, collection) {
+        super();
         this.db = db;
         this.collection = collection;
     }
-    query(query) {
-        return this.db.query(this.collection, query);
+    query(filters, sorts, limit) {
+        return this.db.query(this.collection, filters, sorts, limit);
     }
     item(id) {
         return this.db.item(this.collection, id);
@@ -13,18 +21,16 @@ export class Collection {
     add(data) {
         return this.db.provider.addItem(this.collection, data);
     }
-    toString() {
-        return this.collection;
-    }
 }
 /** Reference to a collection in an asynchronous provider. */
-export class AsyncCollection {
+export class AsyncCollection extends BaseCollection {
     constructor(db, collection) {
+        super();
         this.db = db;
         this.collection = collection;
     }
-    query(query) {
-        return this.db.query(this.collection, query);
+    query(filters, sorts, limit) {
+        return this.db.query(this.collection, filters, sorts, limit);
     }
     item(id) {
         return this.db.item(this.collection, id);
@@ -32,7 +38,4 @@ export class AsyncCollection {
     add(data) {
         return this.db.provider.addItem(this.collection, data);
     }
-    toString() {
-        return this.collection;
-    }
 }

package/db/Database.d.ts

@@ -1,17 +1,18 @@
 import type { Key, Datas } from "../util/data.js";
-import { ItemData } from "../db/Item.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { QueryProps } from "../constraint/QueryConstraints.js";
+import type { FilterList } from "../constraint/FilterConstraint.js";
+import type { SortList } from "../constraint/SortConstraint.js";
+import type { ItemData } from "../db/Item.js";
 import { Item, AsyncItem } from "./Item.js";
 import { Query, AsyncQuery } from "./Query.js";
-import { AsyncCollection, Collection } from "./Collection.js";
+import { Collection, AsyncCollection } from "./Collection.js";
 /** Database with a synchronous or asynchronous provider. */
 interface AbstractDatabase<T extends Datas> {
     readonly provider: Provider<T> | AsyncProvider<T>;
     /** Create a query on a collection in this database. */
     collection<K extends Key<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
     /** Create a query on a collection in this database. */
-    query<K extends Key<T>>(collection: K, query?: QueryProps<ItemData<T[K]>>): Query<T, K> | AsyncQuery<T, K>;
+    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
     /** Reference an item in a collection in this database. */
     item<K extends Key<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
 }
@@ -20,7 +21,7 @@ export declare class Database<T extends Datas = Datas> implements AbstractDataba
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
     collection<K extends Key<T>>(collection: K): Collection<T, K>;
-    query<K extends Key<T>>(collection: K, query?: QueryProps<ItemData<T[K]>>): Query<T, K>;
+    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item<K extends Key<T>>(collection: K, id: string): Item<T, K>;
 }
 /** Database with a synchronous provider. */
@@ -28,7 +29,7 @@ export declare class AsyncDatabase<T extends Datas = Datas> implements AbstractD
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
     collection<K extends Key<T>>(collection: K): AsyncCollection<T, K>;
-    query<K extends Key<T>>(collection: K, query?: QueryProps<ItemData<T[K]>>): AsyncQuery<T, K>;
+    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item<K extends Key<T>>(collection: K, id: string): AsyncItem<T, K>;
 }
 export {};

package/db/Database.js

@@ -1,6 +1,6 @@
 import { Item, AsyncItem } from "./Item.js";
 import { Query, AsyncQuery } from "./Query.js";
-import { AsyncCollection, Collection } from "./Collection.js";
+import { Collection, AsyncCollection } from "./Collection.js";
 /** Database with a synchronous provider. */
 export class Database {
     constructor(provider) {
@@ -9,8 +9,8 @@ export class Database {
     collection(collection) {
         return new Collection(this, collection);
     }
-    query(collection, query) {
-        return new Query(this, collection, query);
+    query(collection, filters, sorts, limit) {
+        return new Query(this, collection, filters, sorts, limit);
     }
     item(collection, id) {
         return new Item(this, collection, id);
@@ -24,8 +24,8 @@ export class AsyncDatabase {
     collection(collection) {
         return new AsyncCollection(this, collection);
     }
-    query(collection, query) {
-        return new AsyncQuery(this, collection, query);
+    query(collection, filters, sorts, limit) {
+        return new AsyncQuery(this, collection, filters, sorts, limit);
     }
     item(collection, id) {
         return new AsyncItem(this, collection, id);

package/db/Item.d.ts

@@ -7,6 +7,7 @@ import { DataUpdate, PropUpdates } 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";
+import type { Changes } from "./Changes.js";
 /** Item data with a string ID that uniquely identifies it. */
 export declare type ItemData<T extends Data = Data> = T & {
     id: string;
@@ -18,21 +19,22 @@ export declare type ItemArray<T extends Data = Data> = ImmutableArray<ItemData<T
 /** A set of query constraints for item data. */
 export declare type ItemConstraints<T extends Data = Data> = QueryConstraints<ItemData<T>>;
 /** Reference to an item in a synchronous or asynchronous provider. */
-interface ItemInterface<T extends Datas = Datas, K extends Key<T> = Key<T>> extends Observable<ItemValue<T[K]>> {
-    readonly collection: K;
-    readonly id: string;
+declare abstract class BaseItem<T extends Datas = Datas, K extends Key<T> = Key<T>> implements Observable<ItemValue<T[K]>> {
+    abstract readonly db: Database<T> | AsyncDatabase<T>;
+    abstract readonly collection: K;
+    abstract readonly id: string;
     /** Get an 'optional' reference to this item (uses a `ModelQuery` with an `id` filter). */
-    optional: Query<T, K> | AsyncQuery<T, K>;
+    abstract optional: Query<T, K> | AsyncQuery<T, K>;
     /**
      * Does this item exist?
      * @return `true` if an item exists or `false` otherwise (possibly promised).
      */
-    exists: boolean | PromiseLike<boolean>;
+    abstract exists: boolean | PromiseLike<boolean>;
     /**
      * Get the optional data of this item.
      * @return Document's data, or `null` if the item doesn't exist (possibly promised).
      */
-    value: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract value: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
     /**
      * Get the data of this item.
      * - Useful for destructuring, e.g. `{ name, title } = await itemThatMustExist.asyncData`
@@ -40,7 +42,7 @@ interface ItemInterface<T extends Datas = Datas, K extends Key<T> = Key<T>> exte
      * @return Document's data (possibly promised).
      * @throws RequiredError if the item does not exist.
      */
-    data: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
+    abstract data: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
     /**
      * Subscribe to the result of this item (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
@@ -50,15 +52,21 @@ interface ItemInterface<T extends Datas = Datas, K extends Key<T> = Key<T>> exte
      */
     subscribe(next: PartialObserver<ItemValue<T[K]>> | Dispatch<[ItemValue<T[K]>]>): Unsubscribe;
     /** Set the complete data of this item. */
-    set(data: T[K]): void | PromiseLike<void>;
+    abstract set(data: T[K]): void | PromiseLike<void>;
+    /** Get a set change for this item. */
+    getSet(data: T[K]): Changes<T>;
     /** Update this item. */
-    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void | PromiseLike<void>;
+    abstract update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void | PromiseLike<void>;
+    /** Get an update change for this item. */
+    getUpdate(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): Changes<T>;
     /** Delete this item. */
-    delete(): void | PromiseLike<void>;
+    abstract delete(): void | PromiseLike<void>;
+    /** Get a delete change for this item. */
+    getDelete(): Changes<T>;
     toString(): `${K}/${string}`;
 }
 /** Reference to an item in a synchronous provider. */
-export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> implements ItemInterface<T, K> {
+export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseItem<T, K> {
     readonly db: Database<T>;
     readonly collection: K;
     readonly id: string;
@@ -67,14 +75,12 @@ export declare class Item<T extends Datas = Datas, K extends Key<T> = Key<T>> im
     get exists(): boolean;
     get value(): ItemValue<T[K]>;
     get data(): ItemData<T[K]>;
-    subscribe(next: PartialObserver<ItemValue<T[K]>> | Dispatch<[ItemValue<T[K]>]>): Unsubscribe;
     set(data: T[K]): void;
     update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void;
     delete(): void;
-    toString(): `${K}/${string}`;
 }
 /** Reference to an item in an asynchronous provider. */
-export declare class AsyncItem<T extends Datas = Datas, K extends Key<T> = Key<T>> implements ItemInterface<T, K> {
+export declare class AsyncItem<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseItem<T, K> {
     readonly db: AsyncDatabase<T>;
     readonly collection: K;
     readonly id: string;
@@ -83,11 +89,9 @@ export declare class AsyncItem<T extends Datas = Datas, K extends Key<T> = Key<T
     get exists(): Promise<boolean>;
     get value(): Promise<ItemValue<T[K]>>;
     get data(): Promise<ItemData<T[K]>>;
-    subscribe(next: PartialObserver<ItemValue<T[K]>> | Dispatch<[ItemValue<T[K]>]>): Unsubscribe;
     set(data: T[K]): Promise<void>;
     update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): Promise<void>;
     delete(): Promise<void>;
-    toString(): `${K}/${string}`;
 }
 /** Get the ID from item data. */
 export declare const getID: <T extends Data>({ id }: ItemData<T>) => string;

package/db/Item.js

@@ -1,14 +1,46 @@
 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 {
+    /**
+     * Subscribe to the result of this item (indefinitely).
+     * - `next()` is called once with the initial result, and again any time the result changes.
+     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
+     * @return Function that ends the subscription.
+     */
+    subscribe(next) {
+        return this.db.provider.subscribeItem(this.collection, this.id, typeof next === "function" ? { next } : next);
+    }
+    /** Get a set change for this item. */
+    getSet(data) {
+        return { [this.toString()]: data };
+    }
+    /** Get an update change for this item. */
+    getUpdate(updates) {
+        return { [this.toString()]: updates instanceof DataUpdate ? updates : new DataUpdate(updates) };
+    }
+    /** Get a delete change for this item. */
+    getDelete() {
+        return { [this.toString()]: null };
+    }
+    // Implement toString()
+    toString() {
+        return `${this.collection}/${this.id}`;
+    }
+}
 /** Reference to an item in a synchronous provider. */
-export class Item {
+export class Item extends BaseItem {
     constructor(db, collection, id) {
+        super();
         this.db = db;
         this.collection = collection;
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, { filter: { id: this.id }, limit: 1 });
+        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
     }
     get exists() {
         return !!this.db.provider.getItem(this.collection, this.id);
@@ -19,31 +51,26 @@ export class Item {
     get data() {
         return getData(this.value);
     }
-    subscribe(next) {
-        return this.db.provider.subscribeItem(this.collection, this.id, typeof next === "function" ? { next } : next);
-    }
     set(data) {
         return this.db.provider.setItem(this.collection, this.id, data);
     }
     update(updates) {
-        return this.db.provider.updateItem(this.collection, this.id, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+        return this.db.provider.updateItem(this.collection, this.id, isTransformable(updates) ? updates : new DataUpdate(updates));
     }
     delete() {
         return this.db.provider.deleteItem(this.collection, this.id);
     }
-    toString() {
-        return `${this.collection}/${this.id}`;
-    }
 }
 /** Reference to an item in an asynchronous provider. */
-export class AsyncItem {
+export class AsyncItem extends BaseItem {
     constructor(provider, collection, id) {
+        super();
         this.db = provider;
         this.collection = collection;
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, { filter: { id: this.id }, limit: 1 });
+        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
     }
     get exists() {
         return this.db.provider.getItem(this.collection, this.id).then(Boolean);
@@ -54,21 +81,15 @@ export class AsyncItem {
     get data() {
         return this.value.then(getData);
     }
-    subscribe(next) {
-        return this.db.provider.subscribeItem(this.collection, this.id, typeof next === "function" ? { next } : next);
-    }
     set(data) {
         return this.db.provider.setItem(this.collection, this.id, data);
     }
     update(updates) {
-        return this.db.provider.updateItem(this.collection, this.id, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+        return this.db.provider.updateItem(this.collection, this.id, isTransformable(updates) ? updates : new DataUpdate(updates));
     }
     delete() {
         return this.db.provider.deleteItem(this.collection, this.id);
     }
-    toString() {
-        return `${this.collection}/${this.id}`;
-    }
 }
 /** Get the ID from item data. */
 export const getID = ({ id }) => id;

package/db/Query.d.ts

@@ -2,48 +2,51 @@ import type { Dispatch } from "../util/function.js";
 import type { Key, Datas } from "../util/data.js";
 import type { PartialObserver } from "../observe/Observer.js";
 import type { Observable, Unsubscribe } from "../observe/Observable.js";
-import { QueryConstraints, QueryProps } from "../constraint/QueryConstraints.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. */
-interface QueryInterface<T extends Datas = Datas, K extends Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>>, Observable<ItemArray<T[K]>> {
-    readonly collection: K;
+declare abstract class BaseQuery<T extends Datas = Datas, K extends Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>> implements Observable<ItemArray<T[K]>> {
+    abstract readonly db: Database<T> | AsyncDatabase<T>;
+    abstract readonly collection: K;
     /**
      * Get array of entities for this query.
      * @return Array of entities.
      */
-    value: ItemArray<T[K]> | PromiseLike<ItemArray<T[K]>>;
+    abstract value: ItemArray<T[K]> | PromiseLike<ItemArray<T[K]>>;
     /**
      * Count the number of results of this set of items.
      * @return Number of items matching the query (possibly promised).
      */
-    count: number | PromiseLike<number>;
+    abstract count: number | PromiseLike<number>;
     /**
      * Does at least one item exist for this query?
      * @return `true` if a item exists or `false` otherwise (possibly promised).
      */
-    exists: boolean | PromiseLike<boolean>;
+    abstract exists: boolean | PromiseLike<boolean>;
     /**
      * Get the first item matched by this query or `null` if this query has no results.
      * @throws RequiredError if there were no results for this query.
      */
-    firstValue: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract firstValue: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
     /**
      * Get the first item matched by this query.
      * @throws RequiredError if there were no results for this query.
      */
-    firstData: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
+    abstract firstData: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
     /**
      * Get the last item matched by this query or `null` if this query has no results.
      * @throws RequiredError if there were no results for this query.
      */
-    lastValue: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract lastValue: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
     /**
      * Get the last item matched by this query.
      * @throws RequiredError if there were no results for this query.
      */
-    lastData: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
+    abstract lastData: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
     /**
      * Subscribe to all matching items.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -58,25 +61,26 @@ interface QueryInterface<T extends Datas = Datas, K extends Key<T> = Key<T>> ext
      * @param data Complete data to set the item to.
      * @return Nothing (possibly promised).
      */
-    set(data: T[K]): number | PromiseLike<number>;
+    abstract set(data: T[K]): number | PromiseLike<number>;
     /**
      * Update all matching items with the same partial value.
      *
      * @param updates `Update` instance or set of updates to apply to every matching item.
      * @return Nothing (possibly promised).
      */
-    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): number | PromiseLike<number>;
+    abstract update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): number | PromiseLike<number>;
     /**
      * Delete all matching items.
      * @return Nothing (possibly promised).
      */
-    delete(): number | PromiseLike<number>;
+    abstract delete(): number | PromiseLike<number>;
+    toString(): string;
 }
 /** Reference to a set of items in a provider. */
-export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>> implements QueryInterface<T, K> {
+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, props?: QueryProps<ItemData<T[K]>>);
+    constructor(db: Database<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     get value(): ItemArray<T[K]>;
     get count(): number;
     get exists(): boolean;
@@ -84,18 +88,15 @@ export declare class Query<T extends Datas = Datas, K extends Key<T> = Key<T>> e
     get firstData(): ItemData<T[K]>;
     get lastValue(): ItemValue<T[K]>;
     get lastData(): ItemData<T[K]>;
-    subscribe(next: PartialObserver<ItemArray<T[K]>> | Dispatch<[ItemArray<T[K]>]>): Unsubscribe;
     set(data: T[K]): number;
     update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): number;
     delete(): number;
-    toString(): string;
 }
 /** Reference to a set of items in a provider. */
-export declare class AsyncQuery<T extends Datas = Datas, K extends Key<T> = Key<T>> extends QueryConstraints<ItemData<T[K]>> implements QueryInterface<T, K> {
+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, props?: QueryProps<ItemData<T[K]>>);
-    closed?: boolean;
+    constructor(db: AsyncDatabase<T>, collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null);
     get value(): Promise<ItemArray<T[K]>>;
     get count(): Promise<number>;
     get exists(): Promise<boolean>;
@@ -103,10 +104,8 @@ export declare class AsyncQuery<T extends Datas = Datas, K extends Key<T> = Key<
     get firstData(): Promise<ItemData<T[K]>>;
     get lastValue(): Promise<ItemValue<T[K]>>;
     get lastData(): Promise<ItemData<T[K]>>;
-    subscribe(next: PartialObserver<ItemArray<T[K]>> | Dispatch<[ItemArray<T[K]>]>): Unsubscribe;
     set(data: T[K]): Promise<number>;
     update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): PromiseLike<number>;
     delete(): PromiseLike<number>;
-    toString(): string;
 }
 export {};

package/db/Query.js

@@ -2,10 +2,27 @@ import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem }
 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 {
+    /**
+     * Subscribe to all matching items.
+     * - `next()` is called once with the initial results, and again any time the results change.
+     *
+     * @param next Observer with `next`, `error`, or `complete` methods or a `next()` dispatcher.
+     * @return Function that ends the subscription.
+     */
+    subscribe(next) {
+        return this.db.provider.subscribeQuery(this.collection, this, typeof next === "function" ? { next } : next);
+    }
+    // Override to include the collection name.
+    toString() {
+        return `${this.collection}?${super.toString()}`;
+    }
+}
 /** Reference to a set of items in a provider. */
-export class Query extends QueryConstraints {
-    constructor(db, collection, props) {
-        super(props);
+export class Query extends BaseQuery {
+    constructor(db, collection, filters, sorts, limit) {
+        super(filters, sorts, limit);
         this.db = db;
         this.collection = collection;
     }
@@ -30,9 +47,6 @@ export class Query extends QueryConstraints {
     get lastData() {
         return getLastItem(this.value);
     }
-    subscribe(next) {
-        return this.db.provider.subscribeQuery(this.collection, this, typeof next === "function" ? { next } : next);
-    }
     set(data) {
         return this.db.provider.setQuery(this.collection, this, data);
     }
@@ -42,14 +56,11 @@ export class Query extends QueryConstraints {
     delete() {
         return this.db.provider.deleteQuery(this.collection, this);
     }
-    toString() {
-        return `${this.collection}?${super.toString()}`;
-    }
 }
 /** Reference to a set of items in a provider. */
-export class AsyncQuery extends QueryConstraints {
-    constructor(db, collection, props) {
-        super(props);
+export class AsyncQuery extends BaseQuery {
+    constructor(db, collection, filters, sorts, limit) {
+        super(filters, sorts, limit);
         this.db = db;
         this.collection = collection;
     }
@@ -74,9 +85,6 @@ export class AsyncQuery extends QueryConstraints {
     get lastData() {
         return this.value.then(getLastItem);
     }
-    subscribe(next) {
-        return this.db.provider.subscribeQuery(this.collection, this, typeof next === "function" ? { next } : next);
-    }
     set(data) {
         return this.db.provider.setQuery(this.collection, this, data);
     }
@@ -86,7 +94,4 @@ export class AsyncQuery extends QueryConstraints {
     delete() {
         return this.db.provider.deleteQuery(this.collection, this);
     }
-    toString() {
-        return `${this.collection}?${super.toString()}`;
-    }
 }

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.73.1",
+	"version": "1.74.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/provider/BatchProvider.js

@@ -72,4 +72,4 @@ export class BatchProvider extends AsyncThroughProvider {
     }
 }
 const _getItemKey = (collection, id) => `${collection}/${id}`;
-const _getQueryKey = (collection, constraints) => `${collection}:${QueryConstraints.prototype.toString.call(constraints)}`;
+const _getQueryKey = (collection, constraints) => `${collection}?${QueryConstraints.prototype.toString.call(constraints)}`;

package/provider/DebugProvider.js

@@ -238,4 +238,4 @@ export class AsyncDebugProvider extends AbstractDebugProvider {
     }
 }
 const _getItemKey = (collection, id) => `${collection}/${id}`;
-const _getQueryKey = (collection, constraints) => `${collection}:${QueryConstraints.prototype.toString.call(constraints)}`;
+const _getQueryKey = (collection, constraints) => `${collection}?${QueryConstraints.prototype.toString.call(constraints)}`;

package/provider/MemoryProvider.js

@@ -223,4 +223,4 @@ export class MemoryTable extends Subject {
 // When we're writing data, if there's no limit set the results don't need to be sorted (for performance).
 const _getWriteConstraints = (constraints) => (constraints.limit ? constraints : constraints.filters);
 // Queries that have no limit don't care about sorting either.
-const _getQueryKey = (query) => (query.limit ? `{filters:${query.filters.toString()}}` : QueryConstraints.prototype.toString.call(query));
+const _getQueryKey = (query) => (query.limit ? `"filters":${query.filters.toString()}}` : QueryConstraints.prototype.toString.call(query));

package/util/index.d.ts

@@ -28,6 +28,7 @@ export * from "./random.js";
 export * from "./regexp.js";
 export * from "./serialise.js";
 export * from "./sort.js";
+export * from "./source.js";
 export * from "./string.js";
 export * from "./template.js";
 export * from "./timeout.js";

package/util/index.js

@@ -28,6 +28,7 @@ export * from "./random.js";
 export * from "./regexp.js";
 export * from "./serialise.js";
 export * from "./sort.js";
+export * from "./source.js";
 export * from "./string.js";
 export * from "./template.js";
 export * from "./timeout.js";

package/util/transform.d.ts

@@ -6,7 +6,7 @@ import type { ArrayType, ImmutableArray } from "./array.js";
 export interface Transformable<I, O> {
     transform(input: I): O;
 }
-/** Is an unknown value a derivable. */
+/** Is an unknown value a transformable. */
 export declare const isTransformable: <T extends Transformable<unknown, unknown>>(v: unknown) => v is T;
 /** Function that can transform an input value into an output value. */
 export declare type Transform<I, O> = (input: I) => O;

package/util/transform.js

@@ -1,7 +1,7 @@
 import { isFunction } from "./function.js";
 import { getProps, isData } from "./data.js";
 import { getEntries } from "./entry.js";
-/** Is an unknown value a derivable. */
+/** Is an unknown value a transformable. */
 export const isTransformable = (v) => isData(v) && typeof v.transform === "function";
 export function transform(input, transformer) {
     return isFunction(transformer) ? transformer(input) : isTransformable(transformer) ? transformer.transform(input) : transformer;