@zudojs/openapi 1.3.0 → 1.4.0

package/dist/openApiRouting/routeScanner.core.js

@@ -1,5 +1,27 @@
-import { convertRouteToOpenAPI } from "./routeConverter.core.js";
+import { convertRouteToOpenAPI, toOpenAPIPath } from "./routeConverter.core.js";
 import { OpenAPIRouteError } from "../openApiErrors/openApiError.types.js";
+/**
+ * Identity of a route inside the generated document.
+ *
+ * Keyed on the OpenAPI path template rather than the source path, because
+ * that is what the document is keyed on: `/users/:id` and `/users/{id}` are
+ * one path item. Keying on the raw spelling let both register, and the
+ * second then replaced the first during generation — one operation vanished
+ * from the published spec with `validate()` reporting nothing.
+ *
+ * A path `toOpenAPIPath` cannot express keeps its raw spelling here so the
+ * conversion error still surfaces from `scan()`, where it always has.
+ */
+function routeKey(method, path) {
+    let template;
+    try {
+        template = toOpenAPIPath(path);
+    }
+    catch {
+        template = path;
+    }
+    return `${method.toLowerCase()}:${template}`;
+}
 /**
  * Collects routes and converts them into OpenAPI operations.
  *
@@ -12,23 +34,33 @@ export class OpenAPIRouteScannerImpl {
     routes = new Map();
     /** Registers a route. */
     addRoute(route) {
-        const key = `${route.method.toLowerCase()}:${route.path}`;
-        if (this.routes.has(key)) {
-            throw new OpenAPIRouteError(`Route ${route.method.toUpperCase()} ${route.path} is already registered.`, { metadata: { method: route.method, path: route.path } });
+        const key = routeKey(route.method, route.path);
+        const existing = this.routes.get(key);
+        if (existing !== undefined) {
+            throw new OpenAPIRouteError(`Route ${route.method.toUpperCase()} ${route.path} is already registered` +
+                (existing.path === route.path
+                    ? "."
+                    : ` as ${existing.method.toUpperCase()} ${existing.path}; both describe the same OpenAPI path.`), {
+                metadata: {
+                    method: route.method,
+                    path: route.path,
+                    existingPath: existing.path,
+                },
+            });
         }
         this.routes.set(key, route);
     }
     /** Registers a route, replacing any existing one for the same method+path. */
     setRoute(route) {
-        this.routes.set(`${route.method.toLowerCase()}:${route.path}`, route);
+        this.routes.set(routeKey(route.method, route.path), route);
     }
     /** True when a route is registered for this method and path. */
     hasRoute(method, path) {
-        return this.routes.has(`${method.toLowerCase()}:${path}`);
+        return this.routes.has(routeKey(method, path));
     }
     /** Removes a route. Returns whether one was removed. */
     removeRoute(method, path) {
-        return this.routes.delete(`${method.toLowerCase()}:${path}`);
+        return this.routes.delete(routeKey(method, path));
     }
     /** Number of registered routes. */
     get size() {

package/dist/openApiSchema/schemaConverter.core.d.ts

@@ -11,6 +11,8 @@ import type { OpenAPISchema } from "../openApiTypes/openApiTypes.core.js";
  *
  * Field names as of `@zudojs/schema@0.1.0`:
  *   object   `_config.shape`, `_config.requiredKeys` (a Set), `_config.unknownKeys`
+ *            (`"strip" | "strict" | "passthrough"`; absent means the parser's
+ *            own `?? "strip"` default, so it is read with that same default)
  *   array    `_config.itemSchema`, `_config.min`, `_config.max`, `_config.length`
  *            (no `max` means the parser's implicit ceiling, which is emitted)
  *   string   `_config.min|max|length|pattern|format`

package/dist/openApiSchema/schemaConverter.core.js

@@ -309,14 +309,19 @@ function convertSchemaNode(schema, state) {
                 if (forced || !acceptsMissingKey(value))
                     required.push(key);
             }
-            const unknownKeys = c["unknownKeys"];
+            // `ObjectSchema` applies `?? "strip"` internally, so an absent
+            // `unknownKeys` is the same contract as an explicit `.strip()` and
+            // must document the same. Only `strict` emits
+            // `additionalProperties: false`: that is OpenAPI for "reject the
+            // payload", while strip accepts it and discards the extra key, so
+            // emitting it for strip made a generated client refuse what the
+            // service accepts.
+            const unknownKeys = c["unknownKeys"] ?? "strip";
             return {
                 type: "object",
                 ...(Object.keys(properties).length > 0 ? { properties } : {}),
                 ...(required.length > 0 ? { required } : {}),
-                ...(unknownKeys === "strip" || unknownKeys === "strict"
-                    ? { additionalProperties: false }
-                    : {}),
+                ...(unknownKeys === "strict" ? { additionalProperties: false } : {}),
             };
         }
         case "record": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zudojs/openapi",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "OpenAPI 3.0 and 3.1 specification generation, validation, and serialization for Zudojs applications.",
   "license": "MIT",
   "author": {
@@ -26,8 +26,8 @@
     "!dist/.tsbuildinfo"
   ],
   "dependencies": {
-    "@zudojs/constants": "1.1.0",
-    "@zudojs/errors": "1.1.0"
+    "@zudojs/constants": "1.1.1",
+    "@zudojs/errors": "1.2.0"
   },
   "devDependencies": {
     "@types/node": "^26.4.1",