@arcote.tech/arc 0.0.1 → 0.0.2

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

@@ -0,0 +1,17 @@
+import type { Patches } from "mutative";
+export type CollectionChange = {
+    collection: string;
+} & ({
+    type: "set";
+    body: any;
+} | {
+    type: "delete";
+    id: string;
+} | {
+    type: "mutate";
+    id: string;
+    patches: Patches<any>;
+});
+export type CollectionChangesWithoutMutate = Exclude<CollectionChange, {
+    type: "mutate";
+}>;

package/dist/collection/collection.d.ts

@@ -0,0 +1,59 @@
+import type { GetDraft } from "../context/context";
+import type { ArcContextElement } from "../context/element";
+import type { ArcIdAny } from "../elements/id";
+import { type ArcObjectAny } from "../elements/object";
+import type { objectUtil, util } from "../utils";
+import type { CollectionChange } from "./collection-change";
+import type { ReadTransaction, ReadWriteTransaction } from "./db";
+import { ArcAllItemsQueryBuilder } from "./query-builders/all-items";
+import { ArcIndexedItemsQueryBuilder } from "./query-builders/indexed";
+import { ArcOneItemQueryBuilder } from "./query-builders/one-item";
+export type Deserialize<Id extends ArcIdAny, Schema extends ArcObjectAny> = objectUtil.simplify<{
+    _id: ReturnType<Id["deserialize"]>;
+} & ReturnType<Schema["deserialize"]>>;
+declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> implements ArcContextElement {
+    readonly name: Name;
+    readonly id: Id;
+    readonly schema: Schema;
+    constructor(name: Name, id: Id, schema: Schema);
+    serialize(data: objectUtil.simplify<{
+        _id: util.FirstArgument<Id["serialize"]>;
+    } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): objectUtil.simplify<{
+        _id: ReturnType<Id["serialize"]>;
+    } & ReturnType<Schema["serialize"]>>;
+    deserialize(data: objectUtil.simplify<{
+        _id: util.FirstArgument<Id["deserialize"]>;
+    } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): Deserialize<Id, Schema>;
+    queryBuilder(): {
+        all: () => ArcAllItemsQueryBuilder<ArcCollection<Name, Id, Schema>>;
+        one: (id: util.GetType<Id> | undefined) => ArcOneItemQueryBuilder<ArcCollection<Name, Id, Schema>>;
+    };
+    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: util.FirstArgument<Schema["parse"]>) => Promise<any>;
+        set: (id: util.GetType<Id>, data: util.FirstArgument<Schema["deserialize"]>) => Promise<any>;
+    };
+    applyChange(transaction: ReadWriteTransaction, change: CollectionChange, events: CollectionChange[]): Promise<void>;
+    indexBy<Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {
+        [name: string]: Indexes[];
+    }>(indexes: I): ArcIndexedCollection<Name, Id, Schema, keyof ReturnType<Schema["deserialize"]>, I>;
+}
+export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny, Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {
+    [name: string]: Indexes[];
+}> extends ArcCollection<Name, Id, Schema> implements ArcContextElement {
+    readonly indexes: I;
+    constructor(name: Name, id: Id, schema: Schema, indexes: I);
+    queryBuilder(): {
+        all: () => ArcAllItemsQueryBuilder<ArcCollection<Name, Id, Schema>>;
+        one: (id: util.GetType<Id> | undefined) => ArcOneItemQueryBuilder<ArcCollection<Name, Id, Schema>>;
+    } & {
+        [func in keyof I]: (args: {
+            [Key in I[func][number]]: util.GetType<Schema>[Key];
+        }) => ArcIndexedItemsQueryBuilder<ArcIndexedCollection<Name, Id, Schema, Indexes, I>>;
+    };
+}
+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>;
+export {};

package/dist/collection/db.d.ts

@@ -0,0 +1,18 @@
+import type { ArcContextAny } from "../context";
+import type { util } from "../utils";
+import type { ArcCollectionAny, ArcIndexedCollectionAny } from "./collection";
+export interface ReadWriteTransaction extends ReadTransaction {
+    remove<C extends ArcCollectionAny>(collection: C, id: util.GetType<C["id"]>): Promise<void>;
+    set<C extends ArcCollectionAny>(collection: C, data: util.CollectionItemWithId<C>): Promise<void>;
+    commit(): Promise<void>;
+}
+export interface ReadTransaction {
+    findById<C extends ArcCollectionAny>(collection: C, id: util.GetType<C["id"]>): Promise<util.CollectionItemWithId<C>>;
+    findByIndex<C extends ArcIndexedCollectionAny>(collection: C, index: string, data: any): Promise<util.CollectionItemWithId<C>[]>;
+    findAll<C extends ArcCollectionAny>(collection: C): Promise<util.CollectionItemWithId<C>[]>;
+}
+export interface DatabaseAdapter {
+    readWriteTransaction(collections: ArcCollectionAny[]): ReadWriteTransaction;
+    readTransaction(collections: ArcCollectionAny[]): ReadTransaction;
+}
+export type DBAdapterFactory = (context: ArcContextAny) => Promise<DatabaseAdapter>;

package/dist/collection/index.d.ts

@@ -0,0 +1,5 @@
+export { collection, type ArcCollectionAny, type ArcIndexedCollectionAny, } from "./collection";
+export { type CollectionChange } from "./collection-change";
+export * from "./db";
+export { ArcCollectionQuery } from "./queries/abstract-collection-query";
+export type { GetAnyCollectionQueryResult } from "./queries/util";

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

@@ -0,0 +1,20 @@
+import { Subject } from "rxjs";
+import type { ArcQuery } from "../../context/query";
+import type { ArcCollectionAny } from "../collection";
+import type { CollectionChange } from "../collection-change";
+import type { DatabaseAdapter, ReadTransaction } from "../db";
+export declare abstract class ArcCollectionQuery<Collection extends ArcCollectionAny, Response> implements ArcQuery {
+    protected collection: Collection;
+    result$: Subject<Response>;
+    private resultQueue$?;
+    private subscriptions;
+    constructor(collection: Collection);
+    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;
+    private changeHandler;
+    unsubscribe(): void;
+    private nextResult;
+    isUnsubscribed(): boolean;
+}

package/dist/collection/queries/abstract-many-items.d.ts

@@ -0,0 +1,20 @@
+import type { util } from "../../utils";
+import type { ArcCollectionAny } from "../collection";
+import type { CollectionChangesWithoutMutate } from "../collection-change";
+import { ArcCollectionQuery } from "./abstract-collection-query";
+export declare class QueryCollectionResult<C extends ArcCollectionAny> {
+    private result;
+    constructor(result: util.CollectionItemWithId<C>[]);
+    get(id: util.GetType<C["id"]>): ReturnType<C["deserialize"]> | undefined;
+    map<U>(callbackfn: (value: util.CollectionItemWithId<C>, index: number, array: util.CollectionItemWithId<C>[]) => U): U[];
+    toArray(): ReturnType<C["deserialize"]>[];
+}
+export declare abstract class ArcManyItemsQuery<Collection extends ArcCollectionAny> extends ArcCollectionQuery<Collection, QueryCollectionResult<Collection>> {
+    protected filterFn?: ((item: util.CollectionItemWithId<Collection>) => boolean) | undefined;
+    protected sortFn?: ((a: util.CollectionItemWithId<Collection>, b: util.CollectionItemWithId<Collection>) => number) | undefined;
+    constructor(collection: Collection, filterFn?: ((item: util.CollectionItemWithId<Collection>) => boolean) | undefined, sortFn?: ((a: util.CollectionItemWithId<Collection>, b: util.CollectionItemWithId<Collection>) => number) | undefined);
+    protected onChange(change: CollectionChangesWithoutMutate): false | QueryCollectionResult<Collection>;
+    protected createResult(result: util.CollectionItemWithId<Collection>[]): QueryCollectionResult<Collection>;
+    protected createFiltredResult(result: util.CollectionItemWithId<Collection>[]): QueryCollectionResult<Collection>;
+    protected checkItem(item: util.CollectionItemWithId<Collection>): boolean;
+}

package/dist/collection/queries/all-items.d.ts

@@ -0,0 +1,6 @@
+import { type ArcCollectionAny } from "../collection";
+import type { ReadTransaction } from "../db";
+import { ArcManyItemsQuery } from "./abstract-many-items";
+export declare class ArcAllItemsQuery<Collection extends ArcCollectionAny> extends ArcManyItemsQuery<Collection> {
+    protected fetch(transaction: ReadTransaction): Promise<import("./abstract-many-items").QueryCollectionResult<Collection>>;
+}

package/dist/collection/queries/indexed.d.ts

@@ -0,0 +1,13 @@
+import type { util } from "../../utils";
+import type { ArcIndexedCollectionAny } from "../collection";
+import type { ReadTransaction } from "../db";
+import { ArcManyItemsQuery } from "./abstract-many-items";
+export declare class ArcIndexedItemsQuery<Collection extends ArcIndexedCollectionAny> extends ArcManyItemsQuery<Collection> {
+    private index;
+    private data;
+    protected filterFn?: ((item: util.CollectionItemWithId<Collection>) => boolean) | undefined;
+    protected sortFn?: ((a: util.CollectionItemWithId<Collection>, b: util.CollectionItemWithId<Collection>) => number) | undefined;
+    constructor(collection: Collection, index: string, data: any, filterFn?: ((item: util.CollectionItemWithId<Collection>) => boolean) | undefined, sortFn?: ((a: util.CollectionItemWithId<Collection>, b: util.CollectionItemWithId<Collection>) => number) | undefined);
+    protected checkItem(item: util.CollectionItemWithId<Collection>): boolean;
+    protected fetch(transaction: ReadTransaction): Promise<import("./abstract-many-items").QueryCollectionResult<Collection>>;
+}

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

@@ -0,0 +1,11 @@
+import type { util } from "../../utils";
+import type { ArcCollectionAny } from "../collection";
+import type { CollectionChange } from "../collection-change";
+import type { ReadTransaction } from "../db";
+import { ArcCollectionQuery } from "./abstract-collection-query";
+export declare class ArcOneItemQuery<Collection extends ArcCollectionAny> extends ArcCollectionQuery<Collection, util.CollectionItemWithId<Collection>> {
+    private id;
+    constructor(collection: Collection, id: util.GetType<Collection["id"]>);
+    protected onChange(change: CollectionChange): any;
+    protected fetch(transaction: ReadTransaction): Promise<ReturnType<Collection["deserialize"]>> | undefined;
+}

package/dist/collection/queries/util.d.ts

@@ -0,0 +1,6 @@
+import type { ArcContextAny } from "../../context";
+import type { QueryFactoryFunction } from "../../model";
+import type { objectUtil } from "../../utils";
+import type { ArcCollectionAny, ArcIndexedCollectionAny } from "../collection";
+import type { ArcCollectionQuery } from "./abstract-collection-query";
+export type GetAnyCollectionQueryResult<QB extends QueryFactoryFunction<ArcContextAny>> = ReturnType<ReturnType<QB>["toQuery"]> extends ArcCollectionQuery<ArcCollectionAny | ArcIndexedCollectionAny, any> ? objectUtil.simplify<ReturnType<ReturnType<ReturnType<QB>["toQuery"]>["getLastResult"]>> : never;

package/dist/collection/query-builders/abstract-many-items.d.ts

@@ -0,0 +1,9 @@
+import { ArcQueryBuilder } from "../../context/query-builders";
+import type { util } from "../../utils";
+import { type ArcCollectionAny } from "../collection";
+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;
+}

package/dist/collection/query-builders/all-items.d.ts

@@ -0,0 +1,8 @@
+import { type ArcCollectionAny } from "../collection";
+import { ArcAllItemsQuery } from "../queries/all-items";
+import { ArcManyItemsQueryBuilder } from "./abstract-many-items";
+export declare class ArcAllItemsQueryBuilder<C extends ArcCollectionAny> extends ArcManyItemsQueryBuilder<C> {
+    private collection;
+    constructor(collection: C);
+    toQuery(): ArcAllItemsQuery<C>;
+}

package/dist/collection/query-builders/indexed.d.ts

@@ -0,0 +1,10 @@
+import type { ArcIndexedCollectionAny } from "../collection";
+import { ArcIndexedItemsQuery } from "../queries/indexed";
+import { ArcManyItemsQueryBuilder } from "./abstract-many-items";
+export declare class ArcIndexedItemsQueryBuilder<C extends ArcIndexedCollectionAny> extends ArcManyItemsQueryBuilder<C> {
+    private collection;
+    private index;
+    private data;
+    constructor(collection: C, index: string, data: any);
+    toQuery(): ArcIndexedItemsQuery<C>;
+}

package/dist/collection/query-builders/one-item.d.ts

@@ -0,0 +1,10 @@
+import { ArcQueryBuilder } from "../../context/query-builders";
+import type { util } from "../../utils";
+import type { ArcCollectionAny } from "../collection";
+import { ArcOneItemQuery } from "../queries/one-item";
+export declare class ArcOneItemQueryBuilder<C extends ArcCollectionAny> extends ArcQueryBuilder {
+    private collection;
+    private id;
+    constructor(collection: C, id: util.GetType<C["id"]>);
+    toQuery(): ArcOneItemQuery<C>;
+}

package/dist/context/commands.d.ts

@@ -0,0 +1,10 @@
+import type { ArcContextAny } from "./context";
+type Command<C extends ArcContextAny> = (context: ReturnType<C["commandContext"]>["context"], ...args: any[]) => any;
+export type Commands<C extends ArcContextAny> = {
+    [key: string]: Command<C>;
+};
+export type CommandProxy<F> = F extends (ctx: any, ...args: infer args) => infer ret ? (...args: args) => ret : never;
+export type CommandsClient<Cmds extends Commands<any>> = {
+    [Key in keyof Cmds]: CommandProxy<Cmds[Key]>;
+};
+export {};

package/dist/context/context.d.ts

@@ -0,0 +1,31 @@
+import type { CollectionChange } from "../collection/collection-change";
+import type { ReadTransaction, ReadWriteTransaction } from "../collection/db";
+import type { Commands } from "./commands";
+import type { ArcContextElement } from "./element";
+export type GetDraft<T> = (collection: string, base: T) => T;
+declare class ArcContext<const C extends ArcContextElement[]> {
+    readonly collections: C;
+    collectionsMap: {
+        [key: string]: C[number];
+    };
+    constructor(collections: C);
+    queryBuilder(): {
+        [Collection in C[number] as Collection["name"]]: ReturnType<Collection["queryBuilder"]>;
+    };
+    commandContext(transaction: ReadTransaction): {
+        context: {
+            [Collection in C[number] as Collection["name"]]: ReturnType<Collection["commandContext"]>;
+        };
+        finalize: () => CollectionChange[];
+    };
+    applyChange(transaction: ReadWriteTransaction, change: CollectionChange, events: CollectionChange[]): Promise<void>;
+    withCommands<Cmds extends Commands<this>>(commands: Cmds): ArcContextWithCommands<C, Cmds>;
+}
+declare class ArcContextWithCommands<const C extends ArcContextElement[], Cmds extends Commands<ArcContext<C>>> extends ArcContext<C> {
+    readonly commands: Cmds;
+    constructor(context: C, commands: Cmds);
+}
+export type ArcContextAny = ArcContext<ArcContextElement[]>;
+export type ArcContextWithCommandsAny = ArcContextWithCommands<ArcContextElement[], any>;
+export declare function context<const C extends ArcContextElement[]>(...collections: C): ArcContext<C>;
+export {};

package/dist/context/element.d.ts

@@ -0,0 +1,8 @@
+import type { CollectionChange, ReadTransaction, ReadWriteTransaction } from "../collection";
+import type { GetDraft } from "./context";
+export interface ArcContextElement {
+    name: string;
+    queryBuilder(): any;
+    commandContext(transaction: ReadTransaction, changes: CollectionChange[], getDraft: GetDraft<any>): any;
+    applyChange(transaction: ReadWriteTransaction, change: CollectionChange, events: CollectionChange[]): Promise<void>;
+}

package/dist/context/index.d.ts

@@ -0,0 +1 @@
+export { context, type ArcContextAny } from "./context";

package/dist/context/query-builders.d.ts

@@ -0,0 +1,4 @@
+import type { ArcQuery } from "./query";
+export declare abstract class ArcQueryBuilder {
+    abstract toQuery(): ArcQuery;
+}

package/dist/context/query.d.ts

@@ -0,0 +1,3 @@
+export interface ArcQuery {
+    run(...args: unknown[]): void;
+}

package/dist/elements/abstract-primitive.d.ts

@@ -0,0 +1,7 @@
+import { ArcAbstract } from "./abstract";
+export declare abstract class ArcPrimitive<T> extends ArcAbstract {
+    constructor();
+    serialize(value: T): T;
+    parse(value: T): T;
+    deserialize(value: T): T;
+}

package/dist/elements/abstract.d.ts

@@ -0,0 +1,12 @@
+import { ArcBranded } from "./branded";
+import { ArcDefault } from "./default";
+import type { ArcElement } from "./element";
+import { ArcOptional } from "./optional";
+export declare abstract class ArcAbstract implements ArcElement {
+    abstract serialize(value: any): any;
+    abstract deserialize(value: any): any;
+    abstract parse(value: any): any;
+    default(defaultValueOrCallback: (() => ReturnType<this["deserialize"]>) | ReturnType<this["deserialize"]>): ArcDefault<this>;
+    optional(): ArcOptional<this>;
+    branded<Brand extends string | symbol>(name: Brand): ArcBranded<this, Brand>;
+}

package/dist/elements/array.d.ts

@@ -0,0 +1,12 @@
+import { type util } from "../utils";
+import { ArcAbstract } from "./abstract";
+export declare class ArcArray<E extends ArcAbstract> extends ArcAbstract {
+    private parent;
+    constructor(parent: E);
+    parse(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["parse"]>[];
+    serialize(value: util.FirstArgument<E["serialize"]>[]): ReturnType<E["serialize"]>[];
+    deserialize(value: util.FirstArgument<E["deserialize"]>[]): ReturnType<E["deserialize"]>[];
+    deserializePath(path: string[], value: any): any;
+}
+export type ArcArrayAny = ArcArray<any>;
+export declare function array<E extends ArcAbstract>(element: E): ArcArray<E>;

package/dist/elements/boolean.d.ts

@@ -0,0 +1,4 @@
+import { ArcPrimitive } from "./abstract-primitive";
+export declare class ArcBoolean extends ArcPrimitive<boolean> {
+}
+export declare function boolean(): ArcBoolean;

package/dist/elements/branded.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 ArcBranded<E extends ArcAbstract, Brand extends string | symbol> implements ArcElement {
+    private parent;
+    private brand;
+    constructor(parent: E, brand: Brand);
+    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 ArcBrandedAny = ArcBranded<ArcAbstract, any>;

package/dist/elements/date.d.ts

@@ -0,0 +1,8 @@
+import { ArcAbstract } from "./abstract";
+export declare class ArcDate extends ArcAbstract {
+    constructor();
+    parse(value: string | number | Date): Date;
+    serialize(value: Date): string;
+    deserialize(value: string): Date;
+}
+export declare function date(): ArcDate;

package/dist/elements/default.d.ts

@@ -0,0 +1,10 @@
+import { type util } from "../utils";
+import type { ArcElement } from "./element";
+export declare class ArcDefault<E extends ArcElement> implements ArcElement {
+    private parent;
+    private defaultValueOrCallback;
+    constructor(parent: E, defaultValueOrCallback: (() => ReturnType<E["deserialize"]>) | ReturnType<E["deserialize"]>);
+    parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]>;
+    serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
+    deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;
+}

package/dist/elements/element.d.ts

@@ -0,0 +1,5 @@
+export interface ArcElement {
+    serialize(value: unknown): unknown;
+    deserialize(value: unknown): unknown;
+    parse(value: unknown): unknown;
+}

package/dist/elements/id.d.ts

@@ -0,0 +1,9 @@
+import type { util } from "../utils";
+import { ArcBranded } from "./branded";
+import { ArcString } from "./string";
+export declare class ArcId<Brand extends string | symbol> extends ArcBranded<ArcString, Brand> {
+    constructor(name: Brand);
+    generate(): util.GetType<this>;
+}
+export type ArcIdAny = ArcId<any>;
+export declare function id<Brand extends string | symbol>(name: Brand): ArcId<Brand>;

package/dist/elements/index.d.ts

@@ -0,0 +1,9 @@
+export { array, type ArcArrayAny } from "./array";
+export { type ArcBrandedAny } from "./branded";
+export { ArcDate, date } from "./date";
+export { id } from "./id";
+export { ArcNumber, number } from "./number";
+export { object, type ArcObjectAny } from "./object";
+export { type ArcOptionalAny } from "./optional";
+export { ArcString, string } from "./string";
+export { stringEnum, type ArcStringEnumAny } from "./string-enum";

package/dist/elements/number.d.ts

@@ -0,0 +1,4 @@
+import { ArcPrimitive } from "./abstract-primitive";
+export declare class ArcNumber extends ArcPrimitive<number> {
+}
+export declare function number(): ArcNumber;

package/dist/elements/object.d.ts

@@ -0,0 +1,28 @@
+import { objectUtil, type util } from "../utils";
+import { ArcAbstract } from "./abstract";
+import type { ArcElement } from "./element";
+export declare type ArcRawShape = {
+    [k: string]: ArcElement;
+};
+export declare class ArcObject<E extends ArcRawShape> extends ArcAbstract {
+    private rawShape;
+    constructor(rawShape: E);
+    parse(value: {
+        [key in keyof E]: util.FirstArgument<E[key]["parse"]>;
+    }): {
+        [key in keyof E]: ReturnType<E[key]["parse"]>;
+    };
+    serialize(value: {
+        [key in keyof E]: util.FirstArgument<E[key]["serialize"]>;
+    }): {
+        [key in keyof E]: ReturnType<E[key]["serialize"]>;
+    };
+    deserialize(value: objectUtil.addQuestionMarks<{
+        [key in keyof E]: util.FirstArgument<E[key]["deserialize"]>;
+    }>): {
+        [key in keyof E]: ReturnType<E[key]["deserialize"]>;
+    };
+    deserializePath(path: string[], value: any): any;
+}
+export type ArcObjectAny = ArcObject<any>;
+export declare function object<E extends ArcRawShape>(element: E): ArcObject<E>;

package/dist/elements/optional.d.ts

@@ -0,0 +1,11 @@
+import { type util } from "../utils";
+import { ArcAbstract } from "./abstract";
+import type { ArcElement } from "./element";
+export declare class ArcOptional<E extends ArcElement> implements ArcElement {
+    private parent;
+    constructor(parent: E);
+    parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]> | undefined;
+    serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]> | undefined;
+    deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]> | undefined;
+}
+export type ArcOptionalAny = ArcOptional<ArcAbstract>;

package/dist/elements/string-enum.d.ts

@@ -0,0 +1,11 @@
+import { ArcAbstract } from "./abstract";
+export declare class ArcStringEnum<const T extends string[]> extends ArcAbstract {
+    private values;
+    constructor(values: T);
+    parse<Value extends T[number]>(value: Value): Value;
+    serialize<Value extends T[number]>(value: Value): Value;
+    deserialize<Value extends T[number]>(value: Value): Value;
+    getEnumerators(): T;
+}
+export type ArcStringEnumAny = ArcStringEnum<any>;
+export declare function stringEnum<const T extends string[]>(...values: T): ArcStringEnum<T>;

package/dist/elements/string.d.ts

@@ -0,0 +1,4 @@
+import { ArcPrimitive } from "./abstract-primitive";
+export declare class ArcString extends ArcPrimitive<string> {
+}
+export declare function string(): ArcString;

package/dist/model/index.d.ts

@@ -0,0 +1,3 @@
+export { ArcModel, model, type ArcModelDependencies } from "./model";
+export { type QueryFactoryFunction } from "./query-builder";
+export { type RealTimeCommunicationAdapter, type RealTimeCommunicationAdapterFactory, } from "./rtc";

package/dist/model/model.d.ts

@@ -0,0 +1,33 @@
+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 { 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> {
+    private context;
+    private rtc;
+    private dbAdapterPromise;
+    changes$: Subject<CollectionChange>;
+    constructor(context: C, dbAdapterFactory: DBAdapterFactory, rtcAdapterFactory: RealTimeCommunicationAdapterFactory);
+    query(queryFactory: QueryFactoryFunction<C>): ArcQuery;
+    private runQuery;
+    commands(): CommandsClient<C["commands"]>;
+    executeCommand(command: C["commands"][string], ...args: any[]): Promise<{
+        changes: CollectionChange[];
+        result: any;
+    }>;
+    private applyChangesForTransaction;
+    private notifyChange;
+    applyChanges(changes: CollectionChange[]): Promise<void>;
+    getCollection(name: string): ArcCollectionAny | ArcIndexedCollectionAny;
+}
+export type ArcModelAny = ArcModel<ArcContextWithCommandsAny>;
+export type ArcModelDependencies<C extends ArcContextAny> = {
+    dbAdapterFactory: DBAdapterFactory;
+    rtcAdapterFactory: RealTimeCommunicationAdapterFactory;
+};
+export declare function model<C extends ArcContextWithCommandsAny>(context: C, dependencies: ArcModelDependencies<C>): ArcModel<C>;

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

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

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

package/dist/rtc/client.d.ts

@@ -0,0 +1,2 @@
+import type { RealTimeCommunicationAdapterFactory } from "../model/rtc";
+export declare const rtcClientFactory: RealTimeCommunicationAdapterFactory;

package/dist/rtc/deserializeChanges.d.ts

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

package/dist/rtc/index.d.ts

@@ -0,0 +1,3 @@
+export { rtcClientFactory } from "./client";
+export { deserializeChanges } from "./deserializeChanges";
+export type { MessageClientToHost, MessageHostToClient } from "./messages";

package/dist/rtc/messages.d.ts

@@ -0,0 +1,20 @@
+import type { CollectionChange } from "../collection";
+export type MessageClientToHost = {
+    type: "sync";
+    lastDate: string | null;
+} | {
+    type: "command-executed";
+    command: string;
+    changes: CollectionChange[];
+};
+export type MessageHostToClient = {
+    type: "sync-result";
+    collection: string;
+    items: any[];
+} | {
+    type: "collection-changes";
+    changes: CollectionChange[];
+} | {
+    type: "sync-done";
+    date: string;
+};

package/package.json

@@ -4,7 +4,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "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.",
@@ -28,7 +28,7 @@
     "typescript": "^5.0.0"
   },
   "files": [
-    "dist/*.js",
-    "dist/*.d.ts"
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
   ]
 }