@7nohe/openapi-react-query-codegen 2.2.0 → 3.0.0-beta.2

package/dist/common.mjs

@@ -1,17 +1,8 @@
 import { stat } from "node:fs/promises";
 import path from "node:path";
-import { ArrowFunction } from "ts-morph";
+import { ArrowFunction, } from "ts-morph";
 import ts from "typescript";
 import { queriesOutputPath, requestsOutputPath } from "./constants.mjs";
-export const TData = ts.factory.createIdentifier("TData");
-export const TError = ts.factory.createIdentifier("TError");
-export const TContext = ts.factory.createIdentifier("TContext");
-export const EqualsOrGreaterThanToken = ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken);
-export const QuestionToken = ts.factory.createToken(ts.SyntaxKind.QuestionToken);
-export const queryKeyGenericType = ts.factory.createTypeReferenceNode("TQueryKey");
-export const queryKeyConstraint = ts.factory.createTypeReferenceNode("Array", [
-    ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
-]);
 export const capitalizeFirstLetter = (str) => {
     return str.charAt(0).toUpperCase() + str.slice(1);
 };
@@ -149,67 +140,3 @@ export function buildRequestsOutputPath(outputPath) {
 export function buildQueriesOutputPath(outputPath) {
     return path.join(outputPath, queriesOutputPath);
 }
-export function getQueryKeyFnName(queryKey) {
-    return `${capitalizeFirstLetter(queryKey)}Fn`;
-}
-/**
- * Create QueryKey/MutationKey exports
- */
-export function createQueryKeyExport({ methodName, queryKey, }) {
-    return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(queryKey), undefined, undefined, ts.factory.createStringLiteral(`${capitalizeFirstLetter(methodName)}`)),
-    ], ts.NodeFlags.Const));
-}
-export function createQueryKeyFnExport(queryKey, method, type = "query", modelNames = []) {
-    // Mutation keys don't require clientOptions
-    const params = type === "query"
-        ? getRequestParamFromMethod(method, undefined, modelNames)
-        : null;
-    // override key is used to allow the user to override the the queryKey values
-    const overrideKey = ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier(type === "query" ? "queryKey" : "mutationKey"), QuestionToken, ts.factory.createTypeReferenceNode("Array<unknown>", []));
-    return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
-        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(getQueryKeyFnName(queryKey)), undefined, undefined, ts.factory.createArrowFunction(undefined, undefined, params ? [params, overrideKey] : [overrideKey], undefined, EqualsOrGreaterThanToken, type === "query"
-            ? queryKeyFn(queryKey, method)
-            : mutationKeyFn(queryKey))),
-    ], ts.NodeFlags.Const));
-}
-function queryKeyFn(queryKey, method) {
-    return ts.factory.createArrayLiteralExpression([
-        ts.factory.createIdentifier(queryKey),
-        ts.factory.createSpreadElement(ts.factory.createParenthesizedExpression(ts.factory.createBinaryExpression(ts.factory.createIdentifier("queryKey"), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), getVariableArrowFunctionParameters(method)
-            ? // [...clientOptions]
-                ts.factory.createArrayLiteralExpression([
-                    ts.factory.createIdentifier("clientOptions"),
-                ])
-            : // []
-                ts.factory.createArrayLiteralExpression()))),
-    ], false);
-}
-function mutationKeyFn(mutationKey) {
-    return ts.factory.createArrayLiteralExpression([
-        ts.factory.createIdentifier(mutationKey),
-        ts.factory.createSpreadElement(ts.factory.createParenthesizedExpression(ts.factory.createBinaryExpression(ts.factory.createIdentifier("mutationKey"), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), ts.factory.createArrayLiteralExpression()))),
-    ], false);
-}
-export function getRequestParamFromMethod(method, pageParam, modelNames = []) {
-    const sdkParams = getVariableArrowFunctionParameters(method);
-    if (!sdkParams.length) {
-        return null;
-    }
-    const methodName = getNameFromVariable(method);
-    // Use the SDK function's parameter optionality as the authoritative check.
-    // Generic types like Options<XData, ThrowOnError> may not resolve correctly
-    // via extractPropertiesFromObjectParam for type alias properties (path, url).
-    const areAllPropertiesOptional = sdkParams[0].isOptional();
-    return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("clientOptions"), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Options"), [
-        ts.factory.createTypeReferenceNode(modelNames.includes(`${capitalizeFirstLetter(methodName)}Data`)
-            ? `${capitalizeFirstLetter(methodName)}Data`
-            : "unknown"),
-        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("true")),
-    ]), 
-    // if all params are optional, we create an empty object literal
-    // so the hook can be called without any parameters
-    areAllPropertiesOptional
-        ? ts.factory.createObjectLiteralExpression()
-        : undefined);
-}

package/dist/constants.mjs

@@ -5,6 +5,7 @@ export const serviceFileName = "sdk.gen";
 export const modelsFileName = "types.gen";
 export const OpenApiRqFiles = {
     queries: "queries",
+    queryOptions: "queryOptions",
     infiniteQueries: "infiniteQueries",
     common: "common",
     suspense: "suspense",

package/dist/createSource.mjs

@@ -1,115 +1,21 @@
 import { join } from "node:path";
 import { Project } from "ts-morph";
-import ts from "typescript";
-import { OpenApiRqFiles } from "./constants.mjs";
-import { createExports } from "./createExports.mjs";
-import { createImports } from "./createImports.mjs";
-import { getServices } from "./service.mjs";
-const createSourceFile = async ({ outputPath, client, pageParam, nextPageParam, initialPageParam, }) => {
+import { buildGenerationContext, parseOperations } from "./parseOperations.mjs";
+import { generateAllFiles } from "./tsmorph/index.mjs";
+/**
+ * Create source files using ts-morph based generation.
+ */
+export const createSource = async ({ outputPath, client, version, pageParam, nextPageParam, initialPageParam, }) => {
+    // Initialize ts-morph project to read the generated OpenAPI client
     const project = new Project({
-        // Optionally specify compiler options, tsconfig.json, in-memory file system, and more here.
-        // If you initialize with a tsconfig.json, then it will automatically populate the project
-        // with the associated source files.
-        // Read more: https://ts-morph.com/setup/
         skipAddingFilesFromTsConfig: true,
     });
     const sourceFiles = join(process.cwd(), outputPath);
     project.addSourceFilesAtPaths(`${sourceFiles}/**/*`);
-    const service = await getServices(project);
-    const imports = createImports({
-        project,
-        client,
-    });
-    const exports = createExports({
-        service,
-        client,
-        project,
-        pageParam,
-        nextPageParam,
-        initialPageParam,
-    });
-    const commonSource = ts.factory.createSourceFile([...imports, ...exports.allCommon], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    const commonImport = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, ts.factory.createIdentifier("* as Common"), undefined), ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
-    const commonExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
-    const queriesExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral(`./${OpenApiRqFiles.queries}`), undefined);
-    const mainSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.mainExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    const infiniteQueriesSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.infiniteQueriesExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    const suspenseSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.suspenseExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    const indexSource = ts.factory.createSourceFile([commonExport, queriesExport], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    const prefetchSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.allPrefetchExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    const ensureSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.allEnsures], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
-    return {
-        commonSource,
-        infiniteQueriesSource,
-        mainSource,
-        suspenseSource,
-        indexSource,
-        prefetchSource,
-        ensureSource,
-    };
-};
-export const createSource = async ({ outputPath, client, version, pageParam, nextPageParam, initialPageParam, }) => {
-    const queriesFile = ts.createSourceFile(`${OpenApiRqFiles.queries}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const infiniteQueriesFile = ts.createSourceFile(`${OpenApiRqFiles.infiniteQueries}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const commonFile = ts.createSourceFile(`${OpenApiRqFiles.common}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const suspenseFile = ts.createSourceFile(`${OpenApiRqFiles.suspense}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const indexFile = ts.createSourceFile(`${OpenApiRqFiles.index}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const prefetchFile = ts.createSourceFile(`${OpenApiRqFiles.prefetch}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const ensureQueryDataFile = ts.createSourceFile(`${OpenApiRqFiles.ensureQueryData}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const printer = ts.createPrinter({
-        newLine: ts.NewLineKind.LineFeed,
-        removeComments: false,
-    });
-    const { commonSource, mainSource, infiniteQueriesSource, suspenseSource, indexSource, prefetchSource, ensureSource, } = await createSourceFile({
-        outputPath,
-        client,
-        pageParam,
-        nextPageParam,
-        initialPageParam,
-    });
-    const comment = `// generated with @7nohe/openapi-react-query-codegen@${version} \n\n`;
-    const commonResult = comment +
-        printer.printNode(ts.EmitHint.Unspecified, commonSource, commonFile);
-    const mainResult = comment +
-        printer.printNode(ts.EmitHint.Unspecified, mainSource, queriesFile);
-    const infiniteQueriesResult = comment +
-        printer.printNode(ts.EmitHint.Unspecified, infiniteQueriesSource, infiniteQueriesFile);
-    const suspenseResult = comment +
-        printer.printNode(ts.EmitHint.Unspecified, suspenseSource, suspenseFile);
-    const indexResult = comment +
-        printer.printNode(ts.EmitHint.Unspecified, indexSource, indexFile);
-    const prefetchResult = comment +
-        printer.printNode(ts.EmitHint.Unspecified, prefetchSource, prefetchFile);
-    const enqureResult = comment +
-        printer.printNode(ts.EmitHint.Unspecified, ensureSource, ensureQueryDataFile);
-    return [
-        {
-            name: `${OpenApiRqFiles.index}.ts`,
-            content: indexResult,
-        },
-        {
-            name: `${OpenApiRqFiles.common}.ts`,
-            content: commonResult,
-        },
-        {
-            name: `${OpenApiRqFiles.infiniteQueries}.ts`,
-            content: infiniteQueriesResult,
-        },
-        {
-            name: `${OpenApiRqFiles.queries}.ts`,
-            content: mainResult,
-        },
-        {
-            name: `${OpenApiRqFiles.suspense}.ts`,
-            content: suspenseResult,
-        },
-        {
-            name: `${OpenApiRqFiles.prefetch}.ts`,
-            content: prefetchResult,
-        },
-        {
-            name: `${OpenApiRqFiles.ensureQueryData}.ts`,
-            content: enqureResult,
-        },
-    ];
+    // Parse operations from the service file
+    const operations = await parseOperations(project, pageParam);
+    // Build generation context
+    const ctx = buildGenerationContext(project, client, pageParam, nextPageParam, initialPageParam, version);
+    // Generate all files using ts-morph
+    return generateAllFiles(operations, ctx);
 };

package/dist/generate.mjs

@@ -54,7 +54,7 @@ export async function generate(options, version) {
     await writeFile(path.join(openApiOutputPath, "services.gen.ts"), shimContent);
     const source = await createSource({
         outputPath: openApiOutputPath,
-        client: formattedOptions.client,
+        client: clientPlugin,
         version,
         pageParam: formattedOptions.pageParam,
         nextPageParam: formattedOptions.nextPageParam,

package/dist/parseOperations.mjs

@@ -0,0 +1,122 @@
+import ts from "typescript";
+import { capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromVariable, getShortType, getVariableArrowFunctionParameters, } from "./common.mjs";
+import { modelsFileName, serviceFileName } from "./constants.mjs";
+import { getServices } from "./service.mjs";
+/**
+ * Extract parameter information from a method's variable declaration.
+ */
+function extractParameters(method, pageParam) {
+    const arrowParams = getVariableArrowFunctionParameters(method);
+    if (!arrowParams.length) {
+        return [];
+    }
+    return arrowParams.flatMap((param) => {
+        const paramNodes = extractPropertiesFromObjectParam(param);
+        return paramNodes
+            .filter((p) => p.name !== pageParam)
+            .map((refParam) => ({
+            name: refParam.name,
+            typeName: getShortType(refParam.type?.getText() ?? ""),
+            optional: refParam.optional,
+        }));
+    });
+}
+/**
+ * Get paginatable methods by checking if their Data type has the pageParam in query property.
+ * Uses TypeScript compiler API for accurate AST traversal.
+ */
+function getPaginatableMethods(project, pageParam) {
+    const modelsFile = project
+        .getSourceFiles()
+        .find((sf) => sf.getFilePath().includes(modelsFileName));
+    if (!modelsFile)
+        return [];
+    const paginatableMethods = [];
+    const modelDeclarations = modelsFile.getExportedDeclarations();
+    const entries = modelDeclarations.entries();
+    for (const [key, value] of entries) {
+        // Check if this is a *Data type (e.g., FindPetsData)
+        if (!key.endsWith("Data"))
+            continue;
+        const node = value[0].compilerNode;
+        if (!ts.isTypeAliasDeclaration(node))
+            continue;
+        const typeAliasDeclaration = node.type;
+        if (typeAliasDeclaration.kind !== ts.SyntaxKind.TypeLiteral)
+            continue;
+        // Look for 'query' property in the type literal
+        const query = typeAliasDeclaration.members.find((m) => m.kind === ts.SyntaxKind.PropertySignature &&
+            m.name?.getText() === "query");
+        if (!query)
+            continue;
+        // Check if query type has the pageParam
+        const queryType = query.type;
+        if (!queryType || queryType.kind !== ts.SyntaxKind.TypeLiteral)
+            continue;
+        const hasPageParam = queryType.members.some((m) => m.name?.getText() === pageParam);
+        if (hasPageParam) {
+            // 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);
+            paginatableMethods.push(methodNameLower);
+        }
+    }
+    return paginatableMethods;
+}
+/**
+ * Parse operations from the OpenAPI-generated service file and return normalized DTOs.
+ */
+export async function parseOperations(project, pageParam) {
+    const service = await getServices(project);
+    const { methods } = service;
+    const paginatableMethods = getPaginatableMethods(project, pageParam);
+    return methods.map((desc) => {
+        const methodName = getNameFromVariable(desc.method);
+        const httpMethod = desc.httpMethodName.toUpperCase();
+        const parameters = extractParameters(desc.method);
+        // Use the SDK function's parameter optionality as the authoritative check.
+        // Generic types like Options<XData, ThrowOnError> may not resolve correctly
+        // via extractPropertiesFromObjectParam for type alias properties (path, url).
+        const sdkParams = getVariableArrowFunctionParameters(desc.method);
+        const allParamsOptional = sdkParams.length === 0 || sdkParams[0].isOptional();
+        const isPaginatable = httpMethod === "GET" && paginatableMethods.includes(methodName);
+        return {
+            methodName,
+            capitalizedMethodName: capitalizeFirstLetter(methodName),
+            httpMethod,
+            jsDoc: desc.jsDoc,
+            isDeprecated: desc.isDeprecated,
+            parameters,
+            allParamsOptional,
+            isPaginatable,
+        };
+    });
+}
+/**
+ * Build generation context from project configuration.
+ */
+export function buildGenerationContext(project, client, pageParam, nextPageParam, initialPageParam, version) {
+    const modelsFile = project
+        .getSourceFiles()
+        .find((sf) => sf.getFilePath().includes(modelsFileName));
+    const serviceFile = project
+        .getSourceFiles()
+        .find((sf) => sf.getFilePath().includes(serviceFileName));
+    if (!serviceFile) {
+        throw new Error("No service node found");
+    }
+    const modelNames = modelsFile
+        ? Array.from(modelsFile.getExportedDeclarations().keys())
+        : [];
+    const serviceNames = Array.from(serviceFile.getExportedDeclarations().keys());
+    return {
+        client,
+        modelNames,
+        serviceNames,
+        pageParam,
+        nextPageParam,
+        initialPageParam,
+        version,
+    };
+}

package/dist/tsmorph/buildCommon.mjs

@@ -0,0 +1,183 @@
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+/**
+ * Build the default response type alias.
+ * Example: export type FindPetsDefaultResponse = Awaited<ReturnType<typeof findPets>>["data"];
+ */
+export function buildDefaultResponseType(op) {
+    return {
+        kind: StructureKind.TypeAlias,
+        isExported: true,
+        name: `${op.capitalizedMethodName}DefaultResponse`,
+        type: `Awaited<ReturnType<typeof ${op.methodName}>>["data"]`,
+    };
+}
+/**
+ * Build the query result type alias.
+ * Example: export type FindPetsQueryResult<TData = FindPetsDefaultResponse, TError = unknown> = UseQueryResult<TData, TError>;
+ */
+export function buildQueryResultType(op) {
+    return {
+        kind: StructureKind.TypeAlias,
+        isExported: true,
+        name: `${op.capitalizedMethodName}QueryResult`,
+        typeParameters: [
+            { name: "TData", default: `${op.capitalizedMethodName}DefaultResponse` },
+            { name: "TError", default: "unknown" },
+        ],
+        type: "UseQueryResult<TData, TError>",
+    };
+}
+/**
+ * Build the mutation result type alias.
+ * Example: export type AddPetMutationResult = Awaited<ReturnType<typeof addPet>>;
+ */
+export function buildMutationResultType(op) {
+    return {
+        kind: StructureKind.TypeAlias,
+        isExported: true,
+        name: `${op.capitalizedMethodName}MutationResult`,
+        type: `Awaited<ReturnType<typeof ${op.methodName}>>`,
+    };
+}
+/**
+ * Build query key constant.
+ * Example: export const useFindPetsKey = "FindPets";
+ */
+export function buildQueryKeyConst(op) {
+    return {
+        kind: StructureKind.VariableStatement,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: `use${op.capitalizedMethodName}Key`,
+                initializer: `"${op.capitalizedMethodName}"`,
+            },
+        ],
+    };
+}
+/**
+ * Build mutation key constant.
+ * Example: export const useAddPetKey = "AddPet";
+ */
+export function buildMutationKeyConst(op) {
+    return {
+        kind: StructureKind.VariableStatement,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: `use${op.capitalizedMethodName}Key`,
+                initializer: `"${op.capitalizedMethodName}"`,
+            },
+        ],
+    };
+}
+/**
+ * Build query key function.
+ * 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";
+    const params = [];
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    params.push(`clientOptions: Options<${dataTypeName}, true>${defaultValue}`);
+    params.push("queryKey?: Array<unknown>");
+    const fallbackArray = "[clientOptions]";
+    return {
+        kind: StructureKind.VariableStatement,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: `Use${op.capitalizedMethodName}KeyFn`,
+                initializer: `(${params.join(", ")}) => [use${op.capitalizedMethodName}Key, ...(queryKey ?? ${fallbackArray})]`,
+            },
+        ],
+    };
+}
+/**
+ * Build mutation key function.
+ * Example: export const UseAddPetKeyFn = (mutationKey?: Array<unknown>) =>
+ *   [useAddPetKey, ...(mutationKey ?? [])];
+ */
+export function buildMutationKeyFn(op) {
+    return {
+        kind: StructureKind.VariableStatement,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: `Use${op.capitalizedMethodName}KeyFn`,
+                initializer: `(mutationKey?: Array<unknown>) => [use${op.capitalizedMethodName}Key, ...(mutationKey ?? [])]`,
+            },
+        ],
+    };
+}
+/**
+ * Build the client options type for infinite queries.
+ * The page parameter is excluded because TanStack Query supplies it via the
+ * pageParam mechanism (#140).
+ * Example:
+ * export type FindPaginatedPetsInfiniteClientOptions = Omit<Options<FindPaginatedPetsData, true>, "query"> &
+ *   { 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}"> }`;
+    return {
+        kind: StructureKind.TypeAlias,
+        isExported: true,
+        name: `${op.capitalizedMethodName}InfiniteClientOptions`,
+        type,
+    };
+}
+/**
+ * Build the infinite query key constant.
+ * Kept distinct from the plain query key so cached InfiniteData never
+ * collides with plain query data for the same operation (#140).
+ * Example: export const useFindPaginatedPetsInfiniteKey = "FindPaginatedPetsInfinite";
+ */
+export function buildInfiniteQueryKeyConst(op) {
+    return {
+        kind: StructureKind.VariableStatement,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: `use${op.capitalizedMethodName}InfiniteKey`,
+                initializer: `"${op.capitalizedMethodName}Infinite"`,
+            },
+        ],
+    };
+}
+/**
+ * Build the infinite query key function.
+ * Example: export const UseFindPaginatedPetsInfiniteKeyFn = (clientOptions: FindPaginatedPetsInfiniteClientOptions = {}, queryKey?: Array<unknown>) =>
+ *   [useFindPaginatedPetsInfiniteKey, ...(queryKey ?? [clientOptions])];
+ */
+export function buildInfiniteQueryKeyFn(op) {
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    const params = [
+        `clientOptions: ${op.capitalizedMethodName}InfiniteClientOptions${defaultValue}`,
+        "queryKey?: Array<unknown>",
+    ];
+    return {
+        kind: StructureKind.VariableStatement,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: `Use${op.capitalizedMethodName}InfiniteKeyFn`,
+                initializer: `(${params.join(", ")}) => [use${op.capitalizedMethodName}InfiniteKey, ...(queryKey ?? [clientOptions])]`,
+            },
+        ],
+    };
+}

package/dist/tsmorph/buildKeys.mjs

@@ -0,0 +1,110 @@
+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}`,
+            },
+        ],
+    };
+}