typespec-hono 0.8.0 → 0.10.0

package/dist/src/emitter.js

@@ -101,6 +101,20 @@ export async function $onEmit(context) {
          * its server, so `@server("/api/v1")` plus `/accounts` publishes `/api/v1/accounts`. Mounting at
          * the root made every client generated from the document 404.
          */
+        /**
+         * **A service this project does not serve still belongs in the program.**
+         *
+         * One compile is what makes a shared vocabulary shared, so a surface not yet served is in the
+         * spec for its types and its validators. Its server is not wanted, and without a way to say so
+         * the emitter wrote an `app.gen.ts` the project had to keep honest with probe tests and never
+         * mounted.
+         *
+         * Only this file is withheld. Everything the library emits for that service is untouched,
+         * because those are the reason it is in the program at all.
+         */
+        const serviceName = emitted.service.namespace.name;
+        if (context.options.services?.[serviceName]?.["emit-server"] === false)
+            continue;
         const base = resolveBasePath(context.program, emitted.service.namespace);
         await emitFile(context.program, {
             path: resolvePath(emitted.outputDir, "app.gen.ts"),

package/dist/src/lib.d.ts

@@ -18,7 +18,17 @@ import { type EmitterOptions as HttpZodOptions } from "typespec-http-zod";
  * because it carries anything today. The moment a Hono-only option appears it goes here, and the
  * derivation keeps the rest honest.
  */
-export type EmitterOptions = HttpZodOptions;
+export type EmitterOptions = HttpZodOptions & {
+    /**
+     * Per-service overrides this emitter adds on top of the library's.
+     *
+     * **The library's own `services` map is preserved**, because the type is an intersection: an
+     * option added there still arrives here, and this only widens what each entry may carry.
+     */
+    services?: Record<string, {
+        "emit-server"?: boolean;
+    }>;
+};
 /**
  * **A spread of the published schema, so a new key arrives for free.**
  *

package/dist/src/lib.js

@@ -9,7 +9,25 @@ import { EmitterOptionsSchema as httpZodOptions, } from "typespec-http-zod";
  */
 const EmitterOptionsSchema = {
     ...httpZodOptions,
-    properties: { ...httpZodOptions.properties },
+    properties: {
+        ...httpZodOptions.properties,
+        /**
+         * **Spread from the library's own entry rather than restated**, so a per-service option added
+         * there still validates here. Only `emit-server` is added.
+         */
+        services: {
+            ...httpZodOptions.properties.services,
+            additionalProperties: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    ...httpZodOptions.properties.services.additionalProperties.properties,
+                    "emit-server": { type: "boolean", nullable: true },
+                },
+                required: [],
+            },
+        },
+    },
 };
 /**
  * What this emitter refuses that the library does not.

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.8.0",
+  "version": "0.10.0",
   "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.10.0"
+    "typespec-http-zod": "^0.12.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;