@7nohe/openapi-react-query-codegen 3.0.1 → 3.0.2

package/dist/parseOperations.d.mts

@@ -1,4 +1,4 @@
-import type { Project } from "ts-morph";
+import { type Project } from "ts-morph";
 import type { GenerationContext, OperationInfo } from "./types.mjs";
 /**
  * Parse operations from the OpenAPI-generated service file and return normalized DTOs.

package/dist/parseOperations.mjs

@@ -1,3 +1,4 @@
+import { Node, } from "ts-morph";
 import ts from "typescript";
 import { capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromVariable, getShortType, getVariableArrowFunctionParameters, } from "./common.mjs";
 import { modelsFileName, serviceFileName } from "./constants.mjs";
@@ -36,8 +37,25 @@ function extractParameters(method, pageParam) {
     });
 }
 /**
- * Get paginatable methods by checking if their Data type has the pageParam in query property.
+ * Read the operation's Data type name from the first type argument of the
+ * SDK options parameter (`Options<XData, ThrowOnError>`).
+ * See OperationInfo.dataTypeName for why the name is read from the signature
+ * instead of derived from the method name (#213).
+ */
+function getDataTypeNameFromSignature(optionsParam) {
+    const typeNode = optionsParam?.getTypeNode();
+    if (!typeNode || !Node.isTypeReference(typeNode))
+        return undefined;
+    if (typeNode.getTypeName().getText() !== "Options")
+        return undefined;
+    const [dataTypeArg] = typeNode.getTypeArguments();
+    return dataTypeArg?.getText();
+}
+/**
+ * Get paginatable Data types by checking if they have the pageParam in their query property.
  * Uses TypeScript compiler API for accurate AST traversal.
+ * The map is keyed by the Data type name (e.g., "FindPetsData") so callers can
+ * look it up with the name read from the SDK signature.
  */
 function getPaginatableMethods(project, pageParam) {
     const modelsFile = project
@@ -70,13 +88,9 @@ function getPaginatableMethods(project, pageParam) {
             continue;
         const pageParamNode = queryType.members.find((m) => ts.isPropertySignature(m) && m.name?.getText() === pageParam);
         if (pageParamNode) {
-            // Extract method name from Data type name (e.g., "FindPetsData" -> "findPets")
-            const methodName = key.slice(0, -4); // Remove "Data" suffix
-            // Convert first letter to lowercase
-            const methodNameLower = methodName.charAt(0).toLowerCase() + methodName.slice(1);
             const pageParamType = pageParamNode.type?.getText(modelsFile.compilerNode);
             const resolvedType = typeChecker.getTypeAtLocation(pageParamNode.type ?? pageParamNode);
-            paginatableMethods.set(methodNameLower, {
+            paginatableMethods.set(key, {
                 type: pageParamType ?? "unknown",
                 typeKind: getPageParamTypeKind(resolvedType),
             });
@@ -100,11 +114,15 @@ export async function parseOperations(project, pageParam) {
         // via extractPropertiesFromObjectParam for type alias properties (path, url).
         const sdkParams = getVariableArrowFunctionParameters(desc.method);
         const allParamsOptional = sdkParams.length === 0 || sdkParams[0].isOptional();
-        const pageParamInfo = paginatableMethods.get(methodName);
+        const dataTypeName = getDataTypeNameFromSignature(sdkParams[0]);
+        const pageParamInfo = dataTypeName
+            ? paginatableMethods.get(dataTypeName)
+            : undefined;
         const isPaginatable = httpMethod === "GET" && pageParamInfo !== undefined;
         return {
             methodName,
             capitalizedMethodName: capitalizeFirstLetter(methodName),
+            dataTypeName,
             httpMethod,
             jsDoc: desc.jsDoc,
             isDeprecated: desc.isDeprecated,

package/dist/tsmorph/buildCommon.d.mts

@@ -30,7 +30,7 @@ export declare function buildMutationKeyConst(op: OperationInfo): VariableStatem
  * Example: export const UseFindPetsKeyFn = (clientOptions: Options<FindPetsData, true> = {}, queryKey?: Array<unknown>) =>
  *   [useFindPetsKey, ...(queryKey ?? [clientOptions])];
  */
-export declare function buildQueryKeyFn(op: OperationInfo, ctx: GenerationContext): VariableStatementStructure;
+export declare function buildQueryKeyFn(op: OperationInfo): VariableStatementStructure;
 /**
  * Build mutation key function.
  * Example: export const UseAddPetKeyFn = (mutationKey?: Array<unknown>) =>

package/dist/tsmorph/buildCommon.mjs

@@ -1,4 +1,5 @@
 import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { getDataTypeName } from "./operationNames.mjs";
 /**
  * Build the default response type alias.
  * Example: export type FindPetsDefaultResponse = Awaited<ReturnType<typeof findPets>>["data"];
@@ -78,10 +79,8 @@ export function buildMutationKeyConst(op) {
  * Example: export const UseFindPetsKeyFn = (clientOptions: Options<FindPetsData, true> = {}, queryKey?: Array<unknown>) =>
  *   [useFindPetsKey, ...(queryKey ?? [clientOptions])];
  */
-export function buildQueryKeyFn(op, ctx) {
-    const dataTypeName = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
-        ? `${op.capitalizedMethodName}Data`
-        : "unknown";
+export function buildQueryKeyFn(op) {
+    const dataTypeName = getDataTypeName(op);
     const params = [];
     const defaultValue = op.allParamsOptional ? " = {}" : "";
     params.push(`clientOptions: Options<${dataTypeName}, true>${defaultValue}`);
@@ -126,12 +125,8 @@ export function buildMutationKeyFn(op) {
  *   { query?: Omit<NonNullable<FindPaginatedPetsData["query"]>, "page"> };
  */
 export function buildInfiniteClientOptionsType(op, ctx) {
-    const dataTypeName = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
-        ? `${op.capitalizedMethodName}Data`
-        : "unknown";
-    const type = dataTypeName === "unknown"
-        ? "Options<unknown, true>"
-        : `Omit<Options<${dataTypeName}, true>, "query"> & { query?: Omit<NonNullable<${dataTypeName}["query"]>, "${ctx.pageParam}"> }`;
+    const dataTypeName = getDataTypeName(op);
+    const type = `Omit<Options<${dataTypeName}, true>, "query"> & { query?: Omit<NonNullable<${dataTypeName}["query"]>, "${ctx.pageParam}"> }`;
     return {
         kind: StructureKind.TypeAlias,
         isExported: true,

package/dist/tsmorph/buildMutationHooks.mjs

@@ -1,19 +1,6 @@
 import { StructureKind, VariableDeclarationKind, } from "ts-morph";
 import { SDK_CALL_ARGS } from "./buildQueryHooks.mjs";
-/**
- * Get the error type string based on client type.
- */
-function getErrorType(op, ctx) {
-    const errorTypeName = `${op.capitalizedMethodName}Error`;
-    // Operations without error responses have no generated Error type
-    const errorType = ctx.modelNames.includes(errorTypeName)
-        ? errorTypeName
-        : "unknown";
-    if (ctx.client === "@hey-api/client-axios") {
-        return `AxiosError<${errorType}>`;
-    }
-    return errorType;
-}
+import { getDataTypeName, getErrorType } from "./operationNames.mjs";
 /**
  * Build useMutation hook.
  * Example:
@@ -30,10 +17,7 @@ export function buildUseMutationHook(op, ctx) {
     const hookName = `use${op.capitalizedMethodName}`;
     const errorType = getErrorType(op, ctx);
     const dataTypeDefault = `Common.${op.capitalizedMethodName}MutationResult`;
-    const dataTypeName = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
-        ? `${op.capitalizedMethodName}Data`
-        : "unknown";
-    const optionsType = `Options<${dataTypeName}, true>`;
+    const optionsType = `Options<${getDataTypeName(op)}, true>`;
     const mutationFn = `clientOptions => ${op.methodName}(${SDK_CALL_ARGS}) as unknown as Promise<TData>`;
     const body = `useMutation<TData, TError, ${optionsType}, TContext>({ mutationKey: Common.Use${op.capitalizedMethodName}KeyFn(mutationKey), mutationFn: ${mutationFn}, ...options })`;
     return {

package/dist/tsmorph/buildQueryHooks.d.mts

@@ -1,10 +1,5 @@
 import { type VariableStatementStructure } from "ts-morph";
 import type { GenerationContext, OperationInfo } from "../types.mjs";
-/**
- * Resolve the generated Data type name for an operation, falling back to
- * unknown when the operation has no generated Data type.
- */
-export declare function getDataTypeName(op: OperationInfo, ctx: GenerationContext): string;
 /**
  * SDK call arguments shared by every generated queryFn/mutationFn.
  * throwOnError: true forces the SDK call to reject on error responses; the
@@ -19,17 +14,28 @@ export declare function getPageParamType(op: OperationInfo): string;
 /**
  * Build the client options parameter string.
  */
-export declare function buildClientOptionsParam(op: OperationInfo, ctx: GenerationContext): string;
+export declare function buildClientOptionsParam(op: OperationInfo): string;
 /**
  * Build the clientOptions parameter typed with the page-less infinite
  * options type — the page parameter is supplied by TanStack Query's
  * pageParam mechanism.
  */
 export declare function buildInfiniteClientOptionsParam(op: OperationInfo): string;
+/**
+ * The type of a single page. TanStack Query instantiates the infinite options
+ * with this as TQueryFnData, so it is what `getNextPageParam` receives as
+ * `lastPage` (#203). NonNullable because `throwOnError: true` means a resolved
+ * page is always present.
+ */
+export declare function getPageType(op: OperationInfo): string;
 /**
  * Build the paginated SDK call shared by every infinite query builder.
+ * The resolved response is narrowed to the page type so it matches the
+ * TQueryFnData the infinite options are instantiated with (#203). Spelled as
+ * a cast rather than `!` because generated code is linted downstream, and a
+ * non-null assertion trips biome's noNonNullAssertion.
  */
-export declare function buildPagedQueryFn(op: OperationInfo, ctx: GenerationContext, castTData: boolean): string;
+export declare function buildPagedQueryFn(op: OperationInfo, ctx: GenerationContext): string;
 /**
  * Format the initialPageParam literal. Emits `undefined` when the caller opted
  * to omit it (#177); otherwise a numeric literal when possible so the inferred
@@ -51,8 +57,15 @@ export declare function buildGetNextPageParamExpr(ctx: GenerationContext, op?: O
  * Build an options type where the pagination fields TanStack Query marks as
  * required become optional overrides: the generator supplies them, and
  * callers may replace them for custom pagination schemes (#156, #146).
+ *
+ * The first type argument is TQueryFnData — a single page — not TData (#203).
+ * Passing TData there made `getNextPageParam` receive the aggregated
+ * `InfiniteData<...>` as `lastPage`, so any custom pagination logic failed to
+ * compile. Only the first three type arguments are written: TanStack Query
+ * dropped TQueryData from `UseInfiniteQueryOptions` within the v5 line, so
+ * positions beyond TData are not stable across the supported peer range.
  */
-export declare function buildOverridableInfiniteOptionsType(optionsTypeName: string): string;
+export declare function buildOverridableInfiniteOptionsType(optionsTypeName: string, pageType: string): string;
 /**
  * Build useQuery hook.
  * Example:
@@ -89,14 +102,14 @@ export declare function buildUseSuspenseInfiniteQueryHook(op: OperationInfo, ctx
  *     ...options
  *   });
  */
-export declare function buildPrefetchFn(op: OperationInfo, ctx: GenerationContext): VariableStatementStructure;
+export declare function buildPrefetchFn(op: OperationInfo): VariableStatementStructure;
 /**
  * Build prefetchInfiniteQuery function for a paginatable operation.
  * Example:
- * export const prefetchUseFindPaginatedPetsInfinite = (queryClient: QueryClient, clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, options?: Omit<FetchInfiniteQueryOptions<Common.FindPaginatedPetsDefaultResponse>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">) =>
+ * export const prefetchUseFindPaginatedPetsInfinite = (queryClient: QueryClient, clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, options?: Omit<FetchInfiniteQueryOptions<NonNullable<Common.FindPaginatedPetsDefaultResponse>>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"> & Partial<Pick<FetchInfiniteQueryOptions<NonNullable<Common.FindPaginatedPetsDefaultResponse>>, "initialPageParam">> & { getNextPageParam?: GetNextPageParamFunction<unknown, NonNullable<Common.FindPaginatedPetsDefaultResponse>> }) =>
  *   queryClient.prefetchInfiniteQuery({
  *     queryKey: Common.UseFindPaginatedPetsInfiniteKeyFn(clientOptions),
- *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data),
+ *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data as NonNullable<Common.FindPaginatedPetsDefaultResponse>),
  *     initialPageParam: 1,
  *     getNextPageParam: (response: unknown) => (response as { nextPage: number }).nextPage,
  *     ...options
@@ -113,4 +126,4 @@ export declare function buildPrefetchInfiniteQueryFn(op: OperationInfo, ctx: Gen
  *     ...options
  *   });
  */
-export declare function buildEnsureQueryDataFn(op: OperationInfo, ctx: GenerationContext): VariableStatementStructure;
+export declare function buildEnsureQueryDataFn(op: OperationInfo): VariableStatementStructure;

package/dist/tsmorph/buildQueryHooks.mjs

@@ -1,27 +1,5 @@
 import { StructureKind, VariableDeclarationKind, } from "ts-morph";
-/**
- * Get the error type string based on client type.
- */
-function getErrorType(op, ctx) {
-    const errorTypeName = `${op.capitalizedMethodName}Error`;
-    // Operations without error responses have no generated Error type
-    const errorType = ctx.modelNames.includes(errorTypeName)
-        ? errorTypeName
-        : "unknown";
-    if (ctx.client === "@hey-api/client-axios") {
-        return `AxiosError<${errorType}>`;
-    }
-    return errorType;
-}
-/**
- * Resolve the generated Data type name for an operation, falling back to
- * unknown when the operation has no generated Data type.
- */
-export function getDataTypeName(op, ctx) {
-    return ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
-        ? `${op.capitalizedMethodName}Data`
-        : "unknown";
-}
+import { getDataTypeName, getErrorType } from "./operationNames.mjs";
 /**
  * SDK call arguments shared by every generated queryFn/mutationFn.
  * throwOnError: true forces the SDK call to reject on error responses; the
@@ -38,8 +16,8 @@ export function getPageParamType(op) {
 /**
  * Build the client options parameter string.
  */
-export function buildClientOptionsParam(op, ctx) {
-    const dataTypeName = getDataTypeName(op, ctx);
+export function buildClientOptionsParam(op) {
+    const dataTypeName = getDataTypeName(op);
     const hasParams = op.parameters.length > 0;
     if (!hasParams) {
         return `clientOptions: Options<${dataTypeName}, true> = {}`;
@@ -56,14 +34,25 @@ export function buildInfiniteClientOptionsParam(op) {
     const defaultValue = op.allParamsOptional ? " = {}" : "";
     return `clientOptions: Common.${op.capitalizedMethodName}InfiniteClientOptions${defaultValue}`;
 }
+/**
+ * The type of a single page. TanStack Query instantiates the infinite options
+ * with this as TQueryFnData, so it is what `getNextPageParam` receives as
+ * `lastPage` (#203). NonNullable because `throwOnError: true` means a resolved
+ * page is always present.
+ */
+export function getPageType(op) {
+    return `NonNullable<Common.${op.capitalizedMethodName}DefaultResponse>`;
+}
 /**
  * Build the paginated SDK call shared by every infinite query builder.
+ * The resolved response is narrowed to the page type so it matches the
+ * TQueryFnData the infinite options are instantiated with (#203). Spelled as
+ * a cast rather than `!` because generated code is linted downstream, and a
+ * non-null assertion trips biome's noNonNullAssertion.
  */
-export function buildPagedQueryFn(op, ctx, castTData) {
-    const dataTypeName = getDataTypeName(op, ctx);
-    const thenClause = castTData
-        ? ".then(response => response.data as TData) as TData"
-        : ".then(response => response.data)";
+export function buildPagedQueryFn(op, ctx) {
+    const dataTypeName = getDataTypeName(op);
+    const thenClause = `.then(response => response.data as ${getPageType(op)})`;
     const pageParamType = getPageParamType(op);
     // When the initial page param is omitted, the first request must send no
     // page param at all, so spread it in only once TanStack Query provides one.
@@ -116,9 +105,16 @@ export function buildGetNextPageParamExpr(ctx, op) {
  * Build an options type where the pagination fields TanStack Query marks as
  * required become optional overrides: the generator supplies them, and
  * callers may replace them for custom pagination schemes (#156, #146).
+ *
+ * The first type argument is TQueryFnData — a single page — not TData (#203).
+ * Passing TData there made `getNextPageParam` receive the aggregated
+ * `InfiniteData<...>` as `lastPage`, so any custom pagination logic failed to
+ * compile. Only the first three type arguments are written: TanStack Query
+ * dropped TQueryData from `UseInfiniteQueryOptions` within the v5 line, so
+ * positions beyond TData are not stable across the supported peer range.
  */
-export function buildOverridableInfiniteOptionsType(optionsTypeName) {
-    const instantiated = `${optionsTypeName}<TData, TError>`;
+export function buildOverridableInfiniteOptionsType(optionsTypeName, pageType) {
+    const instantiated = `${optionsTypeName}<${pageType}, TError, TData>`;
     return `Omit<${instantiated}, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"> & Partial<Pick<${instantiated}, "initialPageParam" | "getNextPageParam">>`;
 }
 /**
@@ -138,7 +134,7 @@ export function buildUseQueryHook(op, ctx) {
     const hookName = `use${op.capitalizedMethodName}`;
     const errorType = getErrorType(op, ctx);
     const dataTypeDefault = `Common.${op.capitalizedMethodName}DefaultResponse`;
-    const clientOptionsParam = buildClientOptionsParam(op, ctx);
+    const clientOptionsParam = buildClientOptionsParam(op);
     const queryFn = `({ signal }) => ${op.methodName}(${QUERY_SDK_CALL_ARGS}).then(response => response.data as TData) as TData`;
     const body = `useQuery<TData, TError>({ queryKey: Common.Use${op.capitalizedMethodName}KeyFn(clientOptions, queryKey), queryFn: ${queryFn}, ...options })`;
     return {
@@ -162,7 +158,7 @@ export function buildUseSuspenseQueryHook(op, ctx) {
     const hookName = `use${op.capitalizedMethodName}Suspense`;
     const errorType = getErrorType(op, ctx);
     const dataTypeDefault = `NonNullable<Common.${op.capitalizedMethodName}DefaultResponse>`;
-    const clientOptionsParam = buildClientOptionsParam(op, ctx);
+    const clientOptionsParam = buildClientOptionsParam(op);
     const queryFn = `({ signal }) => ${op.methodName}(${QUERY_SDK_CALL_ARGS}).then(response => response.data as TData) as TData`;
     const body = `useSuspenseQuery<TData, TError>({ queryKey: Common.Use${op.capitalizedMethodName}KeyFn(clientOptions, queryKey), queryFn: ${queryFn}, ...options })`;
     return {
@@ -201,7 +197,7 @@ function buildInfiniteHook(op, ctx, suspense) {
     const dataTypeDefault = suspense
         ? `InfiniteData<NonNullable<${baseDataType}>>`
         : `InfiniteData<${baseDataType}>`;
-    const queryFn = buildPagedQueryFn(op, ctx, true);
+    const queryFn = buildPagedQueryFn(op, ctx);
     const infiniteOptions = `initialPageParam: ${formatInitialPageParam(ctx, op)}, getNextPageParam: ${buildGetNextPageParamExpr(ctx, op)}`;
     const body = `${hookCall}({ queryKey: Common.Use${op.capitalizedMethodName}InfiniteKeyFn(clientOptions, queryKey), queryFn: ${queryFn}, ${infiniteOptions}, ...options })`;
     return {
@@ -213,7 +209,7 @@ function buildInfiniteHook(op, ctx, suspense) {
         declarations: [
             {
                 name: hookName,
-                initializer: `<TData = ${dataTypeDefault}, TError = ${errorType}, TQueryKey extends Array<unknown> = unknown[]>(${buildInfiniteClientOptionsParam(op)}, queryKey?: TQueryKey, options?: ${buildOverridableInfiniteOptionsType(optionsTypeName)}) => ${body}`,
+                initializer: `<TData = ${dataTypeDefault}, TError = ${errorType}, TQueryKey extends Array<unknown> = unknown[]>(${buildInfiniteClientOptionsParam(op)}, queryKey?: TQueryKey, options?: ${buildOverridableInfiniteOptionsType(optionsTypeName, getPageType(op))}) => ${body}`,
             },
         ],
     };
@@ -240,7 +236,7 @@ export function buildUseSuspenseInfiniteQueryHook(op, ctx) {
  *     ...options
  *   });
  */
-export function buildPrefetchFn(op, ctx) {
+export function buildPrefetchFn(op) {
     const fnName = `prefetchUse${op.capitalizedMethodName}`;
     const queryFn = `({ signal }) => ${op.methodName}(${QUERY_SDK_CALL_ARGS}).then(response => response.data)`;
     const optionsParam = `options?: Omit<FetchQueryOptions<Common.${op.capitalizedMethodName}DefaultResponse>, "queryKey" | "queryFn">`;
@@ -254,7 +250,7 @@ export function buildPrefetchFn(op, ctx) {
         declarations: [
             {
                 name: fnName,
-                initializer: `(queryClient: QueryClient, ${buildClientOptionsParam(op, ctx)}, ${optionsParam}) => ${body}`,
+                initializer: `(queryClient: QueryClient, ${buildClientOptionsParam(op)}, ${optionsParam}) => ${body}`,
             },
         ],
     };
@@ -262,10 +258,10 @@ export function buildPrefetchFn(op, ctx) {
 /**
  * Build prefetchInfiniteQuery function for a paginatable operation.
  * Example:
- * export const prefetchUseFindPaginatedPetsInfinite = (queryClient: QueryClient, clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, options?: Omit<FetchInfiniteQueryOptions<Common.FindPaginatedPetsDefaultResponse>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">) =>
+ * export const prefetchUseFindPaginatedPetsInfinite = (queryClient: QueryClient, clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, options?: Omit<FetchInfiniteQueryOptions<NonNullable<Common.FindPaginatedPetsDefaultResponse>>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"> & Partial<Pick<FetchInfiniteQueryOptions<NonNullable<Common.FindPaginatedPetsDefaultResponse>>, "initialPageParam">> & { getNextPageParam?: GetNextPageParamFunction<unknown, NonNullable<Common.FindPaginatedPetsDefaultResponse>> }) =>
  *   queryClient.prefetchInfiniteQuery({
  *     queryKey: Common.UseFindPaginatedPetsInfiniteKeyFn(clientOptions),
- *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data),
+ *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data as NonNullable<Common.FindPaginatedPetsDefaultResponse>),
  *     initialPageParam: 1,
  *     getNextPageParam: (response: unknown) => (response as { nextPage: number }).nextPage,
  *     ...options
@@ -276,9 +272,17 @@ export function buildPrefetchInfiniteQueryFn(op, ctx) {
         return null;
     }
     const fnName = `prefetchUse${op.capitalizedMethodName}Infinite`;
-    const queryFn = buildPagedQueryFn(op, ctx, false);
+    const queryFn = buildPagedQueryFn(op, ctx);
     const infiniteOptions = `initialPageParam: ${formatInitialPageParam(ctx, op)}, getNextPageParam: ${buildGetNextPageParamExpr(ctx, op)}`;
-    const optionsParam = `options?: Omit<FetchInfiniteQueryOptions<Common.${op.capitalizedMethodName}DefaultResponse>, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam">`;
+    // The pagination fields are re-added as optional overrides: `...options` is
+    // spread after the defaults, so replacing them works at runtime and must not
+    // be forbidden by the type (#203). getNextPageParam is spelled out rather
+    // than Picked, because FetchInfiniteQueryOptions only exposes it on the
+    // union member that also requires `pages`.
+    const pageType = getPageType(op);
+    const instantiated = `FetchInfiniteQueryOptions<${pageType}>`;
+    const overrides = `Partial<Pick<${instantiated}, "initialPageParam">> & { getNextPageParam?: GetNextPageParamFunction<unknown, ${pageType}> }`;
+    const optionsParam = `options?: Omit<${instantiated}, "queryKey" | "queryFn" | "initialPageParam" | "getNextPageParam"> & ${overrides}`;
     const body = `queryClient.prefetchInfiniteQuery({ queryKey: Common.Use${op.capitalizedMethodName}InfiniteKeyFn(clientOptions), queryFn: ${queryFn}, ${infiniteOptions}, ...options })`;
     return {
         kind: StructureKind.VariableStatement,
@@ -304,7 +308,7 @@ export function buildPrefetchInfiniteQueryFn(op, ctx) {
  *     ...options
  *   });
  */
-export function buildEnsureQueryDataFn(op, ctx) {
+export function buildEnsureQueryDataFn(op) {
     const fnName = `ensureUse${op.capitalizedMethodName}Data`;
     const queryFn = `({ signal }) => ${op.methodName}(${QUERY_SDK_CALL_ARGS}).then(response => response.data)`;
     const optionsParam = `options?: Omit<EnsureQueryDataOptions<Common.${op.capitalizedMethodName}DefaultResponse>, "queryKey" | "queryFn">`;
@@ -318,7 +322,7 @@ export function buildEnsureQueryDataFn(op, ctx) {
         declarations: [
             {
                 name: fnName,
-                initializer: `(queryClient: QueryClient, ${buildClientOptionsParam(op, ctx)}, ${optionsParam}) => ${body}`,
+                initializer: `(queryClient: QueryClient, ${buildClientOptionsParam(op)}, ${optionsParam}) => ${body}`,
             },
         ],
     };

package/dist/tsmorph/buildQueryOptions.d.mts

@@ -12,17 +12,18 @@ import type { GenerationContext, OperationInfo } from "../types.mjs";
  *     queryFn: () => findPets({ ...clientOptions, throwOnError: true }).then(response => response.data),
  *   });
  */
-export declare function buildQueryOptionsFn(op: OperationInfo, ctx: GenerationContext): VariableStatementStructure;
+export declare function buildQueryOptionsFn(op: OperationInfo): VariableStatementStructure;
 /**
  * Build an infiniteQueryOptions factory for a paginatable GET operation.
  * Uses the dedicated infinite query key and page-less options type.
  * Example:
- * export const findPaginatedPetsInfiniteOptions = (clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, queryKey?: Array<unknown>) =>
+ * export const findPaginatedPetsInfiniteOptions = (clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, queryKey?: Array<unknown>, options?: Partial<Pick<UseInfiniteQueryOptions<NonNullable<Common.FindPaginatedPetsDefaultResponse>>, "initialPageParam" | "getNextPageParam">>) =>
  *   infiniteQueryOptions({
  *     queryKey: Common.UseFindPaginatedPetsInfiniteKeyFn(clientOptions, queryKey),
- *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data),
+ *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data as NonNullable<Common.FindPaginatedPetsDefaultResponse>),
  *     initialPageParam: 1,
  *     getNextPageParam: (response: unknown) => (response as { nextPage: number }).nextPage,
+ *     ...options,
  *   });
  */
 export declare function buildInfiniteQueryOptionsFn(op: OperationInfo, ctx: GenerationContext): VariableStatementStructure | null;

package/dist/tsmorph/buildQueryOptions.mjs

@@ -1,5 +1,5 @@
 import { StructureKind, VariableDeclarationKind, } from "ts-morph";
-import { buildClientOptionsParam, buildGetNextPageParamExpr, buildInfiniteClientOptionsParam, buildPagedQueryFn, formatInitialPageParam, QUERY_SDK_CALL_ARGS, } from "./buildQueryHooks.mjs";
+import { buildClientOptionsParam, buildGetNextPageParamExpr, buildInfiniteClientOptionsParam, buildPagedQueryFn, formatInitialPageParam, getPageType, QUERY_SDK_CALL_ARGS, } from "./buildQueryHooks.mjs";
 /**
  * Build a queryOptions factory for a GET operation.
  * The factory centralizes queryKey and queryFn so they can be reused with
@@ -12,9 +12,9 @@ import { buildClientOptionsParam, buildGetNextPageParamExpr, buildInfiniteClient
  *     queryFn: () => findPets({ ...clientOptions, throwOnError: true }).then(response => response.data),
  *   });
  */
-export function buildQueryOptionsFn(op, ctx) {
+export function buildQueryOptionsFn(op) {
     const fnName = `${op.methodName}Options`;
-    const clientOptionsParam = buildClientOptionsParam(op, ctx);
+    const clientOptionsParam = buildClientOptionsParam(op);
     const queryFn = `({ signal }) => ${op.methodName}(${QUERY_SDK_CALL_ARGS}).then(response => response.data)`;
     const body = `queryOptions({ queryKey: Common.Use${op.capitalizedMethodName}KeyFn(clientOptions, queryKey), queryFn: ${queryFn} })`;
     return {
@@ -35,12 +35,13 @@ export function buildQueryOptionsFn(op, ctx) {
  * Build an infiniteQueryOptions factory for a paginatable GET operation.
  * Uses the dedicated infinite query key and page-less options type.
  * Example:
- * export const findPaginatedPetsInfiniteOptions = (clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, queryKey?: Array<unknown>) =>
+ * export const findPaginatedPetsInfiniteOptions = (clientOptions: Common.FindPaginatedPetsInfiniteClientOptions = {}, queryKey?: Array<unknown>, options?: Partial<Pick<UseInfiniteQueryOptions<NonNullable<Common.FindPaginatedPetsDefaultResponse>>, "initialPageParam" | "getNextPageParam">>) =>
  *   infiniteQueryOptions({
  *     queryKey: Common.UseFindPaginatedPetsInfiniteKeyFn(clientOptions, queryKey),
- *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data),
+ *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam as number }, throwOnError: true } as Options<FindPaginatedPetsData, true>).then(response => response.data as NonNullable<Common.FindPaginatedPetsDefaultResponse>),
  *     initialPageParam: 1,
  *     getNextPageParam: (response: unknown) => (response as { nextPage: number }).nextPage,
+ *     ...options,
  *   });
  */
 export function buildInfiniteQueryOptionsFn(op, ctx) {
@@ -48,9 +49,13 @@ export function buildInfiniteQueryOptionsFn(op, ctx) {
         return null;
     }
     const fnName = `${op.methodName}InfiniteOptions`;
-    const queryFn = buildPagedQueryFn(op, ctx, false);
+    const queryFn = buildPagedQueryFn(op, ctx);
     const infiniteOptions = `initialPageParam: ${formatInitialPageParam(ctx, op)}, getNextPageParam: ${buildGetNextPageParamExpr(ctx, op)}`;
-    const body = `infiniteQueryOptions({ queryKey: Common.Use${op.capitalizedMethodName}InfiniteKeyFn(clientOptions, queryKey), queryFn: ${queryFn}, ${infiniteOptions} })`;
+    // Only the pagination fields are overridable here: the factory's return type
+    // is what every downstream consumer infers from, and a wider options type
+    // (select, placeholderData, ...) would make that inference ambiguous (#203).
+    const optionsParam = `options?: Partial<Pick<UseInfiniteQueryOptions<${getPageType(op)}>, "initialPageParam" | "getNextPageParam">>`;
+    const body = `infiniteQueryOptions({ queryKey: Common.Use${op.capitalizedMethodName}InfiniteKeyFn(clientOptions, queryKey), queryFn: ${queryFn}, ${infiniteOptions}, ...options })`;
     return {
         kind: StructureKind.VariableStatement,
         // Copy the operation's JSDoc (description and @deprecated) from the SDK function
@@ -60,7 +65,7 @@ export function buildInfiniteQueryOptionsFn(op, ctx) {
         declarations: [
             {
                 name: fnName,
-                initializer: `(${buildInfiniteClientOptionsParam(op)}, queryKey?: Array<unknown>) => ${body}`,
+                initializer: `(${buildInfiniteClientOptionsParam(op)}, queryKey?: Array<unknown>, ${optionsParam}) => ${body}`,
             },
         ],
     };

package/dist/tsmorph/generateFiles.mjs

@@ -3,30 +3,20 @@ import { buildDefaultResponseType, buildInfiniteClientOptionsType, buildInfinite
 import { buildUseMutationHook } from "./buildMutationHooks.mjs";
 import { buildEnsureQueryDataFn, buildPrefetchFn, buildPrefetchInfiniteQueryFn, buildUseInfiniteQueryHook, buildUseQueryHook, buildUseSuspenseInfiniteQueryHook, buildUseSuspenseQueryHook, } from "./buildQueryHooks.mjs";
 import { buildInfiniteQueryOptionsFn, buildQueryOptionsFn, } from "./buildQueryOptions.mjs";
-import { buildAxiosErrorImport, buildClientImport, buildCommonImport, buildModelImport, buildQueryImport, buildQueryOptionsImport, buildServiceImport, createGenerationProject, } from "./projectFactory.mjs";
+import { buildCommonFileImports, buildHookFileImports, buildQueryOptionsFileImports, createGenerationProject, } from "./projectFactory.mjs";
 /**
- * Build imports for common.ts file.
+ * Add one variable statement per operation, skipping the ones the builder
+ * declines. A builder returns null when the operation is out of its scope —
+ * every infinite-query builder returns null for non-paginatable operations,
+ * which is how the paginatable subset gets selected.
  */
-function buildCommonFileImports(ctx) {
-    const imports = [
-        buildClientImport(ctx),
-        buildQueryImport(),
-        buildServiceImport(ctx),
-    ];
-    const modelImport = buildModelImport(ctx);
-    if (modelImport) {
-        imports.push(modelImport);
-    }
-    if (ctx.client === "@hey-api/client-axios") {
-        imports.push(buildAxiosErrorImport());
+function addStatements(sourceFile, operations, build) {
+    for (const op of operations) {
+        const statement = build(op);
+        if (statement) {
+            sourceFile.addVariableStatement(statement);
+        }
     }
-    return imports;
-}
-/**
- * Build imports for hook files (queries, suspense, infinite, prefetch, ensure).
- */
-function buildHookFileImports(ctx) {
-    return [buildCommonImport(), ...buildCommonFileImports(ctx)];
 }
 /**
  * Generate the index.ts file content.
@@ -51,7 +41,7 @@ function generateCommonFile(operations, ctx) {
         sourceFile.addTypeAlias(buildDefaultResponseType(op));
         sourceFile.addTypeAlias(buildQueryResultType(op));
         sourceFile.addVariableStatement(buildQueryKeyConst(op));
-        sourceFile.addVariableStatement(buildQueryKeyFn(op, ctx));
+        sourceFile.addVariableStatement(buildQueryKeyFn(op));
     }
     // Add dedicated infinite query types and keys for paginatable operations
     for (const op of getOperations.filter((o) => o.isPaginatable)) {
@@ -95,28 +85,14 @@ function generateQueryOptionsFile(operations, ctx) {
     const project = createGenerationProject();
     const sourceFile = project.createSourceFile(`${OpenApiRqFiles.queryOptions}.ts`, undefined, { overwrite: true });
     // Add imports
-    const imports = [
-        buildCommonImport(),
-        buildQueryOptionsImport(),
-        buildClientImport(ctx),
-        buildServiceImport(ctx),
-    ];
-    const modelImport = buildModelImport(ctx);
-    if (modelImport) {
-        imports.push(modelImport);
-    }
-    sourceFile.addImportDeclarations(imports);
+    sourceFile.addImportDeclarations(buildQueryOptionsFileImports(ctx));
     // Only GET operations have query options
     const getOperations = operations.filter((op) => op.httpMethod === "GET");
     for (const op of getOperations) {
-        sourceFile.addVariableStatement(buildQueryOptionsFn(op, ctx));
-    }
-    for (const op of getOperations) {
-        const infiniteOptions = buildInfiniteQueryOptionsFn(op, ctx);
-        if (infiniteOptions) {
-            sourceFile.addVariableStatement(infiniteOptions);
-        }
+        sourceFile.addVariableStatement(buildQueryOptionsFn(op));
     }
+    // Add infiniteQueryOptions factories
+    addStatements(sourceFile, getOperations, (op) => buildInfiniteQueryOptionsFn(op, ctx));
     return sourceFile.getFullText();
 }
 /**
@@ -133,13 +109,8 @@ function generateSuspenseFile(operations, ctx) {
     for (const op of getOperations) {
         sourceFile.addVariableStatement(buildUseSuspenseQueryHook(op, ctx));
     }
-    // Add useSuspenseInfiniteQuery hooks for paginatable operations
-    for (const op of getOperations.filter((o) => o.isPaginatable)) {
-        const hook = buildUseSuspenseInfiniteQueryHook(op, ctx);
-        if (hook) {
-            sourceFile.addVariableStatement(hook);
-        }
-    }
+    // Add useSuspenseInfiniteQuery hooks
+    addStatements(sourceFile, getOperations, (op) => buildUseSuspenseInfiniteQueryHook(op, ctx));
     return sourceFile.getFullText();
 }
 /**
@@ -150,15 +121,10 @@ function generateInfiniteQueriesFile(operations, ctx) {
     const sourceFile = project.createSourceFile(`${OpenApiRqFiles.infiniteQueries}.ts`, undefined, { overwrite: true });
     // Add imports
     sourceFile.addImportDeclarations(buildHookFileImports(ctx));
-    // Only paginatable GET operations
-    const paginatableOperations = operations.filter((op) => op.httpMethod === "GET" && op.isPaginatable);
+    // Only GET operations can be paginatable
+    const getOperations = operations.filter((op) => op.httpMethod === "GET");
     // Add useInfiniteQuery hooks
-    for (const op of paginatableOperations) {
-        const hook = buildUseInfiniteQueryHook(op, ctx);
-        if (hook) {
-            sourceFile.addVariableStatement(hook);
-        }
-    }
+    addStatements(sourceFile, getOperations, (op) => buildUseInfiniteQueryHook(op, ctx));
     return sourceFile.getFullText();
 }
 /**
@@ -173,15 +139,10 @@ function generatePrefetchFile(operations, ctx) {
     const getOperations = operations.filter((op) => op.httpMethod === "GET");
     // Add prefetch functions
     for (const op of getOperations) {
-        sourceFile.addVariableStatement(buildPrefetchFn(op, ctx));
-    }
-    // Add prefetchInfiniteQuery functions for paginatable operations
-    for (const op of getOperations.filter((o) => o.isPaginatable)) {
-        const fn = buildPrefetchInfiniteQueryFn(op, ctx);
-        if (fn) {
-            sourceFile.addVariableStatement(fn);
-        }
+        sourceFile.addVariableStatement(buildPrefetchFn(op));
     }
+    // Add prefetchInfiniteQuery functions
+    addStatements(sourceFile, getOperations, (op) => buildPrefetchInfiniteQueryFn(op, ctx));
     return sourceFile.getFullText();
 }
 /**
@@ -196,7 +157,7 @@ function generateEnsureQueryDataFile(operations, ctx) {
     const getOperations = operations.filter((op) => op.httpMethod === "GET");
     // Add ensureQueryData functions
     for (const op of getOperations) {
-        sourceFile.addVariableStatement(buildEnsureQueryDataFn(op, ctx));
+        sourceFile.addVariableStatement(buildEnsureQueryDataFn(op));
     }
     return sourceFile.getFullText();
 }

package/dist/tsmorph/operationNames.d.mts

@@ -0,0 +1,16 @@
+import type { GenerationContext, OperationInfo } from "../types.mjs";
+/**
+ * Resolve the generated Data type name for an operation, falling back to
+ * unknown when the SDK signature exposes no Data type.
+ * See OperationInfo.dataTypeName for why the name is read from the signature
+ * instead of derived from the method name (#213).
+ */
+export declare function getDataTypeName(op: OperationInfo): string;
+/**
+ * Get the error type string based on client type.
+ * The Error type shares its stem with the Data type — hey-api mints both from
+ * the operationId (see OperationInfo.dataTypeName, #213) — so the stem comes
+ * from `dataTypeName` rather than the method name. The modelNames probe stays
+ * because operations without error responses have no generated Error type.
+ */
+export declare function getErrorType(op: OperationInfo, ctx: GenerationContext): string;

package/dist/tsmorph/operationNames.mjs

@@ -0,0 +1,29 @@
+/**
+ * Resolve the generated Data type name for an operation, falling back to
+ * unknown when the SDK signature exposes no Data type.
+ * See OperationInfo.dataTypeName for why the name is read from the signature
+ * instead of derived from the method name (#213).
+ */
+export function getDataTypeName(op) {
+    return op.dataTypeName ?? "unknown";
+}
+/**
+ * Get the error type string based on client type.
+ * The Error type shares its stem with the Data type — hey-api mints both from
+ * the operationId (see OperationInfo.dataTypeName, #213) — so the stem comes
+ * from `dataTypeName` rather than the method name. The modelNames probe stays
+ * because operations without error responses have no generated Error type.
+ */
+export function getErrorType(op, ctx) {
+    const stem = op.dataTypeName
+        ? op.dataTypeName.replace(/Data$/, "")
+        : op.capitalizedMethodName;
+    const errorTypeName = `${stem}Error`;
+    const errorType = ctx.modelNames.includes(errorTypeName)
+        ? errorTypeName
+        : "unknown";
+    if (ctx.client === "@hey-api/client-axios") {
+        return `AxiosError<${errorType}>`;
+    }
+    return errorType;
+}

package/dist/tsmorph/projectFactory.d.mts

@@ -45,3 +45,9 @@ export declare function buildCommonFileImports(ctx: GenerationContext): ImportDe
  * Build all imports needed for hook files (queries, suspense, infinite).
  */
 export declare function buildHookFileImports(ctx: GenerationContext): ImportDeclarationStructure[];
+/**
+ * Build all imports needed for the queryOptions file.
+ * Narrower than the hook file imports: queryOptions only needs the
+ * queryOptions/infiniteQueryOptions helpers, not the TanStack hooks.
+ */
+export declare function buildQueryOptionsFileImports(ctx: GenerationContext): ImportDeclarationStructure[];

package/dist/tsmorph/projectFactory.mjs

@@ -53,6 +53,7 @@ export function buildQueryImport() {
             { name: "InfiniteData", isTypeOnly: true },
             { name: "FetchQueryOptions", isTypeOnly: true },
             { name: "FetchInfiniteQueryOptions", isTypeOnly: true },
+            { name: "GetNextPageParamFunction", isTypeOnly: true },
             { name: "EnsureQueryDataOptions", isTypeOnly: true },
         ],
     };
@@ -64,7 +65,11 @@ export function buildQueryOptionsImport() {
     return {
         kind: StructureKind.ImportDeclaration,
         moduleSpecifier: "@tanstack/react-query",
-        namedImports: [{ name: "queryOptions" }, { name: "infiniteQueryOptions" }],
+        namedImports: [
+            { name: "queryOptions" },
+            { name: "infiniteQueryOptions" },
+            { name: "UseInfiniteQueryOptions", isTypeOnly: true },
+        ],
     };
 }
 /**
@@ -137,3 +142,21 @@ export function buildCommonFileImports(ctx) {
 export function buildHookFileImports(ctx) {
     return [buildCommonImport(), ...buildCommonFileImports(ctx)];
 }
+/**
+ * Build all imports needed for the queryOptions file.
+ * Narrower than the hook file imports: queryOptions only needs the
+ * queryOptions/infiniteQueryOptions helpers, not the TanStack hooks.
+ */
+export function buildQueryOptionsFileImports(ctx) {
+    const imports = [
+        buildCommonImport(),
+        buildQueryOptionsImport(),
+        buildClientImport(ctx),
+        buildServiceImport(ctx),
+    ];
+    const modelImport = buildModelImport(ctx);
+    if (modelImport) {
+        imports.push(modelImport);
+    }
+    return imports;
+}

package/dist/types.d.mts

@@ -7,6 +7,20 @@ export interface OperationInfo {
     methodName: string;
     /** Capitalized method name (e.g., "FindPets") */
     capitalizedMethodName: string;
+    /**
+     * Generated Data type name read from the SDK function's own
+     * `Options<XData, ThrowOnError>` signature (e.g., "FindPetsData").
+     * Not derivable from the method name: for digit-leading operationIds
+     * hey-api prefixes the function but strips the digits from the type (#213).
+     * Undefined when the SDK signature exposes no Data type.
+     *
+     * The rule this encodes: names hey-api owns (Data, Error) must be read from
+     * the SDK signature or share this field's stem; names this codegen mints
+     * itself (DefaultResponse, MutationResult, key fns) may be derived from
+     * capitalizedMethodName because they anchor back to the SDK via
+     * `typeof methodName`.
+     */
+    dataTypeName?: string;
     /** HTTP method (e.g., "GET", "POST", "PUT", "PATCH", "DELETE") */
     httpMethod: string;
     /** JSDoc comment string (if present) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "3.0.1",
+  "version": "3.0.2",
   "description": "OpenAPI React Query Codegen",
   "bin": {
     "openapi-rq": "dist/cli.mjs"

package/dist/tsmorph/buildKeys.d.mts

@@ -1,42 +0,0 @@
-import { type VariableStatementStructure } from "ts-morph";
-import type { GenerationContext, OperationInfo } from "../types.mjs";
-/**
- * Build query key constant name (e.g., "findPetsQueryKey").
- */
-export declare function getQueryKeyName(op: OperationInfo): string;
-/**
- * Build mutation key constant name (e.g., "addPetMutationKey").
- */
-export declare function getMutationKeyName(op: OperationInfo): string;
-/**
- * Build query key fn name (e.g., "FindPetsQueryKeyFn").
- */
-export declare function getQueryKeyFnName(op: OperationInfo): string;
-/**
- * Build mutation key fn name (e.g., "AddPetMutationKeyFn").
- */
-export declare function getMutationKeyFnName(op: OperationInfo): string;
-/**
- * Build the query key constant export.
- * Example: export const findPetsQueryKey = "FindPets";
- */
-export declare function buildQueryKeyExport(op: OperationInfo): VariableStatementStructure;
-/**
- * Build the mutation key constant export.
- * Example: export const addPetMutationKey = "AddPet";
- */
-export declare function buildMutationKeyExport(op: OperationInfo): VariableStatementStructure;
-/**
- * Build the query key function export.
- * Example:
- * export const FindPetsQueryKeyFn = (clientOptions: Options<FindPetsData, true>, queryKey?: Array<unknown>) =>
- *   [findPetsQueryKey, ...(queryKey ?? [clientOptions])] as const;
- */
-export declare function buildQueryKeyFnExport(op: OperationInfo, ctx: GenerationContext): VariableStatementStructure;
-/**
- * Build the mutation key function export.
- * Example:
- * export const AddPetMutationKeyFn = (mutationKey?: Array<unknown>) =>
- *   [addPetMutationKey, ...(mutationKey ?? [])] as const;
- */
-export declare function buildMutationKeyFnExport(op: OperationInfo): VariableStatementStructure;

package/dist/tsmorph/buildKeys.mjs

@@ -1,110 +0,0 @@
-import { StructureKind, VariableDeclarationKind, } from "ts-morph";
-/**
- * Build query key constant name (e.g., "findPetsQueryKey").
- */
-export function getQueryKeyName(op) {
-    return `${op.methodName}QueryKey`;
-}
-/**
- * Build mutation key constant name (e.g., "addPetMutationKey").
- */
-export function getMutationKeyName(op) {
-    return `${op.methodName}MutationKey`;
-}
-/**
- * Build query key fn name (e.g., "FindPetsQueryKeyFn").
- */
-export function getQueryKeyFnName(op) {
-    return `${op.capitalizedMethodName}QueryKeyFn`;
-}
-/**
- * Build mutation key fn name (e.g., "AddPetMutationKeyFn").
- */
-export function getMutationKeyFnName(op) {
-    return `${op.capitalizedMethodName}MutationKeyFn`;
-}
-/**
- * Build the query key constant export.
- * Example: export const findPetsQueryKey = "FindPets";
- */
-export function buildQueryKeyExport(op) {
-    return {
-        kind: StructureKind.VariableStatement,
-        isExported: true,
-        declarationKind: VariableDeclarationKind.Const,
-        declarations: [
-            {
-                name: getQueryKeyName(op),
-                initializer: `"${op.capitalizedMethodName}"`,
-            },
-        ],
-    };
-}
-/**
- * Build the mutation key constant export.
- * Example: export const addPetMutationKey = "AddPet";
- */
-export function buildMutationKeyExport(op) {
-    return {
-        kind: StructureKind.VariableStatement,
-        isExported: true,
-        declarationKind: VariableDeclarationKind.Const,
-        declarations: [
-            {
-                name: getMutationKeyName(op),
-                initializer: `"${op.capitalizedMethodName}"`,
-            },
-        ],
-    };
-}
-/**
- * Build the query key function export.
- * Example:
- * export const FindPetsQueryKeyFn = (clientOptions: Options<FindPetsData, true>, queryKey?: Array<unknown>) =>
- *   [findPetsQueryKey, ...(queryKey ?? [clientOptions])] as const;
- */
-export function buildQueryKeyFnExport(op, ctx) {
-    const hasParams = op.parameters.length > 0;
-    const dataTypeName = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
-        ? `${op.capitalizedMethodName}Data`
-        : "unknown";
-    const params = [];
-    if (hasParams) {
-        const defaultValue = op.allParamsOptional ? " = {}" : "";
-        params.push(`clientOptions: Options<${dataTypeName}, true>${defaultValue}`);
-    }
-    params.push("queryKey?: Array<unknown>");
-    const fallbackArray = hasParams ? "[clientOptions]" : "[]";
-    const body = `[${getQueryKeyName(op)}, ...(queryKey ?? ${fallbackArray})] as const`;
-    return {
-        kind: StructureKind.VariableStatement,
-        isExported: true,
-        declarationKind: VariableDeclarationKind.Const,
-        declarations: [
-            {
-                name: getQueryKeyFnName(op),
-                initializer: `(${params.join(", ")}) => ${body}`,
-            },
-        ],
-    };
-}
-/**
- * Build the mutation key function export.
- * Example:
- * export const AddPetMutationKeyFn = (mutationKey?: Array<unknown>) =>
- *   [addPetMutationKey, ...(mutationKey ?? [])] as const;
- */
-export function buildMutationKeyFnExport(op) {
-    const body = `[${getMutationKeyName(op)}, ...(mutationKey ?? [])] as const`;
-    return {
-        kind: StructureKind.VariableStatement,
-        isExported: true,
-        declarationKind: VariableDeclarationKind.Const,
-        declarations: [
-            {
-                name: getMutationKeyFnName(op),
-                initializer: `(mutationKey?: Array<unknown>) => ${body}`,
-            },
-        ],
-    };
-}