shelving 1.41.0 → 1.42.0

package/db/Operation.d.ts

@@ -0,0 +1,73 @@
+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 {
+    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 | DatabaseQuery, data: X): AddOperation<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, data: X): 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>;
+    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 update operation on a document. */
+    static on({ collection, id }: DatabaseDocument): 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,116 @@
+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);
+    }
+    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);
+    }
+    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);
+    }
+    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 update operation on a document. */
+    static on({ collection, id }) {
+        return new DeleteOperation(collection, id);
+    }
+    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.42.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/operation/AddOperation.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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

package/operation/Operations.d.ts

@@ -1,21 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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";