@arcote.tech/arc 0.1.4 → 0.1.5

package/dist/command/command.d.ts

@@ -20,6 +20,10 @@ export declare class ArcCommand<Name extends string, Params extends ArcObjectAny
     description(description: string): ArcCommand<Name, Params, Results, Elements>;
     public(): ArcCommand<Name, Params, Results, Elements>;
     get isPublic(): boolean;
+    matchesCommandPath(pathname: string): {
+        matches: boolean;
+        isPublic: boolean;
+    };
     withParams<NewParams extends ArcRawShape>(schema: NewParams | ArcObject<NewParams>): ArcCommand<Name, ArcObject<NewParams>, Results, Elements>;
     withResult<NewResults extends ArcRawShape[]>(...schemas: NewResults): ArcCommand<Name, Params, { [K in keyof NewResults]: ArcObject<NewResults[K]>; }, Elements>;
     handle(handler: ArcCommmandHandler<Elements, Params, Results> | false): ArcCommand<Name, Params, Results, Elements>;

package/dist/context/context.d.ts

@@ -41,8 +41,6 @@ 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 | false | Promise<{
-    default: ArcContextElementAny;
-}>)[]>(elementsPromise: Elements): Promise<ArcContext<RemoveFalseAndResolvedPromiseFromArray<Elements>>>;
+export declare function context<const Elements extends ArcContextElementAny[]>(elementsPromise: Elements): Promise<ArcContext<Elements>>;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/context/element.d.ts

@@ -50,7 +50,7 @@ export type StoreSchema = {
 export declare abstract class ArcContextElement<const Event, const Name extends string | undefined = undefined> {
     readonly $event: Event;
     readonly name?: Name;
-    queryBuilder?(queryContext: QueryBuilderContext, authContext: AuthContext): any;
+    queryBuilder?: (queryContext: QueryBuilderContext, authContext: AuthContext) => any;
     commandContext?: (dataStorage: DataStorage, publishEvent: PublishEventFunction, authContext: AuthContext) => any;
     commandClient?: (commandContext: any, authContext: AuthContext) => (...args: any[]) => any;
     observer?: (authContext: AuthContext) => Record<string, ListenerConfig>;

package/dist/context/event.d.ts

@@ -3,14 +3,7 @@ import { ArcObject, type ArcObjectAny, type ArcRawShape } from "../elements/obje
 import type { $type } from "../utils";
 import { ArcContextElementWithStore, type AuthContext, type AuthorizationRestrictions, type EventAuthorizationRestrictions, type StoreSchema } from "./element";
 export type EventMetadata = {
-    occurredAt: string;
-    createdBy?: {
-        id: string;
-        type: string;
-    };
-    source?: string;
-    correlationId?: string;
-    version?: number;
+    createdAt: Date;
 };
 export declare class ArcEvent<const Name extends string, const PayloadShape extends ArcObjectAny | undefined> extends ArcContextElementWithStore<ArcEventInstance<ArcEvent<Name, PayloadShape>>, Name> {
     readonly name: Name;

package/dist/elements/any.d.ts

@@ -0,0 +1,9 @@
+import { ArcAbstract, type Validators } from "./abstract";
+export declare class ArcAny<V extends Validators = []> extends ArcAbstract<V> {
+    constructor();
+    parse(value: any): any;
+    serialize(value: any): any;
+    deserialize(value: any): any;
+}
+export declare function any(): ArcAny<[]>;
+//# sourceMappingURL=any.d.ts.map

package/dist/elements/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./any";
 export * from "./array";
 export * from "./blob";
 export * from "./boolean";

package/dist/index.d.ts

@@ -6,6 +6,7 @@ export * from "./db";
 export * from "./elements";
 export * from "./listener";
 export * from "./model";
+export * from "./route";
 export * from "./rtc";
 export * from "./state";
 export * from "./utils";

package/dist/index.js

@@ -2,6 +2,7 @@
 class ArcContextElement {
   $event;
   name;
+  queryBuilder;
   commandContext;
   commandClient;
   observer;
@@ -314,6 +315,24 @@ function customId(name, createFn) {
   return new ArcCustomId(name, createFn);
 }
 
+// elements/any.ts
+class ArcAny extends ArcAbstract {
+  constructor() {
+    super([]);
+  }
+  parse(value) {
+    return value;
+  }
+  serialize(value) {
+    return value;
+  }
+  deserialize(value) {
+    return value;
+  }
+}
+function any() {
+  return new ArcAny;
+}
 // elements/object.ts
 var objectValidator = typeValidatorBuilder("object");
 
@@ -1114,7 +1133,7 @@ class ArcFindQuery extends ArcCollectionQuery {
   }
   onChange(change) {
     const lastResult = this.lastResult;
-    const lastResultAsArray = lastResult?.toArray() || [];
+    const lastResultAsArray = lastResult || [];
     const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.id));
     const isInLastResult = index !== -1;
     const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.item);
@@ -1304,6 +1323,16 @@ class ArcCommand extends ArcContextElement {
   get isPublic() {
     return this._isPublic;
   }
+  matchesCommandPath(pathname) {
+    if (!pathname.startsWith("/command/")) {
+      return { matches: false, isPublic: false };
+    }
+    const commandName = pathname.split("/command/")[1];
+    if (commandName === this.name) {
+      return { matches: true, isPublic: this._isPublic };
+    }
+    return { matches: false, isPublic: false };
+  }
   withParams(schema) {
     const clone = this.clone();
     clone._params = schema instanceof ArcObject ? schema : object(schema);
@@ -1496,7 +1525,7 @@ class ArcEvent extends ArcContextElementWithStore {
           id: eventId.generate(),
           type: this.name,
           payload,
-          createdAt: new Date().toISOString()
+          createdAt: new Date
         };
         await dataStorage.getStore("events").set(event);
         await publishEvent(event);
@@ -2495,6 +2524,40 @@ class Model extends ModelBase {
       }
     });
   }
+  routes(authContext) {
+    return new Proxy({}, {
+      get: (_, name) => {
+        const element3 = this.context.elements.find((element4) => element4.name === name);
+        if (!element3) {
+          throw new Error(`Route element "${String(name)}" not found`);
+        }
+        if (typeof element3.getHandler !== "function") {
+          throw new Error(`Element "${String(name)}" does not have route handlers`);
+        }
+        return async (method, req, routeParams, url) => {
+          const handler = element3.getHandler(method);
+          if (!handler) {
+            throw new Error(`Method ${method} not allowed for route ${String(name)}`);
+          }
+          const forkedDataStorage = this.dataStorage.fork();
+          const eventPublisher = new EventPublisher(this.context, this.dataStorage, authContext);
+          const publishEvent = async (event3) => {
+            await eventPublisher.publishEvent(event3, forkedDataStorage);
+          };
+          const commandContext = this.context.commandContext(forkedDataStorage, publishEvent, authContext);
+          try {
+            const result = await handler(commandContext, req, routeParams, url);
+            await forkedDataStorage.merge();
+            eventPublisher.runAsyncListeners();
+            return result;
+          } catch (error) {
+            this.catchErrorCallback(error);
+            throw error;
+          }
+        };
+      }
+    });
+  }
   get $debug() {
     return {};
   }
@@ -2643,8 +2706,7 @@ class RemoteModelClient extends ModelBase {
     if (!response.ok) {
       throw new Error(`Query failed: ${response.statusText}`);
     }
-    const { result } = await response.json();
-    return result;
+    return await response.json();
   }
   subscribe(queryBuilderFn, callback, authContext) {
     const result = this.query(queryBuilderFn, authContext);
@@ -2688,6 +2750,95 @@ class RemoteModelClient extends ModelBase {
     });
     return commandsProxy;
   }
+  routes(authContext) {
+    throw new Error("Remote model client does not support route execution");
+  }
+}
+// route/route.ts
+class ArcRoute extends ArcContextElement {
+  name;
+  _description;
+  _path;
+  _elements;
+  _handlers;
+  _isPublic = false;
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  use(elements) {
+    const clone = this.clone();
+    clone._elements = elements;
+    return clone;
+  }
+  description(description) {
+    const clone = this.clone();
+    clone._description = description;
+    return clone;
+  }
+  path(path) {
+    const clone = this.clone();
+    clone._path = path;
+    return clone;
+  }
+  public() {
+    const clone = this.clone();
+    clone._isPublic = true;
+    return clone;
+  }
+  get isPublic() {
+    return this._isPublic;
+  }
+  get routePath() {
+    return this._path || `/${this.name}`;
+  }
+  handle(handlers) {
+    const clone = this.clone();
+    clone._handlers = handlers;
+    return clone;
+  }
+  getHandler(method) {
+    return this._handlers?.[method];
+  }
+  matchesPath(pathname) {
+    const routePath = this.routePath;
+    const routeParts = routePath.split("/").filter(Boolean);
+    const pathParts = pathname.split("/").filter(Boolean);
+    if (routeParts.length !== pathParts.length) {
+      return { matches: false, params: {} };
+    }
+    const params = {};
+    for (let i = 0;i < routeParts.length; i++) {
+      const routePart = routeParts[i];
+      const pathPart = pathParts[i];
+      if (routePart.startsWith(":")) {
+        const paramName = routePart.slice(1);
+        params[paramName] = pathPart;
+      } else if (routePart !== pathPart) {
+        return { matches: false, params: {} };
+      }
+    }
+    return { matches: true, params };
+  }
+  matchesRoutePath(pathname) {
+    const { matches, params } = this.matchesPath(pathname);
+    if (matches) {
+      return { matches: true, isPublic: this._isPublic, params };
+    }
+    return { matches: false, isPublic: false };
+  }
+  clone() {
+    const clone = new ArcRoute(this.name);
+    clone._description = this._description;
+    clone._path = this._path;
+    clone._handlers = this._handlers;
+    clone._elements = this._elements;
+    clone._isPublic = this._isPublic;
+    return clone;
+  }
+}
+function route(name) {
+  return new ArcRoute(name);
 }
 // rtc/client.ts
 class RTCClient {
@@ -2795,22 +2946,6 @@ class ArcViewQuery extends ArcSerializableQuery {
 }
 
 // view/queries/find.ts
-class QueryViewResult {
-  result;
-  constructor(result) {
-    this.result = result;
-  }
-  get(id3) {
-    return id3 ? this.result.find((r) => r._id === id3) : undefined;
-  }
-  map(callbackfn) {
-    return this.result.map(callbackfn);
-  }
-  toArray() {
-    return this.result;
-  }
-}
-
 class ArcViewFindQuery extends ArcViewQuery {
   params;
   constructor(view, params) {
@@ -2857,7 +2992,7 @@ class ArcViewFindQuery extends ArcViewQuery {
   }
   onChange(change) {
     const lastResult = this.lastResult;
-    const lastResultAsArray = lastResult?.toArray() || [];
+    const lastResultAsArray = lastResult || [];
     const index = lastResultAsArray.findIndex((e) => e._id === (change.type === "delete" ? change.id : change.id));
     const isInLastResult = index !== -1;
     const shouldBeInTheResult = change.type !== "delete" && this.checkItem(change.item);
@@ -2870,7 +3005,7 @@ class ArcViewFindQuery extends ArcViewQuery {
     return false;
   }
   createResult(result) {
-    return new QueryViewResult(result);
+    return result;
   }
 }
 
@@ -2896,19 +3031,6 @@ class ArcViewFindQueryBuilder {
 }
 
 // view/queries/find-one.ts
-class QueryViewFindOneResult {
-  result;
-  constructor(result) {
-    this.result = result;
-  }
-  get() {
-    return this.result;
-  }
-  exists() {
-    return this.result !== undefined;
-  }
-}
-
 class ArcViewFindOneQuery extends ArcViewQuery {
   params;
   constructor(view, params) {
@@ -2955,7 +3077,7 @@ class ArcViewFindOneQuery extends ArcViewQuery {
   }
   onChange(change) {
     const lastResult = this.lastResult;
-    const currentItem = lastResult?.get();
+    const currentItem = lastResult;
     const itemId = change.type === "delete" ? change.id : change.id;
     const hasCurrentItem = currentItem !== undefined;
     const isCurrentItem = hasCurrentItem && currentItem._id === itemId;
@@ -2969,7 +3091,7 @@ class ArcViewFindOneQuery extends ArcViewQuery {
     return false;
   }
   createResult(result) {
-    return new QueryViewFindOneResult(result);
+    return result;
   }
 }
 
@@ -3157,6 +3279,7 @@ export {
   stringEnum,
   string,
   rtcClientFactory,
+  route,
   record,
   reactive,
   object,
@@ -3175,6 +3298,7 @@ export {
   boolean,
   blob,
   array,
+  any,
   StoreState,
   SQLiteAdapter,
   RemoteModelClient,
@@ -3190,6 +3314,7 @@ export {
   ArcView,
   ArcStringEnum,
   ArcString,
+  ArcRoute,
   ArcRecord,
   ArcQueryBuilder,
   ArcQuery,
@@ -3211,5 +3336,6 @@ export {
   ArcBranded,
   ArcBoolean,
   ArcBlob,
-  ArcArray
+  ArcArray,
+  ArcAny
 };

package/dist/model/model.d.ts

@@ -15,6 +15,7 @@ export declare abstract class ModelBase<C extends ArcContextAny> {
         unsubscribe: () => void;
     };
     abstract commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
+    abstract routes(authContext: AuthContext): any;
 }
 export declare class Model<C extends ArcContextAny> extends ModelBase<C> {
     private readonly context;
@@ -28,6 +29,7 @@ export declare class Model<C extends ArcContextAny> extends ModelBase<C> {
         unsubscribe: () => void;
     };
     commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
+    routes(authContext: AuthContext): any;
     get $debug(): {};
 }
 export declare class RemoteModelClient<C extends ArcContextAny> extends ModelBase<C> {
@@ -62,6 +64,7 @@ export declare class RemoteModelClient<C extends ArcContextAny> extends ModelBas
         unsubscribe: () => void;
     };
     commands(authContext: AuthContext): ArcContextElementMethodReturnType<C["elements"], "commandClient">;
+    routes(authContext: AuthContext): any;
 }
 export {};
 //# sourceMappingURL=model.d.ts.map

package/dist/route/index.d.ts

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

package/dist/route/route.d.ts

@@ -0,0 +1,35 @@
+import type { ArcCommandContext } from "../context";
+import { ArcContextElement, type ArcContextElementAny } from "../context/element";
+export type ArcRouteHandler<ContextElements extends ArcContextElementAny[]> = (ctx: ArcCommandContext<ContextElements>, request: Request, params: Record<string, string>, url: URL) => Promise<Response> | Response;
+export type ArcRouteHandlers<ContextElements extends ArcContextElementAny[]> = {
+    [Method in "GET" | "POST" | "PUT" | "DELETE" | "PATCH"]?: ArcRouteHandler<ContextElements>;
+};
+export declare class ArcRoute<Name extends string, const Elements extends ArcContextElementAny[]> extends ArcContextElement<null, Name> {
+    readonly name: Name;
+    private _description?;
+    private _path?;
+    private _elements?;
+    private _handlers?;
+    private _isPublic;
+    constructor(name: Name);
+    use<const E extends ArcContextElementAny[]>(elements: E): ArcRoute<Name, E>;
+    description(description: string): ArcRoute<Name, Elements>;
+    path(path: string): ArcRoute<Name, Elements>;
+    public(): ArcRoute<Name, Elements>;
+    get isPublic(): boolean;
+    get routePath(): string;
+    handle(handlers: ArcRouteHandlers<Elements>): ArcRoute<Name, Elements>;
+    getHandler(method: string): ArcRouteHandler<Elements> | undefined;
+    matchesPath(pathname: string): {
+        matches: boolean;
+        params: Record<string, string>;
+    };
+    matchesRoutePath(pathname: string): {
+        matches: boolean;
+        isPublic: boolean;
+        params?: Record<string, string>;
+    };
+    private clone;
+}
+export declare function route<Name extends string>(name: Name): ArcRoute<Name, any[]>;
+//# sourceMappingURL=route.d.ts.map

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

@@ -1,18 +1,12 @@
 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"]>>> {
+export declare class ArcViewFindOneQuery<View extends ArcViewAny> extends ArcViewQuery<View, ArcViewItem<View["id"], View["schema"]> | undefined, 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 fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<ArcViewItem<View["id"], View["schema"]> | undefined>;
     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>;
+    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | ArcViewItem<View["id"], View["schema"]> | undefined;
+    protected createResult(result: ArcViewItem<View["id"], View["schema"]> | undefined): ArcViewItem<View["id"], View["schema"]> | undefined;
 }
 //# sourceMappingURL=find-one.d.ts.map

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

@@ -9,12 +9,12 @@ export declare class QueryViewResult<V extends ArcViewAny> {
     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"]>>> {
+export declare class ArcViewFindQuery<View extends ArcViewAny> extends ArcViewQuery<View, ArcViewItem<View["id"], View["schema"]>[], 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 fetch(store: StoreState<ArcViewItem<View["id"], View["schema"]>>): Promise<ArcViewItem<View["id"], View["schema"]>[]>;
     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>;
+    protected onChange(change: ListenerEvent<ArcViewItem<View["id"], View["schema"]>>): false | ArcViewItem<View["id"], View["schema"]>[];
+    protected createResult(result: ArcViewItem<View["id"], View["schema"]>[]): ArcViewItem<View["id"], View["schema"]>[];
 }
 //# sourceMappingURL=find.d.ts.map

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

@@ -7,7 +7,7 @@ export declare class ArcViewFindOneQueryBuilder<V extends ArcViewAny> {
     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>;
+    toQuery(): ArcViewFindOneQuery<V>;
+    run(): ArcViewItem<V["id"], V["schema"]> | undefined;
 }
 //# sourceMappingURL=find-one.d.ts.map

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

@@ -7,7 +7,7 @@ export declare class ArcViewFindQueryBuilder<V extends ArcViewAny> {
     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>;
+    toQuery(): ArcViewFindQuery<V>;
+    run(): ArcViewItem<V["id"], V["schema"]>[];
 }
 //# sourceMappingURL=find.d.ts.map

package/package.json

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