@kubb/plugin-react-query 5.10.0-canary.20261109T201601 → 5.11.0-canary.20261109T211530

package/dist/index.cjs

@@ -26,7 +26,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let _kubb_kit = require("@kubb/kit");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
-let _kubb_plugin_zod = require("@kubb/plugin-zod");
 let _kubb_renderer_jsx = require("@kubb/renderer-jsx");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
 let _kubb_renderer_jsx_jsx_runtime = require("@kubb/renderer-jsx/jsx-runtime");
@@ -72,10 +71,11 @@ function resolveDependencyOperationFile(options) {
 		group: group ?? void 0
 	}));
 }
-function getOperationLink(node, link) {
-	if (!link) return null;
-	if (typeof link === "function") return link(node) ?? null;
-	return node.path ? `{@link ${_kubb_kit.Url.toPath(node.path)}}` : null;
+/**
+* The operation's method and path as plain text, such as `` `GET /pet/{petId}` ``. A path is not a valid `{@link}` target.
+*/
+function getOperationRequestLine(node) {
+	return _kubb_kit.ast.isHttpOperationNode(node) && node.path ? `\`${node.method.toUpperCase()} ${node.path}\`` : null;
 }
 /**
 * Derives the shared `ContentTypeInfo` shape from a list of content types, tracking whether several
@@ -137,19 +137,31 @@ function isEventStream(node) {
 }
 /**
 * Builds the `client?:` option type shared by the generated query hooks (`useQuery`,
-* `useInfiniteQuery`, `useSWR`, ...). Unlike {@link buildRequestConfigType}, it never adds a
-* `contentType?:` member: query hooks wrap GET operations, which carry no request body to select a
-* content type for. It drops the data-shape keys to stay assignable to `Options`, which omits them
-* from `RequestConfig`. `cookies` is a group only on an operation that declares one.
+* `useInfiniteQuery`, `useSWR`, ...): `RequestConfig` minus what the
+* hook fills in, which is every request group and `throwOnError`. Unlike {@link buildRequestConfigType},
+* it never narrows `contentType`: query hooks wrap GET operations, which carry no request body to select
+* a content type for.
 */
-function buildClientOptionType(node) {
-	return `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers'${getOperationParameters(node).cookie.length > 0 ? ` | 'cookies'` : ""} | 'url'>>`;
+function buildClientOptionType(options = {}) {
+	return `Partial<Omit<RequestConfig, ${[
+		...requestGroupOrder,
+		"url",
+		...options.omit ?? [],
+		"throwOnError"
+	].map((key) => `'${key}'`).join(" | ")}>>`;
 }
+/**
+* The `client?:` option type of a mutation hook. When the operation has a request content type choice,
+* the mutation variables carry `contentType`, so the config leaves it out. Otherwise the ambiguous side is
+* narrowed to the operation's media types; a single-type side has nothing to pick, so it stays baked in the
+* generated call.
+*/
 function buildRequestConfigType(node) {
+	if (hasRequestContentTypeChoice(node)) return buildClientOptionType({ omit: ["contentType"] });
 	const request = getContentTypeInfo(node);
 	const response = getResponseContentTypeInfo(node);
 	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
-	const base = buildClientOptionType(node);
+	const base = buildClientOptionType();
 	return members.length ? `${base} & { contentType?: { ${members.join("; ")} } }` : base;
 }
 /** The grouped request options, in the order generated signatures and calls list them. */
@@ -193,19 +205,13 @@ function getRequestGroupOptionality(node) {
 	};
 }
 function buildOperationComments(node, options = {}) {
-	const { link = "pathTemplate", linkPosition = "afterDeprecated", splitLines = false } = options;
-	const linkComment = getOperationLink(node, link);
-	const filteredComments = (linkPosition === "beforeDeprecated" ? [
+	const { splitLines = false } = options;
+	const filteredComments = [
+		getOperationRequestLine(node),
 		node.description && `@description ${node.description}`,
 		node.summary && `@summary ${node.summary}`,
-		linkComment,
 		node.deprecated && "@deprecated"
-	] : [
-		node.description && `@description ${node.description}`,
-		node.summary && `@summary ${node.summary}`,
-		node.deprecated && "@deprecated",
-		linkComment
-	]).filter((comment) => Boolean(comment));
+	].filter((comment) => Boolean(comment));
 	if (!splitLines) return filteredComments;
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
@@ -259,12 +265,6 @@ function getOperationParameters(node) {
 function hasRequestContentTypeChoice(node) {
 	return (node.requestBody?.content ?? []).filter((entry) => entry.schema).length > 1;
 }
-/**
-* Casts a call argument to the client's parameter type; a `'plain'` client is non-generic.
-*/
-function castToClientOptions(callArg, clientName, returnType = "full") {
-	return `${callArg} as Parameters<typeof ${clientName}${returnType === "plain" ? "" : "<true>"}>[0]`;
-}
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
 	return Number.isNaN(code) ? null : code;
@@ -550,8 +550,9 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.10.0-canary.20261109T201601";
+var version = "5.11.0-canary.20261109T211530";
 // ../../internals/client/src/resolveOperationTypes.ts
+const pluginZodName = "plugin-zod";
 /**
 * A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
 * exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
@@ -594,7 +595,7 @@ function toZodTypeResolver(resolver) {
 function resolveOperationTypes(driver, pluginName) {
 	return driver.memo(`operationTypes:${pluginName}`, () => {
 		const pluginTs = driver.getPlugin(_kubb_plugin_ts.pluginTsName);
-		const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
+		const pluginZod = driver.getPlugin(pluginZodName);
 		if (pluginTs && pluginZod?.options?.inferred !== "codec") {
 			const resolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
 			return {
@@ -612,7 +613,7 @@ function resolveOperationTypes(driver, pluginName) {
 			location: { kind: "config" },
 			plugin: pluginName
 		});
-		const resolver = toZodTypeResolver(driver.getResolver(_kubb_plugin_zod.pluginZodName));
+		const resolver = toZodTypeResolver(driver.getResolver(pluginZodName));
 		return {
 			response: resolver.response,
 			resolver,
@@ -956,8 +957,8 @@ function buildGroupedRequestParam(node, options) {
 /**
 * Builds the shared `({ path, query, body, headers, cookies }, config = {})` parameter list for a
 * TanStack query-options function. The leading parameter mirrors the client signature, and the
-* trailing `config` is a partial `RequestConfig` minus the grouped data-shape keys, which are passed
-* explicitly. Framework plugins wrap the result when needed, for example vue-query applies `MaybeRefOrGetter`.
+* trailing `config` is the client's `Options` minus the request groups and `throwOnError`, which the
+* hook passes itself. Framework plugins wrap the result when needed, for example vue-query applies `MaybeRefOrGetter`.
 */
 function buildQueryOptionsParams(node, options) {
 	const { resolver, memberTypeWrapper } = options;
@@ -967,7 +968,7 @@ function buildQueryOptionsParams(node, options) {
 	});
 	const configParam = (0, _kubb_plugin_ts.createFunctionParameter)({
 		name: "config",
-		type: buildClientOptionType(node),
+		type: buildClientOptionType(),
 		default: "{}"
 	});
 	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [groupedParam, configParam].filter((param) => param !== null) });
@@ -979,26 +980,30 @@ function buildQueryOptionsParams(node, options) {
 * can't flip the query's error semantics. Queries thread the TanStack `signal`; mutations omit it.
 *
 * When `unwrapName` is set, each request group is passed as an explicit member unwrapped through it,
-* used by vue-query to resolve refs and getters with `toValue(...)` at call time.
+* used by vue-query to resolve refs and getters with `toValue(...)` at call time. `pageParam` names the
+* query parameter an infinite query sets from TanStack's `pageParam`.
 *
 * @example
 * ```ts
 * buildClientCall(node, { clientName: 'getPetById', signal: true })
-* // getPetById({ path, ...config, signal: config.signal ?? signal, throwOnError: true })
+* // getPetById({ ...config, path, signal: config.signal ?? signal, throwOnError: true })
 * ```
 */
 function buildClientCall(node, options) {
-	const { clientName, signal = false, unwrapName, withContentType = false, returnType = "full" } = options;
+	const { clientName, signal = false, unwrapName, withContentType = false, pageParam } = options;
 	const { groups } = getRequestGroupOptionality(node);
 	const names = requestGroupOrder.filter((key) => groups[key]);
-	const args = [
+	const member = (name) => {
+		const value = unwrapName ? unwrapName(name) : name;
+		if (name === "query" && pageParam) return `query: { ...${value}, ${JSON.stringify(pageParam)}: pageParam }`;
+		return unwrapName ? `${name}: ${value}` : name;
+	};
+	return `${clientName}({ ${[
 		"...config",
-		...withContentType && hasRequestContentTypeChoice(node) ? ["...variables"] : names.map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		...withContentType && hasRequestContentTypeChoice(node) ? ["...variables"] : names.map(member),
 		signal ? "signal: config.signal ?? signal" : null,
 		"throwOnError: true"
-	].filter((part) => part !== null);
-	if (withContentType && hasRequestContentTypeChoice(node)) return `${clientName}(${castToClientOptions(`{ ${args.join(", ")} }`, clientName, returnType)})`;
-	return `${clientName}({ ${args.join(", ")} })`;
+	].filter((part) => part !== null).join(", ")} })`;
 }
 /**
 * Builds the query/mutation body that resolves a `buildClientCall` expression down to the bare
@@ -1247,9 +1252,15 @@ function buildHookParams(node, options) {
 }
 /**
 * The `TRequest` type argument of a mutation hook: the options type when the operation takes a request, else `undefined`.
+* When the variables carry the request media type and the response has several, `contentType` can pick the
+* response one too, as `{ request, response }`.
 */
 function resolveMutationRequestType(node, resolver) {
-	return buildGroupedRequestParam(node, { resolver }) ? resolver.response.options(node) : "undefined";
+	if (!buildGroupedRequestParam(node, { resolver })) return "undefined";
+	const optionsName = resolver.response.options(node);
+	const response = getResponseContentTypeInfo(node);
+	if (!hasRequestContentTypeChoice(node) || !response.isMultipleContentTypes) return optionsName;
+	return `${/^[\w$]+$/.test(optionsName) ? optionsName : `(${optionsName})`} & { contentType?: string | { response?: ${response.contentTypeUnion} } }`;
 }
 /**
 * Builds the object literal that unwraps each request group's getter before it reaches `queryKey`/`queryOptions`; `null` without a request group.
@@ -1283,10 +1294,12 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitI
 		memberTypeWrapper
 	});
 	const paramsSignature = declarationPrinter$6.print(paramsNode) ?? "";
+	const pageParam = queryParam && queryParamsTypeName ? queryParam : void 0;
 	const queryFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: true,
-		unwrapName
+		unwrapName,
+		pageParam
 	}), {
 		clientReturnType,
 		returnType
@@ -1313,12 +1326,7 @@ function InfiniteQueryOptions({ name, clientName, initialPageParam, hasExplicitI
 		getNextPageParamExpr,
 		getPreviousPageParamExpr
 	].filter(Boolean);
-	const infiniteOverrideParams = queryParam && queryParamsTypeName ? `query = {
-      ...(query ?? {}),
-      ['${queryParam}']: pageParam as unknown as ${queryParamsTypeName}['${queryParam}'],
-    } as ${queryParamsTypeName}` : "";
-	const queryFnArgs = infiniteOverrideParams ? "{ signal, pageParam }" : "{ signal }";
-	const queryFnStatements = infiniteOverrideParams ? `${infiniteOverrideParams}\n    ${queryFnBody}` : queryFnBody;
+	const queryFnArgs = pageParam ? "{ signal, pageParam }" : "{ signal }";
 	return /* @__PURE__ */ (0, _kubb_renderer_jsx_jsx_runtime.jsx)(_kubb_renderer_jsx.File.Source, {
 		name,
 		isExportable: true,
@@ -1332,7 +1340,7 @@ const queryKey = ${queryKeyName}(${queryKeyParamsCall})
 return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${queryFnDataType}>, ${queryKeyType}, ${pageParamType}>({
   queryKey,
   queryFn: async (${queryFnArgs}) => {
-    ${queryFnStatements}
+    ${queryFnBody}
   },
   ${queryOptionsArr.join(",\n  ")}
 })
@@ -1793,7 +1801,7 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 		memberTypeWrapper: maybeValueOrGetter,
 		optionsType: `{
   query?: Partial<${observerOptionsType}> & { client?: QueryClient },
-  client?: ${buildClientOptionType(node)}
+  client?: ${buildClientOptionType()}
 }`
 	});
 	const paramsSignature = declarationPrinter$3.print(paramsNode) ?? "";
@@ -2057,13 +2065,12 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 	});
 	const hasMutationParams = groupedParam !== null;
 	const groupedParamsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedParam ? [groupedParam] : [] });
-	const TRequest = hasMutationParams ? tsResolver.response.options(node) : "undefined";
+	const TRequest = resolveMutationRequestType(node, tsResolver);
 	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "_";
 	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
 		signal: false,
-		withContentType: true,
-		returnType: clientReturnType
+		withContentType: true
 	}), {
 		clientReturnType,
 		returnType