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

package/dist/{components-B79Gljyl.js → components-CAlEf7Oh.js}

@@ -1,9 +1,9 @@
 import { t as __name } from "./chunk-C0LytTxp.js";
 import { ast } from "@kubb/core";
-import { functionPrinter } from "@kubb/plugin-ts";
+import { buildGroupParam, caseParams, createOperationParams, getNestedAccessor, resolveGroupType, resolveParamType } from "@kubb/ast/utils";
+import { functionPrinter, renderType } 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$7.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: "{}"
 		})]
 	});
@@ -451,107 +456,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`
@@ -560,12 +510,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;
 }
@@ -581,27 +530,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 });
 }
 functionPrinter({ mode: "declaration" });
 const queryKeyTransformer = ({ node, casing }) => {
@@ -620,43 +567,31 @@ const queryKeyTransformer = ({ node, casing }) => {
 };
 //#endregion
 //#region src/utils.ts
-function printType(typeNode) {
-	if (!typeNode) return "unknown";
-	if (typeNode.variant === "reference") return typeNode.name;
-	if (typeNode.variant === "member") return `${typeNode.base}['${typeNode.key}']`;
-	if (typeNode.variant === "struct") return `{ ${typeNode.properties.map((p) => {
-		const typeStr = printType(p.type);
-		const key = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(p.name) ? p.name : JSON.stringify(p.name);
-		return p.optional ? `${key}?: ${typeStr}` : `${key}: ${typeStr}`;
-	}).join("; ")} }`;
-	return "unknown";
-}
+/**
+* Wraps each parameter type in `MaybeRefOrGetter<…>` so a vue-query signature
+* accepts refs or getters. Group members are wrapped individually; `skip` opts a
+* plain parameter out by name.
+*/
 function wrapWithMaybeRefOrGetter(paramsNode, skip) {
 	const wrappedParams = paramsNode.params.map((param) => {
-		if ("kind" in param && param.kind === "ParameterGroup") {
-			const group = param;
-			return {
-				...group,
-				properties: group.properties.map((p) => ({
-					...p,
-					type: p.type ? ast.createParamsType({
-						variant: "reference",
-						name: `MaybeRefOrGetter<${printType(p.type)}>`
-					}) : p.type
-				}))
+		if (typeof param.name !== "string") {
+			const type = param.type;
+			if (type && typeof type !== "string" && type.kind === "TypeLiteral") return {
+				...param,
+				type: ast.factory.createTypeLiteral({ members: type.members.map((member) => ({
+					...member,
+					type: `MaybeRefOrGetter<${renderType(member.type)}>`
+				})) })
 			};
+			return param;
 		}
-		const fp = param;
-		if (skip?.(fp.name)) return fp;
+		if (skip?.(param.name)) return param;
 		return {
-			...fp,
-			type: fp.type ? ast.createParamsType({
-				variant: "reference",
-				name: `MaybeRefOrGetter<${printType(fp.type)}>`
-			}) : fp.type
+			...param,
+			type: param.type ? `MaybeRefOrGetter<${renderType(param.type)}>` : param.type
 		};
 	});
-	return ast.createFunctionParameters({ params: wrappedParams });
+	return ast.factory.createFunctionParameters({ params: wrappedParams });
 }
 //#endregion
 //#region src/components/QueryKey.tsx
@@ -781,24 +716,21 @@ function buildInfiniteQueryParamsNode(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<UseInfiniteQueryOptions<${[
-				TData,
-				TError,
-				"TQueryData",
-				"TQueryKey",
-				"TQueryData"
-			].join(", ")}>> & { client?: QueryClient },
+			TData,
+			TError,
+			"TQueryData",
+			"TQueryKey",
+			"TQueryData"
+		].join(", ")}>> & { client?: QueryClient },
   client?: ${requestName ? `Partial<RequestConfig<${requestName}>> & { client?: Client }` : "Partial<RequestConfig> & { client?: Client }"}
-}`
-		}),
+}`,
 		default: "{}"
 	});
-	return wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -984,9 +916,9 @@ function addToValueCalls(callStr, enabledNames = []) {
 //#region src/components/Mutation.tsx
 const declarationPrinter$1 = functionPrinter({ mode: "declaration" });
 const callPrinter$1 = functionPrinter({ mode: "call" });
-const keysPrinter = functionPrinter({ mode: "keys" });
+const keysPrinter = functionPrinter({ mode: "call" });
 function createMutationArgParams(node, options) {
-	return ast.createOperationParams(node, {
+	return createOperationParams(node, {
 		paramsType: "inline",
 		pathParamsType: "inline",
 		paramsCasing: options.paramsCasing,
@@ -1005,20 +937,17 @@ function buildMutationParamsNode(node, options) {
 		resolver
 	}));
 	const TRequestWrapped = wrappedParamsNode.params.length > 0 ? declarationPrinter$1.print(wrappedParamsNode) ?? "" : "";
-	return ast.createFunctionParameters({ params: [ast.createFunctionParameter({
+	return ast.factory.createFunctionParameters({ params: [ast.factory.createFunctionParameter({
 		name: "options",
-		type: ast.createParamsType({
-			variant: "reference",
-			name: `{
+		type: `{
   mutation?: MutationObserverOptions<${[
-				TData,
-				TError,
-				TRequestWrapped ? `{${TRequestWrapped}}` : "undefined",
-				"TContext"
-			].join(", ")}> & { client?: QueryClient },
+			TData,
+			TError,
+			TRequestWrapped ? `{${TRequestWrapped}}` : "undefined",
+			"TContext"
+		].join(", ")}> & { client?: QueryClient },
   client?: ${buildRequestConfigType(node, resolver)},
-}`
-		}),
+}`,
 		default: "{}"
 	})] });
 }
@@ -1041,19 +970,16 @@ function Mutation({ name, clientName, paramsCasing, paramsType, pathParamsType,
 		TRequest ? `{${TRequest}}` : "undefined",
 		"TContext"
 	].join(", ");
-	const mutationKeyParamsNode = ast.createFunctionParameters({ params: [] });
+	const mutationKeyParamsNode = ast.factory.createFunctionParameters({ params: [] });
 	const mutationKeyParamsCall = callPrinter$1.print(mutationKeyParamsNode) ?? "";
-	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: "{}"
 		})]
 	});
@@ -1102,24 +1028,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<UseQueryOptions<${[
-				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 wrapWithMaybeRefOrGetter(ast.createOperationParams(node, {
+	return wrapWithMaybeRefOrGetter(createOperationParams(node, {
 		paramsType,
 		pathParamsType: paramsType === "object" ? "object" : pathParamsType === "object" ? "object" : "inline",
 		paramsCasing,
@@ -1192,4 +1115,4 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, paramsT
 //#endregion
 export { QueryOptions as a, resolveZodSchemaNames as c, getOperationParameters as d, operationFileEntry as f, InfiniteQuery as i, MutationKey as l, camelCase as m, Mutation as n, QueryKey as o, resolveOperationTypeNames as p, InfiniteQueryOptions as r, queryKeyTransformer as s, Query as t, mutationKeyTransformer as u };
 
-//# sourceMappingURL=components-B79Gljyl.js.map
+//# sourceMappingURL=components-CAlEf7Oh.js.map