typespec-http-zod 0.15.1 → 0.16.0

package/dist/src/api.js

@@ -601,6 +601,29 @@ function alternateSchemaFor(operation, status, registry) {
  * document does not state AND reject what a server actually receives, since `c.req.parseBody()`
  * hands back a `File`. The type of a value is positional, exactly as its visibility is.
  */
+/**
+ * The TS type for a **multipart** request body, built from the same parts as its validator.
+ *
+ * **`requestBodyOf` returns a type only for `bodyKind === "single"`, so a multipart body reached the
+ * request type not at all.** Measured: `UploadInput` was `{ "Content-Type": "multipart/form-data" }`
+ * while the validator beside it was `z.object({ file: ..., alt: ... })` and the document published
+ * every part. Two artefacts from one program, contradicting each other.
+ *
+ * **Built from `body.parts`, not from the parts model.** Walking the model types each part as its
+ * `HttpPart<T>` wrapper - `file: {}` - where the validator unwraps to `T`. Mirroring
+ * {@link multipartSchemaOf} part for part, including `multi` as an array, `optional`, and a binary
+ * part as `unknown`, is what makes the two agree by construction rather than by coincidence.
+ */
+function multipartTsOf(body, registry) {
+    const entries = body.parts.map((part) => {
+        const type = part.body?.type;
+        const inner = type === undefined || isBinaryPart(type) ? "unknown" : registry.expressionFor(type);
+        const value = part.multi === true ? `(${inner})[]` : inner;
+        const optional = part.optional === true ? "?" : "";
+        return `\t${objectKey(part.name ?? "")}${optional}: ${value};`;
+    });
+    return entries.length === 0 ? "{}" : `{\n${entries.join("\n")}\n}`;
+}
 function multipartSchemaOf(body, registry) {
     const entries = body.parts.map((part) => {
         const type = part.body?.type;
@@ -660,7 +683,9 @@ export function isRawBinaryMediaType(contentTypes) {
 /** The declared request body type, if the operation takes one. */
 function requestBodyOf(operation) {
     const body = operation.parameters.body;
-    return body?.bodyKind === "single" ? body.type : undefined;
+    if (body?.bodyKind === "single")
+        return body.type;
+    return undefined;
 }
 /**
  * Parameters are emitted as their **own** schemas rather than folded into the body, because the two
@@ -1421,6 +1446,9 @@ function collectRequestTypes(program, registry, service) {
             if (successStatusOf(operation) === undefined)
                 continue;
             const body = requestBodyOf(operation);
+            /** The parts of a multipart body, which `requestBodyOf` deliberately does not return. */
+            const multipartBody = operation.parameters.body;
+            const multipart = multipartBody?.bodyKind === "multipart" ? { parts: multipartBody.parts } : undefined;
             /**
              * Headers are part of the input too.
              *
@@ -1466,9 +1494,11 @@ function collectRequestTypes(program, registry, service) {
                 operationId: operationIdOf(program, operation.operation),
                 bodyRef: rawBody !== undefined
                     ? `{\n\t${rawBody}: ${rawBodyType};\n}`
-                    : body === undefined
-                        ? undefined
-                        : registry.expressionFor(body),
+                    : multipart !== undefined
+                        ? multipartTsOf(multipart, registry)
+                        : body === undefined
+                            ? undefined
+                            : registry.expressionFor(body),
                 extraProperties,
             });
         }

package/dist/src/types.js

@@ -207,7 +207,28 @@ function modelToTs(program, model) {
      * Permissiveness is a statement about the VALIDATOR - what it lets through - not about what a
      * producer must contain. The contract type is the floor: these fields, at least.
      */
-    return entries.length === 0 ? "{}" : `{\n${entries.join("\n")}\n}`;
+    /**
+     * **An open model carries its catchall here too, or the two walks disagree.**
+     *
+     * `modelToZod` emits `.loose()` for a `...Record<unknown>` indexer and `.catchall(T)` for a typed
+     * one, so `z.infer` gains an index signature. This walk emitted the declared properties alone, and
+     * the emitter's OWN assertion caught it:
+     * `TS2344: the emitted validator and the shared wire type describe different shapes`. Any spec with
+     * `...Record<unknown>` on a request model shipped a `wire-contract.gen.ts` that does not compile.
+     *
+     * **Emitted rather than compared away.** The document says `additionalProperties`, the validator
+     * says `.loose()`, so the type saying it too is what makes all three agree. Relaxing the comparison
+     * instead would hide the disagreement rather than remove it, and a looser comparison stops catching
+     * the drift it exists for.
+     *
+     * The dictionary case above returns before this: a model with an indexer and NO declared properties
+     * is a `Record<...>` outright rather than an object with a catchall.
+     */
+    const catchall = indexerKey === "string" && indexer !== undefined && !isNeverType(indexer.value)
+        ? [`\t[key: string]: ${typeToTs(program, indexer.value)};`]
+        : [];
+    const all = [...entries, ...catchall];
+    return all.length === 0 ? "{}" : `{\n${all.join("\n")}\n}`;
 }
 /**
  * A property line, including its optionality marker.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-http-zod",
-  "version": "0.15.1",
+  "version": "0.16.0",
   "description": "TypeSpec emitter and library: turn an HTTP service definition into Zod validators and framework-free contract types that agree, keyword for keyword, with the OpenAPI document @typespec/openapi3 publishes from the same source.",
   "keywords": [
     "codegen",