@telorun/http-server 0.3.4 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # @telorun/http-server
 
+## 0.4.0
+
+### Minor Changes
+
+- 0f80fc5: `Bench.Suite.scenarios[*]` and `Http.Server.notFoundHandler` follow the canonical sibling shape: `invoke:` describes the dispatch target only; `inputs:` carries the call-time arguments as a sibling. The previously-accepted nested `invoke.inputs` form is gone — the benchmark runtime now reads `scenario.inputs` and the http-server runtime now reads `notFoundHandler.inputs`. Five benchmark manifests, one example, and `apps/registry/telo.yaml` migrated to the sibling form.
+
+  Statically validate CEL expressions inside `Telo.Definition` template bodies. The analyzer now registers `self` (typed from the definition's `schema:`) and `inputs` (typed from `inputType:`, falling back to the `extends:`-declared abstract's `inputType:`) as available variables in `resources:` / `invoke:` / `run:` / `provide:` / top-level `inputs:` / top-level `result:` fields, catching typos at load time instead of first invocation.
+
+  Aligns Telo.Definition's template-body shape with how Run.Sequence steps factor dispatch from data: `invoke:` / `provide:` / `run:` describe the dispatch target only; `inputs:` (values passed to the target) and `result:` (provide-only post-call mapping) live as top-level siblings on the definition. The previous nested `invoke.inputs` shape is gone — the kernel template controller now reads `definition.inputs`, and `modules/sql-repository/Read` migrates to the sibling form.
+
+  Inside top-level `result:`, the `result` CEL variable is typed from the dispatch target's `outputType:`. The produced top-level `result` value is also AJV-checked against the abstract this definition `extends` (`outputType`); top-level `inputs` is AJV-checked against the dispatch target's `inputType` when declared. Mismatches surface as a new `TEMPLATE_TARGET_MISMATCH` diagnostic.
+
+  Adds two reusable context-annotation forms used by the `Telo.Definition` builtin schema and available to any module that needs the same capabilities:
+
+  - `x-telo-context-from-root: "<path>"` — root-anchored navigation (replace semantics), used to type variables sourced from a top-level field regardless of where the CEL appears.
+  - `x-telo-context-from-ref-kind: "<refPath>#<field>"` — reads a kind name from `manifestRoot.<refPath>`, resolves it via the definition registry, and returns that kind's `<field>` schema.
+
+  Schema-extracted contexts are now sorted by scope specificity (longest first) so the first-match-wins resolver picks the most-specific context. No existing module relied on the previous ordering (no overlapping scopes), so this change is observably backward-compatible.
+
 ## 0.3.4
 
 ### Patch Changes

package/dist/http-server-controller.d.ts

@@ -36,6 +36,7 @@ type HttpServerResource = RuntimeResource & {
     }>;
     notFoundHandler?: {
         invoke: KindRef<Invocable>;
+        inputs?: Record<string, unknown>;
         returns?: ReturnEntry[];
         catches?: CatchEntry[];
     };

package/dist/http-server-controller.js

@@ -138,9 +138,22 @@ class HttpServer {
                 };
                 const acceptHeader = request.headers["accept"]?.toString();
                 const sink = fastifyReplySink(reply);
+                // Expand the `inputs:` sibling template against the request context,
+                // then pass the merged shape (spread for convenience + `inputs:` field
+                // for handlers that read it explicitly) to the dispatch target. Same
+                // contract Api.routes[*] uses. When no `inputs:` is declared, the
+                // request context itself is forwarded so existing manifests that read
+                // `request.*` directly continue to work.
+                const resolvedInputs = handler.inputs && Object.keys(handler.inputs).length > 0
+                    ? (this.ctx.moduleContext.expandWith(handler.inputs, requestContext) ?? {})
+                    : requestContext;
+                const invokeInput = {
+                    ...resolvedInputs,
+                    inputs: resolvedInputs,
+                };
                 let result;
                 try {
-                    result = await this.ctx.invoke(handler.kind, handler.name, requestContext);
+                    result = await this.ctx.invoke(handler.kind, handler.name, invokeInput);
                 }
                 catch (err) {
                     if (!isInvokeError(err))
@@ -206,7 +219,7 @@ export async function create(resource, ctx) {
         resolvedNotFoundHandler = {
             kind,
             name,
-            inputs: invoke?.inputs ?? {},
+            inputs: resource.notFoundHandler.inputs ?? {},
             returns: resource.notFoundHandler.returns,
             catches: resource.notFoundHandler.catches,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/http-server",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "description": "Telo HTTP Server module - HTTP server and API resource kinds for Telo manifests.",
   "keywords": [
     "telo",

package/src/http-server-controller.ts

@@ -54,6 +54,7 @@ type HttpServerResource = RuntimeResource & {
   }>;
   notFoundHandler?: {
     invoke: KindRef<Invocable>;
+    inputs?: Record<string, unknown>;
     returns?: ReturnEntry[];
     catches?: CatchEntry[];
   };
@@ -221,9 +222,24 @@ class HttpServer implements ResourceInstance {
 
         const sink = fastifyReplySink(reply);
 
+        // Expand the `inputs:` sibling template against the request context,
+        // then pass the merged shape (spread for convenience + `inputs:` field
+        // for handlers that read it explicitly) to the dispatch target. Same
+        // contract Api.routes[*] uses. When no `inputs:` is declared, the
+        // request context itself is forwarded so existing manifests that read
+        // `request.*` directly continue to work.
+        const resolvedInputs: Record<string, any> =
+          handler.inputs && Object.keys(handler.inputs).length > 0
+            ? ((this.ctx.moduleContext.expandWith(handler.inputs, requestContext) as any) ?? {})
+            : requestContext;
+        const invokeInput: Record<string, any> = {
+          ...resolvedInputs,
+          inputs: resolvedInputs,
+        };
+
         let result: any;
         try {
-          result = await this.ctx.invoke(handler.kind, handler.name, requestContext);
+          result = await this.ctx.invoke(handler.kind, handler.name, invokeInput);
         } catch (err) {
           if (!isInvokeError(err)) throw err;
           return dispatchCatches(
@@ -310,7 +326,7 @@ export async function create(
     resolvedNotFoundHandler = {
       kind,
       name,
-      inputs: (invoke as any)?.inputs ?? {},
+      inputs: resource.notFoundHandler.inputs ?? {},
       returns: resource.notFoundHandler.returns,
       catches: resource.notFoundHandler.catches,
     };