@arcote.tech/arc 0.0.15 → 0.0.17

package/dist/index.js

@@ -1,13 +1,26 @@
-// collection/queries/abstract-collection-query.ts
-class ArcCollectionQuery {
-  collection;
+// context/element.ts
+class ArcContextElement {
+  $event;
+}
+
+// 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)
@@ -15,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;
@@ -91,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);
   }
 }
@@ -167,7 +183,7 @@ class ArcIndexedItemsQuery extends ArcManyItemsQuery {
     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);
   }
 }
@@ -198,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;
   }
 }
@@ -229,12 +247,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 +277,7 @@ class ArcCollection {
       one: (id) => new ArcOneItemQueryBuilder(this, id)
     };
   }
-  commandContext(dataStorage) {
+  commandContext(dataStorage, publishEvent) {
     const store = dataStorage.getStore(this.name);
     return {
       add: async (data) => {
@@ -269,6 +288,10 @@ class ArcCollection {
           ...parsed
         };
         await store.set(body);
+        await publishEvent({
+          type: "set",
+          to: body
+        });
         return { id };
       },
       remove: async (id) => {
@@ -282,6 +305,10 @@ class ArcCollection {
           ...parsed
         };
         await store.set(body);
+        await publishEvent({
+          type: "set",
+          to: body
+        });
         return { success: true };
       },
       all: async () => {
@@ -291,8 +318,22 @@ class ArcCollection {
         return store.findById(id);
       },
       modify: async (id, data) => {
-        const deserialized = this.schema.deserialize(data);
-        await store.modify(id, deserialized);
+        const deserialized = this.schema.serializePartial(data);
+        const { from, to } = await store.modify(id, deserialized);
+        await publishEvent({
+          type: "modify",
+          changes: deserialized,
+          from,
+          to
+        });
+      },
+      edit: async (id, editCallback) => {
+        const { from, to } = await store.mutate(id, editCallback);
+        await publishEvent({
+          type: "mutate",
+          from,
+          to
+        });
       }
     };
   }
@@ -307,8 +348,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 +377,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,21 +405,83 @@ class ArcContext {
       }
     });
   }
-  commandContext(dataStorage) {
+  commandContext(client, dataStorage, publishEvent) {
     return new Proxy({}, {
       get: (target, name) => {
+        if (name === "$client") {
+          return client;
+        }
         const element = this.elementsMap[name];
-        return element.commandContext(dataStorage);
+        return element.commandContext(dataStorage, (event) => publishEvent({
+          element: name,
+          ...event
+        }));
+      }
+    });
+  }
+  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(client, forkedDataStorage, async (data) => {
+              if (!this.listeners)
+                return;
+              await Promise.all(this.listeners?.map((listener) => listener(data, commandContext)));
+            });
+            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.`);
+        return;
       }
     });
   }
 }
+// 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;
@@ -405,13 +510,27 @@ class StoreState {
       id,
       data
     };
-    await this.applyChanges([change]);
+    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);
     }
   }
@@ -426,42 +545,77 @@ 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 ? 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 {
+        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);
@@ -469,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;
@@ -499,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() {
@@ -523,57 +687,96 @@ 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;
   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 ? 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);
+      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) {
@@ -582,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)
@@ -618,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();
@@ -637,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);
@@ -662,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);
   }
@@ -784,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) {
@@ -801,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
@@ -869,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);
@@ -906,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);
@@ -1034,6 +1306,7 @@ class RTCClient {
         });
         break;
       case "state-changes":
+        this.storage.applyChanges(message.changes);
         break;
       default:
         console.warn(`Message unsupported`, message);
@@ -1047,41 +1320,114 @@ 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;
+// 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,
-  deserializeChanges,
   date,
   context,
   collection,
@@ -1092,9 +1438,13 @@ export {
   MasterDataStorage,
   ForkedStoreState,
   ForkedDataStorage,
+  DataStorage,
   ArcStringEnum,
   ArcString,
+  ArcState,
+  ArcRecord,
   ArcQueryBuilder,
+  ArcQuery,
   ArcOptional,
   ArcObject,
   ArcNumber,