@arcote.tech/arc 0.0.27 → 0.1.2

package/dist/collection/collection.d.ts

@@ -1,39 +1,18 @@
-import { ArcContextElement } from "../context/element";
+import { ArcContextElementWithStore, type StoreSchema } from "../context/element";
 import { type ArcIdAny } from "../elements/id";
 import { type ArcObjectAny } from "../elements/object";
-import { objectUtil, type DeepPartial, type util } from "../utils";
+import { type $type, type DeepPartial, type objectUtil, type util } from "../utils";
+import type { QueryBuilderContext } from "../context/query-builder-context";
 import type { DataStorage } from "../data-storage";
-import type { IndexQueryArgument } from "../db";
-import { ArcAllItemsQueryBuilder } from "./query-builders/all-items";
-import { ArcIndexedItemsQueryBuilder } from "./query-builders/indexed";
-import { ArcOneItemQueryBuilder } from "./query-builders/one-item";
-export type CollectionItem<C extends ArcCollectionAny | ArcIndexedCollectionAny> = objectUtil.simplify<{
+import type { FindOptions } from "../data-storage/types";
+import { ArcFindQueryBuilder } from "./query-builders/find";
+export type CollectionItem<C extends ArcCollectionAny> = objectUtil.simplify<{
     _id: string;
-} & ReturnType<C["deserialize"]>>;
+} & $type<C>>;
 export type Deserialize<Id extends ArcIdAny, Schema extends ArcObjectAny> = objectUtil.simplify<{
-    _id: ReturnType<Id["deserialize"]>;
-} & ReturnType<Schema["deserialize"]>>;
-type CollectionQueryBuilder<T extends ArcCollection<any, any, any>> = {
-    all: () => ArcAllItemsQueryBuilder<T>;
-    one: (id: util.GetType<T["id"]> | undefined | null) => ArcOneItemQueryBuilder<T>;
-};
-type CollectionCommandContext<Id extends ArcIdAny, Schema extends 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>;
-    edit: (id: util.GetType<Id>, editCallback: (item: Deserialize<Id, Schema>) => Promise<void> | void) => Promise<void>;
-    modify: (id: util.GetType<Id>, data: objectUtil.addQuestionMarks<DeepPartial<util.FirstArgument<Schema["serialize"]>>>) => Promise<any>;
-};
-type IndexValue<Schema extends ArcObjectAny, Indexes extends keyof ReturnType<Schema["deserialize"]>, I extends {
-    [name: string]: Indexes[];
-}, func extends keyof I> = {
-    [Key in I[func][number]]: util.GetType<Schema>[Key];
-};
-export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> extends ArcContextElement<{
+    _id: $type<Id>;
+} & $type<Schema>>;
+export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny> extends ArcContextElementWithStore<{
     type: "delete";
     from: CollectionItem<ArcCollection<Name, Id, Schema>>;
 } | {
@@ -48,12 +27,13 @@ export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Sch
     type: "mutate";
     from: CollectionItem<ArcCollection<Name, Id, Schema>>;
     to: CollectionItem<ArcCollection<Name, Id, Schema>>;
-}> {
+}, Name> {
     readonly name: Name;
     readonly id: Id;
     readonly schema: Schema;
     readonly options: ArcCollectionOptions<Id, Schema>;
     constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>);
+    storeSchema(): StoreSchema;
     serialize(data: objectUtil.simplify<{
         _id: util.FirstArgument<Id["serialize"]>;
     } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["serialize"]>>>): objectUtil.simplify<{
@@ -62,26 +42,26 @@ export declare class ArcCollection<Name extends string, Id extends ArcIdAny, Sch
     deserialize(data: objectUtil.simplify<{
         _id: util.FirstArgument<Id["deserialize"]>;
     } & objectUtil.addQuestionMarks<util.FirstArgument<Schema["deserialize"]>>>): Deserialize<Id, Schema>;
-    queryBuilder(): CollectionQueryBuilder<ArcCollection<Name, Id, Schema>>;
-    commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): 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 {
-    [name: string]: Indexes[];
-}> extends ArcCollection<Name, Id, Schema> {
-    readonly indexes: I;
-    constructor(name: Name, id: Id, schema: Schema, options: ArcCollectionOptions<Id, Schema>, indexes: I);
-    commandContext(dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>): CollectionCommandContext<Id, Schema> & {
-        [func in keyof I]: (args: objectUtil.simplify<IndexQueryArgument<objectUtil.simplify<IndexValue<Schema, Indexes, I, func>>>>) => Deserialize<Id, Schema>[];
+    queryBuilder: (context: QueryBuilderContext) => {
+        find: (options?: FindOptions<CollectionItem<ArcCollection<Name, Id, Schema>>>) => ArcFindQueryBuilder<ArcCollection<Name, Id, Schema>>;
     };
-    queryBuilder(): CollectionQueryBuilder<ArcCollection<Name, Id, Schema>> & {
-        [func in keyof I]: (args: objectUtil.simplify<IndexQueryArgument<objectUtil.simplify<IndexValue<Schema, Indexes, I, func>>>>) => ArcIndexedItemsQueryBuilder<ArcIndexedCollection<Name, Id, Schema, Indexes, I>>;
+    commandContext: (dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>) => {
+        add: (data: $type<Schema>) => Promise<{
+            id: any;
+        }>;
+        remove: (id: $type<Id>) => Promise<{
+            success: boolean;
+        }>;
+        set: (id: $type<Id>, data: $type<Schema>) => Promise<{
+            success: boolean;
+        }>;
+        find: (options: FindOptions<Deserialize<Id, Schema>>) => Promise<Deserialize<Id, Schema>[]>;
+        findOne: (where: FindOptions<Deserialize<Id, Schema>>["where"]) => Promise<Deserialize<Id, Schema> | undefined>;
+        modify: (id: $type<Id>, data: DeepPartial<$type<Schema>>) => Promise<void>;
+        edit: (id: $type<Id>, editCallback: (item: Deserialize<Id, Schema>) => void) => Promise<void>;
     };
 }
 export type ArcCollectionAny = ArcCollection<any, any, any>;
-export type ArcIndexedCollectionAny = ArcIndexedCollection<any, any, any, any, any>;
 type ArcCollectionOptions<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
     sort?: (a: Deserialize<Id, Schema>, b: Deserialize<Id, Schema>) => number;
 };

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

@@ -1,16 +1,14 @@
-import { ArcQuery, type ArcQueryListener } from "../../context/query";
+import { ArcSerializableQuery } from "../../context/serializable-query";
 import type { DataStorage, ListenerEvent, StoreState } from "../../data-storage";
 import type { ArcCollectionAny, CollectionItem } from "../collection";
-export declare abstract class ArcCollectionQuery<Collection extends ArcCollectionAny, Result> extends ArcQuery<Result> {
+export declare abstract class ArcCollectionQuery<Collection extends ArcCollectionAny, Result, Params> extends ArcSerializableQuery<Result, Params> {
     protected collection: Collection;
     protected bindedChangeHandler: (changes: ListenerEvent<CollectionItem<Collection>>[]) => void;
     private store;
-    constructor(collection: Collection);
-    run(dataStorage: DataStorage, listener?: ArcQueryListener<Result>): Promise<Result>;
+    constructor(collection: Collection, params: Params);
+    run(dataStorage: DataStorage): Promise<Result>;
     protected abstract onChange(change: ListenerEvent<CollectionItem<Collection>>): Result | false;
     protected abstract fetch(store: StoreState<CollectionItem<Collection>>): Promise<Result>;
     protected changeHandler(changes: ListenerEvent<CollectionItem<Collection>>[]): void;
-    unsubscribe(): void;
-    private nextResult;
 }
 //# sourceMappingURL=abstract-collection-query.d.ts.map

package/dist/collection/queries/{abstract-many-items.d.ts → find.d.ts}

@@ -1,4 +1,5 @@
-import type { ListenerEvent } from "../../data-storage";
+import type { ListenerEvent, StoreState } from "../../data-storage";
+import type { FindOptions } from "../../data-storage/types";
 import type { util } from "../../utils";
 import type { ArcCollectionAny, CollectionItem } from "../collection";
 import { ArcCollectionQuery } from "./abstract-collection-query";
@@ -17,13 +18,12 @@ export declare class QueryCollectionResult<C extends ArcCollectionAny> {
         _id: string;
     } & ReturnType<C["deserialize"]>)[KeyType]; } : never)[];
 }
-export declare abstract class ArcManyItemsQuery<Collection extends ArcCollectionAny> extends ArcCollectionQuery<Collection, QueryCollectionResult<Collection>> {
-    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);
+export declare class ArcFindQuery<Collection extends ArcCollectionAny> extends ArcCollectionQuery<Collection, QueryCollectionResult<Collection>, FindOptions<CollectionItem<Collection>>> {
+    protected params: FindOptions<CollectionItem<Collection>>;
+    constructor(collection: Collection, params: FindOptions<CollectionItem<Collection>>);
+    protected fetch(store: StoreState<CollectionItem<Collection>>): Promise<QueryCollectionResult<Collection>>;
+    protected checkItem(item: CollectionItem<Collection>): boolean;
     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
+//# sourceMappingURL=find.d.ts.map

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

@@ -1,19 +1,2 @@
-import type { ListenerEvent, StoreState } from "../../data-storage";
-import type { util } from "../../utils";
-import type { ArcCollectionAny, CollectionItem } from "../collection";
-import { ArcCollectionQuery } from "./abstract-collection-query";
-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: ListenerEvent<CollectionItem<Collection>>): false | ({
-        _id: string;
-    } & ReturnType<Collection["deserialize"]> extends infer T ? { [KeyType in keyof T]: ({
-        _id: string;
-    } & ReturnType<Collection["deserialize"]>)[KeyType]; } : never) | null;
-    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>;
-}
+export {};
 //# sourceMappingURL=one-item.d.ts.map

package/dist/collection/query-builders/find-by-id.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=find-by-id.d.ts.map

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

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

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

@@ -0,0 +1,13 @@
+import { QueryBuilderContext } from "../../context/query-builder-context";
+import type { FindOptions } from "../../data-storage/types";
+import { type ArcCollectionAny, type CollectionItem } from "../collection";
+import { ArcFindQuery } from "../queries/find";
+export declare class ArcFindQueryBuilder<C extends ArcCollectionAny> {
+    private collection;
+    protected queryContext: QueryBuilderContext;
+    protected options: FindOptions<CollectionItem<C>>;
+    constructor(collection: C, queryContext: QueryBuilderContext, options: FindOptions<CollectionItem<C>>);
+    toQuery(): ArcFindQuery<ArcCollectionAny>;
+    run(): import("../queries/find").QueryCollectionResult<ArcCollectionAny>;
+}
+//# sourceMappingURL=find.d.ts.map

package/dist/command/command.d.ts

@@ -0,0 +1,29 @@
+import type { ArcCommandContext } from "../context";
+import { ArcContextElement, type ArcContextElementAny } from "../context/element";
+import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements";
+import type { $type } from "../utils";
+export type ArcCommmandHandler<ContextElements extends ArcContextElementAny[], Params extends ArcObjectAny | null, Result extends ArcObjectAny> = (ctx: ArcCommandContext<ContextElements>, params: Params extends ArcObjectAny ? $type<Params> : null) => Promise<$type<Result>> | $type<Result>;
+export declare class ArcCommand<Name extends string, Params extends ArcObjectAny | null, Result extends ArcObjectAny, const Elements extends ArcContextElementAny[]> extends ArcContextElement<{
+    type: "execute";
+    params: Params;
+    result: Result;
+}, Name> {
+    readonly name: Name;
+    private _description?;
+    private _params?;
+    private _result?;
+    private _elements?;
+    private _handler?;
+    constructor(name: Name);
+    use<const E extends ArcContextElementAny[]>(elements: E): ArcCommand<Name, Params, Result, E>;
+    description(description: string): ArcCommand<Name, Params, Result, Elements>;
+    withParams<NewParams extends ArcRawShape>(schema: NewParams | ArcObject<NewParams>): ArcCommand<Name, ArcObject<NewParams>, Result, Elements>;
+    withResult<NewResult extends ArcRawShape>(schema: NewResult): ArcCommand<Name, Params, ArcObject<NewResult>, Elements>;
+    handle(handler: ArcCommmandHandler<Elements, Params, Result> | false): ArcCommand<Name, Params, Result, Elements>;
+    commandClient: (ctx: any) => (Params extends ArcObjectAny ? (params: $type<Params>) => Promise<$type<Result>> : () => Promise<$type<Result>>) & {
+        params: Params;
+    };
+    private clone;
+}
+export declare function command<Name extends string>(name: Name): ArcCommand<Name, null, any, any[]>;
+//# sourceMappingURL=command.d.ts.map

package/dist/command/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./command";
+//# sourceMappingURL=index.d.ts.map

package/dist/context/context.d.ts

@@ -1,25 +1,39 @@
 import type { DataStorage } from "../data-storage";
 import type { objectUtil } from "../utils";
-import type { CommandContext, Commands, CommandsClient } from "./commands";
+import type { CommandContext } from "./commands";
 import type { ArcContextElement, ArcContextElementAny } from "./element";
-declare class ArcContext<const C extends ArcContextElementAny[], const Cmds extends Commands<ArcContext<C, any, any>>, const L extends Listener<ArcContext<C, any, any>>[]> {
-    readonly version: number;
-    readonly elements: C;
-    readonly commands: Cmds;
-    readonly listeners?: L | undefined;
-    elementsMap: {
-        [key: string]: C[number];
+import type { QueryBuilderContext } from "./query-builder-context";
+type Filter<T extends any[], Method extends keyof T[number]> = T extends [
+    infer First,
+    ...infer Rest
+] ? First[Method] extends (...args: any) => any ? [First, ...Filter<Rest, Method>] : Filter<Rest, Method> : [];
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+type ArcContextElementMethodReturnType<Elements extends ArcContextElementAny[], Method extends keyof Elements[number]> = UnionToIntersection<{
+    [Element in Filter<Elements, Method>[number] as number]: {
+        [ElementName in Element["name"]]: Element[Method] extends (...args: any) => any ? ReturnType<Element[Method]> : undefined;
     };
-    constructor(version: number, elements: C, commands: Cmds, listeners?: L | undefined);
-    queryBuilder(): {
-        [Collection in C[number] as Collection["name"]]: ReturnType<Collection["queryBuilder"]>;
-    };
-    commandContext(client: string, dataStorage: DataStorage, publishEvent: (event: any) => Promise<void>): { [ContextElement in C[number] as ContextElement["name"]]: ReturnType<ContextElement["commandContext"]>; } & {
-        $client: any;
-    };
-    commandsClient(client: string, dataStorage: DataStorage, catchErrorCallback: (error: any) => void): CommandsClient<Cmds>;
+}[number]>;
+export type ArcCommandContext<E extends ArcContextElementAny[]> = ArcContextElementMethodReturnType<E, "commandContext"> & {
+    $client: any;
+};
+export type RemoveFalseAndResolvedPromiseFromArray<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends false ? RemoveFalseAndResolvedPromiseFromArray<Rest> : First extends Promise<{
+    default: infer Inner;
+}> ? RemoveFalseAndResolvedPromiseFromArray<[Inner, ...Rest]> : [First, ...RemoveFalseAndResolvedPromiseFromArray<Rest>] : [];
+export declare class ArcContext<const E extends ArcContextElementAny[]> {
+    readonly elements: E;
+    private eventListeners;
+    constructor(elements: E);
+    pipe<const NewElements extends (ArcContextElementAny | false | Promise<{
+        default: ArcContextElementAny;
+    }>)[]>(newElements: NewElements): ArcContext<[
+        ...E,
+        ...RemoveFalseAndResolvedPromiseFromArray<NewElements>
+    ]>;
+    queryBuilder(queryContext: QueryBuilderContext): ArcContextElementMethodReturnType<E, "queryBuilder">;
+    commandContext(client: string, dataStorage: DataStorage): ArcCommandContext<E>;
+    commandsClient(client: string, queryContext: QueryBuilderContext, dataStorage: DataStorage, catchErrorCallback: (error: any) => void): ArcContextElementMethodReturnType<E, "commandClient">;
 }
-export type ArcContextAny = ArcContext<ArcContextElementAny[], Commands<any>, any>;
+export type ArcContextAny = ArcContext<ArcContextElementAny[]>;
 export type ElementEvents<Element extends ArcContextElementAny> = Element extends ArcContextElement<any> ? Element["$event"] : never;
 export type ContextEvents<Context extends ArcContextAny> = {
     [Element in Context["elements"][number] as Element["name"]]: objectUtil.simplify<{
@@ -27,6 +41,8 @@ export type ContextEvents<Context extends ArcContextAny> = {
     } & ElementEvents<Element>>;
 }[Context["elements"][number]["name"]];
 export type Listener<Context extends ArcContextAny> = (event: ContextEvents<Context>, context: CommandContext<Context>) => Promise<void> | void;
-export declare function context<const Elements extends ArcContextElementAny[], Cmds extends Commands<ArcContext<Elements, any, any>>, L extends Listener<ArcContext<Elements, Cmds, any>>[]>(version: number, elements: Elements, commands: Cmds, listeners?: L): ArcContext<Elements, Cmds, L>;
+export declare function context<const Elements extends (ArcContextElementAny | false | Promise<{
+    default: ArcContextElementAny;
+}>)[]>(elementsPromise: Elements): Promise<ArcContext<RemoveFalseAndResolvedPromiseFromArray<Elements>>>;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/context/element.d.ts

@@ -1,10 +1,40 @@
 import type { DataStorage } from "../data-storage";
-export declare abstract class ArcContextElement<const Event> {
+import type { QueryBuilderContext } from "./query-builder-context";
+export type EventListener<Event> = (event: Event, dataStorage: DataStorage) => Promise<void>;
+export type StoreColumn = {
+    name: string;
+    type: string;
+    isOptional?: boolean;
+    default?: any;
+    computed?: string | ((item: any, context: {
+        now: string;
+    }) => any);
+};
+export type StoreRelation = {
+    table: string;
+    type: "one-to-many" | "many-to-many" | "one-to-one";
+    foreignKey: string;
+    throughTable?: string;
+};
+export type StoreTable = {
+    name: string;
+    columns: StoreColumn[];
+    primaryKey: string;
+};
+export type StoreSchema = {
+    tables: StoreTable[];
+    relations?: StoreRelation[];
+};
+export declare abstract class ArcContextElement<const Event, const Name extends string | undefined = undefined> {
     readonly $event: Event;
-    abstract name: string;
-    abstract queryBuilder(): any;
-    abstract commandContext(dataStorage: DataStorage, publishEvent: (event: Event) => Promise<void>): any;
-    abstract deserialize(data: any): any;
+    readonly name?: Name;
+    queryBuilder?(queryContext: QueryBuilderContext): any;
+    commandContext?: (dataStorage: DataStorage, publishEvent: (event: Event) => Promise<void>) => any;
+    commandClient?: (commandContext: any) => (...args: any[]) => any;
+    observer?: () => Record<string, EventListener<Event>>;
 }
-export type ArcContextElementAny = ArcContextElement<any>;
+export declare abstract class ArcContextElementWithStore<const Event, const Name extends string | undefined = undefined> extends ArcContextElement<Event, Name> {
+    abstract storeSchema(): StoreSchema;
+}
+export type ArcContextElementAny = ArcContextElement<any, any>;
 //# sourceMappingURL=element.d.ts.map

package/dist/context/event.d.ts

@@ -0,0 +1,39 @@
+import type { DataStorage } from "../data-storage";
+import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements/object";
+import type { $type } from "../utils";
+import { ArcContextElementWithStore, type StoreSchema } from "./element";
+export type EventMetadata = {
+    occurredAt: string;
+    createdBy?: {
+        id: string;
+        type: string;
+    };
+    source?: string;
+    correlationId?: string;
+    version?: number;
+};
+export declare class ArcEvent<const Name extends string, const PayloadShape extends ArcObjectAny | undefined> extends ArcContextElementWithStore<ArcEventInstance<ArcEvent<Name, PayloadShape>>, Name> {
+    readonly name: Name;
+    readonly payload: PayloadShape;
+    storeSchema: () => StoreSchema;
+    constructor(name: Name, payload: PayloadShape);
+    commandContext: (dataStorage: DataStorage, publishEvent: (event: ArcEventInstance<ArcEvent<Name, PayloadShape>>) => Promise<void>) => {
+        emit: (payload: PayloadShape extends ArcObjectAny ? $type<PayloadShape> : undefined) => Promise<void>;
+    };
+}
+export type ArcEventInstance<Event extends ArcEventAny> = {
+    type: Event["name"];
+    payload: Event["payload"] extends ArcObjectAny ? $type<Event["payload"]> : undefined;
+} & EventMetadata;
+export type ArcEventAny = ArcEvent<any, any>;
+export declare function event<const Name extends string, PayloadShape extends ArcRawShape | undefined>(name: Name, payload?: PayloadShape): ArcEvent<Name, PayloadShape extends ArcRawShape ? ArcObject<PayloadShape, [{
+    name: "type";
+    validator: (value: any) => false | {
+        current: "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function";
+        expected: "object";
+    };
+}, {
+    name: "schema";
+    validator: (value: any) => false | { [key in keyof PayloadShape]: ReturnType<PayloadShape[key]["validate"]>; };
+}]> : undefined>;
+//# sourceMappingURL=event.d.ts.map

package/dist/context/index.d.ts

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

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

@@ -0,0 +1,15 @@
+import type { DataStorage } from "../data-storage/data-storage.abstract";
+import type { ArcQueryAny } from "./query";
+import { QueryCache } from "./query-cache";
+export declare class QueryBuilderContext {
+    private readonly queryCache;
+    private readonly dataStorage;
+    private usedQueries;
+    constructor(queryCache: QueryCache, dataStorage: DataStorage);
+    cacheQuery<T extends ArcQueryAny, Arguments extends any[]>(QueryConstructor: (new (...args: Arguments) => T) & {
+        key: string;
+    }, args: Arguments): T;
+    runQuery<T extends ArcQueryAny>(query: T): T["lastResult"];
+    getUsedQueries(): ArcQueryAny[];
+}
+//# sourceMappingURL=query-builder-context.d.ts.map

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

@@ -1,7 +1,16 @@
 import type { ArcContextAny } from "./context";
 import type { ArcQueryAny } from "./query";
-export declare abstract class ArcQueryBuilder {
+import type { QueryBuilderContext } from "./query-builder-context";
+export type RunQuery<T extends ArcQueryAny> = (query: T) => T["lastResult"];
+export interface IArcQueryBuilder {
+    toQuery(context?: QueryBuilderContext): ArcQueryAny;
+}
+export declare abstract class ArcQueryBuilder implements IArcQueryBuilder {
+    protected queryContext: QueryBuilderContext;
+    constructor(queryContext: QueryBuilderContext);
     abstract toQuery(): ArcQueryAny;
+    run(): ReturnType<this["toQuery"]>["lastResult"];
 }
-export type QueryFactoryFunction<C extends ArcContextAny> = (queryBuilder: ReturnType<C["queryBuilder"]>) => ArcQueryBuilder;
+export type UnaryFunction<T, R> = (input: T) => R;
+export type QueryFactoryFunction<C extends ArcContextAny> = UnaryFunction<ReturnType<C["queryBuilder"]>, IArcQueryBuilder>;
 //# sourceMappingURL=query-builders.d.ts.map

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

@@ -0,0 +1,9 @@
+import type { ArcQueryAny } from "./query";
+export declare class QueryCache {
+    private cache;
+    private getIndexHash;
+    set(index: any[], query: ArcQueryAny): void;
+    get(index: any[]): ArcQueryAny | undefined;
+    debug(): Map<any, any>;
+}
+//# sourceMappingURL=query-cache.d.ts.map

package/dist/context/query.d.ts

@@ -2,9 +2,11 @@ import type { DataStorage } from "../data-storage";
 export type ArcQueryListener<Result> = (result: Result) => void;
 export declare abstract class ArcQuery<Result> {
     lastResult: Result;
-    listener?: ArcQueryListener<Result>;
-    abstract run(store: DataStorage, callback?: ArcQueryListener<Result>): Promise<Result>;
-    abstract unsubscribe(): void;
+    abstract run(dataStorage: DataStorage): Promise<Result>;
+    private listeners;
+    subscribe(listener: ArcQueryListener<Result>): void;
+    unsubscribe(listener: ArcQueryListener<Result>): void;
+    nextResult(result: Result): void;
 }
 export type ArcQueryAny = ArcQuery<any>;
 //# sourceMappingURL=query.d.ts.map

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

@@ -0,0 +1,23 @@
+import { ArcQuery } from "./query";
+import type { QueryBuilderContext } from "./query-builder-context";
+import { type IArcQueryBuilder, type UnaryFunction } from "./query-builders";
+declare class ReactiveQuery<T, R> extends ArcQuery<Awaited<R>> {
+    private readonly queryContext;
+    private readonly queryBuilder;
+    private readonly fn;
+    queries: ArcQuery<any>[];
+    constructor(queryContext: QueryBuilderContext, queryBuilder: T, fn: UnaryFunction<T, R>);
+    run(): Promise<Awaited<R>>;
+    private onChangeHandler;
+    onChange(): Promise<void>;
+    runQuery(): Promise<R>;
+}
+declare class ReactiveQueryBuilder<T, R> implements IArcQueryBuilder {
+    private readonly queryBuilder;
+    private readonly fn;
+    constructor(queryBuilder: T, fn: UnaryFunction<T, R>);
+    toQuery(context: QueryBuilderContext): ReactiveQuery<T, R>;
+}
+export declare function reactive<T, R>(fn: UnaryFunction<T, R>): (context: T) => ReactiveQueryBuilder<T, R>;
+export {};
+//# sourceMappingURL=reactive-query.d.ts.map

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

@@ -0,0 +1,11 @@
+import { ArcQuery } from "./query";
+export declare abstract class ArcSerializableQuery<Result, Params> extends ArcQuery<Result> {
+    protected readonly params: Params;
+    static key: string;
+    constructor(params: Params);
+    serialize(): {
+        key: any;
+        params: Params;
+    };
+}
+//# sourceMappingURL=serializable-query.d.ts.map

package/dist/data-storage/store-state-fork.d.ts

@@ -1,5 +1,6 @@
 import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { StoreState } from "./store-state.abstract";
+import type { FindOptions } from "./types";
 export declare class ForkedStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {
@@ -17,8 +18,6 @@ export declare class ForkedStoreState<Item extends {
         to: Item | null;
     }>;
     applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
-    findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
-    findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
-    findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+    find(options: FindOptions<Item>, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
 }
 //# sourceMappingURL=store-state-fork.d.ts.map

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

@@ -1,11 +1,10 @@
 import type { ReadWriteTransaction } from "../db";
 import type { DataStorage, ListenerEvent, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { StoreState } from "./store-state.abstract";
+import type { FindOptions } from "./types";
 export declare class MasterStoreState<Item extends {
     _id: string;
 }> extends StoreState<Item> {
-    private items;
-    private isComplete;
     constructor(storeName: string, dataStorage: DataStorage, deserialize?: (data: any) => Item);
     applyChangeAndReturnEvent(transaction: ReadWriteTransaction, change: StoreStateChange<Item>): Promise<{
         from: Item | null;
@@ -17,8 +16,6 @@ export declare class MasterStoreState<Item extends {
         to: Item | null;
     }>;
     applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
-    findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
-    findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
-    findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+    find(options: FindOptions<Item>, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
 }
 //# sourceMappingURL=store-state-master.d.ts.map

package/dist/data-storage/store-state.abstract.d.ts

@@ -1,5 +1,6 @@
 import type { DataStorage, ListenerEvent, QueryListener, QueryListenerCallback, StoreStateChange } from "./data-storage.abstract";
 import { ForkedStoreState } from "./store-state-fork";
+import type { FindOptions } from "./types";
 export declare abstract class StoreState<Item extends {
     _id: string;
 }> {
@@ -13,9 +14,7 @@ export declare abstract class StoreState<Item extends {
         to: Item | null;
     }>;
     abstract applyChanges(changes: StoreStateChange<Item>[]): Promise<void>;
-    abstract findById(id: string, listener?: QueryListenerCallback<Item>): Promise<Item | null | undefined>;
-    abstract findAll(listener?: QueryListenerCallback<Item>): Promise<Item[]>;
-    abstract findByIndex(index: string, data: any, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
+    abstract find(options: FindOptions<Item>, listener?: QueryListenerCallback<Item>): Promise<Item[]>;
     fork(): ForkedStoreState<Item>;
     set(item: Item): Promise<void>;
     remove(id: string): Promise<void>;

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

@@ -0,0 +1,28 @@
+export type WhereOperators<T> = {
+    $eq?: T;
+    $ne?: T;
+    $gt?: T;
+    $gte?: T;
+    $lt?: T;
+    $lte?: T;
+    $in?: T[];
+    $nin?: T[];
+    $exists?: boolean;
+};
+export type WhereCondition<T = any> = {
+    [K in keyof T]?: T[K] | WhereOperators<T[K]>;
+};
+export type OrderByCondition = {
+    [key: string]: "asc" | "desc";
+};
+export type FindOptions<T> = {
+    where?: WhereCondition<T>;
+    limit?: number;
+    offset?: number;
+    orderBy?: OrderByCondition;
+};
+export type QueryResult<T> = {
+    items: T[];
+    total: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/db/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./interface";
+export * from "./sqliteAdapter";
 //# sourceMappingURL=index.d.ts.map

package/dist/db/interface.d.ts

@@ -1,22 +1,7 @@
 import type { ArcContextAny } from "../context";
-export type IndexQueryArgument<T> = T | ({
-    $gt?: T;
-    $gte?: T;
-    $lt?: T;
-    $lte?: T;
-} & ({
-    $gt: T;
-} | {
-    $gte: T;
-} | {
-    $lt: T;
-} | {
-    $lte: T;
-}));
+import type { FindOptions } from "../data-storage/types";
 export interface ReadTransaction {
-    findById(store: string, id: any): Promise<any | undefined>;
-    findByIndex(store: string, index: string, data: IndexQueryArgument<any>): Promise<any[]>;
-    findAll(store: string): Promise<any[]>;
+    find(store: string, options: FindOptions<any>): Promise<any[]>;
 }
 export interface ReadWriteTransaction extends ReadTransaction {
     remove(store: string, id: any): Promise<void>;