typespec-http-zod 0.19.0 → 0.20.0

package/dist/src/api.d.ts

@@ -222,6 +222,22 @@ export interface EmittedRoute {
      * {@link rawBodyProperty}, whose case is the same statement about a different body.
      */
     readonly bodyProperty: string | undefined;
+    /**
+     * Whether the document publishes `requestBody.required: false`, so a request carrying NO body at
+     * all is one the contract permits.
+     *
+     * **A body that may be absent cannot be flattened into the input, which is why this is published
+     * rather than kept internal.** Merged, there is no way to say "these properties are here only
+     * sometimes" without making every one of them optional, which would be a different and weaker
+     * claim about the body that IS sent. So an optional body is named, exactly as an indexed one is,
+     * and a wrapping emitter spells the property optional from this.
+     *
+     * Measured before it existed: a bodyless `POST` naming `content-type: application/json` answered
+     * **400 `Malformed JSON in request body`** as `text/plain`, produced before the app's `invalid`
+     * hook and so outside its error envelope entirely - a service refusing a request its own contract
+     * permits, in a shape that contract forbids.
+     */
+    readonly optionalBody: boolean;
     /** Declared failures, each with the schema for its OWN body, in OpenAPI's precedence order. */
     readonly errorArms: readonly {
         readonly status: StatusKey;

package/dist/src/api.js

@@ -1054,7 +1054,12 @@ export function collectRoutes(program, registry, service) {
              * resolved model's own indexer rather than from the emitted schema text, which would be a
              * decision made by pattern-matching generated output.
              */
-            const bodyProperty = requestType?.kind === "Model" && requestType.indexer !== undefined
+            /**
+             * **An OPTIONAL body is named for the same reason an indexed one is**: the merge cannot
+             * express "absent". See {@link EmittedRoute.optionalBody}.
+             */
+            const optionalBody = bodyParameter?.property?.optional === true;
+            const bodyProperty = requestType?.kind === "Model" && (requestType.indexer !== undefined || optionalBody)
                 ? (bodyParameter?.property?.name ?? "body")
                 : undefined;
             routes.push({
@@ -1135,6 +1140,7 @@ export function collectRoutes(program, registry, service) {
                         : registry.expressionFor(responseType)),
                 rawBodyProperty,
                 bodyProperty,
+                optionalBody,
                 // Responses are read at Visibility.Read, exactly as the success body above is. Resolving
                 // them under the ambient request visibility declared six components under the wrong
                 // suffix - measured: type/model/visibility gained six divergences.
@@ -1780,7 +1786,29 @@ type Identical<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends
  *
  * Deep, because openness recurs: a nested open model puts one at every level, which is why a single
  * spread never repaired the shape it was supposed to repair.
+ *
+ * **An index signature arrives two ways and only one of them is openness.** A model spreading
+ * \`...Record<unknown>\` gains one because its validator is loose - a fact about the MODEL, which the
+ * contract type does not state, so it is stripped. A property declared \`Record<unknown>\` gains one
+ * because that IS its type, stated identically in both artefacts, and stripping it destroys the
+ * property: \`Declared<Record<string, unknown>>\` became \`{}\`, and any spec with a dictionary
+ * property emitted an assertion that does not compile.
+ *
+ * The two are told apart the same way \`types.ts\` already tells them apart: **a string indexer means
+ * "dictionary" only when there are no declared properties beside it.** So the index signature is
+ * dropped from a shape that has other keys, and kept - with its value type still mapped - from one
+ * that does not.
  */
+type DeclaredKeyOf<T> = keyof {
+	[K in keyof T as string extends K
+		? never
+		: number extends K
+			? never
+			: symbol extends K
+				? never
+				: K]: 0;
+};
+
 type Declared<T> = T extends (...args: never[]) => unknown
 	? T
 	: T extends readonly (infer Element)[]
@@ -1788,15 +1816,17 @@ type Declared<T> = T extends (...args: never[]) => unknown
 			? Declared<Element>[]
 			: readonly Declared<Element>[]
 		: T extends object
-			? {
-					[K in keyof T as string extends K
-						? never
-						: number extends K
+			? [DeclaredKeyOf<T>] extends [never]
+				? { [K in keyof T]: Declared<T[K]> }
+				: {
+						[K in keyof T as string extends K
 							? never
-							: symbol extends K
+							: number extends K
 								? never
-								: K]: Declared<T[K]>;
-				}
+								: symbol extends K
+									? never
+									: K]: Declared<T[K]>;
+					}
 			: T;
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typespec-http-zod",
-  "version": "0.19.0",
+  "version": "0.20.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",