shelving 1.91.2 → 1.92.0

package/db/Change.d.ts

@@ -1,44 +1,43 @@
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { Updates } from "../update/DataUpdate.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Data } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
-/** Change on a collection. */
-export interface Change {
-    readonly action: string;
-    readonly collection: string;
-}
+import type { Updates } from "../util/update.js";
 /** Add on an item. */
-export interface AddChange<T extends Data> extends Change {
-    readonly action: "ADD";
+export interface AddChange<T extends Data> {
+    readonly action: "add";
+    readonly collection: string;
     readonly data: T;
 }
 /** Set on an item. */
-export interface SetChange<T extends Data = Data> extends Change {
-    readonly action: "SET";
+export interface SetChange<T extends Data> {
+    readonly action: "set";
+    readonly collection: string;
     readonly id: string;
     readonly data: T;
 }
 /** Update change on an item. */
-export interface UpdateChange<T extends Data = Data> extends Change {
-    readonly action: "UPDATE";
+export interface UpdateChange<T extends Data> {
+    readonly action: "update";
+    readonly collection: string;
     readonly id: string;
     readonly updates: Updates<T>;
 }
 /** Delete change on an item. */
-export interface DeleteChange extends Change {
-    readonly action: "DELETE";
+export interface DeleteChange {
+    readonly action: "delete";
+    readonly collection: string;
     readonly id: string;
 }
 /** Set, update, or delete change on an item. */
-export type ItemChange<T extends Data = Data> = SetChange<T> | UpdateChange<T> | DeleteChange;
+export type ItemChange<T extends Data> = SetChange<T> | UpdateChange<T> | DeleteChange;
 /** Array of item changes. */
-export type ItemChanges = ImmutableArray<ItemChange>;
+export type ItemChanges = ImmutableArray<ItemChange<Data>>;
 /** Write change on an item. */
-export type WriteChange<T extends Data = Data> = ItemChange<T> | AddChange<T>;
+export type WriteChange<T extends Data> = ItemChange<T> | AddChange<T>;
 /** Array of write changes. */
-export type WriteChanges = ImmutableArray<WriteChange>;
+export type WriteChanges = ImmutableArray<WriteChange<Data>>;
 /** Apply a set of changes to a synchronous provider. */
-export declare function changeProvider(provider: Provider, ...changes: Nullish<WriteChange>[]): ItemChanges;
+export declare function changeProvider(provider: Provider, ...changes: Nullish<WriteChange<Data>>[]): ItemChanges;
 /** Apply a set of changes to an asynchronous provider. */
-export declare function changeAsyncProvider(provider: AsyncProvider, ...changes: Nullish<WriteChange>[]): Promise<ItemChanges>;
+export declare function changeAsyncProvider(provider: AsyncProvider, ...changes: Nullish<WriteChange<Data>>[]): Promise<ItemChanges>;

package/db/Change.js

@@ -1,34 +1,35 @@
 import { notNullish } from "../util/null.js";
-import { getItemStatement } from "./Item.js";
+import { mapArray, mapItems } from "../util/transform.js";
+import { getItemQuery } from "./ItemReference.js";
 /** Apply a set of changes to a synchronous provider. */
 export function changeProvider(provider, ...changes) {
-    return changes.filter(notNullish).map(_changeItem, provider);
+    return mapArray(changes.filter(notNullish), _changeItem, provider);
 }
-function _changeItem(change) {
+function _changeItem(change, provider) {
     const { action, collection } = change;
-    if (action === "ADD")
-        return { action: "SET", collection, id: this.addItem(collection, change.data), data: change.data };
-    else if (action === "SET")
-        this.setItem(collection, change.id, change.data);
-    else if (action === "UPDATE")
-        this.updateQuery(collection, getItemStatement(change.id), change.updates);
-    else if (action === "DELETE")
-        this.deleteItem(collection, change.id);
+    if (action === "add")
+        return { action: "set", collection, id: provider.addItem(collection, change.data), data: change.data };
+    else if (action === "set")
+        provider.setItem(collection, change.id, change.data);
+    else if (action === "update")
+        provider.updateQuery(collection, getItemQuery(change.id), change.updates);
+    else if (action === "delete")
+        provider.deleteItem(collection, change.id);
     return change;
 }
 /** Apply a set of changes to an asynchronous provider. */
 export function changeAsyncProvider(provider, ...changes) {
-    return Promise.all(changes.filter(notNullish).map(_changeAsyncItem, provider));
+    return Promise.all(mapItems(changes.filter(notNullish), _changeAsyncItem, provider));
 }
-async function _changeAsyncItem(change) {
+async function _changeAsyncItem(change, provider) {
     const { collection, action } = change;
-    if (action === "ADD")
-        return { action: "SET", collection, id: await this.addItem(collection, change.data), data: change.data };
-    else if (action === "SET")
-        await this.setItem(collection, change.id, change.data);
-    else if (action === "UPDATE")
-        await this.updateQuery(collection, getItemStatement(change.id), change.updates);
-    else if (action === "DELETE")
-        await this.deleteItem(collection, change.id);
+    if (action === "add")
+        return { action: "set", collection, id: await provider.addItem(collection, change.data), data: change.data };
+    else if (action === "set")
+        await provider.setItem(collection, change.id, change.data);
+    else if (action === "update")
+        await provider.updateQuery(collection, getItemQuery(change.id), change.updates);
+    else if (action === "delete")
+        await provider.deleteItem(collection, change.id);
     return change;
 }

package/db/CollectionReference.d.ts

@@ -0,0 +1,103 @@
+import type { AddChange, DeleteChange, SetChange, UpdateChange } from "./Change.js";
+import type { ItemArray, ItemData, ItemQuery, ItemValue } from "./ItemReference.js";
+import type { AsyncProvider, Provider } from "../provider/Provider.js";
+import type { Data } from "../util/data.js";
+import type { Updates } from "../util/update.js";
+import { AsyncItemReference, ItemReference } from "./ItemReference.js";
+import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
+/** Reference to a collection in a synchronous or asynchronous provider. */
+declare abstract class AbstractCollectionReference<T extends Data = Data> {
+    abstract readonly provider: Provider | AsyncProvider;
+    readonly collection: string;
+    constructor(collection: string);
+    /**
+     * Get array of entities for this query.
+     * @return Array of entities.
+     */
+    abstract items: ItemArray<T> | PromiseLike<ItemArray<T>>;
+    /**
+     * Count the number of results of this set of items.
+     * @return Number of items matching the query (possibly promised).
+     */
+    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).
+     */
+    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.
+     */
+    abstract first: ItemValue<T> | PromiseLike<ItemValue<T>>;
+    /**
+     * 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.
+     */
+    abstract last: ItemValue<T> | PromiseLike<ItemValue<T>>;
+    /**
+     * Get the first item matched by this query.
+     * @throws RequiredError if there were no results for this query.
+     */
+    abstract data: ItemData<T> | PromiseLike<ItemData<T>>;
+    /** Create a query on this item's collection. */
+    abstract query(query?: ItemQuery<T>): QueryReference<T> | AsyncQueryReference<T>;
+    /** Create a query on this item's collection. */
+    abstract item(id: string): ItemReference<T> | AsyncItemReference<T>;
+    /** Get an item from this collection. */
+    abstract get(id: string): ItemValue<T> | Promise<ItemValue<T>>;
+    /** Add an item to this collection. */
+    abstract add(data: T): string | Promise<string>;
+    /** Set a document in this collection. */
+    abstract set(id: string, data: T): void | Promise<void>;
+    /** Update a document in this collection. */
+    abstract update(id: string, updates: Updates<T>): void | Promise<void>;
+    /** Delete a document in this collection. */
+    abstract delete(id: string): void | Promise<void>;
+    /** Get an add change for this collection. */
+    getAdd(data: T): AddChange<T>;
+    /** Get a set change for this collection. */
+    getSet(id: string, data: T): SetChange<T>;
+    /** Get an update change for this collection. */
+    getUpdate(id: string, updates: Updates<T>): UpdateChange<T>;
+    /** Get a delete change for this collection. */
+    getDelete(id: string): DeleteChange;
+    toString(): string;
+}
+/** Reference to a collection in a synchronous provider. */
+export declare class CollectionReference<T extends Data = Data> extends AbstractCollectionReference<T> {
+    readonly provider: Provider;
+    constructor(provider: Provider, collection: string);
+    get items(): ItemArray<T>;
+    get count(): number;
+    get exists(): boolean;
+    get first(): ItemValue<T>;
+    get last(): ItemValue<T>;
+    get data(): ItemData<T>;
+    query(constraints?: ItemQuery<T>): QueryReference<T>;
+    item(id: string): ItemReference<T>;
+    get(id: string): ItemValue<T>;
+    add(data: T): string;
+    set(id: string, data: T): void;
+    update(id: string, updates: Updates<T>): void;
+    delete(id: string): void;
+}
+/** Reference to a collection in an asynchronous provider. */
+export declare class AsyncCollectionReference<T extends Data = Data> extends AbstractCollectionReference<T> {
+    readonly provider: AsyncProvider;
+    constructor(provider: AsyncProvider, collection: string);
+    get items(): Promise<ItemArray<T>>;
+    get count(): Promise<number>;
+    get exists(): Promise<boolean>;
+    get first(): Promise<ItemValue<T>>;
+    get last(): Promise<ItemValue<T>>;
+    get data(): Promise<ItemData<T>>;
+    query(query?: ItemQuery<T>): AsyncQueryReference<T>;
+    item(id: string): AsyncItemReference<T>;
+    get(id: string): Promise<ItemValue<T>>;
+    add(data: T): Promise<string>;
+    set(id: string, data: T): Promise<void>;
+    update(id: string, updates: Updates<T>): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+export {};

package/db/CollectionReference.js

@@ -0,0 +1,127 @@
+import { countArray, getFirstItem, getOptionalFirstItem, getOptionalLastItem, isArrayLength } from "../util/array.js";
+import { AsyncItemReference, ItemReference } from "./ItemReference.js";
+import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
+/** Reference to a collection in a synchronous or asynchronous provider. */
+class AbstractCollectionReference {
+    constructor(collection) {
+        this.collection = collection;
+    }
+    /** Get an add change for this collection. */
+    getAdd(data) {
+        return { action: "add", collection: this.collection, data };
+    }
+    /** Get a set change for this collection. */
+    getSet(id, data) {
+        return { action: "set", collection: this.collection, id, data };
+    }
+    /** Get an update change for this collection. */
+    getUpdate(id, updates) {
+        return { action: "update", collection: this.collection, id, updates };
+    }
+    /** Get a delete change for this collection. */
+    getDelete(id) {
+        return { action: "delete", collection: this.collection, id };
+    }
+    // Implement toString()
+    toString() {
+        return this.collection;
+    }
+}
+/** Reference to a collection in a synchronous provider. */
+export class CollectionReference extends AbstractCollectionReference {
+    constructor(provider, collection) {
+        super(collection);
+        this.provider = provider;
+    }
+    get items() {
+        return _getItemArray(this);
+    }
+    get count() {
+        return this.items.length;
+    }
+    get exists() {
+        return !!_getSingleItemArray(this).length;
+    }
+    get first() {
+        return getOptionalFirstItem(_getSingleItemArray(this));
+    }
+    get last() {
+        return getOptionalLastItem(this.items);
+    }
+    get data() {
+        return getFirstItem(_getSingleItemArray(this));
+    }
+    query(constraints) {
+        return new QueryReference(this.provider, this.collection, constraints);
+    }
+    item(id) {
+        return new ItemReference(this.provider, this.collection, id);
+    }
+    get(id) {
+        return this.provider.getItem(this.collection, id);
+    }
+    add(data) {
+        return this.provider.addItem(this.collection, data);
+    }
+    set(id, data) {
+        return this.provider.setItem(this.collection, id, data);
+    }
+    update(id, updates) {
+        return this.provider.updateItem(this.collection, id, updates);
+    }
+    delete(id) {
+        return this.provider.deleteItem(this.collection, id);
+    }
+}
+/** Reference to a collection in an asynchronous provider. */
+export class AsyncCollectionReference extends AbstractCollectionReference {
+    constructor(provider, collection) {
+        super(collection);
+        this.provider = provider;
+    }
+    get items() {
+        return _getItemArray(this);
+    }
+    get count() {
+        return this.items.then(countArray);
+    }
+    get exists() {
+        return _getSingleItemArray(this).then(isArrayLength);
+    }
+    get first() {
+        return _getSingleItemArray(this).then(getOptionalFirstItem);
+    }
+    get last() {
+        return this.items.then(getOptionalLastItem);
+    }
+    get data() {
+        return _getSingleItemArray(this).then(getFirstItem);
+    }
+    query(query) {
+        return new AsyncQueryReference(this.provider, this.collection, query);
+    }
+    item(id) {
+        return new AsyncItemReference(this.provider, this.collection, id);
+    }
+    get(id) {
+        return this.provider.getItem(this.collection, id);
+    }
+    add(data) {
+        return this.provider.addItem(this.collection, data);
+    }
+    set(id, data) {
+        return this.provider.setItem(this.collection, id, data);
+    }
+    update(id, updates) {
+        return this.provider.updateItem(this.collection, id, updates);
+    }
+    delete(id) {
+        return this.provider.deleteItem(this.collection, id);
+    }
+}
+function _getItemArray({ provider, collection }) {
+    return provider.getQuery(collection, {});
+}
+function _getSingleItemArray({ provider, collection }) {
+    return provider.getQuery(collection, { $limit: 1 });
+}

package/db/Database.d.ts

@@ -1,25 +1,23 @@
 import type { AddChange, DeleteChange, ItemChanges, SetChange, UpdateChange, WriteChange } from "./Change.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 { ItemQuery, ItemValue } from "./ItemReference.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { Updates } from "../update/DataUpdate.js";
-import type { DataKey, Datas } from "../util/data.js";
+import type { Data, DataKey, Datas } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
-import { AsyncCollection, Collection } from "./Collection.js";
-import { AsyncItem, Item } from "./Item.js";
-import { AsyncQuery, Query } from "./Query.js";
+import type { Updates } from "../util/update.js";
+import { AsyncCollectionReference, CollectionReference } from "./CollectionReference.js";
+import { AsyncItemReference, ItemReference } from "./ItemReference.js";
+import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
 /** Database with a synchronous or asynchronous provider. */
-declare abstract class BaseDatabase<T extends Datas> {
+declare abstract class AbstractDatabase<T extends Datas> {
     abstract readonly provider: Provider | AsyncProvider;
     /** Create a query on a collection in this database. */
-    abstract collection<K extends DataKey<T>>(collection: K): Collection<T[K]> | AsyncCollection<T[K]>;
+    abstract collection<K extends DataKey<T>>(collection: K): CollectionReference<T[K]> | AsyncCollectionReference<T[K]>;
     /** Create a query on a collection in this database. */
-    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]>;
+    abstract query<K extends DataKey<T>>(collection: K, query?: ItemQuery<T>): QueryReference<T[K]> | AsyncQueryReference<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]>;
+    abstract item<K extends DataKey<T>>(collection: K, id: string): ItemReference<T[K]> | AsyncItemReference<T[K]>;
     /** Run a set of changes in this database. */
-    abstract change(...changes: Nullish<WriteChange>[]): ItemChanges | Promise<ItemChanges>;
+    abstract change(...changes: Nullish<WriteChange<Data>>[]): ItemChanges | Promise<ItemChanges>;
     /** Get a document from a collection in this database. */
     abstract get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
     /** Add a document to a collection in this database. */
@@ -40,13 +38,13 @@ declare abstract class BaseDatabase<T extends Datas> {
     getDelete<K extends DataKey<T>>(collection: K, id: string): DeleteChange;
 }
 /** Database with a synchronous provider. */
-export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
+export declare class Database<T extends Datas = Datas> extends AbstractDatabase<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?: 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;
+    collection<K extends DataKey<T>>(collection: K): CollectionReference<T[K]>;
+    query<K extends DataKey<T>>(collection: K, query?: ItemQuery<T>): QueryReference<T[K]>;
+    item<K extends DataKey<T>>(collection: K, id: string): ItemReference<T[K]>;
+    change(...changes: Nullish<WriteChange<Data>>[]): ItemChanges;
     get<K extends DataKey<T>>(collection: K, id: string): ItemValue<T[K]>;
     add<K extends DataKey<T>>(collection: K, data: T[K]): string;
     set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
@@ -54,13 +52,13 @@ export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
     delete<K extends DataKey<T>>(collection: K, id: string): void;
 }
 /** Database with a synchronous provider. */
-export declare class AsyncDatabase<T extends Datas = Datas> extends BaseDatabase<T> {
+export declare class AsyncDatabase<T extends Datas = Datas> extends AbstractDatabase<T> {
     readonly provider: AsyncProvider;
     constructor(provider: AsyncProvider);
-    collection<K extends DataKey<T>>(collection: K): AsyncCollection<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>;
+    collection<K extends DataKey<T>>(collection: K): AsyncCollectionReference<T[K]>;
+    query<K extends DataKey<T>>(collection: K, query?: ItemQuery<T>): AsyncQueryReference<T[K]>;
+    item<K extends DataKey<T>>(collection: K, id: string): AsyncItemReference<T[K]>;
+    change(...changes: Nullish<WriteChange<Data>>[]): Promise<ItemChanges>;
     get<K extends DataKey<T>>(collection: K, id: string): Promise<ItemValue<T[K]>>;
     add<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
     set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;

package/db/Database.js

@@ -1,40 +1,40 @@
 import { changeAsyncProvider, changeProvider } from "./Change.js";
-import { AsyncCollection, Collection } from "./Collection.js";
-import { AsyncItem, Item } from "./Item.js";
-import { AsyncQuery, Query } from "./Query.js";
+import { AsyncCollectionReference, CollectionReference } from "./CollectionReference.js";
+import { AsyncItemReference, ItemReference } from "./ItemReference.js";
+import { AsyncQueryReference, QueryReference } from "./QueryReference.js";
 /** Database with a synchronous or asynchronous provider. */
-class BaseDatabase {
+class AbstractDatabase {
     /** Get an add change for a collection in this database. */
     getAdd(collection, data) {
-        return { action: "ADD", collection, data };
+        return { action: "add", collection, data };
     }
     /** Get a set change for a collection in this database. */
     getSet(collection, id, data) {
-        return { action: "SET", collection, id, data };
+        return { action: "set", collection, id, data };
     }
     /** Get an update change for a collection in this database. */
     getUpdate(collection, id, updates) {
-        return { action: "UPDATE", collection, id, updates };
+        return { action: "update", collection, id, updates };
     }
     /** Get a delete change for a collection in this database. */
     getDelete(collection, id) {
-        return { action: "DELETE", collection, id };
+        return { action: "delete", collection, id };
     }
 }
 /** Database with a synchronous provider. */
-export class Database extends BaseDatabase {
+export class Database extends AbstractDatabase {
     constructor(provider) {
         super();
         this.provider = provider;
     }
     collection(collection) {
-        return new Collection(this.provider, collection);
+        return new CollectionReference(this.provider, collection);
     }
-    query(collection, filters, sorts, limit) {
-        return new Query(this.provider, collection, filters, sorts, limit);
+    query(collection, query) {
+        return new QueryReference(this.provider, collection, query);
     }
     item(collection, id) {
-        return new Item(this.provider, collection, id);
+        return new ItemReference(this.provider, collection, id);
     }
     change(...changes) {
         return changeProvider(this.provider, ...changes);
@@ -56,19 +56,19 @@ export class Database extends BaseDatabase {
     }
 }
 /** Database with a synchronous provider. */
-export class AsyncDatabase extends BaseDatabase {
+export class AsyncDatabase extends AbstractDatabase {
     constructor(provider) {
         super();
         this.provider = provider;
     }
     collection(collection) {
-        return new AsyncCollection(this.provider, collection);
+        return new AsyncCollectionReference(this.provider, collection);
     }
-    query(collection, filters, sorts, limit) {
-        return new AsyncQuery(this.provider, collection, filters, sorts, limit);
+    query(collection, query) {
+        return new AsyncQueryReference(this.provider, collection, query);
     }
     item(collection, id) {
-        return new AsyncItem(this.provider, collection, id);
+        return new AsyncItemReference(this.provider, collection, id);
     }
     change(...changes) {
         return changeAsyncProvider(this.provider, ...changes);

package/db/{Item.d.ts → ItemReference.d.ts}

@@ -1,10 +1,10 @@
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
-import type { Updates } from "../update/DataUpdate.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Data } from "../util/data.js";
 import type { Dispatch, Handler, Stop } from "../util/function.js";
-import { Statement } from "../constraint/Statement.js";
+import type { Query } from "../util/query.js";
+import type { Updates } from "../util/update.js";
 /** Item data with a string ID that uniquely identifies it. */
 export type ItemData<T extends Data = Data> = T & {
     id: string;
@@ -18,14 +18,17 @@ 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 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>>;
+export type ItemQuery<T extends Data = Data> = Query<ItemData<T>>;
+/** Get query that targets a single database item by its ID. */
+export declare const getItemQuery: (id: string) => Query<{
+    id: string;
+}>;
 /** Reference to an item in a synchronous or asynchronous database. */
-declare abstract class BaseItem<T extends Data = Data> implements AsyncIterable<ItemValue<T>> {
+declare abstract class AbstractItemReference<T extends Data = Data> implements AsyncIterable<ItemValue<T>> {
     abstract readonly provider: Provider | AsyncProvider;
-    abstract readonly collection: string;
-    abstract readonly id: string;
+    readonly collection: string;
+    readonly id: string;
+    constructor(collection: string, id: string);
     /**
      * Does this item exist?
      * @return `true` if an item exists or `false` otherwise (possibly promised).
@@ -62,10 +65,8 @@ declare abstract class BaseItem<T extends Data = Data> implements AsyncIterable<
     [Symbol.asyncIterator](): AsyncIterator<ItemValue<T>>;
 }
 /** Reference to an item in a synchronous database. */
-export declare class Item<T extends Data = Data> extends BaseItem<T> {
+export declare class ItemReference<T extends Data = Data> extends AbstractItemReference<T> {
     readonly provider: Provider;
-    readonly collection: string;
-    readonly id: string;
     constructor(provider: Provider, collection: string, id: string);
     get exists(): boolean;
     get value(): ItemValue<T>;
@@ -75,10 +76,8 @@ export declare class Item<T extends Data = Data> extends BaseItem<T> {
     delete(): void;
 }
 /** Reference to an item in an asynchronous database. */
-export declare class AsyncItem<T extends Data = Data> extends BaseItem<T> {
+export declare class AsyncItemReference<T extends Data = Data> extends AbstractItemReference<T> {
     readonly provider: AsyncProvider;
-    readonly collection: string;
-    readonly id: string;
     constructor(provider: AsyncProvider, collection: string, id: string);
     get exists(): Promise<boolean>;
     get value(): Promise<ItemValue<T>>;

package/db/{Item.js → ItemReference.js}

@@ -1,6 +1,3 @@
-import { Filter } from "../constraint/Filter.js";
-import { Filters } from "../constraint/Filters.js";
-import { Statement } from "../constraint/Statement.js";
 import { getData } from "../util/data.js";
 import { runSequence } from "../util/sequence.js";
 /** Get the ID from item data. */
@@ -10,21 +7,25 @@ export function* getIDs(entities) {
     for (const { id } of entities)
         yield id;
 }
-/** 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);
+/** Get query that targets a single database item by its ID. */
+export const getItemQuery = (id) => ({ id, $limit: 1 });
 /** Reference to an item in a synchronous or asynchronous database. */
-class BaseItem {
+class AbstractItemReference {
+    constructor(collection, id) {
+        this.collection = collection;
+        this.id = id;
+    }
     /** Get a set change for this item. */
     getSet(data) {
-        return { action: "SET", collection: this.collection, id: this.id, data };
+        return { action: "set", collection: this.collection, id: this.id, data };
     }
     /** Get an update change for this item. */
     getUpdate(updates) {
-        return { action: "UPDATE", collection: this.collection, id: this.id, updates };
+        return { action: "update", collection: this.collection, id: this.id, updates };
     }
     /** Get a delete change for this item. */
     getDelete() {
-        return { action: "DELETE", collection: this.collection, id: this.id };
+        return { action: "delete", collection: this.collection, id: this.id };
     }
     // Implement toString()
     toString() {
@@ -40,12 +41,10 @@ class BaseItem {
     }
 }
 /** Reference to an item in a synchronous database. */
-export class Item extends BaseItem {
+export class ItemReference extends AbstractItemReference {
     constructor(provider, collection, id) {
-        super();
+        super(collection, id);
         this.provider = provider;
-        this.collection = collection;
-        this.id = id;
     }
     get exists() {
         return !!this.provider.getItem(this.collection, this.id);
@@ -67,12 +66,10 @@ export class Item extends BaseItem {
     }
 }
 /** Reference to an item in an asynchronous database. */
-export class AsyncItem extends BaseItem {
+export class AsyncItemReference extends AbstractItemReference {
     constructor(provider, collection, id) {
-        super();
+        super(collection, id);
         this.provider = provider;
-        this.collection = collection;
-        this.id = id;
     }
     get exists() {
         return this.provider.getItem(this.collection, this.id).then(Boolean);