typespec-hono 0.5.0 → 0.7.0

package/dist/src/app.js

@@ -248,7 +248,7 @@ basePaths = [],
  * audience is wider.
  */
 securityFor) {
-    const entries = emitted.routes.flatMap((route) => {
+    const mounted = emitted.routes.flatMap((route) => {
         let dispatched;
         const names = emitted.schemaNames.get(route.operationId);
         // The library declares a `Responses` const for every operation, so a missing entry is a bug in
@@ -291,6 +291,7 @@ securityFor) {
         }
         return [{ route, names, validators, dispatched }];
     });
+    const entries = mounted;
     /**
      * **One registration per verb+path, not per operation.**
      *
@@ -600,7 +601,7 @@ securityFor) {
             "\t\t\t},",
             "\t\t)",
         ].join("\n");
-        return { target, text };
+        return { target, text, headOnly };
     });
     /**
      * Every identifier this file names, imported from the module that declares it.
@@ -608,8 +609,21 @@ securityFor) {
      * **Derived from what the rendered text actually references, not from what was available.** An
      * unused import fails the lint a generated file has to pass like any other, and a missing one is a
      * file that does not compile. Both have happened.
+     *
+     * **The text is TOKENISED and compared by equality, never matched name by name.** It used to build
+     * `new RegExp("\\b" + identifier + "\\b")` per name, and that was wrong twice over for any
+     * identifier containing a `$`, which TypeSpec permits in a model or operation name: `$` is an
+     * anchor in a regular expression, and escaping it alone does not help because `\b` is a WORD
+     * boundary and `$` is not a word character, so `\b\$select\b` cannot match either. Measured on
+     * `op list$Items(...): Item$Ref[]`, every identifier reported ABSENT, the whole
+     * `./schemas.gen.js` import was dropped, and the emitted file failed with four
+     * `TS2304: Cannot find name`. No diagnostic anywhere.
+     *
+     * Splitting on the language's own identifier rule and testing membership has neither failure: no
+     * metacharacter can be misread, and `Foo` cannot match `FooExtra`.
      */
     const rendered = [...registrations.map((r) => r.text), ...methods, ...aliases].join("\n");
+    const mentioned = new Set(rendered.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) ?? []);
     const referenced = [
         ...new Set(entries.flatMap((entry) => [
             entry.names.path,
@@ -620,7 +634,7 @@ securityFor) {
             entry.names.responses,
         ].filter((name) => name !== undefined))),
     ]
-        .filter((identifier) => new RegExp(`\\b${identifier}\\b`).test(rendered))
+        .filter((identifier) => mentioned.has(identifier))
         .toSorted();
     const imports = referenced.length === 0
         ? ""
@@ -670,17 +684,47 @@ securityFor) {
     // Imported only where a route actually negotiates: an unused import fails the repo's own lint.
     const negotiates = [...grouped.values()].some((group) => group.length > 1);
     // Same rule: imported only where a HEAD operation stands alone on its path.
-    const guardsHead = registrations.some((registration) => registration.text.includes("headOnly,"));
+    const guardsHead = registrations.some((registration) => registration.headOnly);
     /**
-     * Read from the entries rather than from the rendered text, which the two lines above still do.
+     * **Which runtime imports to write is read from the DATA, never from the rendered text.**
      *
-     * **Matching a substring of generated output is how this import went missing once already.** It
-     * tested for `byContentType([`, the emitted call gained arguments before its bracket, the substring
-     * stopped matching, the import stopped being written, and the emitted module threw
+     * Matching a substring of generated output is how one of these went missing already: it tested for
+     * `byContentType([`, the emitted call gained arguments before its bracket, the substring stopped
+     * matching, the import stopped being written, and the emitted module threw
      * `ReferenceError: byContentType is not defined` at registration. Nothing in the emitter objected,
      * because the check was a string about a string.
+     *
+     * `guardsHead` above had the same shape, and the sibling library had it in a worse place, deciding
+     * whether a parameter gets a wire decoder by `declared.startsWith("z.number()")`. A literal union
+     * (`@query size: 10 | 25 | 50`) begins with neither prefix, so every conformant caller of that
+     * parameter got a 400 that no document comparison could see.
+     *
+     * The rendered text is still read to decide which VALIDATOR identifiers to import, and that one is
+     * safe in a way these are not: an identifier absent from the text is genuinely not needed, so the
+     * check cannot be wrong in the direction that breaks a build.
      */
     const dispatchesBody = entries.some((entry) => entry.dispatched !== undefined);
+    /**
+     * **Imported only where a route actually validates something, like every other value import here.**
+     *
+     * This one was unconditional while the three around it were not, and the comment above them stated
+     * the rule it was breaking. A service whose operations declare no parameters at all -- two bare
+     * `GET`s, which is where a health check starts and therefore where a new consumer starts -- emitted
+     * an import nothing used, and `tsp compile` reported success:
+     * `TS6133: 'zValidator' is declared but its value is never read`.
+     *
+     * Counted from the same filtered list the middleware is rendered from, so it cannot disagree with
+     * what was emitted: a dispatched body's validator is `byContentType`, not a `zValidator`.
+     */
+    /**
+     * **`z` is only ever reached through `z.infer`**, which appears where an operation has an input
+     * type or a response body. A service whose every operation takes nothing and returns `void` names
+     * neither, so the import was written and never used:
+     * `TS6133: 'z' is declared but its value is never read`. Same shape as the `zValidator` one above,
+     * one step further along.
+     */
+    const usesZod = entries.some((entry) => inputTypeOf(entry) !== undefined || entry.names.response !== undefined);
+    const validates = entries.some((entry) => entry.validators.filter(([target]) => entry.dispatched === undefined || target !== VALIDATOR_TARGET.body).length > 0);
     const runtimeModule = JSON.stringify(emitted.options.runtimeModule);
     /**
      * **One base sub-app, mounted with `app.route()`. Hono's own nesting, not a rewritten path on
@@ -692,10 +736,8 @@ securityFor) {
     const usesBasePath = basePaths.length > 0;
     const needsHonoValue = subApps.size > 0 || usesBasePath;
     return `${GENERATED_BANNER}
-import { zValidator } from "@hono/zod-validator";
-${needsHonoValue ? 'import { Hono } from "hono";\nimport type { Context, Input } from "hono";' : 'import type { Context, Hono, Input } from "hono";'}
-import { z } from "zod";
-import type { AppEnv, Awaitable, Ctx, Result, RouteDeps } from ${runtimeModule};${negotiates ? `\nimport { selectContentType } from ${runtimeModule};` : ""}${guardsHead ? `\nimport { headOnly } from ${runtimeModule};` : ""}${dispatchesBody ? `\nimport { byContentType } from ${runtimeModule};` : ""}
+${validates ? 'import { zValidator } from "@hono/zod-validator";\n' : ""}${needsHonoValue ? 'import { Hono } from "hono";\nimport type { Context, Input } from "hono";' : 'import type { Context, Hono, Input } from "hono";'}
+${usesZod ? 'import { z } from "zod";\n' : ""}import type { AppEnv, Awaitable, Ctx, Result, RouteDeps } from ${runtimeModule};${negotiates ? `\nimport { selectContentType } from ${runtimeModule};` : ""}${guardsHead ? `\nimport { headOnly } from ${runtimeModule};` : ""}${dispatchesBody ? `\nimport { byContentType } from ${runtimeModule};` : ""}
 ${imports}
 /**
  * One method per operation, each concretely typed from the schemas it validates against.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-hono",
-  "version": "0.5.0",
+  "version": "0.7.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.5.0"
+    "typespec-http-zod": "^0.9.0"
   },
   "devDependencies": {
     "@hono/zod-openapi": "^1.4.0",