@kubb/plugin-fetch 6.1.0-canary.20261109T175349 → 6.1.0-canary.20261109T191216

package/dist/index.cjs

@@ -594,22 +594,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
 /**
@@ -804,6 +801,18 @@ function buildSecurityMetadata({ security }) {
 	if (!security?.length) return null;
 	return `[${security.map(serializeAuth).join(", ")}]`;
 }
+// ../../internals/client/src/builders/server.ts
+/**
+* Returns the URL of the operation's own `servers`, else its path item's, picked with `server.index` and falling back to the
+* first entry. Returns `undefined` without `servers`, for a relative URL such as `/v2`, which would drop the client's host, or
+* for a URL with `{variable}` placeholders, which are not supported, so the client's `baseURL` applies.
+*/
+function getOperationBaseURL({ document, method, path, server: { index = 0 } = {} }) {
+	const pathItem = document?.paths?.[path];
+	const servers = [(pathItem?.[method.toLowerCase()])?.servers, pathItem?.servers].find((list) => list?.length);
+	const url = (servers?.[index] ?? servers?.[0])?.url;
+	return url && /^[a-z][a-z\d+.-]*:\/\/[^{}]*$/i.test(url) ? url : void 0;
+}
 // ../../internals/client/src/builders/validator.ts
 /**
 * Builds the validator-hook references for one operation. Request body and params validation run before the send.
@@ -814,8 +823,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;
@@ -825,7 +833,7 @@ function buildValidatorHooks({ node, validator, zodResolver }) {
 	const cookies = resolveParamsName("cookies", paramGroups.cookie);
 	const importedZodNames = [
 		response,
-		error,
+		...errorParse?.names ?? [],
 		request,
 		path,
 		query,
@@ -839,17 +847,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
 /**
@@ -902,13 +910,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}`,
@@ -917,7 +925,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.
@@ -927,26 +934,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 (!_kubb_kit.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
 /**
@@ -962,37 +974,45 @@ 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 operation's own `baseURL` comes before the `...config` spread, so a per-call one wins. The
+* `validator` and `throwOnError` entries come after it, 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
 * stream's literal leaves the `response` validator to `toEventStream`, which runs it per item.
 */
-function buildCallConfig({ node, validatorHooks, security, throwOnErrorDefault, returnType }) {
+function buildCallConfig({ node, validatorHooks, security, baseURL, 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 {
 		callConfig: `{ ${[
 			`method: '${node.method.toUpperCase()}'`,
 			`url: '${node.path}'`,
+			baseURL ? `baseURL: ${JSON.stringify(baseURL)}` : null,
 			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,
@@ -1034,11 +1054,12 @@ function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDef
 * body destructures `contentType` from `options`. Shared by the standalone functions and the SDK methods, so a
 * `text/event-stream` operation is wired to `toEventStream` in one place.
 */
-function buildOperationBody({ node, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
+function buildOperationBody({ node, types, validatorHooks, security, baseURL, returnType, throwOnErrorDefault }) {
 	const { callConfig, mergeContentType, eventStream } = buildCallConfig({
 		node,
 		validatorHooks,
 		security,
+		baseURL,
 		throwOnErrorDefault,
 		returnType
 	});
@@ -1078,13 +1099,14 @@ function buildOperationBody({ node, types, validatorHooks, security, returnType,
 * type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
 * the source.
 */
-function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security }) {
+function Operation({ name, node, types, validatorHooks, returnType, throwOnErrorDefault, security, baseURL }) {
 	if (!_kubb_kit.ast.isHttpOperationNode(node)) return null;
 	const body = buildOperationBody({
 		node,
 		types,
 		validatorHooks,
 		security,
+		baseURL,
 		returnType,
 		throwOnErrorDefault
 	});
@@ -1283,6 +1305,12 @@ function createClientGenerator(name, { sse } = {}) {
 				method: node.method,
 				path: node.path
 			});
+			const baseURL = getOperationBaseURL({
+				document: ctx.adapter.document,
+				method: node.method,
+				path: node.path,
+				server: ctx.adapter.options?.server
+			});
 			const clientPath = importPath ?? node_path.default.resolve(root, ".kubb/client.ts");
 			const clientRoot = importPath === void 0 ? meta.file.path : void 0;
 			const standardSchemaPath = importPath ?? node_path.default.resolve(root, ".kubb/standardSchema.ts");
@@ -1377,7 +1405,8 @@ function createClientGenerator(name, { sse } = {}) {
 						validatorHooks,
 						returnType,
 						throwOnErrorDefault,
-						security
+						security,
+						baseURL
 					})
 				]
 			});
@@ -1388,13 +1417,14 @@ function createClientGenerator(name, { sse } = {}) {
 /**
 * Builds one instance method of a generated SDK class; a per-call `options.client` overrides `this.client`.
 */
-function buildSdkMethod({ node, name, types, validatorHooks, security, returnType, throwOnErrorDefault }) {
+function buildSdkMethod({ node, name, types, validatorHooks, security, baseURL, returnType, throwOnErrorDefault }) {
 	if (!_kubb_kit.ast.isHttpOperationNode(node)) return "";
 	const body = buildOperationBody({
 		node,
 		types,
 		validatorHooks,
 		security,
+		baseURL,
 		returnType,
 		throwOnErrorDefault
 	});
@@ -1418,12 +1448,13 @@ function buildSdkMethod({ node, name, types, validatorHooks, security, returnTyp
 * still overrides the instance client for a one-off call.
 */
 function SdkClient({ name, operations, returnType, throwOnErrorDefault }) {
-	const methods = operations.map(({ node, name: methodName, types, validatorHooks, security }) => buildSdkMethod({
+	const methods = operations.map(({ node, name: methodName, types, validatorHooks, security, baseURL }) => buildSdkMethod({
 		node,
 		name: methodName,
 		types,
 		validatorHooks,
 		security,
+		baseURL,
 		returnType,
 		throwOnErrorDefault
 	}));
@@ -1478,6 +1509,7 @@ function buildControllers(nodes, ctx, types, validatorEnabled) {
 	const pluginZod = validatorEnabled ? driver.getPlugin(_kubb_plugin_zod.pluginZodName) : null;
 	const zodResolver = pluginZod ? driver.getResolver(_kubb_plugin_zod.pluginZodName) : null;
 	const document = ctx.adapter.document;
+	const server = ctx.adapter.options?.server;
 	function buildOperationData(node) {
 		const typeFile = types.resolver.file({
 			...operationFileEntry(node, node.operationId),
@@ -1496,6 +1528,12 @@ function buildControllers(nodes, ctx, types, validatorEnabled) {
 			method: node.method,
 			path: node.path
 		}) : void 0;
+		const baseURL = _kubb_kit.ast.isHttpOperationNode(node) ? getOperationBaseURL({
+			document,
+			method: node.method,
+			path: node.path,
+			server
+		}) : void 0;
 		const validatorHooks = zodResolver ? buildValidatorHooks({
 			node,
 			validator,
@@ -1512,7 +1550,8 @@ function buildControllers(nodes, ctx, types, validatorEnabled) {
 			typeFile,
 			zodFile,
 			validatorHooks,
-			security
+			security,
+			baseURL
 		};
 	}
 	return nodes.reduce((acc, operationNode) => {
@@ -1801,7 +1840,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "6.1.0-canary.20261109T175349";
+var version = "6.1.0-canary.20261109T191216";
 // src/plugin.ts
 /**
 * Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin