@arcote.tech/arc 0.0.11 → 0.0.13

package/dist/collection/collection.d.ts

@@ -15,7 +15,8 @@ declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema ext
     readonly name: Name;
     readonly id: Id;
     readonly schema: Schema;
-    constructor(name: Name, id: Id, schema: Schema);
+    readonly options: ArcCollectionOptions<Id, Schema>;
+    constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>);
     serialize(data: objectUtil.simplify<{
         _id: util.FirstArgument<Id["serialize"]>;
     } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): objectUtil.simplify<{
@@ -31,7 +32,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>;
@@ -43,7 +46,7 @@ export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdA
     [name: string]: Indexes[];
 }> extends ArcCollection<Name, Id, Schema> implements ArcContextElement {
     readonly indexes: I;
-    constructor(name: Name, id: Id, schema: Schema, indexes: I);
+    constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>, indexes: I);
     queryBuilder(): {
         all: () => ArcAllItemsQueryBuilder<ArcCollection<Name, Id, Schema>>;
         one: (id: util.GetType<Id> | undefined) => ArcOneItemQueryBuilder<ArcCollection<Name, Id, Schema>>;
@@ -55,5 +58,8 @@ export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdA
 }
 export type ArcCollectionAny = ArcCollection<any, any, any>;
 export type ArcIndexedCollectionAny = ArcIndexedCollection<any, any, any, any, any>;
-export declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema): ArcCollection<Name, Id, Schema>;
+type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    sort?: (a: Deserialize<Id, Schema>, b: Deserialize<Id, Schema>) => number;
+};
+export declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema, options?: ArcCollectionOptions<Id, Schema>): ArcCollection<Name, Id, Schema>;
 export {};

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/collection/query-builders/abstract-many-items.d.ts

@@ -1,9 +1,11 @@
 import { ArcQueryBuilder } from "../../context/query-builders";
 import type { util } from "../../utils";
 import { type ArcCollectionAny } from "../collection";
+type SortComparator<C extends ArcCollectionAny> = ((a: util.CollectionItemWithId<C>, b: util.CollectionItemWithId<C>) => number) | Array<[keyof util.CollectionItemWithId<C>, "ASC" | "DESC"]>;
 export declare abstract class ArcManyItemsQueryBuilder<C extends ArcCollectionAny> extends ArcQueryBuilder {
     protected filterFn?: (item: util.CollectionItemWithId<C>) => boolean;
     protected sortFn?: (a: util.CollectionItemWithId<C>, b: util.CollectionItemWithId<C>) => number;
     filter(callback: (item: util.CollectionItemWithId<C>) => boolean): this;
-    sort(callback: (a: util.CollectionItemWithId<C>, b: util.CollectionItemWithId<C>) => number): this;
+    sort(comparator: SortComparator<C>): this;
 }
+export {};

package/dist/elements/instanceOf.d.ts

@@ -0,0 +1,19 @@
+import type { ArcElement } from "./element";
+import type { ArcRawShape } from "./object";
+import { ArcOptional } from "./optional";
+export declare function ArcClass<E extends ArcRawShape>(shape: E): {
+    new (): { [key in keyof E]: ReturnType<E[key]["deserialize"]>; };
+};
+export declare class ArcInstanceOf<E> implements ArcElement {
+    private Class;
+    constructor(Class: {
+        new (): E;
+    });
+    serialize(value: unknown): unknown;
+    deserialize(value: unknown): E;
+    parse(value: unknown): unknown;
+    optional(): ArcOptional<this>;
+}
+export declare function instanceOf<E>(element: {
+    new (): E;
+}): ArcInstanceOf<E>;

package/dist/elements/or.d.ts

@@ -0,0 +1,11 @@
+import type { util } from "../utils";
+import type { ArcElement } from "./element";
+export declare class ArcOr<T extends ArcElement[]> implements ArcElement {
+    private elements;
+    constructor(elements: T);
+    serialize(value: util.FirstArgument<T[number]["serialize"]>): ReturnType<T[number]["serialize"]>;
+    deserialize(value: util.FirstArgument<T[number]["deserialize"]>): ReturnType<T[number]["deserialize"]>;
+    parse(value: util.FirstArgument<T[number]["parse"]>): ReturnType<T[number]["parse"]>;
+    private isTypeOf;
+}
+export declare function or<T extends ArcElement[]>(...elements: T): ArcOr<T>;

package/dist/elements/recurent.d.ts

@@ -0,0 +1,20 @@
+import { type util } from "../utils";
+import { ArcAbstract } from "./abstract";
+import type { ArcElement } from "./element";
+import { ArcOptional } from "./optional";
+export declare class ArcRecurent<E extends ArcElement, Brand extends string | symbol> implements ArcElement {
+    private parent;
+    constructor(parent: E);
+    serialize(value: util.FirstArgument<E["serialize"]> & {
+        __brand: Brand;
+    }): ReturnType<E["serialize"]>;
+    deserialize(value: util.FirstArgument<E["deserialize"]>): ReturnType<E["deserialize"]> & {
+        __brand: Brand;
+    };
+    parse(value: util.FirstArgument<E["parse"]>): ReturnType<E["parse"]> & {
+        __brand: Brand;
+    };
+    optional(): ArcOptional<this>;
+}
+export type ArcRecurentAny = ArcRecurent<ArcAbstract, any>;
+export declare function recurent<E extends () => ArcElement>(element: E): ArcRecurent<ArcElement, string | symbol>;

package/dist/index.js

@@ -114,6 +114,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 +138,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 +150,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);
@@ -175,6 +194,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);
@@ -217,18 +238,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 {
@@ -304,14 +327,14 @@ class ArcCollection {
     }
   }
   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;
   }
   queryBuilder() {
@@ -713,7 +736,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 +759,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 +971,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 +1037,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.13",
   "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": {