shelving 1.41.0 → 1.44.1

package/db/Database.d.ts

@@ -29,10 +29,10 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
 }
 /** A documents reference within a specific database. */
 export declare class DatabaseQuery<T extends Data = Data> extends Query<T> implements Observable<Results<T>>, Validatable<Entries<T>>, Iterable<Entry<T>> {
-    readonly provider: Provider;
+    readonly db: Database;
     readonly validator: Validator<T>;
     readonly collection: string;
-    constructor(provider: Provider, validator: Validator<T>, collection: string, filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null);
+    constructor(db: Database, validator: Validator<T>, collection: string, filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null);
     /** Reference a document in this query's collection. */
     doc(id: string): DatabaseDocument<T>;
     /**
@@ -114,11 +114,11 @@ export declare class DatabaseQuery<T extends Data = Data> extends Query<T> imple
 export declare function getQueryData<T extends Data>(entries: Entries<T>, ref: DatabaseQuery<T>): Entry<T>;
 /** A document reference within a specific database. */
 export declare class DatabaseDocument<T extends Data = Data> implements Observable<Result<T>>, Validatable<T> {
-    readonly provider: Provider;
+    readonly db: Database;
     readonly validator: Validator<T>;
     readonly collection: string;
     readonly id: string;
-    constructor(provider: Provider, validator: Validator<T>, collection: string, id: string);
+    constructor(db: Database, validator: Validator<T>, collection: string, id: string);
     /** Create a query on this document's collection. */
     query(filters?: Filters<T>, sorts?: Sorts<T>, limit?: number | null): DatabaseQuery<T>;
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */

package/db/Database.js

@@ -18,11 +18,11 @@ export class Database {
     }
     /** Create a query on a collection in this model. */
     query(collection, filters, sorts, limit) {
-        return new DatabaseQuery(this.provider, this.validators[collection], collection, filters, sorts, limit);
+        return new DatabaseQuery(this, this.validators[collection], collection, filters, sorts, limit);
     }
     /** Reference a document in a collection in this model. */
     doc(collection, id) {
-        return new DatabaseDocument(this.provider, this.validators[collection], collection, id);
+        return new DatabaseDocument(this, this.validators[collection], collection, id);
     }
     /**
      * Create a new document with a random ID.
@@ -38,15 +38,15 @@ export class Database {
 }
 /** A documents reference within a specific database. */
 export class DatabaseQuery extends Query {
-    constructor(provider, validator, collection, filters, sorts, limit) {
+    constructor(db, validator, collection, filters, sorts, limit) {
         super(filters, sorts, limit);
-        this.provider = provider;
+        this.db = db;
         this.validator = validator;
         this.collection = collection;
     }
     /** Reference a document in this query's collection. */
     doc(id) {
-        return new DatabaseDocument(this.provider, this.validator, this.collection, id);
+        return new DatabaseDocument(this.db, this.validator, this.collection, id);
     }
     /**
      * Create a new document with a random ID.
@@ -56,21 +56,21 @@ export class DatabaseQuery extends Query {
      * @return String ID for the created document (possibly promised).
      */
     add(data) {
-        return this.provider.add(this, data);
+        return this.db.provider.add(this, data);
     }
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
     get entries() {
-        return this.provider.getQuery(this);
+        return this.db.provider.getQuery(this);
     }
     /**
      * Get an iterable that yields the results of this entry.
      * @return Map containing the results.
      */
     get results() {
-        return callAsync(getMap, this.provider.getQuery(this));
+        return callAsync(getMap, this.db.provider.getQuery(this));
     }
     /**
      * Count the number of results of this set of documents.
@@ -84,7 +84,7 @@ export class DatabaseQuery extends Query {
      * @return `true` if a document exists or `false` otherwise (possibly promised).
      */
     get exists() {
-        return callAsync(hasItems, this.provider.getQuery(this.max(1)));
+        return callAsync(hasItems, this.db.provider.getQuery(this.max(1)));
     }
     /**
      * Get an entry for the first document matched by this query or `undefined` if this query has no results.
@@ -93,7 +93,7 @@ export class DatabaseQuery extends Query {
      * @throws RequiredError if there were no results for this query.
      */
     get result() {
-        return callAsync(getFirstItem, this.provider.getQuery(this.max(1)));
+        return callAsync(getFirstItem, this.db.provider.getQuery(this.max(1)));
     }
     /**
      * Get an entry for the first document matched by this query.
@@ -102,7 +102,7 @@ export class DatabaseQuery extends Query {
      * @throws RequiredError if there were no results for this query.
      */
     get data() {
-        return callAsync(getQueryData, this.provider.getQuery(this.max(1)), this);
+        return callAsync(getQueryData, this.db.provider.getQuery(this.max(1)), this);
     }
     /**
      * Subscribe to all matching documents.
@@ -112,7 +112,7 @@ export class DatabaseQuery extends Query {
      * @return Function that ends the subscription.
      */
     subscribe(next) {
-        return this.provider.subscribeQuery(this, new ResultsObserver(typeof next === "function" ? { next } : next));
+        return this.db.provider.subscribeQuery(this, new ResultsObserver(typeof next === "function" ? { next } : next));
     }
     /**
      * Set all matching documents to the same exact value.
@@ -121,7 +121,7 @@ export class DatabaseQuery extends Query {
      * @return Nothing (possibly promised).
      */
     set(data) {
-        return this.provider.setQuery(this, data);
+        return this.db.provider.setQuery(this, data);
     }
     /**
      * Update all matching documents with the same partial value.
@@ -130,14 +130,14 @@ export class DatabaseQuery extends Query {
      * @return Nothing (possibly promised).
      */
     update(updates) {
-        return this.provider.updateQuery(this, updates instanceof Update ? updates : new DataUpdate(updates));
+        return this.db.provider.updateQuery(this, updates instanceof Update ? updates : new DataUpdate(updates));
     }
     /**
      * Delete all matching documents.
      * @return Nothing (possibly promised).
      */
     delete() {
-        return this.provider.deleteQuery(this);
+        return this.db.provider.deleteQuery(this);
     }
     /** Iterate over the resuls (will throw `Promise` if the results are asynchronous). */
     [Symbol.iterator]() {
@@ -175,33 +175,33 @@ export function getQueryData(entries, ref) {
 }
 /** A document reference within a specific database. */
 export class DatabaseDocument {
-    constructor(provider, validator, collection, id) {
-        this.provider = provider;
+    constructor(db, validator, collection, id) {
+        this.db = db;
         this.validator = validator;
         this.collection = collection;
         this.id = id;
     }
     /** Create a query on this document's collection. */
     query(filters, sorts, limit) {
-        return new DatabaseQuery(this.provider, this.validator, this.collection, filters, sorts, limit);
+        return new DatabaseQuery(this.db, this.validator, this.collection, filters, sorts, limit);
     }
     /** Get an 'optional' reference to this document (uses a `ModelQuery` with an `id` filter). */
     get optional() {
-        return new DatabaseQuery(this.provider, this.validator, this.collection, new Filters(new EqualFilter("id", this.id)));
+        return new DatabaseQuery(this.db, this.validator, this.collection, new Filters(new EqualFilter("id", this.id)));
     }
     /**
      * Does this document exist?
      * @return `true` if a document exists or `false` otherwise (possibly promised).
      */
     get exists() {
-        return callAsync(Boolean, this.provider.get(this));
+        return callAsync(Boolean, this.db.provider.get(this));
     }
     /**
      * Get the result of this document.
      * @return Document's data, or `undefined` if the document doesn't exist (possibly promised).
      */
     get result() {
-        return this.provider.get(this);
+        return this.db.provider.get(this);
     }
     /**
      * Get the data of this document.
@@ -211,7 +211,7 @@ export class DatabaseDocument {
      * @throws RequiredError if the document's result was undefined.
      */
     get data() {
-        return callAsync(getDocumentData, this.provider.get(this), this);
+        return callAsync(getDocumentData, this.db.provider.get(this), this);
     }
     /**
      * Subscribe to the result of this document (indefinitely).
@@ -221,19 +221,19 @@ export class DatabaseDocument {
      * @return Function that ends the subscription.
      */
     subscribe(next) {
-        return this.provider.subscribe(this, typeof next === "function" ? { next } : next);
+        return this.db.provider.subscribe(this, typeof next === "function" ? { next } : next);
     }
     /** Set the complete data of this document. */
     set(data) {
-        return this.provider.set(this, data);
+        return this.db.provider.set(this, data);
     }
     /** Update this document. */
     update(updates) {
-        return this.provider.update(this, updates instanceof Update ? updates : new DataUpdate(updates));
+        return this.db.provider.update(this, updates instanceof Update ? updates : new DataUpdate(updates));
     }
     /** Delete this document. */
     delete() {
-        return this.provider.delete(this);
+        return this.db.provider.delete(this);
     }
     /** Validate data for this query reference. */
     validate(unsafeData) {

package/db/Operation.d.ts

@@ -0,0 +1,82 @@
+import { PropUpdates, Update } from "../update/index.js";
+import { ImmutableArray, Nullish, Data, Key } from "../util/index.js";
+import type { Database, DatabaseDocument, DatabaseQuery } from "./Database.js";
+/** Represent a write operation on a database. */
+export declare abstract class Operation {
+    /** Run this operation and return the result operation. */
+    abstract run(db: Database): Promise<Operation>;
+}
+/** Represent a list of write operations on a database run in series. */
+export declare class Operations extends Operation {
+    /** Return a new write operations list with a set of write operations. */
+    static with(...operations: Nullish<Operation>[]): Operations;
+    readonly operations: ImmutableArray<Operation>;
+    constructor(operations: ImmutableArray<Nullish<Operation>>);
+    run(db: Database): Promise<Operations>;
+    /** Return a new write operations list with an additional write operation added. */
+    with(...operations: Nullish<Operation>[]): {
+        __proto__: any;
+    } & this & {
+        operations: (Operation | Nullish<Operation>[])[];
+    };
+}
+/** Represent a add operation made to a collection in a database. */
+export declare class AddOperation<T extends Data> extends Operation {
+    /** Create a new add operation on a collection. */
+    static on<X extends Data>({ collection }: DatabaseDocument<X> | DatabaseQuery<X>, data: X): AddOperation<X>;
+    /** Run a new add operation on a collection and return the result operation. */
+    static run<X extends Data>({ collection, db }: DatabaseDocument<X> | DatabaseQuery<X>, data: X): Promise<SetOperation<X>>;
+    readonly collection: string;
+    readonly data: T;
+    constructor(collection: string, data: T);
+    run(db: Database): Promise<SetOperation<T>>;
+    /** Set one of the props on this set operation to a different value. */
+    with<K extends Key<T>>(key: Nullish<K>, value: T[K]): this;
+}
+/** Represent a set operation made to a single document in a database. */
+export declare class SetOperation<T extends Data> extends Operation {
+    /** Create a new add operation on a collection. */
+    static on<X extends Data>({ collection, id }: DatabaseDocument<X>, data: X): SetOperation<X>;
+    /** Run a new set operation on a collection and return the result operation. */
+    static run<X extends Data>({ collection, id, db }: DatabaseDocument<X>, data: X): Promise<SetOperation<X>>;
+    readonly collection: string;
+    readonly id: string;
+    readonly data: T;
+    constructor(collection: string, id: string, data: T);
+    run(db: Database): Promise<this>;
+    /** Set one of the props on this set operation to a different value. */
+    with<K extends Key<T>>(key: Nullish<K>, value: T[K]): this;
+}
+/** Represent an update operation made to a single document in a database. */
+export declare class UpdateOperation<T extends Data> extends Operation {
+    /** Create a new update operation on a document. */
+    static on<X extends Data>({ collection, id }: DatabaseDocument<X>, updates: PropUpdates<X>): UpdateOperation<X>;
+    /** Run a new set operation on a collection and return the result operation. */
+    static run<X extends Data>({ collection, id, db }: DatabaseDocument<X>, updates: PropUpdates<X>): Promise<UpdateOperation<X>>;
+    readonly collection: string;
+    readonly id: string;
+    readonly updates: PropUpdates<T>;
+    constructor(collection: string, id: string, updates: PropUpdates<T>);
+    run(db: Database): Promise<this>;
+    /** update one of the props on this set operation to a different value. */
+    with<K extends Key<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
+}
+/** Represent a delete operation made to a single document in a database. */
+export declare class DeleteOperation extends Operation {
+    /** Create a new delete operation on a document. */
+    static on<X extends Data>({ collection, id }: DatabaseDocument<X>): DeleteOperation;
+    /** Run a new delete operation on a document. */
+    static run<X extends Data>({ collection, id, db }: DatabaseDocument<X>): Promise<DeleteOperation>;
+    readonly collection: string;
+    readonly id: string;
+    constructor(collection: string, id: string);
+    run(db: Database): Promise<this>;
+}
+/** Set of hydrations for all change classes. */
+export declare const OPERATION_HYDRATIONS: {
+    Operations: typeof Operations;
+    AddOperation: typeof AddOperation;
+    SetOperation: typeof SetOperation;
+    UpdateOperation: typeof UpdateOperation;
+    DeleteOperation: typeof DeleteOperation;
+};

package/db/Operation.js

@@ -0,0 +1,132 @@
+import { callAsyncSeries, isNotNullish, isNullish } from "../util/index.js";
+/** Represent a write operation on a database. */
+export class Operation {
+}
+/** Represent a list of write operations on a database run in series. */
+export class Operations extends Operation {
+    constructor(operations) {
+        super();
+        this.operations = operations.filter(isNotNullish);
+    }
+    /** Return a new write operations list with a set of write operations. */
+    static with(...operations) {
+        return new Operations(operations);
+    }
+    async run(db) {
+        return new Operations(await callAsyncSeries(_write, this.operations, db));
+    }
+    /** Return a new write operations list with an additional write operation added. */
+    with(...operations) {
+        return { __proto__: Object.getPrototypeOf(this), ...this, operations: [...this.operations, operations] };
+    }
+}
+const _write = (operation, db) => operation.run(db);
+/** Represent a add operation made to a collection in a database. */
+export class AddOperation extends Operation {
+    constructor(collection, data) {
+        super();
+        this.collection = collection;
+        this.data = data;
+    }
+    /** Create a new add operation on a collection. */
+    static on({ collection }, data) {
+        return new AddOperation(collection, data);
+    }
+    /** Run a new add operation on a collection and return the result operation. */
+    static run({ collection, db }, data) {
+        return new AddOperation(collection, data).run(db);
+    }
+    async run(db) {
+        const id = await db.query(this.collection).add(this.data);
+        return new SetOperation(this.collection, id, this.data); // When an add operation is run it returns a set operation so the operation is repeatable.
+    }
+    /** Set one of the props on this set operation to a different value. */
+    with(key, value) {
+        if (isNullish(key))
+            return this;
+        return { __proto__: Object.getPrototypeOf(this), ...this, data: { ...this.data, [key]: value } };
+    }
+}
+/** Represent a set operation made to a single document in a database. */
+export class SetOperation extends Operation {
+    constructor(collection, id, data) {
+        super();
+        this.collection = collection;
+        this.id = id;
+        this.data = data;
+    }
+    /** Create a new add operation on a collection. */
+    static on({ collection, id }, data) {
+        return new SetOperation(collection, id, data);
+    }
+    /** Run a new set operation on a collection and return the result operation. */
+    static run({ collection, id, db }, data) {
+        return new SetOperation(collection, id, data).run(db);
+    }
+    async run(db) {
+        await db.doc(this.collection, this.id).set(this.data);
+        return this;
+    }
+    /** Set one of the props on this set operation to a different value. */
+    with(key, value) {
+        if (isNullish(key))
+            return this;
+        return { __proto__: Object.getPrototypeOf(this), ...this, data: { ...this.data, [key]: value } };
+    }
+}
+/** Represent an update operation made to a single document in a database. */
+export class UpdateOperation extends Operation {
+    constructor(collection, id, updates) {
+        super();
+        this.collection = collection;
+        this.id = id;
+        this.updates = updates;
+    }
+    /** Create a new update operation on a document. */
+    static on({ collection, id }, updates) {
+        return new UpdateOperation(collection, id, updates);
+    }
+    /** Run a new set operation on a collection and return the result operation. */
+    static run({ collection, id, db }, updates) {
+        return new UpdateOperation(collection, id, updates).run(db);
+    }
+    async run(db) {
+        await db.doc(this.collection, this.id).update(this.updates);
+        return this;
+    }
+    /** update one of the props on this set operation to a different value. */
+    with(key, value) {
+        if (isNullish(key))
+            return this;
+        return { __proto__: Object.getPrototypeOf(this), ...this, updates: { ...this.updates, [key]: value } };
+    }
+}
+/** Represent a delete operation made to a single document in a database. */
+export class DeleteOperation extends Operation {
+    constructor(collection, id) {
+        super();
+        this.collection = collection;
+        this.id = id;
+    }
+    /** Create a new delete operation on a document. */
+    static on({ collection, id }) {
+        return new DeleteOperation(collection, id);
+    }
+    /** Run a new delete operation on a document. */
+    static run({ collection, id, db }) {
+        return new DeleteOperation(collection, id).run(db);
+    }
+    async run(db) {
+        await db.doc(this.collection, this.id).delete();
+        return this;
+    }
+}
+/** Set of hydrations for all change classes. */
+export const OPERATION_HYDRATIONS = {
+    Operations: Operations,
+    AddOperation,
+    SetOperation,
+    UpdateOperation,
+    DeleteOperation,
+};
+OPERATION_HYDRATIONS;

package/db/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./Database.js";
+export * from "./Operation.js";
 export * from "./Pagination.js";
 export * from "./errors.js";

package/db/index.js

@@ -1,3 +1,4 @@
 export * from "./Database.js";
+export * from "./Operation.js";
 export * from "./Pagination.js";
 export * from "./errors.js";

package/index.d.ts

@@ -13,5 +13,4 @@ export * from "./feedback/index.js";
 export * from "./markup/index.js";
 export * from "./stream/index.js";
 export * from "./update/index.js";
-export * from "./operation/index.js";
 export * from "./util/index.js";

package/index.js

@@ -15,7 +15,6 @@ export * from "./feedback/index.js";
 export * from "./markup/index.js";
 export * from "./stream/index.js";
 export * from "./update/index.js";
-export * from "./operation/index.js";
 export * from "./util/index.js";
 // Integrations.
 // export * from "./react/index.js"; // Not exported.

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.41.0",
+	"version": "1.44.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -63,14 +63,14 @@
 		"@types/jest": "^27.4.0",
 		"@types/react": "^17.0.38",
 		"@types/react-dom": "^17.0.11",
-		"@typescript-eslint/eslint-plugin": "^5.8.1",
-		"@typescript-eslint/parser": "^5.8.1",
+		"@typescript-eslint/eslint-plugin": "^5.9.0",
+		"@typescript-eslint/parser": "^5.9.0",
 		"eslint": "^8.6.0",
 		"eslint-config-prettier": "^8.3.0",
-		"eslint-plugin-import": "^2.25.3",
+		"eslint-plugin-import": "^2.25.4",
 		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.6.1",
-		"jest": "^27.4.5",
+		"firebase": "^9.6.2",
+		"jest": "^27.4.7",
 		"jest-ts-webcompat-resolver": "^1.0.0",
 		"prettier": "^2.5.1",
 		"react": "^17.0.2",

package/react/useDocument.js

@@ -30,13 +30,13 @@ export function useAsyncDocument(ref, maxAge = 1000) {
 function getCachedResult(ref) {
     if (!ref)
         return undefined;
-    const provider = findSourceProvider(ref.provider, CacheProvider);
+    const provider = findSourceProvider(ref.db.provider, CacheProvider);
     return provider.isCached(ref) ? provider.cache.get(ref) : NOVALUE;
 }
 /** Effect that subscribes a component to the cache for a reference. */
 function subscribeEffect(ref, maxAge, next, error) {
     if (ref) {
-        const provider = findSourceProvider(ref.provider, CacheProvider);
+        const provider = findSourceProvider(ref.db.provider, CacheProvider);
         const stopCache = provider.cache.subscribe(ref, { next, error });
         if (maxAge === true) {
             // If `maxAge` is true subscribe to the source for as long as this component is attached.

package/react/useQuery.js

@@ -30,18 +30,18 @@ export function useAsyncQuery(ref, maxAge = 1000) {
 function getCachedResults(ref) {
     if (!ref)
         return undefined;
-    const provider = findSourceProvider(ref.provider, CacheProvider);
+    const provider = findSourceProvider(ref.db.provider, CacheProvider);
     return provider.isCached(ref) ? getMap(provider.cache.getQuery(ref)) : NOVALUE;
 }
 /** Effect that subscribes a component to the cache for a reference. */
 function subscribeEffect(ref, maxAge, next, error) {
     if (ref) {
-        const provider = findSourceProvider(ref.provider, CacheProvider);
+        const provider = findSourceProvider(ref.db.provider, CacheProvider);
         const observer = new ResultsObserver({ next, error });
         const stopCache = provider.cache.subscribeQuery(ref, observer);
         if (maxAge === true) {
             // If `maxAge` is true subscribe to the source for as long as this component is attached.
-            const stopSource = ref.provider.subscribeQuery(ref, observer);
+            const stopSource = ref.db.provider.subscribeQuery(ref, observer);
             return () => {
                 stopCache();
                 stopSource();

package/update/DataUpdate.d.ts

@@ -12,10 +12,12 @@ export declare type PropUpdates<T extends Data> = {
 };
 /** Update that can be applied to a data object to update its props. */
 export declare class DataUpdate<T extends Data> extends Update<T> implements Iterable<Prop<PropUpdates<T>>>, Transformable<T, T> {
+    /** Return a data update with a specific prop marked for update. */
+    static with<X extends Data, K extends Key<X>>(key: Nullish<K>, value: X[K] | Update<X[K]>): DataUpdate<X>;
     readonly updates: PropUpdates<T>;
     constructor(props: PropUpdates<T>);
     transform(existing: T): T;
-    /** Return a new object with the specified additional transform for a prop. */
+    /** Return a data update with a specific prop marked for update. */
     with<K extends Key<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
     /** Iterate over the transforms in this object. */
     [Symbol.iterator](): Iterator<Prop<PropUpdates<T>>, void>;

package/update/DataUpdate.js

@@ -6,10 +6,14 @@ export class DataUpdate extends Update {
         super();
         this.updates = props;
     }
+    /** Return a data update with a specific prop marked for update. */
+    static with(key, value) {
+        return new DataUpdate(!isNullish(key) ? { [key]: value } : {});
+    }
     transform(existing) {
         return transformProps(existing, this.updates);
     }
-    /** Return a new object with the specified additional transform for a prop. */
+    /** Return a data update with a specific prop marked for update. */
     with(key, value) {
         if (isNullish(key))
             return this;