@arcote.tech/arc 0.0.15 → 0.0.16

package/dist/collection/collection.d.ts

@@ -1,8 +1,7 @@
-import type { ArcContextElement } from "../context/element";
+import { ArcContextElement } from "../context/element";
 import type { ArcIdAny } from "../elements/id";
 import { type ArcObjectAny } from "../elements/object";
 import { objectUtil, type util } from "../utils";
-import type { CollectionChange } from "./collection-change";
 import type { DataStorage } from "../data-storage";
 import type { ArcDefault } from "../elements/default";
 import { ArcAllItemsQueryBuilder } from "./query-builders/all-items";
@@ -28,7 +27,18 @@ type CollectionCommandContext<Id extends ArcIdAny, Schema extends ArcObjectAny |
     set: (id: util.GetType<Id>, data: util.FirstArgument<Schema["serialize"]>) => Promise<any>;
     modify: (id: util.GetType<Id>, data: objectUtil.addQuestionMarks<Partial<util.FirstArgument<Schema["serialize"]>>>) => Promise<any>;
 };
-export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> implements ArcContextElement<CollectionChange, CollectionChange> {
+export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> extends ArcContextElement<{
+    type: "delete";
+    item: CollectionItem<ArcCollection<Name, Id, Schema>>;
+} | {
+    type: "set";
+    item: CollectionItem<ArcCollection<Name, Id, Schema>>;
+} | {
+    type: "modify";
+    from: CollectionItem<ArcCollection<Name, Id, Schema>>;
+    to: CollectionItem<ArcCollection<Name, Id, Schema>>;
+    changes: objectUtil.simplify<Partial<util.FirstArgument<Schema["serialize"]>>>;
+}> {
     readonly name: Name;
     readonly id: Id;
     readonly schema: Schema;
@@ -43,7 +53,7 @@ export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Sch
         _id: util.FirstArgument<Id["deserialize"]>;
     } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): Deserialize<Id, Schema>;
     queryBuilder(): CollectionQueryBuilder<ArcCollection<Name, Id, Schema>>;
-    commandContext(dataStorage: DataStorage): CollectionCommandContext<Id, Schema>;
+    commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): CollectionCommandContext<Id, Schema>;
     indexBy<Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {
         [name: string]: Indexes[];
     }>(indexes: I): ArcIndexedCollection<Name, Id, Schema, keyof ReturnType<Schema["deserialize"]>, I>;
@@ -53,7 +63,7 @@ export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdA
 }> extends ArcCollection<Name, Id, Schema> {
     readonly indexes: I;
     constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>, indexes: I);
-    commandContext(dataStorage: DataStorage): CollectionCommandContext<Id, Schema> & {
+    commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): CollectionCommandContext<Id, Schema> & {
         [func in keyof I]: (args: {
             [Key in I[func][number]]: util.GetType<Schema>[Key];
         }) => Deserialize<Id, Schema>[];

package/dist/collection/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./collection";
-export * from "./collection-change";
 export * from "./queries/abstract-collection-query";
 export * from "./queries/util";
 //# sourceMappingURL=index.d.ts.map

package/dist/context/context.d.ts

@@ -1,21 +1,30 @@
 import type { DataStorage } from "../data-storage";
-import type { Commands } from "./commands";
-import type { ArcContextElementAny, ArcContextElementChanges } from "./element";
-declare class ArcContext<const C extends ArcContextElementAny[]> {
-    readonly elements: C;
-    readonly commands: Commands<ArcContext<C>>;
+import type { objectUtil } from "../utils";
+import type { CommandContext, Commands, CommandsClient } from "./commands";
+import type { ArcContextElement, ArcContextElementAny } from "./element";
+declare class ArcContext<const C extends ArcContextElementAny[], const Cmds extends Commands<ArcContext<C, any, any>>, const L extends Listener<ArcContext<C, any, any>>[]> {
     readonly version: number;
+    readonly elements: C;
+    readonly commands: Cmds;
+    readonly listeners?: L | undefined;
     elementsMap: {
         [key: string]: C[number];
     };
-    constructor(elements: C, commands: Commands<ArcContext<C>>, version: number);
+    constructor(version: number, elements: C, commands: Cmds, listeners?: L | undefined);
     queryBuilder(): {
         [Collection in C[number] as Collection["name"]]: ReturnType<Collection["queryBuilder"]>;
     };
-    commandContext(dataStorage: DataStorage): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; };
+    commandContext(dataStorage: DataStorage, publishEvent: (event: any) => Promise<void>): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; };
+    commandsClient(dataStorage: DataStorage): CommandsClient<Cmds>;
 }
-export type ArcContextAny = ArcContext<ArcContextElementAny[]>;
-export type ArcContextChanges<C extends ArcContextAny> = ArcContextElementChanges<C["elements"][number]>;
-export declare function context<const Elements extends ArcContextElementAny[], Cmds extends Commands<ArcContext<Elements>>>(elements: Elements, commands: Cmds, version: number): ArcContext<Elements>;
+export type ArcContextAny = ArcContext<ArcContextElementAny[], Commands<any>, any>;
+export type ElementEvents<Element extends ArcContextElementAny> = Element extends ArcContextElement<any> ? Element["$event"] : never;
+export type ContextEvents<Context extends ArcContextAny> = {
+    [Element in Context["elements"][number] as Element["name"]]: objectUtil.simplify<{
+        element: Element["name"];
+    } & ElementEvents<Element>>;
+}[Context["elements"][number]["name"]];
+export type Listener<Context extends ArcContextAny> = (event: ContextEvents<Context>, context: CommandContext<Context>) => Promise<void> | void;
+export declare function context<const Elements extends ArcContextElementAny[], Cmds extends Commands<ArcContext<Elements, any, any>>, L extends Listener<ArcContext<Elements, Cmds, any>>[]>(version: number, elements: Elements, commands: Cmds, listeners?: L): ArcContext<Elements, Cmds, L>;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/context/element.d.ts

@@ -1,10 +1,10 @@
 import type { DataStorage } from "../data-storage";
-export interface ArcContextElement<Change, Event> {
-    name: string;
-    queryBuilder(): any;
-    commandContext(dataStorage: DataStorage): unknown;
-    deserialize?: (data: any) => any;
+export declare abstract class ArcContextElement<const Event> {
+    readonly $event: Event;
+    abstract name: string;
+    abstract queryBuilder(): any;
+    abstract commandContext(dataStorage: DataStorage, publishEvent: (event: Event) => Promise<void>): any;
+    abstract deserialize(data: any): any;
 }
-export type ArcContextElementAny = ArcContextElement<any, any>;
-export type ArcContextElementChanges<Element extends ArcContextElementAny> = Element extends ArcContextElement<infer Change, any> ? Change : never;
+export type ArcContextElementAny = ArcContextElement<any>;
 //# sourceMappingURL=element.d.ts.map

package/dist/data-storage/store-state-fork.d.ts

@@ -1,4 +1,4 @@
-import type { DataStorage, QueryListenerCallback, StoreStateChange } from "./data-storage.interface";
+import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.interface";
 import { StoreState } from "./store-state.abstract";
 export declare class ForkedStoreState<Item extends {
     _id: string;
@@ -7,6 +7,15 @@ export declare class ForkedStoreState<Item extends {
     protected changedItems: Map<string, Item | null>;
     changes: StoreStateChange<Item>[];
     constructor(storeName: string, dataStorage: DataStorage, master: StoreState<Item>, deserialize?: (data: any) => Item);
+    applyChangeAndReturnEvent(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+        event: ListenerEvent<Item>;
+    }>;
+    applyChange(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
     applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
     findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
     findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;

package/dist/data-storage/store-state-master.d.ts

@@ -1,4 +1,5 @@
-import type { DataStorage, QueryListenerCallback, StoreStateChange } from "./data-storage.interface";
+import type { ReadWriteTransaction } from "../db";
+import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.interface";
 import { StoreState } from "./store-state.abstract";
 export declare class MasterStoreState<Item extends {
     _id: string;
@@ -6,6 +7,15 @@ export declare class MasterStoreState<Item extends {
     private items;
     private isComplete;
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
+    applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+        event: ListenerEvent<Item>;
+    }>;
+    applyChange(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
     applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
     findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
     findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;

package/dist/data-storage/store-state.abstract.d.ts

@@ -8,6 +8,10 @@ export declare abstract class StoreState<Item extends {
     protected deserialize?: ((data: any) => Item) | undefined;
     protected listeners: Set<QueryListener<Item>>;
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: ((data: any) => Item) | undefined);
+    abstract applyChange(change: StoreStateChange<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
     abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
     abstract findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
     abstract findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
@@ -15,7 +19,10 @@ export declare abstract class StoreState<Item extends {
     fork(): ForkedStoreState<Item>;
     set(item: Item): Promise<void>;
     remove(id: string): Promise<void>;
-    modify(id: string, data: Partial<Item>): Promise<void>;
+    modify(id: string, data: Partial<Item>): Promise<{
+        from: Item | null;
+        to: Item | null;
+    }>;
     unsubscribe(listener: QueryListener<Item>): void;
     protected notifyListeners(events: ListenerEvent<Item>[]): void;
 }

package/dist/index.js

@@ -1,3 +1,8 @@
+// context/element.ts
+class ArcContextElement {
+  $event;
+}
+
 // collection/queries/abstract-collection-query.ts
 class ArcCollectionQuery {
   collection;
@@ -229,12 +234,13 @@ function collection(name, id, schema, options = {}) {
   return new ArcCollection(name, id, schema, options);
 }
 
-class ArcCollection {
+class ArcCollection extends ArcContextElement {
   name;
   id;
   schema;
   options;
   constructor(name, id, schema, options) {
+    super();
     this.name = name;
     this.id = id;
     this.schema = schema;
@@ -258,7 +264,7 @@ class ArcCollection {
       one: (id) => new ArcOneItemQueryBuilder(this, id)
     };
   }
-  commandContext(dataStorage) {
+  commandContext(dataStorage, publishEvent) {
     const store = dataStorage.getStore(this.name);
     return {
       add: async (data) => {
@@ -292,7 +298,13 @@ class ArcCollection {
       },
       modify: async (id, data) => {
         const deserialized = this.schema.deserialize(data);
-        await store.modify(id, deserialized);
+        const { from, to } = await store.modify(id, deserialized);
+        await publishEvent({
+          type: "modify",
+          changes: data,
+          from,
+          to
+        });
       }
     };
   }
@@ -307,8 +319,8 @@ class ArcIndexedCollection extends ArcCollection {
     super(name, id, schema, options);
     this.indexes = indexes;
   }
-  commandContext(dataStorage) {
-    const superContext = super.commandContext(dataStorage);
+  commandContext(dataStorage, publishEvent) {
+    const superContext = super.commandContext(dataStorage, publishEvent);
     return new Proxy(superContext, {
       get: (target, name) => {
         if (name in target) {
@@ -336,19 +348,21 @@ class ArcIndexedCollection extends ArcCollection {
   }
 }
 // context/context.ts
-function context(elements, commands, version) {
-  return new ArcContext(elements, commands, version);
+function context(version, elements, commands, listeners) {
+  return new ArcContext(version, elements, commands, listeners);
 }
 
 class ArcContext {
+  version;
   elements;
   commands;
-  version;
+  listeners;
   elementsMap;
-  constructor(elements, commands, version) {
+  constructor(version, elements, commands, listeners) {
+    this.version = version;
     this.elements = elements;
     this.commands = commands;
-    this.version = version;
+    this.listeners = listeners;
     this.elementsMap = Object.fromEntries(elements.map((collection3) => [collection3.name, collection3]));
   }
   queryBuilder() {
@@ -362,11 +376,35 @@ class ArcContext {
       }
     });
   }
-  commandContext(dataStorage) {
+  commandContext(dataStorage, publishEvent) {
     return new Proxy({}, {
       get: (target, name) => {
         const element = this.elementsMap[name];
-        return element.commandContext(dataStorage);
+        return element.commandContext(dataStorage, (event) => publishEvent({
+          element: name,
+          ...event
+        }));
+      }
+    });
+  }
+  commandsClient(dataStorage) {
+    return new Proxy({}, {
+      get: (_, name) => {
+        if (name in this.commands) {
+          return async (...args) => {
+            const forkedDataStorage = dataStorage.fork();
+            const commandContext = this.commandContext(forkedDataStorage, async (data) => {
+              if (!this.listeners)
+                return;
+              await Promise.all(this.listeners?.map((listener) => listener(data, commandContext)));
+            });
+            const result = await this.commands[name](commandContext, ...args);
+            await forkedDataStorage.merge();
+            return result;
+          };
+        }
+        console.warn(`Command '${name}' not found in the context.`);
+        return;
       }
     });
   }
@@ -405,7 +443,8 @@ class StoreState {
       id,
       data
     };
-    await this.applyChanges([change]);
+    const { from, to } = await this.applyChange(change);
+    return { from, to };
   }
   unsubscribe(listener) {
     this.listeners.delete(listener);
@@ -426,42 +465,62 @@ class ForkedStoreState extends StoreState {
     super(storeName, dataStorage, deserialize);
     this.master = master;
   }
+  async applyChangeAndReturnEvent(change) {
+    this.changes.push(change);
+    if (change.type === "set") {
+      const item = this.deserialize ? this.deserialize(change.data) : change.data;
+      this.changedItems.set(change.data._id, item);
+      return {
+        from: null,
+        to: item,
+        event: {
+          type: "set",
+          item: change.data,
+          id: change.data._id
+        }
+      };
+    }
+    if (change.type === "delete") {
+      const from = await this.findById(change.id);
+      this.changedItems.set(change.id, null);
+      return {
+        from: from || null,
+        to: null,
+        event: {
+          type: "delete",
+          item: null,
+          id: change.id
+        }
+      };
+    }
+    if (change.type === "modify") {
+      const existing = await this.findById(change.id);
+      const updated = existing ? { ...existing, ...change.data } : change.data;
+      const item = this.deserialize ? this.deserialize(updated) : updated;
+      this.changedItems.set(change.id, item);
+      return {
+        from: existing || null,
+        to: item,
+        event: {
+          type: "set",
+          item,
+          id: change.id
+        }
+      };
+    }
+    throw new Error("Unknown change type");
+  }
+  async applyChange(change) {
+    const { event, from, to } = await this.applyChangeAndReturnEvent(change);
+    this.notifyListeners([event]);
+    return { from, to };
+  }
   async applyChanges(changes) {
     const events = [];
     for (const change of changes) {
-      switch (change.type) {
-        case "set":
-          const item = this.deserialize ? this.deserialize(change.data) : change.data;
-          this.changedItems.set(change.data._id, item);
-          events.push({
-            type: "set",
-            item: change.data,
-            id: change.data._id
-          });
-          break;
-        case "delete":
-          this.changedItems.set(change.id, null);
-          events.push({
-            type: "delete",
-            item: null,
-            id: change.id
-          });
-          break;
-        case "modify":
-          {
-            const existing = await this.findById(change.id);
-            const updated = existing ? { ...existing, ...change.data } : change.data;
-            const item2 = this.deserialize ? this.deserialize(updated) : updated;
-            this.changedItems.set(change.id, item2);
-            events.push({
-              type: "set",
-              item: item2,
-              id: change.id
-            });
-          }
-          break;
-      }
-      this.changes.push(change);
+      const { event } = await this.applyChangeAndReturnEvent(change);
+      if (event)
+        events.push(event);
     }
     if (events.length > 0) {
       this.notifyListeners(events);
@@ -535,45 +594,65 @@ class MasterStoreState extends StoreState {
   constructor(storeName, dataStorage, deserialize) {
     super(storeName, dataStorage, deserialize);
   }
+  async applyChangeAndReturnEvent(transaction, change) {
+    if (change.type === "set") {
+      await transaction.set(this.storeName, change.data);
+      const item = this.deserialize ? this.deserialize(change.data) : change.data;
+      this.items.set(change.data._id, item);
+      return {
+        from: null,
+        to: item,
+        event: {
+          type: "set",
+          item: change.data,
+          id: change.data._id
+        }
+      };
+    }
+    if (change.type === "delete") {
+      await transaction.remove(this.storeName, change.id);
+      this.items.set(change.id, null);
+      return {
+        from: null,
+        to: null,
+        event: {
+          type: "delete",
+          item: null,
+          id: change.id
+        }
+      };
+    }
+    if (change.type === "modify") {
+      const existing = await transaction.findById(this.storeName, change.id);
+      const updated = existing ? { ...existing, ...change.data } : change.data;
+      await transaction.set(this.storeName, updated);
+      const item = this.deserialize ? this.deserialize(updated) : updated;
+      this.items.set(change.id, item);
+      return {
+        from: null,
+        to: item,
+        event: {
+          type: "set",
+          item,
+          id: change.id
+        }
+      };
+    }
+    throw new Error("Unknown change type");
+  }
+  async applyChange(change) {
+    const transaction = await this.dataStorage.getReadWriteTransaction();
+    const { event, from, to } = await this.applyChangeAndReturnEvent(transaction, change);
+    this.notifyListeners([event]);
+    return { from, to };
+  }
   async applyChanges(changes) {
     const transaction = await this.dataStorage.getReadWriteTransaction();
     const events = [];
     for (const change of changes) {
-      switch (change.type) {
-        case "set":
-          await transaction.set(this.storeName, change.data);
-          const item = this.deserialize ? this.deserialize(change.data) : change.data;
-          this.items.set(change.data._id, item);
-          events.push({
-            type: "set",
-            item: change.data,
-            id: change.data._id
-          });
-          break;
-        case "delete":
-          await transaction.remove(this.storeName, change.id);
-          this.items.set(change.id, null);
-          events.push({
-            type: "delete",
-            item: null,
-            id: change.id
-          });
-          break;
-        case "modify":
-          {
-            const existing = await transaction.findById(this.storeName, change.id);
-            const updated = existing ? { ...existing, ...change.data } : change.data;
-            await transaction.set(this.storeName, updated);
-            const item2 = this.deserialize ? this.deserialize(updated) : updated;
-            this.items.set(change.id, item2);
-            events.push({
-              type: "set",
-              item: item2,
-              id: change.id
-            });
-          }
-          break;
-      }
+      const { event } = await this.applyChangeAndReturnEvent(transaction, change);
+      if (event)
+        events.push(event);
     }
     await transaction.commit();
     if (events.length > 0) {
@@ -1047,33 +1126,6 @@ class RTCClient {
 var rtcClientFactory = (storage) => {
   return new RTCClient(storage);
 };
-// rtc/deserializeChanges.ts
-function deserializeChanges(changes, getCollection) {
-  return changes.map((change) => {
-    const c = getCollection(change.collection);
-    if (!c) {
-      console.error(`Collection ${change.collection} not found`);
-      return change;
-    }
-    switch (change.type) {
-      case "set":
-        return {
-          ...change,
-          body: c.deserialize(change.body)
-        };
-      case "mutate":
-        return {
-          ...change,
-          patches: change.patches.map((patch) => ({
-            ...patch,
-            value: c.schema.deserializePath(patch.path, patch.value)
-          }))
-        };
-      default:
-        return change;
-    }
-  });
-}
 export {
   stringEnum,
   string,
@@ -1081,7 +1133,6 @@ export {
   object,
   number,
   id,
-  deserializeChanges,
   date,
   context,
   collection,

package/dist/rtc/index.d.ts

@@ -1,4 +1,3 @@
 export * from "./client";
-export * from "./deserializeChanges";
 export * from "./messages";
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "private": false,
   "author": "Przemysław Krasiński [arcote.tech]",
   "description": "Arc is a framework designed to align code closely with business logic, streamlining development and enhancing productivity.",