@kubb/plugin-vue-query 5.3.0-canary.20261012T190229 → 5.3.0

package/dist/index.d.ts

@@ -119,7 +119,51 @@ type Infinite = {
    * @default 0
    */
   initialPageParam?: unknown;
+  /**
+   * Whether `initialPageParam` was explicitly configured rather than defaulted.
+   * When omitted or false, the default previous page threshold remains 1 (legacy 1-based default).
+   */
+  hasExplicitInitialPageParam?: boolean;
+  /**
+   * Source of TanStack Query's `getNextPageParam`, inlined verbatim as a function expression. Use it
+   * when the next page has to be computed rather than read from a field. Takes precedence over
+   * `nextParam` and `cursorParam`.
+   *
+   * Note: Because functions are inlined verbatim into generated code via `.toString()`, they cannot
+   * reference local closures or external variables from the config file.
+   *
+   * @example
+   * `'(lastPage) => (lastPage.hasNext ? lastPage.number + 1 : undefined)'`
+   * // or with definePageParam:
+   * `definePageParam<MyResponse, number>((lastPage) => (lastPage.hasNext ? lastPage.number + 1 : undefined))`
+   */
+  getNextPageParam?: string | PageParamFn | null;
+  /**
+   * Source of TanStack Query's `getPreviousPageParam`, inlined verbatim as a function expression.
+   * Takes precedence over `previousParam` and `cursorParam`.
+   *
+   * Note: Because functions are inlined verbatim into generated code via `.toString()`, they cannot
+   * reference local closures or external variables from the config file.
+   *
+   * @example
+   * `'(firstPage) => (firstPage.number > 0 ? firstPage.number - 1 : undefined)'`
+   * // or with definePageParam:
+   * `definePageParam<MyResponse, number>((firstPage) => (firstPage.number > 0 ? firstPage.number - 1 : undefined))`
+   */
+  getPreviousPageParam?: string | PageParamFn | null;
 };
+type PageParamFn<TPage = any, TParam = any> = (page: TPage, allPages: Array<TPage>, pageParam: TParam, allPageParams: Array<TParam>) => TParam | undefined | null;
+//#endregion
+//#region ../../internals/tanstack-query/src/utils.d.ts
+/**
+ * Helper to define a typed page param function for `infinite.getNextPageParam` or
+ * `infinite.getPreviousPageParam`. Serializes the function to a string for inlining in generated code.
+ *
+ * Note: Because the function is inlined verbatim into the generated file via `.toString()`,
+ * it must be self-contained and cannot reference local closures or external variables from
+ * the config file.
+ */
+export declare function definePageParam<TPage = any, TParam = any>(fn: PageParamFn<TPage, TParam>): string;
 //#endregion
 //#region src/types.d.ts
 /**
@@ -369,5 +413,5 @@ export declare const pluginVueQuery: import("kubb/kit").PluginFactory<PluginVueQ
  */
 export declare const resolverVueQuery: ResolverVueQuery;
 //#endregion
-export { type PluginVueQuery, type ResolverVueQuery, pluginVueQuery as default };
+export { type PageParamFn, type PluginVueQuery, type ResolverVueQuery, pluginVueQuery as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -323,7 +323,7 @@ function createGroupConfig(group) {
 }
 //#endregion
 //#region package.json
-var version = "5.3.0-canary.20261012T190229";
+var version = "5.3.0";
 //#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
 /**
@@ -541,22 +541,61 @@ function classifyOperation(node, { query, mutation }) {
 	};
 }
 /**
+* Helper to define a typed page param function for `infinite.getNextPageParam` or
+* `infinite.getPreviousPageParam`. Serializes the function to a string for inlining in generated code.
+*
+* Note: Because the function is inlined verbatim into the generated file via `.toString()`,
+* it must be self-contained and cannot reference local closures or external variables from
+* the config file.
+*/
+function definePageParam(fn) {
+	return fn.toString();
+}
+/**
 * Applies the shared infinite-query defaults during plugin setup: a falsy value disables infinite
 * queries, and an object merges over `queryParam: 'id'` and `initialPageParam: 0` with the cursor
 * paths cleared.
 */
 function resolveInfiniteConfig(infinite) {
 	if (!infinite) return false;
+	const hasExplicitInitialPageParam = infinite.hasExplicitInitialPageParam ?? infinite.initialPageParam !== void 0;
+	const getNextPageParam = infinite.getNextPageParam ? typeof infinite.getNextPageParam === "function" ? infinite.getNextPageParam.toString() : infinite.getNextPageParam : null;
+	const getPreviousPageParam = infinite.getPreviousPageParam ? typeof infinite.getPreviousPageParam === "function" ? infinite.getPreviousPageParam.toString() : infinite.getPreviousPageParam : null;
 	return {
 		queryParam: "id",
 		initialPageParam: 0,
+		hasExplicitInitialPageParam,
 		cursorParam: null,
 		nextParam: null,
 		previousParam: null,
-		...infinite
+		getNextPageParam,
+		getPreviousPageParam,
+		...infinite,
+		...getNextPageParam ? { getNextPageParam } : {},
+		...getPreviousPageParam ? { getPreviousPageParam } : {}
 	};
 }
 /**
+* Whether the infinite hook for `node` should be generated: the operation takes the configured
+* `queryParam`.
+*/
+function matchesInfinite(node, infinite) {
+	if (!infinite.queryParam) return false;
+	return getOperationParameters(node).query.some((param) => param.name.replace(/\?$/, "") === infinite.queryParam);
+}
+/**
+* Warning for an infinite hook that falls back to the built-in page params on a response that
+* isn't an array. Those params only stop on an empty array, so `hasNextPage` never turns false.
+*/
+function getDefaultPageParamsWarning(node, infinite) {
+	if (!(infinite.getNextPageParam == null && infinite.getPreviousPageParam == null && infinite.nextParam == null && infinite.previousParam == null && !infinite.cursorParam)) return null;
+	const content = getPrimarySuccessResponse(node)?.content;
+	let resolved = (content?.find((item) => item.contentType?.includes("json")) ?? content?.[0])?.schema;
+	while (resolved?.type === "ref" || resolved?.type === "intersection" && resolved.members?.length === 1) resolved = resolved.type === "ref" ? resolved.schema : resolved.members?.[0];
+	if (!resolved || resolved.type === "array") return null;
+	return `${node.operationId}: the default infinite page params expect an array response and never end for this one. Set \`infinite.getNextPageParam\` (or \`nextParam\`) to read the next page from the response.`;
+}
+/**
 * The request groups a query key is built from, matching `buildQueryKeyParams`. Headers are
 * deliberately absent: they do not identify a cache entry, so the key factory takes no parameter
 * for an operation that only carries headers.
@@ -570,7 +609,7 @@ const queryKeyGroupOrder = [
 //#region ../../internals/tanstack-query/src/components/InfiniteQueryOptions.tsx
 const declarationPrinter$7 = functionPrinter({ mode: "declaration" });
 const callPrinter$4 = functionPrinter({ mode: "call" });
-function InfiniteQueryOptions$1({ name, clientName, initialPageParam, cursorParam, nextParam, previousParam, node, tsResolver, queryParam, queryKeyName, queryKeyType = "typeof queryKey", memberTypeWrapper, unwrapName, returnType = "full" }) {
+function InfiniteQueryOptions$1({ 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);
 	const { queryParamsTypeName, pageParamType } = resolvePageParamType(node, {
 		resolver: tsResolver,
@@ -594,18 +633,25 @@ function InfiniteQueryOptions$1({ name, clientName, initialPageParam, cursorPara
 		signal: true,
 		unwrapName
 	}), { returnType });
-	const hasNewParams = nextParam != null || previousParam != null;
-	const [getNextPageParamExpr, getPreviousPageParamExpr] = (() => {
-		if (hasNewParams) {
-			const nextAccessor = nextParam ? getNestedAccessor(nextParam, "lastPage") : null;
-			const prevAccessor = previousParam ? getNestedAccessor(previousParam, "firstPage") : null;
-			return [nextAccessor ? `getNextPageParam: (lastPage) => ${nextAccessor}` : null, prevAccessor ? `getPreviousPageParam: (firstPage) => ${prevAccessor}` : null];
-		}
-		if (cursorParam) return [`getNextPageParam: (lastPage) => lastPage['${cursorParam}']`, `getPreviousPageParam: (firstPage) => firstPage['${cursorParam}']`];
-		return ["getNextPageParam: (lastPage, _allPages, lastPageParam) => Array.isArray(lastPage) && lastPage.length === 0 ? undefined : lastPageParam + 1", "getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= 1 ? undefined : firstPageParam - 1"];
+	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";
+	})();
+	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 (serializedGetNextPageParam || nextParam) return null;
+		return `getPreviousPageParam: (_firstPage, _allPages, firstPageParam) => firstPageParam <= ${defaultPreviousThreshold} ? undefined : firstPageParam - 1`;
 	})();
 	const queryOptionsArr = [
-		`initialPageParam: ${typeof initialPageParam === "string" ? JSON.stringify(initialPageParam) : initialPageParam}`,
+		`initialPageParam: ${initialPageParamLiteral}`,
 		getNextPageParamExpr,
 		getPreviousPageParamExpr
 	].filter(Boolean);
@@ -1195,21 +1241,28 @@ function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, t
 const infiniteQueryGenerator = defineGenerator({
 	name: "vue-query-infinite",
 	renderer: jsxRenderer,
+	match(node, ctx) {
+		const operationNode = node;
+		if (!ast.isHttpOperationNode(operationNode)) return false;
+		const { query, mutation, infinite, hooks } = ctx.options;
+		const { isQuery, isMutation } = classifyOperation(operationNode, {
+			query,
+			mutation
+		});
+		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
+		if (!isQuery || isMutation || !infiniteOptions || !hooks) return false;
+		return matchesInfinite(operationNode, infiniteOptions);
+	},
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { config, driver, resolver, root } = ctx;
-		const { output, query, mutation, infinite, client, group, hooks } = ctx.options;
+		const { output, query, infinite, client, group } = ctx.options;
+		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
+		if (!infiniteOptions) return null;
+		const pageParamsWarning = getDefaultPageParamsWarning(node, infiniteOptions);
+		if (pageParamsWarning) ctx.warn(pageParamsWarning);
 		const pluginTs = ctx.requirePlugin(pluginTsName);
 		const tsResolver = driver.getResolver(pluginTsName);
-		const { isQuery, isMutation } = classifyOperation(node, {
-			query,
-			mutation
-		});
-		const infiniteOptions = infinite && typeof infinite === "object" ? infinite : null;
-		if (!isQuery || isMutation || !infiniteOptions || !hooks) return null;
-		const normalizeKey = (key) => key.replace(/\?$/, "");
-		const queryParamKeys = getOperationParameters(node).query.map((p) => p.name);
-		if (!(infiniteOptions.queryParam ? queryParamKeys.some((k) => normalizeKey(k) === infiniteOptions.queryParam) : false)) return null;
 		const importPath = query ? query.importPath : "@tanstack/vue-query";
 		const contractOp = resolveClientOperation({
 			clientPlugin: { pluginName: client.pluginName },
@@ -1328,7 +1381,10 @@ const infiniteQueryGenerator = defineGenerator({
 					cursorParam: infiniteOptions.cursorParam,
 					nextParam: infiniteOptions.nextParam,
 					previousParam: infiniteOptions.previousParam,
+					getNextPageParam: infiniteOptions.getNextPageParam,
+					getPreviousPageParam: infiniteOptions.getPreviousPageParam,
 					initialPageParam: infiniteOptions.initialPageParam,
+					hasExplicitInitialPageParam: infiniteOptions.hasExplicitInitialPageParam,
 					queryParam: infiniteOptions.queryParam,
 					returnType: contractOp.returnType
 				}),
@@ -1744,6 +1800,6 @@ const pluginVueQuery = definePlugin({
 	}
 });
 //#endregion
-export { pluginVueQuery as default, pluginVueQuery, pluginVueQueryName, resolverVueQuery };
+export { pluginVueQuery as default, pluginVueQuery, definePageParam, pluginVueQueryName, resolverVueQuery };
 
 //# sourceMappingURL=index.js.map