@kubb/plugin-fetch 5.9.0-canary.20261024T190549 → 5.9.1

package/dist/index.cjs

@@ -472,7 +472,7 @@ function createGroupConfig(group) {
 function isValidatorEnabled(validator) {
 	if (!validator) return false;
 	if (validator === "zod") return true;
-	return Boolean(validator.request || validator.response);
+	return Boolean(validator.request || validator.params || validator.response);
 }
 /**
 * Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
@@ -483,6 +483,14 @@ function resolveRequestValidator(validator) {
 	return validator.request ?? null;
 }
 /**
+* Returns `'zod'` when path, query, and header params parsing is enabled, `null` otherwise. Only the
+* object form `{ params: 'zod' }` enables it.
+*/
+function resolveParamsValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.params ?? null;
+}
+/**
 * Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
 * maps to response parsing.
 */
@@ -501,30 +509,6 @@ function buildZodErrorParse(node, zodResolver) {
 	return zodResolver.response.error?.(node) || null;
 }
 //#endregion
-//#region ../../internals/client/src/builders/validator.ts
-/**
-* Builds the validator-hook references for one operation. Request validation runs before the send;
-* response validation runs on the success body only. Returns `null` references when the matching
-* direction is disabled or the schema is absent.
-*/
-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 request = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) || null : null;
-	return {
-		request,
-		response,
-		error,
-		importedZodNames: [
-			response,
-			error,
-			request
-		].filter((name) => Boolean(name))
-	};
-}
-//#endregion
 //#region ../../internals/client/src/builders/security.ts
 function serializeAuth(auth) {
 	const parts = [`type: '${auth.type}'`];
@@ -597,6 +581,49 @@ function buildSecurityMetadata({ security }) {
 	return `[${security.map(serializeAuth).join(", ")}]`;
 }
 //#endregion
+//#region ../../internals/client/src/builders/validator.ts
+/**
+* Builds the validator-hook references for one operation. Request body and params validation run before the send.
+* Response validation runs on the success body only. Returns `null` references when the matching
+* direction is disabled or the schema is absent.
+*/
+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 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;
+	const path = resolveParamsName("path", paramGroups.path);
+	const query = resolveParamsName("query", paramGroups.query);
+	const headers = resolveParamsName("headers", paramGroups.header);
+	const importedZodNames = [
+		response,
+		error,
+		request,
+		path,
+		query,
+		headers
+	].filter((name) => Boolean(name));
+	return {
+		request,
+		path,
+		query,
+		headers: headers ? `toHeadersStandardSchema(${headers}, ${headers}.shape)` : null,
+		response,
+		error,
+		importedZodNames
+	};
+}
+/**
+* Prints the `validator: { … }` entry of a call config from the hooks named in `keys`, or `null` when none is set.
+*/
+function buildValidatorLiteral(hooks, keys) {
+	const entries = keys.flatMap((key) => hooks?.[key] ? [`${key}: ${hooks[key]}`] : []);
+	return entries.length ? `validator: { ${entries.join(", ")} }` : null;
+}
+//#endregion
 //#region ../../internals/client/src/builders/contentType.ts
 /**
 * Builds the `contentType` entry baked into the call config, or `null` for the JSON default.
@@ -801,12 +828,14 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 	const eventStream = isEventStream(node);
 	const responseType = getResponseType(node);
 	const responseTypeLiteral = responseType ? `responseType: '${responseType}'` : null;
-	const validatorEntries = [
-		validators.request ? `request: ${validators.request}` : null,
-		validators.response ? `response: ${validators.response}` : null,
-		validators.error ? `error: ${validators.error}` : null
-	].filter(Boolean);
-	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
+	const validatorLiteral = buildValidatorLiteral(validators, [
+		"request",
+		"path",
+		"query",
+		"headers",
+		"response",
+		"error"
+	]);
 	const callConfig = `{ ${[
 		`method: '${node.method.toUpperCase()}'`,
 		`url: '${node.path}'`,
@@ -853,14 +882,35 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 //#endregion
 //#region ../../internals/client/src/resolveOperationTypes.ts
 /**
-* Picks the plugin a generated client takes its `Options` and `Responses` types from.
+* A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
+* exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
+*/
+function toZodTypeResolver(resolver) {
+	const type = (name) => resolver.schema.type(name);
+	return {
+		...resolver,
+		file: resolver.file.bind(resolver),
+		param: {
+			name: (node, p) => type(resolver.param.name(node, p)),
+			path: (node, p) => type(resolver.param.path(node, p)),
+			query: (node, p) => type(resolver.param.query(node, p)),
+			headers: (node, p) => type(resolver.param.headers(node, p))
+		},
+		response: {
+			body: (node) => type(resolver.response.body(node)),
+			status: (node, statusCode) => type(resolver.response.status(node, statusCode)),
+			response: (node) => type(resolver.response.response(node)),
+			responses: (node) => type(resolver.response.responses(node)),
+			options: (node) => resolver.response.options(node)
+		}
+	};
+}
+/**
+* Picks the plugin generated clients, query hooks, and MCP handlers take their operation types from.
 *
-* `plugin-ts` wins whenever it is in the pipeline, so existing configs keep the types they generate
-* today. Without it, `pluginZod({ inferred: true })` takes over: its inferred options and responses
-* types are built from the same shared schemas as the `plugin-ts` ones, so a client typed off
-* `z.infer` carries what the codecs decode to (a `Temporal` instance, a `Date`) rather than the raw
-* wire type. Throws `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available, since the
-* client has nothing to type against.
+* `pluginZod({ inferred: 'codec' })` wins, so a codec param takes its domain value. Otherwise `plugin-ts`
+* wins when it is in the pipeline, and without it any `pluginZod({ inferred })`. Throws
+* `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available.
 *
 * @example
 * ```ts
@@ -870,16 +920,16 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 */
 function resolveOperationTypes(driver, pluginName) {
 	const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
-	if (pluginTs) {
+	const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
+	if (pluginTs && pluginZod?.options?.inferred !== "codec") {
 		const resolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
 		return {
 			response: resolver.response,
 			resolver,
 			output: pluginTs.options?.output,
-			group: pluginTs.options?.group
+			group: pluginTs.options?.group ?? void 0
 		};
 	}
-	const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
 	if (!pluginZod?.options?.inferred) throw new kubb_kit.Diagnostics.Error({
 		code: kubb_kit.Diagnostics.code.missingDependency,
 		severity: "error",
@@ -888,15 +938,12 @@ function resolveOperationTypes(driver, pluginName) {
 		location: { kind: "config" },
 		plugin: pluginName
 	});
-	const resolver = driver.getResolver(_kubb_plugin_zod.pluginZodName);
+	const resolver = toZodTypeResolver(driver.getResolver(_kubb_plugin_zod.pluginZodName));
 	return {
-		response: {
-			options: resolver.response.options,
-			responses: (node) => resolver.schema.type(resolver.response.responses(node))
-		},
+		response: resolver.response,
 		resolver,
 		output: pluginZod.options.output,
-		group: pluginZod.options.group
+		group: pluginZod.options.group ?? void 0
 	};
 }
 //#endregion
@@ -918,14 +965,15 @@ function createClientGenerator(name, resolveClientPath) {
 			const { config, driver, resolver, root } = ctx;
 			const { output, validator, returnType, throwOnErrorDefault, group } = ctx.options;
 			const types = resolveOperationTypes(driver, ctx.plugin.name);
-			const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(_kubb_plugin_zod.pluginZodName) : null;
+			const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(_kubb_plugin_zod.pluginZodName) : null;
 			const zodResolver = pluginZod ? driver.getResolver(_kubb_plugin_zod.pluginZodName) : null;
 			const importedTypeNames = [types.response.options(node), types.response.responses(node)];
-			const importedZodNames = buildValidatorHooks({
+			const validatorHooks = buildValidatorHooks({
 				node,
 				validator,
 				zodResolver
-			}).importedZodNames;
+			});
+			const importedZodNames = validatorHooks.importedZodNames;
 			const meta = {
 				name: resolver.name(node.operationId),
 				file: resolver.file({
@@ -957,6 +1005,7 @@ function createClientGenerator(name, resolveClientPath) {
 			const customClientPath = resolveClientPath?.(ctx.options, root);
 			const clientPath = customClientPath ?? node_path.default.resolve(root, ".kubb/client.ts");
 			const clientRoot = customClientPath === void 0 ? meta.file.path : void 0;
+			const standardSchemaPath = customClientPath ?? node_path.default.resolve(root, ".kubb/standardSchema.ts");
 			const eventStream = isEventStream(node);
 			const clientValueImports = (() => {
 				if (eventStream) return ["client", "toEventStream"];
@@ -1021,6 +1070,11 @@ function createClientGenerator(name, resolveClientPath) {
 						root: meta.file.path,
 						path: meta.fileZod.path
 					}),
+					validatorHooks.headers && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+						name: ["toHeadersStandardSchema"],
+						root: clientRoot,
+						path: standardSchemaPath
+					}),
 					/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(Operation, {
 						name: meta.name,
 						node,
@@ -1041,14 +1095,14 @@ function createClientGenerator(name, resolveClientPath) {
 /**
 * Builds the call config literal forwarded to the contract client; the `throwOnError` fallback is applied after the `...config` spread.
 */
-function buildCallConfig({ node, validator, zodResolver, security, throwOnErrorDefault }) {
-	const validators = buildValidatorHooks({
-		node,
-		validator,
-		zodResolver
-	});
-	const validatorEntries = [validators.request ? `request: ${validators.request}` : null, validators.response ? `response: ${validators.response}` : null].filter(Boolean);
-	const validatorLiteral = validatorEntries.length ? `validator: { ${validatorEntries.join(", ")} }` : null;
+function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault }) {
+	const validatorLiteral = buildValidatorLiteral(validatorHooks, [
+		"request",
+		"path",
+		"query",
+		"headers",
+		"response"
+	]);
 	const securityLiteral = buildSecurityMetadata({ security });
 	const { literal: contentTypeLiteral } = buildContentType({ node });
 	return `{ ${[
@@ -1064,7 +1118,7 @@ function buildCallConfig({ node, validator, zodResolver, security, throwOnErrorD
 /**
 * Builds one instance method of a generated SDK class; a per-call `options.client` overrides `this.client`.
 */
-function buildSdkMethod({ node, name, types, zodResolver, validator, security, returnType, throwOnErrorDefault }) {
+function buildSdkMethod({ node, name, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
 	if (!kubb_kit.ast.isHttpOperationNode(node)) return "";
 	const signature = buildGroupedOptionsSignature({
 		node,
@@ -1077,8 +1131,7 @@ function buildSdkMethod({ node, name, types, zodResolver, validator, security, r
 		types,
 		callConfig: buildCallConfig({
 			node,
-			validator,
-			zodResolver,
+			validatorHooks,
 			security,
 			throwOnErrorDefault
 		}),
@@ -1104,13 +1157,12 @@ function buildSdkMethod({ node, name, types, zodResolver, validator, security, r
 * instance: `const api = new PetClient({ baseURL }); api.getPetById(...)`. A per-call `client` option
 * still overrides the instance client for a one-off call.
 */
-function SdkClient({ name, operations, validator, returnType, throwOnErrorDefault }) {
-	const methods = operations.map(({ node, name: methodName, types, zodResolver, security }) => buildSdkMethod({
+function SdkClient({ name, operations, returnType, throwOnErrorDefault }) {
+	const methods = operations.map(({ node, name: methodName, types, validatorHooks, security }) => buildSdkMethod({
 		node,
 		name: methodName,
 		types,
-		zodResolver,
-		validator,
+		validatorHooks,
 		security,
 		returnType,
 		throwOnErrorDefault
@@ -1158,9 +1210,6 @@ function SdkFacade({ name, members }) {
 function resolveTypeImportNames(node, types) {
 	return [types.response.options(node), types.response.responses(node)];
 }
-function resolveZodImportNames(node, zodResolver, validator) {
-	return [resolveResponseValidator(validator) === "zod" ? zodResolver.response.response(node) : null, resolveRequestValidator(validator) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null].filter((n) => Boolean(n));
-}
 /**
 * Groups operations into one controller per tag. Operations without a tag fall back to a single
 * `Client`/`ApiClient` controller, matching the resolver's default naming.
@@ -1189,13 +1238,18 @@ function buildControllers(nodes, ctx, types) {
 			method: node.method,
 			path: node.path
 		}) : void 0;
+		const validatorHooks = zodResolver ? buildValidatorHooks({
+			node,
+			validator,
+			zodResolver
+		}) : null;
 		return {
 			node,
 			name: resolver.name(node.operationId),
 			types,
-			zodResolver,
 			typeFile,
 			zodFile,
+			validatorHooks,
 			security
 		};
 	}
@@ -1268,6 +1322,7 @@ function createSdkGenerator() {
 			});
 			const controllers = buildControllers(nodes, ctx, resolveOperationTypes(ctx.driver, ctx.plugin.name));
 			const clientPath = node_path.default.resolve(root, ".kubb/client.ts");
+			const standardSchemaPath = node_path.default.resolve(root, ".kubb/standardSchema.ts");
 			const banner = (file) => resolver.default.banner(ctx.meta, {
 				output,
 				config,
@@ -1291,7 +1346,7 @@ function createSdkGenerator() {
 				}));
 				const { namesByPath: zodNamesByPath, filesByPath: zodFilesByPath } = isValidatorEnabled(validator) ? collectImportsByFile(ops, (op) => ({
 					file: op.zodFile,
-					names: op.zodResolver ? resolveZodImportNames(op.node, op.zodResolver, validator) : []
+					names: op.validatorHooks?.importedZodNames.filter((name) => name !== op.validatorHooks?.error) ?? []
 				})) : {
 					namesByPath: /* @__PURE__ */ new Map(),
 					filesByPath: /* @__PURE__ */ new Map()
@@ -1341,10 +1396,14 @@ function createSdkGenerator() {
 							root: file.path,
 							path: zodFilesByPath.get(filePath).path
 						}, filePath)),
+						ops.some((op) => op.validatorHooks?.headers) && /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Import, {
+							name: ["toHeadersStandardSchema"],
+							root: file.path,
+							path: standardSchemaPath
+						}),
 						/* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(SdkClient, {
 							name: className,
 							operations: ops,
-							validator,
 							returnType,
 							throwOnErrorDefault
 						})
@@ -1447,7 +1506,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.9.0-canary.20261024T190549";
+var version = "5.9.1";
 //#endregion
 //#region src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */