@arcote.tech/arc 0.4.10 → 0.5.1

package/dist/index.js

@@ -1697,6 +1697,165 @@ function event(name, payload) {
   });
 }
 
+// src/context-element/element-context.ts
+function buildElementContext(queryElements, mutationElements, adapters) {
+  const queryMap = new Map;
+  const mutateMap = new Map;
+  const queryProps = {};
+  for (const element of queryElements) {
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      queryProps[element.name] = ctx;
+      queryMap.set(element, ctx);
+    }
+  }
+  const mutateProps = {};
+  for (const element of mutationElements) {
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      mutateProps[element.name] = ctx;
+      mutateMap.set(element, ctx);
+    }
+  }
+  const queryFn = (element) => {
+    const cached = queryMap.get(element);
+    if (cached)
+      return cached;
+    if (element.queryContext) {
+      const ctx = element.queryContext(adapters);
+      queryMap.set(element, ctx);
+      return ctx;
+    }
+    throw new Error(`Element "${element.name}" has no queryContext`);
+  };
+  Object.assign(queryFn, queryProps);
+  const mutateFn = (element) => {
+    const cached = mutateMap.get(element);
+    if (cached)
+      return cached;
+    if (element.mutateContext) {
+      const ctx = element.mutateContext(adapters);
+      mutateMap.set(element, ctx);
+      return ctx;
+    }
+    throw new Error(`Element "${element.name}" has no mutateContext`);
+  };
+  Object.assign(mutateFn, mutateProps);
+  return {
+    query: queryFn,
+    mutate: mutateFn
+  };
+}
+
+// src/context-element/function/arc-function.ts
+class ArcFunction {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+  withParams(schema) {
+    return new ArcFunction({
+      ...this.data,
+      params: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    });
+  }
+  withResult(schema) {
+    return new ArcFunction({
+      ...this.data,
+      result: schema instanceof ArcObject ? schema : new ArcObject(schema)
+    });
+  }
+  query(elements) {
+    return new ArcFunction({
+      ...this.data,
+      queryElements: elements
+    });
+  }
+  mutate(elements) {
+    return new ArcFunction({
+      ...this.data,
+      mutationElements: elements
+    });
+  }
+  protectedBy(token, check) {
+    const existingProtections = this.data.protections || [];
+    return new ArcFunction({
+      ...this.data,
+      protections: [...existingProtections, { token, check }]
+    });
+  }
+  description(desc) {
+    return new ArcFunction({
+      ...this.data,
+      description: desc
+    });
+  }
+  handle(handler) {
+    return new ArcFunction({
+      ...this.data,
+      handler
+    });
+  }
+  get isPublic() {
+    return !this.hasProtections;
+  }
+  get hasProtections() {
+    return (this.data.protections?.length ?? 0) > 0;
+  }
+  get protections() {
+    return this.data.protections || [];
+  }
+  get handler() {
+    return this.data.handler;
+  }
+  get params() {
+    return this.data.params;
+  }
+  get result() {
+    return this.data.result;
+  }
+  async verifyProtections(tokens) {
+    if (!this.data.protections || this.data.protections.length === 0) {
+      return true;
+    }
+    for (const protection of this.data.protections) {
+      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
+      if (!tokenInstance) {
+        return false;
+      }
+      const result = await protection.check(tokenInstance);
+      if (result === false) {
+        return false;
+      }
+    }
+    return true;
+  }
+  buildContext(adapters) {
+    return buildElementContext(this.data.queryElements || [], this.data.mutationElements || [], adapters);
+  }
+  toJsonSchema() {
+    return {
+      params: this.data.params?.toJsonSchema?.() ?? null,
+      result: this.data.result?.toJsonSchema?.() ?? null
+    };
+  }
+}
+var defaultFunctionData = {
+  params: null,
+  result: null,
+  queryElements: [],
+  mutationElements: [],
+  protections: [],
+  handler: null,
+  description: undefined
+};
+function arcFunction() {
+  return new ArcFunction(defaultFunctionData);
+}
+function arcFunctionWithCtx() {
+  return new ArcFunction(defaultFunctionData);
+}
+
 // src/context-element/aggregate/aggregate-base.ts
 class AggregateBase {
   value;
@@ -1797,12 +1956,13 @@ class ArcAggregateElement extends ArcContextElement {
     };
     return new ArcAggregateElement(this.name, this._id_factory, this.schema, [...this._events, entry], this._protections, this._mutateMethods, this._queryMethods, this._seeds);
   }
-  mutateMethod(methodName, config, handler) {
-    const paramsObj = config.params instanceof ArcObject ? config.params : new ArcObject(config.params);
+  mutateMethod(methodName, configure) {
+    const baseFn = arcFunctionWithCtx();
+    const configuredFn = configure(baseFn);
     const entry = {
       name: methodName,
-      params: paramsObj,
-      handler
+      params: configuredFn.data.params,
+      handler: configuredFn.data.handler
     };
     return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, this._protections, [...this._mutateMethods, entry], this._queryMethods, this._seeds);
   }
@@ -1811,13 +1971,18 @@ class ArcAggregateElement extends ArcContextElement {
       throw new Error("cron() must be called immediately after mutateMethod()");
     }
     const methods = [...this._mutateMethods];
-    methods[methods.length - 1] = { ...methods[methods.length - 1], cronExpression: expression };
+    methods[methods.length - 1] = {
+      ...methods[methods.length - 1],
+      cronExpression: expression
+    };
     return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, this._protections, methods, this._queryMethods, this._seeds);
   }
-  clientQuery(methodName, handler) {
+  clientQuery(methodName, configure) {
+    const baseFn = arcFunctionWithCtx();
+    const configuredFn = configure(baseFn);
     const entry = {
       name: methodName,
-      handler
+      handler: configuredFn.data.handler
     };
     return new ArcAggregateElement(this.name, this._id_factory, this.schema, this._events, this._protections, this._mutateMethods, [...this._queryMethods, entry], this._seeds);
   }
@@ -1862,16 +2027,21 @@ class ArcAggregateElement extends ArcContextElement {
       static __aggregateCronMethods = cronMethods;
       static getEvent(eventName) {
         const entry = events.find((e) => e.isPublic && e.event.name === eventName);
-        return entry?.event;
+        if (!entry)
+          return;
+        return Object.assign(Object.create(Object.getPrototypeOf(entry.event)), entry.event, { name: `${name}.${entry.event.name}` });
       }
     };
-    Object.defineProperty(AggregateClass, "name", { value: `${name}Aggregate` });
+    Object.defineProperty(AggregateClass, "name", {
+      value: `${name}Aggregate`
+    });
     return AggregateClass;
   }
   getHandlers() {
     const handlers = {};
     for (const entry of this._events) {
-      handlers[entry.event.name] = entry.handler;
+      const key = entry.isInline ? `${this.name}.${entry.event.name}` : entry.event.name;
+      handlers[key] = entry.handler;
     }
     return handlers;
   }
@@ -1880,7 +2050,9 @@ class ArcAggregateElement extends ArcContextElement {
   }
   getEvent(eventName) {
     const entry = this._events.find((e) => e.isPublic && e.event.name === eventName);
-    return entry?.event;
+    if (!entry)
+      return;
+    return Object.assign(Object.create(Object.getPrototypeOf(entry.event)), entry.event, { name: `${this.name}.${entry.event.name}` });
   }
   get cronMethods() {
     const result = [];
@@ -1901,9 +2073,16 @@ class ArcAggregateElement extends ArcContextElement {
     const AggCtor = this.Aggregate;
     const result = {};
     for (const method of this._queryMethods) {
+      if (!method.handler)
+        continue;
+      const handler = method.handler;
       result[method.name] = (...args) => {
-        const ctx = { $query: privateQuery, $auth: auth, Aggregate: AggCtor };
-        return method.handler(ctx, ...args);
+        const ctx = {
+          $query: privateQuery,
+          $auth: auth,
+          Aggregate: AggCtor
+        };
+        return handler(ctx, ...args);
       };
     }
     return result;
@@ -2020,13 +2199,15 @@ class ArcAggregateElement extends ArcContextElement {
       const ctx = {};
       for (const entry of events) {
         const arcEvent = entry.event;
+        if (!entry.isInline)
+          continue;
         ctx[arcEvent.name] = {
           emit: async (payload) => {
             if (!adapters.eventPublisher) {
               throw new Error(`Cannot emit event "${arcEvent.name}": no eventPublisher adapter available`);
             }
             const eventInstance = {
-              type: arcEvent.name,
+              type: `${aggregateName}.${arcEvent.name}`,
               payload,
               id: `${Date.now()}_${Math.random().toString(36).slice(2)}`,
               createdAt: new Date
@@ -2046,7 +2227,10 @@ class ArcAggregateElement extends ArcContextElement {
           if (!adapters.commandWire) {
             throw new Error(`Method "${method.name}" is server-only but no commandWire (WebSocket) is available.`);
           }
-          const wireAuth = adapters.scope ? { scope: adapters.scope.scopeName, token: adapters.scope.getToken() } : undefined;
+          const wireAuth = adapters.scope ? {
+            scope: adapters.scope.scopeName,
+            token: adapters.scope.getToken()
+          } : undefined;
           return adapters.commandWire.executeCommand(`${aggregateName}.${method.name}`, params, wireAuth);
         }
         const ctx = buildMutateMethodCtx();
@@ -2078,129 +2262,71 @@ function aggregate(name, id2, schema) {
   const schemaObj = schema instanceof ArcObject ? schema : new ArcObject(schema);
   return new ArcAggregateElement(name, id2, schemaObj);
 }
-// src/context-element/element-context.ts
-function buildElementContext(queryElements, mutationElements, adapters) {
-  const context2 = {};
-  const elementMap = new Map;
-  for (const element of queryElements) {
-    if (element.queryContext) {
-      const ctx = element.queryContext(adapters);
-      context2[element.name] = ctx;
-      elementMap.set(element, ctx);
-    }
-  }
-  for (const element of mutationElements) {
-    if (element.mutateContext) {
-      const ctx = element.mutateContext(adapters);
-      context2[element.name] = ctx;
-      elementMap.set(element, ctx);
-    }
-  }
-  context2.get = (element) => {
-    const cached = elementMap.get(element);
-    if (cached)
-      return cached;
-    if (element.queryContext) {
-      const ctx = element.queryContext(adapters);
-      elementMap.set(element, ctx);
-      return ctx;
-    }
-    if (element.mutateContext) {
-      const ctx = element.mutateContext(adapters);
-      elementMap.set(element, ctx);
-      return ctx;
-    }
-    throw new Error(`Element "${element.name}" has no context available`);
-  };
-  context2.query = (element) => {
-    if (!element.queryContext) {
-      throw new Error(`Element "${element.name}" has no queryContext`);
-    }
-    return element.queryContext(adapters);
-  };
-  context2.mutate = (element) => {
-    if (!element.mutateContext) {
-      throw new Error(`Element "${element.name}" has no mutateContext`);
-    }
-    return element.mutateContext(adapters);
-  };
-  return context2;
-}
-
 // src/context-element/command/command.ts
 class ArcCommand extends ArcContextElement {
   data;
-  constructor(data) {
+  #fn;
+  constructor(data, fn) {
     super(data.name);
     this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: data.params,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: data.protections || [],
+      handler: data.handler ?? null,
+      description: data.description
+    });
   }
   description(description) {
-    return new ArcCommand({
-      ...this.data,
-      description
-    });
+    const newFn = this.#fn.description(description);
+    return new ArcCommand({ ...this.data, description }, newFn);
   }
   get isPublic() {
-    return !this.hasProtections;
+    return this.#fn.isPublic;
   }
   query(elements) {
-    return new ArcCommand({
-      ...this.data,
-      queryElements: elements
-    });
+    const newFn = this.#fn.query(elements);
+    return new ArcCommand({ ...this.data, queryElements: elements }, newFn);
   }
   mutate(elements) {
-    return new ArcCommand({
-      ...this.data,
-      mutationElements: elements
-    });
+    const newFn = this.#fn.mutate(elements);
+    return new ArcCommand({ ...this.data, mutationElements: elements }, newFn);
   }
   withParams(schema) {
+    const newFn = this.#fn.withParams(schema);
     return new ArcCommand({
       ...this.data,
       params: schema instanceof ArcObject ? schema : new ArcObject(schema)
-    });
+    }, newFn);
   }
   withResult(...schemas) {
-    return new ArcCommand({
-      ...this.data,
-      results: schemas
-    });
+    return new ArcCommand({ ...this.data, results: schemas }, this.#fn);
   }
   handle(handler) {
-    return new ArcCommand({
-      ...this.data,
+    const newFn = new ArcFunction({
+      ...this.#fn.data,
       handler
     });
+    return new ArcCommand({ ...this.data, handler }, newFn);
   }
   protectBy(token, check) {
+    const newFn = this.#fn.protectedBy(token, check);
     const existingProtections = this.data.protections || [];
     return new ArcCommand({
       ...this.data,
       protections: [...existingProtections, { token, check }]
-    });
+    }, newFn);
   }
   get hasProtections() {
-    return (this.data.protections?.length ?? 0) > 0;
+    return this.#fn.hasProtections;
   }
   get protections() {
-    return this.data.protections || [];
+    return this.#fn.protections;
   }
   async verifyProtections(tokens) {
-    if (!this.data.protections || this.data.protections.length === 0) {
-      return true;
-    }
-    for (const protection of this.data.protections) {
-      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
-      if (!tokenInstance) {
-        return false;
-      }
-      const allowed = await protection.check(tokenInstance);
-      if (!allowed) {
-        return false;
-      }
-    }
-    return true;
+    return this.#fn.verifyProtections(tokens);
   }
   async init(environment, adapters) {
     if (environment === "server" && this.data.handler && adapters.commandWire?.registerCommandHandler) {
@@ -2227,12 +2353,11 @@ class ArcCommand extends ArcContextElement {
       throw new Error(`Command "${this.data.name}" has no handler`);
     }
     const context2 = this.buildCommandContext(adapters);
-    const result = await this.data.handler(context2, params);
-    return result;
+    return await this.data.handler(context2, params);
   }
   buildCommandContext(adapters) {
-    const context2 = buildElementContext(this.data.queryElements, this.data.mutationElements, adapters);
-    if (this.hasProtections && adapters.authAdapter) {
+    const context2 = this.#fn.buildContext(adapters);
+    if (this.#fn.hasProtections && adapters.authAdapter) {
       const decoded = adapters.authAdapter.getDecoded();
       if (decoded) {
         context2.$auth = {
@@ -2272,46 +2397,41 @@ function command(name) {
 // src/context-element/listener/listener.ts
 class ArcListener extends ArcContextElement {
   data;
+  #fn;
   unsubscribers = [];
-  constructor(data) {
+  constructor(data, fn) {
     super(data.name);
     this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: null,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: [],
+      handler: null,
+      description: data.description
+    });
   }
   description(description) {
-    return new ArcListener({
-      ...this.data,
-      description
-    });
+    const newFn = this.#fn.description(description);
+    return new ArcListener({ ...this.data, description }, newFn);
   }
   listenTo(events) {
-    return new ArcListener({
-      ...this.data,
-      eventElements: events
-    });
+    return new ArcListener({ ...this.data, eventElements: events }, this.#fn);
   }
   query(elements) {
-    return new ArcListener({
-      ...this.data,
-      queryElements: elements
-    });
+    const newFn = this.#fn.query(elements);
+    return new ArcListener({ ...this.data, queryElements: elements }, newFn);
   }
   mutate(elements) {
-    return new ArcListener({
-      ...this.data,
-      mutationElements: elements
-    });
+    const newFn = this.#fn.mutate(elements);
+    return new ArcListener({ ...this.data, mutationElements: elements }, newFn);
   }
   async() {
-    return new ArcListener({
-      ...this.data,
-      isAsync: true
-    });
+    return new ArcListener({ ...this.data, isAsync: true }, this.#fn);
   }
   handle(handler) {
-    return new ArcListener({
-      ...this.data,
-      handler
-    });
+    return new ArcListener({ ...this.data, handler }, this.#fn);
   }
   get eventElements() {
     return this.data.eventElements || [];
@@ -2341,48 +2461,7 @@ class ArcListener extends ArcContextElement {
   async handleEvent(event2, adapters) {
     if (!this.data.handler)
       return;
-    const context2 = this.buildListenerContext(adapters);
-    if (this.data.isAsync) {
-      Promise.resolve(this.data.handler(context2, event2)).catch((error) => {
-        console.error(`Async listener "${this.data.name}" error:`, error);
-      });
-    } else {
-      await this.data.handler(context2, event2);
-    }
-  }
-  buildListenerContext(adapters) {
-    const context2 = {};
-    const elementMap = new Map;
-    for (const element of this.data.queryElements) {
-      if (element.queryContext) {
-        const elementContext = element.queryContext(adapters);
-        context2[element.name] = elementContext;
-        elementMap.set(element, elementContext);
-      }
-    }
-    for (const element of this.data.mutationElements) {
-      if (element.mutateContext) {
-        const elementContext = element.mutateContext(adapters);
-        context2[element.name] = elementContext;
-        elementMap.set(element, elementContext);
-      }
-    }
-    context2.get = (element) => {
-      const cached = elementMap.get(element);
-      if (cached)
-        return cached;
-      if (element.queryContext) {
-        const ctx = element.queryContext(adapters);
-        elementMap.set(element, ctx);
-        return ctx;
-      }
-      if (element.mutateContext) {
-        const ctx = element.mutateContext(adapters);
-        elementMap.set(element, ctx);
-        return ctx;
-      }
-      throw new Error(`Element "${element.name}" has no context available`);
-    };
+    const context2 = this.#fn.buildContext(adapters);
     if (adapters.authAdapter) {
       const decoded = adapters.authAdapter.getDecoded();
       if (decoded) {
@@ -2392,7 +2471,13 @@ class ArcListener extends ArcContextElement {
         };
       }
     }
-    return context2;
+    if (this.data.isAsync) {
+      Promise.resolve(this.data.handler(context2, event2)).catch((error) => {
+        console.error(`Async listener "${this.data.name}" error:`, error);
+      });
+    } else {
+      await this.data.handler(context2, event2);
+    }
   }
   destroy() {
     for (const unsubscribe of this.unsubscribers) {
@@ -2413,52 +2498,48 @@ function listener(name) {
 // src/context-element/route/route.ts
 class ArcRoute extends ArcContextElement {
   data;
-  constructor(data) {
+  #fn;
+  constructor(data, fn) {
     super(data.name);
     this.data = data;
+    this.#fn = fn ?? new ArcFunction({
+      params: null,
+      result: null,
+      queryElements: data.queryElements,
+      mutationElements: data.mutationElements,
+      protections: data.protections || [],
+      handler: null,
+      description: data.description
+    });
   }
   description(description) {
-    return new ArcRoute({
-      ...this.data,
-      description
-    });
+    const newFn = this.#fn.description(description);
+    return new ArcRoute({ ...this.data, description }, newFn);
   }
   path(path) {
-    return new ArcRoute({
-      ...this.data,
-      path
-    });
+    return new ArcRoute({ ...this.data, path }, this.#fn);
   }
   public() {
-    return new ArcRoute({
-      ...this.data,
-      isPublic: true
-    });
+    return new ArcRoute({ ...this.data, isPublic: true }, this.#fn);
   }
   query(elements) {
-    return new ArcRoute({
-      ...this.data,
-      queryElements: elements
-    });
+    const newFn = this.#fn.query(elements);
+    return new ArcRoute({ ...this.data, queryElements: elements }, newFn);
   }
   mutate(elements) {
-    return new ArcRoute({
-      ...this.data,
-      mutationElements: elements
-    });
+    const newFn = this.#fn.mutate(elements);
+    return new ArcRoute({ ...this.data, mutationElements: elements }, newFn);
   }
   protectBy(token, check) {
+    const newFn = this.#fn.protectedBy(token, check);
     const existingProtections = this.data.protections || [];
     return new ArcRoute({
       ...this.data,
       protections: [...existingProtections, { token, check }]
-    });
+    }, newFn);
   }
   handle(handlers) {
-    return new ArcRoute({
-      ...this.data,
-      handlers
-    });
+    return new ArcRoute({ ...this.data, handlers }, this.#fn);
   }
   get routePath() {
     return this.data.path || `/${this.data.name}`;
@@ -2470,7 +2551,7 @@ class ArcRoute extends ArcContextElement {
     return this.data.isPublic;
   }
   get hasProtections() {
-    return (this.data.protections?.length ?? 0) > 0;
+    return this.#fn.hasProtections;
   }
   get protections() {
     return this.data.protections || [];
@@ -2502,23 +2583,10 @@ class ArcRoute extends ArcContextElement {
     if (this.data.isPublic) {
       return true;
     }
-    if (!this.data.protections || this.data.protections.length === 0) {
-      return true;
-    }
-    for (const protection of this.data.protections) {
-      const tokenInstance = tokens.find((t) => t.getTokenDefinition() === protection.token);
-      if (!tokenInstance) {
-        return false;
-      }
-      const allowed = await protection.check(tokenInstance);
-      if (!allowed) {
-        return false;
-      }
-    }
-    return true;
+    return this.#fn.verifyProtections(tokens);
   }
   buildContext(adapters, authParams) {
-    const context2 = buildElementContext(this.data.queryElements, this.data.mutationElements, adapters);
+    const context2 = this.#fn.buildContext(adapters);
     if (authParams) {
       context2.$auth = authParams;
     }
@@ -2972,6 +3040,8 @@ function deepMerge(target, source) {
 function isPlainObject(item) {
   return item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date) && Object.prototype.toString.call(item) === "[object Object]";
 }
+// src/utils/merge-unsafe.ts
+var mergeUnsafe = (schema, unsafeSchema) => Object.assign({}, schema, unsafeSchema);
 // src/utils/murmur-hash.ts
 function murmurHash(key, seed = 0) {
   let remainder, bytes, h1, h1b, c1, c2, k1, i;
@@ -5010,12 +5080,14 @@ export {
   number,
   mutationExecutor,
   murmurHash,
+  mergeUnsafe,
   listener,
   id,
   file,
   extractDatabaseAgnosticSchema,
   executeDescriptor,
   event,
+  defaultFunctionData,
   deepMerge,
   date,
   customId,
@@ -5028,6 +5100,8 @@ export {
   boolean,
   blob,
   array,
+  arcFunctionWithCtx,
+  arcFunction,
   applyOrderByAndLimit,
   any,
   aggregate,
@@ -5066,6 +5140,7 @@ export {
   ArcNumber,
   ArcListener,
   ArcId,
+  ArcFunction,
   ArcFragmentBase,
   ArcFile,
   ArcEvent,