@kubb/plugin-zod 5.8.0 → 5.8.2

package/dist/index.js

@@ -52,6 +52,22 @@ function resolveContentTypeVariants(entries, baseName) {
 }
 const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 /**
+* An OpenAPI 3.2 `querystring` parameter is the whole query string, so a form-encoded object becomes one query parameter
+* per property, typed and serialized like any other.
+* Another content type, such as JSON, stays one parameter named after it, and the runtime sends its value as the whole query string.
+*/
+function spreadQuerystring(param) {
+	const schema = param.schema.type === "ref" ? param.schema.schema : param.schema;
+	const formEncoded = !param.contentType || param.contentType.split(";")[0].trim().toLowerCase() === "application/x-www-form-urlencoded";
+	if (schema?.type !== "object" || !formEncoded) return [param];
+	return schema.properties.map((property) => ast.factory.createParameter({
+		name: property.name,
+		in: "query",
+		schema: property.schema,
+		required: param.required && property.required
+	}));
+}
+/**
 * Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
 * group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
 * (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
@@ -60,17 +76,18 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
-	const group = (location) => {
+	const dedupe = (params) => {
 		const seen = /* @__PURE__ */ new Set();
-		return node.parameters.filter((param) => {
-			if (param.in !== location || seen.has(param.name)) return false;
+		return params.filter((param) => {
+			if (seen.has(param.name)) return false;
 			seen.add(param.name);
 			return true;
 		});
 	};
+	const group = (location) => dedupe(node.parameters.filter((param) => param.in === location));
 	const groups = {
 		path: group("path"),
-		query: group("query"),
+		query: dedupe([...group("query"), ...group("querystring").flatMap(spreadQuerystring)]),
 		header: group("header"),
 		cookie: group("cookie")
 	};
@@ -1259,6 +1276,37 @@ function printWithOmit(ctx, node, modify, mini = false) {
 }
 // src/printers/zodNodes.ts
 /**
+* Reads a union of bare single-value enums as one enum, except under `xor` or an enum override, which need each member.
+* Only a numeric union with a `format` coerces, because it printed as `z.coerce.number()` before the adapter kept its values.
+*/
+function getLiteralUnion({ node, options }) {
+	if (node.strategy === "one" && options.oneOfType === "xor" || options.nodes?.enum) return void 0;
+	const values = (node.members ?? []).map((member) => {
+		const enumNode = ast.narrowSchema(member, ast.schemaTypes.enum);
+		return enumNode && !enumNode.name && !enumNode.nullable && !enumNode.namedEnumValues && enumNode.enumValues?.length === 1 ? enumNode.enumValues[0] : void 0;
+	});
+	if (!values.length || !values.every((value) => value !== void 0 && value !== null)) return void 0;
+	return {
+		values,
+		coerce: !!node.format && values.every((value) => typeof value === "number") && shouldCoerce(options.coercion, "numbers")
+	};
+}
+/**
+* Whether a discriminated union member's discriminator property prints as a coerced literal union.
+*/
+function hasCoercedDiscriminator({ member, propertyName, options }) {
+	return ast.resolveSchemaProperties({
+		node: member,
+		propertyName
+	}).some(({ schema }) => {
+		const resolved = syncSchemaRef(schema);
+		return resolved.type === "union" && !!getLiteralUnion({
+			node: resolved,
+			options
+		})?.coerce;
+	});
+}
+/**
 * Builds the scalar handlers both dialects share. They never recurse into children. The temporal
 * scalars and `bigint` differ per dialect, so each printer adds its own.
 */
@@ -1397,8 +1445,21 @@ function buildZodNodes(dialect, cyclicSchemas) {
 			return `z.tuple(${buildList(mapSchemaItems(node, (item) => this.transform(item)).map(({ output }) => output).filter(Boolean))})`;
 		},
 		union(node) {
+			const literalUnion = getLiteralUnion({
+				node,
+				options: this.options
+			});
+			if (literalUnion) {
+				const schema = buildEnum(literalUnion.values);
+				return literalUnion.coerce ? dialect.coercedNumber(schema) : schema;
+			}
 			const nodeMembers = node.members ?? [];
-			const isDiscriminated = !!node.discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemas));
+			const { discriminatorPropertyName } = node;
+			const isDiscriminated = !!discriminatorPropertyName && nodeMembers.every((m) => isObjectSchemaNode(m, cyclicSchemas)) && !nodeMembers.some((m) => hasCoercedDiscriminator({
+				member: m,
+				propertyName: discriminatorPropertyName,
+				options: this.options
+			}));
 			const isXor = node.strategy === "one" && !isDiscriminated && this.options.oneOfType === "xor";
 			const isStrict = node.strategy === "one" && !isXor && !unionsWithSiblings.has(node);
 			const members = mapSchemaMembers(node, (memberNode) => this.transform(isStrict ? strictOneOfNode(memberNode) : memberNode)).map(({ schema, output }) => output && isStrict && dialect.strictMember ? dialect.strictMember(output, schema, cyclicSchemas) : output).filter(Boolean);
@@ -1584,6 +1645,7 @@ const standardDialect = {
 	patternKey: patternKeySchema,
 	objectShape: buildZodObjectShape,
 	coercedInt: "z.coerce.number().int()",
+	coercedNumber: (schema) => `z.coerce.number().pipe(${schema})`,
 	catchall: (object, value) => `${object}.catchall(${value})`,
 	nullable: (value) => `${value}.nullable()`,
 	unique: (array) => `${array}.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" })`,
@@ -1692,6 +1754,7 @@ const miniDialect = {
 	patternKey: patternKeySchemaMini,
 	objectShape: buildZodMiniObjectShape,
 	coercedInt: "z.coerce.number().check(z.int())",
+	coercedNumber: (schema) => `z.pipe(z.coerce.number(), ${schema})`,
 	catchall: (object, value) => `z.catchall(${object}, ${value})`,
 	nullable: (value) => `z.nullable(${value})`,
 	unique: (array) => `${array}.check(z.refine(items => new Set(items).size === items.length, { message: "Array entries must be unique" }))`,
@@ -2118,11 +2181,11 @@ const zodGenerator = defineGenerator({
 });
 // kubb-extension.json
 var compatibility = {
-	"kubb": ">=5.14.6",
+	"kubb": ">=5.16.0",
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.8.0";
+var version = "5.8.2";
 // src/resolvers/resolverZod.ts
 /**
 * Default resolver used by `@kubb/plugin-zod`. Decides the names and file