@arcote.tech/arc 0.1.2 → 0.1.4

package/dist/listener/index.d.ts

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

package/dist/listener/listener.d.ts

@@ -0,0 +1,23 @@
+import { type ArcCommandContext, type AuthContext } from "../context";
+import { ArcContextElement, type ArcContextElementAny, type ListenerConfig } from "../context/element";
+type GetEvents<Elements extends ArcContextElementAny[]> = Elements[number]["$event"];
+export type ArcListenerHandler<ContextElements extends ArcContextElementAny[], EventElements extends ArcContextElementAny[]> = (ctx: ArcCommandContext<ContextElements>, event: GetEvents<EventElements>) => Promise<void> | void;
+export declare class ArcListener<Name extends string, const Elements extends ArcContextElementAny[], EventElements extends ArcContextElementAny[] = ArcContextElementAny[]> extends ArcContextElement<null, Name> {
+    readonly name: Name;
+    private _description?;
+    private _elements?;
+    private _eventElements?;
+    private _handler?;
+    private _isAsync;
+    constructor(name: Name);
+    use<const E extends ArcContextElementAny[]>(elements: E): ArcListener<Name, E, EventElements>;
+    description(description: string): ArcListener<Name, Elements, EventElements>;
+    listenTo<const E extends ArcContextElementAny[]>(events: E): ArcListener<Name, Elements, E>;
+    async(): ArcListener<Name, Elements, EventElements>;
+    handle(handler: ArcListenerHandler<Elements, EventElements>): ArcListener<Name, Elements, EventElements>;
+    observer: (authContext: AuthContext) => Record<string, ListenerConfig>;
+    private clone;
+}
+export declare function listener<Name extends string>(name: Name): ArcListener<Name, any[], any[]>;
+export {};
+//# sourceMappingURL=listener.d.ts.map

package/dist/model/model.d.ts

@@ -1,46 +1,67 @@
 import { type ArcContextAny, type IArcQueryBuilder } from "../context";
+import type { ArcContextElementMethodReturnType } from "../context/context";
+import type { AuthContext } from "../context/element";
 import { type DataStorage } from "../data-storage";
 type UnaryFunction<T, R> = (input: T) => R;
 export declare abstract class ModelBase<C extends ArcContextAny> {
-    abstract query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
-    abstract subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void): {
+    protected token: string | null;
+    /**
+     * Set the authentication token for API requests
+     */
+    setAuthToken(token: string | null): void;
+    abstract query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, authContext: AuthContext): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
+    abstract subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void, authContext: AuthContext): {
         result: ReturnType<Q["toQuery"]>["lastResult"];
         unsubscribe: () => void;
     };
-    abstract commands(): ReturnType<C["commandsClient"]>;
+    abstract commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
 }
 export declare class Model<C extends ArcContextAny> extends ModelBase<C> {
     private readonly context;
     private readonly dataStorage;
-    private readonly client;
     private readonly catchErrorCallback;
     private queryCache;
-    constructor(context: C, dataStorage: DataStorage, client: string, catchErrorCallback: (error: any) => void);
-    query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
-    subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void): {
+    constructor(context: C, dataStorage: DataStorage, catchErrorCallback: (error: any) => void);
+    query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, authContext: AuthContext): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
+    subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void, authContext: AuthContext): {
         result: ReturnType<Q["toQuery"]>["lastResult"];
         unsubscribe: () => void;
     };
-    commands(): ReturnType<C["commandsClient"]>;
-    fork(): ForkedModel<C>;
+    commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
     get $debug(): {};
 }
-export declare class ForkedModel<C extends ArcContextAny> extends Model<C> {
-    constructor(context: C, dataStorage: DataStorage, client: string, catchErrorCallback: (error: any) => void);
-    merge(): void;
-}
 export declare class RemoteModelClient<C extends ArcContextAny> extends ModelBase<C> {
     private readonly context;
     private readonly apiBaseUrl;
     private readonly client;
     private readonly catchErrorCallback;
     constructor(context: C, apiBaseUrl: string, client: string, catchErrorCallback: (error: any) => void);
-    query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
-    subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void): {
+    /**
+     * Check if a schema contains blob or file elements
+     */
+    private schemaContainsBlobOrFile;
+    /**
+     * Recursively check object shape for blob/file elements
+     */
+    private checkShapeForBlobOrFile;
+    /**
+     * Check if an element is a blob or file element
+     */
+    private isBlobOrFileElement;
+    /**
+     * Convert an object to FormData, handling nested objects and blobs
+     */
+    private objectToFormData;
+    /**
+     * Get authorization headers for API requests
+     */
+    private getAuthHeaders;
+    query<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, authContext: AuthContext): Promise<ReturnType<Q["toQuery"]>["lastResult"]>;
+    subscribe<Q extends IArcQueryBuilder>(queryBuilderFn: UnaryFunction<ReturnType<C["queryBuilder"]>, Q>, callback: (result: ReturnType<Q["toQuery"]>["lastResult"]) => void, authContext: AuthContext): {
         result: ReturnType<Q["toQuery"]>["lastResult"];
         unsubscribe: () => void;
     };
-    commands(): ReturnType<C["commandsClient"]>;
+    commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
 }
 export {};
 //# sourceMappingURL=model.d.ts.map

package/dist/tests/utils/test-model.d.ts

@@ -20,7 +20,6 @@ export declare class TestRTCAdapter implements RealTimeCommunicationAdapter {
 export declare function testModel<C extends ArcContextAny>(arcContext: C): {
     model: Model<C>;
     getRTCAdapter(): TestRTCAdapter;
-    fork(): import("../..").ForkedModel<C>;
     clearRTCHistory(): void;
 };
 //# sourceMappingURL=test-model.d.ts.map

package/dist/view/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./queries";
+export * from "./query-builders";
+export * from "./view";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,20 @@
+import { ArcSerializableQuery } from "../../context/serializable-query";
+import type { DataStorage, ListenerEvent, StoreState } from "../../data-storage";
+import type { ArcIdAny, ArcObjectAny } from "../../elements";
+import type { $type } from "../../utils";
+import type { ArcView } from "../view";
+export type ArcViewItem<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
+    _id: $type<Id>;
+} & $type<Schema>;
+export type ArcViewAny = ArcView<any, any, any, any>;
+export declare abstract class ArcViewQuery<View extends ArcViewAny, Result, Params> extends ArcSerializableQuery<Result, Params> {
+    protected view: View;
+    protected bindedChangeHandler: (changes: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>[]) => void;
+    private store;
+    constructor(view: View, params: Params);
+    run(dataStorage: DataStorage): Promise<Result>;
+    protected abstract onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): Result | false;
+    protected abstract fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<Result>;
+    protected changeHandler(changes: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>[]): void;
+}
+//# sourceMappingURL=abstract-view-query.d.ts.map

package/dist/view/queries/find-one.d.ts

@@ -0,0 +1,18 @@
+import type { ListenerEvent, StoreState } from "../../data-storage";
+import type { FindOptions } from "../../data-storage/types";
+import { ArcViewQuery, type ArcViewAny, type ArcViewItem } from "./abstract-view-query";
+export declare class QueryViewFindOneResult<V extends ArcViewAny> {
+    private result;
+    constructor(result: ArcViewItem<V["id"], V["schema"]> | undefined);
+    get(): ArcViewItem<V["id"], V["schema"]> | undefined;
+    exists(): boolean;
+}
+export declare class ArcViewFindOneQuery<View extends ArcViewAny> extends ArcViewQuery<View, QueryViewFindOneResult<View>, FindOptions<ArcViewItem<View["id"], View["schema"]>>> {
+    protected params: FindOptions<ArcViewItem<View["id"], View["schema"]>>;
+    constructor(view: View, params: FindOptions<ArcViewItem<View["id"], View["schema"]>>);
+    protected fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<QueryViewFindOneResult<View>>;
+    protected checkItem(item: ArcViewItem<View["id"], View["schema"]>): boolean;
+    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | QueryViewFindOneResult<View>;
+    protected createResult(result: ArcViewItem<View["id"], View["schema"]> | undefined): QueryViewFindOneResult<View>;
+}
+//# sourceMappingURL=find-one.d.ts.map

package/dist/view/queries/find.d.ts

@@ -0,0 +1,20 @@
+import type { ListenerEvent, StoreState } from "../../data-storage";
+import type { FindOptions } from "../../data-storage/types";
+import type { util } from "../../utils";
+import { ArcViewQuery, type ArcViewAny, type ArcViewItem } from "./abstract-view-query";
+export declare class QueryViewResult<V extends ArcViewAny> {
+    private result;
+    constructor(result: ArcViewItem<V["id"], V["schema"]>[]);
+    get(id: util.GetType<V["id"]> | null): ArcViewItem<V["id"], V["schema"]> | undefined;
+    map<U>(callbackfn: (value: ArcViewItem<V["id"], V["schema"]>, index: number, array: ArcViewItem<V["id"], V["schema"]>[]) => U): U[];
+    toArray(): ArcViewItem<V["id"], V["schema"]>[];
+}
+export declare class ArcViewFindQuery<View extends ArcViewAny> extends ArcViewQuery<View, QueryViewResult<View>, FindOptions<ArcViewItem<View["id"], View["schema"]>>> {
+    protected params: FindOptions<ArcViewItem<View["id"], View["schema"]>>;
+    constructor(view: View, params: FindOptions<ArcViewItem<View["id"], View["schema"]>>);
+    protected fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<QueryViewResult<View>>;
+    protected checkItem(item: ArcViewItem<View["id"], View["schema"]>): boolean;
+    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | QueryViewResult<View>;
+    protected createResult(result: ArcViewItem<View["id"], View["schema"]>[]): QueryViewResult<View>;
+}
+//# sourceMappingURL=find.d.ts.map

package/dist/view/queries/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./abstract-view-query";
+export * from "./find";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,13 @@
+import { QueryBuilderContext } from "../../context/query-builder-context";
+import type { FindOptions } from "../../data-storage/types";
+import type { ArcViewAny, ArcViewItem } from "../queries/abstract-view-query";
+import { ArcViewFindOneQuery } from "../queries/find-one";
+export declare class ArcViewFindOneQueryBuilder<V extends ArcViewAny> {
+    private view;
+    protected queryContext: QueryBuilderContext;
+    protected options: FindOptions<ArcViewItem<V["id"], V["schema"]>>;
+    constructor(view: V, queryContext: QueryBuilderContext, options: FindOptions<ArcViewItem<V["id"], V["schema"]>>);
+    toQuery(): ArcViewFindOneQuery<ArcViewAny>;
+    run(): import("../queries/find-one").QueryViewFindOneResult<ArcViewAny>;
+}
+//# sourceMappingURL=find-one.d.ts.map

package/dist/view/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 { ArcViewAny, ArcViewItem } from "../queries/abstract-view-query";
+import { ArcViewFindQuery } from "../queries/find";
+export declare class ArcViewFindQueryBuilder<V extends ArcViewAny> {
+    private view;
+    protected queryContext: QueryBuilderContext;
+    protected options: FindOptions<ArcViewItem<V["id"], V["schema"]>>;
+    constructor(view: V, queryContext: QueryBuilderContext, options: FindOptions<ArcViewItem<V["id"], V["schema"]>>);
+    toQuery(): ArcViewFindQuery<ArcViewAny>;
+    run(): import("..").QueryViewResult<ArcViewAny>;
+}
+//# sourceMappingURL=find.d.ts.map

package/dist/view/query-builders/index.d.ts

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

package/dist/view/view.d.ts

@@ -1,16 +1,19 @@
-import { ArcContextElementWithStore, type ArcContextElementAny, type StoreSchema } from "../context/element";
+import { ArcContextElementWithStore, type ArcContextElementAny, type AuthContext, type ListenerConfig, type PublishEventFunction, type StoreSchema } from "../context/element";
 import type { QueryBuilderContext } from "../context/query-builder-context";
 import type { DataStorage } from "../data-storage";
-import type { FindOptions } from "../data-storage/types";
+import type { FindOptions, WhereCondition } from "../data-storage/types";
 import { type ArcIdAny, type ArcObjectAny } from "../elements";
 import type { $type } from "../utils";
+import { ArcViewFindQueryBuilder } from "./query-builders/find";
+import { ArcViewFindOneQueryBuilder } from "./query-builders/find-one";
 type GetEvents<Elements extends ArcContextElementAny[]> = Elements[number]["$event"];
 type ArcViewHandlerContext<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
-    modify: (id: $type<Id>, data: $type<Schema>) => Promise<void>;
+    modify: (id: $type<Id>, data: Partial<$type<Schema>>) => Promise<void>;
     set: (id: $type<Id>, data: $type<Schema>) => Promise<void>;
     remove: (id: $type<Id>) => Promise<void>;
     find: (options: FindOptions<ArcViewItem<Id, Schema>>) => Promise<ArcViewItem<Id, Schema>[]>;
     findOne: (where: FindOptions<ArcViewItem<Id, Schema>>["where"]) => Promise<ArcViewItem<Id, Schema> | undefined>;
+    $auth: AuthContext;
 };
 type ArcViewItem<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
     _id: $type<Id>;
@@ -25,23 +28,32 @@ export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema ex
     private _description?;
     private _elements?;
     private _handler?;
+    private _isAsync;
+    private restrictions?;
     constructor(name: Name, id: Id, schema: Schema);
     storeSchema: () => StoreSchema;
+    /**
+     * Define read access restrictions for this view
+     * @param restrictionsFn - Function that takes auth context and returns where condition for read access
+     */
+    auth(restrictionsFn: (authContext: AuthContext) => WhereCondition): ArcView<Name, Id, Schema, Elements>;
     use<const E extends ArcContextElementAny[]>(elements: E): ArcView<Name, Id, Schema, E>;
     description(description: string): ArcView<Name, Id, Schema, Elements>;
+    async(): ArcView<Name, Id, Schema, Elements>;
     handle<Handler extends ArcViewHandler<Elements, Id, Schema>>(handler: Handler): ArcView<Name, Id, Schema, Elements>;
-    queryBuilder: (context: QueryBuilderContext) => {
-        readonly find: (options?: FindOptions<$type<Schema>>) => never;
+    /**
+     * Helper function to merge where conditions from restrictions with query options
+     */
+    private applyRestrictions;
+    queryBuilder: (context: QueryBuilderContext, authContext: AuthContext) => {
+        readonly find: (options?: FindOptions<ArcViewItem<Id, Schema>>) => ArcViewFindQueryBuilder<ArcView<Name, Id, Schema, Elements>>;
+        readonly findOne: (where: FindOptions<ArcViewItem<Id, Schema>>["where"]) => ArcViewFindOneQueryBuilder<ArcView<Name, Id, Schema, Elements>>;
     };
-    commandContext: (dataStorage: DataStorage, publishEvent: (event: this["$event"]) => Promise<void>) => {
-        readonly find: (options: FindOptions<ArcViewItem<Id, Schema>>) => Promise<{
-            _id: string;
-        }[]>;
-        readonly findOne: (where: FindOptions<ArcViewItem<Id, Schema>>["where"]) => Promise<{
-            _id: string;
-        }>;
+    commandContext: (dataStorage: DataStorage, publishEvent: PublishEventFunction, authContext: AuthContext) => {
+        readonly find: (options: FindOptions<ArcViewItem<Id, Schema>>) => Promise<ArcViewItem<Id, Schema>[]>;
+        readonly findOne: (where: FindOptions<ArcViewItem<Id, Schema>>["where"]) => Promise<ArcViewItem<Id, Schema> | undefined>;
     };
-    observer: () => Record<string, any>;
+    observer: (authContext: AuthContext) => Record<string, ListenerConfig>;
     private clone;
 }
 export declare function view<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny>(name: Name, id: Id, schema: Schema): ArcView<Name, Id, Schema, any[]>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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.",

package/dist/db/index-query.d.ts

@@ -1,3 +0,0 @@
-import { type IndexQueryArgument } from "./interface";
-export declare function indexQueryPredicate<T>(item: T, query: IndexQueryArgument<any>): boolean;
-//# sourceMappingURL=index-query.d.ts.map