@kubb/plugin-fetch 5.5.2 → 5.5.3

package/dist/index.d.ts

@@ -27,8 +27,10 @@ type Mode = 'tag' | 'flat';
  * - `'full'`: the complete `{ status, data, error, contentType, request, response }` result.
  * - `'data'`: the bare success body when `throwOnError` is true, or the full result when it is false
  *   so callers can inspect `error`.
+ * - `'plain'`: the client's own promise typed as `RequestResult`, with no `withUnwrap` / `unwrapResult`
+ *   helper. Backs `@kubb/plugin-client`.
  */
-type ReturnTypeOption = 'full' | 'data';
+type ReturnTypeOption = 'full' | 'data' | 'plain';
 /**
  * The resolver shared by the client plugins. Inherits the built-in camelCase `name` and `file`;
  * classes and tag groups use PascalCase (with a `Client` suffix for groups).

package/dist/index.js

@@ -452,7 +452,8 @@ function buildRequestResultGenerics({ node, types }) {
 }
 /**
 * Builds the full return type an operation's function signature uses: `Unwrappable<RequestResult>`
-* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, or a
+* for the default `returnType: 'full'`, already a promise so no further wrapping is needed, a plain
+* `Promise<RequestResult>` for the internal `'plain'` shape, or a
 * `Promise` of the runtime's `UnwrappedResult` when `returnType: 'data'` narrows a resolved call
 * down to the bare success body.
 *
@@ -464,7 +465,9 @@ function buildResultType({ node, types, returnType }) {
 		node,
 		types
 	});
-	return returnType === "data" ? `Promise<UnwrappedResult<${generics}>>` : `Unwrappable<RequestResult<${generics}>>`;
+	if (returnType === "data") return `Promise<UnwrappedResult<${generics}>>`;
+	if (returnType === "plain") return `Promise<RequestResult<${generics}>>`;
+	return `Unwrappable<RequestResult<${generics}>>`;
 }
 //#endregion
 //#region ../../internals/client/src/builders/returnStatement.ts
@@ -476,6 +479,7 @@ function buildResultType({ node, types, returnType }) {
 * 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, using the plugin default when the call leaves `throwOnError` unset.
+* With `returnType: 'plain'` it returns the runtime call as is, cast to `RequestResult`, with no helper.
 *
 * 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>`
@@ -486,6 +490,8 @@ function buildResultType({ node, types, returnType }) {
 * `return withUnwrap(request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>)`
 * @example
 * `return unwrapResult(request({ method: 'POST', url: '/pet', ...config }), config.throwOnError ?? false) as Promise<UnwrappedResult<AddPetResponses, ThrowOnError>>`
+* @example
+* `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
 */
 function buildReturnStatement({ node, types, callConfig, returnType, throwOnErrorDefault }) {
 	if (returnType === "data") return `return unwrapResult(request(${callConfig}), config.throwOnError ?? ${throwOnErrorDefault}) as ${buildResultType({
@@ -493,6 +499,10 @@ function buildReturnStatement({ node, types, callConfig, returnType, throwOnErro
 		types,
 		returnType
 	})}`;
+	if (returnType === "plain") return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
+		node,
+		types
+	})}>>`;
 	return `return withUnwrap(request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
 		node,
 		types
@@ -970,7 +980,7 @@ function resolveOperationTypes(driver) {
 * generator `name` differs between plugins. Every other resolution, import, and rendering step is
 * identical.
 */
-function createClientGenerator(name) {
+function createClientGenerator(name, resolveClientPath) {
 	return defineGenerator({
 		name,
 		renderer: jsxRenderer,
@@ -1020,8 +1030,30 @@ function createClientGenerator(name) {
 				method: node.method,
 				path: node.path
 			});
-			const clientPath = path.resolve(root, ".kubb/client.ts");
+			const customClientPath = resolveClientPath?.(ctx.options, root);
+			const clientPath = customClientPath ?? path.resolve(root, ".kubb/client.ts");
+			const clientRoot = customClientPath === void 0 ? meta.file.path : void 0;
 			const eventStream = isEventStream(node);
+			const clientValueImports = (() => {
+				if (eventStream) return ["client", "toEventStream"];
+				if (returnType === "plain") return ["client"];
+				if (returnType === "data") return ["client", "unwrapResult"];
+				return ["client", "withUnwrap"];
+			})();
+			const clientTypeImports = (() => {
+				if (eventStream) return [
+					"Options",
+					"EventStreamResult",
+					"SuccessOf"
+				];
+				if (returnType === "plain") return ["Options", "RequestResult"];
+				if (returnType === "data") return ["Options", "UnwrappedResult"];
+				return [
+					"Options",
+					"Unwrappable",
+					"RequestResult"
+				];
+			})();
 			return /* @__PURE__ */ jsxs(File, {
 				baseName: meta.file.baseName,
 				path: meta.file.path,
@@ -1044,21 +1076,13 @@ function createClientGenerator(name) {
 				}),
 				children: [
 					/* @__PURE__ */ jsx(File.Import, {
-						name: eventStream ? ["client", "toEventStream"] : ["client", returnType === "data" ? "unwrapResult" : "withUnwrap"],
-						root: meta.file.path,
+						name: clientValueImports,
+						root: clientRoot,
 						path: clientPath
 					}),
 					/* @__PURE__ */ jsx(File.Import, {
-						name: eventStream ? [
-							"Options",
-							"EventStreamResult",
-							"SuccessOf"
-						] : returnType === "data" ? ["Options", "UnwrappedResult"] : [
-							"Options",
-							"Unwrappable",
-							"RequestResult"
-						],
-						root: meta.file.path,
+						name: clientTypeImports,
+						root: clientRoot,
 						path: clientPath,
 						isTypeOnly: true
 					}),