@kubb/plugin-client 6.1.0-canary.20261109T175349 → 6.1.0-canary.20261109T175913

package/dist/index.js

@@ -521,7 +521,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "6.1.0-canary.20261109T175349";
+var version = "6.1.0-canary.20261109T175913";
 // ../../internals/client/src/builders/validatorOptions.ts
 /**
 * Returns `true` when any direction of the validator uses zod (used for dependency checks).
@@ -557,22 +557,19 @@ function resolveResponseValidator(validator) {
 	return validator.response ?? null;
 }
 /**
-* Resolves the zod schema name a generated client validates an error body with on the non-throw path.
-* Uses the error-only `<operation>ErrorSchema` (the union of non-2xx statuses); returns `null` when the
-* operation documents no error responses with a schema.
+* Builds the `validator.error` map of a call, one plugin-zod `<operation>StatusNNNSchema` per non-2xx response with a
+* schema, such as `{ 404: getPetStatus404Schema, '5XX': getPetStatus5XXSchema }`. Returns `null` without one.
 */
 function buildZodErrorParse(node, zodResolver) {
-	if (!getErrorStatusCodes(node).length) return null;
-	return zodResolver.response.error?.(node) || null;
-}
-/** Prints the statuses `<operation>ErrorSchema` covers, such as `[404, '5XX']`, or `null` when a `default` response covers them all. */
-function buildErrorStatusLiteral(node) {
-	const statusCodes = getErrorStatusCodes(node);
-	if (!statusCodes.length || statusCodes.includes("default")) return null;
-	return `[${statusCodes.map((statusCode) => /^\d+$/.test(statusCode) ? statusCode : stringify(statusCode)).join(", ")}]`;
-}
-function getErrorStatusCodes(node) {
-	return node.responses.filter((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema)).map((res) => String(res.statusCode));
+	const entries = node.responses.filter((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema)).map((res) => ({
+		key: String(res.statusCode),
+		name: zodResolver.response.status(node, res.statusCode)
+	}));
+	if (!entries.length) return null;
+	return {
+		literal: `{ ${entries.map(({ key, name }) => `${/^\d+$/.test(key) ? key : stringify(key)}: ${name}`).join(", ")} }`,
+		names: entries.map(({ name }) => name)
+	};
 }
 // ../../internals/client/src/builders/generics.ts
 /**
@@ -777,8 +774,7 @@ function buildValidatorHooks({ node, validator, zodResolver }) {
 	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
 	const parsesResponse = zodResolver && resolveResponseValidator(validator) === "zod";
 	const response = parsesResponse ? zodResolver.response.response(node) || null : null;
-	const error = parsesResponse ? buildZodErrorParse(node, zodResolver) : null;
-	const errorStatus = error ? buildErrorStatusLiteral(node) : null;
+	const errorParse = parsesResponse ? buildZodErrorParse(node, zodResolver) : null;
 	const request = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) || null : null;
 	const paramGroups = getOperationParameters(node);
 	const resolveParamsName = (kind, params) => zodResolver && resolveParamsValidator(validator) === "zod" && params.length > 0 ? zodResolver.param[kind](node, params[0]) : null;
@@ -788,7 +784,7 @@ function buildValidatorHooks({ node, validator, zodResolver }) {
 	const cookies = resolveParamsName("cookies", paramGroups.cookie);
 	const importedZodNames = [
 		response,
-		error,
+		...errorParse?.names ?? [],
 		request,
 		path,
 		query,
@@ -802,17 +798,17 @@ function buildValidatorHooks({ node, validator, zodResolver }) {
 		headers: headers ? `toHeadersStandardSchema(${headers}, ${headers}.shape)` : null,
 		cookies,
 		response,
-		error,
-		errorStatus,
+		error: errorParse?.literal ?? null,
 		importedZodNames
 	};
 }
 /**
 * Prints the `validator: { … }` entry of a call config from the hooks named in `keys`, or `null` when none is set.
+* The entry spreads `config.validator` last, so a per-call hook overrides the generated one for its key only.
 */
 function buildValidatorLiteral(hooks, keys) {
 	const entries = keys.flatMap((key) => hooks?.[key] ? [`${key}: ${hooks[key]}`] : []);
-	return entries.length ? `validator: { ${entries.join(", ")} }` : null;
+	return entries.length ? `validator: { ${entries.join(", ")}, ...config.validator }` : null;
 }
 // ../../internals/client/src/builders/contentType.ts
 /**
@@ -865,13 +861,13 @@ function serializeParameter(parameter) {
 	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
 }
 /**
-* Serializes the `encoding` of the request body's default content type into a `{ property: { ... } }`
-* literal, or `null` when it carries none. Only an operation with a single request content type
+* Serializes the `encoding` of the request body's default content type into `property: { ... }`
+* entries, empty when it carries none. Only an operation with a single request content type
 * emits it, because the runtime applies `styles.body` to whichever type the caller selects.
 */
 function serializeBodyEncoding(node) {
 	const content = node.requestBody?.content;
-	const entries = Object.entries(content?.length === 1 ? content[0]?.encoding ?? {} : {}).map(([property, { contentType, style, explode, allowReserved }]) => {
+	return Object.entries(content?.length === 1 ? content[0]?.encoding ?? {} : {}).map(([property, { contentType, style, explode, allowReserved }]) => {
 		const parts = [
 			style && `style: ${JSON.stringify(style)}`,
 			explode !== void 0 && `explode: ${explode}`,
@@ -880,7 +876,6 @@ function serializeBodyEncoding(node) {
 		].filter(Boolean);
 		return `${isValidVarName(property) ? property : JSON.stringify(property)}: { ${parts.join(", ")} }`;
 	});
-	return entries.length > 0 ? `body: { ${entries.join(", ")} }` : null;
 }
 /**
 * Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
@@ -890,26 +885,31 @@ function serializeBodyEncoding(node) {
 * is unchanged. A form request body adds a `body` group keyed by property name from its `encoding`.
 * Returns `null` when nothing carries metadata.
 *
+* With `merge`, the literal spreads `config.styles` per parameter, so a per-call entry overrides the generated one for
+* that parameter and leaves the others in place.
+*
 * @example
 * ```ts
 * // a path param with { style: 'matrix', explode: true } and a query param with { explode: false }
 * buildStyles({ node }) // "{ path: { id: { style: 'matrix', explode: true } }, query: { tags: { explode: false } } }"
 * ```
 */
-function buildStyles({ node }) {
+function buildStyles({ node, merge }) {
 	if (!ast.isHttpOperationNode(node)) return null;
 	const groups = {
 		path: [],
 		query: [],
 		header: [],
-		cookie: []
+		cookie: [],
+		body: serializeBodyEncoding(node)
 	};
 	for (const [location, parameters] of Object.entries(getOperationParameters(node))) for (const parameter of parameters) {
 		const literal = serializeParameter(parameter);
 		if (literal) groups[location].push(`${toKey(parameter.name)}: ${literal}`);
 	}
-	const entries = [...Object.keys(groups).filter((location) => groups[location].length > 0).map((location) => `${location}: { ${groups[location].join(", ")} }`), serializeBodyEncoding(node)].filter(Boolean);
-	return entries.length > 0 ? `{ ${entries.join(", ")} }` : null;
+	const entries = Object.entries(groups).filter(([, items]) => items.length > 0).map(([location, items]) => `${location}: { ${(merge ? [...items, `...config.styles?.${location}`] : items).join(", ")} }`);
+	if (entries.length === 0) return null;
+	return `{ ${(merge ? ["...config.styles", ...entries] : entries).join(", ")} }`;
 }
 // ../../internals/client/src/builders/callConfig.ts
 /**
@@ -925,7 +925,9 @@ function buildResponseTypeLiteral(node) {
 }
 /**
 * Builds the call config literal a generated operation forwards to the client, shared by the standalone
-* functions and the SDK methods. The `throwOnError` fallback is applied after the `...config` spread.
+* functions and the SDK methods. The `validator` and `throwOnError` entries come after the `...config` spread, so a
+* per-call `validator` is merged per key with the generated one instead of replacing it. `styles` is merged the same
+* way, per parameter, unless `returnType` is `'plain'`.
 *
 * `mergeContentType` is `true` when the caller must destructure `contentType` from `options`, and
 * `eventStream` is `true` when the operation streams `text/event-stream` or JSON Lines. Unless `returnType` is `'plain'`, a
@@ -934,16 +936,20 @@ function buildResponseTypeLiteral(node) {
 function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault, returnType }) {
 	const eventStream = isEventStream(node);
 	const securityLiteral = buildSecurityMetadata({ security });
-	const stylesLiteral = buildStyles({ node });
+	const ownRuntime = returnType !== "plain";
+	const stylesLiteral = buildStyles({
+		node,
+		merge: ownRuntime
+	});
+	const styles = stylesLiteral ? `styles: ${stylesLiteral}` : null;
 	const validatorLiteral = buildValidatorLiteral(validatorHooks, [
 		"request",
 		"path",
 		"query",
 		"headers",
 		"cookies",
-		...eventStream && returnType !== "plain" ? [] : ["response"],
-		"error",
-		"errorStatus"
+		...eventStream && ownRuntime ? [] : ["response"],
+		"error"
 	]);
 	const { literal: contentTypeLiteral, merge: mergeContentType } = buildContentType({ node });
 	return {
@@ -951,11 +957,12 @@ function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault,
 			`method: '${node.method.toUpperCase()}'`,
 			`url: '${node.path}'`,
 			securityLiteral ? `security: ${securityLiteral}` : null,
-			stylesLiteral ? `styles: ${stylesLiteral}` : null,
-			validatorLiteral,
+			ownRuntime ? null : styles,
 			contentTypeLiteral,
 			buildResponseTypeLiteral(node),
 			"...config",
+			ownRuntime ? styles : null,
+			validatorLiteral,
 			`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
 		].filter(Boolean).join(", ")} }`,
 		mergeContentType,