@kubb/plugin-fetch 5.5.0-canary.20260924T110844 → 5.5.0

package/dist/index.cjs

@@ -31,6 +31,7 @@ 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_fs = require("node:fs");
 let node_url = require("node:url");
 //#region ../../internals/shared/src/params.ts
 /**
@@ -501,7 +502,7 @@ function buildResultType({ node, types, returnType }) {
 * `withUnwrap`, so the caller can `await` it directly or call `.unwrap()` for the bare success
 * body. With `returnType: 'data'` it instead routes the call through the runtime's `unwrapResult`,
 * which narrows the resolved value down to the bare success body the same way `RequestResult`
-* already does, keeping the `throwOnError` default in one place instead of restating it per call.
+* already does, using the plugin default when the call leaves `throwOnError` unset.
 *
 * Cast first, wrap second, for the `'full'` path. That order keeps `withUnwrap`'s generic inferred
 * as `RequestResult` instead of the runtime's own internal result type. Casting an `Unwrappable<A>`
@@ -511,10 +512,10 @@ function buildResultType({ node, types, returnType }) {
 * @example
 * `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
 * @example
-* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
+* `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
 */
-function buildReturnStatement({ node, types, callConfig, returnType }) {
-	if (returnType === "data") return `return unwrapResult(request(${callConfig}), config.throwOnError) as ${buildResultType({
+function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
+	if (returnType === "data") return `return unwrapResult(request(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
 		node,
 		types,
 		returnType
@@ -604,7 +605,7 @@ const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declara
 * per-operation input type has to be emitted. Both names come from `types`, which is `plugin-ts` or
 * `plugin-zod`'s inferred types (see `resolveOperationTypes`).
 */
-function buildGroupedOptionsSignature({ node, types, returnType }) {
+function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDefault }) {
 	const optionsName = types.response.options(node);
 	const { isOptional } = getRequestGroupOptionality(node);
 	return {
@@ -618,7 +619,7 @@ function buildGroupedOptionsSignature({ node, types, returnType }) {
 			types,
 			returnType
 		}),
-		generics: ["ThrowOnError extends boolean = true"]
+		generics: [`ThrowOnError extends boolean = ${throwOnErrorDefault}`]
 	};
 }
 //#endregion
@@ -712,9 +713,10 @@ function buildValidatorHooks({ node, validator, zodResolver }) {
 /**
 * 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.
+* per-call field. The plugin's `throwOnError` fallback is applied after the spread so it also wins
+* over a client instance's runtime config when the call omits an override.
 */
-function buildCallConfig({ node, validator, zodResolver, security }) {
+function buildCallConfig({ node, validator, zodResolver, security, throwOnErrorDefault }) {
 	const validators = buildValidatorHooks({
 		node,
 		validator,
@@ -728,7 +730,8 @@ function buildCallConfig({ node, validator, zodResolver, security }) {
 		`url: '${node.path}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
 		validatorLiteral,
-		"...config"
+		"...config",
+		`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
 	].filter(Boolean).join(", ")} }`;
 }
 /**
@@ -738,12 +741,13 @@ function buildCallConfig({ node, validator, zodResolver, security }) {
 * instance client, so one operation can be routed to a different environment without a new
 * instance.
 */
-function buildSdkMethod({ node, name, types, zodResolver, validator, security, returnType }) {
+function buildSdkMethod({ node, name, types, zodResolver, validator, security, returnType, throwOnErrorDefault }) {
 	if (!kubb_kit.ast.isHttpOperationNode(node)) return "";
 	const signature = buildGroupedOptionsSignature({
 		node,
 		types,
-		returnType
+		returnType,
+		throwOnErrorDefault
 	});
 	const returnStatement = buildReturnStatement({
 		node,
@@ -752,9 +756,11 @@ function buildSdkMethod({ node, name, types, zodResolver, validator, security, r
 			node,
 			validator,
 			zodResolver,
-			security
+			security,
+			throwOnErrorDefault
 		}),
-		returnType
+		returnType,
+		throwOnErrorDefault
 	});
 	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
 	const jsdoc = buildJSDoc(buildOperationComments(node, {
@@ -830,12 +836,13 @@ function buildStyles({ node }) {
 * type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
 * the source.
 */
-function Operation({ name, node, types, zodResolver, validator, returnType, security, isExportable = true, isIndexable = true }) {
+function Operation({ name, node, types, zodResolver, validator, returnType, throwOnErrorDefault, security, isExportable = true, isIndexable = true }) {
 	if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
 	const signature = buildGroupedOptionsSignature({
 		node,
 		types,
-		returnType
+		returnType,
+		throwOnErrorDefault
 	});
 	const validators = buildValidatorHooks({
 		node,
@@ -865,7 +872,8 @@ function Operation({ name, node, types, zodResolver, validator, returnType, secu
 		validatorLiteral,
 		contentTypeLiteral,
 		responseTypeLiteral,
-		"...config"
+		"...config",
+		`throwOnError: config.throwOnError ?? ${throwOnErrorDefault}`
 	].filter(Boolean).join(", ")} }`;
 	const eventType = `SuccessOf<${types.response.responses(node)}>`;
 	const functionReturnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
@@ -873,7 +881,8 @@ function Operation({ name, node, types, zodResolver, validator, returnType, secu
 		node,
 		types,
 		callConfig,
-		returnType
+		returnType,
+		throwOnErrorDefault
 	});
 	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name,
@@ -906,7 +915,7 @@ function Operation({ name, node, types, zodResolver, validator, returnType, secu
 * 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, isExportable = true, isIndexable = true, operations, validator, returnType, children }) {
+function SdkClient({ name, isExportable = true, isIndexable = true, operations, validator, returnType, throwOnErrorDefault, children }) {
 	const methods = operations.map(({ node, name: methodName, types, zodResolver, security }) => buildSdkMethod({
 		node,
 		name: methodName,
@@ -914,7 +923,8 @@ function SdkClient({ name, isExportable = true, isIndexable = true, operations,
 		zodResolver,
 		validator,
 		security,
-		returnType
+		returnType,
+		throwOnErrorDefault
 	}));
 	const classCode = `export class ${name} {\n${[
 		"  private readonly client: ClientInstance",
@@ -994,7 +1004,7 @@ function createClientGenerator(name) {
 		operation(node, ctx) {
 			if (!kubb_kit.ast.isHttpOperationNode(node)) return null;
 			const { config, driver, resolver, root } = ctx;
-			const { output, validator, returnType, group } = ctx.options;
+			const { output, validator, returnType, throwOnErrorDefault, group } = ctx.options;
 			const types = resolveOperationTypes(driver);
 			if (!types) {
 				ctx.warn(MISSING_OPERATION_TYPES_WARNING);
@@ -1097,6 +1107,7 @@ function createClientGenerator(name) {
 						zodResolver,
 						validator,
 						returnType,
+						throwOnErrorDefault,
 						security
 					})
 				]
@@ -1237,7 +1248,7 @@ function createSdkGenerator() {
 		renderer: kubb_jsx.jsxRenderer,
 		operations(nodes, ctx) {
 			const { config, resolver, root } = ctx;
-			const { output, group, validator, returnType, sdk } = ctx.options;
+			const { output, group, validator, returnType, throwOnErrorDefault, sdk } = ctx.options;
 			if (!sdk) return null;
 			const types = resolveOperationTypes(ctx.driver);
 			if (!types) {
@@ -1323,7 +1334,8 @@ function createSdkGenerator() {
 							name: className,
 							operations: ops,
 							validator,
-							returnType
+							returnType,
+							throwOnErrorDefault
 						})
 					]
 				}, file.path);
@@ -1409,6 +1421,27 @@ const resolverClient = (0, kubb_kit.createResolver)({
 	}
 });
 //#endregion
+//#region ../../internals/client/src/runtimeTemplate.ts
+/** Apply the active TypeScript parser's import extension to a copied client runtime. */
+function runtimeTemplate(path, config) {
+	const parser = config.parsers.find((item) => item.extNames?.includes(".ts"));
+	const probe = kubb_kit.ast.factory.createFile({
+		baseName: "probe.ts",
+		path: "probe.ts",
+		imports: [kubb_kit.ast.factory.createImport({
+			name: ["KubbRuntimeImport"],
+			path: "/probeDependency.ts",
+			root: "/"
+		})],
+		sources: [kubb_kit.ast.factory.createSource({
+			name: "probe",
+			nodes: [kubb_kit.ast.factory.createText("KubbRuntimeImport")]
+		})]
+	});
+	const extension = parser?.parse(probe).match(/from ['"]\.\/probeDependency(\.[^'"]+)?['"]/)?.[1] ?? "";
+	return (0, node_fs.readFileSync)(path, "utf8").replace(/(from ['"]\.\/(?:serializers|standardSchema))(?:\.ts|\.js)?(['"])/g, `$1${extension}$2`);
+}
+//#endregion
 //#region src/generators/clientGenerator.tsx
 /**
 * Built-in operation generator for `@kubb/plugin-fetch`. Emits one async function per OpenAPI
@@ -1460,7 +1493,7 @@ const pluginFetch = (0, kubb_kit.definePlugin)((options) => {
 	const { output = {
 		path: "clients",
 		barrel: { type: "named" }
-	}, exclude = [], include, override = [], baseURL, validator = false, returnType = "full", group, sdk, resolver: userResolver } = options;
+	}, exclude = [], include, override = [], baseURL, throwOnErrorDefault = true, validator = false, returnType = "full", group, sdk, resolver: userResolver } = options;
 	const resolved = {
 		output,
 		exclude,
@@ -1468,6 +1501,7 @@ const pluginFetch = (0, kubb_kit.definePlugin)((options) => {
 		override,
 		group: createGroupConfig(group),
 		baseURL,
+		throwOnErrorDefault,
 		validator,
 		returnType,
 		sdk: sdk ? {
@@ -1496,7 +1530,7 @@ const pluginFetch = (0, kubb_kit.definePlugin)((options) => {
 			ctx.injectFile({
 				baseName: "client.ts",
 				path: node_path.default.resolve(root, ".kubb/client.ts"),
-				copy: fetchClientTemplatePath,
+				banner: runtimeTemplate(fetchClientTemplatePath, ctx.config),
 				footer: baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : void 0
 			});
 			ctx.injectFile({