@arcote.tech/arc 0.0.12 → 0.0.14

package/dist/index.js

@@ -1,48 +1,34 @@
-// collection/collection.ts
-import { apply } from "mutative";
-
 // collection/queries/abstract-collection-query.ts
-import { BehaviorSubject, debounceTime, Subject } from "rxjs";
-
 class ArcCollectionQuery {
   collection;
-  result$ = new Subject;
-  resultQueue$;
-  subscriptions = [];
+  lastResult;
+  listener;
   constructor(collection) {
     this.collection = collection;
   }
-  getLastResult() {
-    return this.resultQueue$.getValue();
-  }
-  async run(db, changes$) {
-    const subscription = changes$.subscribe(this.changeHandler.bind(this));
-    this.subscriptions.push(subscription);
-    const transaction = await db.readTransaction([this.collection]);
-    const result = await this.fetch(transaction);
-    this.resultQueue$ = new BehaviorSubject(result);
-    const subscriptionDebounce = this.resultQueue$.pipe(debounceTime(50)).subscribe(this.result$);
-    this.subscriptions.push(subscriptionDebounce);
+  async run(dataStorage, listener) {
+    const store = dataStorage.getStore(this.collection.name);
+    const result = await this.fetch(store);
+    this.lastResult = result;
+    if (listener)
+      this.listener = listener;
+    return result;
   }
-  changeHandler(change) {
-    if (change.collection !== this.collection.name)
-      return;
-    if (!this.resultQueue$)
-      return;
-    const response = this.onChange(change);
-    if (response !== false)
-      this.nextResult(response);
+  changeHandler(changes) {
+    for (const change of changes) {
+      const response = this.onChange(change);
+      if (response !== false)
+        this.lastResult = response;
+    }
+    if (this.lastResult)
+      this.nextResult(this.lastResult);
   }
   unsubscribe() {
-    this.subscriptions.forEach((sub) => sub.unsubscribe());
+    console.log("unsubscribe");
   }
   nextResult(result) {
-    if (!this.resultQueue$)
-      return console.warn("Weird, it shouldn't happen :/");
-    this.resultQueue$.next(result);
-  }
-  isUnsubscribed() {
-    return this.subscriptions.every((sub) => sub.closed);
+    this.lastResult = result;
+    this.listener?.(result);
   }
 }
 
@@ -72,17 +58,17 @@ class ArcManyItemsQuery extends ArcCollectionQuery {
     this.sortFn = sortFn;
   }
   onChange(change) {
-    const lastResult = this.getLastResult();
-    const lastResultAsArray = lastResult.toArray();
-    const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.body._id));
+    const lastResult = this.lastResult;
+    const lastResultAsArray = lastResult?.toArray() || [];
+    const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.id));
     const isInLastResult = index !== -1;
-    const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.body);
+    const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.item);
     if (isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.toSpliced(index, 1, change.body));
+      return this.createResult(lastResultAsArray.toSpliced(index, 1, change.item));
     else if (isInLastResult && (change.type === "delete" || !shouldBeInTheResult))
       return this.createResult(lastResultAsArray.toSpliced(index, 1));
     else if (!isInLastResult && shouldBeInTheResult)
-      return this.createResult(lastResultAsArray.concat(change.body));
+      return this.createResult(lastResultAsArray.concat(change.item));
     return false;
   }
   createResult(result) {
@@ -104,8 +90,9 @@ class ArcManyItemsQuery extends ArcCollectionQuery {
 
 // collection/queries/all-items.ts
 class ArcAllItemsQuery extends ArcManyItemsQuery {
-  async fetch(transaction) {
-    return this.createFiltredResult(await transaction.findAll(this.collection));
+  async fetch(store) {
+    const results = await store.findAll(this.changeHandler.bind(this));
+    return this.createFiltredResult(results);
   }
 }
 
@@ -114,6 +101,23 @@ class ArcQueryBuilder {
 }
 
 // collection/query-builders/abstract-many-items.ts
+function sortComparatorBuilder(comparator) {
+  if (typeof comparator === "function") {
+    return comparator;
+  } else if (Array.isArray(comparator)) {
+    return (a, b) => {
+      for (const [key, order] of comparator) {
+        if (a[key] < b[key])
+          return order === "ASC" ? -1 : 1;
+        if (a[key] > b[key])
+          return order === "ASC" ? 1 : -1;
+      }
+      return 0;
+    };
+  }
+  throw new Error("Invalid comparator type");
+}
+
 class ArcManyItemsQueryBuilder extends ArcQueryBuilder {
   filterFn;
   sortFn;
@@ -121,8 +125,8 @@ class ArcManyItemsQueryBuilder extends ArcQueryBuilder {
     this.filterFn = callback;
     return this;
   }
-  sort(callback) {
-    this.sortFn = callback;
+  sort(comparator) {
+    this.sortFn = sortComparatorBuilder(comparator);
     return this;
   }
 }
@@ -133,6 +137,8 @@ class ArcAllItemsQueryBuilder extends ArcManyItemsQueryBuilder {
   constructor(collection) {
     super();
     this.collection = collection;
+    if (collection.options.sort)
+      this.sortFn = collection.options.sort;
   }
   toQuery() {
     return new ArcAllItemsQuery(this.collection, this.filterFn, this.sortFn);
@@ -160,8 +166,9 @@ class ArcIndexedItemsQuery extends ArcManyItemsQuery {
       return false;
     return true;
   }
-  async fetch(transaction) {
-    return this.createFiltredResult(await transaction.findByIndex(this.collection, this.index, this.data));
+  async fetch(store) {
+    const results = await store.findByIndex(this.index, this.data, this.changeHandler.bind(this));
+    return this.createFiltredResult(results);
   }
 }
 
@@ -175,6 +182,8 @@ class ArcIndexedItemsQueryBuilder extends ArcManyItemsQueryBuilder {
     this.collection = collection;
     this.index = index;
     this.data = data;
+    if (collection.options.sort)
+      this.sortFn = collection.options.sort;
   }
   toQuery() {
     return new ArcIndexedItemsQuery(this.collection, this.index, this.data, this.filterFn, this.sortFn);
@@ -189,16 +198,15 @@ class ArcOneItemQuery extends ArcCollectionQuery {
     this.id = id;
   }
   onChange(change) {
-    if (change.type === "delete" && change.id === this.id)
+    if (change.type === "delete")
       return;
-    if (change.type === "set" && change.body._id === this.id)
-      return change.body;
+    if (change.type === "set")
+      return change.item;
     return false;
   }
-  fetch(transaction) {
-    if (!this.id)
-      return;
-    return transaction.findById(this.collection, this.id);
+  async fetch(store) {
+    const result = await store.findById(this.id, this.changeHandler.bind(this));
+    return result;
   }
 }
 
@@ -217,18 +225,20 @@ class ArcOneItemQueryBuilder extends ArcQueryBuilder {
 }
 
 // collection/collection.ts
-function collection(name, id, schema) {
-  return new ArcCollection(name, id, schema);
+function collection(name, id, schema, options = {}) {
+  return new ArcCollection(name, id, schema, options);
 }
 
 class ArcCollection {
   name;
   id;
   schema;
-  constructor(name, id, schema) {
+  options;
+  constructor(name, id, schema, options) {
     this.name = name;
     this.id = id;
     this.schema = schema;
+    this.options = options;
   }
   serialize(data) {
     return {
@@ -248,72 +258,69 @@ class ArcCollection {
       one: (id) => new ArcOneItemQueryBuilder(this, id)
     };
   }
-  commandContext(transaction, changes, getDraft) {
+  commandContext(dataStorage) {
+    const store = dataStorage.getStore(this.name);
     return {
-      add: (data) => {
+      add: async (data) => {
         const id = this.id.generate();
         const parsed = this.schema.parse(data);
         const body = {
           _id: id,
           ...parsed
         };
-        changes.push({ type: "set", collection: this.name, body });
+        await store.set(body);
         return { id };
       },
-      remove: (id) => {
-        changes.push({ type: "delete", collection: this.name, id });
+      remove: async (id) => {
+        await store.remove(id);
         return { success: true };
       },
-      set: (id, data) => {
+      set: async (id, data) => {
         const parsed = this.schema.parse(data);
         const body = {
           _id: id,
           ...parsed
         };
-        changes.push({ type: "set", collection: this.name, body });
+        await store.set(body);
         return { success: true };
       },
+      all: async () => {
+        return store.findAll();
+      },
       one: async (id) => {
-        const object = await transaction.findById(this, id);
-        return getDraft(this.name, object);
+        return store.findById(id);
+      },
+      modify: async (id, data) => {
+        const deserialized = this.schema.deserialize(data);
+        await store.modify(id, deserialized);
       }
     };
   }
-  async applyChange(transaction, change, events) {
-    switch (change.type) {
-      case "set":
-        await transaction.set(this, change.body);
-        events.push(change);
-        break;
-      case "delete":
-        await transaction.remove(this, change.id);
-        events.push(change);
-        break;
-      case "mutate":
-        const existingObject = await transaction.findById(this, change.id);
-        if (existingObject) {
-          const updatedObject = apply(existingObject, change.patches);
-          await transaction.set(this, updatedObject);
-          events.push({
-            type: "set",
-            collection: change.collection,
-            body: updatedObject
-          });
-        }
-        break;
-    }
-  }
   indexBy(indexes) {
-    return new ArcIndexedCollection(this.name, this.id, this.schema, indexes);
+    return new ArcIndexedCollection(this.name, this.id, this.schema, this.options, indexes);
   }
 }
 
 class ArcIndexedCollection extends ArcCollection {
   indexes;
-  constructor(name, id, schema, indexes) {
-    super(name, id, schema);
+  constructor(name, id, schema, options, indexes) {
+    super(name, id, schema, options);
     this.indexes = indexes;
   }
+  commandContext(dataStorage) {
+    const superContext = super.commandContext(dataStorage);
+    return new Proxy(superContext, {
+      get: (target, name) => {
+        if (name in target) {
+          return target[name];
+        }
+        if (!(name in this.indexes)) {
+          throw new Error(`Index "${name}" not found in collection "${this.name}"`);
+        }
+        return (data) => dataStorage.getStore(this.name, this.deserialize.bind(this)).findByIndex(name, data);
+      }
+    });
+  }
   queryBuilder() {
     const superQueryBuilder = super.queryBuilder();
     return new Proxy({}, {
@@ -329,22 +336,25 @@ class ArcIndexedCollection extends ArcCollection {
   }
 }
 // context/context.ts
-import { create } from "mutative";
-function context(...collections) {
-  return new ArcContext(collections);
+function context(elements, commands, version) {
+  return new ArcContext(elements, commands, version);
 }
 
 class ArcContext {
-  collections;
-  collectionsMap;
-  constructor(collections) {
-    this.collections = collections;
-    this.collectionsMap = Object.fromEntries(collections.map((collection3) => [collection3.name, collection3]));
+  elements;
+  commands;
+  version;
+  elementsMap;
+  constructor(elements, commands, version) {
+    this.elements = elements;
+    this.commands = commands;
+    this.version = version;
+    this.elementsMap = Object.fromEntries(elements.map((collection3) => [collection3.name, collection3]));
   }
   queryBuilder() {
     return new Proxy({}, {
       get: (target, name) => {
-        const collection3 = this.collectionsMap[name];
+        const collection3 = this.elementsMap[name];
         if (!collection3) {
           throw new Error(`Collection "${name}" not found`);
         }
@@ -352,57 +362,308 @@ class ArcContext {
       }
     });
   }
-  commandContext(transaction) {
-    const changes = [];
-    const collectionDrafts = [];
-    function getDraft(collection3, base) {
-      const [draft, finalize2] = create(base, { enablePatches: true });
-      collectionDrafts.push({
-        collection: collection3,
-        finalize: finalize2
-      });
-      return draft;
-    }
-    const contextProxy = new Proxy({}, {
+  commandContext(dataStorage) {
+    return new Proxy({}, {
       get: (target, name) => {
-        const collection3 = this.collectionsMap[name];
-        if (!collection3) {
-          throw new Error(`Collection "${name}" not found`);
-        }
-        return collection3.commandContext(transaction, changes, getDraft);
+        const element = this.elementsMap[name];
+        return element.commandContext(dataStorage);
       }
     });
-    function finalize() {
-      for (const { finalize: finalize2, collection: collection3 } of collectionDrafts) {
-        const [object, patches, inversePatches] = finalize2();
-        changes.push({
-          type: "mutate",
-          collection: collection3,
-          id: object._id,
-          patches
-        });
+  }
+}
+// data-storage/store-state.abstract.ts
+class StoreState {
+  storeName;
+  dataStorage;
+  deserialize;
+  listeners = new Set;
+  constructor(storeName, dataStorage, deserialize) {
+    this.storeName = storeName;
+    this.dataStorage = dataStorage;
+    this.deserialize = deserialize;
+  }
+  fork() {
+    return new ForkedStoreState(this.storeName, this.dataStorage, this, this.deserialize);
+  }
+  async set(item) {
+    const change = {
+      type: "set",
+      data: item
+    };
+    await this.applyChanges([change]);
+  }
+  async remove(id) {
+    const change = {
+      type: "delete",
+      id
+    };
+    await this.applyChanges([change]);
+  }
+  async modify(id, data) {
+    const change = {
+      type: "modify",
+      id,
+      data
+    };
+    await this.applyChanges([change]);
+  }
+  unsubscribe(listener) {
+    this.listeners.delete(listener);
+  }
+  notifyListeners(events) {
+    for (const listener of this.listeners) {
+      listener.callback(events);
+    }
+  }
+}
+
+// data-storage/store-state-fork.ts
+class ForkedStoreState extends StoreState {
+  master;
+  changedItems = new Map;
+  changes = [];
+  constructor(storeName, dataStorage, master, deserialize) {
+    super(storeName, dataStorage, deserialize);
+    this.master = master;
+  }
+  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;
       }
-      return changes;
+      this.changes.push(change);
+    }
+    if (events.length > 0) {
+      this.notifyListeners(events);
     }
-    return { context: contextProxy, finalize };
   }
-  async applyChange(transaction, change, events) {
-    const collection3 = this.collectionsMap[change.collection];
-    if (!collection3) {
-      throw new Error(`Collection "${change.collection}" not found`);
+  async findById(id, listener) {
+    if (listener)
+      this.listeners.add({ 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 });
+    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;
+    });
+  }
+  async findAll(listener) {
+    if (listener)
+      this.listeners.add({ callback: listener });
+    const parentResult = await this.master.findAll();
+    return parentResult.map((item) => {
+      const id = item._id;
+      if (this.changedItems.has(id))
+        return this.changedItems.get(id);
+      return item;
+    });
+  }
+}
+
+// data-storage/data-storage-forked.ts
+class ForkedDataStorage {
+  master;
+  stores = new Map;
+  constructor(master) {
+    this.master = master;
+  }
+  getReadTransaction() {
+    return this.master.getReadTransaction();
+  }
+  getReadWriteTransaction() {
+    return this.master.getReadWriteTransaction();
+  }
+  getStore(storeName, deserialize) {
+    if (this.stores.has(storeName))
+      return this.stores.get(storeName);
+    const masterStorage = this.master.getStore(storeName, deserialize);
+    const storage = new ForkedStoreState(storeName, this, masterStorage, deserialize);
+    this.stores.set(storeName, storage);
+    return storage;
+  }
+  fork() {
+    return new ForkedDataStorage(this);
+  }
+  async merge() {
+    for (const store of this.stores.values()) {
+      await store.master?.applyChanges(store.changes);
     }
-    return collection3.applyChange(transaction, change, events);
   }
-  withCommands(commands) {
-    return new ArcContextWithCommands(this.collections, commands);
+}
+// data-storage/store-state-master.ts
+class MasterStoreState extends StoreState {
+  items = new Map;
+  isComplete = false;
+  constructor(storeName, dataStorage, deserialize) {
+    super(storeName, dataStorage, deserialize);
+  }
+  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;
+      }
+    }
+    await transaction.commit();
+    if (events.length > 0) {
+      this.notifyListeners(events);
+    }
+  }
+  async findById(id, listener) {
+    if (listener)
+      this.listeners.add({ 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)
+      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 });
+    if (this.isComplete) {
+      const results2 = Array.from(this.items.values()).filter((item) => {
+        if (!item)
+          return false;
+        const notCorrect = Object.entries(data).some(([key, value]) => item[key] !== value);
+        return !notCorrect;
+      });
+      return results2;
+    }
+    const transaction = await this.dataStorage.getReadTransaction();
+    const dbResults = await transaction.findByIndex(this.storeName, index, data);
+    const results = dbResults.map((item) => {
+      const id = item._id;
+      if (this.items.has(id))
+        return this.items.get(id);
+      const processedItem = this.deserialize ? this.deserialize(item) : item;
+      return processedItem;
+    });
+    return results;
+  }
+  async findAll(listener) {
+    if (listener)
+      this.listeners.add({ callback: listener });
+    if (this.isComplete)
+      return Array.from(this.items.values()).filter((e) => !!e);
+    const transaction = await this.dataStorage.getReadTransaction();
+    const dbResults = await transaction.findAll(this.storeName);
+    const items = dbResults.map((item) => {
+      const id = item._id;
+      if (this.items.has(id))
+        return this.items.get(id);
+      const processedItem = this.deserialize ? this.deserialize(item) : item;
+      this.items.set(processedItem._id, processedItem);
+      return processedItem;
+    });
+    this.isComplete = true;
+    return items;
   }
 }
 
-class ArcContextWithCommands extends ArcContext {
-  commands;
-  constructor(context2, commands) {
-    super(context2);
-    this.commands = commands;
+// data-storage/data-storage-master.ts
+class MasterDataStorage {
+  dbAdapter;
+  arcContext;
+  stores = new Map;
+  rtcAdapter;
+  constructor(dbAdapter, rtcAdapterFactory, arcContext) {
+    this.dbAdapter = dbAdapter;
+    this.arcContext = arcContext;
+    this.rtcAdapter = rtcAdapterFactory(this);
+  }
+  async getReadTransaction() {
+    return (await this.dbAdapter).readTransaction();
+  }
+  async getReadWriteTransaction() {
+    return (await this.dbAdapter).readWriteTransaction();
+  }
+  getStore(storeName) {
+    if (!this.stores.has(storeName)) {
+      const contextElement = this.arcContext.elementsMap[storeName];
+      if (!contextElement)
+        console.log(`Can't find ${storeName} as context element`);
+      this.stores.set(storeName, new MasterStoreState(storeName, this, contextElement && contextElement.deserialize ? (a) => contextElement.deserialize(a) : undefined));
+    }
+    return this.stores.get(storeName);
+  }
+  fork() {
+    return new ForkedDataStorage(this);
   }
 }
 // elements/optional.ts
@@ -666,257 +927,18 @@ class ArcStringEnum extends ArcAbstract {
     return this.values;
   }
 }
-// model/model.ts
-import { Subject as Subject2 } from "rxjs";
-function model(context3, dependencies) {
-  return new ArcModel(context3, dependencies.dbAdapterFactory, dependencies.rtcAdapterFactory);
-}
-
-class ArcModel {
-  context3;
-  rtc;
-  dbAdapterPromise;
-  changes$ = new Subject2;
-  constructor(context3, dbAdapterFactory, rtcAdapterFactory) {
-    this.context = context3;
-    this.rtc = rtcAdapterFactory(this);
-    this.dbAdapterPromise = dbAdapterFactory(this.context);
-  }
-  query(queryFactory) {
-    const queryBuilder = this.context.queryBuilder();
-    const query = queryFactory(queryBuilder).toQuery();
-    this.runQuery(query);
-    return query;
-  }
-  async runQuery(query) {
-    const dbAdapter = await this.dbAdapterPromise;
-    query.run(dbAdapter, this.changes$);
-  }
-  commands() {
-    return new Proxy({}, {
-      get: (target, name) => {
-        if (name in this.context.commands) {
-          return async (...args) => {
-            const { result } = await this.executeCommand(this.context.commands[name], ...args);
-            return result;
-          };
-        }
-        console.warn(`Command '${name}' not found in the context.`);
-        return;
-      }
-    });
-  }
-  async executeCommand(command, ...args) {
-    const dbAdapter = await this.dbAdapterPromise;
-    const transaction = await dbAdapter.readWriteTransaction(this.context.collections);
-    const { context: context3, finalize } = await this.context.commandContext(transaction);
-    const result = await command(context3, ...args);
-    const changes = await finalize();
-    await this.applyChangesForTransaction(transaction, changes);
-    this.rtc.changesExecuted(changes);
-    return { changes, result };
-  }
-  async applyChangesForTransaction(transaction, changes) {
-    const events = [];
-    for (const change of changes) {
-      await this.context.applyChange(transaction, change, events);
-    }
-    await transaction.commit();
-    events.forEach((change) => this.notifyChange(change));
-  }
-  notifyChange(change) {
-    this.changes$.next(change);
-  }
-  async applyChanges(changes) {
-    const dbAdapter = await this.dbAdapterPromise;
-    const transaction = await dbAdapter.readWriteTransaction(this.context.collections);
-    await this.applyChangesForTransaction(transaction, changes);
-  }
-  getCollection(name) {
-    return this.context.collectionsMap[name];
-  }
-}
-// model/submodel.ts
-import { Subject as Subject3 } from "rxjs";
-
-// collection/in-memory-db-proxy.ts
-class InMemoryTransaction {
-  parentTransaction;
-  local;
-  constructor(parentTransaction, local) {
-    this.parentTransaction = parentTransaction;
-    this.local = local;
-  }
-  async set(collection3, data) {
-    let collectionLocal = this.local.get(collection3.name);
-    if (!collectionLocal) {
-      collectionLocal = new Map;
-      this.local.set(collection3.name, collectionLocal);
-    }
-    collectionLocal.set(data._id, data);
-  }
-  async remove(collection3, id3) {
-    let collectionLocal = this.local.get(collection3.name);
-    if (!collectionLocal) {
-      collectionLocal = new Map;
-      this.local.set(collection3.name, collectionLocal);
-    }
-    collectionLocal.set(id3, null);
-  }
-  async findById(collection3, id3) {
-    const localItem = this.local.get(collection3.name)?.get(id3);
-    if (localItem !== undefined) {
-      return localItem === null ? undefined : localItem;
-    }
-    return this.parentTransaction.findById(collection3, id3);
-  }
-  async findByIndex(collection3, index, data) {
-    const parentResults = await this.parentTransaction.findByIndex(collection3, index, data);
-    const localResults = Array.from(this.local.get(collection3.name)?.values() || []).filter((item) => item !== null && this.matchesIndex(item, index, data));
-    return this.mergeResults(parentResults, localResults);
-  }
-  async findAll(collection3) {
-    const parentResults = await this.parentTransaction.findAll(collection3);
-    const localResults = Array.from(this.local.get(collection3.name)?.values() || []).filter((item) => item !== null);
-    return this.mergeResults(parentResults, localResults);
-  }
-  async commit() {
-  }
-  matchesIndex(item, index, data) {
-    return Object.entries(data).every(([key, value]) => item[key] === value);
-  }
-  mergeResults(parentResults, localResults) {
-    const mergedMap = new Map;
-    parentResults.forEach((item) => mergedMap.set(item._id, item));
-    localResults.forEach((item) => mergedMap.set(item._id, item));
-    return Array.from(mergedMap.values());
-  }
-}
-
-class InMemoryDatabaseProxyAdapter {
-  parentAdapter;
-  local = new Map;
-  constructor(parentAdapter) {
-    this.parentAdapter = parentAdapter;
-  }
-  readWriteTransaction(collections) {
-    const parentTransaction = this.parentAdapter.readWriteTransaction(collections);
-    return new InMemoryTransaction(parentTransaction, this.local);
-  }
-  readTransaction(collections) {
-    const parentTransaction = this.parentAdapter.readTransaction(collections);
-    return new InMemoryTransaction(parentTransaction, this.local);
-  }
-  clearLocal() {
-    this.local.clear();
-  }
-}
-
-// model/submodel.ts
-class ArcSubModel {
-  parentModel;
-  changes$ = new Subject3;
-  proxyAdapterPromise;
-  uncommitedChanges = [];
-  constructor(parentModel) {
-    this.parentModel = parentModel;
-    this.parentModel.changes$.subscribe(this.changes$);
-    this.proxyAdapterPromise = this.parentModel.dbAdapterPromise.then((dbAdapter) => new InMemoryDatabaseProxyAdapter(dbAdapter));
-  }
-  query(queryFactory) {
-    const queryBuilder = this.context.queryBuilder();
-    const query = queryFactory(queryBuilder).toQuery();
-    this.runQuery(query);
-    return query;
-  }
-  async runQuery(query) {
-    const proxyAdapter = await this.proxyAdapterPromise;
-    query.run(proxyAdapter, this.changes$);
-  }
-  commands() {
-    return new Proxy({}, {
-      get: (target, name) => {
-        if (name in this.parentModel.context.commands) {
-          return async (...args) => {
-            const { result } = await this.executeCommand(this.parentModel.context.commands[name], ...args);
-            return result;
-          };
-        }
-        console.warn(`Command '${name}' not found in the context.`);
-        return;
-      }
-    });
-  }
-  async executeCommand(command, ...args) {
-    const proxyAdapter = await this.proxyAdapterPromise;
-    const transaction = proxyAdapter.readWriteTransaction(this.parentModel.context.collections);
-    const { context: context3, finalize } = await this.parentModel.context.commandContext(transaction);
-    const result = await command(context3, ...args);
-    const changes = await finalize();
-    const events = [];
-    for (const change of changes) {
-      await this.context.applyChange(transaction, change, events);
-    }
-    this.uncommitedChanges.push(...changes);
-    events.forEach((change) => this.changes$.next(change));
-    return { changes, result };
-  }
-  getCollection(name) {
-    return this.parentModel.getCollection(name);
-  }
-  async applyChanges(changes) {
-    const proxyAdapter = await this.proxyAdapterPromise;
-    const transaction = proxyAdapter.readWriteTransaction(this.parentModel.context.collections);
-    await this.parentModel.applyChangesForTransaction(transaction, changes);
-  }
-  get context() {
-    return this.parentModel.context;
-  }
-  async commitChanges() {
-    this.parentModel.applyChanges(this.uncommitedChanges);
-    this.parentModel.rtc.changesExecuted(this.uncommitedChanges);
-  }
-}
-// 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;
-    }
-  });
-}
-
 // rtc/client.ts
 class RTCClient {
-  model3;
+  storage;
   _socket;
   openSocket;
   reconnectAttempts = 0;
   maxReconnectAttempts = 5;
-  constructor(model3) {
-    this.model = model3;
+  constructor(storage) {
+    this.storage = storage;
     this.connect();
   }
-  connect() {
+  async connect() {
     this._socket = new WebSocket(`wss://${window.location.host}/ws`);
     this.openSocket = new Promise((resolve) => {
       this._socket.addEventListener("open", () => {
@@ -924,6 +946,7 @@ class RTCClient {
         resolve(this._socket);
       });
     });
+    const arcState = await this.storage.getStore("state").findById("$arc", (a) => a);
     this._socket.addEventListener("message", (e) => {
       this.onMessage(JSON.parse(e.data));
     });
@@ -934,7 +957,7 @@ class RTCClient {
     });
     this.sendMessage({
       type: "sync",
-      lastDate: window.localStorage.getItem("lastSync")
+      lastDate: arcState?.lastSyncDate || null
     });
   }
   reconnect() {
@@ -948,7 +971,7 @@ class RTCClient {
       console.error("Max reconnect attempts reached. Giving up.");
     }
   }
-  changesExecuted(changes) {
+  commitChanges(changes) {
     return this.sendMessage({
       type: "changes-executed",
       changes
@@ -958,35 +981,37 @@ class RTCClient {
     switch (message.type) {
       case "sync-result":
         {
-          const { collection: collection3, items } = message;
-          const c = this.model.getCollection(collection3);
-          if (!c) {
-            console.error(`Collection ${collection3} not found`);
+          const { store, items } = message;
+          const storeState = this.storage.getStore(store);
+          if (!storeState) {
+            console.error(`Store ${store} not found`);
             return;
           }
-          const deserializedItems = items.map((item) => {
+          const changes = items.map((item) => {
             if (item.deleted) {
               return {
-                collection: collection3,
                 type: "delete",
                 id: item._id
               };
             }
             return {
-              collection: collection3,
               type: "set",
-              body: item
+              data: item
             };
           });
-          this.model.applyChanges(deserializedItems);
+          storeState.applyChanges(changes);
         }
         break;
       case "sync-done":
-        window.localStorage.setItem("lastSync", message.date);
+        const stateStorage = this.storage.getStore("state");
+        stateStorage.applyChanges([
+          {
+            type: "set",
+            data: { _id: "$arc", lastSyncDate: message.date }
+          }
+        ]);
         break;
-      case "collection-changes":
-        const deserializedChanges = deserializeChanges(message.changes, (name) => this.model.getCollection(name));
-        this.model.applyChanges(deserializedChanges);
+      case "state-changes":
         break;
       default:
         console.warn(`Message unsupported`, message);
@@ -997,16 +1022,42 @@ class RTCClient {
     socket.send(JSON.stringify(message));
   }
 }
-var rtcClientFactory = (model3) => {
-  return new RTCClient(model3);
+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,
   rtcClientFactory,
   object,
   number,
-  model,
   id,
   deserializeChanges,
   date,
@@ -1014,17 +1065,22 @@ export {
   collection,
   boolean,
   array,
-  ArcSubModel,
+  StoreState,
+  MasterStoreState,
+  MasterDataStorage,
+  ForkedStoreState,
+  ForkedDataStorage,
   ArcStringEnum,
   ArcString,
+  ArcQueryBuilder,
   ArcOptional,
   ArcObject,
   ArcNumber,
-  ArcModel,
   ArcIndexedCollection,
   ArcId,
   ArcDate,
   ArcCollectionQuery,
+  ArcCollection,
   ArcBranded,
   ArcBoolean,
   ArcArray