shelving 1.40.0 → 1.41.0

package/db/Database.d.ts

@@ -1,8 +1,7 @@
-import { Entry, Observable, Observer, Result, Unsubscriber, Results, Validatable, Validator, Key, Data, Entries, Datas, Validators, ValidatorType, Dispatcher, Nullish } from "../util/index.js";
+import { Entry, Observable, Observer, Result, Unsubscriber, Results, Validatable, Validator, Key, Data, Entries, Datas, Validators, ValidatorType, Dispatcher } from "../util/index.js";
 import { PropUpdates, Update } from "../update/index.js";
 import type { Provider } from "../provider/Provider.js";
 import { Filters, Sorts, Query } from "../query/index.js";
-import { DocumentDelete, DocumentSet, DocumentUpdate, Write } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -18,10 +17,15 @@ export declare class Database<V extends Validators<Datas> = Validators<Datas>> {
     query<K extends Key<V>>(collection: K, filters?: Filters<ValidatorType<V[K]>>, sorts?: Sorts<ValidatorType<V[K]>>, limit?: number | null): DatabaseQuery<ValidatorType<V[K]>>;
     /** Reference a document in a collection in this model. */
     doc<K extends Key<V>>(collection: K, id: string): DatabaseDocument<ValidatorType<V[K]>>;
-    /** Create a writer for this database from a set of separate writes. */
-    writer(...writes: Nullish<Write>[]): Write;
-    /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
-    write(...writes: Nullish<Write>[]): Promise<Write>;
+    /**
+     * 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).
+     */
+    add<K extends Key<V>>(collection: K, data: ValidatorType<V[K]>): string | PromiseLike<string>;
 }
 /** 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>> {
@@ -151,12 +155,6 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
     update(updates: Update<T> | PropUpdates<T>): void | PromiseLike<void>;
     /** Delete this document. */
     delete(): void | PromiseLike<void>;
-    /** Represent a write that sets the complete data of this document in a database. */
-    setter(data: T): DocumentSet<T>;
-    /** Represent a write that updates this document in a database. */
-    updater(updates: PropUpdates<T>): DocumentUpdate<T>;
-    /** Represent a write that deletes this document in a database. */
-    deleter(): DocumentDelete<T>;
     /** Validate data for this query reference. */
     validate(unsafeData: Data): T;
     toString(): string;

package/db/Database.js

@@ -1,9 +1,8 @@
-import { callAsync, getFirstItem, throwAsync, validate, getMap, countItems, isNotNullish, hasItems, ResultsObserver, } from "../util/index.js";
+import { callAsync, getFirstItem, throwAsync, validate, getMap, countItems, hasItems, ResultsObserver, } from "../util/index.js";
 import { DataUpdate, Update } from "../update/index.js";
 import { Feedback, InvalidFeedback } from "../feedback/index.js";
 import { Filters, Query, EqualFilter } from "../query/index.js";
 import { DocumentRequiredError, DocumentValidationError, QueryRequiredError, QueryValidationError } from "./errors.js";
-import { DocumentDelete, DocumentSet, DocumentUpdate, Writes } from "./Write.js";
 /**
  * Combines a database model and a provider.
  *
@@ -25,15 +24,16 @@ export class Database {
     doc(collection, id) {
         return new DatabaseDocument(this.provider, this.validators[collection], collection, id);
     }
-    /** Create a writer for this database from a set of separate writes. */
-    writer(...writes) {
-        return new Writes(...writes.filter(isNotNullish));
-    }
-    /** Perform one or more writes on this database and return the `Writes` instance representing the combined changes. */
-    async write(...writes) {
-        const write = new Writes(...writes.filter(isNotNullish));
-        await write.transform(this);
-        return write;
+    /**
+     * 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).
+     */
+    add(collection, data) {
+        return this.query(collection).add(data);
     }
 }
 /** A documents reference within a specific database. */
@@ -235,18 +235,6 @@ export class DatabaseDocument {
     delete() {
         return this.provider.delete(this);
     }
-    /** Represent a write that sets the complete data of this document in a database. */
-    setter(data) {
-        return new DocumentSet(this, data);
-    }
-    /** Represent a write that updates this document in a database. */
-    updater(updates) {
-        return new DocumentUpdate(this, updates);
-    }
-    /** Represent a write that deletes this document in a database. */
-    deleter() {
-        return new DocumentDelete(this);
-    }
     /** Validate data for this query reference. */
     validate(unsafeData) {
         try {

package/db/index.d.ts

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

package/db/index.js

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

package/index.d.ts

@@ -13,4 +13,5 @@ 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,6 +15,7 @@ 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/operation/AddOperation.d.ts

@@ -0,0 +1,15 @@
+import type { Database, DatabaseQuery } from "../db/index.js";
+import { Data, Nullish, Key } from "../util/index.js";
+import { SetOperation } from "./SetOperation.js";
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent a add operation made to a collection in a database. */
+export declare class AddOperation<T extends Data> extends WriteOperation {
+    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;
+}
+/** Create an add operation for a document. */
+export declare const ADD: <T extends Data>({ collection }: DatabaseQuery<T>, data: T) => AddOperation<T>;

package/operation/AddOperation.js

@@ -0,0 +1,23 @@
+import { isNullish } from "../util/index.js";
+import { SetOperation } from "./SetOperation.js";
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent a add operation made to a collection in a database. */
+export class AddOperation extends WriteOperation {
+    constructor(collection, data) {
+        super();
+        this.collection = collection;
+        this.data = data;
+    }
+    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 } };
+    }
+}
+/** Create an add operation for a document. */
+export const ADD = ({ collection }, data) => new AddOperation(collection, data);

package/operation/DeleteOperation.d.ts

@@ -0,0 +1,9 @@
+import { Database } from "../db/Database.js";
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent a delete operation made to a single document in a database. */
+export declare class DeleteOperation extends WriteOperation {
+    readonly collection: string;
+    readonly id: string;
+    constructor(collection: string, id: string);
+    run(db: Database): Promise<this>;
+}

package/operation/DeleteOperation.js

@@ -0,0 +1,13 @@
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent a delete operation made to a single document in a database. */
+export class DeleteOperation extends WriteOperation {
+    constructor(collection, id) {
+        super();
+        this.collection = collection;
+        this.id = id;
+    }
+    async run(db) {
+        await db.doc(this.collection, this.id).delete();
+        return this;
+    }
+}

package/operation/Operation.d.ts

@@ -0,0 +1,6 @@
+import { Arguments } from "../index.js";
+/** Represent an async operation. */
+export declare abstract class Operation<A extends Arguments = []> {
+    /** Run this operation against a database and return the operation that was completed (which may be this same `Operation` instance). */
+    abstract run(...args: A): Promise<Operation<A>>;
+}

package/operation/Operation.js

@@ -0,0 +1,3 @@
+/** Represent an async operation. */
+export class Operation {
+}

package/operation/Operations.d.ts

@@ -0,0 +1,21 @@
+import { ImmutableArray, Nullish, Arguments } from "../util/index.js";
+import { Operation } from "./Operation.js";
+/** Represent a list of operations that take the same arguments. */
+export declare abstract class Operations<A extends Arguments> extends Operation<A> {
+    readonly operations: ImmutableArray<Operation<A>>;
+    constructor(...operations: Nullish<Operation<A>>[]);
+    /** Return a new instance of this object with an additional operation added. */
+    with(operation: Nullish<Operation<A>>): this;
+}
+/** Represent a list of operations run in series. */
+export declare class SeriesOperations<A extends Arguments> extends Operations<A> {
+    run(...args: A): Promise<SeriesOperations<A>>;
+}
+/** Create a list of operations to be run. */
+export declare const SERIES: <A extends Arguments>(...operations: Operation<A>[]) => SeriesOperations<A>;
+/** Represent a list of operations run in series. */
+export declare class ParallelOperations<A extends Arguments> extends Operations<A> {
+    run(...args: A): Promise<ParallelOperations<A>>;
+}
+/** Create a list of operations to be run. */
+export declare const PARALLEL: <A extends Arguments>(...operations: Operation<A>[]) => ParallelOperations<A>;

package/operation/Operations.js

@@ -0,0 +1,33 @@
+import { callAsyncSeries, callAsyncParallel, isNullish, isNotNullish } from "../util/index.js";
+import { Operation } from "./Operation.js";
+// Run an operation on to a database.
+const _runOperation = (operation, ...args) => operation.run(...args);
+/** Represent a list of operations that take the same arguments. */
+export class Operations extends Operation {
+    constructor(...operations) {
+        super();
+        this.operations = operations.filter(isNotNullish);
+    }
+    /** Return a new instance of this object with an additional operation added. */
+    with(operation) {
+        if (isNullish(operation))
+            return this;
+        return { __proto__: Object.getPrototypeOf(this), ...this, operations: [...this.operations, operation] };
+    }
+}
+/** Represent a list of operations run in series. */
+export class SeriesOperations extends Operations {
+    async run(...args) {
+        return new SeriesOperations(...(await callAsyncSeries(_runOperation, this.operations, ...args)));
+    }
+}
+/** Create a list of operations to be run. */
+export const SERIES = (...operations) => new SeriesOperations(...operations);
+/** Represent a list of operations run in series. */
+export class ParallelOperations extends Operations {
+    async run(...args) {
+        return new ParallelOperations(...(await callAsyncParallel(_runOperation, this.operations, ...args)));
+    }
+}
+/** Create a list of operations to be run. */
+export const PARALLEL = (...operations) => new ParallelOperations(...operations);

package/operation/SetOperation.d.ts

@@ -0,0 +1,15 @@
+import type { Database, DatabaseDocument } from "../db/index.js";
+import { Data, Key, Nullish } from "../util/index.js";
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent a set operation made to a single document in a database. */
+export declare class SetOperation<T extends Data> extends WriteOperation {
+    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;
+}
+/** Create a set operation for a document. */
+export declare const SET: <T extends Data>({ collection, id }: DatabaseDocument<T>, data: T) => SetOperation<T>;

package/operation/SetOperation.js

@@ -0,0 +1,23 @@
+import { isNullish } from "../util/index.js";
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent a set operation made to a single document in a database. */
+export class SetOperation extends WriteOperation {
+    constructor(collection, id, data) {
+        super();
+        this.collection = collection;
+        this.id = id;
+        this.data = data;
+    }
+    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 } };
+    }
+}
+/** Create a set operation for a document. */
+export const SET = ({ collection, id }, data) => new SetOperation(collection, id, data);

package/operation/UpdateOperation.d.ts

@@ -0,0 +1,16 @@
+import type { Database, DatabaseDocument } from "../db/index.js";
+import type { PropUpdates, Update } from "../update/index.js";
+import { Data, Key, Nullish } from "../util/index.js";
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent an update operation made to a single document in a database. */
+export declare class UpdateOperation<T extends Data> extends WriteOperation {
+    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;
+}
+/** Create an update operation for a document. */
+export declare const UPDATE: <T extends Data>({ collection, id }: DatabaseDocument<T>, updates: PropUpdates<T>) => UpdateOperation<T>;

package/operation/UpdateOperation.js

@@ -0,0 +1,23 @@
+import { isNullish } from "../util/index.js";
+import { WriteOperation } from "./WriteOperation.js";
+/** Represent an update operation made to a single document in a database. */
+export class UpdateOperation extends WriteOperation {
+    constructor(collection, id, updates) {
+        super();
+        this.collection = collection;
+        this.id = id;
+        this.updates = updates;
+    }
+    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 } };
+    }
+}
+/** Create an update operation for a document. */
+export const UPDATE = ({ collection, id }, updates) => new UpdateOperation(collection, id, updates);

package/operation/WriteOperation.d.ts

@@ -0,0 +1,16 @@
+import type { Database } from "../db/Database.js";
+import { ImmutableArray, Nullish } from "../util/index.js";
+import { Operation } from "./Operation.js";
+/** Represent a write operation on a database. */
+export declare abstract class WriteOperation extends Operation<[Database]> {
+}
+/** Represent a list of write operations on a database run in series. */
+export declare class WriteOperations extends WriteOperation {
+    readonly operations: ImmutableArray<WriteOperation>;
+    constructor(...operations: Nullish<WriteOperation>[]);
+    run(db: Database): Promise<WriteOperations>;
+    /** Return a new instance of this object with an additional operation added. */
+    with(operation: Nullish<WriteOperation>): this;
+}
+/** Create a list of operations to be run. */
+export declare const WRITES: (...operations: WriteOperation[]) => WriteOperations;

package/operation/WriteOperation.js

@@ -0,0 +1,25 @@
+import { callAsyncSeries, isNullish, isNotNullish } from "../util/index.js";
+import { Operation } from "./Operation.js";
+/** Represent a write operation on a database. */
+export class WriteOperation extends Operation {
+}
+/** Represent a list of write operations on a database run in series. */
+export class WriteOperations extends WriteOperation {
+    constructor(...operations) {
+        super();
+        this.operations = operations.filter(isNotNullish);
+    }
+    async run(db) {
+        return new WriteOperations(...(await callAsyncSeries(_write, this.operations, db)));
+    }
+    /** Return a new instance of this object with an additional operation added. */
+    with(operation) {
+        if (isNullish(operation))
+            return this;
+        return { __proto__: Object.getPrototypeOf(this), ...this, operations: [...this.operations, operation] };
+    }
+}
+// Run an operation on to a database.
+const _write = (operation, db) => operation.run(db);
+/** Create a list of operations to be run. */
+export const WRITES = (...operations) => new WriteOperations(...operations);

package/operation/hydrations.d.ts

@@ -0,0 +1,13 @@
+import { AddOperation } from "./AddOperation.js";
+import { DeleteOperation } from "./DeleteOperation.js";
+import { SetOperation } from "./SetOperation.js";
+import { UpdateOperation } from "./UpdateOperation.js";
+import { WriteOperations } from "./WriteOperation.js";
+/** Set of hydrations for all change classes. */
+export declare const OPERATION_HYDRATIONS: {
+    WriteOperations: typeof WriteOperations;
+    AddOperation: typeof AddOperation;
+    SetOperation: typeof SetOperation;
+    UpdateOperation: typeof UpdateOperation;
+    DeleteOperation: typeof DeleteOperation;
+};

package/operation/hydrations.js

@@ -0,0 +1,14 @@
+import { AddOperation } from "./AddOperation.js";
+import { DeleteOperation } from "./DeleteOperation.js";
+import { SetOperation } from "./SetOperation.js";
+import { UpdateOperation } from "./UpdateOperation.js";
+import { WriteOperations } from "./WriteOperation.js";
+/** Set of hydrations for all change classes. */
+export const OPERATION_HYDRATIONS = {
+    WriteOperations,
+    AddOperation,
+    SetOperation,
+    UpdateOperation,
+    DeleteOperation,
+};
+OPERATION_HYDRATIONS;

package/operation/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./Operation.js";
+export * from "./Operations.js";
+export * from "./WriteOperation.js";
+export * from "./AddOperation.js";
+export * from "./DeleteOperation.js";
+export * from "./SetOperation.js";
+export * from "./UpdateOperation.js";
+export * from "./hydrations.js";

package/operation/index.js

@@ -0,0 +1,8 @@
+export * from "./Operation.js";
+export * from "./Operations.js";
+export * from "./WriteOperation.js";
+export * from "./AddOperation.js";
+export * from "./DeleteOperation.js";
+export * from "./SetOperation.js";
+export * from "./UpdateOperation.js";
+export * from "./hydrations.js";

package/package.json

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

package/update/ArrayUpdate.d.ts

@@ -3,15 +3,15 @@ import { Update } from "./Update.js";
 /** Update that can be applied to an array to add/remove items. */
 export declare class ArrayUpdate<T> extends Update<ImmutableArray<T>> {
     /** Return an array update with an item marked for addition. */
-    static add<X>(...adds: X[]): ArrayUpdate<X>;
+    static with<X>(...adds: X[]): ArrayUpdate<X>;
     /** Return an array update with an item marked for deletion. */
-    static delete<X>(...deletes: X[]): ArrayUpdate<X>;
+    static without<X>(...deletes: X[]): ArrayUpdate<X>;
     readonly adds: ImmutableArray<T>;
     readonly deletes: ImmutableArray<T>;
     constructor(adds?: ImmutableArray<T>, deletes?: ImmutableArray<T>);
     transform(existing: unknown): ImmutableArray<T>;
     /** Return an array update with an additional item marked for addition. */
-    add(...adds: T[]): this;
+    with(...adds: T[]): this;
     /** Return an array update with an additional item marked for deletion. */
-    delete(...deletes: T[]): this;
+    without(...deletes: T[]): this;
 }

package/update/ArrayUpdate.js

@@ -8,11 +8,11 @@ export class ArrayUpdate extends Update {
         this.deletes = deletes;
     }
     /** Return an array update with an item marked for addition. */
-    static add(...adds) {
+    static with(...adds) {
         return new ArrayUpdate(adds);
     }
     /** Return an array update with an item marked for deletion. */
-    static delete(...deletes) {
+    static without(...deletes) {
         return new ArrayUpdate([], deletes);
     }
     transform(existing) {
@@ -20,11 +20,11 @@ export class ArrayUpdate extends Update {
         return withoutItems(withItems(existingArray, this.adds), this.deletes);
     }
     /** Return an array update with an additional item marked for addition. */
-    add(...adds) {
+    with(...adds) {
         return { __proto__: Object.getPrototypeOf(this), ...this, adds: [...this.adds, ...adds] };
     }
     /** Return an array update with an additional item marked for deletion. */
-    delete(...deletes) {
+    without(...deletes) {
         return { __proto__: Object.getPrototypeOf(this), ...this, deletes: [...this.deletes, ...deletes] };
     }
 }

package/update/DataUpdate.d.ts

@@ -16,7 +16,7 @@ export declare class DataUpdate<T extends Data> extends Update<T> implements Ite
     constructor(props: PropUpdates<T>);
     transform(existing: T): T;
     /** Return a new object with the specified additional transform for a prop. */
-    update<K extends Key<T>>(key: Nullish<K>, value: T[K] | Update<T[K]>): this;
+    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

@@ -10,7 +10,7 @@ export class DataUpdate extends Update {
         return transformProps(existing, this.updates);
     }
     /** Return a new object with the specified additional transform for a prop. */
-    update(key, value) {
+    with(key, value) {
         if (isNullish(key))
             return this;
         return { __proto__: Object.getPrototypeOf(this), ...this, updates: { ...this.updates, [key]: value } };

package/update/ObjectUpdate.d.ts

@@ -5,17 +5,17 @@ export declare type EntryUpdates<T> = ImmutableObject<T | Update<T>>;
 /** Update that can be applied to a map-like object to add/remove/update its entries. */
 export declare class ObjectUpdate<T> extends Update<ImmutableObject<T>> implements Iterable<Entry<T | Update<T> | undefined>> {
     /** Return an object update with a specific entry marked for update. */
-    static update<X>(key: string | undefined | null, value: X | Update<X>): ObjectUpdate<X>;
+    static with<X>(key: string | undefined | null, value: X | Update<X>): ObjectUpdate<X>;
     /** Return an object update with a specific entry marked for deletion. */
-    static delete<X>(key: string | undefined | null): ObjectUpdate<X>;
+    static without<X>(key: string | undefined | null): ObjectUpdate<X>;
     readonly updates: EntryUpdates<T>;
     readonly deletes: ImmutableArray<string>;
     constructor(updates?: EntryUpdates<T>, deletes?: ImmutableArray<string>);
     transform(existing: unknown): ImmutableObject<T>;
     /** Return an object update with a specific entry marked for update. */
-    update(key: Nullish<string>, value: T | Update<T>): this;
+    with(key: Nullish<string>, value: T | Update<T>): this;
     /** Return an object update with a specific entry marked for deletion. */
-    delete(key: Nullish<string>): this;
+    without(key: Nullish<string>): this;
     /**
      * Iterate over the changes in this object.
      * - Updates are yielded first, then deletes.

package/update/ObjectUpdate.js

@@ -8,11 +8,11 @@ export class ObjectUpdate extends Update {
         this.deletes = deletes;
     }
     /** Return an object update with a specific entry marked for update. */
-    static update(key, value) {
+    static with(key, value) {
         return new ObjectUpdate(isNullish(key) ? {} : { [key]: value });
     }
     /** Return an object update with a specific entry marked for deletion. */
-    static delete(key) {
+    static without(key) {
         return new ObjectUpdate({}, isNullish(key) ? [] : [key]);
     }
     transform(existing) {
@@ -20,13 +20,13 @@ export class ObjectUpdate extends Update {
         return transformEntries(existingObject, this.updates, this.deletes);
     }
     /** Return an object update with a specific entry marked for update. */
-    update(key, value) {
+    with(key, value) {
         if (isNullish(key))
             return this;
         return { __proto__: Object.getPrototypeOf(this), ...this, sets: { ...this.updates, [key]: value } };
     }
     /** Return an object update with a specific entry marked for deletion. */
-    delete(key) {
+    without(key) {
         if (isNullish(key))
             return this;
         return { __proto__: Object.getPrototypeOf(this), ...this, deletes: [...this.deletes, key] };

package/util/async.d.ts

@@ -1,6 +1,7 @@
+import type { ImmutableArray } from "./array.js";
+import type { Arguments, Dispatcher } from "./function.js";
 import { DONE } from "./constants.js";
 import { Handler } from "./error.js";
-import type { Arguments, Dispatcher } from "./function.js";
 /**
  * Throw the value if it's an async (promised) value.
  * @returns Synchronous (not promised) value.
@@ -9,9 +10,32 @@ import type { Arguments, Dispatcher } from "./function.js";
 export declare function throwAsync<T>(asyncValue: T | PromiseLike<T>): T;
 /** Is a value an async (promised) value. */
 export declare const isAsync: <T>(v: T | PromiseLike<T>) => v is PromiseLike<T>;
-/** Call a function with a set of values *BUT* if the first value is asynchronous wait for it to resolve first before calling the function. */
-export declare const callAsync: <I, O, A extends Arguments = []>(callback: (v: I, ...a: A) => O, value: I | PromiseLike<I>, ...args: A) => O | PromiseLike<O>;
-export declare const _awaitCallAsync: <I, O, A extends Arguments>(callback: (v: I, ...a: A) => O, value: PromiseLike<I>, args: A) => Promise<O>;
+/**
+ * Call a callback with an item.
+ * - If neither `callback` or `item` are async then the value returned will be synchronous.
+ *
+ * @param callback The sync or async function to call.
+ * @param item The first argument for `callback` (if this value is async it will be awaited before `callback` is called).
+ * @param ...args Additional arguments for `callback`
+ */
+export declare const callAsync: <I, O, A extends Arguments = []>(callback: (v: I, ...a: A) => O | PromiseLike<O>, item: I | PromiseLike<I>, ...args: A) => O | PromiseLike<O>;
+export declare const _awaitCallAsync: <I, O, A extends Arguments>(callback: (v: I, ...a: A) => O | PromiseLike<O>, item: PromiseLike<I>, args: A) => Promise<O>;
+/**
+ * Call a callback for a set of items in series.
+ *
+ * @param callback The sync or async function to call for each item.
+ * @param items The set of first arguments for `callback` (if this value is async it will be awaited before `callback` is called).
+ * @param ...args Additional arguments for `callback`
+ */
+export declare function callAsyncSeries<I, O, A extends Arguments = []>(callback: (item: I, ...a: A) => O | PromiseLike<O>, items: Iterable<I | PromiseLike<I>>, ...args: A): Promise<ImmutableArray<O>>;
+/**
+ * Call a callback for a set of items in parallel.
+ *
+ * @param callback The sync or async function to call for each item.
+ * @param items The set of first arguments for `callback` (if this value is async it will be awaited before `callback` is called).
+ * @param ...args Additional arguments for `callback`
+ */
+export declare function callAsyncParallel<I, O, A extends Arguments = []>(callback: (item: I, ...a: A) => O | PromiseLike<O>, items: Iterable<I | PromiseLike<I>>, ...args: A): Promise<ImmutableArray<O>>;
 /** Type of `Promise` with its `resolve()` and `reject()` methods exposed publicly. */
 export declare class Deferred<T> extends Promise<T> {
     static get [Symbol.species](): PromiseConstructor;

package/util/async.js

@@ -11,9 +11,42 @@ export function throwAsync(asyncValue) {
 }
 /** Is a value an async (promised) value. */
 export const isAsync = (v) => typeof v === "object" && v !== null && typeof v.then === "function";
-/** Call a function with a set of values *BUT* if the first value is asynchronous wait for it to resolve first before calling the function. */
-export const callAsync = (callback, value, ...args) => (isAsync(value) ? _awaitCallAsync(callback, value, args) : callback(value, ...args));
-export const _awaitCallAsync = async (callback, value, args) => callback(await value, ...args);
+/**
+ * Call a callback with an item.
+ * - If neither `callback` or `item` are async then the value returned will be synchronous.
+ *
+ * @param callback The sync or async function to call.
+ * @param item The first argument for `callback` (if this value is async it will be awaited before `callback` is called).
+ * @param ...args Additional arguments for `callback`
+ */
+export const callAsync = (callback, item, ...args) => isAsync(item) ? _awaitCallAsync(callback, item, args) : callback(item, ...args);
+export const _awaitCallAsync = async (callback, item, args) => callback(await item, ...args);
+/**
+ * Call a callback for a set of items in series.
+ *
+ * @param callback The sync or async function to call for each item.
+ * @param items The set of first arguments for `callback` (if this value is async it will be awaited before `callback` is called).
+ * @param ...args Additional arguments for `callback`
+ */
+export async function callAsyncSeries(callback, items, ...args) {
+    const outputs = [];
+    for (const item of items)
+        outputs.push(await callback(await item, ...args));
+    return outputs;
+}
+/**
+ * Call a callback for a set of items in parallel.
+ *
+ * @param callback The sync or async function to call for each item.
+ * @param items The set of first arguments for `callback` (if this value is async it will be awaited before `callback` is called).
+ * @param ...args Additional arguments for `callback`
+ */
+export async function callAsyncParallel(callback, items, ...args) {
+    const outputs = [];
+    for (const item of await Promise.all(items))
+        outputs.push(callback(item, ...args));
+    return Promise.all(outputs);
+}
 // Internal way for us to save `resolve()` and `reject()` from a new Promise used by `Deferred` and `ExtendablePromise`
 let resolve; // eslint-disable-line @typescript-eslint/no-explicit-any
 let reject;

package/db/Write.d.ts

@@ -1,50 +0,0 @@
-import { PropUpdates, Update } from "../update/index.js";
-import { ImmutableArray, Data, Transformable, Key, Nullish } from "../util/index.js";
-import type { Database, DatabaseDocument } from "./Database.js";
-/** Represent a write made to a database. */
-export declare abstract class Write implements Transformable<Database, void | PromiseLike<void>> {
-    abstract transform(db: Database): void | PromiseLike<void>;
-}
-/**
- * Represent a list of writes made to a database.
- * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
- * - Every write must be applied to a specific database document in a specific collection and are applied in the specified order.
- */
-export declare class Writes extends Write {
-    readonly writes: ImmutableArray<Write>;
-    constructor(...writes: Write[]);
-    transform(db: Database): Promise<void>;
-}
-/** Represent a write made to a single document in a database. */
-export declare abstract class DocumentWrite<T extends Data> extends Write {
-    readonly collection: string;
-    readonly id: string;
-    constructor({ collection, id }: DatabaseDocument<T>);
-}
-/** Represent a set operation made to a single document in a database. */
-export declare class DocumentSet<T extends Data> extends DocumentWrite<T> {
-    readonly data: T;
-    constructor(ref: DatabaseDocument<T>, data: T);
-    transform(db: Database): Promise<void>;
-    /** Set one of the props on this set operation to a different value. */
-    set<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 DocumentUpdate<T extends Data> extends DocumentWrite<T> {
-    readonly updates: PropUpdates<T>;
-    constructor(ref: DatabaseDocument<T>, updates: PropUpdates<T>);
-    transform(db: Database): Promise<void>;
-    /** update one of the props on this set operation to a different value. */
-    update<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 DocumentDelete<T extends Data> extends DocumentWrite<T> {
-    transform(db: Database): Promise<void>;
-}
-/** Set of hydrations for all change classes. */
-export declare const WRITE_HYDRATIONS: {
-    Writes: typeof Writes;
-    DocumentSet: typeof DocumentSet;
-    DocumentUpdate: typeof DocumentUpdate;
-    DocumentDelete: typeof DocumentDelete;
-};

package/db/Write.js

@@ -1,73 +0,0 @@
-import { transform, isNullish } from "../util/index.js";
-/** Represent a write made to a database. */
-export class Write {
-}
-/**
- * Represent a list of writes made to a database.
- * - Sets of writes are predictable and repeatable, so unpredictable operations like `create()` and query operations are not supported.
- * - Every write must be applied to a specific database document in a specific collection and are applied in the specified order.
- */
-export class Writes extends Write {
-    constructor(...writes) {
-        super();
-        this.writes = writes;
-    }
-    async transform(db) {
-        for (const writes of this.writes)
-            await transform(db, writes);
-    }
-}
-/** Represent a write made to a single document in a database. */
-export class DocumentWrite extends Write {
-    constructor({ collection, id }) {
-        super();
-        this.collection = collection;
-        this.id = id;
-    }
-}
-/** Represent a set operation made to a single document in a database. */
-export class DocumentSet extends DocumentWrite {
-    constructor(ref, data) {
-        super(ref);
-        this.data = data;
-    }
-    async transform(db) {
-        await db.doc(this.collection, this.id).set(this.data);
-    }
-    /** Set one of the props on this set operation to a different value. */
-    set(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 DocumentUpdate extends DocumentWrite {
-    constructor(ref, updates) {
-        super(ref);
-        this.updates = updates;
-    }
-    async transform(db) {
-        await db.doc(this.collection, this.id).update(this.updates);
-    }
-    /** update one of the props on this set operation to a different value. */
-    update(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 DocumentDelete extends DocumentWrite {
-    async transform(db) {
-        await db.doc(this.collection, this.id).delete();
-    }
-}
-/** Set of hydrations for all change classes. */
-export const WRITE_HYDRATIONS = {
-    Writes,
-    DocumentSet,
-    DocumentUpdate,
-    DocumentDelete,
-};
-WRITE_HYDRATIONS;