@kubb/plugin-zod 5.0.0-beta.30 → 5.0.0-beta.31

package/dist/index.js

@@ -249,6 +249,89 @@ function ensureValidVarName(name) {
 	return `_${name}`;
 }
 //#endregion
+//#region ../../internals/shared/src/operation.ts
+/**
+* Maps a content type to the PascalCase suffix used to name per-content-type variants
+* (e.g. `application/json` → `Json`, `application/xml` → `Xml`, `multipart/form-data` → `FormData`).
+*/
+function getContentTypeSuffix(contentType) {
+	const baseType = contentType.split(";")[0].trim();
+	if (baseType === "application/json") return "Json";
+	if (baseType === "multipart/form-data") return "FormData";
+	if (baseType === "application/x-www-form-urlencoded") return "FormUrlEncoded";
+	const parts = (baseType.split("/").pop() ?? baseType).split(/[^a-zA-Z0-9]+/).filter(Boolean);
+	if (parts.length === 0) return "Unknown";
+	return parts.map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+/**
+* Appends a content-type suffix to a base name, keeping a trailing `Data` segment last
+* (e.g. `AddPetData` + `Json` → `AddPetJsonData`, `AddPetStatus200` + `Xml` → `AddPetStatus200Xml`).
+*/
+function getPerContentTypeName(baseName, suffix) {
+	if (baseName.endsWith("Data")) return suffix.endsWith("Data") ? baseName.slice(0, -4) + suffix : `${baseName.slice(0, -4)}${suffix}Data`;
+	return baseName + suffix;
+}
+/**
+* Resolves per-content-type variant names for a set of content entries, deduplicating suffix
+* collisions with a numeric counter. Entries without a schema are skipped. The returned `suffix` is
+* the final (possibly counter-augmented) value, so callers can derive parallel names in another
+* namespace (e.g. plugin-faker deriving the matching plugin-ts type name).
+*/
+function resolveContentTypeVariants(entries, baseName) {
+	const usedNames = /* @__PURE__ */ new Set();
+	return entries.filter((entry) => entry.schema).map((entry) => {
+		const baseSuffix = getContentTypeSuffix(entry.contentType);
+		let suffix = baseSuffix;
+		let name = getPerContentTypeName(baseName, suffix);
+		let counter = 2;
+		while (usedNames.has(name)) {
+			suffix = `${baseSuffix}${counter++}`;
+			name = getPerContentTypeName(baseName, suffix);
+		}
+		usedNames.add(name);
+		return {
+			name,
+			suffix,
+			schema: entry.schema,
+			keysToOmit: entry.keysToOmit,
+			contentType: entry.contentType
+		};
+	});
+}
+//#endregion
+//#region ../../internals/shared/src/group.ts
+/**
+* Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
+* shared default naming so every plugin groups output consistently:
+*
+* - `path` groups use the second path segment (`/pet/findByStatus` → `pet`).
+* - other groups use `${camelCase(group)}${suffix}` (e.g. `petController`).
+*
+* Returns `null` when grouping is disabled, matching the per-plugin convention.
+*
+* @param group - The user-supplied group option, or `undefined` to disable grouping.
+* @param options.suffix - Appended to non-`path` group names, e.g. `'Controller'` or `'Requests'`.
+* @param options.honorName - When `true`, a user-provided `group.name` overrides the default namer.
+*
+* @example
+* ```ts
+* createGroupConfig(group, { suffix: 'Controller' })                  // plugin-ts, plugin-zod
+* createGroupConfig(group, { suffix: 'Controller', honorName: true }) // plugin-faker, plugin-client, …
+* createGroupConfig(group, { suffix: 'Requests', honorName: true })   // plugin-cypress, plugin-mcp
+* ```
+*/
+function createGroupConfig(group, options) {
+	if (!group) return null;
+	const defaultName = (ctx) => {
+		if (group.type === "path") return `${ctx.group.split("/")[1]}`;
+		return `${camelCase(ctx.group)}${options.suffix}`;
+	};
+	return {
+		...group,
+		name: options.honorName && group.name ? group.name : defaultName
+	};
+}
+//#endregion
 //#region src/components/Operations.tsx
 function Operations({ name, operations }) {
 	const operationsJSON = operations.reduce((prev, acc) => {
@@ -256,6 +339,7 @@ function Operations({ name, operations }) {
 		return prev;
 	}, {});
 	const pathsJSON = operations.reduce((prev, acc) => {
+		if (!ast.isHttpOperationNode(acc.node)) return prev;
 		prev[`"${acc.node.path}"`] = {
 			...prev[`"${acc.node.path}"`] ?? {},
 			[acc.node.method]: `operations["${acc.node.operationId}"]`
@@ -365,6 +449,61 @@ function shouldCoerce(coercion, type) {
 	return !!coercion[type];
 }
 /**
+* Registered codecs, checked in order.
+*/
+const codecs = [{
+	matches(node) {
+		return node.type === "date" && node.representation === "date";
+	},
+	decode(node) {
+		return node.format === "date" ? "z.iso.date().transform((value) => new Date(value))" : "z.iso.datetime().transform((value) => new Date(value))";
+	},
+	encode(node) {
+		return node.format === "date" ? "z.date().transform((value) => value.toISOString().slice(0, 10))" : "z.date().transform((value) => value.toISOString())";
+	}
+}];
+/**
+* Returns the codec for this node, or `undefined` when the node needs no
+* encode/decode (its wire and runtime types match).
+*/
+function getCodec(node) {
+	if (!node) return void 0;
+	return codecs.find((codec) => codec.matches(node));
+}
+/**
+* Returns `true` when the node itself is encoded/decoded by a codec.
+*/
+function hasCodec(node) {
+	return getCodec(node) !== void 0;
+}
+/**
+* Returns `true` when the schema transitively contains a codec node —
+* a value whose runtime type differs from its wire type (see {@link hasCodec}),
+* so it must be decoded (response) or encoded (request) at the validation boundary.
+* `$ref`s are followed via their resolved schema; a `seen` set guards cycles.
+*/
+function containsCodec(node, seen = /* @__PURE__ */ new Set()) {
+	if (!node) return false;
+	if (hasCodec(node)) return true;
+	if (node.type === "ref") {
+		if (!node.ref) return false;
+		const refName = ast.extractRefName(node.ref);
+		if (refName) {
+			if (seen.has(refName)) return false;
+			seen.add(refName);
+		}
+		const resolved = ast.syncSchemaRef(node);
+		if (resolved.type === "ref") return false;
+		return containsCodec(resolved, seen);
+	}
+	const children = [];
+	if ("properties" in node && node.properties) children.push(...node.properties.map((prop) => prop.schema));
+	if ("items" in node && node.items) children.push(...node.items);
+	if ("members" in node && node.members) children.push(...node.members);
+	if ("additionalProperties" in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties);
+	return children.some((child) => containsCodec(child, seen));
+}
+/**
 * Collects all resolved schema names for an operation's parameters and responses
 * into a single lookup object, useful for building imports and type references.
 */
@@ -536,8 +675,9 @@ const printerZod = ast.definePrinter((options) => {
 				return shouldCoerce(this.options.coercion, "numbers") ? "z.coerce.bigint()" : "z.bigint()";
 			},
 			date(node) {
-				if (node.representation === "string") return "z.iso.date()";
-				return shouldCoerce(this.options.coercion, "dates") ? "z.coerce.date()" : "z.date()";
+				const codec = getCodec(node);
+				if (codec) return this.options.direction === "input" ? codec.encode(node) : codec.decode(node);
+				return "z.iso.date()";
 			},
 			datetime(node) {
 				const offset = node.offset || this.options.dateType === "stringOffset";
@@ -574,7 +714,8 @@ const printerZod = ast.definePrinter((options) => {
 			ref(node) {
 				if (!node.name) return null;
 				const refName = node.ref ? ast.extractRefName(node.ref) ?? node.name : node.name;
-				const resolvedName = node.ref ? this.options.resolver?.default(refName, "function") ?? refName : node.name;
+				const useInputVariant = node.ref != null && this.options.direction === "input" && containsCodec(node);
+				const resolvedName = node.ref ? useInputVariant ? this.options.resolver?.resolveInputSchemaName(refName) ?? refName : this.options.resolver?.default(refName, "function") ?? refName : node.name;
 				if (node.ref && this.options.cyclicSchemas?.has(refName)) return `z.lazy(() => ${resolvedName})`;
 				return resolvedName;
 			},
@@ -841,6 +982,54 @@ const printerZodMini = ast.definePrinter((options) => {
 const zodPrinterCache = /* @__PURE__ */ new WeakMap();
 const zodMiniPrinterCache = /* @__PURE__ */ new WeakMap();
 /**
+* Returns the cached `output`/`input` direction printers for a resolver, building them on
+* first use. The `input` printer encodes `Date → string` for request bodies; `output` decodes
+* `string → Date` for responses. Schemas without `dateType: 'date'` fields print identically.
+*/
+function getStdPrinters(resolver, params) {
+	const cached = zodPrinterCache.get(resolver);
+	if (cached && cached.coercion === params.coercion && cached.guidType === params.guidType && cached.dateType === params.dateType) return {
+		output: cached.output,
+		input: cached.input
+	};
+	const base = {
+		...params,
+		resolver
+	};
+	const output = printerZod({
+		...base,
+		direction: "output"
+	});
+	const input = printerZod({
+		...base,
+		direction: "input"
+	});
+	zodPrinterCache.set(resolver, {
+		output,
+		input,
+		coercion: params.coercion,
+		guidType: params.guidType,
+		dateType: params.dateType
+	});
+	return {
+		output,
+		input
+	};
+}
+function getMiniPrinter(resolver, params) {
+	const cached = zodMiniPrinterCache.get(resolver);
+	if (cached && cached.guidType === params.guidType) return cached.printer;
+	const p = printerZodMini({
+		...params,
+		resolver
+	});
+	zodMiniPrinterCache.set(resolver, {
+		printer: p,
+		guidType: params.guidType
+	});
+	return p;
+}
+/**
 * Built-in generator for `@kubb/plugin-zod`. Emits one Zod schema per
 * schema in the spec plus per-operation request/response/parameter schemas.
 * When `mini: true`, schemas use the Zod Mini functional API instead of
@@ -856,7 +1045,10 @@ const zodGenerator = defineGenerator({
 		if (!node.name) return;
 		const mode = ctx.getMode(output);
 		const isZodImport = ZOD_NAMESPACE_IMPORTS.has(importPath);
-		const imports = adapter.getImports(node, (schemaName) => ({
+		const cyclicSchemas = new Set(ctx.meta.circularNames);
+		const hasCodec = !mini && containsCodec(node);
+		const codecRefNames = new Set(hasCodec ? ast.collect(node, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? void 0 : void 0 }) : []);
+		const importEntries = adapter.getImports(node, (schemaName) => ({
 			name: resolver.resolveSchemaName(schemaName),
 			path: resolver.resolveFile({
 				name: schemaName,
@@ -867,6 +1059,24 @@ const zodGenerator = defineGenerator({
 				group: group ?? void 0
 			}).path
 		}));
+		const inputImportEntries = hasCodec ? [...codecRefNames].map((schemaName) => ({
+			name: resolver.resolveInputSchemaName(schemaName),
+			path: resolver.resolveFile({
+				name: schemaName,
+				extname: ".ts"
+			}, {
+				root,
+				output,
+				group: group ?? void 0
+			}).path
+		})) : [];
+		const seenImports = /* @__PURE__ */ new Set();
+		const imports = [...importEntries, ...inputImportEntries].filter((imp) => {
+			const key = `${Array.isArray(imp.name) ? imp.name.join(",") : imp.name}|${imp.path}`;
+			if (seenImports.has(key)) return false;
+			seenImports.add(key);
+			return true;
+		});
 		const meta = {
 			name: resolver.resolveSchemaName(node.name),
 			file: resolver.resolveFile({
@@ -879,44 +1089,20 @@ const zodGenerator = defineGenerator({
 			})
 		};
 		const inferTypeName = inferred ? resolver.resolveSchemaTypeName(node.name) : null;
-		const cyclicSchemas = new Set(ctx.meta.circularNames);
-		const schemaPrinter = mini ? getCachedMiniPrinter() : getCachedStdPrinter();
-		function getCachedStdPrinter() {
-			const cached = zodPrinterCache.get(resolver);
-			if (cached && cached.coercion === coercion && cached.guidType === guidType && cached.dateType === dateType) return cached.printer;
-			const p = printerZod({
-				coercion,
-				guidType,
-				dateType,
-				wrapOutput,
-				resolver,
-				cyclicSchemas,
-				nodes: printer?.nodes
-			});
-			zodPrinterCache.set(resolver, {
-				printer: p,
-				coercion,
-				guidType,
-				dateType
-			});
-			return p;
-		}
-		function getCachedMiniPrinter() {
-			const cached = zodMiniPrinterCache.get(resolver);
-			if (cached && cached.guidType === guidType) return cached.printer;
-			const p = printerZodMini({
-				guidType,
-				wrapOutput,
-				resolver,
-				cyclicSchemas,
-				nodes: printer?.nodes
-			});
-			zodMiniPrinterCache.set(resolver, {
-				printer: p,
-				guidType
-			});
-			return p;
-		}
+		const stdPrinters = mini ? null : getStdPrinters(resolver, {
+			coercion,
+			guidType,
+			dateType,
+			wrapOutput,
+			cyclicSchemas,
+			nodes: printer?.nodes
+		});
+		const schemaPrinter = mini ? getMiniPrinter(resolver, {
+			guidType,
+			wrapOutput,
+			cyclicSchemas,
+			nodes: printer?.nodes
+		}) : stdPrinters.output;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
@@ -947,17 +1133,28 @@ const zodGenerator = defineGenerator({
 					root: meta.file.path,
 					path: imp.path,
 					name: imp.name
-				}, [node.name, imp.path].join("-"))),
+				}, [
+					node.name,
+					imp.path,
+					imp.name
+				].join("-"))),
 				/* @__PURE__ */ jsx(Zod, {
 					name: meta.name,
 					node,
 					printer: schemaPrinter,
 					inferTypeName
+				}),
+				hasCodec && stdPrinters && /* @__PURE__ */ jsx(Zod, {
+					name: resolver.resolveInputSchemaName(node.name),
+					node,
+					printer: stdPrinters.input,
+					inferTypeName: inferred ? resolver.resolveInputSchemaTypeName(node.name) : null
 				})
 			]
 		});
 	},
 	operation(node, ctx) {
+		if (!ast.isHttpOperationNode(node)) return null;
 		const { adapter, config, resolver, root } = ctx;
 		const { output, coercion, guidType, mini, wrapOutput, inferred, importPath, group, paramsCasing, printer } = ctx.options;
 		const dateType = adapter.options.dateType;
@@ -975,11 +1172,12 @@ const zodGenerator = defineGenerator({
 			group: group ?? void 0
 		}) };
 		const cyclicSchemas = new Set(ctx.meta.circularNames);
-		function renderSchemaEntry({ schema, name, keysToOmit }) {
+		function renderSchemaEntry({ schema, name, keysToOmit, direction = "output" }) {
 			if (!schema) return null;
 			const inferTypeName = inferred ? resolver.resolveTypeName(name) : null;
+			const codecRefNames = direction === "input" && !mini ? new Set(ast.collect(schema, { schema: (n) => n.type === "ref" && n.ref && containsCodec(n) ? ast.extractRefName(n.ref) ?? void 0 : void 0 })) : null;
 			const imports = adapter.getImports(schema, (schemaName) => ({
-				name: resolver.resolveSchemaName(schemaName),
+				name: codecRefNames?.has(schemaName) ? resolver.resolveInputSchemaName(schemaName) : resolver.resolveSchemaName(schemaName),
 				path: resolver.resolveFile({
 					name: schemaName,
 					extname: ".ts"
@@ -989,8 +1187,6 @@ const zodGenerator = defineGenerator({
 					group: group ?? void 0
 				}).path
 			}));
-			const cachedStd = zodPrinterCache.get(resolver);
-			const cachedMini = zodMiniPrinterCache.get(resolver);
 			const schemaPrinter = mini ? keysToOmit?.length ? printerZodMini({
 				guidType,
 				wrapOutput,
@@ -998,10 +1194,9 @@ const zodGenerator = defineGenerator({
 				keysToOmit,
 				cyclicSchemas,
 				nodes: printer?.nodes
-			}) : cachedMini?.guidType === guidType ? cachedMini.printer : printerZodMini({
+			}) : getMiniPrinter(resolver, {
 				guidType,
 				wrapOutput,
-				resolver,
 				cyclicSchemas,
 				nodes: printer?.nodes
 			}) : keysToOmit?.length ? printerZod({
@@ -1012,16 +1207,16 @@ const zodGenerator = defineGenerator({
 				resolver,
 				keysToOmit,
 				cyclicSchemas,
-				nodes: printer?.nodes
-			}) : cachedStd?.coercion === coercion && cachedStd?.guidType === guidType && cachedStd?.dateType === dateType ? cachedStd.printer : printerZod({
+				nodes: printer?.nodes,
+				direction
+			}) : getStdPrinters(resolver, {
 				coercion,
 				guidType,
 				dateType,
 				wrapOutput,
-				resolver,
 				cyclicSchemas,
 				nodes: printer?.nodes
-			});
+			})[direction];
 			return /* @__PURE__ */ jsxs(Fragment, { children: [mode === "split" && imports.map((imp) => /* @__PURE__ */ jsx(File.Import, {
 				root: meta.file.path,
 				path: imp.path,
@@ -1037,22 +1232,48 @@ const zodGenerator = defineGenerator({
 				inferTypeName
 			})] });
 		}
+		function buildContentTypeVariants(entries, baseName, decorate, direction) {
+			const variants = resolveContentTypeVariants(entries, baseName);
+			const unionSchema = ast.createSchema({
+				type: "union",
+				members: variants.map((variant) => ast.createSchema({
+					type: "ref",
+					name: variant.name
+				}))
+			});
+			return /* @__PURE__ */ jsxs(Fragment, { children: [variants.map((variant) => renderSchemaEntry({
+				schema: decorate ? decorate(variant.schema) : variant.schema,
+				name: variant.name,
+				keysToOmit: variant.keysToOmit,
+				direction
+			})), renderSchemaEntry({
+				schema: unionSchema,
+				name: baseName,
+				direction
+			})] });
+		}
 		const paramSchemas = params.map((param) => renderSchemaEntry({
 			schema: param.schema,
-			name: resolver.resolveParamName(node, param)
+			name: resolver.resolveParamName(node, param),
+			direction: "input"
 		}));
-		const responseSchemas = node.responses.map((res) => renderSchemaEntry({
-			schema: res.content?.[0]?.schema ?? null,
-			name: resolver.resolveResponseStatusName(node, res.statusCode),
-			keysToOmit: res.content?.[0]?.keysToOmit
-		}));
-		const responsesWithSchema = node.responses.filter((res) => res.content?.[0]?.schema);
+		const responseSchemas = node.responses.map((res) => {
+			const variants = (res.content ?? []).filter((entry) => entry.schema);
+			if (variants.length > 1) return buildContentTypeVariants(res.content, resolver.resolveResponseStatusName(node, res.statusCode));
+			const primary = variants[0] ?? res.content?.[0];
+			return renderSchemaEntry({
+				schema: primary?.schema ?? null,
+				name: resolver.resolveResponseStatusName(node, res.statusCode),
+				keysToOmit: primary?.keysToOmit
+			});
+		});
+		const responsesWithSchema = node.responses.filter((res) => res.content?.some((entry) => entry.schema));
 		const responseUnionSchema = responsesWithSchema.length > 0 ? (() => {
 			const responseUnionName = resolver.resolveResponseName(node);
-			if (new Set(responsesWithSchema.flatMap((res) => res.content?.[0]?.schema ? adapter.getImports(res.content[0].schema, (schemaName) => ({
+			if (new Set(responsesWithSchema.flatMap((res) => (res.content ?? []).flatMap((entry) => entry.schema ? adapter.getImports(entry.schema, (schemaName) => ({
 				name: resolver.resolveSchemaName(schemaName),
 				path: ""
-			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : [])).has(responseUnionName)) return null;
+			})).flatMap((imp) => Array.isArray(imp.name) ? imp.name : [imp.name]) : []))).has(responseUnionName)) return null;
 			const members = responsesWithSchema.map((res) => ast.createSchema({
 				type: "ref",
 				name: resolver.resolveResponseStatusName(node, res.statusCode)
@@ -1065,14 +1286,27 @@ const zodGenerator = defineGenerator({
 				name: responseUnionName
 			});
 		})() : null;
-		const requestSchema = node.requestBody?.content?.[0]?.schema ? renderSchemaEntry({
-			schema: {
-				...node.requestBody.content[0].schema,
-				description: node.requestBody.description ?? node.requestBody.content[0].schema.description
-			},
-			name: resolver.resolveDataName(node),
-			keysToOmit: node.requestBody.content[0].keysToOmit
-		}) : null;
+		const requestBodyContent = node.requestBody?.content ?? [];
+		const requestSchema = (() => {
+			if (requestBodyContent.length === 0) return null;
+			if (requestBodyContent.length === 1) {
+				const entry = requestBodyContent[0];
+				if (!entry.schema) return null;
+				return renderSchemaEntry({
+					schema: {
+						...entry.schema,
+						description: node.requestBody.description ?? entry.schema.description
+					},
+					name: resolver.resolveDataName(node),
+					keysToOmit: entry.keysToOmit,
+					direction: "input"
+				});
+			}
+			return buildContentTypeVariants(requestBodyContent, resolver.resolveDataName(node), (schema) => ({
+				...schema,
+				description: node.requestBody.description ?? schema.description
+			}), "input");
+		})();
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
 			path: meta.file.path,
@@ -1119,7 +1353,7 @@ const zodGenerator = defineGenerator({
 			output,
 			group: group ?? void 0
 		}) };
-		const transformedOperations = nodes.map((node) => {
+		const transformedOperations = nodes.filter(ast.isHttpOperationNode).map((node) => {
 			return {
 				node,
 				data: buildSchemaNames(node, {
@@ -1218,6 +1452,12 @@ const resolverZod = defineResolver(() => {
 		resolveSchemaTypeName(name) {
 			return ensureValidVarName(pascalCase(name, { suffix: "schema" }));
 		},
+		resolveInputSchemaName(name) {
+			return this.resolveSchemaName(`${name} input`);
+		},
+		resolveInputSchemaTypeName(name) {
+			return this.resolveSchemaTypeName(`${name} input`);
+		},
 		resolveTypeName(name) {
 			return ensureValidVarName(pascalCase(name));
 		},
@@ -1287,13 +1527,7 @@ const pluginZod = definePlugin((options) => {
 		path: "zod",
 		barrelType: "named"
 	}, group, exclude = [], include, override = [], typed = false, operations = false, mini = false, guidType = "uuid", importPath = mini ? "zod/mini" : "zod", coercion = false, inferred = false, wrapOutput = void 0, paramsCasing, printer, resolver: userResolver, transformer: userTransformer, generators: userGenerators = [] } = options;
-	const groupConfig = group ? {
-		...group,
-		name: (ctx) => {
-			if (group.type === "path") return `${ctx.group.split("/")[1]}`;
-			return `${camelCase(ctx.group)}Controller`;
-		}
-	} : null;
+	const groupConfig = createGroupConfig(group, { suffix: "Controller" });
 	return {
 		name: pluginZodName,
 		options,