@arcote.tech/arc 0.0.11 → 0.0.12

package/dist/collection/collection.d.ts

@@ -31,7 +31,9 @@ declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema ext
     commandContext(transaction: ReadTransaction, changes: CollectionChange[], getDraft: GetDraft<any>): {
         one: (id: util.GetType<Id>) => Deserialize<Id, Schema>;
         remove: (id: util.GetType<Id>) => Promise<any>;
-        add: (data: objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>) => Promise<any>;
+        add: (data: objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>) => Promise<{
+            id: util.GetType<Id>;
+        }>;
         set: (id: util.GetType<Id>, data: util.FirstArgument<Schema["serialize"]>) => Promise<any>;
     };
     applyChange(transaction: ReadWriteTransaction, change: CollectionChange, events: CollectionChange[]): Promise<void>;

package/dist/collection/db.d.ts

@@ -7,7 +7,7 @@ export interface ReadWriteTransaction extends ReadTransaction {
     commit(): Promise<void>;
 }
 export interface ReadTransaction {
-    findById<C extends ArcCollectionAny>(collection: C, id: util.GetType<C["id"]>): Promise<util.CollectionItemWithId<C>>;
+    findById<C extends ArcCollectionAny>(collection: C, id: util.GetType<C["id"]>): Promise<util.CollectionItemWithId<C> | undefined>;
     findByIndex<C extends ArcIndexedCollectionAny>(collection: C, index: string, data: any): Promise<util.CollectionItemWithId<C>[]>;
     findAll<C extends ArcCollectionAny>(collection: C): Promise<util.CollectionItemWithId<C>[]>;
 }

package/dist/collection/in-memory-db-proxy.d.ts

@@ -0,0 +1,10 @@
+import type { ArcCollectionAny } from "../collection";
+import type { DatabaseAdapter, ReadTransaction, ReadWriteTransaction } from "../collection/db";
+export declare class InMemoryDatabaseProxyAdapter implements DatabaseAdapter {
+    private parentAdapter;
+    private local;
+    constructor(parentAdapter: DatabaseAdapter);
+    readWriteTransaction(collections: ArcCollectionAny[]): ReadWriteTransaction;
+    readTransaction(collections: ArcCollectionAny[]): ReadTransaction;
+    clearLocal(): void;
+}

package/dist/collection/queries/abstract-collection-query.d.ts

@@ -12,7 +12,7 @@ export declare abstract class ArcCollectionQuery<Collection extends ArcCollectio
     getLastResult(): Response;
     run(db: DatabaseAdapter, changes$: Subject<CollectionChange>): Promise<void>;
     protected abstract onChange(change: CollectionChange): Response | false;
-    protected abstract fetch(transaction: ReadTransaction): Promise<Response> | undefined;
+    protected abstract fetch(transaction: ReadTransaction): Promise<Response | undefined> | undefined;
     private changeHandler;
     unsubscribe(): void;
     private nextResult;

package/dist/collection/queries/one-item.d.ts

@@ -7,5 +7,5 @@ export declare class ArcOneItemQuery<Collection extends ArcCollectionAny> extend
     private id;
     constructor(collection: Collection, id: util.GetType<Collection["id"]>);
     protected onChange(change: CollectionChange): any;
-    protected fetch(transaction: ReadTransaction): Promise<ReturnType<Collection["deserialize"]>> | undefined;
+    protected fetch(transaction: ReadTransaction): Promise<ReturnType<Collection["deserialize"]> | undefined> | undefined;
 }

package/dist/index.js

@@ -713,7 +713,7 @@ class ArcModel {
     const result = await command(context3, ...args);
     const changes = await finalize();
     await this.applyChangesForTransaction(transaction, changes);
-    this.rtc.commandExecuted(command.name, changes);
+    this.rtc.changesExecuted(changes);
     return { changes, result };
   }
   async applyChangesForTransaction(transaction, changes) {
@@ -736,6 +736,147 @@ class ArcModel {
     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) => {
@@ -807,10 +948,9 @@ class RTCClient {
       console.error("Max reconnect attempts reached. Giving up.");
     }
   }
-  commandExecuted(command, changes) {
+  changesExecuted(changes) {
     return this.sendMessage({
-      type: "command-executed",
-      command,
+      type: "changes-executed",
       changes
     });
   }
@@ -874,6 +1014,7 @@ export {
   collection,
   boolean,
   array,
+  ArcSubModel,
   ArcStringEnum,
   ArcString,
   ArcOptional,

package/dist/model/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./model";
 export * from "./query-builder";
 export * from "./rtc";
+export * from "./submodel";

package/dist/model/model.d.ts

@@ -1,16 +1,24 @@
 import { Subject } from "rxjs";
 import type { ArcCollectionAny, ArcIndexedCollectionAny } from "../collection";
 import type { CollectionChange } from "../collection/collection-change";
-import type { DBAdapterFactory } from "../collection/db";
+import type { DatabaseAdapter, DBAdapterFactory, ReadWriteTransaction } from "../collection/db";
 import type { CommandsClient } from "../context/commands";
 import { type ArcContextAny, type ArcContextWithCommandsAny } from "../context/context";
 import type { ArcQuery } from "../context/query";
 import type { QueryFactoryFunction } from "./query-builder";
-import type { RealTimeCommunicationAdapterFactory } from "./rtc";
-export declare class ArcModel<C extends ArcContextWithCommandsAny> {
+import type { RealTimeCommunicationAdapter, RealTimeCommunicationAdapterFactory } from "./rtc";
+export interface IArcModel<C extends ArcContextWithCommandsAny> {
     readonly context: C;
-    private rtc;
-    private dbAdapterPromise;
+    changes$: Subject<CollectionChange>;
+    query(queryFactory: QueryFactoryFunction<C>): ArcQuery;
+    commands(): CommandsClient<C["commands"]>;
+    getCollection(name: string): ArcCollectionAny | ArcIndexedCollectionAny;
+    applyChanges(changes: CollectionChange[]): Promise<void>;
+}
+export declare class ArcModel<C extends ArcContextWithCommandsAny> implements IArcModel<C> {
+    readonly context: C;
+    rtc: RealTimeCommunicationAdapter;
+    dbAdapterPromise: Promise<DatabaseAdapter>;
     changes$: Subject<CollectionChange>;
     constructor(context: C, dbAdapterFactory: DBAdapterFactory, rtcAdapterFactory: RealTimeCommunicationAdapterFactory);
     query(queryFactory: QueryFactoryFunction<C>): ArcQuery;
@@ -20,7 +28,7 @@ export declare class ArcModel<C extends ArcContextWithCommandsAny> {
         changes: CollectionChange[];
         result: any;
     }>;
-    private applyChangesForTransaction;
+    applyChangesForTransaction(transaction: ReadWriteTransaction, changes: CollectionChange[]): Promise<void>;
     private notifyChange;
     applyChanges(changes: CollectionChange[]): Promise<void>;
     getCollection(name: string): ArcCollectionAny | ArcIndexedCollectionAny;

package/dist/model/rtc.d.ts

@@ -1,6 +1,6 @@
 import type { CollectionChange } from "../collection/collection-change";
 import type { ArcModelAny } from "./model";
 export interface RealTimeCommunicationAdapter {
-    commandExecuted(command: string, changes: CollectionChange[]): void;
+    changesExecuted(changes: CollectionChange[]): void;
 }
 export type RealTimeCommunicationAdapterFactory = (model: ArcModelAny) => RealTimeCommunicationAdapter;

package/dist/model/submodel.d.ts

@@ -0,0 +1,23 @@
+import { Subject } from "rxjs";
+import type { ArcCollectionAny, ArcIndexedCollectionAny } from "../collection";
+import type { CollectionChange } from "../collection/collection-change";
+import type { CommandsClient } from "../context/commands";
+import type { ArcContextWithCommandsAny } from "../context/context";
+import type { ArcQuery } from "../context/query";
+import { ArcModel, type IArcModel } from "./model";
+import type { QueryFactoryFunction } from "./query-builder";
+export declare class ArcSubModel<C extends ArcContextWithCommandsAny> implements IArcModel<C> {
+    private parentModel;
+    changes$: Subject<CollectionChange>;
+    private proxyAdapterPromise;
+    private uncommitedChanges;
+    constructor(parentModel: ArcModel<C>);
+    query(queryFactory: QueryFactoryFunction<C>): ArcQuery;
+    private runQuery;
+    commands(): CommandsClient<C["commands"]>;
+    private executeCommand;
+    getCollection(name: string): ArcCollectionAny | ArcIndexedCollectionAny;
+    applyChanges(changes: CollectionChange[]): Promise<void>;
+    get context(): C;
+    commitChanges(): Promise<void>;
+}

package/dist/rtc/messages.d.ts

@@ -3,8 +3,7 @@ export type MessageClientToHost = {
     type: "sync";
     lastDate: string | null;
 } | {
-    type: "command-executed";
-    command: string;
+    type: "changes-executed";
     changes: CollectionChange[];
 };
 export type MessageHostToClient = {

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "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.",
@@ -13,7 +13,6 @@
     "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json",
     "postbuild": "rimraf tsconfig.types.tsbuildinfo",
     "type-check": "tsc",
-    "publish": "bun run build && npm publish --access=public",
     "dev": "nodemon --ignore dist -e ts,tsx --exec 'bun run build'"
   },
   "dependencies": {