shelving 1.74.0 → 1.75.0

package/db/Change.d.ts

@@ -0,0 +1,49 @@
+import type { Data, Datas, Key } from "../util/data.js";
+import type { ImmutableArray } from "../util/array.js";
+import type { Provider, AsyncProvider } from "../provider/Provider.js";
+import { DataUpdate } from "../update/DataUpdate.js";
+import { Nullish } from "../util/null.js";
+import type { ItemConstraints, ItemData } from "./Item.js";
+export interface Change<T extends Datas, K extends Key<T>> {
+    readonly action: string;
+    readonly collection: K;
+}
+/** Add on an item. */
+export interface AddChange<T extends Datas, K extends Key<T>> extends Change<T, K> {
+    readonly action: "ADD";
+    readonly collection: K;
+    readonly data: T[K];
+}
+/** Set on an item. */
+export interface SetChange<T extends Datas, K extends Key<T>> extends Change<T, K> {
+    readonly action: "SET";
+    readonly collection: K;
+    readonly id: string;
+    readonly data: T[K];
+}
+/** Update change on an item. */
+export interface UpdateChange<T extends Datas, K extends Key<T>> extends Change<T, K> {
+    readonly action: "UPDATE";
+    readonly collection: K;
+    readonly id: string;
+    readonly update: DataUpdate<T[K]>;
+}
+/** Delete change on an item. */
+export interface DeleteChange<T extends Datas, K extends Key<T>> extends Change<T, K> {
+    readonly action: "DELETE";
+    readonly collection: K;
+    readonly id: string;
+}
+/** Set, update, or delete change on an item. */
+export declare type ItemChange<T extends Datas, K extends Key<T> = Key<T>> = SetChange<T, K> | UpdateChange<T, K> | DeleteChange<T, K>;
+/** Array of item changes. */
+export declare type ItemChanges<T extends Datas, K extends Key<T> = Key<T>> = ImmutableArray<ItemChange<T, K>>;
+/** Write change on an item. */
+export declare type WriteChange<T extends Datas, K extends Key<T> = Key<T>> = ItemChange<T, K> | AddChange<T, K>;
+/** Array of write changes. */
+export declare type WriteChanges<T extends Datas, K extends Key<T> = Key<T>> = ImmutableArray<WriteChange<T, K>>;
+/** Apply a set of changes to a synchronous provider. */
+export declare function changeProvider<T extends Datas, K extends Key<T> = Key<T>>(provider: Provider<T>, changes: ImmutableArray<Nullish<WriteChange<T, K>>>): ItemChanges<T, K>;
+/** Apply a set of changes to an asynchronous provider. */
+export declare function changeAsyncProvider<T extends Datas, K extends Key<T>>(provider: AsyncProvider<T>, changes: ImmutableArray<Nullish<WriteChange<T, K>>>): Promise<ItemChanges<T, K>>;
+export declare function _getItemConstraint<T extends Data>(id: string): ItemConstraints<ItemData<T>>;

package/db/Change.js

@@ -0,0 +1,38 @@
+import { QueryConstraints } from "../constraint/QueryConstraints.js";
+import { FilterConstraint } from "../constraint/FilterConstraint.js";
+import { notNullish } from "../util/null.js";
+/** Apply a set of changes to a synchronous provider. */
+export function changeProvider(provider, changes) {
+    return changes.filter(notNullish).map(_changeItem, provider);
+}
+function _changeItem(change) {
+    const { action, collection } = change;
+    if (action === "ADD")
+        return { action: "SET", collection, id: this.addItem(collection, change.data), data: change.data };
+    else if (action === "SET")
+        this.setItem(collection, change.id, change.data);
+    else if (action === "UPDATE")
+        this.updateQuery(collection, _getItemConstraint(change.id), change.update);
+    else if (action === "DELETE")
+        this.deleteItem(collection, change.id);
+    return change;
+}
+/** Apply a set of changes to an asynchronous provider. */
+export function changeAsyncProvider(provider, changes) {
+    return Promise.all(changes.filter(notNullish).map(_changeAsyncItem, provider));
+}
+async function _changeAsyncItem(change) {
+    const { collection, action } = change;
+    if (action === "ADD")
+        return { action: "SET", collection, id: await this.addItem(collection, change.data), data: change.data };
+    else if (action === "SET")
+        await this.setItem(collection, change.id, change.data);
+    else if (action === "UPDATE")
+        await this.updateQuery(collection, _getItemConstraint(change.id), change.update);
+    else if (action === "DELETE")
+        await this.deleteItem(collection, change.id);
+    return change;
+}
+export function _getItemConstraint(id) {
+    return new QueryConstraints(new FilterConstraint("id", id), undefined, 1);
+}

package/db/Collection.d.ts

@@ -1,9 +1,11 @@
 import type { Datas, Key } from "../util/data.js";
+import type { Nullish } from "../util/null.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
 import type { ItemData, AsyncItem, Item } from "./Item.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 import type { AsyncQuery, Query } from "./Query.js";
+import type { ItemChanges, WriteChange } from "./Change.js";
 /** Reference to a collection in a synchronous or asynchronous provider. */
 declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> {
     abstract readonly db: Database<T> | AsyncDatabase<T>;
@@ -14,6 +16,8 @@ declare abstract class BaseCollection<T extends Datas = Datas, K extends Key<T>
     abstract item(id: string): Item<T, K> | AsyncItem<T, K>;
     /** Add an item to this collection. */
     abstract add(data: T[K]): string | Promise<string>;
+    /** Run a set of changes on this database. */
+    abstract change(...changes: Nullish<WriteChange<T, K>>[]): ItemChanges<T, K> | Promise<ItemChanges<T, K>>;
     toString(): K;
 }
 /** Reference to a collection in a synchronous provider. */
@@ -24,6 +28,7 @@ export declare class Collection<T extends Datas = Datas, K extends Key<T> = Key<
     query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item(id: string): Item<T, K>;
     add(data: T[K]): string;
+    change(...changes: Nullish<WriteChange<T, K>>[]): ItemChanges<T, K>;
 }
 /** Reference to a collection in an asynchronous provider. */
 export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> = Key<T>> extends BaseCollection<T, K> {
@@ -33,5 +38,6 @@ export declare class AsyncCollection<T extends Datas = Datas, K extends Key<T> =
     query(filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item(id: string): AsyncItem<T, K>;
     add(data: T[K]): Promise<string>;
+    change(...changes: Nullish<WriteChange<T, K>>[]): Promise<ItemChanges<T, K>>;
 }
 export {};

package/db/Collection.js

@@ -21,6 +21,9 @@ export class Collection extends BaseCollection {
     add(data) {
         return this.db.provider.addItem(this.collection, data);
     }
+    change(...changes) {
+        return this.db.change(...changes);
+    }
 }
 /** Reference to a collection in an asynchronous provider. */
 export class AsyncCollection extends BaseCollection {
@@ -38,4 +41,7 @@ export class AsyncCollection extends BaseCollection {
     add(data) {
         return this.db.provider.addItem(this.collection, data);
     }
+    change(...changes) {
+        return this.db.change(...changes);
+    }
 }

package/db/Database.d.ts

@@ -3,33 +3,39 @@ import type { AsyncProvider, Provider } from "../provider/Provider.js";
 import type { FilterList } from "../constraint/FilterConstraint.js";
 import type { SortList } from "../constraint/SortConstraint.js";
 import type { ItemData } from "../db/Item.js";
+import type { Nullish } from "../util/null.js";
 import { Item, AsyncItem } from "./Item.js";
 import { Query, AsyncQuery } from "./Query.js";
 import { Collection, AsyncCollection } from "./Collection.js";
+import { ItemChanges, WriteChange } from "./Change.js";
 /** Database with a synchronous or asynchronous provider. */
-interface AbstractDatabase<T extends Datas> {
-    readonly provider: Provider<T> | AsyncProvider<T>;
+declare abstract class BaseDatabase<T extends Datas> {
+    abstract readonly provider: Provider<T> | AsyncProvider<T>;
     /** Create a query on a collection in this database. */
-    collection<K extends Key<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
+    abstract collection<K extends Key<T>>(collection: K): Collection<T, K> | AsyncCollection<T, K>;
     /** Create a query on a collection in this database. */
-    query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
+    abstract query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K> | AsyncQuery<T, K>;
     /** Reference an item in a collection in this database. */
-    item<K extends Key<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
+    abstract item<K extends Key<T>>(collection: K, id: string): Item<T, K> | AsyncItem<T, K>;
+    /** Run a set of changes on this database. */
+    abstract change<K extends Key<T>>(...changes: Nullish<WriteChange<T, K>>[]): ItemChanges<T, K> | Promise<ItemChanges<T, K>>;
 }
 /** Database with a synchronous provider. */
-export declare class Database<T extends Datas = Datas> implements AbstractDatabase<T> {
+export declare class Database<T extends Datas = Datas> implements BaseDatabase<T> {
     readonly provider: Provider<T>;
     constructor(provider: Provider<T>);
     collection<K extends Key<T>>(collection: K): Collection<T, K>;
     query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): Query<T, K>;
     item<K extends Key<T>>(collection: K, id: string): Item<T, K>;
+    change<K extends Key<T>>(...changes: Nullish<WriteChange<T, K>>[]): ItemChanges<T, K>;
 }
 /** Database with a synchronous provider. */
-export declare class AsyncDatabase<T extends Datas = Datas> implements AbstractDatabase<T> {
+export declare class AsyncDatabase<T extends Datas = Datas> implements BaseDatabase<T> {
     readonly provider: AsyncProvider<T>;
     constructor(provider: AsyncProvider<T>);
     collection<K extends Key<T>>(collection: K): AsyncCollection<T, K>;
     query<K extends Key<T>>(collection: K, filters?: FilterList<ItemData<T[K]>>, sorts?: SortList<ItemData<T[K]>>, limit?: number | null): AsyncQuery<T, K>;
     item<K extends Key<T>>(collection: K, id: string): AsyncItem<T, K>;
+    change<K extends Key<T>>(...changes: Nullish<WriteChange<T, K>>[]): Promise<ItemChanges<T, K>>;
 }
 export {};

package/db/Database.js

@@ -1,6 +1,10 @@
 import { Item, AsyncItem } from "./Item.js";
 import { Query, AsyncQuery } from "./Query.js";
 import { Collection, AsyncCollection } from "./Collection.js";
+import { changeAsyncProvider, changeProvider } from "./Change.js";
+/** Database with a synchronous or asynchronous provider. */
+class BaseDatabase {
+}
 /** Database with a synchronous provider. */
 export class Database {
     constructor(provider) {
@@ -15,6 +19,9 @@ export class Database {
     item(collection, id) {
         return new Item(this, collection, id);
     }
+    change(...changes) {
+        return changeProvider(this.provider, changes);
+    }
 }
 /** Database with a synchronous provider. */
 export class AsyncDatabase {
@@ -30,4 +37,7 @@ export class AsyncDatabase {
     item(collection, id) {
         return new AsyncItem(this, collection, id);
     }
+    change(...changes) {
+        return changeAsyncProvider(this.provider, changes);
+    }
 }

package/db/Item.d.ts

@@ -7,7 +7,7 @@ import { DataUpdate, PropUpdates } from "../update/DataUpdate.js";
 import type { QueryConstraints } from "../constraint/QueryConstraints.js";
 import type { AsyncDatabase, Database } from "./Database.js";
 import type { AsyncQuery, Query } from "./Query.js";
-import type { Changes } from "./Changes.js";
+import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 /** Item data with a string ID that uniquely identifies it. */
 export declare type ItemData<T extends Data = Data> = T & {
     id: string;
@@ -53,16 +53,16 @@ declare abstract class BaseItem<T extends Datas = Datas, K extends Key<T> = Key<
     subscribe(next: PartialObserver<ItemValue<T[K]>> | Dispatch<[ItemValue<T[K]>]>): Unsubscribe;
     /** Set the complete data of this item. */
     abstract set(data: T[K]): void | PromiseLike<void>;
-    /** Get a set change for this item. */
-    getSet(data: T[K]): Changes<T>;
     /** Update this item. */
     abstract update(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): void | PromiseLike<void>;
-    /** Get an update change for this item. */
-    getUpdate(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): Changes<T>;
     /** Delete this item. */
     abstract delete(): void | PromiseLike<void>;
+    /** Get a set change for this item. */
+    getSet(data: T[K]): SetChange<T, K>;
+    /** Get an update change for this item. */
+    getUpdate(updates: DataUpdate<T[K]> | PropUpdates<T[K]>): UpdateChange<T, K>;
     /** Get a delete change for this item. */
-    getDelete(): Changes<T>;
+    getDelete(): DeleteChange<T, K>;
     toString(): `${K}/${string}`;
 }
 /** Reference to an item in a synchronous provider. */

package/db/Item.js

@@ -16,15 +16,15 @@ class BaseItem {
     }
     /** Get a set change for this item. */
     getSet(data) {
-        return { [this.toString()]: data };
+        return { action: "SET", collection: this.collection, id: this.id, data };
     }
     /** Get an update change for this item. */
     getUpdate(updates) {
-        return { [this.toString()]: updates instanceof DataUpdate ? updates : new DataUpdate(updates) };
+        return { action: "UPDATE", collection: this.collection, id: this.id, update: updates instanceof DataUpdate ? updates : new DataUpdate(updates) };
     }
     /** Get a delete change for this item. */
     getDelete() {
-        return { [this.toString()]: null };
+        return { action: "DELETE", collection: this.collection, id: this.id };
     }
     // Implement toString()
     toString() {

package/db/index.d.ts

@@ -2,4 +2,4 @@ export * from "./Database.js";
 export * from "./Collection.js";
 export * from "./Item.js";
 export * from "./Query.js";
-export * from "./Changes.js";
+export * from "./Change.js";

package/db/index.js

@@ -2,4 +2,4 @@ export * from "./Database.js";
 export * from "./Collection.js";
 export * from "./Item.js";
 export * from "./Query.js";
-export * from "./Changes.js";
+export * from "./Change.js";

package/package.json

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

package/db/Changes.d.ts

@@ -1,24 +0,0 @@
-import type { Data, Datas, Key } from "../util/data.js";
-import { DataUpdate } from "../update/DataUpdate.js";
-import type { Provider, AsyncProvider } from "../provider/Provider.js";
-import type { Database, AsyncDatabase } from "./Database.js";
-import { ItemConstraints, ItemData } from "./Item.js";
-/**
- * Change set of operations to run against a database in `{ "collection/id": data | DataUpdate | null }`  format.
- * - If data is an object, sets the item.
- * - If data is a `DataUpdate` instance, updates the item.
- * - If data is null, deletes the item.
- * - If data is undefined, skip the item.
- */
-export declare type Changes<T extends Datas> = {
-    [K in Key<T> as `${K}/${string}`]: T[K] | DataUpdate<T[K]> | null | undefined;
-};
-/** Apply a set of changes to a synchronous database. */
-export declare function changeDatabase<T extends Datas>({ provider }: Database<T>, changes: Changes<T>): Changes<T>;
-/** Apply a set of changes to an asynchronous database. */
-export declare function changeAsyncDatabase<T extends Datas>({ provider }: AsyncDatabase<T>, changes: Changes<T>): Promise<Changes<T>>;
-/** Apply a set of changes to a synchronous provider. */
-export declare function changeProvider<T extends Datas>(provider: Provider<T>, changes: Changes<T>): Changes<T>;
-/** Apply a set of changes to an asynchronous provider. */
-export declare function changeAsyncProvider<T extends Datas>(provider: AsyncProvider<T>, changes: Changes<T>): Promise<Changes<T>>;
-export declare function _getItemConstraint<T extends Data>(id: string): ItemConstraints<ItemData<T>>;

package/db/Changes.js

@@ -1,45 +0,0 @@
-import { splitString } from "../util/string.js";
-import { DataUpdate } from "../update/DataUpdate.js";
-import { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { FilterConstraint } from "../constraint/FilterConstraint.js";
-/** Apply a set of changes to a synchronous database. */
-export function changeDatabase({ provider }, changes) {
-    return changeProvider(provider, changes);
-}
-/** Apply a set of changes to an asynchronous database. */
-export function changeAsyncDatabase({ provider }, changes) {
-    return changeAsyncProvider(provider, changes);
-}
-/** Apply a set of changes to a synchronous provider. */
-export function changeProvider(provider, changes) {
-    for (const [key, change] of Object.entries(changes)) {
-        const [collection, id] = splitString(key, "/", 2);
-        if (change === undefined)
-            continue;
-        else if (change === null)
-            provider.deleteItem(collection, id);
-        else if (change instanceof DataUpdate)
-            provider.updateQuery(collection, _getItemConstraint(id), change);
-        else
-            provider.setItem(collection, id, change);
-    }
-    return changes;
-}
-/** Apply a set of changes to an asynchronous provider. */
-export async function changeAsyncProvider(provider, changes) {
-    for (const [key, change] of Object.entries(changes)) {
-        const [collection, id] = splitString(key, "/", 2);
-        if (change === undefined)
-            continue;
-        else if (change === null)
-            await provider.deleteItem(collection, id);
-        else if (change instanceof DataUpdate)
-            await provider.updateQuery(collection, _getItemConstraint(id), change);
-        else
-            await provider.setItem(collection, id, change);
-    }
-    return changes;
-}
-export function _getItemConstraint(id) {
-    return new QueryConstraints(new FilterConstraint("id", id), undefined, 1);
-}

package/db/Changes.test.d.ts

@@ -1 +0,0 @@
-export {};

package/db/Changes.test.js

@@ -1,35 +0,0 @@
-import { AsyncDatabase, DataUpdate } from "../index.js";
-test("Typescript", () => {
-    const operations1 = {
-        "collection1/a1": { one: 1, bool: false },
-        "collection1/b2": null,
-        "collection1/b3": new DataUpdate({ bool: true }),
-        "collection2/a1": { two: 1, bool: false },
-        "collection2/b2": null,
-        "collection2/c3": new DataUpdate({ bool: true }),
-    };
-    // Check the keys.
-    const operations2 = {
-        // @ts-expect-error
-        "NOTCOLLECTION/a1": { a: 1, bool: false },
-    };
-    // Check the values.
-    const operations3 = {
-        "collection1/a1": {
-            one: 1,
-            // @ts-expect-error
-            bool: "NOTBOOL",
-        },
-    };
-    // Check some objects.
-    const db = new AsyncDatabase(undefined);
-    const changes = {
-        ...db.item("collection1", "a1").getUpdate({ bool: true }),
-        ...db.item("collection2", "b2").getSet({ two: 123, bool: false }),
-        ...db.item("collection2", "b2").getDelete(),
-    };
-    // Merging changes.
-    const changes1 = {};
-    const changes2 = {};
-    const changes3 = { ...changes1, ...changes2 };
-});