shelving 1.19.0 → 1.20.0

package/db/Change.d.ts

@@ -4,16 +4,16 @@ import type { Database, DatabaseDocument } from "./Database.js";
 /** A single change that can be made to a database. */
 export declare abstract class Change<T extends Datas> {
     /** Apply this change to a database. */
-    abstract apply(db: Database<T>): void | Promise<void>;
+    abstract apply(db: Database<T>): void | PromiseLike<void>;
 }
 /** A change that writes a document in a database. */
-export declare class Write<D extends Datas, C extends Key<D>> extends Change<D> {
-    static on<X extends Datas, Y extends Key<X>>({ collection, id }: DatabaseDocument<X, Y>, value: X[Y] | Transform<X[Y]> | undefined): Write<X, Y>;
+export declare class Write<C extends Key<D>, D extends Datas> extends Change<D> {
+    static on<Y extends Key<X>, X extends Datas>({ collection, id }: DatabaseDocument<Y, X>, value: X[Y] | Transform<X[Y]> | undefined): Write<Y, X>;
     readonly collection: C;
     readonly id: string;
     readonly value: D[C] | Transform<D[C]> | undefined;
     constructor(collection: C, id: string, value: D[C] | Transform<D[C]> | undefined);
-    apply(db: Database<D>): void | Promise<void>;
+    apply(db: Database<D>): void | PromiseLike<void>;
 }
 /**
  * Set of writes that can be applied to documents in a database.
@@ -25,11 +25,11 @@ export declare class Writes<D extends Datas> extends Change<D> {
     readonly changes: ImmutableArray<Change<D>>;
     constructor(...changes: ImmutableArray<Change<D>>);
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    set<C extends Key<D>>({ collection, id }: DatabaseDocument<D, C>, data: D[C]): this;
+    set<C extends Key<D>>({ collection, id }: DatabaseDocument<C, D>, data: D[C]): this;
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    delete<C extends Key<D>>({ collection, id }: DatabaseDocument<D, C>): this;
+    delete<C extends Key<D>>({ collection, id }: DatabaseDocument<C, D>): this;
     /** Return a new `Changes` instance with an additional `Write` instance in its changes list. */
-    update<C extends Key<D>>({ collection, id }: DatabaseDocument<D, C>, transforms: Transforms<D[C]> | Transform<D[C]>): this;
+    update<C extends Key<D>>({ collection, id }: DatabaseDocument<C, D>, transforms: Transforms<D[C]> | Transform<D[C]>): this;
     apply(db: Database<D>): Promise<void> | undefined;
 }
 /** Set of hydrations for all change classes. */

package/db/Database.d.ts

@@ -1,4 +1,4 @@
-import { Dispatcher, Entry, Observable, Observer, Result, Unsubscriber, Datas, Results, Validatable, Validator, Validators, Key, Data, ImmutableMap } from "../util/index.js";
+import { Dispatcher, Entry, Observable, Observer, Result, Unsubscriber, Datas, ResultsMap, Validatable, Validator, Validators, Key, Data, Results } from "../util/index.js";
 import { Transform, Transforms } from "../transform/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
@@ -14,18 +14,18 @@ export declare class Database<D extends Datas> {
     readonly provider: Provider<D>;
     constructor(validators: Validators<D>, provider: Provider<D>);
     /** Create a query on a collection in this model. */
-    query<C extends Key<D>>(collection: C, filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null): DatabaseQuery<D, C>;
+    query<C extends Key<D>>(collection: C, filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null): DatabaseQuery<C, D>;
     /** Reference a document in a collection in this model. */
-    doc<C extends Key<D>>(collection: C, id: string): DatabaseDocument<D, C>;
+    doc<C extends Key<D>>(collection: C, id: string): DatabaseDocument<C, D>;
 }
 /** A documents reference within a specific database. */
-export declare class DatabaseQuery<D extends Datas, C extends Key<D>> extends Query<D[C]> implements Observable<Results<D[C]>>, Validatable<Results<D[C]>>, Iterable<Entry<D[C]>> {
+export declare class DatabaseQuery<C extends Key<D>, D extends Datas> extends Query<D[C]> implements Observable<Results<D[C]>>, Validatable<Results<D[C]>>, Iterable<Entry<D[C]>> {
     readonly db: Database<D>;
     readonly validator: Validator<D[C]>;
     readonly collection: C;
     constructor(db: Database<D>, collection: C, filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null);
     /** Reference a document in this query's collection. */
-    doc(id: string): DatabaseDocument<D, C>;
+    doc(id: string): DatabaseDocument<C, D>;
     /**
      * Create a new document with a random ID.
      * - Created document is guaranteed to have a unique ID.
@@ -33,22 +33,27 @@ export declare class DatabaseQuery<D extends Datas, C extends Key<D>> extends Qu
      * @param data Complete data to set the document to.
      * @return String ID for the created document (possibly promised).
      */
-    add(data: D[C]): string | Promise<string>;
+    add(data: D[C]): string | PromiseLike<string>;
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
-    get results(): Results<D[C]> | Promise<Results<D[C]>>;
+    get results(): Results<D[C]> | PromiseLike<Results<D[C]>>;
     /**
-     * Read the results of this query into a map.
-     * @return Set of results in `id: data` format (possibly promised).
+     * Get an iterable that yields the results of this entry.
+     * @return Map containing the results.
      */
-    get map(): ImmutableMap<D[C]> | Promise<ImmutableMap<D[C]>>;
+    get resultsMap(): ResultsMap<D[C]> | PromiseLike<ResultsMap<D[C]>>;
     /**
      * Count the number of results of this set of documents.
      * @return Number of documents in the collection (possibly promised).
      */
-    get count(): number | Promise<number>;
+    get count(): number | PromiseLike<number>;
+    /**
+     * Get an entry for the first document matching this query.
+     * @return Entry in `[id, data]` format for the first document, or `undefined` if there are no matching documents (possibly promised).
+     */
+    get first(): Entry<D[C]> | undefined | PromiseLike<Entry<D[C]> | undefined>;
     /**
      * Subscribe to all matching documents.
      * - `next()` is called once with the initial results, and again any time the results change.
@@ -62,17 +67,24 @@ export declare class DatabaseQuery<D extends Datas, C extends Key<D>> extends Qu
      */
     subscribe(next: Observer<Results<D[C]>> | Dispatcher<Results<D[C]>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
     /**
-     * Get an entry for the first document matching this query.
-     * @return Entry in `[id, data]` format for the first document, or `undefined` if there are no matching documents (possibly promised).
+     * Subscribe to all matching documents.
+     * - `next()` is called once with the initial results, and again any time the results change.
+     *
+     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
+     * @param next Callback that is called once initially and again whenever the results change.
+     * @param error Callback that is called if an error occurs.
+     * @param complete Callback that is called when the subscription is done.
+     *
+     * @return Function that ends the subscription.
      */
-    get first(): Entry<D[C]> | undefined | Promise<Entry<D[C]> | undefined>;
+    subscribeMap(next: Observer<ResultsMap<D[C]>> | Dispatcher<ResultsMap<D[C]>>, error?: Dispatcher<Error | unknown>, complete?: Dispatcher<void>): Unsubscriber;
     /**
      * Set all matching documents to the same exact value.
      *
      * @param data Complete data to set the document to.
      * @return Nothing (possibly promised).
      */
-    set(data: D[C]): void | Promise<void>;
+    set(data: D[C]): void | PromiseLike<void>;
     /**
      * Update all matching documents with the same partial value.
      *
@@ -81,17 +93,17 @@ export declare class DatabaseQuery<D extends Datas, C extends Key<D>> extends Qu
      *
      * @return Nothing (possibly promised).
      */
-    update(transform: Transform<D[C]> | Transforms<D[C]>): void | Promise<void>;
+    update(transform: Transform<D[C]> | Transforms<D[C]>): void | PromiseLike<void>;
     /**
      * Delete all matching documents.
      * @return Nothing (possibly promised).
      */
-    delete(): void | Promise<void>;
+    delete(): void | PromiseLike<void>;
     /**
      * Combine `set()`, `update()`, `delete()` into a single method.
      * @return Nothing (possibly promised).
      */
-    write(value: Result<D[C]> | Transform<D[C]>): void | Promise<void>;
+    write(value: Result<D[C]> | Transform<D[C]>): void | PromiseLike<void>;
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator](): Iterator<Entry<D[C]>, void>;
     /** Validate a set of results for this query reference. */
@@ -99,28 +111,28 @@ export declare class DatabaseQuery<D extends Datas, C extends Key<D>> extends Qu
     toString(): string;
 }
 /** A document reference within a specific database. */
-export declare class DatabaseDocument<D extends Datas, C extends Key<D>> implements Observable<Result<D[C]>>, Validatable<D[C]> {
+export declare class DatabaseDocument<C extends Key<D>, D extends Datas> implements Observable<Result<D[C]>>, Validatable<D[C]> {
     readonly db: Database<D>;
     readonly validator: Validator<D[C]>;
     readonly collection: C;
     readonly id: string;
     constructor(db: Database<D>, collection: C, id: string);
     /** Create a query on this document's collection. */
-    query(filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null): DatabaseQuery<D, C>;
+    query(filters?: Filters<D[C]>, sorts?: Sorts<D[C]>, limit?: number | null): DatabaseQuery<C, D>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
-    get optional(): DatabaseQuery<D, C>;
+    get optional(): DatabaseQuery<C, D>;
     /**
      * Does this document exist?
      *
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
-    get exists(): boolean | Promise<boolean>;
+    get exists(): boolean | PromiseLike<boolean>;
     /**
      * Get the result of this document.
      *
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
-    get result(): Result<D[C]> | Promise<Result<D[C]>>;
+    get result(): Result<D[C]> | PromiseLike<Result<D[C]>>;
     /**
      * Get the data of this document.
      * - Useful for destructuring, e.g. `{ name, title } = await documentThatMustExist.asyncData`
@@ -128,7 +140,7 @@ export declare class DatabaseDocument<D extends Datas, C extends Key<D>> impleme
      * @return Document's data (possibly promised).
      * @throws RequiredError if the document's result was undefined.
      */
-    get data(): D[C] | Promise<D[C]>;
+    get data(): D[C] | PromiseLike<D[C]>;
     /**
      * Subscribe to the result of this document (indefinitely).
      * - `next()` is called once with the initial result, and again any time the result changes.
@@ -148,7 +160,7 @@ export declare class DatabaseDocument<D extends Datas, C extends Key<D>> impleme
      *
      * @return Nothing (possibly promised).
      */
-    set(data: D[C]): void | Promise<void>;
+    set(data: D[C]): void | PromiseLike<void>;
     /**
      * Update this document with partial data.
      * - If the document exists, merge the partial data into it.
@@ -160,19 +172,29 @@ export declare class DatabaseDocument<D extends Datas, C extends Key<D>> impleme
      * @return Nothing (possibly promised).
      * @throws Error If the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    update(transforms: Transform<D[C]> | Transforms<D[C]>): void | Promise<void>;
+    update(transforms: Transform<D[C]> | Transforms<D[C]>): void | PromiseLike<void>;
     /**
      * Delete this document.
      * - Will not throw an error if the document doesn't exist.
      *
      * @return Nothing (possibly promised).
      */
-    delete(): void | Promise<void>;
+    delete(): void | PromiseLike<void>;
     /**
      * Combine `set()`, `update()`, `delete()` into a single method.
      */
-    write(value: Result<D[C]> | Transform<D[C]>): void | Promise<void>;
+    write(value: Result<D[C]> | Transform<D[C]>): void | PromiseLike<void>;
     /** Validate data for this query reference. */
     validate(unsafeData: Data): D[C];
     toString(): string;
 }
+/** Get the data for a document from a result for that document. */
+export declare function getDocumentData<C extends Key<D>, D extends Datas>(result: Result<D[C]>, ref: DatabaseDocument<C, D>): D[C];
+/** Database query with a collection name. */
+export declare type CollectionQuery<C extends string, T extends Data> = DatabaseQuery<C, {
+    [K in C]: T;
+}>;
+/** Database document with a collection name. */
+export declare type CollectionDocument<C extends string, T extends Data> = DatabaseDocument<C, {
+    [K in C]: T;
+}>;

package/db/Database.js

@@ -1,4 +1,4 @@
-import { deriveAsync, createObserver, getFirstItem, isAsync, throwAsync, validate, toMap, countItems, } from "../util/index.js";
+import { callAsync, createObserver, getFirstItem, throwAsync, validate, toMap, countItems, DeriveObserver, } from "../util/index.js";
 import { DataTransform, Transform } from "../transform/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
@@ -54,18 +54,25 @@ export class DatabaseQuery extends Query {
         return this.db.provider.getQuery(this);
     }
     /**
-     * Read the results of this query into a map.
-     * @return Set of results in `id: data` format (possibly promised).
+     * Get an iterable that yields the results of this entry.
+     * @return Map containing the results.
      */
-    get map() {
-        return deriveAsync(this.db.provider.getQuery(this), toMap);
+    get resultsMap() {
+        return callAsync(toMap, this.db.provider.getQuery(this));
     }
     /**
      * Count the number of results of this set of documents.
      * @return Number of documents in the collection (possibly promised).
      */
     get count() {
-        return deriveAsync(this.db.provider.getQuery(this), countItems);
+        return callAsync(countItems, this.results);
+    }
+    /**
+     * Get an entry for the first document matching this query.
+     * @return Entry in `[id, data]` format for the first document, or `undefined` if there are no matching documents (possibly promised).
+     */
+    get first() {
+        return callAsync(getFirstItem, this.max(1).results);
     }
     /**
      * Subscribe to all matching documents.
@@ -82,11 +89,18 @@ export class DatabaseQuery extends Query {
         return this.db.provider.subscribeQuery(this, createObserver(next, error, complete));
     }
     /**
-     * Get an entry for the first document matching this query.
-     * @return Entry in `[id, data]` format for the first document, or `undefined` if there are no matching documents (possibly promised).
+     * Subscribe to all matching documents.
+     * - `next()` is called once with the initial results, and again any time the results change.
+     *
+     * @param observer Observer with `next`, `error`, or `complete` methods that the document results are reported back to.
+     * @param next Callback that is called once initially and again whenever the results change.
+     * @param error Callback that is called if an error occurs.
+     * @param complete Callback that is called when the subscription is done.
+     *
+     * @return Function that ends the subscription.
      */
-    get first() {
-        return deriveAsync(this.max(1).results, getFirstItem);
+    subscribeMap(next, error, complete) {
+        return this.db.provider.subscribeQuery(this, new DeriveObserver(toMap, createObserver(next, error, complete)));
     }
     /**
      * Set all matching documents to the same exact value.
@@ -171,8 +185,7 @@ export class DatabaseDocument {
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
     get exists() {
-        const result = this.db.provider.get(this);
-        return isAsync(result) ? result.then(Boolean) : !!result;
+        return callAsync(Boolean, this.db.provider.get(this));
     }
     /**
      * Get the result of this document.
@@ -190,12 +203,7 @@ export class DatabaseDocument {
      * @throws RequiredError if the document's result was undefined.
      */
     get data() {
-        const result = this.db.provider.get(this);
-        if (isAsync(result))
-            return _awaitRequired(this, result);
-        if (!result)
-            throw new DocumentRequiredError(this);
-        return result;
+        return callAsync(getDocumentData, this.db.provider.get(this), this);
     }
     /**
      * Subscribe to the result of this document (indefinitely).
@@ -264,10 +272,9 @@ export class DatabaseDocument {
         return `${this.collection}/${this.id}`;
     }
 }
-/** Wait for a result and throw a `DocumentRequiredError` if the document doesn't exist. */
-async function _awaitRequired(ref, asyncResult) {
-    const result = await asyncResult;
-    if (!result)
-        throw new DocumentRequiredError(ref);
-    return result;
+/** Get the data for a document from a result for that document. */
+export function getDocumentData(result, ref) {
+    if (result)
+        return result;
+    throw new DocumentRequiredError(ref);
 }

package/db/Pagination.d.ts

@@ -1,26 +1,34 @@
-import { Results, Datas, Key, ImmutableMap, Entry } from "../util/index.js";
-import { AbstractState } from "../stream/index.js";
+import { Datas, Key, ResultsMap, Entry, Results } from "../util/index.js";
+import { State } from "../stream/index.js";
 import { DatabaseQuery } from "./Database.js";
 /**
  * State that wraps a `Documents` reference to enable pagination.
  * - If you pass in initial values, it will use that as the first page.
  * - If you don't pass in initial values, it will autoload the first page.
  */
-export declare class Pagination<D extends Datas, C extends Key<D>> extends AbstractState<Results<D[C]>, ImmutableMap<D[C]>> implements Iterable<Entry<D[C]>> {
-    protected _pending: boolean;
-    readonly ref: DatabaseQuery<D, C>;
-    constructor(ref: DatabaseQuery<D, C>);
+export declare class Pagination<C extends Key<D>, D extends Datas> extends State<ResultsMap<D[C]>> implements Iterable<Entry<D[C]>> {
+    readonly ref: DatabaseQuery<C, D>;
+    readonly limit: number;
+    readonly startLoading: boolean;
+    readonly startDone: boolean;
+    readonly endLoading: boolean;
+    readonly endDone: boolean;
+    constructor(ref: DatabaseQuery<C, D>);
     /**
      * Load more results before the start.
      * - Promise that needs to be handled.
      */
-    backward: () => Promise<void>;
+    loadStart: () => Promise<void>;
     /**
      * Load more results after the end.
      * - Promise that needs to be handled.
      */
-    forward: () => Promise<void>;
-    _derive(results: Results<D[C]>): void;
+    loadEnd: () => Promise<void>;
+    /**
+     * Merge more results into this pagination.
+     * @return The change in the number of results.
+     */
+    merge(more: Results<D[C]>): void;
     /** Iterate over the entries of the values currently in the pagination. */
     [Symbol.iterator](): Iterator<Entry<D[C]>>;
 }

package/db/Pagination.js

@@ -1,60 +1,77 @@
-import { getFirstItem, getLastItem, assertLength, assertNumber, yieldMerged } from "../util/index.js";
-import { AbstractState, StreamClosedError } from "../stream/index.js";
+import { getFirstItem, getLastItem, assertLength, assertNumber, yieldMerged, toMap } from "../util/index.js";
+import { State } from "../stream/index.js";
+import { ConditionError } from "../index.js";
 /**
  * State that wraps a `Documents` reference to enable pagination.
  * - If you pass in initial values, it will use that as the first page.
  * - If you don't pass in initial values, it will autoload the first page.
  */
-export class Pagination extends AbstractState {
+export class Pagination extends State {
     constructor(ref) {
         super();
-        this._pending = false;
+        this.startLoading = false;
+        this.startDone = false;
+        this.endLoading = false;
+        this.endDone = false;
         /**
          * Load more results before the start.
          * - Promise that needs to be handled.
          */
-        this.backward = async () => {
+        this.loadStart = async () => {
             if (this.closed)
-                throw new StreamClosedError();
-            if (!this._pending) {
-                const entry = getFirstItem(this.value);
-                this._pending = true;
-                this.next(await (entry ? this.ref.before(entry[0], entry[1]).results : this.ref.results));
+                throw new ConditionError();
+            if (!this.startLoading) {
+                this.startLoading = true;
+                if (!this.loading) {
+                    const firstItem = getFirstItem(this.value);
+                    if (firstItem) {
+                        const next = await this.ref.after(firstItem[0], firstItem[1]).resultsMap;
+                        this.startDone = next.size < this.limit;
+                        this.startLoading = false;
+                        return this.merge(next);
+                    }
+                }
+                const next = await this.ref.resultsMap;
+                this.startDone = next.size < this.limit;
+                this.startLoading = false;
+                return this.next(next);
             }
         };
         /**
          * Load more results after the end.
          * - Promise that needs to be handled.
          */
-        this.forward = async () => {
+        this.loadEnd = async () => {
             if (this.closed)
-                throw new StreamClosedError();
-            if (!this._pending) {
-                const entry = getLastItem(this.value);
-                this._pending = true;
-                this.next(await (entry ? this.ref.after(entry[0], entry[1]).results : this.ref.results));
+                throw new ConditionError();
+            if (!this.endLoading) {
+                this.endLoading = true;
+                if (!this.loading) {
+                    const lastItem = getLastItem(this.value);
+                    if (lastItem) {
+                        const next = await this.ref.after(lastItem[0], lastItem[1]).resultsMap;
+                        this.endDone = next.size < this.limit;
+                        this.endLoading = false;
+                        return this.merge(next);
+                    }
+                }
+                const next = await this.ref.resultsMap;
+                this.endDone = next.size < this.limit;
+                this.endLoading = false;
+                return this.next(next);
             }
         };
         this.ref = ref;
         assertNumber(ref.limit); // Collection must have a numeric limit to paginate (otherwise you'd be retrieving the entire set of documents).
         assertLength(ref.sorts, 1, Infinity); // Collection must have at least one sort order to paginate.
+        this.limit = ref.limit;
     }
-    // Dispatch doesn't just dispatch the next value, it merges it into the current results and dispatches the combined results.
-    _derive(results) {
-        this._pending = false;
-        if (this.loading) {
-            // Merge the results into the existing results.
-            const current = this.value;
-            const next = new Map(this.ref.sorts.derive(yieldMerged(this.value, results)));
-            const change = next.size - current.size;
-            super._dispatch(next);
-            // Automatically complete the pagination if there are fewer entries than the slice limit.
-            if (typeof this.ref.limit === "number" && change < this.ref.limit)
-                this.complete();
-        }
-        else {
-            super._dispatch(new Map(results));
-        }
+    /**
+     * Merge more results into this pagination.
+     * @return The change in the number of results.
+     */
+    merge(more) {
+        this.next(toMap(this.ref.sorts.derive(yieldMerged(more, this.value))));
     }
     /** Iterate over the entries of the values currently in the pagination. */
     [Symbol.iterator]() {

package/db/errors.d.ts

@@ -4,16 +4,16 @@ import { Feedback } from "../feedback/index.js";
 import type { DatabaseDocument, DatabaseQuery } from "./Database.js";
 /** Thrown if a document doesn't exist. */
 export declare class DocumentRequiredError<D extends Datas, C extends Key<D>> extends RequiredError {
-    ref: DatabaseDocument<D, C>;
-    constructor(ref: DatabaseDocument<D, C>);
+    ref: DatabaseDocument<C, D>;
+    constructor(ref: DatabaseDocument<C, D>);
 }
 /** Thrown if a document can't validate. */
 export declare class DocumentValidationError<D extends Datas, C extends Key<D>> extends ValidationError {
-    ref: DatabaseDocument<D, C>;
-    constructor(ref: DatabaseDocument<D, C>, feedback: Feedback);
+    ref: DatabaseDocument<C, D>;
+    constructor(ref: DatabaseDocument<C, D>, feedback: Feedback);
 }
 /** Thrown if a query can't validate a set of results. */
 export declare class QueryValidationError<D extends Datas, C extends Key<D>> extends ValidationError {
-    ref: DatabaseQuery<D, C>;
-    constructor(ref: DatabaseQuery<D, C>, feedback: Feedback);
+    ref: DatabaseQuery<C, D>;
+    constructor(ref: DatabaseQuery<C, D>, feedback: Feedback);
 }

package/error/ConditionError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Thrown if the program is in a condition it shouldn't have reached.
+ * e.g. writing to a stream that's already closed
+ */
+export declare class ConditionError extends Error {
+    constructor(message?: string);
+}

package/error/ConditionError.js

@@ -0,0 +1,10 @@
+/**
+ * Thrown if the program is in a condition it shouldn't have reached.
+ * e.g. writing to a stream that's already closed
+ */
+export class ConditionError extends Error {
+    constructor(message = "Invalid condition") {
+        super(message);
+    }
+}
+ConditionError.prototype.name = "ConditionError";

package/error/index.d.ts

@@ -3,3 +3,4 @@ export * from "./PermissionError.js";
 export * from "./RequiredError.js";
 export * from "./UnsupportedError.js";
 export * from "./ValidationError.js";
+export * from "./ConditionError.js";

package/error/index.js

@@ -3,3 +3,4 @@ export * from "./PermissionError.js";
 export * from "./RequiredError.js";
 export * from "./UnsupportedError.js";
 export * from "./ValidationError.js";
+export * from "./ConditionError.js";

package/firestore/client/FirestoreClientProvider.d.ts

@@ -9,11 +9,11 @@ import { Results, Provider, DatabaseDocument, DatabaseQuery, Result, Observer, T
 export declare class FirestoreClientProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<D, C>, observer: Observer<Result<D[C]>>): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Promise<Results<D[C]>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, observer: Observer<Results<D[C]>>): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Promise<Result<D[C]>>;
+    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): () => void;
+    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): Promise<string>;
+    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Promise<Results<D[C]>>;
+    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): () => void;
+    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
 }

package/firestore/lite/FirestoreLiteProvider.d.ts

@@ -1,5 +1,5 @@
 import type { Firestore } from "firebase/firestore/lite";
-import { Results, Provider, DatabaseDocument, DatabaseQuery, Result, Transform, AsynchronousProvider, Datas, Key } from "../../index.js";
+import { Provider, DatabaseDocument, DatabaseQuery, Result, Transform, AsynchronousProvider, Datas, Key, Results } from "../../index.js";
 /**
  * Firestore Lite client database provider.
  * - Works with the Firebase JS SDK.
@@ -9,11 +9,11 @@ import { Results, Provider, DatabaseDocument, DatabaseQuery, Result, Transform,
 export declare class FirestoreClientProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
     readonly firestore: Firestore;
     constructor(firestore: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Promise<Result<D[C]>>;
+    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Promise<Result<D[C]>>;
     subscribe(): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Promise<Results<D[C]>>;
+    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): Promise<string>;
+    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Promise<Results<D[C]>>;
     subscribeQuery(): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
 }

package/firestore/server/FirestoreServerProvider.d.ts

@@ -1,5 +1,5 @@
 import { Firestore } from "@google-cloud/firestore";
-import { Results, Provider, DatabaseDocument, DatabaseQuery, Observer, Result, Transform, AsynchronousProvider, Datas, Key, Entry } from "../../index.js";
+import { Provider, DatabaseDocument, DatabaseQuery, Observer, Result, Transform, AsynchronousProvider, Datas, Key, Entry, Results } from "../../index.js";
 /**
  * Firestore server database provider.
  * - Works with the Firebase Admin SDK for Node.JS
@@ -7,11 +7,11 @@ import { Results, Provider, DatabaseDocument, DatabaseQuery, Observer, Result, T
 export declare class FirestoreServerProvider<D extends Datas> extends Provider<D> implements AsynchronousProvider<D> {
     readonly firestore: Firestore;
     constructor(firestore?: Firestore);
-    get<C extends Key<D>>(ref: DatabaseDocument<D, C>): Promise<Result<D[C]>>;
-    subscribe<C extends Key<D>>(ref: DatabaseDocument<D, C>, observer: Observer<Result<D[C]>>): () => void;
-    add<C extends Key<D>>(ref: DatabaseQuery<D, C>, data: D[C]): Promise<string>;
-    write<C extends Key<D>>(ref: DatabaseDocument<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
-    getQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>): Promise<Iterable<Entry<D[C]>>>;
-    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, observer: Observer<Results<D[C]>>): () => void;
-    writeQuery<C extends Key<D>>(ref: DatabaseQuery<D, C>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    get<C extends Key<D>>(ref: DatabaseDocument<C, D>): Promise<Result<D[C]>>;
+    subscribe<C extends Key<D>>(ref: DatabaseDocument<C, D>, observer: Observer<Result<D[C]>>): () => void;
+    add<C extends Key<D>>(ref: DatabaseQuery<C, D>, data: D[C]): Promise<string>;
+    write<C extends Key<D>>(ref: DatabaseDocument<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
+    getQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>): Promise<Iterable<Entry<D[C]>>>;
+    subscribeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, observer: Observer<Results<D[C]>>): () => void;
+    writeQuery<C extends Key<D>>(ref: DatabaseQuery<C, D>, value: D[C] | Transform<D[C]> | undefined): Promise<void>;
 }

package/package.json

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