typespec-hono 0.7.0 → 0.9.1

package/dist/src/app.d.ts

@@ -23,7 +23,20 @@ import { type EmittedRoute, type EmittedService } from "typespec-http-zod";
  * operation (validators included) over a template no router could mount. What a request body must
  * look like does not depend on that.
  */
-export declare function toHonoPath(template: string, refuse: (template: string, name: string) => void): string;
+export declare function toHonoPath(template: string, refuse: (template: string, name: string) => void, 
+/**
+ * Wire names the document says carry RFC 6570 reserved expansion, so their value may contain `/`.
+ *
+ * **A hierarchical identifier is ONE value, not several segments.** An Obsidian note is
+ * `areas/health.md`; an S3 key and a GitHub file path are the same shape. A router that stops at
+ * the first `/` binds `areas` and 404s the rest. Hono spells the greedy form `:name{.+}`.
+ *
+ * Read from `EmittedRoute.reservedPathParameters`, which the library resolves from `allowReserved`
+ * on the parameter. **Never from the template**: the operator does not survive to `route.path`,
+ * `@typespec/http` strips it, and it can also be set with no operator in the template at all, so
+ * the template is a derived artefact rather than the source of truth.
+ */
+reserved?: ReadonlySet<string>): string;
 /** The one thing a Hono server cannot express, handed back rather than thrown. */
 export interface RenderRefusals {
     readonly unsupportedPathTemplate: (route: EmittedRoute, template: string, name: string) => void;

package/dist/src/app.js

@@ -29,12 +29,32 @@ const PLAIN_PATH_PARAMETER = /^[A-Za-z0-9_.~-]+$/;
  * operation (validators included) over a template no router could mount. What a request body must
  * look like does not depend on that.
  */
-export function toHonoPath(template, refuse) {
+export function toHonoPath(template, refuse, 
+/**
+ * Wire names the document says carry RFC 6570 reserved expansion, so their value may contain `/`.
+ *
+ * **A hierarchical identifier is ONE value, not several segments.** An Obsidian note is
+ * `areas/health.md`; an S3 key and a GitHub file path are the same shape. A router that stops at
+ * the first `/` binds `areas` and 404s the rest. Hono spells the greedy form `:name{.+}`.
+ *
+ * Read from `EmittedRoute.reservedPathParameters`, which the library resolves from `allowReserved`
+ * on the parameter. **Never from the template**: the operator does not survive to `route.path`,
+ * `@typespec/http` strips it, and it can also be set with no operator in the template at all, so
+ * the template is a derived artefact rather than the source of truth.
+ */
+reserved = new Set()) {
     return template.replace(/\{([^}]+)\}/g, (match, name) => {
-        if (PLAIN_PATH_PARAMETER.test(name))
-            return `:${name}`;
-        refuse(template, name);
-        return match;
+        /**
+         * **The name check comes FIRST and is unconditional.** A name Hono cannot carry is refused
+         * whether or not it is reserved: greedy matching does not make a space or a `+` in a parameter
+         * name expressible, and letting one through because another flag was set would mount a route
+         * matching the wrong requests rather than one that fails.
+         */
+        if (!PLAIN_PATH_PARAMETER.test(name)) {
+            refuse(template, name);
+            return match;
+        }
+        return reserved.has(name) ? `:${name}{.+}` : `:${name}`;
     });
 }
 /**
@@ -386,7 +406,7 @@ securityFor) {
         /** A HEAD with no GET beside it: registered under GET, and guarded so only a HEAD reaches it. */
         const headOnly = plainGroups.length === 0 && headGroups.length > 0;
         const method = HONO_METHOD[registrationVerbOf(route.verb)] ?? "on";
-        const path = toHonoPath(route.path, (template, name) => refuse.unsupportedPathTemplate(route, template, name));
+        const path = toHonoPath(route.path, (template, name) => refuse.unsupportedPathTemplate(route, template, name), new Set(route.reservedPathParameters));
         /**
          * A route inside a sub-app is registered RELATIVE to the prefix it is mounted at.
          *

package/dist/src/runtime.d.ts

@@ -12,6 +12,28 @@ import type { input, output, ZodType } from "zod";
 export interface ResponseArm {
     readonly status: number | "default" | `${1 | 2 | 3 | 4 | 5}XX`;
     readonly schema: ZodType | undefined;
+    /**
+     * The media types this response offers, where the document names MORE than one.
+     *
+     * Absent where it names one, which is what an application already assumes, so "one type" and
+     * "not carried" are the same state rather than two to tell apart. Present, it is the set to
+     * negotiate against: `selectContentType` takes the caller's `Accept` and these.
+     */
+    readonly contentTypes?: readonly string[];
+    /**
+     * The headers this response declares, as the document publishes them.
+     *
+     * **Two names, because two different things need them.** `name` is the WIRE name, which is what
+     * the response sets; `property` is the name on the value the handler returned, which is where the
+     * value is read from. `@header("x-correlation-id") correlationId: string` is `x-correlation-id`
+     * on the wire and `correlationId` in the result, and they differ for any header with a hyphen.
+     *
+     * Absent where the response declares none.
+     */
+    readonly headers?: readonly {
+        readonly name: string;
+        readonly property: string;
+    }[];
     readonly when?: {
         readonly property: string;
         readonly value: boolean | string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-hono",
-  "version": "0.7.0",
+  "version": "0.9.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.9.0"
+    "typespec-http-zod": "^0.11.0"
   },
   "devDependencies": {
     "@hono/zod-openapi": "^1.4.0",

package/src/runtime.ts

@@ -14,6 +14,25 @@ import type { input, output, ZodType } from "zod";
 export interface ResponseArm {
 	readonly status: number | "default" | `${1 | 2 | 3 | 4 | 5}XX`;
 	readonly schema: ZodType | undefined;
+	/**
+	 * The media types this response offers, where the document names MORE than one.
+	 *
+	 * Absent where it names one, which is what an application already assumes, so "one type" and
+	 * "not carried" are the same state rather than two to tell apart. Present, it is the set to
+	 * negotiate against: `selectContentType` takes the caller's `Accept` and these.
+	 */
+	readonly contentTypes?: readonly string[];
+	/**
+	 * The headers this response declares, as the document publishes them.
+	 *
+	 * **Two names, because two different things need them.** `name` is the WIRE name, which is what
+	 * the response sets; `property` is the name on the value the handler returned, which is where the
+	 * value is read from. `@header("x-correlation-id") correlationId: string` is `x-correlation-id`
+	 * on the wire and `correlationId` in the result, and they differ for any header with a hyphen.
+	 *
+	 * Absent where the response declares none.
+	 */
+	readonly headers?: readonly { readonly name: string; readonly property: string }[];
 	readonly when?: {
 		readonly property: string;
 		readonly value: boolean | string;