@kubb/plugin-fetch 5.0.0-beta.95 → 5.0.0-beta.98

package/dist/index.cjs

@@ -27,8 +27,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
 let kubb_kit = require("kubb/kit");
-let kubb_jsx = require("kubb/jsx");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
+let kubb_jsx = require("kubb/jsx");
 let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
 let _kubb_plugin_zod = require("@kubb/plugin-zod");
 let node_url = require("node:url");
@@ -594,64 +594,65 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
-//#region ../../internals/client/src/builders/validatorOptions.ts
-/**
-* Returns `true` when any direction of the validator uses zod (used for dependency checks).
-*/
-function isValidatorEnabled(validator) {
-	if (!validator) return false;
-	if (validator === "zod") return true;
-	return Boolean(validator.request || validator.response);
-}
-/**
-* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
-* `'zod'` validates the response only, so it does not enable request parsing.
-*/
-function resolveRequestValidator(validator) {
-	if (!validator || validator === "zod") return null;
-	return validator.request ?? null;
-}
-/**
-* Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise. Only the object form
-* `{ request: 'zod' }` enables it.
-*/
-function resolveQueryParamsValidator(validator) {
-	if (!validator || validator === "zod") return null;
-	return validator.request ?? null;
-}
+//#region ../../internals/client/src/builders/paramsRemap.ts
 /**
-* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
-* maps to response parsing.
+* Builds the call-config entries that rename the camelCased `query` and `headers` keys back to the
+* names the OpenAPI document declares, so the wire format follows the spec while the generated
+* types keep camelCase keys. Returns an empty array when no name changes. Path parameters need no
+* remap because the URL template placeholders are renamed in sync with the `path` keys. Emit the
+* entries after the `...config` spread so they override the camelCased groups the caller passes in.
+*
+* @example
+* ```ts
+* // a query param named include_deleted in the spec
+* buildParamsRemap({ node }) // ['query: config.query ? { "include_deleted": config.query.includeDeleted } : config.query']
+* ```
 */
-function resolveResponseValidator(validator) {
-	if (!validator) return null;
-	if (validator === "zod") return "zod";
-	return validator.response ?? null;
+function buildParamsRemap({ node }) {
+	if (!kubb_kit.ast.isHttpOperationNode(node)) return [];
+	const original = getOperationParameters(node, { paramsCasing: "original" });
+	const cased = getOperationParameters(node);
+	const queryMapping = buildParamsMapping(original.query, cased.query);
+	const headerMapping = buildParamsMapping(original.header, cased.header);
+	const entries = [];
+	if (queryMapping) entries.push(`query: ${buildParamsRemapExpression({
+		source: "config.query",
+		mapping: queryMapping
+	})}`);
+	if (headerMapping) entries.push(`headers: ${buildParamsRemapExpression({
+		source: "config.headers",
+		mapping: headerMapping
+	})}`);
+	return entries;
 }
+//#endregion
+//#region ../../internals/client/src/builders/generics.ts
 /**
-* Resolves the zod expression a generated client validates a success response with. Only success
-* (2xx) bodies reach the parse under the throw-on-error contract, so the success-only
-* `<operation>ResponseSchema` is used; error bodies are never zod-parsed.
+* Builds the `RequestResult` generic arguments for one operation: the plugin-ts per-status responses
+* record plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
+* runtime, so this only names the record and threads `ThrowOnError`.
+*
+* @example
+* `buildRequestResultGenerics({ node, tsResolver }) // 'AddPetResponses, ThrowOnError'`
 */
-function buildZodResponseParse(node, zodResolver) {
-	const name = zodResolver.response.response(node);
-	return name ? {
-		expression: name,
-		importNames: [name]
-	} : null;
+function buildRequestResultGenerics({ node, tsResolver }) {
+	return `${tsResolver.response.responses(node)}, ThrowOnError`;
 }
+//#endregion
+//#region ../../internals/client/src/builders/returnStatement.ts
 /**
-* Resolves the zod expression 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 return statement of a generated operation function. The runtime call already resolves
+* to `{ data, error, request, response }`; the generated code forwards that result and casts it to
+* the operation's `RequestResult`, which carries the `throwOnError` discrimination.
+*
+* @example
+* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
 */
-function buildZodErrorParse(node, zodResolver) {
-	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
-	const name = zodResolver.response.error?.(node);
-	return name ? {
-		expression: name,
-		importNames: [name]
-	} : null;
+function buildReturnStatement({ node, tsResolver, callConfig }) {
+	return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		tsResolver
+	})}>>`;
 }
 //#endregion
 //#region ../../internals/client/src/builders/security.ts
@@ -722,67 +723,6 @@ function buildSecurityMetadata({ security }) {
 	return `[${security.map(serializeAuth).join(", ")}]`;
 }
 //#endregion
-//#region ../../internals/client/src/builders/paramsRemap.ts
-/**
-* Builds the call-config entries that rename the camelCased `query` and `headers` keys back to the
-* names the OpenAPI document declares, so the wire format follows the spec while the generated
-* types keep camelCase keys. Returns an empty array when no name changes. Path parameters need no
-* remap because the URL template placeholders are renamed in sync with the `path` keys. Emit the
-* entries after the `...config` spread so they override the camelCased groups the caller passes in.
-*
-* @example
-* ```ts
-* // a query param named include_deleted in the spec
-* buildParamsRemap({ node }) // ['query: config.query ? { "include_deleted": config.query.includeDeleted } : config.query']
-* ```
-*/
-function buildParamsRemap({ node }) {
-	if (!kubb_kit.ast.isHttpOperationNode(node)) return [];
-	const original = getOperationParameters(node, { paramsCasing: "original" });
-	const cased = getOperationParameters(node);
-	const queryMapping = buildParamsMapping(original.query, cased.query);
-	const headerMapping = buildParamsMapping(original.header, cased.header);
-	const entries = [];
-	if (queryMapping) entries.push(`query: ${buildParamsRemapExpression({
-		source: "config.query",
-		mapping: queryMapping
-	})}`);
-	if (headerMapping) entries.push(`headers: ${buildParamsRemapExpression({
-		source: "config.headers",
-		mapping: headerMapping
-	})}`);
-	return entries;
-}
-//#endregion
-//#region ../../internals/client/src/builders/generics.ts
-/**
-* Builds the `RequestResult` generic arguments for one operation: the plugin-ts per-status responses
-* record plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
-* runtime, so this only names the record and threads `ThrowOnError`.
-*
-* @example
-* `buildRequestResultGenerics({ node, tsResolver }) // 'AddPetResponses, ThrowOnError'`
-*/
-function buildRequestResultGenerics({ node, tsResolver }) {
-	return `${tsResolver.response.responses(node)}, ThrowOnError`;
-}
-//#endregion
-//#region ../../internals/client/src/builders/returnStatement.ts
-/**
-* Builds the return statement of a generated operation function. The runtime call already resolves
-* to `{ data, error, request, response }`; the generated code forwards that result and casts it to
-* the operation's `RequestResult`, which carries the `throwOnError` discrimination.
-*
-* @example
-* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
-*/
-function buildReturnStatement({ node, tsResolver, callConfig }) {
-	return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
-		node,
-		tsResolver
-	})}>>`;
-}
-//#endregion
 //#region ../../internals/client/src/builders/signature.ts
 const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 /**
@@ -814,6 +754,152 @@ function buildGroupedOptionsSignature({ node, tsResolver }) {
 	};
 }
 //#endregion
+//#region ../../internals/client/src/builders/validatorOptions.ts
+/**
+* Returns `true` when any direction of the validator uses zod (used for dependency checks).
+*/
+function isValidatorEnabled(validator) {
+	if (!validator) return false;
+	if (validator === "zod") return true;
+	return Boolean(validator.request || validator.response);
+}
+/**
+* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
+* `'zod'` validates the response only, so it does not enable request parsing.
+*/
+function resolveRequestValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? null;
+}
+/**
+* Returns `'zod'` when query-parameters parsing is enabled, `null` otherwise. Only the object form
+* `{ request: 'zod' }` enables it.
+*/
+function resolveQueryParamsValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? null;
+}
+/**
+* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
+* maps to response parsing.
+*/
+function resolveResponseValidator(validator) {
+	if (!validator) return null;
+	if (validator === "zod") return "zod";
+	return validator.response ?? null;
+}
+/**
+* Resolves the zod expression a generated client validates a success response with. Only success
+* (2xx) bodies reach the parse under the throw-on-error contract, so the success-only
+* `<operation>ResponseSchema` is used; error bodies are never zod-parsed.
+*/
+function buildZodResponseParse(node, zodResolver) {
+	const name = zodResolver.response.response(node);
+	return name ? {
+		expression: name,
+		importNames: [name]
+	} : null;
+}
+/**
+* Resolves the zod expression 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.
+*/
+function buildZodErrorParse(node, zodResolver) {
+	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
+	const name = zodResolver.response.error?.(node);
+	return name ? {
+		expression: name,
+		importNames: [name]
+	} : 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 importedZodNames = [];
+	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) : null;
+	const request = zodRequestName ?? null;
+	if (zodRequestName) importedZodNames.push(zodRequestName);
+	const responseParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
+	const response = responseParse ? responseParse.expression : null;
+	if (responseParse) importedZodNames.push(...responseParse.importNames);
+	const errorParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
+	const error = errorParse ? errorParse.expression : null;
+	if (errorParse) importedZodNames.push(...errorParse.importNames);
+	return {
+		request,
+		response,
+		error,
+		importedZodNames
+	};
+}
+//#endregion
+//#region ../../internals/client/src/builders/sdkMethod.ts
+/**
+* Builds the call config literal forwarded to the contract client, mirroring the shared `Operation`
+* component: `{ method, url, security?, validator?, ...config }`. The `...config` spread carries every
+* per-call field (including `throwOnError`), so the method stays a thin wrapper over the contract.
+*/
+function buildCallConfig({ node, validator, zodResolver, security }) {
+	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;
+	const securityLiteral = buildSecurityMetadata({ security });
+	return `{ ${[
+		`method: '${node.method.toUpperCase()}'`,
+		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
+		securityLiteral ? `security: ${securityLiteral}` : null,
+		validatorLiteral,
+		"...config",
+		...buildParamsRemap({ node })
+	].filter(Boolean).join(", ")} }`;
+}
+/**
+* Builds a single instance method for a generated SDK class. The body forwards the single grouped
+* `options` object to the instance's own client (`this.client`, built once in the constructor) and
+* returns the `RequestResult`. A per-call `options.client` still overrides the instance client, so
+* one operation can be routed to a different environment without a new instance.
+*/
+function buildSdkMethod({ node, name, tsResolver, zodResolver, validator, security }) {
+	if (!kubb_kit.ast.isHttpOperationNode(node)) return "";
+	const signature = buildGroupedOptionsSignature({
+		node,
+		tsResolver
+	});
+	const returnStatement = buildReturnStatement({
+		node,
+		tsResolver,
+		callConfig: buildCallConfig({
+			node,
+			validator,
+			zodResolver,
+			security
+		})
+	});
+	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
+	const jsdoc = buildJSDoc(buildOperationComments(node, {
+		link: "urlPath",
+		linkPosition: "beforeDeprecated",
+		splitLines: true
+	}));
+	const methodBody = [
+		"const { client: request = this.client, ...config } = options",
+		"",
+		returnStatement
+	].map((line) => line ? `    ${line}` : "").join("\n");
+	return `${jsdoc}  public ${name}${generics}(${signature.paramsSignature}): ${signature.returnType} {\n${methodBody}\n  }`;
+}
+//#endregion
 //#region ../../internals/client/src/builders/styles.ts
 /**
 * Renders a parameter name as an object-literal key, quoted when it is not a bare identifier.
@@ -867,32 +953,6 @@ function buildStyles({ node }) {
 	return `{ ${locations.map((location) => `${location}: { ${groups[location].join(", ")} }`).join(", ")} }`;
 }
 //#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 importedZodNames = [];
-	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) : null;
-	const request = zodRequestName ?? null;
-	if (zodRequestName) importedZodNames.push(zodRequestName);
-	const responseParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
-	const response = responseParse ? responseParse.expression : null;
-	if (responseParse) importedZodNames.push(...responseParse.importNames);
-	const errorParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
-	const error = errorParse ? errorParse.expression : null;
-	if (errorParse) importedZodNames.push(...errorParse.importNames);
-	return {
-		request,
-		response,
-		error,
-		importedZodNames
-	};
-}
-//#endregion
 //#region ../../internals/client/src/components/Operation.tsx
 /**
 * Renders one client operation: the grouped `<Name>Request` type and the function that forwards a
@@ -967,66 +1027,6 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 	});
 }
 //#endregion
-//#region ../../internals/client/src/builders/sdkMethod.ts
-/**
-* Builds the call config literal forwarded to the contract client, mirroring the shared `Operation`
-* component: `{ method, url, security?, validator?, ...config }`. The `...config` spread carries every
-* per-call field (including `throwOnError`), so the method stays a thin wrapper over the contract.
-*/
-function buildCallConfig({ node, validator, zodResolver, security }) {
-	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;
-	const securityLiteral = buildSecurityMetadata({ security });
-	return `{ ${[
-		`method: '${node.method.toUpperCase()}'`,
-		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
-		securityLiteral ? `security: ${securityLiteral}` : null,
-		validatorLiteral,
-		"...config",
-		...buildParamsRemap({ node })
-	].filter(Boolean).join(", ")} }`;
-}
-/**
-* Builds a single instance method for a generated SDK class. The body forwards the single grouped
-* `options` object to the instance's own client (`this.client`, built once in the constructor) and
-* returns the `RequestResult`. A per-call `options.client` still overrides the instance client, so
-* one operation can be routed to a different environment without a new instance.
-*/
-function buildSdkMethod({ node, name, tsResolver, zodResolver, validator, security }) {
-	if (!kubb_kit.ast.isHttpOperationNode(node)) return "";
-	const signature = buildGroupedOptionsSignature({
-		node,
-		tsResolver
-	});
-	const returnStatement = buildReturnStatement({
-		node,
-		tsResolver,
-		callConfig: buildCallConfig({
-			node,
-			validator,
-			zodResolver,
-			security
-		})
-	});
-	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
-	const jsdoc = buildJSDoc(buildOperationComments(node, {
-		link: "urlPath",
-		linkPosition: "beforeDeprecated",
-		splitLines: true
-	}));
-	const methodBody = [
-		"const { client: request = this.client, ...config } = options",
-		"",
-		returnStatement
-	].map((line) => line ? `    ${line}` : "").join("\n");
-	return `${jsdoc}  public ${name}${generics}(${signature.paramsSignature}): ${signature.returnType} {\n${methodBody}\n  }`;
-}
-//#endregion
 //#region ../../internals/client/src/components/SdkClient.tsx
 /**
 * Renders one instance class per tag with one method per operation. The constructor takes a client