@kubb/plugin-vue-query 5.9.0-canary.20261029T142044 → 5.9.0

package/dist/index.cjs

@@ -51,19 +51,19 @@ function operationFileEntry(node, name, extname = ".ts") {
 	};
 }
 /**
-* Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the
-* current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the
+* Resolves a dependency plugin's generated file for `node.operationId`, cached in `memo` (the
+* build's `ctx.memo`) under the resolver's own plugin name and the operation. Several dependents reading the
 * same dependency for the same operation in one pass (a query plugin's several hook generators, the
 * MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
 *
 * @example Cache `plugin-ts`'s file for the current operation
 * ```ts
-* const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })
+* const fileTs = resolveDependencyOperationFile({ memo: ctx.memo, node, resolver: tsResolver, root, output })
 * ```
 */
 function resolveDependencyOperationFile(options) {
-	const { cache, node, resolver, root, output, group } = options;
-	return cache.ensureItem(`${resolver.pluginName}:operationFile`, () => resolver.file({
+	const { memo, node, resolver, root, output, group } = options;
+	return memo(`${resolver.pluginName}:operationFile:${node.operationId}`, () => resolver.file({
 		...operationFileEntry(node, node.operationId),
 		root,
 		output,
@@ -508,7 +508,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.9.0-canary.20261029T142044";
+var version = "5.9.0";
 // ../../internals/client/src/resolveOperationTypes.ts
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
@@ -705,7 +705,7 @@ function resolveImportPath(options) {
 * output root, the same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
 * With plugin-client they come from the user's `importPath` module instead.
 *
-* The result is cached in the current node's `cache` (`ctx.cache`) under the client plugin's name,
+* The result is cached in `memo` (the build's `ctx.memo`) under the client plugin's name and the operation,
 * so several dependents reading the same client plugin for one operation in a single pass
 * (react-query's query/mutation/infinite generators, vue-query, swr, the MCP handler, ...) share
 * one computed result instead of each re-deriving the name and path.
@@ -715,9 +715,9 @@ function resolveImportPath(options) {
 * and import path therefore match the `<op>` actually emitted, even when an `override` changes it.
 */
 function resolveClientOperation(options) {
-	const { clientPlugin, driver, node, root, output, cache } = options;
+	const { clientPlugin, driver, node, root, output, memo } = options;
 	if (!clientPlugin) return null;
-	return cache.ensureItem(`${clientPlugin.pluginName}:clientOperation`, () => {
+	return memo(`${clientPlugin.pluginName}:clientOperation:${node.operationId}`, () => {
 		const resolver = driver.getResolver(clientPlugin.pluginName);
 		const pluginOptions = driver.getPlugin(clientPlugin.pluginName)?.options ?? {};
 		const { exclude, include, override } = pluginOptions;
@@ -757,8 +757,16 @@ function resolveClientOperation(options) {
 * `pluginZod({ inferred: 'codec' })`), banner and footer.
 */
 function resolveHookFile(node, ctx, options) {
-	const { name, output, group, contractOp, keyTypeName, extraTypeNames = [] } = options;
+	const { name, output, group, contractOp, keyTypeName, extraTypeNames = [], returnType = "data" } = options;
 	const { config, root, resolver } = ctx;
+	if (returnType !== "data" && contractOp.returnType === "data") throw new _kubb_kit.Diagnostics.Error({
+		code: _kubb_kit.Diagnostics.code.invalidPluginOptions,
+		severity: "error",
+		message: `Option \`returnType\` is '${returnType}' for ${node.operationId}, but the client plugin has \`returnType: 'data'\` and only returns the response body.`,
+		help: "Set the client plugin's `returnType` to 'full', or set the hook plugin's `returnType` to 'data'.",
+		location: { kind: "config" },
+		plugin: resolver.pluginName
+	});
 	const types = resolveOperationTypes(ctx.driver, resolver.pluginName);
 	const tsResolver = types.resolver;
 	const file = resolver.file({
@@ -768,7 +776,7 @@ function resolveHookFile(node, ctx, options) {
 		group: group ?? void 0
 	});
 	const fileTs = resolveDependencyOperationFile({
-		cache: ctx.cache,
+		memo: ctx.memo,
 		node,
 		resolver: tsResolver,
 		root,
@@ -777,9 +785,10 @@ function resolveHookFile(node, ctx, options) {
 	});
 	const importedTypeNames = [
 		tsResolver.response.options(node),
+		tsResolver.response.responses(node),
 		...extraTypeNames,
 		...resolveOperationTypeNames(node, tsResolver, {
-			exclude: keyTypeName ? [keyTypeName] : void 0,
+			exclude: [keyTypeName, returnType !== "data" ? tsResolver.response.response(node) : null].filter((name) => Boolean(name)),
 			order: "body-response-first",
 			includeParams: false
 		})
@@ -794,6 +803,7 @@ function resolveHookFile(node, ctx, options) {
 		tsResolver,
 		contractOp,
 		importedTypeNames,
+		returnType,
 		banner: resolver.default.banner(ctx.meta, {
 			output,
 			config,
@@ -824,7 +834,11 @@ function HookFile({ hook, imports, children }) {
 				path: contractOp.path
 			}),
 			/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
-				name: ["RequestConfig", "ResponseErrorConfig"],
+				name: [
+					"RequestConfig",
+					"ResponseErrorConfig",
+					"RequestResult"
+				],
 				root: contractOp.clientPathIsFile ? file.path : void 0,
 				path: contractOp.clientPath,
 				isTypeOnly: true
@@ -964,11 +978,12 @@ function buildClientCall(node, options) {
 }
 /**
 * Builds the query/mutation body that resolves a `buildClientCall` expression down to the bare
-* success body. `returnType` mirrors the registered client plugin's own `returnType` option: with
+* success body. `clientReturnType` mirrors the registered client plugin's own `returnType` option: with
 * `'data'` the call already resolves to the bare body, so it is returned directly; with `'full'`
 * (the default) the call carries `unwrap()`, so the body calls it instead of destructuring `data`
 * off the full result by hand. With `'plain'` (plugin-client) the call resolves to the user's
-* `RequestResult`, so the body awaits it and reads `data`.
+* `RequestResult`, so the body awaits it and reads `data`. With `returnType` `'full'` the body
+* resolves to the whole `RequestResult`; `resolveHookFile` rejects that for a client that already stripped it.
 *
 * @example
 * ```ts
@@ -977,22 +992,24 @@ function buildClientCall(node, options) {
 * ```
 */
 function buildCallResultBody(call, options = {}) {
-	const { returnType = "full" } = options;
-	if (returnType === "data") return `return await ${call}`;
-	if (returnType === "plain") return `return (await ${call}).data`;
+	const { clientReturnType = "full", returnType = "data" } = options;
+	if (returnType !== "data" || clientReturnType === "data") return `return ${call}`;
+	if (clientReturnType === "plain") return `return (await ${call}).data`;
 	return `return ${call}.unwrap()`;
 }
 /**
 * Builds the `TData` / `TError` type expressions shared by every generated hook, joining the resolved
 * success responses into `TData` and wrapping the error responses in `ResponseErrorConfig<...>`.
+* With `returnType` `'full'`, `TData` is the client's `RequestResult` over the operation's responses record.
 */
-function buildResponseTypes(node, resolver) {
-	return resolver.memo(`responseTypes:${node.method}\0${node.path}`, () => {
+function buildResponseTypes(node, resolver, options = {}) {
+	const { returnType = "data" } = options;
+	return resolver.memo(`responseTypes:${returnType}:${node.method}\0${node.path}`, () => {
 		const successNames = resolveSuccessNames(node, resolver);
 		const responseName = successNames.length > 0 ? successNames.join(" | ") : resolver.response.response(node);
 		const errorNames = resolveErrorNames(node, resolver);
 		return {
-			TData: responseName,
+			TData: returnType !== "data" ? `RequestResult<${resolver.response.responses(node)}, true>` : responseName,
 			TError: `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`
 		};
 	});
@@ -1177,8 +1194,9 @@ function resolveMutationRequestType(node, resolver) {
 // ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$5 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$3 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, returnType = "full" }) {
-	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver);
+function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitInitialPageParam, cursorParam, nextParam, previousParam, getNextPageParam, getPreviousPageParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, clientReturnType, returnType }) {
+	const { TData: queryFnDataType, TError: errorType } = buildResponseTypes(node, tsResolver, { returnType });
+	const dataSuffix = returnType === "data" ? "" : ".data";
 	const { queryParamsTypeName, pageParamType } = resolvePageParamType(node, {
 		resolver: tsResolver,
 		initialPageParam,
@@ -1200,21 +1218,24 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitI
 		clientName,
 		signal: true,
 		unwrapName
-	}), { returnType });
+	}), {
+		clientReturnType,
+		returnType
+	});
 	const initialPageParamLiteral = typeof initialPageParam === "string" || typeof initialPageParam === "object" && initialPageParam !== null ? JSON.stringify(initialPageParam) : String(initialPageParam === void 0 ? 0 : initialPageParam);
 	const serializedGetNextPageParam = typeof getNextPageParam === "function" ? getNextPageParam.toString() : getNextPageParam;
 	const getNextPageParamExpr = (() => {
 		if (serializedGetNextPageParam) return `getNextPageParam: ${serializedGetNextPageParam}`;
-		if (nextParam) return `getNextPageParam: (lastPage) => ${getNestedAccessor(nextParam, "lastPage")}`;
-		if (cursorParam) return `getNextPageParam: (lastPage) => lastPage['${cursorParam}']`;
-		return "getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1";
+		if (nextParam) return `getNextPageParam: (lastPage) => ${getNestedAccessor(nextParam, `lastPage${dataSuffix}`)}`;
+		if (cursorParam) return `getNextPageParam: (lastPage) => lastPage${dataSuffix}['${cursorParam}']`;
+		return `getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage${dataSuffix}) && lastPage${dataSuffix}.length === 0 ? undefined : lastPageParam + 1`;
 	})();
 	const serializedGetPreviousPageParam = typeof getPreviousPageParam === "function" ? getPreviousPageParam.toString() : getPreviousPageParam;
 	const defaultPreviousThreshold = hasExplicitInitialPageParam ? initialPageParamLiteral : "1";
 	const getPreviousPageParamExpr = (() => {
 		if (serializedGetPreviousPageParam) return `getPreviousPageParam: ${serializedGetPreviousPageParam}`;
-		if (previousParam) return `getPreviousPageParam: (firstPage) => ${getNestedAccessor(previousParam, "firstPage")}`;
-		if (cursorParam) return `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`;
+		if (previousParam) return `getPreviousPageParam: (firstPage) => ${getNestedAccessor(previousParam, `firstPage${dataSuffix}`)}`;
+		if (cursorParam) return `getPreviousPageParam: (firstPage) => firstPage${dataSuffix}['${cursorParam}']`;
 		if (serializedGetNextPageParam || nextParam) return null;
 		return `getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= ${defaultPreviousThreshold} ? undefined : firstPageParam - 1`;
 	})();
@@ -1437,8 +1458,8 @@ function getQueryOptionsParams(node, options) {
 		memberTypeWrapper: maybeRefOrGetter
 	});
 }
-function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, returnType = "full" }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
+function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, clientReturnType, returnType }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
 	const queryKeyParamsNode = buildQueryKeyParams(node, {
 		resolver: tsResolver,
 		memberTypeWrapper: maybeRefOrGetter
@@ -1450,7 +1471,10 @@ function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, return
 		clientName,
 		signal: true,
 		unwrapName: (name) => `toValue(${name})`
-	}), { returnType });
+	}), {
+		clientReturnType,
+		returnType
+	});
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name,
 		isExportable: true,
@@ -1474,11 +1498,11 @@ function QueryOptions({ name, clientName, node, tsResolver, queryKeyName, return
 // src/components/Query.tsx
 const declarationPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter$1 = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
-function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, infinite }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
+function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver, infinite, returnType }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
 	const optionsName = infinite ? "UseInfiniteQueryOptions" : "UseQueryOptions";
 	const hookName = infinite ? "useInfiniteQuery" : "useQuery";
-	const returnType = `${infinite ? "UseInfiniteQueryReturnType" : "UseQueryReturnType"}<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
+	const resultType = `${infinite ? "UseInfiniteQueryReturnType" : "UseQueryReturnType"}<${["TData", TError].join(", ")}> & { queryKey: TQueryKey }`;
 	const generics = [
 		infinite ? `TData = InfiniteData<${TData}>` : `TData = ${TData}`,
 		`TQueryData = ${TData}`,
@@ -1545,7 +1569,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
         ...${queryOptionsName}(${queryOptionsParamsCall}),
         ...resolvedOptions,
         queryKey
-       } as unknown as ${optionsName}<${castGenerics.join(", ")}>, toValue(queryClient)) as ${returnType}
+       } as unknown as ${optionsName}<${castGenerics.join(", ")}>, toValue(queryClient)) as ${resultType}
 
        queryResult.queryKey = queryKey as TQueryKey
 
@@ -1591,7 +1615,7 @@ const infiniteQueryGenerator = (0, _kubb_kit.defineGenerator)({
 			node,
 			root,
 			output,
-			cache: ctx.cache
+			memo: ctx.memo
 		});
 		if (!contractOp) return null;
 		const queryName = resolver.infiniteQuery.name(node);
@@ -1603,6 +1627,7 @@ const infiniteQueryGenerator = (0, _kubb_kit.defineGenerator)({
 			output,
 			group,
 			contractOp,
+			returnType: ctx.options.returnType,
 			keyTypeName: queryKeyTypeName,
 			extraTypeNames: [resolvePageParamType(node, {
 				resolver: resolveOperationTypes(ctx.driver, ctx.resolver.pluginName).resolver,
@@ -1655,7 +1680,8 @@ const infiniteQueryGenerator = (0, _kubb_kit.defineGenerator)({
 					initialPageParam: infiniteOptions.initialPageParam,
 					hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
 					queryParam: infiniteOptions.queryParam,
-					returnType: contractOp.returnType,
+					clientReturnType: contractOp.returnType,
+					returnType: hook.returnType,
 					queryKeyType: "QueryKey",
 					memberTypeWrapper: maybeRefOrGetter,
 					unwrapName: (name) => `toValue(${name})`
@@ -1681,7 +1707,8 @@ const infiniteQueryGenerator = (0, _kubb_kit.defineGenerator)({
 					queryKeyTypeName,
 					node,
 					tsResolver,
-					infinite: true
+					infinite: true,
+					returnType: hook.returnType
 				})
 			]
 		});
@@ -1691,8 +1718,8 @@ const infiniteQueryGenerator = (0, _kubb_kit.defineGenerator)({
 const declarationPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "declaration" });
 const callPrinter = (0, _kubb_plugin_ts.functionPrinter)({ mode: "call" });
 function buildMutationParamsNode(node, options) {
-	const { resolver } = options;
-	const { TData, TError } = buildResponseTypes(node, resolver);
+	const { resolver, returnType } = options;
+	const { TData, TError } = buildResponseTypes(node, resolver, { returnType });
 	return buildHookParams(node, {
 		resolver,
 		withRequest: false,
@@ -1707,8 +1734,8 @@ function buildMutationParamsNode(node, options) {
 }`
 	});
 }
-function Mutation({ name, clientName, node, tsResolver, mutationKeyName, returnType = "full" }) {
-	const { TData, TError } = buildResponseTypes(node, tsResolver);
+function Mutation({ name, clientName, node, tsResolver, mutationKeyName, clientReturnType, returnType }) {
+	const { TData, TError } = buildResponseTypes(node, tsResolver, { returnType });
 	const groupedParam = buildGroupedRequestParam(node, {
 		resolver: tsResolver,
 		withContentType: true
@@ -1721,16 +1748,22 @@ function Mutation({ name, clientName, node, tsResolver, mutationKeyName, returnT
 		clientName,
 		signal: false,
 		withContentType: true,
-		returnType,
+		returnType: clientReturnType,
 		unwrapName: (name) => `toValue<${TRequest}['${name}']>(${name})`
-	}), { returnType });
+	}), {
+		clientReturnType,
+		returnType
+	});
 	const generics = [
 		TData,
 		TError,
 		TRequest,
 		"TContext"
 	].join(", ");
-	const paramsNode = buildMutationParamsNode(node, { resolver: tsResolver });
+	const paramsNode = buildMutationParamsNode(node, {
+		resolver: tsResolver,
+		returnType
+	});
 	const paramsSignature = declarationPrinter.print(paramsNode) ?? "";
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name,
@@ -1783,7 +1816,7 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 			node,
 			root,
 			output,
-			cache: ctx.cache
+			memo: ctx.memo
 		});
 		if (!contractOp) return null;
 		const mutationHookName = resolver.mutation.name(node);
@@ -1792,7 +1825,8 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 			name: mutationHookName,
 			output,
 			group,
-			contractOp
+			contractOp,
+			returnType: ctx.options.returnType
 		});
 		const groups = getRequestGroups(node);
 		const hasRequestGroups = groups.path || groups.query || groups.body || groups.headers;
@@ -1826,7 +1860,8 @@ const mutationGenerator = (0, _kubb_kit.defineGenerator)({
 					node,
 					tsResolver: hook.tsResolver,
 					mutationKeyName,
-					returnType: contractOp.returnType
+					clientReturnType: contractOp.returnType,
+					returnType: hook.returnType
 				})
 			] })]
 		});
@@ -1857,7 +1892,7 @@ const queryGenerator = (0, _kubb_kit.defineGenerator)({
 			node,
 			root,
 			output,
-			cache: ctx.cache
+			memo: ctx.memo
 		});
 		if (!contractOp) return null;
 		const queryName = resolver.query.name(node);
@@ -1869,7 +1904,8 @@ const queryGenerator = (0, _kubb_kit.defineGenerator)({
 			output,
 			group,
 			contractOp,
-			keyTypeName: queryKeyTypeName
+			keyTypeName: queryKeyTypeName,
+			returnType: ctx.options.returnType
 		});
 		const { tsResolver } = hook;
 		return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(HookFile, {
@@ -1903,7 +1939,8 @@ const queryGenerator = (0, _kubb_kit.defineGenerator)({
 					queryKeyName,
 					node,
 					tsResolver,
-					returnType: contractOp.returnType
+					clientReturnType: contractOp.returnType,
+					returnType: hook.returnType
 				}),
 				query && hooks && /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsxs)(_kubb_renderer_jsx_jsx_runtime.Fragment, { children: [
 					/* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Import, {
@@ -1926,7 +1963,8 @@ const queryGenerator = (0, _kubb_kit.defineGenerator)({
 						queryKeyName,
 						queryKeyTypeName,
 						node,
-						tsResolver
+						tsResolver,
+						returnType: hook.returnType
 					})
 				] })
 			]
@@ -2001,7 +2039,7 @@ const pluginVueQuery = (0, _kubb_kit.defineExtension)({
 		const { output = {
 			path: "hooks",
 			barrel: { type: "named" }
-		}, group, exclude = [], include, override = [], infinite = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, hooks = false, client, resolver: userResolver, macros: userMacros } = options;
+		}, group, exclude = [], include, override = [], infinite = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, hooks = false, client, returnType = "data", resolver: userResolver, macros: userMacros } = options;
 		const resolver = userResolver ? _kubb_kit.Resolver.merge(resolverVueQuery, userResolver) : resolverVueQuery;
 		(0, _kubb_kit.setResolver)(resolver);
 		if (userMacros?.length) (0, _kubb_kit.setMacros)(userMacros);
@@ -2013,6 +2051,7 @@ const pluginVueQuery = (0, _kubb_kit.defineExtension)({
 				client,
 				plugins: (0, _kubb_kit.useConfig)().plugins
 			}),
+			returnType,
 			queryKey,
 			query: resolveQueryConfig(query, { importPath: "@tanstack/vue-query" }),
 			mutationKey,