shelving 1.89.2 → 1.89.4

package/constraint/FilterConstraint.d.ts

@@ -1,12 +1,10 @@
-import { Data, DataKey, FlatDataKey } from "../util/data.js";
+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";
 /** Possible operator references. */
 export type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
-/** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
-export type FilterKey<T extends Data> = DataKey<FilterProps<T>>;
 /** Format that allows multiple filters to be specified as a plain object. */
 export type FilterProps<T extends Data> = {
     [K in FlatDataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
@@ -15,6 +13,8 @@ export type FilterProps<T extends Data> = {
 } & {
     [K in FlatDataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
 };
+/** 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>>>;
 /**

package/db/Change.d.ts

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

package/db/Change.js

@@ -1,10 +1,8 @@
-import { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { notNullish } from "../util/null.js";
-import { flattenItems } from "../util/iterate.js";
-import { getItemFilterConstraints } from "./Item.js";
+import { getItemConstraints } from "./Item.js";
 /** Apply a set of changes to a synchronous provider. */
 export function changeProvider(provider, ...changes) {
-    return Array.from(flattenItems(changes)).filter(notNullish).map(_changeItem, provider);
+    return changes.filter(notNullish).map(_changeItem, provider);
 }
 function _changeItem(change) {
     const { action, collection } = change;
@@ -13,14 +11,14 @@ function _changeItem(change) {
     else if (action === "SET")
         this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        this.updateQuery(collection, new QueryConstraints(getItemFilterConstraints(change.id), undefined, 1), change.updates);
+        this.updateQuery(collection, getItemConstraints(change.id), change.updates);
     else if (action === "DELETE")
         this.deleteItem(collection, change.id);
     return change;
 }
 /** Apply a set of changes to an asynchronous provider. */
 export function changeAsyncProvider(provider, ...changes) {
-    return Promise.all(Array.from(flattenItems(changes)).filter(notNullish).map(_changeAsyncItem, provider));
+    return Promise.all(changes.filter(notNullish).map(_changeAsyncItem, provider));
 }
 async function _changeAsyncItem(change) {
     const { collection, action } = change;
@@ -29,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, new QueryConstraints(getItemFilterConstraints(change.id), undefined, 1), change.updates);
+        await this.updateQuery(collection, getItemConstraints(change.id), change.updates);
     else if (action === "DELETE")
         await this.deleteItem(collection, change.id);
     return change;

package/db/Collection.d.ts

@@ -1,69 +1,63 @@
-import type { Datas, DataKey } from "../util/data.js";
-import type { Nullish } from "../util/null.js";
+import type { Data } from "../util/data.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
-import type { DeepIterable } from "../util/iterate.js";
 import type { Updates } from "../update/DataUpdate.js";
-import type { AsyncDatabase, Database } from "./Database.js";
+import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import { ItemData, AsyncItem, Item, ItemValue } from "./Item.js";
 import { AsyncQuery, Query } from "./Query.js";
-import { AddChange, ItemChanges, WriteChange, UpdateChange, DeleteChange, SetChange } from "./Change.js";
+import { AddChange, UpdateChange, DeleteChange, SetChange } from "./Change.js";
 /** Reference to a collection in a synchronous or asynchronous provider. */
-declare abstract class BaseCollection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> {
-    abstract readonly db: Database<T> | AsyncDatabase<T>;
-    abstract readonly collection: K;
+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[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
+    abstract query(filters?: FilterList<Partial<ItemData<T>>>, sorts?: SortList<Partial<ItemData<T>>>, limit?: number | null): Query<T> | AsyncQuery<T>;
     /** Create a query on this item's collection. */
-    abstract item(id: string): Item<T, K> | AsyncItem<T, K>;
-    /** Run a set of changes on this database. */
-    abstract change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K> | Promise<ItemChanges<T, K>>;
+    abstract item(id: string): Item<T> | AsyncItem<T>;
     /** Get an item from this collection. */
-    abstract get(id: string): ItemValue<T[K]> | Promise<ItemValue<T[K]>>;
+    abstract get(id: string): ItemValue<T> | Promise<ItemValue<T>>;
     /** Add an item to this collection. */
-    abstract add(data: T[K]): string | Promise<string>;
+    abstract add(data: T): string | Promise<string>;
     /** Set a document in this collection. */
-    abstract set(id: string, data: T[K]): void | Promise<void>;
+    abstract set(id: string, data: T): void | Promise<void>;
     /** Update a document in this collection. */
-    abstract update(id: string, updates: Updates<T[K]>): void | Promise<void>;
+    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[K]): AddChange<T, K>;
+    getAdd(data: T): AddChange<T>;
     /** Get a set change for this collection. */
-    getSet(id: string, data: T[K]): SetChange<T, K>;
+    getSet(id: string, data: T): SetChange<T>;
     /** Get an update change for this collection. */
-    getUpdate(id: string, updates: Updates<T[K]>): UpdateChange<T, K>;
+    getUpdate(id: string, updates: Updates<T>): UpdateChange<T>;
     /** Get a delete change for this collection. */
-    getDelete(id: string): DeleteChange<T, K>;
-    toString(): K;
+    getDelete(id: string): DeleteChange;
+    toString(): string;
 }
 /** Reference to a collection in a synchronous provider. */
-export declare class Collection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseCollection<T, K> {
-    readonly db: Database<T>;
-    readonly collection: K;
-    constructor(db: Database<T>, collection: K);
-    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
-    item(id: string): Item<T, K>;
-    change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
-    get(id: string): ItemValue<T[K]>;
-    add(data: T[K]): string;
-    set(id: string, data: T[K]): void;
-    update(id: string, updates: Updates<T[K]>): void;
+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>;
+    item(id: string): Item<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 AsyncCollection<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseCollection<T, K> {
-    readonly db: AsyncDatabase<T>;
-    readonly collection: K;
-    constructor(db: AsyncDatabase<T>, collection: K);
-    query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
-    item(id: string): AsyncItem<T, K>;
-    change(...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
-    get(id: string): Promise<ItemValue<T[K]>>;
-    add(data: T[K]): Promise<string>;
-    set(id: string, data: T[K]): Promise<void>;
-    update(id: string, updates: Updates<T[K]>): Promise<void>;
+export declare class AsyncCollection<T extends Data = Data> extends BaseCollection<T> {
+    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>;
+    item(id: string): AsyncItem<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/Collection.js

@@ -1,23 +1,22 @@
 import { AsyncItem, Item } from "./Item.js";
 import { AsyncQuery, Query } from "./Query.js";
-import { changeAsyncProvider, changeProvider } from "./Change.js";
 /** Reference to a collection in a synchronous or asynchronous provider. */
 class BaseCollection {
     /** Get an add change for this collection. */
     getAdd(data) {
-        return this.db.getAdd(this.collection, data);
+        return { action: "ADD", collection: this.collection, data };
     }
     /** Get a set change for this collection. */
     getSet(id, data) {
-        return this.db.getSet(this.collection, id, data);
+        return { action: "SET", collection: this.collection, id, data };
     }
     /** Get an update change for this collection. */
     getUpdate(id, updates) {
-        return this.db.getUpdate(this.collection, id, updates);
+        return { action: "UPDATE", collection: this.collection, id, updates };
     }
     /** Get a delete change for this collection. */
     getDelete(id) {
-        return this.db.getDelete(this.collection, id);
+        return { action: "DELETE", collection: this.collection, id };
     }
     // Implement toString()
     toString() {
@@ -26,65 +25,59 @@ class BaseCollection {
 }
 /** Reference to a collection in a synchronous provider. */
 export class Collection extends BaseCollection {
-    constructor(db, collection) {
+    constructor(provider, collection) {
         super();
-        this.db = db;
+        this.provider = provider;
         this.collection = collection;
     }
     query(filters, sorts, limit) {
-        return new Query(this.db, this.collection, filters, sorts, limit);
+        return new Query(this.provider, this.collection, filters, sorts, limit);
     }
     item(id) {
-        return new Item(this.db, this.collection, id);
-    }
-    change(...changes) {
-        return changeProvider(this.db.provider, changes);
+        return new Item(this.provider, this.collection, id);
     }
     get(id) {
-        return this.db.get(this.collection, id);
+        return this.provider.getItem(this.collection, id);
     }
     add(data) {
-        return this.db.add(this.collection, data);
+        return this.provider.addItem(this.collection, data);
     }
     set(id, data) {
-        return this.db.set(this.collection, id, data);
+        return this.provider.setItem(this.collection, id, data);
     }
     update(id, updates) {
-        return this.db.update(this.collection, id, updates);
+        return this.provider.updateItem(this.collection, id, updates);
     }
     delete(id) {
-        return this.db.delete(this.collection, id);
+        return this.provider.deleteItem(this.collection, id);
     }
 }
 /** Reference to a collection in an asynchronous provider. */
 export class AsyncCollection extends BaseCollection {
-    constructor(db, collection) {
+    constructor(provider, collection) {
         super();
-        this.db = db;
+        this.provider = provider;
         this.collection = collection;
     }
     query(filters, sorts, limit) {
-        return new AsyncQuery(this.db, this.collection, filters, sorts, limit);
+        return new AsyncQuery(this.provider, this.collection, filters, sorts, limit);
     }
     item(id) {
-        return new AsyncItem(this.db, this.collection, id);
-    }
-    change(...changes) {
-        return changeAsyncProvider(this.db.provider, changes);
+        return new AsyncItem(this.provider, this.collection, id);
     }
     get(id) {
-        return this.db.get(this.collection, id);
+        return this.provider.getItem(this.collection, id);
     }
     add(data) {
-        return this.db.add(this.collection, data);
+        return this.provider.addItem(this.collection, data);
     }
     set(id, data) {
-        return this.db.set(this.collection, id, data);
+        return this.provider.setItem(this.collection, id, data);
     }
     update(id, updates) {
-        return this.db.update(this.collection, id, updates);
+        return this.provider.updateItem(this.collection, id, updates);
     }
     delete(id) {
-        return this.db.delete(this.collection, id);
+        return this.provider.deleteItem(this.collection, id);
     }
 }

package/db/Database.d.ts

@@ -1,6 +1,5 @@
 import type { DataKey, Datas } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
-import type { DeepIterable } from "../util/iterate.js";
 import type { AsyncProvider, Provider } from "../provider/Provider.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
@@ -12,15 +11,15 @@ import { Collection, AsyncCollection } from "./Collection.js";
 import { AddChange, DeleteChange, ItemChanges, SetChange, UpdateChange, WriteChange } from "./Change.js";
 /** Database with a synchronous or asynchronous provider. */
 declare abstract class BaseDatabase<T extends Datas> {
-    abstract readonly provider: Provider<T> | AsyncProvider<T>;
+    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): 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?: FilterList<Partial<ItemData<T[K]>>>, sorts?: SortList<Partial<ItemData<T[K]>>>, limit?: number | null): Query<T[K]> | AsyncQuery<T[K]>;
     /** Reference an item in a collection in this database. */
-    abstract item<K extends DataKey<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
+    abstract item<K extends DataKey<T>>(collection: K, id: string): Item<T[K]> | AsyncItem<T[K]>;
     /** Run a set of changes in this database. */
-    abstract change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<T> | Promise<ItemChanges<T>>;
+    abstract change(...changes: Nullish<WriteChange>[]): 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. */
@@ -32,22 +31,22 @@ declare abstract class BaseDatabase<T extends Datas> {
     /** Delete a document from a collection in this database. */
     abstract delete<K extends DataKey<T>>(collection: K, id: string): void | Promise<void>;
     /** Get an add change for a collection in this database. */
-    getAdd<K extends DataKey<T>>(collection: K, data: T[K]): AddChange<T, K>;
+    getAdd<K extends DataKey<T>>(collection: K, data: T[K]): AddChange<T[K]>;
     /** Get a set change for a collection in this database. */
-    getSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): SetChange<T, K>;
+    getSet<K extends DataKey<T>>(collection: K, id: string, data: T[K]): SetChange<T[K]>;
     /** Get an update change for a collection in this database. */
-    getUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateChange<T, K>;
+    getUpdate<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): UpdateChange<T[K]>;
     /** Get a delete change for a collection in this database. */
-    getDelete<K extends DataKey<T>>(collection: K, id: string): DeleteChange<T, K>;
+    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> {
-    readonly provider: Provider<T>;
-    constructor(provider: Provider<T>);
-    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>;
-    item<K extends DataKey<T>>(collection: K, id: string): Item<T, K>;
-    change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): ItemChanges<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]>;
+    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]>;
     add<K extends DataKey<T>>(collection: K, data: T[K]): string;
     set<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
@@ -56,12 +55,12 @@ export declare class Database<T extends Datas = Datas> extends BaseDatabase<T> {
 }
 /** Database with a synchronous provider. */
 export declare class AsyncDatabase<T extends Datas = Datas> extends BaseDatabase<T> {
-    readonly provider: AsyncProvider<T>;
-    constructor(provider: AsyncProvider<T>);
-    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>;
-    item<K extends DataKey<T>>(collection: K, id: string): AsyncItem<T, K>;
-    change(...changes: DeepIterable<Nullish<WriteChange<T>>>[]): Promise<ItemChanges<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?: FilterList<ItemData<T[K]>>, sorts?: SortList<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]>>;
     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

@@ -28,16 +28,16 @@ export class Database extends BaseDatabase {
         this.provider = provider;
     }
     collection(collection) {
-        return new Collection(this, collection);
+        return new Collection(this.provider, collection);
     }
     query(collection, filters, sorts, limit) {
-        return new Query(this, collection, filters, sorts, limit);
+        return new Query(this.provider, collection, filters, sorts, limit);
     }
     item(collection, id) {
-        return new Item(this, collection, id);
+        return new Item(this.provider, collection, id);
     }
     change(...changes) {
-        return changeProvider(this.provider, changes);
+        return changeProvider(this.provider, ...changes);
     }
     get(collection, id) {
         return this.provider.getItem(collection, id);
@@ -62,16 +62,16 @@ export class AsyncDatabase extends BaseDatabase {
         this.provider = provider;
     }
     collection(collection) {
-        return new AsyncCollection(this, collection);
+        return new AsyncCollection(this.provider, collection);
     }
     query(collection, filters, sorts, limit) {
-        return new AsyncQuery(this, collection, filters, sorts, limit);
+        return new AsyncQuery(this.provider, collection, filters, sorts, limit);
     }
     item(collection, id) {
-        return new AsyncItem(this, collection, id);
+        return new AsyncItem(this.provider, collection, id);
     }
     change(...changes) {
-        return changeAsyncProvider(this.provider, changes);
+        return changeAsyncProvider(this.provider, ...changes);
     }
     get(collection, id) {
         return this.provider.getItem(collection, id);

package/db/Item.d.ts

@@ -1,29 +1,31 @@
 import type { ImmutableArray } from "../util/array.js";
 import type { Stop, Handler, Dispatch } from "../util/function.js";
-import type { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { Data, Datas, DataKey } from "../util/data.js";
+import type { Provider, AsyncProvider } from "../provider/Provider.js";
+import { QueryConstraints } from "../constraint/QueryConstraints.js";
+import { Data } from "../util/data.js";
 import { DataUpdate, Updates } from "../update/DataUpdate.js";
-import { FilterConstraints } from "../constraint/FilterConstraints.js";
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
-import type { AsyncQuery, Query } from "./Query.js";
-import type { AsyncDatabase, Database } from "./Database.js";
 /** Item data with a string ID that uniquely identifies it. */
 export type ItemData<T extends Data = Data> = T & {
     id: string;
 };
 /** Entity or `null` to indicate the item doesn't exist. */
 export type ItemValue<T extends Data = Data> = ItemData<T> | null;
+/** Get the ID from item data. */
+export declare const getID: <T extends Data>({ id }: ItemData<T>) => string;
+/** Get the IDs of an iterable set item data. */
+export declare function getIDs<T extends Data>(entities: Iterable<ItemData<T>>): Iterable<string>;
 /** 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>>;
 /** Reference to an item in a synchronous or asynchronous database. */
-declare abstract class BaseItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> implements AsyncIterable<ItemValue<T[K]>> {
-    abstract readonly db: Database<T> | AsyncDatabase<T>;
-    abstract readonly collection: K;
+declare abstract class BaseItem<T extends Data = Data> implements AsyncIterable<ItemValue<T>> {
+    abstract readonly provider: Provider | AsyncProvider;
+    abstract readonly collection: string;
     abstract readonly id: string;
-    /** Get an 'optional' reference to this item (uses a `ModelQuery` with an `id` filter). */
-    abstract optional: Query<T, K> | AsyncQuery<T, K>;
     /**
      * Does this item exist?
      * @return `true` if an item exists or `false` otherwise (possibly promised).
@@ -33,7 +35,7 @@ declare abstract class BaseItem<T extends Datas = Datas, K extends DataKey<T> =
      * Get the optional data of this item.
      * @return Document's data, or `null` if the item doesn't exist (possibly promised).
      */
-    abstract value: ItemValue<T[K]> | PromiseLike<ItemValue<T[K]>>;
+    abstract value: ItemValue<T> | PromiseLike<ItemValue<T>>;
     /**
      * Get the data of this item.
      * - Useful for destructuring, e.g. `{ name, title } = await itemThatMustExist.asyncData`
@@ -41,56 +43,48 @@ declare abstract class BaseItem<T extends Datas = Datas, K extends DataKey<T> =
      * @return Document's data (possibly promised).
      * @throws RequiredError if the item does not exist.
      */
-    abstract data: ItemData<T[K]> | PromiseLike<ItemData<T[K]>>;
+    abstract data: ItemData<T> | PromiseLike<ItemData<T>>;
     /** Set the complete data of this item. */
-    abstract set(data: T[K]): void | PromiseLike<void>;
+    abstract set(data: T): void | PromiseLike<void>;
     /** Update this item. */
-    abstract update(updates: DataUpdate<T[K]> | Updates<T[K]>): void | PromiseLike<void>;
+    abstract update(updates: DataUpdate<T> | Updates<T>): void | PromiseLike<void>;
     /** Delete this item. */
     abstract delete(): void | PromiseLike<void>;
     /** Get a set change for this item. */
-    getSet(data: T[K]): SetChange<T, K>;
+    getSet(data: T): SetChange<T>;
     /** Get an update change for this item. */
-    getUpdate(updates: Updates<T[K]>): UpdateChange<T, K>;
+    getUpdate(updates: Updates<T>): UpdateChange<T>;
     /** Get a delete change for this item. */
-    getDelete(): DeleteChange<T, K>;
-    toString(): `${K}/${string}`;
+    getDelete(): DeleteChange;
+    toString(): string;
     /** Subscribe to this item. */
-    subscribe(onNext?: Dispatch<[ItemValue<T[K]>]>, onError?: Handler): Stop;
-    [Symbol.asyncIterator](): AsyncIterator<ItemValue<T[K]>>;
+    subscribe(onNext?: Dispatch<[ItemValue<T>]>, onError?: Handler): Stop;
+    [Symbol.asyncIterator](): AsyncIterator<ItemValue<T>>;
 }
 /** Reference to an item in a synchronous database. */
-export declare class Item<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseItem<T, K> {
-    readonly db: Database<T>;
-    readonly collection: K;
+export declare class Item<T extends Data = Data> extends BaseItem<T> {
+    readonly provider: Provider;
+    readonly collection: string;
     readonly id: string;
-    constructor(db: Database<T>, collection: K, id: string);
-    get optional(): Query<T, K>;
+    constructor(provider: Provider, collection: string, id: string);
     get exists(): boolean;
-    get value(): ItemValue<T[K]>;
-    get data(): ItemData<T[K]>;
-    set(data: T[K]): void;
-    update(updates: Updates<T[K]>): void;
+    get value(): ItemValue<T>;
+    get data(): ItemData<T>;
+    set(data: T): void;
+    update(updates: Updates<T>): void;
     delete(): void;
 }
 /** Reference to an item in an asynchronous database. */
-export declare class AsyncItem<T extends Datas = Datas, K extends DataKey<T> = DataKey<T>> extends BaseItem<T, K> {
-    readonly db: AsyncDatabase<T>;
-    readonly collection: K;
+export declare class AsyncItem<T extends Data = Data> extends BaseItem<T> {
+    readonly provider: AsyncProvider;
+    readonly collection: string;
     readonly id: string;
-    constructor(db: AsyncDatabase<T>, collection: K, id: string);
-    get optional(): AsyncQuery<T, K>;
+    constructor(provider: AsyncProvider, collection: string, id: string);
     get exists(): Promise<boolean>;
-    get value(): Promise<ItemValue<T[K]>>;
-    get data(): Promise<ItemData<T[K]>>;
-    set(data: T[K]): Promise<void>;
-    update(updates: Updates<T[K]>): Promise<void>;
+    get value(): Promise<ItemValue<T>>;
+    get data(): Promise<ItemData<T>>;
+    set(data: T): Promise<void>;
+    update(updates: Updates<T>): Promise<void>;
     delete(): Promise<void>;
 }
-/** Get the ID from item data. */
-export declare const getID: <T extends Data>({ id }: ItemData<T>) => string;
-/** Get the IDs of an iterable set item data. */
-export declare function getIDs<T extends Data>(entities: Iterable<ItemData<T>>): Iterable<string>;
-/** Get a `FilterConstraints` instance that targets a single item by its ID. */
-export declare function getItemFilterConstraints<T extends Data>(id: string): FilterConstraints<ItemData<T>>;
 export {};