@arcote.tech/arc 0.0.13 → 0.0.15

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

@@ -15,3 +15,4 @@ export type CollectionChange = {
 export type CollectionChangesWithoutMutate = Exclude<CollectionChange, {
     type: "mutate";
 }>;
+//# sourceMappingURL=collection-change.d.ts.map

package/dist/collection/collection.d.ts

@@ -1,17 +1,34 @@
-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 { objectUtil, type util } from "../utils";
 import type { CollectionChange } from "./collection-change";
-import type { ReadTransaction, ReadWriteTransaction } from "./db";
+import type { DataStorage } from "../data-storage";
+import type { ArcDefault } from "../elements/default";
 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<{
+export type CollectionItem<C extends ArcCollectionAny | ArcIndexedCollectionAny> = objectUtil.simplify<{
+    _id: string;
+} & ReturnType<C["deserialize"]>>;
+export type Deserialize<Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> = objectUtil.simplify<{
     _id: ReturnType<Id["deserialize"]>;
 } & ReturnType<Schema["deserialize"]>>;
-declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> implements ArcContextElement {
+type CollectionQueryBuilder<T extends ArcCollection<any, any, any>> = {
+    all: () => ArcAllItemsQueryBuilder<T>;
+    one: (id: util.GetType<T["id"]> | undefined) => ArcOneItemQueryBuilder<T>;
+};
+type CollectionCommandContext<Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> = {
+    one: (id: util.GetType<Id>) => Deserialize<Id, Schema>;
+    remove: (id: util.GetType<Id>) => Promise<any>;
+    all: () => Deserialize<Id, Schema>[];
+    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>;
+    modify: (id: util.GetType<Id>, data: objectUtil.addQuestionMarks<Partial<util.FirstArgument<Schema["serialize"]>>>) => Promise<any>;
+};
+export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>> implements ArcContextElement<CollectionChange, CollectionChange> {
     readonly name: Name;
     readonly id: Id;
     readonly schema: Schema;
@@ -25,32 +42,23 @@ declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema ext
     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: 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>;
+    queryBuilder(): CollectionQueryBuilder<ArcCollection<Name, Id, Schema>>;
+    commandContext(dataStorage: DataStorage): CollectionCommandContext<Id, Schema>;
     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 {
+export declare class ArcIndexedCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>, Indexes extends keyof ReturnType<Schema["deserialize"]>, const I extends {
     [name: string]: Indexes[];
-}> extends ArcCollection<Name, Id, Schema> implements ArcContextElement {
+}> extends ArcCollection<Name, Id, Schema> {
     readonly 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>>;
-    } & {
+    commandContext(dataStorage: DataStorage): CollectionCommandContext<Id, Schema> & {
+        [func in keyof I]: (args: {
+            [Key in I[func][number]]: util.GetType<Schema>[Key];
+        }) => Deserialize<Id, Schema>[];
+    };
+    queryBuilder(): CollectionQueryBuilder<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>>;
@@ -58,8 +66,9 @@ 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>;
-type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<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 declare function collection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny | ArcDefault<ArcObjectAny>>(name: Name, id: Id, schema: Schema, options?: ArcCollectionOptions<Id, Schema>): ArcCollection<Name, Id, Schema>;
 export {};
+//# sourceMappingURL=collection.d.ts.map

package/dist/collection/db.d.ts

@@ -1,18 +1,17 @@
-import type { ArcContextAny } from "../context";
+import type { ReadTransaction, ReadWriteTransaction } from "../db/interface";
 import type { util } from "../utils";
 import type { ArcCollectionAny, ArcIndexedCollectionAny } from "./collection";
-export interface ReadWriteTransaction extends ReadTransaction {
+export declare class CollectionReadTransaction {
+    protected dbTransaction: ReadTransaction;
+    constructor(dbTransaction: ReadTransaction);
+    findById<C extends ArcCollectionAny>(collection: C, id: util.GetType<C["id"]>): Promise<ReturnType<C["deserialize"]> | undefined>;
+    findByIndex<C extends ArcIndexedCollectionAny>(collection: C, index: string, data: any): Promise<ReturnType<C["deserialize"]>[]>;
+    findAll<C extends ArcCollectionAny>(collection: C): Promise<ReturnType<C["deserialize"]>[]>;
+}
+export declare class CollectionReadWriteTransaction extends CollectionReadTransaction {
+    protected dbTransaction: ReadWriteTransaction;
+    constructor(dbTransaction: ReadWriteTransaction);
     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> | 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>[]>;
-}
-export interface DatabaseAdapter {
-    readWriteTransaction(collections: ArcCollectionAny[]): ReadWriteTransaction;
-    readTransaction(collections: ArcCollectionAny[]): ReadTransaction;
-}
-export type DBAdapterFactory = (context: ArcContextAny) => Promise<DatabaseAdapter>;

package/dist/collection/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./collection";
 export * from "./collection-change";
-export * from "./db";
 export * from "./queries/abstract-collection-query";
 export * from "./queries/util";
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,20 +1,17 @@
-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 {
+import type { DataStorage, ListenerEvent, StoreState } from "../../data-storage";
+import type { ArcCollectionAny, CollectionItem } from "../collection";
+export type CollectionQueryListener<Response> = (result: Response) => void;
+export declare abstract class ArcCollectionQuery<Collection extends ArcCollectionAny, Response> implements ArcQuery<Response> {
     protected collection: Collection;
-    result$: Subject<Response>;
-    private resultQueue$?;
-    private subscriptions;
+    lastResult?: Response;
+    private listener?;
     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> | undefined;
-    private changeHandler;
+    run(dataStorage: DataStorage, listener?: CollectionQueryListener<Response>): Promise<Response>;
+    protected abstract onChange(change: ListenerEvent<CollectionItem<Collection>>): Response | false;
+    protected abstract fetch(store: StoreState<CollectionItem<Collection>>): Promise<Response>;
+    protected changeHandler(changes: ListenerEvent<CollectionItem<Collection>>[]): void;
     unsubscribe(): void;
     private nextResult;
-    isUnsubscribed(): boolean;
 }
+//# sourceMappingURL=abstract-collection-query.d.ts.map

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

@@ -1,20 +1,29 @@
+import type { ListenerEvent } from "../../data-storage";
 import type { util } from "../../utils";
-import type { ArcCollectionAny } from "../collection";
-import type { CollectionChangesWithoutMutate } from "../collection-change";
+import type { ArcCollectionAny, CollectionItem } from "../collection";
 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"]>[];
+    constructor(result: CollectionItem<C>[]);
+    get(id: util.GetType<C["id"]>): ({
+        _id: string;
+    } & ReturnType<C["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
+        _id: string;
+    } & ReturnType<C["deserialize"]>)[KeyType]; } : never) | undefined;
+    map<U>(callbackfn: (value: CollectionItem<C>, index: number, array: CollectionItem<C>[]) => U): U[];
+    toArray(): ({
+        _id: string;
+    } & ReturnType<C["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
+        _id: string;
+    } & ReturnType<C["deserialize"]>)[KeyType]; } : never)[];
 }
 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;
+    protected filterFn?: ((item: CollectionItem<Collection>) => boolean) | undefined;
+    protected sortFn?: ((a: CollectionItem<Collection>, b: CollectionItem<Collection>) => number) | undefined;
+    constructor(collection: Collection, filterFn?: ((item: CollectionItem<Collection>) => boolean) | undefined, sortFn?: ((a: CollectionItem<Collection>, b: CollectionItem<Collection>) => number) | undefined);
+    protected onChange(change: ListenerEvent<CollectionItem<Collection>>): false | QueryCollectionResult<Collection>;
+    protected createResult(result: CollectionItem<Collection>[]): QueryCollectionResult<Collection>;
+    protected createFiltredResult(result: CollectionItem<Collection>[]): QueryCollectionResult<Collection>;
+    protected checkItem(item: CollectionItem<Collection>): boolean;
 }
+//# sourceMappingURL=abstract-many-items.d.ts.map

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

@@ -1,6 +1,7 @@
-import { type ArcCollectionAny } from "../collection";
-import type { ReadTransaction } from "../db";
+import type { StoreState } from "../../data-storage";
+import { type ArcCollectionAny, type CollectionItem } from "../collection";
 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>>;
+    protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<import("./abstract-many-items").QueryCollectionResult<Collection>>;
 }
+//# sourceMappingURL=all-items.d.ts.map

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

@@ -1,13 +1,13 @@
-import type { util } from "../../utils";
-import type { ArcIndexedCollectionAny } from "../collection";
-import type { ReadTransaction } from "../db";
+import type { StoreState } from "../../data-storage";
+import type { ArcIndexedCollectionAny, CollectionItem } from "../collection";
 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>>;
+    protected filterFn?: ((item: CollectionItem<Collection>) => boolean) | undefined;
+    protected sortFn?: ((a: CollectionItem<Collection>, b: CollectionItem<Collection>) => number) | undefined;
+    constructor(collection: Collection, index: string, data: any, filterFn?: ((item: CollectionItem<Collection>) => boolean) | undefined, sortFn?: ((a: CollectionItem<Collection>, b: CollectionItem<Collection>) => number) | undefined);
+    protected checkItem(item: CollectionItem<Collection>): boolean;
+    protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<import("./abstract-many-items").QueryCollectionResult<Collection>>;
 }
+//# sourceMappingURL=indexed.d.ts.map

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

@@ -1,11 +1,19 @@
+import type { ListenerEvent, StoreState } from "../../data-storage";
 import type { util } from "../../utils";
-import type { ArcCollectionAny } from "../collection";
-import type { CollectionChange } from "../collection-change";
-import type { ReadTransaction } from "../db";
+import type { ArcCollectionAny, CollectionItem } from "../collection";
 import { ArcCollectionQuery } from "./abstract-collection-query";
-export declare class ArcOneItemQuery<Collection extends ArcCollectionAny> extends ArcCollectionQuery<Collection, util.CollectionItemWithId<Collection>> {
+export declare class ArcOneItemQuery<Collection extends ArcCollectionAny> extends ArcCollectionQuery<Collection, CollectionItem<Collection> | null | undefined> {
     private id;
     constructor(collection: Collection, id: util.GetType<Collection["id"]>);
-    protected onChange(change: CollectionChange): any;
-    protected fetch(transaction: ReadTransaction): Promise<ReturnType<Collection["deserialize"]> | undefined> | undefined;
+    protected onChange(change: ListenerEvent<CollectionItem<Collection>>): false | ({
+        _id: string;
+    } & ReturnType<Collection["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
+        _id: string;
+    } & ReturnType<Collection["deserialize"]>)[KeyType]; } : never) | undefined;
+    protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<({
+        _id: string;
+    } & ReturnType<Collection["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
+        _id: string;
+    } & ReturnType<Collection["deserialize"]>)[KeyType]; } : never) | null | undefined>;
 }
+//# sourceMappingURL=one-item.d.ts.map

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

@@ -1,6 +1,3 @@
-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;
+import type { ArcContextAny, ArcQuery, QueryFactoryFunction } from "../../context";
+export type QueryBuilderFunctionResult<QB extends QueryFactoryFunction<ArcContextAny>> = ReturnType<ReturnType<QB>["toQuery"]> extends ArcQuery<infer Result> ? Result : never;
+//# sourceMappingURL=util.d.ts.map

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

@@ -1,11 +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"]>;
+import { type ArcCollectionAny, type CollectionItem } from "../collection";
+type SortComparator<C extends ArcCollectionAny> = ((a: CollectionItem<C>, b: CollectionItem<C>) => number) | Array<[keyof CollectionItem<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;
+    protected filterFn?: (item: CollectionItem<C>) => boolean;
+    protected sortFn?: (a: CollectionItem<C>, b: CollectionItem<C>) => number;
+    filter(callback: (item: CollectionItem<C>) => boolean): this;
     sort(comparator: SortComparator<C>): this;
 }
 export {};
+//# sourceMappingURL=abstract-many-items.d.ts.map

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

@@ -6,3 +6,4 @@ export declare class ArcAllItemsQueryBuilder<C extends ArcCollectionAny> extends
     constructor(collection: C);
     toQuery(): ArcAllItemsQuery<C>;
 }
+//# sourceMappingURL=all-items.d.ts.map

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

@@ -8,3 +8,4 @@ export declare class ArcIndexedItemsQueryBuilder<C extends ArcIndexedCollectionA
     constructor(collection: C, index: string, data: any);
     toQuery(): ArcIndexedItemsQuery<C>;
 }
+//# sourceMappingURL=indexed.d.ts.map

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

@@ -8,3 +8,4 @@ export declare class ArcOneItemQueryBuilder<C extends ArcCollectionAny> extends
     constructor(collection: C, id: util.GetType<C["id"]>);
     toQuery(): ArcOneItemQuery<C>;
 }
+//# sourceMappingURL=one-item.d.ts.map

package/dist/context/commands.d.ts

@@ -1,5 +1,6 @@
 import type { ArcContextAny } from "./context";
-type Command<C extends ArcContextAny> = (context: ReturnType<C["commandContext"]>["context"], ...args: any[]) => any;
+export type CommandContext<C extends ArcContextAny> = ReturnType<C["commandContext"]>;
+type Command<C extends ArcContextAny> = (context: CommandContext<C>, ...args: any[]) => any;
 export type Commands<C extends ArcContextAny> = {
     [key: string]: Command<C>;
 };
@@ -8,3 +9,4 @@ export type CommandsClient<Cmds extends Commands<any>> = {
     [Key in keyof Cmds]: CommandProxy<Cmds[Key]>;
 };
 export {};
+//# sourceMappingURL=commands.d.ts.map

package/dist/context/context.d.ts

@@ -1,31 +1,21 @@
-import type { CollectionChange } from "../collection/collection-change";
-import type { ReadTransaction, ReadWriteTransaction } from "../collection/db";
+import type { DataStorage } from "../data-storage";
 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: {
+import type { ArcContextElementAny, ArcContextElementChanges } from "./element";
+declare class ArcContext<const C extends ArcContextElementAny[]> {
+    readonly elements: C;
+    readonly commands: Commands<ArcContext<C>>;
+    readonly version: number;
+    elementsMap: {
         [key: string]: C[number];
     };
-    constructor(collections: C);
+    constructor(elements: C, commands: Commands<ArcContext<C>>, version: number);
     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);
+    commandContext(dataStorage: DataStorage): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; };
 }
-export type ArcContextAny = ArcContext<ArcContextElement[]>;
-export type ArcContextWithCommandsAny = ArcContextWithCommands<any, any>;
-export declare function context<const C extends ArcContextElement[]>(...collections: C): ArcContext<C>;
+export type ArcContextAny = ArcContext<ArcContextElementAny[]>;
+export type ArcContextChanges<C extends ArcContextAny> = ArcContextElementChanges<C["elements"][number]>;
+export declare function context<const Elements extends ArcContextElementAny[], Cmds extends Commands<ArcContext<Elements>>>(elements: Elements, commands: Cmds, version: number): ArcContext<Elements>;
 export {};
+//# sourceMappingURL=context.d.ts.map

package/dist/context/element.d.ts

@@ -1,8 +1,10 @@
-import type { CollectionChange, ReadTransaction, ReadWriteTransaction } from "../collection";
-import type { GetDraft } from "./context";
-export interface ArcContextElement {
+import type { DataStorage } from "../data-storage";
+export interface ArcContextElement<Change, Event> {
     name: string;
     queryBuilder(): any;
-    commandContext(transaction: ReadTransaction, changes: CollectionChange[], getDraft: GetDraft<any>): any;
-    applyChange(transaction: ReadWriteTransaction, change: CollectionChange, events: CollectionChange[]): Promise<void>;
+    commandContext(dataStorage: DataStorage): unknown;
+    deserialize?: (data: any) => any;
 }
+export type ArcContextElementAny = ArcContextElement<any, any>;
+export type ArcContextElementChanges<Element extends ArcContextElementAny> = Element extends ArcContextElement<infer Change, any> ? Change : never;
+//# sourceMappingURL=element.d.ts.map

package/dist/context/index.d.ts

@@ -1 +1,5 @@
+export * from "./commands";
 export * from "./context";
+export * from "./query";
+export * from "./query-builders";
+//# sourceMappingURL=index.d.ts.map

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

@@ -1,4 +1,7 @@
-import type { ArcQuery } from "./query";
+import type { ArcContextAny } from "./context";
+import type { ArcQueryAny } from "./query";
 export declare abstract class ArcQueryBuilder {
-    abstract toQuery(): ArcQuery;
+    abstract toQuery(): ArcQueryAny;
 }
+export type QueryFactoryFunction<C extends ArcContextAny> = (queryBuilder: ReturnType<C["queryBuilder"]>) => ArcQueryBuilder;
+//# sourceMappingURL=query-builders.d.ts.map

package/dist/context/query.d.ts

@@ -1,3 +1,7 @@
-export interface ArcQuery {
-    run(...args: unknown[]): void;
+import type { DataStorage } from "../data-storage";
+export interface ArcQuery<Result> {
+    run(store: DataStorage, callback?: (data: Result) => void): Promise<Result>;
+    unsubscribe(): void;
 }
+export type ArcQueryAny = ArcQuery<any>;
+//# sourceMappingURL=query.d.ts.map

package/dist/data-storage/DataStorage.d.ts

@@ -0,0 +1,11 @@
+import type { ReadTransaction, ReadWriteTransaction } from "../db";
+import type { ForkedDataStorage, StoreState } from "./data-storage";
+export interface DataStorage {
+    getStore<Item extends {
+        _id: string;
+    }>(storeName: string, deserialize?: (data: any) => Item): StoreState<Item>;
+    fork(): ForkedDataStorage;
+    getReadTransaction(): Promise<ReadTransaction>;
+    getReadWriteTransaction(): Promise<ReadWriteTransaction>;
+}
+//# sourceMappingURL=DataStorage.d.ts.map

package/dist/data-storage/ForkStoreState.d.ts

@@ -0,0 +1,32 @@
+import type { QueryListenerCallback, StoreStateChange } from "./data-storage";
+import type { DataStorage } from "./data-storage.interface";
+import type { MasterStoreState } from "./store-state-master";
+import { StoreState } from "./store-state.abstract";
+export declare class ForkStoreState<
+  Item extends {
+    _id: string;
+  },
+> extends StoreState<Item> {
+  master: MasterStoreState<Item>;
+  protected changedItems: Map<string, Item>;
+  changes: StoreStateChange<Item>[];
+  constructor(
+    storeName: string,
+    dataStorage: DataStorage,
+    master: MasterStoreState<Item>,
+    deserialize?: (data: any) => Item
+  );
+  applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
+  findById(
+    id: string,
+    listener?: QueryListenerCallback<Item>
+  ): Promise<Item | undefined>;
+  findByIndex(
+    index: string,
+    data: any,
+    listener?: QueryListenerCallback<Item>
+  ): Promise<Item[]>;
+  findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+  private matchesIndex;
+}
+//# sourceMappingURL=ForkStoreState.d.ts.map

package/dist/data-storage/StoreState.d.ts

@@ -0,0 +1,24 @@
+import { ForkStoreState, QueryListener, QueryListenerCallback, StoreStateChange } from "./data-storage";
+import type { DataStorage } from "./data-storage.interface";
+export declare abstract class StoreState<Item extends {
+    _id: string;
+}> {
+    storeName: string;
+    protected dataStorage: DataStorage;
+    protected deserialize?: ((data: any) => Item) | undefined;
+    protected listeners: Set<QueryListener<Item>>;
+    protected indexQueryCache: Map<string, Item[]>;
+    constructor(storeName: string, dataStorage: DataStorage, deserialize?: ((data: any) => Item) | undefined);
+    abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
+    fork(): ForkStoreState<Item>;
+    findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+    set(item: Item): void;
+    remove(id: string): void;
+    modify(id: string, data: Partial<Item>): void;
+    unsubscribe(listener: QueryListener<Item>): void;
+    private notifyListeners;
+    private getAllLocalItems;
+    private mergeWithLocalModifications;
+    private matchesIndex;
+}
+//# sourceMappingURL=StoreState.d.ts.map

package/dist/data-storage/data-storage-forked.d.ts

@@ -0,0 +1,16 @@
+import type { ReadTransaction, ReadWriteTransaction } from "../db";
+import type { DataStorage } from "./data-storage.interface";
+import { StoreState } from "./store-state.abstract";
+export declare class ForkedDataStorage implements DataStorage {
+    private master;
+    private stores;
+    constructor(master: DataStorage);
+    getReadTransaction(): Promise<ReadTransaction>;
+    getReadWriteTransaction(): Promise<ReadWriteTransaction>;
+    getStore<Item extends {
+        _id: string;
+    }>(storeName: string, deserialize?: (data: any) => Item): StoreState<Item>;
+    fork(): ForkedDataStorage;
+    merge(): Promise<void>;
+}
+//# sourceMappingURL=data-storage-forked.d.ts.map

package/dist/data-storage/data-storage-master.d.ts

@@ -0,0 +1,24 @@
+import type { ArcContextAny } from "../context";
+import type { DatabaseAdapter, ReadTransaction, ReadWriteTransaction } from "../db";
+import type { RealTimeCommunicationAdapterFactory } from "../rtc/rtc";
+import { ForkedDataStorage } from "./data-storage-forked";
+import type { DataStorage } from "./data-storage.interface";
+import type { StoreState } from "./store-state.abstract";
+export declare class MasterDataStorage implements DataStorage {
+    private dbAdapter;
+    private arcContext;
+    private stores;
+    private rtcAdapter;
+    constructor(dbAdapter: Promise<DatabaseAdapter>, rtcAdapterFactory: RealTimeCommunicationAdapterFactory, arcContext: ArcContextAny);
+    getReadTransaction(): Promise<ReadTransaction>;
+    getReadWriteTransaction(): Promise<ReadWriteTransaction>;
+    getStore<Item extends {
+        _id: string;
+    }>(storeName: string): StoreState<Item>;
+    fork(): ForkedDataStorage;
+    sync(progressCallback: ({ store, size }: {
+        store: string;
+        size: number;
+    }) => void): Promise<void>;
+}
+//# sourceMappingURL=data-storage-master.d.ts.map

package/dist/data-storage/data-storage.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data-storage.d.ts.map

package/dist/data-storage/data-storage.interface.d.ts

@@ -0,0 +1,37 @@
+import type { ReadTransaction, ReadWriteTransaction } from "../db";
+import type { ForkedDataStorage } from "./data-storage-forked";
+import type { StoreState } from "./store-state.abstract";
+export interface DataStorage {
+    getStore<Item extends {
+        _id: string;
+    }>(storeName: string, deserialize?: (data: any) => Item): StoreState<Item>;
+    fork(): ForkedDataStorage;
+    getReadTransaction(): Promise<ReadTransaction>;
+    getReadWriteTransaction(): Promise<ReadWriteTransaction>;
+}
+export type StoreStateChange<Item> = {
+    type: "set";
+    data: Item;
+} | {
+    type: "delete";
+    id: string;
+} | {
+    type: "modify";
+    id: string;
+    data: Partial<Item>;
+};
+export type QueryListenerCallback<Item> = (events: ListenerEvent<Item>[]) => void;
+export type QueryListener<Item> = {
+    callback: QueryListenerCallback<Item>;
+    id?: string;
+};
+export type ListenerEvent<Item> = {
+    type: "set";
+    item: Item;
+    id: string;
+} | {
+    type: "delete";
+    item: null;
+    id: string;
+};
+//# sourceMappingURL=data-storage.interface.d.ts.map

package/dist/data-storage/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./data-storage-forked";
+export * from "./data-storage-master";
+export * from "./data-storage.interface";
+export * from "./store-state-fork";
+export * from "./store-state-master";
+export * from "./store-state.abstract";
+//# sourceMappingURL=index.d.ts.map