typespec-hono 0.12.0 → 0.13.1

package/dist/src/app.js

@@ -196,7 +196,31 @@ function rawBodyReaderFor(contentTypes) {
  * interface would be a second source of truth that drifts.
  */
 function inputTypeOf(entry) {
-    const parts = entry.validators.map(([, name]) => `z.infer<typeof ${name}>`);
+    /**
+     * **A body the document says must not be flattened is NAMED, not intersected.**
+     *
+     * `EmittedRoute.bodyProperty` is set for a body with an indexer. Intersected, its index signature
+     * is imposed on every sibling, so an optional `@query q?: string` beside a `Record<string>` body
+     * failed with `TS2345: 'q' is incompatible with index signature` and the generated server did not
+     * compile at all. It was wrong before it failed to compile, too: the document states the
+     * parameters and the body separately, and merged, a body key named `q` silently overwrites the
+     * query parameter of that name.
+     */
+    const bodyProperty = entry.route.bodyProperty;
+    /**
+     * **The body validator is found by its SCHEMA, never by its target.** A JSON body validates under
+     * `"json"` and a form body under `"form"`, so keying on the JSON target silently missed every
+     * form - measured on a clean install, `@header contentType: "application/x-www-form-urlencoded"`
+     * with a `Record` body still emitted the intersection and still did not compile. The schema
+     * identifier is the same fact whichever parser reads it.
+     */
+    const bodyName = entry.names.body;
+    const parts = entry.validators
+        .filter(([, name]) => bodyProperty === undefined || name !== bodyName)
+        .map(([, name]) => `z.infer<typeof ${name}>`);
+    if (bodyProperty !== undefined && bodyName !== undefined) {
+        parts.push(`{ ${objectKey(bodyProperty)}: z.infer<typeof ${bodyName}> }`);
+    }
     if (entry.route.rawBodyProperty !== undefined) {
         const reader = rawBodyReaderFor(entry.route.requestContentTypes);
         parts.push(`{ ${objectKey(entry.route.rawBodyProperty)}: ${reader.type} }`);
@@ -520,7 +544,16 @@ securityFor) {
         }
         // A dispatched body is in `validators` under the body target like any other, so there is
         // nothing extra to spread: `byContentType` published it there whichever parser ran.
-        const pieces = validators.map(([target]) => `...c.req.valid(${JSON.stringify(target)})`);
+        // Same rule as `inputTypeOf`: the body is identified by its schema, not by its target.
+        const bodyTarget = validators.find(([, name]) => name === entry.names.body)?.[0];
+        const pieces = validators.map(([target]) => 
+        /**
+         * A named body is assigned rather than spread, matching the input type above and the
+         * document, which states the parameters and the body as separate things.
+         */
+        route.bodyProperty !== undefined && target === bodyTarget
+            ? `${objectKey(route.bodyProperty)}: c.req.valid(${JSON.stringify(target)})`
+            : `...c.req.valid(${JSON.stringify(target)})`);
         if (route.rawBodyProperty !== undefined) {
             // The bytes ARE the contract: a signature covers exactly what arrived, so parsing and
             // re-serialising would verify a different string than the sender signed. WHICH reader

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-hono",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "TypeSpec emitter: generate a Hono server, and the Zod validators it enforces, from an HTTP service definition, agreeing with the OpenAPI document @typespec/openapi3 publishes from the same source.",
   "keywords": [
     "cloudflare-workers",
@@ -44,7 +44,7 @@
     "provenance": true
   },
   "dependencies": {
-    "typespec-http-zod": "^0.14.0"
+    "typespec-http-zod": "^0.15.0"
   },
   "devDependencies": {
     "@hono/zod-openapi": "^1.4.0",