@arcote.tech/arc 0.1.5 → 0.1.6

package/dist/command/command.d.ts

@@ -9,12 +9,12 @@ export declare class ArcCommand<Name extends string, Params extends ArcObjectAny
     result: Results[number];
 }, Name> {
     readonly name: Name;
-    private _description?;
-    private _params?;
-    private _results?;
-    private _elements?;
-    private _handler?;
-    private _isPublic;
+    _description?: string;
+    _params?: Params;
+    _results?: Results;
+    _elements?: Elements;
+    _handler?: ArcCommmandHandler<Elements, Params, Results> | false;
+    _isPublic: boolean;
     constructor(name: Name);
     use<const E extends ArcContextElementAny[]>(elements: E): ArcCommand<Name, Params, Results, E>;
     description(description: string): ArcCommand<Name, Params, Results, Elements>;
@@ -30,7 +30,14 @@ export declare class ArcCommand<Name extends string, Params extends ArcObjectAny
     commandClient: (ctx: any) => (Params extends ArcObjectAny ? (params: $type<Params>) => Promise<$type<Results[number]>> : () => Promise<$type<Results[number]>>) & {
         params: Params;
     };
-    private clone;
+    protected clone(): ArcCommand<Name, Params, Results, Elements>;
+    toJsonSchema(): {
+        type: string;
+        name: Name;
+        description: string | undefined;
+        parameters: any;
+    };
 }
 export declare function command<Name extends string>(name: Name): ArcCommand<Name, null, any[], any[]>;
+export type ArcCommandAny = ArcCommand<any, any, any, any>;
 //# sourceMappingURL=command.d.ts.map

package/dist/context/context.d.ts

@@ -15,6 +15,8 @@ export type ArcContextElementMethodReturnType<Elements extends ArcContextElement
 }[number]>;
 export type ArcCommandContext<E extends ArcContextElementAny[]> = ArcContextElementMethodReturnType<E, "commandContext"> & {
     $auth: AuthContext;
+} & {
+    get: <ArcElement extends ArcContextElementAny>(element: ArcElement) => ArcElement["commandContext"] extends infer CommandContext ? CommandContext extends (...args: any) => any ? ReturnType<CommandContext> : never : never;
 };
 export type RemoveFalseAndResolvedPromiseFromArray<T extends any[]> = T extends [infer First, ...infer Rest] ? First extends false ? RemoveFalseAndResolvedPromiseFromArray<Rest> : First extends Promise<{
     default: infer Inner;
@@ -41,6 +43,7 @@ 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[]>(elementsPromise: Elements): Promise<ArcContext<Elements>>;
+export declare function context<const Elements extends ArcContextElementAny[]>(elements: Elements): ArcContext<Elements>;
+export declare function contextMerge<const Contexts extends ArcContextAny[]>(...contexts: Contexts): ArcContext<Contexts[number]["elements"]>;
 export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/elements/abstract.d.ts

@@ -24,6 +24,10 @@ export declare abstract class ArcAbstract<V extends Validators> implements ArcEl
         name: Name;
         validator: Val;
     }]>;
+    /**
+     * Default JSON Schema representation – concrete subclasses should override where applicable.
+     */
+    toJsonSchema(): any;
     getValidations(): V;
 }
 export type ArcAbstractAny = ArcAbstract<any>;

package/dist/elements/any.d.ts

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

package/dist/elements/array.d.ts

@@ -54,6 +54,10 @@ export declare class ArcArray<E extends ArcElement, V extends Validators = [
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+        items: any;
+    };
 }
 export type ArcArrayAny = ArcArray<any>;
 export declare function array<E extends ArcElement>(element: E): ArcArray<E, [{

package/dist/elements/blob.d.ts

@@ -67,6 +67,11 @@ export declare class ArcBlob<V extends Validators = [typeof blobValidator]> exte
      * Override parse to validate blob objects
      */
     parse(value: any): Blob;
+    toJsonSchema(): {
+        type: string;
+        contentEncoding: string;
+        contentMediaType: string;
+    };
 }
 export declare function blob(): ArcBlob<[{
     readonly name: "blob";

package/dist/elements/boolean.d.ts

@@ -11,6 +11,9 @@ export declare class ArcBoolean<V extends Validators> extends ArcPrimitive<V, bo
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+    };
 }
 export declare function boolean(): ArcBoolean<Validators>;
 //# sourceMappingURL=boolean.d.ts.map

package/dist/elements/branded.d.ts

@@ -17,6 +17,7 @@ export declare class ArcBranded<E extends ArcAbstractAny, Brand extends string |
     };
     optional(): ArcOptional<this>;
     validate(value: unknown): unknown;
+    toJsonSchema(): any;
 }
 export type ArcBrandedAny = ArcBranded<ArcAbstractAny, any>;
 //# sourceMappingURL=branded.d.ts.map

package/dist/elements/date.d.ts

@@ -30,6 +30,10 @@ export declare class ArcDate<V extends Validators = [typeof dateValidator]> exte
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+        format: string;
+    };
 }
 export declare function date(): ArcDate<[{
     name: "type";

package/dist/elements/default.d.ts

@@ -8,5 +8,6 @@ export declare class ArcDefault<E extends ArcElement> implements ArcElement {
     parse(value: util.FirstArgument<E["parse"]> | undefined): ReturnType<E["parse"]>;
     serialize(value: util.FirstArgument<E["serialize"]> | undefined): ReturnType<E["serialize"]>;
     deserialize(value: util.FirstArgument<E["deserialize"]> | undefined): ReturnType<E["deserialize"]>;
+    toJsonSchema(): any;
 }
 //# sourceMappingURL=default.d.ts.map

package/dist/elements/element.d.ts

@@ -3,5 +3,9 @@ export interface ArcElement {
     deserialize(value: unknown): unknown;
     parse(value: unknown): unknown;
     validate(value: unknown): unknown;
+    /**
+     * Returns JSON Schema Draft-07 representation of this element.
+     */
+    toJsonSchema(): any;
 }
 //# sourceMappingURL=element.d.ts.map

package/dist/elements/file.d.ts

@@ -127,6 +127,11 @@ export declare class ArcFile<V extends Validators = [typeof fileValidator]> exte
      * Override parse to validate file objects
      */
     parse(value: any): File;
+    toJsonSchema(): {
+        type: string;
+        contentEncoding: string;
+        contentMediaType: string;
+    };
 }
 export declare function file(): ArcFile<[{
     readonly name: "file";

package/dist/elements/number.d.ts

@@ -27,6 +27,9 @@ export declare class ArcNumber<V extends Validators = [typeof numberValidator]>
         name: Name;
         validator: Fn;
     }]>>>;
+    toJsonSchema(): {
+        type: string;
+    };
 }
 export declare function number(): ArcNumber<[{
     name: "type";

package/dist/elements/object.d.ts

@@ -63,6 +63,7 @@ export declare class ArcObject<E extends ArcRawShape, V extends Validators = [
     pick<Keys extends keyof E>(...keys: Keys[]): ArcObject<Pick<E, Keys>, V>;
     omit<Keys extends keyof E>(...keys: Keys[]): ArcObject<Omit<E, Keys>, V>;
     entries(): [string, ArcElement][];
+    toJsonSchema(): any;
 }
 export type ArcObjectAny = ArcObject<any, any>;
 export type ArcObjectKeys<T extends ArcObjectAny> = T extends ArcObject<infer E, any> ? Exclude<keyof E, symbol> : never;
@@ -80,5 +81,9 @@ export declare function object<E extends ArcRawShape>(element: E): ArcObject<E,
     name: "schema";
     validator: (value: any) => false | { [key in keyof E]: ReturnType<E[key]["validate"]>; };
 }]>;
+export type ArcObjectMerge<A extends ArcObjectAny, B extends ArcObjectAny> = [A, B] extends [
+    ArcObject<infer AShape, infer AValidators>,
+    ArcObject<infer BShape, infer BValidators>
+] ? ArcObject<AShape & BShape, [...AValidators, ...BValidators]> : never;
 export {};
 //# sourceMappingURL=object.d.ts.map

package/dist/elements/optional.d.ts

@@ -8,6 +8,9 @@ export declare class ArcOptional<E extends ArcElement> implements ArcElement {
     serialize(value: util.FirstArgument<E["serialize"]> | null | undefined): ReturnType<E["serialize"]> | null;
     deserialize(value: util.FirstArgument<E["deserialize"]> | null | undefined): ReturnType<E["deserialize"]> | null;
     validate(value: unknown): unknown;
+    toJsonSchema(): {
+        anyOf: any[];
+    };
 }
 export type ArcOptionalAny = ArcOptional<ArcAbstractAny>;
 //# sourceMappingURL=optional.d.ts.map

package/dist/elements/or.d.ts

@@ -1,2 +1,37 @@
-export {};
+import { type util } from "../utils";
+import type { ArcElement } from "./element";
+/**
+ * ArcOr allows you to create a union schema from existing Arc elements.
+ * The generic parameter keeps the type-information of every provided
+ * element which results in a **strongly-typed** union of all underlying
+ * element types.
+ */
+export declare class ArcOr<T extends ArcElement[]> implements ArcElement {
+    private readonly elements;
+    constructor(elements: T);
+    /**
+     * Serialises a union value using the first matching element.
+     */
+    serialize(value: util.FirstArgument<T[number]["serialize"]>): ReturnType<T[number]["serialize"]>;
+    /**
+     * Deserialises a raw value using the first element that validates it.
+     */
+    deserialize(value: util.FirstArgument<T[number]["deserialize"]>): ReturnType<T[number]["deserialize"]>;
+    /**
+     * Parses an input value using the first element that validates it.
+     */
+    parse(value: util.FirstArgument<T[number]["parse"]>): ReturnType<T[number]["parse"]>;
+    /**
+     * Runs validation on a value against **all** underlying elements.
+     * Succeeds (returns `false`) when at least one element validates the value.
+     * Otherwise returns a map of errors keyed by the element index.
+     */
+    validate(value: unknown): unknown;
+    toJsonSchema(): {
+        anyOf: any[];
+    };
+    private pickElement;
+    private isTypeOf;
+}
+export declare function or<T extends ArcElement[]>(...elements: T): ArcOr<T>;
 //# sourceMappingURL=or.d.ts.map

package/dist/elements/record.d.ts

@@ -19,6 +19,11 @@ export declare class ArcRecord<Key extends ArcKey, E extends ArcElement, V exten
     parse(value: Record<util.FirstArgument<Key["parse"]>, util.FirstArgument<E["parse"]>>): Record<ReturnType<Key["parse"]>, ReturnType<E["parse"]>>;
     serialize(value: Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>): Record<ReturnType<Key["serialize"]>, ReturnType<E["serialize"]>>;
     deserialize(value: Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>): Record<ReturnType<Key["deserialize"]>, ReturnType<E["deserialize"]>>;
+    toJsonSchema(): {
+        type: string;
+        propertyNames: any;
+        additionalProperties: any;
+    };
 }
 export type ArcRecordAny = ArcRecord<any, any>;
 export declare function record<Key extends ArcKey, E extends ArcElement>(key: Key, element: E): ArcRecord<Key, E, [{

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

@@ -13,6 +13,10 @@ export declare class ArcStringEnum<const T extends string[], V extends Validator
     parse<Value extends T[number]>(value: Value): Value;
     serialize<Value extends T[number]>(value: Value): Value;
     deserialize<Value extends T[number]>(value: Value): Value;
+    toJsonSchema(): {
+        readonly type: "string";
+        readonly enum: T;
+    };
     getEnumerators(): T;
 }
 export type ArcStringEnumAny = ArcStringEnum<any>;

package/dist/elements/string.d.ts

@@ -64,6 +64,9 @@ export declare class ArcString<V extends Validators = [typeof stringValidator]>
             currentEmail: string;
         } | undefined;
     }]>;
+    toJsonSchema(): {
+        type: string;
+    };
     url(): ArcString<[...V, {
         name: "url";
         validator: (value: string) => {

package/dist/index.js

@@ -37,6 +37,12 @@ class ArcOptional {
       return false;
     return this.parent.validate(value);
   }
+  toJsonSchema() {
+    const parentSchema = this.parent.toJsonSchema?.() ?? {};
+    return {
+      anyOf: [parentSchema, { type: "null" }]
+    };
+  }
 }
 
 // elements/branded.ts
@@ -62,6 +68,9 @@ class ArcBranded {
   validate(value) {
     return this.parent.validate(value);
   }
+  toJsonSchema() {
+    return this.parent.toJsonSchema?.() ?? {};
+  }
 }
 
 // elements/default.ts
@@ -94,6 +103,14 @@ class ArcDefault {
     } else
       return this.defaultValueOrCallback;
   }
+  toJsonSchema() {
+    const schema = this.parent.toJsonSchema?.() ?? {};
+    const defaultValue = typeof this.defaultValueOrCallback === "function" ? this.defaultValueOrCallback() : this.defaultValueOrCallback;
+    return {
+      ...schema,
+      default: defaultValue
+    };
+  }
 }
 
 // elements/abstract.ts
@@ -135,6 +152,9 @@ class ArcAbstract {
     newInstance.validations = [...this.validations, { name, validator }];
     return newInstance;
   }
+  toJsonSchema() {
+    return {};
+  }
   getValidations() {
     return this.validations;
   }
@@ -255,6 +275,9 @@ class ArcString extends ArcPrimitive {
       }
     });
   }
+  toJsonSchema() {
+    return { type: "string" };
+  }
   url() {
     const regex = /^(https?):\/\/(?![-0-9])(?!www\.[0-9])(?:[a-zA-Z0-9-]+(?::[a-zA-Z0-9-]+)?@)?(?:localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b|[a-zA-Z0-9-]+\.)?[a-zA-Z0-9-]+\.(?:[a-zA-Z]{2,}|[a-zA-Z]{2}\.[a-zA-Z]{2})(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$|^(https?):\/\/(localhost|\b(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\b)(?::\d{1,5})?(?!\/\/)(?:\/[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(?!\/{2})(?:;[a-zA-Z0-9-._~:?#\[\]@!$&'()*+,;=]*)*(\?(?!=)[a-zA-Z0-9&=;]*)?(\#[a-zA-Z0-9-]*)?$/;
     return this.validation("url", (value) => {
@@ -329,6 +352,9 @@ class ArcAny extends ArcAbstract {
   deserialize(value) {
     return value;
   }
+  toJsonSchema() {
+    return {};
+  }
 }
 function any() {
   return new ArcAny;
@@ -440,6 +466,23 @@ class ArcObject extends ArcAbstract {
   entries() {
     return Object.entries(this.rawShape);
   }
+  toJsonSchema() {
+    const properties = {};
+    const required = [];
+    for (const [key, element] of Object.entries(this.rawShape)) {
+      properties[key] = element.toJsonSchema?.() ?? {};
+      if (!(element instanceof ArcOptional)) {
+        required.push(key);
+      }
+    }
+    const schema = {
+      type: "object",
+      properties
+    };
+    if (required.length)
+      schema.required = required;
+    return schema;
+  }
 }
 function object(element) {
   return new ArcObject(element);
@@ -529,6 +572,12 @@ class ArcArray extends ArcAbstract {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return {
+      type: "array",
+      items: this.parent.toJsonSchema?.() ?? {}
+    };
+  }
 }
 function array(element) {
   return new ArcArray(element);
@@ -620,6 +669,13 @@ class ArcBlob extends ArcPrimitive {
     }
     throw new Error("Expected Blob object");
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      contentEncoding: "base64",
+      contentMediaType: "application/octet-stream"
+    };
+  }
 }
 function blob() {
   return new ArcBlob;
@@ -638,6 +694,9 @@ class ArcBoolean extends ArcPrimitive {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return { type: "boolean" };
+  }
 }
 function boolean() {
   return new ArcBoolean;
@@ -677,6 +736,12 @@ class ArcDate extends ArcAbstract {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      format: "date-time"
+    };
+  }
 }
 function date() {
   return new ArcDate;
@@ -844,6 +909,13 @@ class ArcFile extends ArcPrimitive {
     }
     throw new Error("Expected File object");
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      contentEncoding: "base64",
+      contentMediaType: "application/octet-stream"
+    };
+  }
 }
 function file() {
   return new ArcFile;
@@ -871,10 +943,65 @@ class ArcNumber extends ArcPrimitive {
     const instance = this.pipeValidation(name, validator);
     return instance;
   }
+  toJsonSchema() {
+    return { type: "number" };
+  }
 }
 function number() {
   return new ArcNumber;
 }
+// elements/or.ts
+class ArcOr {
+  elements;
+  constructor(elements) {
+    this.elements = elements;
+  }
+  serialize(value) {
+    const element = this.pickElement(value);
+    return element.serialize(value);
+  }
+  deserialize(value) {
+    const element = this.pickElement(value);
+    return element.deserialize(value);
+  }
+  parse(value) {
+    const element = this.pickElement(value);
+    return element.parse(value);
+  }
+  validate(value) {
+    const errors = this.elements.reduce((acc, element, idx) => {
+      const err = element.validate(value);
+      if (err)
+        acc[idx] = err;
+      return acc;
+    }, {});
+    if (Object.keys(errors).length !== this.elements.length)
+      return false;
+    return errors;
+  }
+  toJsonSchema() {
+    return {
+      anyOf: this.elements.map((el) => el.toJsonSchema?.() ?? {})
+    };
+  }
+  pickElement(value) {
+    for (const element of this.elements) {
+      if (this.isTypeOf(element, value))
+        return element;
+    }
+    throw new Error("Unable to match value with any of the provided elements for ArcOr");
+  }
+  isTypeOf(element, value) {
+    try {
+      return element.validate(value) === false;
+    } catch {
+      return false;
+    }
+  }
+}
+function or(...elements) {
+  return new ArcOr(elements);
+}
 // elements/record.ts
 class ArcRecord extends ArcAbstract {
   key;
@@ -925,6 +1052,13 @@ class ArcRecord extends ArcAbstract {
       return acc;
     }, {});
   }
+  toJsonSchema() {
+    return {
+      type: "object",
+      propertyNames: this.key.toJsonSchema?.() ?? {},
+      additionalProperties: this.element.toJsonSchema?.() ?? {}
+    };
+  }
 }
 function record(key, element) {
   return new ArcRecord(key, element);
@@ -954,6 +1088,12 @@ class ArcStringEnum extends ArcAbstract {
   deserialize(value) {
     return value;
   }
+  toJsonSchema() {
+    return {
+      type: "string",
+      enum: this.values
+    };
+  }
   getEnumerators() {
     return this.values;
   }
@@ -1364,6 +1504,18 @@ class ArcCommand extends ArcContextElement {
     clone._isPublic = this._isPublic;
     return clone;
   }
+  toJsonSchema() {
+    const parametersSchema = this._params ? this._params.toJsonSchema?.() ?? {
+      type: "object",
+      properties: {}
+    } : { type: "object", properties: {} };
+    return {
+      type: "function",
+      name: this.name,
+      description: this._description ?? undefined,
+      parameters: parametersSchema
+    };
+  }
 }
 function command(name) {
   return new ArcCommand(name);
@@ -1426,6 +1578,18 @@ class ArcContext {
         if (name === "$auth") {
           return authContext;
         }
+        if (name === "get") {
+          return (e) => {
+            const element3 = this.elements.find((element4) => element4.name === e.name);
+            if (!element3) {
+              throw new Error(`Element "${String(name)}" not found`);
+            }
+            if (!element3.commandContext) {
+              throw new Error(`Element "${String(name)}" does not have a command context`);
+            }
+            return element3.commandContext(dataStorage, publishEvent, authContext);
+          };
+        }
         const element2 = this.elements.find((element3) => element3.name === name);
         if (!element2) {
           throw new Error(`Element "${String(name)}" not found`);
@@ -1438,15 +1602,14 @@ class ArcContext {
     });
   }
 }
-async function context(elementsPromise) {
-  const elements = await Promise.all(elementsPromise.map(async (element2) => {
-    if (element2 instanceof Promise) {
-      return (await element2).default;
-    }
-    return element2;
-  })).then((elements2) => elements2.filter(Boolean));
+function context(elements) {
   return new ArcContext(elements);
 }
+function contextMerge(...contexts) {
+  return new ArcContext([
+    ...contexts.map((context2) => context2.elements).flat()
+  ]);
+}
 // context/event.ts
 var eventValidator = typeValidatorBuilder("object");
 var eventStoreSchema = {
@@ -2371,6 +2534,18 @@ class ArcListener extends ArcContextElement {
               if (name === "$auth") {
                 return authContext;
               }
+              if (name === "get") {
+                return (e) => {
+                  const element4 = this._elements.find((element5) => element5.name === e.name);
+                  if (!element4) {
+                    throw new Error(`Element "${String(name)}" not found in listener "${this.name}"`);
+                  }
+                  if (!element4.commandContext) {
+                    throw new Error(`Element "${String(name)}" does not have a command context`);
+                  }
+                  return element4.commandContext(dataStorage, publishEvent, authContext);
+                };
+              }
               const element3 = this._elements.find((element4) => element4.name === name);
               if (!element3) {
                 throw new Error(`Element "${String(name)}" not found in listener "${this.name}"`);
@@ -2712,7 +2887,10 @@ class RemoteModelClient extends ModelBase {
     const result = this.query(queryBuilderFn, authContext);
     result.then((initialResult) => {
       callback(initialResult);
-    }).catch(this.catchErrorCallback);
+    }).catch((error) => {
+      console.error("Error in subscribe", error);
+      callback(null);
+    });
     return {
       unsubscribe: () => {},
       result
@@ -3160,6 +3338,14 @@ class ArcView extends ArcContextElementWithStore {
     clone._handler = handler;
     return clone;
   }
+  handleEvent(event3, handler) {
+    const clone = this.clone();
+    clone._handler = {
+      ...clone._handler ?? {},
+      [event3.name]: handler
+    };
+    return clone;
+  }
   applyRestrictions(authContext, options) {
     if (!this.restrictions) {
       return options;
@@ -3282,6 +3468,7 @@ export {
   route,
   record,
   reactive,
+  or,
   object,
   number,
   listener,
@@ -3292,12 +3479,14 @@ export {
   date,
   customId,
   createSQLiteAdapterFactory,
+  contextMerge,
   context,
   command,
   collection,
   boolean,
   blob,
   array,
+  arcObjectToStoreSchema,
   any,
   StoreState,
   SQLiteAdapter,
@@ -3318,6 +3507,7 @@ export {
   ArcRecord,
   ArcQueryBuilder,
   ArcQuery,
+  ArcOr,
   ArcOptional,
   ArcObject,
   ArcNumber,

package/dist/utils/index.d.ts

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

package/dist/utils.d.ts

@@ -1,6 +1,7 @@
 import type { ArcCollectionAny, CollectionItem } from "./collection/collection";
 import type { QueryCollectionResult } from "./collection/queries/find";
 import type { ArcElement } from "./elements/element";
+export * from "./utils/index";
 export declare namespace objectUtil {
     export type MergeShapes<U, V> = {
         [k in Exclude<keyof U, keyof V>]: U[k];

package/dist/view/view.d.ts

@@ -1,9 +1,10 @@
+import type { ArcEventAny, ArcEventInstance } from "../context";
 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, WhereCondition } from "../data-storage/types";
 import { type ArcIdAny, type ArcObjectAny } from "../elements";
-import type { $type } from "../utils";
+import type { $type, objectUtil } from "../utils";
 import { ArcViewFindQueryBuilder } from "./query-builders/find";
 import { ArcViewFindOneQueryBuilder } from "./query-builders/find-one";
 type GetEvents<Elements extends ArcContextElementAny[]> = Elements[number]["$event"];
@@ -19,8 +20,9 @@ type ArcViewItem<Id extends ArcIdAny, Schema extends ArcObjectAny> = {
     _id: $type<Id>;
 } & $type<Schema>;
 type ArcViewHandler<Elements extends ArcContextElementAny[], Id extends ArcIdAny, Schema extends ArcObjectAny> = {
-    [Event in GetEvents<Elements> as Event["type"]]: (ctx: ArcViewHandlerContext<Id, Schema>, event: Event) => Promise<void>;
+    [Event in GetEvents<Elements> as Event["type"]]: ArcViewEventHandler<Id, Schema, Event>;
 };
+type ArcViewEventHandler<Id extends ArcIdAny, Schema extends ArcObjectAny, Event extends any> = (ctx: ArcViewHandlerContext<Id, Schema>, event: Event) => Promise<void>;
 export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema extends ArcObjectAny, const Elements extends ArcContextElementAny[]> extends ArcContextElementWithStore<null, Name> {
     readonly name: Name;
     readonly id: Id;
@@ -41,6 +43,7 @@ export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema ex
     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>;
+    handleEvent<Event extends ArcEventAny>(event: Event, handler: ArcViewEventHandler<Id, Schema, ArcEventInstance<Event>>): ArcView<Name, Id, Schema, [...Elements, Event]>;
     /**
      * Helper function to merge where conditions from restrictions with query options
      */
@@ -57,5 +60,6 @@ export declare class ArcView<Name extends string, Id extends ArcIdAny, Schema ex
     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[]>;
+export type ArcViewRecord<View extends ArcView<any, any, any, any>> = objectUtil.simplify<ArcViewItem<View["id"], View["schema"]>>;
 export {};
 //# sourceMappingURL=view.d.ts.map

package/package.json

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