@arcote.tech/arc 0.0.13 → 0.0.14

package/dist/model/model.d.ts

@@ -1,41 +1,40 @@
 import { Subject } from "rxjs";
-import type { ArcCollectionAny, ArcIndexedCollectionAny } from "../collection";
-import type { CollectionChange } from "../collection/collection-change";
-import type { DatabaseAdapter, DBAdapterFactory, ReadWriteTransaction } from "../collection/db";
 import type { CommandsClient } from "../context/commands";
-import { type ArcContextAny, type ArcContextWithCommandsAny } from "../context/context";
+import { type ArcContextChanges, type ArcContextWithCommandsAny } from "../context/context";
+import type { ArcContextElementAny } from "../context/element";
 import type { ArcQuery } from "../context/query";
-import type { QueryFactoryFunction } from "./query-builder";
-import type { RealTimeCommunicationAdapter, RealTimeCommunicationAdapterFactory } from "./rtc";
+import type { QueryFactoryFunction } from "../context/query-builders";
+import type { DatabaseAdapter, DBAdapterFactory, ReadWriteTransaction } from "../db";
+import type { RealTimeCommunicationAdapter, RealTimeCommunicationAdapterFactory } from "../rtc/rtc";
 export interface IArcModel<C extends ArcContextWithCommandsAny> {
     readonly context: C;
-    changes$: Subject<CollectionChange>;
+    changes$: Subject<ArcContextChanges<C>>;
     query(queryFactory: QueryFactoryFunction<C>): ArcQuery;
     commands(): CommandsClient<C["commands"]>;
-    getCollection(name: string): ArcCollectionAny | ArcIndexedCollectionAny;
-    applyChanges(changes: CollectionChange[]): Promise<void>;
+    getContextElement(name: string): ArcContextElementAny;
+    applyChanges(changes: ArcContextChanges<C>[]): Promise<void>;
 }
 export declare class ArcModel<C extends ArcContextWithCommandsAny> implements IArcModel<C> {
     readonly context: C;
-    rtc: RealTimeCommunicationAdapter;
+    rtc: RealTimeCommunicationAdapter<C>;
     dbAdapterPromise: Promise<DatabaseAdapter>;
-    changes$: Subject<CollectionChange>;
-    constructor(context: C, dbAdapterFactory: DBAdapterFactory, rtcAdapterFactory: RealTimeCommunicationAdapterFactory);
-    query(queryFactory: QueryFactoryFunction<C>): ArcQuery;
+    changes$: Subject<ArcContextChanges<C>>;
+    constructor(context: C, dbAdapterFactory: DBAdapterFactory, rtcAdapterFactory: RealTimeCommunicationAdapterFactory<C>);
+    query(queryFactory: QueryFactoryFunction<C>): import("..").ArcQueryAny;
     private runQuery;
     commands(): CommandsClient<C["commands"]>;
     executeCommand(command: C["commands"][string], ...args: any[]): Promise<{
-        changes: CollectionChange[];
+        changes: any;
         result: any;
     }>;
-    applyChangesForTransaction(transaction: ReadWriteTransaction, changes: CollectionChange[]): Promise<void>;
+    applyChangesForTransaction(transaction: ReadWriteTransaction, changes: ArcContextChanges<C>[]): Promise<void>;
     private notifyChange;
-    applyChanges(changes: CollectionChange[]): Promise<void>;
-    getCollection(name: string): ArcCollectionAny | ArcIndexedCollectionAny;
+    applyChanges(changes: ArcContextChanges<C>[]): Promise<void>;
+    getContextElement(name: string): any;
 }
 export type ArcModelAny = ArcModel<ArcContextWithCommandsAny>;
-export type ArcModelDependencies<C extends ArcContextAny> = {
+export type ArcModelDependencies<C extends ArcContextWithCommandsAny> = {
     dbAdapterFactory: DBAdapterFactory;
-    rtcAdapterFactory: RealTimeCommunicationAdapterFactory;
+    rtcAdapterFactory: RealTimeCommunicationAdapterFactory<C>;
 };
 export declare function model<C extends ArcContextWithCommandsAny>(context: C, dependencies: ArcModelDependencies<C>): ArcModel<C>;

package/dist/rtc/client.d.ts

@@ -1,2 +1,3 @@
-import type { RealTimeCommunicationAdapterFactory } from "../model/rtc";
+import type { RealTimeCommunicationAdapterFactory } from "./rtc";
 export declare const rtcClientFactory: RealTimeCommunicationAdapterFactory;
+//# sourceMappingURL=client.d.ts.map

package/dist/rtc/deserializeChanges.d.ts

@@ -1,2 +1,3 @@
 import type { CollectionChange } from "../collection";
 export declare function deserializeChanges(changes: CollectionChange[], getCollection: (name: string) => any): CollectionChange[];
+//# sourceMappingURL=deserializeChanges.d.ts.map

package/dist/rtc/index.d.ts

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

package/dist/rtc/messages.d.ts

@@ -1,19 +1,20 @@
-import type { CollectionChange } from "../collection";
+import type { StoreStateChange } from "../data-storage";
 export type MessageClientToHost = {
     type: "sync";
     lastDate: string | null;
 } | {
     type: "changes-executed";
-    changes: CollectionChange[];
+    changes: StoreStateChange<any>[];
 };
 export type MessageHostToClient = {
     type: "sync-result";
-    collection: string;
+    store: string;
     items: any[];
 } | {
-    type: "collection-changes";
-    changes: CollectionChange[];
+    type: "state-changes";
+    changes: StoreStateChange<any>[];
 } | {
     type: "sync-done";
     date: string;
 };
+//# sourceMappingURL=messages.d.ts.map

package/dist/rtc/rtc.d.ts

@@ -0,0 +1,6 @@
+import type { DataStorage, StoreStateChange } from "../data-storage/data-storage.interface";
+export interface RealTimeCommunicationAdapter {
+    commitChanges(changes: StoreStateChange<any>[]): void;
+}
+export type RealTimeCommunicationAdapterFactory = (storage: DataStorage) => RealTimeCommunicationAdapter;
+//# sourceMappingURL=rtc.d.ts.map

package/dist/state/db.d.ts

@@ -0,0 +1,14 @@
+import type { ReadTransaction, ReadWriteTransaction } from "../db/interface";
+import type { ArcStateAny } from "./state";
+import type { StateItem } from "./util";
+export declare class StateReadTransaction {
+    protected dbTransaction: ReadTransaction;
+    constructor(dbTransaction: ReadTransaction);
+    find<S extends ArcStateAny>(state: S): Promise<StateItem<S> | undefined>;
+}
+export declare class StateReadWriteTransaction extends StateReadTransaction {
+    protected dbTransaction: ReadWriteTransaction;
+    constructor(dbTransaction: ReadWriteTransaction);
+    set<C extends ArcStateAny>(state: C, data: StateItem<C>): Promise<void>;
+    commit(): Promise<void>;
+}

package/dist/state/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./db";
+export * from "./state";
+export * from "./state-change";

package/dist/state/query-builder.d.ts

@@ -0,0 +1,8 @@
+import { ArcQueryBuilder } from "../context/query-builders";
+import { ArcStateQuery } from "./query";
+import type { ArcStateAny } from "./state";
+export declare class ArcStateQueryBuilder<S extends ArcStateAny> extends ArcQueryBuilder {
+    private collection;
+    constructor(collection: S);
+    toQuery(): ArcStateQuery<S>;
+}

package/dist/state/query.d.ts

@@ -0,0 +1,22 @@
+import { Subject } from "rxjs";
+import type { ArcQuery } from "../context/query";
+import type { DatabaseAdapter } from "../db";
+import { StateReadTransaction } from "./db";
+import type { ArcStateAny } from "./state";
+import type { StateChange } from "./state-change";
+import type { StateItem } from "./util";
+export declare class ArcStateQuery<State extends ArcStateAny> implements ArcQuery<StateItem<State>> {
+    protected state: State;
+    result$: Subject<StateItem<State>>;
+    private resultQueue$?;
+    private subscriptions;
+    constructor(state: State);
+    getLastResult(): StateItem<State>;
+    run(db: DatabaseAdapter, changes$: Subject<StateChange>): Promise<void>;
+    protected onChange(change: StateChange): any;
+    protected fetch(transaction: StateReadTransaction): Promise<ReturnType<State["deserialize"]> | undefined>;
+    private changeHandler;
+    unsubscribe(): void;
+    private nextResult;
+    isUnsubscribed(): boolean;
+}

package/dist/state/state-change.d.ts

@@ -0,0 +1,13 @@
+import type { Patches } from "mutative";
+export type StateChange = {
+    state: string;
+} & ({
+    type: "set";
+    body: any;
+} | {
+    type: "mutate";
+    patches: Patches<any>;
+});
+export type StateEvent = Exclude<StateChange, {
+    type: "mutate";
+}>;

package/dist/state/state.d.ts

@@ -0,0 +1,28 @@
+import type { ArcContextElement } from "../context/element";
+import type { ReadTransaction, ReadWriteTransaction } from "../db";
+import { type ArcObjectAny } from "../elements/object";
+import { objectUtil, type util } from "../utils";
+import { ArcStateQueryBuilder } from "./query-builder";
+import type { StateChange, StateEvent } from "./state-change";
+import type { StateItem } from "./util";
+type StateCommandContext<State extends ArcStateAny> = {
+    context: {
+        get: () => StateItem<State>;
+    };
+    finalize: () => StateChange[];
+};
+export declare class ArcState<Name extends string, Schema extends ArcObjectAny> implements ArcContextElement<StateChange, StateEvent> {
+    readonly name: Name;
+    readonly schema: Schema;
+    constructor(name: Name, schema: Schema);
+    serialize(data: objectUtil.simplify<objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): {
+        [x: string]: any;
+    };
+    deserialize(data: objectUtil.simplify<objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): ReturnType<Schema["deserialize"]>;
+    queryBuilder(): ArcStateQueryBuilder<this>;
+    commandContext(transaction: ReadTransaction): StateCommandContext<this>;
+    applyChange(transaction: ReadWriteTransaction, change: StateChange, events: StateChange[]): Promise<void>;
+}
+export type ArcStateAny = ArcState<any, any>;
+export declare function state<Name extends string, Schema extends ArcObjectAny>(name: Name, schema: Schema): ArcState<Name, Schema>;
+export {};

package/dist/state/util.d.ts

@@ -0,0 +1,2 @@
+import type { ArcStateAny } from "./state";
+export type StateItem<S extends ArcStateAny> = ReturnType<S["deserialize"]>;

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import type { ArcCollectionAny, ArcIndexedCollectionAny } from "./collection/collection";
+import type { ArcCollectionAny, ArcIndexedCollectionAny, CollectionItem } from "./collection/collection";
 import type { QueryCollectionResult } from "./collection/queries/abstract-many-items";
 import type { ArcElement } from "./elements/element";
 export declare namespace objectUtil {
@@ -42,21 +42,24 @@ export declare namespace objectUtil {
 export declare namespace util {
     type FirstArgument<T> = T extends (arg: infer U, ...args: any[]) => any ? U : never;
     type GetType<Element extends ArcElement> = ReturnType<Element["deserialize"]>;
-    type CollectionItemWithId<C extends ArcCollectionAny> = ReturnType<C["deserialize"]>;
+    type CollectionItemWithId<C extends ArcCollectionAny | ArcIndexedCollectionAny> = ReturnType<C["deserialize"]>;
 }
 export type ContextTypes<Ctx extends {
-    collections: any;
-}> = Ctx["collections"] extends (ArcCollectionAny | ArcIndexedCollectionAny)[] ? {
-    [Collection in Ctx["collections"][number] as `${Collection["name"]}.bodyWithoutId`]: util.GetType<Collection["schema"]>;
-} & {
-    [Collection in Ctx["collections"][number] as `${Collection["name"]}.setBody`]: objectUtil.addQuestionMarks<util.FirstArgument<Collection["schema"]["parse"]>>;
-} & {
-    [Collection in Ctx["collections"][number] as `${Collection["name"]}.id`]: util.GetType<Collection["id"]>;
-} & {
-    [Collection in Ctx["collections"][number] as `${Collection["name"]}.body`]: util.CollectionItemWithId<Collection>;
-} & {
-    [Collection in Ctx["collections"][number] as `${Collection["name"]}.queryCollectionResult`]: Omit<QueryCollectionResult<Collection>, "result">;
-} : never;
+    elements: any[];
+}> = {
+    [key in keyof Ctx["elements"]]: Ctx["elements"][key] extends ArcCollectionAny | ArcIndexedCollectionAny ? {
+        [Collection in Ctx["elements"][number] as `${Collection["name"]}.bodyWithoutId`]: util.GetType<Collection["schema"]>;
+    } & {
+        [Collection in Ctx["elements"][number] as `${Collection["name"]}.setBody`]: objectUtil.addQuestionMarks<util.FirstArgument<Collection["schema"]["parse"]>>;
+    } & {
+        [Collection in Ctx["elements"][number] as `${Collection["name"]}.id`]: util.GetType<Collection["id"]>;
+    } & {
+        [Collection in Ctx["elements"][number] as `${Collection["name"]}.body`]: CollectionItem<Collection>;
+    } & {
+        [Collection in Ctx["elements"][number] as `${Collection["name"]}.queryCollectionResult`]: Omit<QueryCollectionResult<Collection>, "result">;
+    } : never;
+}[keyof Ctx["elements"]];
 export type infer<E extends {
     deserialize: (...args: any) => any;
 }> = ReturnType<E["deserialize"]>;
+//# sourceMappingURL=utils.d.ts.map

package/package.json

@@ -4,13 +4,13 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "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.",
   "scripts": {
     "build": "bun build --target=node ./index.ts --outfile=dist/index.js --external rxjs --external mutative && bun run build:declaration",
-    "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json",
+    "build:declaration": "tsc --emitDeclarationOnly --project tsconfig.types.json --declarationMap",
     "postbuild": "rimraf tsconfig.types.tsbuildinfo",
     "type-check": "tsc",
     "dev": "nodemon --ignore dist -e ts,tsx --exec 'bun run build'"

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

@@ -1,10 +0,0 @@
-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/elements/instanceOf.d.ts

@@ -1,19 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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/model/index.d.ts

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

package/dist/model/query-builder.d.ts

@@ -1,3 +0,0 @@
-import type { ArcContextAny } from "../context/context";
-import type { ArcQueryBuilder } from "../context/query-builders";
-export type QueryFactoryFunction<C extends ArcContextAny> = (queryBuilder: ReturnType<C["queryBuilder"]>) => ArcQueryBuilder;

package/dist/model/rtc.d.ts

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

package/dist/model/submodel.d.ts

@@ -1,23 +0,0 @@
-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>;
-}