@arcote.tech/arc 0.0.16 → 0.0.18

package/dist/index.js

@@ -3,16 +3,24 @@ class ArcContextElement {
   $event;
 }
 
-// collection/queries/abstract-collection-query.ts
-class ArcCollectionQuery {
-  collection;
+// context/query.ts
+class ArcQuery {
   lastResult;
   listener;
+}
+
+// collection/queries/abstract-collection-query.ts
+class ArcCollectionQuery extends ArcQuery {
+  collection;
+  bindedChangeHandler = this.changeHandler.bind(this);
+  store;
   constructor(collection) {
+    super();
     this.collection = collection;
   }
   async run(dataStorage, listener) {
     const store = dataStorage.getStore(this.collection.name);
+    this.store = store;
     const result = await this.fetch(store);
     this.lastResult = result;
     if (listener)
@@ -20,16 +28,19 @@ class ArcCollectionQuery {
     return result;
   }
   changeHandler(changes) {
+    let resultChanged = false;
     for (const change of changes) {
       const response = this.onChange(change);
-      if (response !== false)
+      if (response !== false) {
         this.lastResult = response;
+        resultChanged = true;
+      }
     }
-    if (this.lastResult)
+    if (resultChanged)
       this.nextResult(this.lastResult);
   }
   unsubscribe() {
-    console.log("unsubscribe");
+    this.store.unsubscribe(this.bindedChangeHandler);
   }
   nextResult(result) {
     this.lastResult = result;
@@ -96,7 +107,7 @@ class ArcManyItemsQuery extends ArcCollectionQuery {
 // collection/queries/all-items.ts
 class ArcAllItemsQuery extends ArcManyItemsQuery {
   async fetch(store) {
-    const results = await store.findAll(this.changeHandler.bind(this));
+    const results = await store.findAll(this.bindedChangeHandler);
     return this.createFiltredResult(results);
   }
 }
@@ -166,13 +177,13 @@ class ArcIndexedItemsQuery extends ArcManyItemsQuery {
   checkItem(item) {
     if (!super.checkItem(item))
       return false;
-    const notCorrect = Object.entries(this.data).find(([key, value]) => item[key] !== value);
-    if (notCorrect)
+    const correct = Object.entries(this.data).every(([key, value]) => item[key] === value);
+    if (!correct)
       return false;
     return true;
   }
   async fetch(store) {
-    const results = await store.findByIndex(this.index, this.data, this.changeHandler.bind(this));
+    const results = await store.findByIndex(this.index, this.data, this.bindedChangeHandler);
     return this.createFiltredResult(results);
   }
 }
@@ -203,14 +214,16 @@ class ArcOneItemQuery extends ArcCollectionQuery {
     this.id = id;
   }
   onChange(change) {
+    if (change.id !== this.id)
+      return false;
     if (change.type === "delete")
-      return;
+      return null;
     if (change.type === "set")
       return change.item;
     return false;
   }
   async fetch(store) {
-    const result = await store.findById(this.id, this.changeHandler.bind(this));
+    const result = await store.findById(this.id, this.bindedChangeHandler);
     return result;
   }
 }
@@ -275,6 +288,10 @@ class ArcCollection extends ArcContextElement {
           ...parsed
         };
         await store.set(body);
+        await publishEvent({
+          type: "set",
+          to: body
+        });
         return { id };
       },
       remove: async (id) => {
@@ -288,6 +305,10 @@ class ArcCollection extends ArcContextElement {
           ...parsed
         };
         await store.set(body);
+        await publishEvent({
+          type: "set",
+          to: body
+        });
         return { success: true };
       },
       all: async () => {
@@ -297,11 +318,19 @@ class ArcCollection extends ArcContextElement {
         return store.findById(id);
       },
       modify: async (id, data) => {
-        const deserialized = this.schema.deserialize(data);
+        const deserialized = this.schema.serializePartial(data);
         const { from, to } = await store.modify(id, deserialized);
         await publishEvent({
           type: "modify",
-          changes: data,
+          changes: deserialized,
+          from,
+          to
+        });
+      },
+      edit: async (id, editCallback) => {
+        const { from, to } = await store.mutate(id, editCallback);
+        await publishEvent({
+          type: "mutate",
           from,
           to
         });
@@ -376,9 +405,12 @@ class ArcContext {
       }
     });
   }
-  commandContext(dataStorage, publishEvent) {
+  commandContext(client, dataStorage, publishEvent) {
     return new Proxy({}, {
       get: (target, name) => {
+        if (name === "$client") {
+          return client;
+        }
         const element = this.elementsMap[name];
         return element.commandContext(dataStorage, (event) => publishEvent({
           element: name,
@@ -387,20 +419,26 @@ class ArcContext {
       }
     });
   }
-  commandsClient(dataStorage) {
+  commandsClient(client, dataStorage, catchErrorCallback) {
     return new Proxy({}, {
       get: (_, name) => {
         if (name in this.commands) {
           return async (...args) => {
             const forkedDataStorage = dataStorage.fork();
-            const commandContext = this.commandContext(forkedDataStorage, async (data) => {
+            const commandContext = this.commandContext(client, 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;
+            try {
+              const result = await this.commands[name](commandContext, ...args);
+              await forkedDataStorage.merge();
+              return result;
+            } catch (error) {
+              console.log("error", error);
+              catchErrorCallback(error);
+              return error;
+            }
           };
         }
         console.warn(`Command '${name}' not found in the context.`);
@@ -409,12 +447,41 @@ class ArcContext {
     });
   }
 }
+// data-storage/data-storage.abstract.ts
+class DataStorage {
+  async commitChanges(changes) {
+    await Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+  }
+}
+
+// data-storage/store-state-fork.ts
+import { apply } from "mutative";
+
+// data-storage/deep-merge.ts
+function deepMerge(target, source) {
+  const output = { ...target };
+  for (const key in source) {
+    if (source[key] === undefined)
+      continue;
+    if (isObject(source[key]) && isObject(target[key])) {
+      output[key] = deepMerge(target[key], source[key]);
+    } else {
+      output[key] = source[key];
+    }
+  }
+  return output;
+}
+function isObject(item) {
+  return item && typeof item === "object" && !Array.isArray(item);
+}
+
 // data-storage/store-state.abstract.ts
+import { create } from "mutative";
 class StoreState {
   storeName;
   dataStorage;
   deserialize;
-  listeners = new Set;
+  listeners = new Map;
   constructor(storeName, dataStorage, deserialize) {
     this.storeName = storeName;
     this.dataStorage = dataStorage;
@@ -446,11 +513,24 @@ class StoreState {
     const { from, to } = await this.applyChange(change);
     return { from, to };
   }
+  async mutate(id, editCallback) {
+    const object = await this.findById(id);
+    const [draft, finalize] = create(object || {}, { enablePatches: true });
+    await editCallback(draft);
+    const [_, patches] = finalize();
+    const change = {
+      type: "mutate",
+      id,
+      patches
+    };
+    const { from, to } = await this.applyChange(change);
+    return { from, to };
+  }
   unsubscribe(listener) {
     this.listeners.delete(listener);
   }
   notifyListeners(events) {
-    for (const listener of this.listeners) {
+    for (const listener of this.listeners.values()) {
       listener.callback(events);
     }
   }
@@ -495,7 +575,22 @@ class ForkedStoreState extends StoreState {
     }
     if (change.type === "modify") {
       const existing = await this.findById(change.id);
-      const updated = existing ? { ...existing, ...change.data } : change.data;
+      const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...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
+        }
+      };
+    }
+    if (change.type === "mutate") {
+      const existing = await this.findById(change.id);
+      const updated = apply(existing || {}, change.patches);
       const item = this.deserialize ? this.deserialize(updated) : updated;
       this.changedItems.set(change.id, item);
       return {
@@ -528,25 +623,34 @@ class ForkedStoreState extends StoreState {
   }
   async findById(id, listener) {
     if (listener)
-      this.listeners.add({ callback: listener, id });
+      this.listeners.set(listener, { callback: listener, id });
     if (this.changedItems.has(id))
       return this.changedItems.get(id);
     return await this.master.findById(id);
   }
   async findByIndex(index, data, listener) {
     if (listener)
-      this.listeners.add({ callback: listener });
+      this.listeners.set(listener, { callback: listener });
     const parentResult = await this.master.findByIndex(index, data);
-    return parentResult.map((item) => {
-      const id = item._id;
-      if (this.changedItems.has(id))
-        return this.changedItems.get(id);
-      return item;
-    });
+    const results = new Map;
+    parentResult.forEach((item) => results.set(item._id, item));
+    for (const [id, changedItem] of this.changedItems) {
+      if (changedItem === null) {
+        results.delete(id);
+        continue;
+      }
+      const matches = Object.entries(data).every(([key, value]) => changedItem[key] === value);
+      if (matches) {
+        results.set(id, changedItem);
+      } else {
+        results.delete(id);
+      }
+    }
+    return Array.from(results.values());
   }
   async findAll(listener) {
     if (listener)
-      this.listeners.add({ callback: listener });
+      this.listeners.set(listener, { callback: listener });
     const parentResult = await this.master.findAll();
     return parentResult.map((item) => {
       const id = item._id;
@@ -558,10 +662,11 @@ class ForkedStoreState extends StoreState {
 }
 
 // data-storage/data-storage-forked.ts
-class ForkedDataStorage {
+class ForkedDataStorage extends DataStorage {
   master;
   stores = new Map;
   constructor(master) {
+    super();
     this.master = master;
   }
   getReadTransaction() {
@@ -582,12 +687,15 @@ class ForkedDataStorage {
     return new ForkedDataStorage(this);
   }
   async merge() {
-    for (const store of this.stores.values()) {
-      await store.master?.applyChanges(store.changes);
-    }
+    const changes = Array.from(this.stores.values()).filter((store) => store.changes.length > 0).map((store) => ({
+      store: store.storeName,
+      changes: store.changes
+    }));
+    await this.master.commitChanges(changes);
   }
 }
 // data-storage/store-state-master.ts
+import { apply as apply2 } from "mutative";
 class MasterStoreState extends StoreState {
   items = new Map;
   isComplete = false;
@@ -624,7 +732,23 @@ class MasterStoreState extends StoreState {
     }
     if (change.type === "modify") {
       const existing = await transaction.findById(this.storeName, change.id);
-      const updated = existing ? { ...existing, ...change.data } : change.data;
+      const updated = existing ? deepMerge(existing, change.data) : { _id: change.id, ...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
+        }
+      };
+    }
+    if (change.type === "mutate") {
+      const existing = await transaction.findById(this.storeName, change.id);
+      const updated = apply2(existing, change.patches);
       await transaction.set(this.storeName, updated);
       const item = this.deserialize ? this.deserialize(updated) : updated;
       this.items.set(change.id, item);
@@ -661,20 +785,20 @@ class MasterStoreState extends StoreState {
   }
   async findById(id, listener) {
     if (listener)
-      this.listeners.add({ callback: listener, id });
+      this.listeners.set(listener, { callback: listener, id });
     if (this.items.has(id))
       return this.items.get(id);
     const transaction = await this.dataStorage.getReadTransaction();
     const result = await transaction.findById(this.storeName, id);
-    if (!result)
+    const item = result && this.deserialize ? this.deserialize(result) : result;
+    if (!item)
       return;
-    const item = this.deserialize ? this.deserialize(result) : result;
     this.items.set(id, item);
     return item;
   }
   async findByIndex(index, data, listener) {
     if (listener)
-      this.listeners.add({ callback: listener });
+      this.listeners.set(listener, { callback: listener });
     if (this.isComplete) {
       const results2 = Array.from(this.items.values()).filter((item) => {
         if (!item)
@@ -697,7 +821,7 @@ class MasterStoreState extends StoreState {
   }
   async findAll(listener) {
     if (listener)
-      this.listeners.add({ callback: listener });
+      this.listeners.set(listener, { callback: listener });
     if (this.isComplete)
       return Array.from(this.items.values()).filter((e) => !!e);
     const transaction = await this.dataStorage.getReadTransaction();
@@ -716,12 +840,13 @@ class MasterStoreState extends StoreState {
 }
 
 // data-storage/data-storage-master.ts
-class MasterDataStorage {
+class MasterDataStorage extends DataStorage {
   dbAdapter;
   arcContext;
   stores = new Map;
   rtcAdapter;
   constructor(dbAdapter, rtcAdapterFactory, arcContext) {
+    super();
     this.dbAdapter = dbAdapter;
     this.arcContext = arcContext;
     this.rtcAdapter = rtcAdapterFactory(this);
@@ -741,6 +866,15 @@ class MasterDataStorage {
     }
     return this.stores.get(storeName);
   }
+  async applyChanges(changes) {
+    return Promise.all(changes.map(({ store, changes: changes2 }) => this.getStore(store).applyChanges(changes2)));
+  }
+  async commitChanges(changes) {
+    await Promise.all([
+      this.applyChanges(changes),
+      this.rtcAdapter.commitChanges(changes)
+    ]);
+  }
   fork() {
     return new ForkedDataStorage(this);
   }
@@ -863,7 +997,10 @@ class ArcObject extends ArcAbstract {
     }, {});
   }
   deserialize(value) {
-    return Object.fromEntries(Object.entries(this.rawShape).filter(([key]) => (key in value)).map(([key, element]) => [key, element.deserialize(value[key])]));
+    return Object.fromEntries(Object.entries(this.rawShape).map(([key, element]) => [
+      key,
+      element.deserialize(value[key])
+    ]));
   }
   deserializePath(path, value) {
     if (path.length === 0) {
@@ -880,6 +1017,24 @@ class ArcObject extends ArcAbstract {
     }
     return element.deserialize(value);
   }
+  parsePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].parse(value2);
+      return acc;
+    }, {});
+  }
+  deserializePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].deserialize(value2);
+      return acc;
+    }, {});
+  }
+  serializePartial(value) {
+    return Object.entries(value).reduce((acc, [key, value2]) => {
+      acc[key] = this.rawShape[key].serialize(value2);
+      return acc;
+    }, {});
+  }
 }
 
 // elements/array.ts
@@ -948,7 +1103,7 @@ class ArcDate extends ArcAbstract {
     return new Date(value);
   }
   serialize(value) {
-    return value.toString();
+    return value.getTime();
   }
   deserialize(value) {
     return new Date(value);
@@ -985,6 +1140,44 @@ function number() {
 
 class ArcNumber extends ArcPrimitive {
 }
+// elements/record.ts
+function record(key, element) {
+  return new ArcRecord(key, element);
+}
+
+class ArcRecord extends ArcAbstract {
+  key;
+  element;
+  constructor(key, element) {
+    super();
+    this.key = key;
+    this.element = element;
+  }
+  parse(value) {
+    if (!value)
+      return {};
+    return Object.entries(value).reduce((acc, [key, recordValue]) => {
+      acc[key] = this.element.parse(recordValue);
+      return acc;
+    }, {});
+  }
+  serialize(value) {
+    if (!value)
+      return {};
+    return Object.entries(value).reduce((acc, [key, recordValue]) => {
+      acc[key] = this.element.serialize(recordValue);
+      return acc;
+    }, {});
+  }
+  deserialize(value) {
+    if (!value)
+      return {};
+    return Object.entries(value).reduce((acc, [key, recordValue]) => {
+      acc[key] = this.element.deserialize(recordValue);
+      return acc;
+    }, {});
+  }
+}
 // elements/string-enum.ts
 function stringEnum(...values) {
   return new ArcStringEnum(values);
@@ -1113,6 +1306,7 @@ class RTCClient {
         });
         break;
       case "state-changes":
+        this.storage.applyChanges(message.changes);
         break;
       default:
         console.warn(`Message unsupported`, message);
@@ -1126,10 +1320,111 @@ class RTCClient {
 var rtcClientFactory = (storage) => {
   return new RTCClient(storage);
 };
+// state/query.ts
+class ArcStateQuery extends ArcQuery {
+  state;
+  bindedChangeHandler = this.changeHandler.bind(this);
+  store;
+  constructor(state) {
+    super();
+    this.state = state;
+  }
+  async run(dataStorage, listener) {
+    this.store = dataStorage.getStore("state");
+    const result = await this.store.findById(this.state.name, this.bindedChangeHandler);
+    this.lastResult = this.state.deserialize(result);
+    if (listener)
+      this.listener = listener;
+    return this.lastResult;
+  }
+  onChange(change) {
+    if (change.type === "set")
+      return change.item;
+    return false;
+  }
+  changeHandler(changes) {
+    for (const change of changes) {
+      const response = this.onChange(change);
+      if (response !== false)
+        this.lastResult = this.state.deserialize(response);
+    }
+    if (this.lastResult)
+      this.nextResult(this.lastResult);
+  }
+  unsubscribe() {
+    this.store.unsubscribe(this.bindedChangeHandler);
+  }
+  nextResult(result) {
+    this.lastResult = result;
+    this.listener?.(result);
+  }
+}
+
+// state/query-builder.ts
+class ArcStateQueryBuilder extends ArcQueryBuilder {
+  state;
+  constructor(state) {
+    super();
+    this.state = state;
+  }
+  toQuery() {
+    return new ArcStateQuery(this.state);
+  }
+}
+
+// state/state.ts
+function state(name, schema) {
+  return new ArcState(name, schema);
+}
+
+class ArcState extends ArcContextElement {
+  name;
+  schema;
+  constructor(name, schema) {
+    super();
+    this.name = name;
+    this.schema = schema;
+  }
+  serialize(data) {
+    return {
+      ...this.schema.serialize(data),
+      _id: this.name
+    };
+  }
+  deserialize(data) {
+    return this.schema.deserialize(data || {});
+  }
+  queryBuilder() {
+    return new ArcStateQueryBuilder(this);
+  }
+  commandContext(dataStorage, publishEvent) {
+    const store = dataStorage.getStore("state");
+    return {
+      get: async () => {
+        return store.findById(this.name);
+      },
+      modify: async (data) => {
+        const serialized = this.serialize(data);
+        const { from, to } = await store.modify(this.name, serialized);
+        await publishEvent({
+          type: "modify",
+          changes: data,
+          from,
+          to
+        });
+      },
+      edit: async (editCallback) => {
+        const { from, to } = await store.mutate(this.name, editCallback);
+      }
+    };
+  }
+}
 export {
   stringEnum,
   string,
+  state,
   rtcClientFactory,
+  record,
   object,
   number,
   id,
@@ -1143,9 +1438,13 @@ export {
   MasterDataStorage,
   ForkedStoreState,
   ForkedDataStorage,
+  DataStorage,
   ArcStringEnum,
   ArcString,
+  ArcState,
+  ArcRecord,
   ArcQueryBuilder,
+  ArcQuery,
   ArcOptional,
   ArcObject,
   ArcNumber,

package/dist/rtc/index.d.ts

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

package/dist/rtc/messages.d.ts

@@ -1,10 +1,10 @@
-import type { StoreStateChange } from "../data-storage";
+import type { DataStorageChanges } from "../data-storage/data-storage.abstract";
 export type MessageClientToHost = {
     type: "sync";
     lastDate: string | null;
 } | {
     type: "changes-executed";
-    changes: StoreStateChange<any>[];
+    changes: DataStorageChanges[];
 };
 export type MessageHostToClient = {
     type: "sync-result";
@@ -12,7 +12,7 @@ export type MessageHostToClient = {
     items: any[];
 } | {
     type: "state-changes";
-    changes: StoreStateChange<any>[];
+    changes: DataStorageChanges[];
 } | {
     type: "sync-done";
     date: string;

package/dist/rtc/rtc.d.ts

@@ -1,10 +1,11 @@
-import type { DataStorage, StoreStateChange } from "../data-storage/data-storage.interface";
+import type { MasterDataStorage } from "../data-storage";
+import type { DataStorageChanges } from "../data-storage/data-storage.abstract";
 export interface RealTimeCommunicationAdapter {
-    commitChanges(changes: StoreStateChange<any>[]): void;
+    commitChanges(changes: DataStorageChanges[]): void;
     sync(progressCallback: ({ store, size }: {
         store: string;
         size: number;
     }) => void): Promise<void>;
 }
-export type RealTimeCommunicationAdapterFactory = (storage: DataStorage) => RealTimeCommunicationAdapter;
+export type RealTimeCommunicationAdapterFactory = (storage: MasterDataStorage) => RealTimeCommunicationAdapter;
 //# sourceMappingURL=rtc.d.ts.map