@kubb/plugin-react-query 5.0.0-beta.56 → 5.0.0-beta.64

package/dist/{components-DL0Cai7l.js → components-Ds-e_nnK.js}

@@ -1,9 +1,9 @@
 import "./chunk-C0LytTxp.js";
 import { ast } from "@kubb/core";
+import { buildGroupParam, caseParams, createOperationParams, getNestedAccessor, resolveGroupType, resolveParamType } from "@kubb/ast/utils";
 import { functionPrinter } from "@kubb/plugin-ts";
 import { File, Function, Type } from "@kubb/renderer-jsx";
 import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
-import { getNestedAccessor } from "@kubb/ast/utils";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -278,7 +278,7 @@ function buildOperationComments(node, options = {}) {
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
 function getOperationParameters(node, options = {}) {
-	const params = ast.caseParams(node.parameters, options.paramsCasing);
+	const params = caseParams(node.parameters, options.paramsCasing);
 	return {
 		path: params.filter((param) => param.in === "path"),
 		query: params.filter((param) => param.in === "query"),
@@ -360,7 +360,7 @@ const mutationKeyTransformer = ({ node }) => {
 	return [`{ url: '${Url.toPath(node.path)}' }`];
 };
 function MutationKey({ name, paramsCasing, node, transformer }) {
-	const paramsNode = ast.createFunctionParameters({ params: [] });
+	const paramsNode = ast.factory.createFunctionParameters({ params: [] });
 	const paramsSignature = declarationPrinter$10.print(paramsNode) ?? "";
 	const keys = (transformer ?? mutationKeyTransformer)({
 		node,
@@ -382,6 +382,14 @@ function MutationKey({ name, paramsCasing, node, transformer }) {
 //#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
 /**
+* Returns the `TypeLiteral` members of a destructured group parameter, or `null`
+* for a plain named parameter.
+*/
+function groupMembers(param) {
+	if (typeof param.name === "string") return null;
+	return param.type && typeof param.type !== "string" && param.type.kind === "TypeLiteral" ? param.type.members : [];
+}
+/**
 * Builds the shared `(…params, config = {})` parameter list for a TanStack
 * query-options function. The trailing `config` parameter is typed as a partial
 * `RequestConfig` with an optional `client`. Framework plugins wrap the result
@@ -390,17 +398,14 @@ function MutationKey({ name, paramsCasing, node, transformer }) {
 function buildQueryOptionsParams(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : void 0;
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver,
-		extraParams: [ast.createFunctionParameter({
+		extraParams: [ast.factory.createFunctionParameter({
 			name: "config",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"
-			}),
+			type: requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }",
 			default: "{}"
 		})]
 	});
@@ -473,107 +478,52 @@ function resolveZodSchemaNames(node, zodResolver, parser) {
 	].filter((n) => Boolean(n));
 }
 /**
-* Resolve the type for a single path parameter.
-*
-* - When the resolver's group name differs from the individual param name
-*   (e.g. kubbV4) → `GroupName['paramName']` (member access).
-* - When they match (v5 default) → `TypeName` (direct reference).
-*/
-function resolvePathParamType(node, param, resolver) {
-	const individualName = resolver.resolveParamName(node, param);
-	const groupName = resolver.resolvePathParamsName(node, param);
-	if (groupName !== individualName) return ast.createParamsType({
-		variant: "member",
-		base: groupName,
-		key: param.name
-	});
-	return ast.createParamsType({
-		variant: "reference",
-		name: individualName
-	});
-}
-/**
-* Derive a query-params group type from the resolver.
-* Returns `null` when no query params exist or when the group name
-* equals the individual param name (no real group).
-*/
-function resolveQueryGroupType(node, params, resolver) {
-	if (!params.length) return null;
-	const firstParam = params[0];
-	const groupName = resolver.resolveQueryParamsName(node, firstParam);
-	if (groupName === resolver.resolveParamName(node, firstParam)) return null;
-	return {
-		type: ast.createParamsType({
-			variant: "reference",
-			name: groupName
-		}),
-		optional: params.every((p) => !p.required)
-	};
-}
-/**
-* Build a single `FunctionParameterNode` for a query or header group.
-*/
-function buildGroupParam(name, node, params, groupType, resolver) {
-	if (groupType) return [ast.createFunctionParameter({
-		name,
-		type: groupType.type,
-		optional: groupType.optional
-	})];
-	if (params.length) {
-		const structProps = params.map((p) => ({
-			name: p.name,
-			type: ast.createParamsType({
-				variant: "reference",
-				name: resolver.resolveParamName(node, p)
-			}),
-			optional: !p.required
-		}));
-		return [ast.createFunctionParameter({
-			name,
-			type: ast.createParamsType({
-				variant: "struct",
-				properties: structProps
-			}),
-			optional: params.every((p) => !p.required)
-		})];
-	}
-	return [];
-}
-/**
 * Build QueryKey params: pathParams + data + queryParams (NO headers, NO config).
 */
 function buildQueryKeyParams(node, options) {
 	const { pathParamsType, paramsCasing, resolver } = options;
-	const casedParams = ast.caseParams(node.parameters, paramsCasing);
+	const casedParams = caseParams(node.parameters, paramsCasing);
 	const pathParams = casedParams.filter((p) => p.in === "path");
 	const queryParams = casedParams.filter((p) => p.in === "query");
-	const queryGroupType = resolveQueryGroupType(node, queryParams, resolver);
-	const bodyType = node.requestBody?.content?.[0]?.schema ? ast.createParamsType({
-		variant: "reference",
-		name: resolver.resolveDataName(node)
-	}) : null;
+	const queryGroupType = resolveGroupType({
+		node,
+		params: queryParams,
+		group: "query",
+		resolver
+	});
+	const bodyType = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
 	const bodyRequired = node.requestBody?.required ?? false;
 	const params = [];
 	if (pathParams.length) {
-		const pathChildren = pathParams.map((p) => ast.createFunctionParameter({
+		const pathChildren = pathParams.map((p) => ({
 			name: p.name,
-			type: resolvePathParamType(node, p, resolver),
+			type: resolveParamType({
+				node,
+				param: p,
+				resolver
+			}),
 			optional: !p.required
 		}));
-		params.push({
-			kind: "ParameterGroup",
+		if (pathParamsType === "object") params.push(ast.factory.createFunctionParameter({
 			properties: pathChildren,
-			inline: pathParamsType === "inline",
 			default: pathChildren.every((c) => c.optional) ? "{}" : void 0
-		});
+		}));
+		else params.push(...pathChildren.map((child) => ast.factory.createFunctionParameter(child)));
 	}
-	if (bodyType) params.push(ast.createFunctionParameter({
+	if (bodyType) params.push(ast.factory.createFunctionParameter({
 		name: "data",
 		type: bodyType,
 		optional: !bodyRequired
 	}));
-	params.push(...buildGroupParam("params", node, queryParams, queryGroupType, resolver));
-	return ast.createFunctionParameters({ params });
+	params.push(...buildGroupParam({
+		name: "params",
+		node,
+		params: queryParams,
+		groupType: queryGroupType,
+		resolver,
+		wrapType: (type) => type
+	}));
+	return ast.factory.createFunctionParameters({ params });
 }
 /**
 * Collect the names of the required params (no default) that drive the `enabled`
@@ -582,12 +532,11 @@ function buildQueryKeyParams(node, options) {
 */
 function getEnabledParamNames(paramsNode) {
 	const required = [];
-	for (const param of paramsNode.params) if ("kind" in param && param.kind === "ParameterGroup") {
-		const group = param;
-		for (const child of group.properties) if (!child.optional && child.default === void 0) required.push(child.name);
-	} else {
-		const fp = param;
-		if (!fp.optional && fp.default === void 0) required.push(fp.name);
+	for (const param of paramsNode.params) {
+		const members = groupMembers(param);
+		if (members) {
+			for (const member of members) if (!member.optional) required.push(member.name);
+		} else if (typeof param.name === "string" && !param.optional && param.default === void 0) required.push(param.name);
 	}
 	return required;
 }
@@ -603,27 +552,25 @@ function markParamsOptional(paramsNode, names) {
 	if (names.length === 0) return paramsNode;
 	const nameSet = new Set(names);
 	const params = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
+		const members = groupMembers(param);
+		if (members) {
+			const next = members.map((member) => nameSet.has(member.name) ? {
+				...member,
+				optional: true
+			} : member);
 			return {
-				...group,
-				properties: group.properties.map((child) => nameSet.has(child.name) ? ast.createFunctionParameter({
-					name: child.name,
-					type: child.type,
-					rest: child.rest,
-					optional: true
-				}) : child)
+				...param,
+				type: ast.factory.createTypeLiteral({ members: next })
 			};
 		}
-		const fp = param;
-		return nameSet.has(fp.name) ? ast.createFunctionParameter({
-			name: fp.name,
-			type: fp.type,
-			rest: fp.rest,
+		return typeof param.name === "string" && nameSet.has(param.name) ? ast.factory.createFunctionParameter({
+			name: param.name,
+			type: param.type,
+			rest: param.rest,
 			optional: true
-		}) : fp;
+		}) : param;
 	});
-	return ast.createFunctionParameters({ params });
+	return ast.factory.createFunctionParameters({ params });
 }
 /**
 * Add a non-null assertion (`!`) to the named params inside a printed client-call
@@ -751,18 +698,15 @@ const callPrinter$7 = functionPrinter({ mode: "call" });
 function buildInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = ast.createFunctionParameter({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -951,14 +895,11 @@ return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${que
 //#region src/components/MutationOptions.tsx
 const declarationPrinter$5 = functionPrinter({ mode: "declaration" });
 const callPrinter$5 = functionPrinter({ mode: "call" });
-const keysPrinter = functionPrinter({ mode: "keys" });
+const keysPrinter = functionPrinter({ mode: "call" });
 function buildMutationConfigParamsNode(node, resolver) {
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+	return ast.factory.createFunctionParameters({ params: [ast.factory.createFunctionParameter({
 		name: "config",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: buildRequestConfigType(node, resolver)
-		}),
+		type: buildRequestConfigType(node, resolver),
 		default: "{}"
 	})] });
 }
@@ -970,7 +911,7 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const configParamsNode = buildMutationConfigParamsNode(node, tsResolver);
 	const paramsSignature = declarationPrinter$5.print(configParamsNode) ?? "";
-	const mutationArgParamsNode = ast.createOperationParams(node, {
+	const mutationArgParamsNode = createOperationParams(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing,
@@ -979,17 +920,14 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 	const hasMutationParams = mutationArgParamsNode.params.length > 0;
 	const TRequest = hasMutationParams ? declarationPrinter$5.print(mutationArgParamsNode) ?? "" : "";
 	const argKeysStr = hasMutationParams ? keysPrinter.print(mutationArgParamsNode) ?? "" : "";
-	const clientCallParamsNode = ast.createOperationParams(node, {
+	const clientCallParamsNode = createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
 		resolver: tsResolver,
-		extraParams: [ast.createFunctionParameter({
+		extraParams: [ast.factory.createFunctionParameter({
 			name: "config",
-			type: ast.createParamsType({
-				variant: "reference",
-				name: buildRequestConfigType(node, tsResolver)
-			}),
+			type: buildRequestConfigType(node, tsResolver),
 			default: "{}"
 		})]
 	});
@@ -1020,7 +958,7 @@ function MutationOptions({ name, clientName, dataReturnType, node, tsResolver, p
 const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
 const callPrinter$4 = functionPrinter({ mode: "call" });
 function createMutationArgParams(node, options) {
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing: options.paramsCasing,
@@ -1045,15 +983,12 @@ function buildMutationParamsNode(node, options) {
 		TRequest ? `{${TRequest}}` : "undefined",
 		"TContext"
 	].join(", ");
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+	return ast.factory.createFunctionParameters({ params: [ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   mutation?: UseMutationOptions<${generics}> & { client?: QueryClient },
   client?: ${buildRequestConfigType(node, resolver)},
-}`
-		}),
+}`,
 		default: "{}"
 	})] });
 }
@@ -1121,24 +1056,21 @@ function buildQueryParamsNode(node, options) {
 	const errorNames = resolveErrorNames(node, resolver);
 	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = ast.createFunctionParameter({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<QueryObserverOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TData",
+			"TQueryData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1215,18 +1147,15 @@ const callPrinter$2 = functionPrinter({ mode: "call" });
 function buildSuspenseInfiniteQueryParamsNode(node, options) {
 	const { paramsType, paramsCasing, pathParamsType, resolver, pageParamGeneric } = options;
 	const requestName = node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null;
-	const optionsParam = ast.createFunctionParameter({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<UseSuspenseInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, ${pageParamGeneric}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1420,23 +1349,20 @@ function buildSuspenseQueryParamsNode(node, options) {
 	const errorNames = resolveErrorNames(node, resolver);
 	const TData = dataReturnType === "data" ? responseName : buildStatusUnionType(node, resolver);
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
-	const optionsParam = ast.createFunctionParameter({
+	const optionsParam = ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   query?: Partial<UseSuspenseQueryOptions<${[
-				TData,
-				TError,
-				"TData",
-				"TQueryKey"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TData",
+			"TQueryKey"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1504,4 +1430,4 @@ function SuspenseQuery({ name, queryKeyTypeName, queryOptionsName, queryKeyName,
 //#endregion
 export { operationFileEntry as _, Mutation as a, InfiniteQuery as c, queryKeyTransformer as d, resolveOperationOverrides as f, getOperationParameters as g, mutationKeyTransformer as h, Query as i, QueryOptions as l, MutationKey as m, SuspenseInfiniteQueryOptions as n, MutationOptions as o, resolveZodSchemaNames as p, SuspenseInfiniteQuery as r, InfiniteQueryOptions as s, SuspenseQuery as t, QueryKey as u, resolveOperationTypeNames as v, camelCase as y };
 
-//# sourceMappingURL=components-DL0Cai7l.js.map
+//# sourceMappingURL=components-Ds-e_nnK.js.map