shelving 1.70.0 → 1.72.0

package/db/Changes.d.ts

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

package/db/Changes.js

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

package/db/Database.d.ts

@@ -1,23 +1,17 @@
-import type { Validators, ValidatorType } from "../util/validate.js";
 import type { Key, Datas, Entity } from "../util/data.js";
-import type { Provider } from "../provider/Provider.js";
+import type { AsyncProvider, AbstractProvider, Provider } from "../provider/Provider.js";
 import type { QueryProps } from "../query/Query.js";
-import { DocumentReference, QueryReference } from "./Reference.js";
-/**
- * Combines a database model and a provider.
- *
- * @param documents Set of loci describing named documents at the root level of the database.
- * @param collections Set of loci describing collections at the root level of the database.
- * @param provider Provider that allows data to be read/written.
- */
-export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
-    readonly validators: V;
-    readonly provider: Provider;
-    constructor(validators: V, provider: Provider);
-    /** Create a query on a collection in this model. */
-    query<K extends Key<V>>(collection: K, query?: QueryProps<Entity<ValidatorType<V[K]>>>): QueryReference<ValidatorType<V[K]>>;
-    /** Reference a document in a collection in this model. */
-    doc<K extends Key<V>>(collection: K, id: string): DocumentReference<ValidatorType<V[K]>>;
+import { DatabaseDocument, SynchronousDatabaseDocument, AsynchronousDatabaseDocument } from "./DatabaseDocument.js";
+import { DatabaseQuery, SynchronousDatabaseQuery, AsynchronousDatabaseQuery } from "./DatabaseQuery.js";
+/** Database with a provider. */
+export declare type Database<T extends Datas = Datas> = _AbstractDatabase<T>;
+/** Database with a synchronous or asynchronous provider. */
+declare abstract class _AbstractDatabase<T extends Datas> {
+    abstract readonly provider: AbstractProvider<T>;
+    /** Create a query on a collection in this database. */
+    abstract query<K extends Key<T>>(collection: K, query?: QueryProps<Entity<T[K]>>): DatabaseQuery<T, K>;
+    /** Reference a document in a collection in this database. */
+    abstract doc<K extends Key<T>>(collection: K, id: string): DatabaseDocument<T, K>;
     /**
      * Create a new document with a random ID.
      * - Created document is guaranteed to have a unique ID.
@@ -26,5 +20,22 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
      * @param data Complete data to set the document to.
      * @return String ID for the created document (possibly promised).
      */
-    add<K extends Key<V>>(collection: K, data: ValidatorType<V[K]>): string | PromiseLike<string>;
+    abstract add<K extends Key<T>>(collection: K, data: T[K]): string | PromiseLike<string>;
 }
+/** Database with a synchronous provider. */
+export declare class SynchronousDatabase<T extends Datas> implements _AbstractDatabase<T> {
+    readonly provider: Provider<T>;
+    constructor(provider: Provider<T>);
+    query<K extends Key<T>>(collection: K, query?: QueryProps<Entity<T[K]>>): SynchronousDatabaseQuery<T, K>;
+    doc<K extends Key<T>>(collection: K, id: string): SynchronousDatabaseDocument<T, K>;
+    add<K extends Key<T>>(collection: K, data: T[K]): string;
+}
+/** Database with a synchronous provider. */
+export declare class AsynchronousDatabase<T extends Datas> implements _AbstractDatabase<T> {
+    readonly provider: AsyncProvider<T>;
+    constructor(provider: AsyncProvider<T>);
+    query<K extends Key<T>>(collection: K, query?: QueryProps<Entity<T[K]>>): AsynchronousDatabaseQuery<T, K>;
+    doc<K extends Key<T>>(collection: K, id: string): AsynchronousDatabaseDocument<T, K>;
+    add<K extends Key<T>>(collection: K, data: T[K]): Promise<string>;
+}
+export {};

package/db/Database.js

@@ -1,35 +1,35 @@
-import { DocumentReference, QueryReference } from "./Reference.js";
-/**
- * Combines a database model and a provider.
- *
- * @param documents Set of loci describing named documents at the root level of the database.
- * @param collections Set of loci describing collections at the root level of the database.
- * @param provider Provider that allows data to be read/written.
- */
-// Note: typing this with `Validators` rather than raw `Datas` works better for inference — type for props in each collection tends to get lost.
-export class Database {
-    constructor(validators, provider) {
-        this.validators = validators;
+import { SynchronousDatabaseDocument, AsynchronousDatabaseDocument } from "./DatabaseDocument.js";
+import { SynchronousDatabaseQuery, AsynchronousDatabaseQuery } from "./DatabaseQuery.js";
+/** Database with a synchronous or asynchronous provider. */
+class _AbstractDatabase {
+}
+/** Database with a synchronous provider. */
+export class SynchronousDatabase {
+    constructor(provider) {
         this.provider = provider;
     }
-    /** Create a query on a collection in this model. */
     query(collection, query) {
-        const validator = this.validators[collection];
-        return new QueryReference(this, validator, collection, query);
+        return new SynchronousDatabaseQuery(this, collection, query);
     }
-    /** Reference a document in a collection in this model. */
     doc(collection, id) {
-        return new DocumentReference(this, this.validators[collection], collection, id);
-    }
-    /**
-     * Create a new document with a random ID.
-     * - Created document is guaranteed to have a unique ID.
-     *
-     * @param collection Name of the collection to add the document to.
-     * @param data Complete data to set the document to.
-     * @return String ID for the created document (possibly promised).
-     */
+        return new SynchronousDatabaseDocument(this, collection, id);
+    }
+    add(collection, data) {
+        return this.provider.addDocument({ collection }, data);
+    }
+}
+/** Database with a synchronous provider. */
+export class AsynchronousDatabase {
+    constructor(provider) {
+        this.provider = provider;
+    }
+    query(collection, query) {
+        return new AsynchronousDatabaseQuery(this, collection, query);
+    }
+    doc(collection, id) {
+        return new AsynchronousDatabaseDocument(this, collection, id);
+    }
     add(collection, data) {
-        return this.query(collection).add(data);
+        return this.provider.addDocument({ collection }, data);
     }
 }

package/db/DatabaseDocument.d.ts

@@ -0,0 +1,87 @@
+import { OptionalData, Entity, OptionalEntity, Datas, Key } from "../util/data.js";
+import type { Dispatch } from "../util/function.js";
+import type { PartialObserver } from "../observe/Observer.js";
+import { QueryProps } from "../query/Query.js";
+import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
+import type { Observable, Unsubscribe } from "../observe/Observable.js";
+import type { ProviderDocument } from "../provider/Provider.js";
+import type { Database, SynchronousDatabase, AsynchronousDatabase } from "./Database.js";
+import type { DatabaseQuery, AsynchronousDatabaseQuery, SynchronousDatabaseQuery } from "./DatabaseQuery.js";
+/** Reference to a document in a provider. */
+export declare type DatabaseDocument<T extends Datas, K extends Key<T>> = _AbstractDatabaseDocument<T, K>;
+/** Reference to a document in a synchronous or asynchronous provider. */
+declare abstract class _AbstractDatabaseDocument<T extends Datas, K extends Key<T>> implements Observable<OptionalData<T[K]>>, ProviderDocument<T, K> {
+    abstract readonly db: Database<T>;
+    abstract readonly collection: K;
+    abstract readonly id: string;
+    /** Create a query on this document's collection. */
+    abstract query(query?: QueryProps<Entity<T[K]>>): DatabaseQuery<T, K>;
+    /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
+    abstract optional: DatabaseQuery<T, K>;
+    /**
+     * Does this document exist?
+     * @return `true` if a document exists or `false` otherwise (possibly promised).
+     */
+    abstract exists: boolean | PromiseLike<boolean>;
+    /**
+     * Get the optional data of this document.
+     * @return Document's data, or `null` if the document doesn't exist (possibly promised).
+     */
+    abstract value: OptionalEntity<T[K]> | PromiseLike<OptionalEntity<T[K]>>;
+    /**
+     * Get the data of this document.
+     * - Useful for destructuring, e.g. `{ name, title } = await documentThatMustExist.asyncData`
+     *
+     * @return Document's data (possibly promised).
+     * @throws RequiredError if the document does not exist.
+     */
+    abstract data: Entity<T[K]> | PromiseLike<Entity<T[K]>>;
+    /**
+     * Subscribe to the result of this document (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: PartialObserver<OptionalEntity<T[K]>> | Dispatch<[OptionalEntity<T[K]>]>): Unsubscribe;
+    /** Set the complete data of this document. */
+    abstract set(data: T[K]): void | PromiseLike<void>;
+    /** Update this document. */
+    abstract update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void | PromiseLike<void>;
+    /** Delete this document. */
+    abstract delete(): void | PromiseLike<void>;
+    toString(): string;
+}
+/** Reference to a document in a synchronous provider. */
+export declare class SynchronousDatabaseDocument<T extends Datas, K extends Key<T>> extends _AbstractDatabaseDocument<T, K> {
+    readonly db: SynchronousDatabase<T>;
+    readonly collection: K;
+    readonly id: string;
+    constructor(db: SynchronousDatabase<T>, collection: K, id: string);
+    query(query?: QueryProps<Entity<T[K]>>): SynchronousDatabaseQuery<T, K>;
+    get optional(): SynchronousDatabaseQuery<T, K>;
+    get exists(): boolean;
+    get value(): OptionalEntity<T[K]>;
+    get data(): Entity<T[K]>;
+    set(data: T[K]): void;
+    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void;
+    delete(): void;
+}
+/** Reference to a document in an asynchronous provider. */
+export declare class AsynchronousDatabaseDocument<T extends Datas, K extends Key<T>> extends _AbstractDatabaseDocument<T, K> {
+    readonly db: AsynchronousDatabase<T>;
+    readonly collection: K;
+    readonly id: string;
+    constructor(provider: AsynchronousDatabase<T>, collection: K, id: string);
+    query(query?: QueryProps<Entity<T[K]>>): AsynchronousDatabaseQuery<T, K>;
+    get optional(): AsynchronousDatabaseQuery<T, K>;
+    get exists(): Promise<boolean>;
+    get value(): Promise<OptionalEntity<T[K]>>;
+    get data(): Promise<Entity<T[K]>>;
+    set(data: T[K]): Promise<void>;
+    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): Promise<void>;
+    delete(): Promise<void>;
+}
+/** Get the data for a document from a result for that document. */
+export declare function getDocumentData<T extends Datas, K extends Key<T>>(entity: OptionalEntity<T[K]>, ref: _AbstractDatabaseDocument<T, K>): Entity<T[K]>;
+export {};

package/db/DatabaseDocument.js

@@ -0,0 +1,91 @@
+import { DataUpdate } from "../update/DataUpdate.js";
+import { RequiredError } from "../error/RequiredError.js";
+/** Reference to a document in a synchronous or asynchronous provider. */
+class _AbstractDatabaseDocument {
+    /**
+     * Subscribe to the result of this document (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.subscribeDocument(this, typeof next === "function" ? { next } : next);
+    }
+    // Implement toString()
+    toString() {
+        return `${this.collection}/${this.id}`;
+    }
+}
+/** Reference to a document in a synchronous provider. */
+export class SynchronousDatabaseDocument extends _AbstractDatabaseDocument {
+    constructor(db, collection, id) {
+        super();
+        this.db = db;
+        this.collection = collection;
+        this.id = id;
+    }
+    query(query) {
+        return this.db.query(this.collection, query);
+    }
+    get optional() {
+        return this.db.query(this.collection, { filter: { id: this.id }, limit: 1 });
+    }
+    get exists() {
+        return !!this.db.provider.getDocument(this);
+    }
+    get value() {
+        return this.db.provider.getDocument(this);
+    }
+    get data() {
+        return getDocumentData(this.value, this);
+    }
+    set(data) {
+        return this.db.provider.setDocument(this, data);
+    }
+    update(updates) {
+        return this.db.provider.updateDocument(this, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+    }
+    delete() {
+        return this.db.provider.deleteDocument(this);
+    }
+}
+/** Reference to a document in an asynchronous provider. */
+export class AsynchronousDatabaseDocument extends _AbstractDatabaseDocument {
+    constructor(provider, collection, id) {
+        super();
+        this.db = provider;
+        this.collection = collection;
+        this.id = id;
+    }
+    query(query) {
+        return this.db.query(this.collection, query);
+    }
+    get optional() {
+        return this.db.query(this.collection, { filter: { id: this.id }, limit: 1 });
+    }
+    get exists() {
+        return this.db.provider.getDocument(this).then(Boolean);
+    }
+    get value() {
+        return this.db.provider.getDocument(this);
+    }
+    get data() {
+        return this.value.then(v => getDocumentData(v, this));
+    }
+    set(data) {
+        return this.db.provider.setDocument(this, data);
+    }
+    update(updates) {
+        return this.db.provider.updateDocument(this, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+    }
+    delete() {
+        return this.db.provider.deleteDocument(this);
+    }
+}
+/** Get the data for a document from a result for that document. */
+export function getDocumentData(entity, ref) {
+    if (entity)
+        return entity;
+    throw new RequiredError(`Document "${ref}" does not exist`);
+}

package/db/DatabaseQuery.d.ts

@@ -0,0 +1,120 @@
+import { Entity, OptionalEntity, Entities, Key, Datas } from "../util/data.js";
+import type { Dispatch } from "../util/function.js";
+import { ImmutableArray } from "../util/array.js";
+import type { PartialObserver } from "../observe/Observer.js";
+import { Query, QueryProps } from "../query/Query.js";
+import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
+import type { Observable, Unsubscribe } from "../observe/Observable.js";
+import type { Database, AsynchronousDatabase, SynchronousDatabase } from "./Database.js";
+import type { DatabaseDocument, AsynchronousDatabaseDocument, SynchronousDatabaseDocument } from "./DatabaseDocument.js";
+/** Reference to a set of documents in a provider. */
+export declare type DatabaseQuery<T extends Datas, K extends Key<T>> = _AbstractDatabaseQuery<T, K>;
+/** Reference to a set of documents in a sync or async provider. */
+declare abstract class _AbstractDatabaseQuery<T extends Datas, K extends Key<T>> extends Query<Entity<T[K]>> implements Observable<ImmutableArray<Entity<T[K]>>> {
+    abstract readonly db: Database<T>;
+    abstract readonly collection: K;
+    /** Reference a document in this query's collection. */
+    abstract doc(id: string): DatabaseDocument<T, K>;
+    /**
+     * Create a new document with a random ID.
+     * - Created document is guaranteed to have a unique ID.
+     *
+     * @param data Complete data to set the document to.
+     * @return String ID for the created document (possibly promised).
+     */
+    abstract add(data: T[K]): string | PromiseLike<string>;
+    /**
+     * Get array of entities for this query.
+     * @return Array of entities.
+     */
+    abstract value: Entities<T[K]> | PromiseLike<Entities<T[K]>>;
+    /**
+     * Count the number of results of this set of documents.
+     * @return Number of documents matching the query (possibly promised).
+     */
+    abstract count: number | PromiseLike<number>;
+    /**
+     * Does at least one document exist for this query?
+     * @return `true` if a document exists or `false` otherwise (possibly promised).
+     */
+    abstract exists: boolean | PromiseLike<boolean>;
+    /**
+     * Get the first document matched by this query or `null` if this query has no results.
+     * @throws RequiredError if there were no results for this query.
+     */
+    abstract first: OptionalEntity<T[K]> | PromiseLike<OptionalEntity<T[K]>>;
+    /**
+     * Get the first document matched by this query.
+     * @throws RequiredError if there were no results for this query.
+     */
+    abstract data: Entity<T[K]> | PromiseLike<Entity<T[K]>>;
+    /**
+     * Subscribe to all matching documents.
+     * - `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: PartialObserver<Entities<T[K]>> | Dispatch<[Entities<T[K]>]>): Unsubscribe;
+    /**
+     * Set all matching documents to the same exact value.
+     *
+     * @param data Complete data to set the document to.
+     * @return Nothing (possibly promised).
+     */
+    abstract set(data: T[K]): number | PromiseLike<number>;
+    /**
+     * Update all matching documents with the same partial value.
+     *
+     * @param updates `Update` instance or set of updates to apply to every matching document.
+     * @return Nothing (possibly promised).
+     */
+    abstract update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): number | PromiseLike<number>;
+    /**
+     * Delete all matching documents.
+     * @return Nothing (possibly promised).
+     */
+    abstract delete(): number | PromiseLike<number>;
+    toString(): string;
+}
+/** Reference to a set of documents in a provider. */
+export declare class SynchronousDatabaseQuery<T extends Datas, K extends Key<T>> extends _AbstractDatabaseQuery<T, K> {
+    readonly db: SynchronousDatabase<T>;
+    readonly collection: K;
+    constructor(db: SynchronousDatabase<T>, collection: K, props?: QueryProps<Entity<T[K]>>);
+    doc(id: string): SynchronousDatabaseDocument<T, K>;
+    add(data: T[K]): string;
+    get value(): Entities<T[K]>;
+    get count(): number;
+    get exists(): boolean;
+    get first(): OptionalEntity<T[K]>;
+    get data(): Entity<T[K]>;
+    set(data: T[K]): number;
+    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): number;
+    delete(): number;
+}
+/** Reference to a set of documents in a provider. */
+export declare class AsynchronousDatabaseQuery<T extends Datas, K extends Key<T>> extends _AbstractDatabaseQuery<T, K> {
+    readonly db: AsynchronousDatabase<T>;
+    readonly collection: K;
+    constructor(db: AsynchronousDatabase<T>, collection: K, props?: QueryProps<Entity<T[K]>>);
+    doc(id: string): AsynchronousDatabaseDocument<T, K>;
+    add(data: T[K]): Promise<string>;
+    get value(): Promise<Entities<T[K]>>;
+    get count(): Promise<number>;
+    get exists(): Promise<boolean>;
+    get first(): Promise<OptionalEntity<T[K]>>;
+    get data(): Promise<Entity<T[K]>>;
+    set(data: T[K]): Promise<number>;
+    update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): PromiseLike<number>;
+    delete(): PromiseLike<number>;
+}
+/** Get the optional data for a document from a set of queried entities. */
+export declare function getQueryFirstItem<T extends Datas, K extends Key<T>>(entities: Entities<T[K]>): OptionalEntity<T[K]>;
+/** Get the data for a document from a set of queried entities. */
+export declare function getQueryFirstData<T extends Datas, K extends Key<T>>(entities: Entities<T[K]>, ref: _AbstractDatabaseQuery<T, K>): Entity<T[K]>;
+/** Get the optional data for a document from a set of queried entities. */
+export declare function getQueryLastValue<T extends Datas, K extends Key<T>>(entities: Entities<T[K]>): OptionalEntity<T[K]>;
+/** Get the data for a document from a set of queried entities. */
+export declare function getQueryLastItem<T extends Datas, K extends Key<T>>(entities: Entities<T[K]>, ref: _AbstractDatabaseQuery<T, K>): Entity<T[K]>;
+export {};

package/db/DatabaseQuery.js

@@ -0,0 +1,120 @@
+import { getFirstItem, getLastItem } from "../util/array.js";
+import { Query } from "../query/Query.js";
+import { countItems, hasItems } from "../util/iterate.js";
+import { DataUpdate } from "../update/DataUpdate.js";
+import { RequiredError } from "../error/RequiredError.js";
+/** Reference to a set of documents in a sync or async provider. */
+class _AbstractDatabaseQuery extends Query {
+    /**
+     * Subscribe to all matching documents.
+     * - `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, typeof next === "function" ? { next } : next);
+    }
+    // Override to include the collection name.
+    toString() {
+        return `${this.collection}?${super.toString()}`;
+    }
+}
+/** Reference to a set of documents in a provider. */
+export class SynchronousDatabaseQuery extends _AbstractDatabaseQuery {
+    constructor(db, collection, props) {
+        super(props);
+        this.db = db;
+        this.collection = collection;
+    }
+    doc(id) {
+        return this.db.doc(this.collection, id);
+    }
+    add(data) {
+        return this.db.provider.addDocument(this, data);
+    }
+    get value() {
+        return this.db.provider.getQuery(this);
+    }
+    get count() {
+        return this.value.length;
+    }
+    get exists() {
+        return hasItems(this.db.provider.getQuery(this.max(1)));
+    }
+    get first() {
+        return getQueryFirstItem(this.db.provider.getQuery(this.max(1)));
+    }
+    get data() {
+        return getQueryFirstData(this.db.provider.getQuery(this.max(1)), this);
+    }
+    set(data) {
+        return this.db.provider.setQuery(this, data);
+    }
+    update(updates) {
+        return this.db.provider.updateQuery(this, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+    }
+    delete() {
+        return this.db.provider.deleteQuery(this);
+    }
+}
+/** Reference to a set of documents in a provider. */
+export class AsynchronousDatabaseQuery extends _AbstractDatabaseQuery {
+    constructor(db, collection, props) {
+        super(props);
+        this.db = db;
+        this.collection = collection;
+    }
+    doc(id) {
+        return this.db.doc(this.collection, id);
+    }
+    add(data) {
+        return this.db.provider.addDocument(this, data);
+    }
+    get value() {
+        return this.db.provider.getQuery(this);
+    }
+    get count() {
+        return this.value.then(countItems);
+    }
+    get exists() {
+        return this.db.provider.getQuery(this.max(1)).then(hasItems);
+    }
+    get first() {
+        return this.db.provider.getQuery(this.max(1)).then(getQueryFirstItem);
+    }
+    get data() {
+        return this.db.provider.getQuery(this.max(1)).then(v => getQueryFirstData(v, this));
+    }
+    set(data) {
+        return this.db.provider.setQuery(this, data);
+    }
+    update(updates) {
+        return this.db.provider.updateQuery(this, updates instanceof DataUpdate ? updates : new DataUpdate(updates));
+    }
+    delete() {
+        return this.db.provider.deleteQuery(this);
+    }
+}
+/** Get the optional data for a document from a set of queried entities. */
+export function getQueryFirstItem(entities) {
+    return getFirstItem(entities) || null;
+}
+/** Get the data for a document from a set of queried entities. */
+export function getQueryFirstData(entities, ref) {
+    const entity = getQueryFirstItem(entities);
+    if (entity)
+        return entity;
+    throw new RequiredError(`Query "${ref}" has no documents`);
+}
+/** Get the optional data for a document from a set of queried entities. */
+export function getQueryLastValue(entities) {
+    return getLastItem(entities) || null;
+}
+/** Get the data for a document from a set of queried entities. */
+export function getQueryLastItem(entities, ref) {
+    const entity = getQueryLastValue(entities);
+    if (entity)
+        return entity;
+    throw new RequiredError(`Query "${ref}" has no documents`);
+}

package/db/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./Database.js";
-export * from "./Reference.js";
-export * from "./Operation.js";
+export * from "./DatabaseDocument.js";
+export * from "./DatabaseQuery.js";
+export * from "./Changes.js";

package/db/index.js

@@ -1,3 +1,4 @@
 export * from "./Database.js";
-export * from "./Reference.js";
-export * from "./Operation.js";
+export * from "./DatabaseDocument.js";
+export * from "./DatabaseQuery.js";
+export * from "./Changes.js";

package/error/ValidationError.js

@@ -1,7 +1,8 @@
+import { debug } from "../util/debug.js";
 /** Thrown if a value isn't valid. */
 export class ValidationError extends Error {
     constructor(message, feedback) {
-        super(`${message}:\n${feedback.toString()}`);
+        super(`${message}:\n${feedback.message} (received ${debug(feedback.value)})`);
         this.feedback = feedback;
     }
 }

package/feedback/ErrorFeedback.d.ts

@@ -1,4 +1,4 @@
 import { Feedback } from "./Feedback.js";
 /** Specific type of `Feedback` to indicate an error (something went wrong). */
-export declare class ErrorFeedback extends Feedback {
+export declare class ErrorFeedback<T = unknown> extends Feedback<T> {
 }

package/feedback/ErrorFeedback.js

@@ -2,3 +2,4 @@ import { Feedback } from "./Feedback.js";
 /** Specific type of `Feedback` to indicate an error (something went wrong). */
 export class ErrorFeedback extends Feedback {
 }
+ErrorFeedback.prototype.name = "ErrorFeedback";