typespec-http-zod 0.18.0 → 0.19.1

package/dist/src/api.js

@@ -1,4 +1,4 @@
-import { emitFile, getDoc, getEncode, getSummary, isErrorModel, isNeverType, isVoidType, resolvePath, } from "@typespec/compiler";
+import { emitFile, getDoc, getEncode, getSummary, isErrorModel, isNeverType, isVoidType, NoTarget, resolvePath, } from "@typespec/compiler";
 import { getAuthenticationForOperation, resolveRequestVisibility, Visibility, } from "@typespec/http";
 import { getOperationId, resolveOperationId } from "@typespec/openapi";
 import { reportDiagnostic } from "./lib.js";
@@ -1260,8 +1260,20 @@ function renderSchemas(registry, externals, routeDeclarations, runtimeModule) {
      *
      * `z.infer` of `.optional()` gives `p?: T | undefined`, which under `exactOptionalPropertyTypes`
      * admits an explicitly-undefined property. **JSON has no `undefined`**, and the document says the
-     * same thing by leaving the property out of `required`, so the inferred type was wider than both
-     * the contract and the wire and a consumer had to strip it at the boundary.
+     * same thing by leaving the property out of `required`, so the inferred type is wider than the
+     * wire and a consumer reading a payload had to strip it at the boundary.
+     *
+     * **It does NOT match the contract type, and this docblock used to claim it did.** The
+     * contract types in `requests.gen.ts` keep `?: T | undefined` on purpose: they are the floor a
+     * PRODUCER supplies, and `{ p: undefined }` serialises identically to omitting `p`, so refusing
+     * it would cost every producer a conditional spread and buy the wire nothing. Measured when this
+     * was "fixed" to agree: `(ctx, input) => ok(input)` - return what you were given - stopped
+     * compiling.
+     *
+     * So the two surfaces differ on this axis deliberately, exactly as they differ on openness: this
+     * one is the narrow view of what ARRIVES, the contract type is the permissive floor for what you
+     * may SEND. A reader comparing them will find them unequal and should - the emitted assertion
+     * pairs the contract against raw `z.infer`, not against this.
      *
      * Derived from the same schema rather than hand-written beside it, so there is still one source of
      * truth: a mapped type cannot drift from the thing it maps.
@@ -1663,8 +1675,14 @@ type Simplify<T> = { [K in keyof T]: T[K] } & {};
  * No branch for functions, deliberately: the wire vocabulary is primitives, objects and arrays, so
  * a call signature cannot appear here. Mapping one would yield \`{}\`, so the day something does
  * carry a method - a narrowed multipart file part is the near miss - this needs one.
+ *
+ * **Exported, because a consumer needs it for a NAMED type and could not reach it.** It was applied
+ * to \`WireOutputs\` and declared locally, so a codebase whose layers hand back \`readonly T[]\` had
+ * the producer view sitting in the file it was already importing and no way to name it. Measured on
+ * one service: 2 contract methods returning \`readonly T[]\` and 35 readonly array properties, none
+ * of them expressible against the published shape.
  */
-type Produced<T> = T extends readonly (infer Element)[]
+export type Produced<T> = T extends readonly (infer Element)[]
 	? readonly Produced<Element>[]
 	: T extends object
 		? { readonly [K in keyof T]: Produced<T[K]> }
@@ -1762,7 +1780,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)[]
@@ -1770,15 +1810,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;
 
 /**
@@ -1872,6 +1914,36 @@ export async function emitHttpZod(context, wrapper = {}) {
      * there means a server emitter follows without knowing this rule exists.
      */
     const distinctServices = new Set(snapshots.map((snapshot) => snapshot.service.namespace.name));
+    /**
+     * **Every service must seal the same way, because `@typespec/openapi3` has no per-service
+     * options.**
+     *
+     * This option exists only so that two emitters answering the same question about the same models
+     * give the same answer - it is stated twice on purpose, and its own docblock says to set it to
+     * whatever openapi3 is set to. openapi3 applies ONE value to the whole program. So services that
+     * seal differently cannot both be mirrored: whichever way openapi3 is configured, at least one
+     * service publishes a document that disagrees with the validator generated beside it. Sealed here
+     * and silent there refuses a payload the document permits; the reverse publishes a strictness the
+     * runtime does not enforce.
+     *
+     * Reported once for the program rather than once per service, because the fault is the
+     * DISAGREEMENT and no single service is the wrong one.
+     */
+    const sealings = new Map();
+    for (const snapshot of snapshots) {
+        const name = snapshot.service.namespace.name;
+        const perService = options.services?.[name];
+        sealings.set(name, perService?.["seal-object-schemas"] ?? options["seal-object-schemas"] ?? false);
+    }
+    if (new Set(sealings.values()).size > 1) {
+        const sealed = [...sealings.entries()].filter(([, seals]) => seals).map(([name]) => name);
+        const open = [...sealings.entries()].filter(([, seals]) => !seals).map(([name]) => name);
+        reportDiagnostic(context.program, {
+            code: "unmirrorable-seal",
+            target: NoTarget,
+            format: { sealed: sealed.join(", "), open: open.join(", ") },
+        });
+    }
     for (const snapshot of snapshots) {
         beginOperationIds();
         const service = snapshot.service;

package/dist/src/lib.d.ts

@@ -125,6 +125,9 @@ export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
     "empty-union": {
         readonly default: import("@typespec/compiler").CallableMessage<["why"]>;
     };
+    "unmirrorable-seal": {
+        readonly default: import("@typespec/compiler").CallableMessage<["sealed", "open"]>;
+    };
     "unknown-key-vocabulary": {
         readonly default: import("@typespec/compiler").CallableMessage<["name", "service"]>;
     };
@@ -138,7 +141,7 @@ export declare const $lib: import("@typespec/compiler").TypeSpecLibrary<{
         readonly default: import("@typespec/compiler").CallableMessage<["name"]>;
     };
 }, EmitterOptions, never>;
-export declare const reportDiagnostic: <C extends "duplicate-declaration" | "duplicate-operation-id" | "empty-union" | "undeclared-discriminator" | "unknown-key-vocabulary" | "unsupported-default" | "unsupported-status-code-range" | "unsupported-type", M extends keyof {
+export declare const reportDiagnostic: <C extends "duplicate-declaration" | "duplicate-operation-id" | "empty-union" | "undeclared-discriminator" | "unknown-key-vocabulary" | "unmirrorable-seal" | "unsupported-default" | "unsupported-status-code-range" | "unsupported-type", M extends keyof {
     "unsupported-type": {
         readonly default: import("@typespec/compiler").CallableMessage<["artefact", "kind", "why", "remedy"]>;
     };
@@ -151,6 +154,9 @@ export declare const reportDiagnostic: <C extends "duplicate-declaration" | "dup
     "empty-union": {
         readonly default: import("@typespec/compiler").CallableMessage<["why"]>;
     };
+    "unmirrorable-seal": {
+        readonly default: import("@typespec/compiler").CallableMessage<["sealed", "open"]>;
+    };
     "unknown-key-vocabulary": {
         readonly default: import("@typespec/compiler").CallableMessage<["name", "service"]>;
     };
@@ -176,6 +182,9 @@ export declare const reportDiagnostic: <C extends "duplicate-declaration" | "dup
     "empty-union": {
         readonly default: import("@typespec/compiler").CallableMessage<["why"]>;
     };
+    "unmirrorable-seal": {
+        readonly default: import("@typespec/compiler").CallableMessage<["sealed", "open"]>;
+    };
     "unknown-key-vocabulary": {
         readonly default: import("@typespec/compiler").CallableMessage<["name", "service"]>;
     };

package/dist/src/lib.js

@@ -127,6 +127,19 @@ const diagnostics = {
      * consumer can iterate a closed key set at run time; a typo would emit no tuple at all, and "the
      * vocabulary is missing" looks exactly like "the vocabulary is empty" at the point it is used.
      */
+    /**
+     * Two services sealing differently, which `@typespec/openapi3` cannot mirror.
+     *
+     * An error rather than a warning, on the same footing as every other divergence here: the output
+     * is a document and a validator that contradict each other about whether a property may exist,
+     * and shipping that is worse than failing the build.
+     */
+    "unmirrorable-seal": {
+        severity: "error",
+        messages: {
+            default: paramMessage `'seal-object-schemas' resolves to true for ${"sealed"} and false for ${"open"}, and '@typespec/openapi3' has no per-service options - it applies one value to the whole program. So one of these services would publish a document that disagrees with the validator emitted beside it. Give every service the same value, or split the surfaces into separate compiles.`,
+        },
+    },
     "unknown-key-vocabulary": {
         severity: "error",
         messages: {

package/dist/src/types.js

@@ -256,7 +256,23 @@ export function propertyToTs(program, property, wireName) {
      */
     if (property.defaultValue !== undefined)
         return `${key}: ${value};`;
-    // `exactOptionalPropertyTypes` is on, and Zod's `.optional()` infers `T | undefined`.
+    /**
+     * **`?: T | undefined`, and dropping the `| undefined` was tried in `0.19.0` and reverted.**
+     *
+     * It looks wrong - JSON has no `undefined`, so a wire type saying `?: T` reads more honest, and
+     * it would make this walk agree with `Exact<z.infer<...>>` on the schemas side. **Measured, it
+     * breaks the most ordinary handler there is.** `createWidget: (ctx, input) => ok(input)` - return
+     * what you were given - stopped compiling, because what a handler RECEIVES carries
+     * `?: T | undefined` and what it would then have to SUPPLY did not.
+     *
+     * That is the difference from the index signature and from `readonly`, which look like the same
+     * class and are not: removing those two makes MORE values assignable, and removing this one makes
+     * fewer. `{ retiredOn: undefined }` serialises to `{}`, identical to omitting the key, so
+     * permitting it costs the wire nothing and refusing it costs every producer a conditional spread.
+     *
+     * The two emitted surfaces differ here on purpose, exactly as they do on openness:
+     * `schemas.gen.ts` exports the narrow received view, this walk emits the permissive floor.
+     */
     return property.optional ? `${key}?: ${value} | undefined;` : `${key}: ${value};`;
 }
 /** Installed by the registry so a named model is declared once and referenced everywhere else. */

package/package.json

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