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

package/dist/tsmorph/buildMutationHooks.mjs

@@ -0,0 +1,51 @@
+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;
+}
+/**
+ * Build useMutation hook.
+ * Example:
+ * export const useAddPet = <TData = Common.AddPetMutationResult, TError = AddPetError, TQueryKey extends Array<unknown> = unknown[], TContext = unknown>(
+ *   mutationKey?: TQueryKey,
+ *   options?: Omit<UseMutationOptions<TData, TError, Options<AddPetData, true>, TContext>, "mutationKey" | "mutationFn">
+ * ) => useMutation<TData, TError, Options<AddPetData, true>, TContext>({
+ *   mutationKey: Common.UseAddPetKeyFn(mutationKey),
+ *   mutationFn: clientOptions => addPet(clientOptions) as unknown as Promise<TData>,
+ *   ...options
+ * });
+ */
+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 mutationFn = `clientOptions => ${op.methodName}(clientOptions) as unknown as Promise<TData>`;
+    const body = `useMutation<TData, TError, ${optionsType}, TContext>({ mutationKey: Common.Use${op.capitalizedMethodName}KeyFn(mutationKey), mutationFn: ${mutationFn}, ...options })`;
+    return {
+        kind: StructureKind.VariableStatement,
+        // Copy the operation's JSDoc (description and @deprecated) from the SDK function
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: hookName,
+                initializer: `<TData = ${dataTypeDefault}, TError = ${errorType}, TQueryKey extends Array<unknown> = unknown[], TContext = unknown>(mutationKey?: TQueryKey, options?: Omit<UseMutationOptions<TData, TError, ${optionsType}, TContext>, "mutationKey" | "mutationFn">) => ${body}`,
+            },
+        ],
+    };
+}

package/dist/tsmorph/buildQueryHooks.mjs

@@ -0,0 +1,246 @@
+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;
+}
+/**
+ * Get the data type based on hook type.
+ */
+function getDataTypeDefault(op, hookType) {
+    const baseType = `Common.${op.capitalizedMethodName}DefaultResponse`;
+    if (hookType === "useSuspenseQuery") {
+        return `NonNullable<${baseType}>`;
+    }
+    if (hookType === "useInfiniteQuery") {
+        return `InfiniteData<${baseType}>`;
+    }
+    return baseType;
+}
+/**
+ * Get the options type name.
+ */
+function getOptionsTypeName(hookType) {
+    switch (hookType) {
+        case "useSuspenseQuery":
+            return "UseSuspenseQueryOptions";
+        case "useInfiniteQuery":
+            return "UseInfiniteQueryOptions";
+        default:
+            return "UseQueryOptions";
+    }
+}
+/**
+ * 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";
+}
+/**
+ * Build the client options parameter string.
+ */
+export function buildClientOptionsParam(op, ctx) {
+    const dataTypeName = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
+        ? `${op.capitalizedMethodName}Data`
+        : "unknown";
+    const hasParams = op.parameters.length > 0;
+    if (!hasParams) {
+        return `clientOptions: Options<${dataTypeName}, true> = {}`;
+    }
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    return `clientOptions: Options<${dataTypeName}, true>${defaultValue}`;
+}
+/**
+ * Build useQuery hook.
+ * Example:
+ * export const useFindPets = <TData = Common.FindPetsDefaultResponse, TError = FindPetsError, TQueryKey extends Array<unknown> = unknown[]>(
+ *   clientOptions: Options<FindPetsData, true> = {},
+ *   queryKey?: TQueryKey,
+ *   options?: Omit<UseQueryOptions<TData, TError>, "queryKey" | "queryFn">
+ * ) => useQuery<TData, TError>({
+ *   queryKey: Common.UseFindPetsKeyFn(clientOptions, queryKey),
+ *   queryFn: () => findPets({ ...clientOptions }).then(response => response.data as TData) as TData,
+ *   ...options
+ * });
+ */
+export function buildUseQueryHook(op, ctx) {
+    const hookName = `use${op.capitalizedMethodName}`;
+    const errorType = getErrorType(op, ctx);
+    const dataTypeDefault = getDataTypeDefault(op, "useQuery");
+    const clientOptionsParam = buildClientOptionsParam(op, ctx);
+    const hasParams = op.parameters.length > 0;
+    // Build the queryFn body
+    const callArgs = hasParams ? "{ ...clientOptions }" : "{ ...clientOptions }";
+    const queryFn = `() => ${op.methodName}(${callArgs}).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 {
+        kind: StructureKind.VariableStatement,
+        // Copy the operation's JSDoc (description and @deprecated) from the SDK function
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: hookName,
+                initializer: `<TData = ${dataTypeDefault}, TError = ${errorType}, TQueryKey extends Array<unknown> = unknown[]>(${clientOptionsParam}, queryKey?: TQueryKey, options?: Omit<UseQueryOptions<TData, TError>, "queryKey" | "queryFn">) => ${body}`,
+            },
+        ],
+    };
+}
+/**
+ * Build useSuspenseQuery hook.
+ */
+export function buildUseSuspenseQueryHook(op, ctx) {
+    const hookName = `use${op.capitalizedMethodName}Suspense`;
+    const errorType = getErrorType(op, ctx);
+    const dataTypeDefault = getDataTypeDefault(op, "useSuspenseQuery");
+    const clientOptionsParam = buildClientOptionsParam(op, ctx);
+    const hasParams = op.parameters.length > 0;
+    const callArgs = hasParams ? "{ ...clientOptions }" : "{ ...clientOptions }";
+    const queryFn = `() => ${op.methodName}(${callArgs}).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 {
+        kind: StructureKind.VariableStatement,
+        // Copy the operation's JSDoc (description and @deprecated) from the SDK function
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: hookName,
+                initializer: `<TData = ${dataTypeDefault}, TError = ${errorType}, TQueryKey extends Array<unknown> = unknown[]>(${clientOptionsParam}, queryKey?: TQueryKey, options?: Omit<UseSuspenseQueryOptions<TData, TError>, "queryKey" | "queryFn">) => ${body}`,
+            },
+        ],
+    };
+}
+/**
+ * Build the nested type for getNextPageParam.
+ * E.g., "meta.next" becomes "{ meta: { next: number } }"
+ */
+export function buildNestedNextPageType(nextPageParam) {
+    const segments = nextPageParam.split(".");
+    return segments.reduceRight((acc, segment) => {
+        return `{ ${segment}: ${acc} }`;
+    }, "number");
+}
+/**
+ * Build useInfiniteQuery hook.
+ */
+export function buildUseInfiniteQueryHook(op, ctx) {
+    if (!op.isPaginatable) {
+        return null;
+    }
+    const hookName = `use${op.capitalizedMethodName}Infinite`;
+    const errorType = getErrorType(op, ctx);
+    const baseDataType = `Common.${op.capitalizedMethodName}DefaultResponse`;
+    const dataTypeName = getDataTypeName(op, ctx);
+    // Infinite queries take a dedicated options type that excludes the page
+    // parameter — it is supplied by TanStack Query's pageParam mechanism
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    const clientOptionsParam = `clientOptions: Common.${op.capitalizedMethodName}InfiniteClientOptions${defaultValue}`;
+    // Build the queryFn with pageParam handling
+    const queryFn = `({ pageParam }) => ${op.methodName}({ ...clientOptions, query: { ...clientOptions.query, ${ctx.pageParam}: pageParam as number } } as Options<${dataTypeName}, true>).then(response => response.data as TData) as TData`;
+    // Build getNextPageParam with nested type
+    const nestedType = buildNestedNextPageType(ctx.nextPageParam);
+    const getNextPageParam = `getNextPageParam: (response) => (response as ${nestedType}).${ctx.nextPageParam}`;
+    // initialPageParam is a string literal
+    const infiniteOptions = `initialPageParam: "${ctx.initialPageParam}", ${getNextPageParam}`;
+    const body = `useInfiniteQuery({ 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
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: hookName,
+                initializer: `<TData = InfiniteData<${baseDataType}>, TError = ${errorType}, TQueryKey extends Array<unknown> = unknown[]>(${clientOptionsParam}, queryKey?: TQueryKey, options?: Omit<UseInfiniteQueryOptions<TData, TError>, "queryKey" | "queryFn">) => ${body}`,
+            },
+        ],
+    };
+}
+/**
+ * Build prefetch function.
+ * Example:
+ * export const prefetchUseFindPets = (queryClient: QueryClient, clientOptions: Options<FindPetsData, true> = {}) =>
+ *   queryClient.prefetchQuery({
+ *     queryKey: Common.UseFindPetsKeyFn(clientOptions),
+ *     queryFn: () => findPets({ ...clientOptions }).then(response => response.data)
+ *   });
+ */
+export function buildPrefetchFn(op, ctx) {
+    const fnName = `prefetchUse${op.capitalizedMethodName}`;
+    const dataTypeName = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
+        ? `${op.capitalizedMethodName}Data`
+        : "unknown";
+    const hasParams = op.parameters.length > 0;
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    const clientOptionsParam = hasParams
+        ? `clientOptions: Options<${dataTypeName}, true>${defaultValue}`
+        : `clientOptions: Options<${dataTypeName}, true> = {}`;
+    const callArgs = "{ ...clientOptions }";
+    const queryFn = `() => ${op.methodName}(${callArgs}).then(response => response.data)`;
+    const body = `queryClient.prefetchQuery({ queryKey: Common.Use${op.capitalizedMethodName}KeyFn(clientOptions), queryFn: ${queryFn} })`;
+    return {
+        kind: StructureKind.VariableStatement,
+        // Copy the operation's JSDoc (description and @deprecated) from the SDK function
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: fnName,
+                initializer: `(queryClient: QueryClient, ${clientOptionsParam}) => ${body}`,
+            },
+        ],
+    };
+}
+/**
+ * Build ensureQueryData function.
+ * Example:
+ * export const ensureUseFindPetsData = (queryClient: QueryClient, clientOptions: Options<FindPetsData, true> = {}) =>
+ *   queryClient.ensureQueryData({
+ *     queryKey: Common.UseFindPetsKeyFn(clientOptions),
+ *     queryFn: () => findPets({ ...clientOptions }).then(response => response.data)
+ *   });
+ */
+export function buildEnsureQueryDataFn(op, ctx) {
+    const fnName = `ensureUse${op.capitalizedMethodName}Data`;
+    const dataTypeName = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
+        ? `${op.capitalizedMethodName}Data`
+        : "unknown";
+    const hasParams = op.parameters.length > 0;
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    const clientOptionsParam = hasParams
+        ? `clientOptions: Options<${dataTypeName}, true>${defaultValue}`
+        : `clientOptions: Options<${dataTypeName}, true> = {}`;
+    const callArgs = "{ ...clientOptions }";
+    const queryFn = `() => ${op.methodName}(${callArgs}).then(response => response.data)`;
+    const body = `queryClient.ensureQueryData({ queryKey: Common.Use${op.capitalizedMethodName}KeyFn(clientOptions), queryFn: ${queryFn} })`;
+    return {
+        kind: StructureKind.VariableStatement,
+        // Copy the operation's JSDoc (description and @deprecated) from the SDK function
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: fnName,
+                initializer: `(queryClient: QueryClient, ${clientOptionsParam}) => ${body}`,
+            },
+        ],
+    };
+}

package/dist/tsmorph/buildQueryOptions.mjs

@@ -0,0 +1,76 @@
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { buildClientOptionsParam, buildNestedNextPageType, getDataTypeName, } from "./buildQueryHooks.mjs";
+/**
+ * Build a queryOptions factory for a GET operation.
+ * The factory centralizes queryKey and queryFn so they can be reused with
+ * every TanStack Query utility (useQuery, useQueries, prefetchQuery,
+ * ensureQueryData, setQueryData, ...) with full type safety.
+ * Example:
+ * export const findPetsOptions = (clientOptions: Options<FindPetsData, true> = {}, queryKey?: Array<unknown>) =>
+ *   queryOptions({
+ *     queryKey: Common.UseFindPetsKeyFn(clientOptions, queryKey),
+ *     queryFn: () => findPets({ ...clientOptions }).then(response => response.data),
+ *   });
+ */
+export function buildQueryOptionsFn(op, ctx) {
+    const fnName = `${op.methodName}Options`;
+    const clientOptionsParam = buildClientOptionsParam(op, ctx);
+    const queryFn = `() => ${op.methodName}({ ...clientOptions }).then(response => response.data)`;
+    const body = `queryOptions({ queryKey: Common.Use${op.capitalizedMethodName}KeyFn(clientOptions, queryKey), queryFn: ${queryFn} })`;
+    return {
+        kind: StructureKind.VariableStatement,
+        // Copy the operation's JSDoc (description and @deprecated) from the SDK function
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: fnName,
+                initializer: `(${clientOptionsParam}, queryKey?: Array<unknown>) => ${body}`,
+            },
+        ],
+    };
+}
+/**
+ * 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>) =>
+ *   infiniteQueryOptions({
+ *     queryKey: Common.UseFindPaginatedPetsInfiniteKeyFn(clientOptions, queryKey),
+ *     queryFn: ({ pageParam }) => findPaginatedPets({ ...clientOptions, query: { ...clientOptions.query, page: pageParam } } as Options<FindPaginatedPetsData, true>).then(response => response.data),
+ *     initialPageParam: 1,
+ *     getNextPageParam: (response) => (response as { nextPage: number }).nextPage,
+ *   });
+ */
+export function buildInfiniteQueryOptionsFn(op, ctx) {
+    if (!op.isPaginatable) {
+        return null;
+    }
+    const fnName = `${op.methodName}InfiniteOptions`;
+    const dataTypeName = getDataTypeName(op, ctx);
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    const clientOptionsParam = `clientOptions: Common.${op.capitalizedMethodName}InfiniteClientOptions${defaultValue}`;
+    const queryFn = `({ pageParam }) => ${op.methodName}({ ...clientOptions, query: { ...clientOptions.query, ${ctx.pageParam}: pageParam } } as Options<${dataTypeName}, true>).then(response => response.data)`;
+    // Emit a numeric literal when possible so the inferred pageParam type
+    // matches what getNextPageParam returns
+    const initialPageParam = /^-?\d+$/.test(ctx.initialPageParam)
+        ? ctx.initialPageParam
+        : JSON.stringify(ctx.initialPageParam);
+    const nestedType = buildNestedNextPageType(ctx.nextPageParam);
+    const getNextPageParam = `(response) => (response as ${nestedType}).${ctx.nextPageParam}`;
+    const body = `infiniteQueryOptions({ queryKey: Common.Use${op.capitalizedMethodName}InfiniteKeyFn(clientOptions, queryKey), queryFn: ${queryFn}, initialPageParam: ${initialPageParam}, getNextPageParam: ${getNextPageParam} })`;
+    return {
+        kind: StructureKind.VariableStatement,
+        // Copy the operation's JSDoc (description and @deprecated) from the SDK function
+        leadingTrivia: op.jsDoc ? `${op.jsDoc}\n` : undefined,
+        isExported: true,
+        declarationKind: VariableDeclarationKind.Const,
+        declarations: [
+            {
+                name: fnName,
+                initializer: `(${clientOptionsParam}, queryKey?: Array<unknown>) => ${body}`,
+            },
+        ],
+    };
+}

package/dist/tsmorph/generateFiles.mjs

@@ -0,0 +1,251 @@
+import { StructureKind, } from "ts-morph";
+import { OpenApiRqFiles } from "../constants.mjs";
+import { buildDefaultResponseType, buildInfiniteClientOptionsType, buildInfiniteQueryKeyConst, buildInfiniteQueryKeyFn, buildMutationKeyConst, buildMutationKeyFn, buildMutationResultType, buildQueryKeyConst, buildQueryKeyFn, buildQueryResultType, } from "./buildCommon.mjs";
+import { buildUseMutationHook } from "./buildMutationHooks.mjs";
+import { buildEnsureQueryDataFn, buildPrefetchFn, buildUseInfiniteQueryHook, buildUseQueryHook, buildUseSuspenseQueryHook, } from "./buildQueryHooks.mjs";
+import { buildInfiniteQueryOptionsFn, buildQueryOptionsFn, } from "./buildQueryOptions.mjs";
+import { buildAxiosErrorImport, buildClientImport, buildCommonImport, buildModelImport, buildQueryImport, buildQueryOptionsImport, buildServiceImport, createGenerationProject, } from "./projectFactory.mjs";
+/**
+ * Build imports for common.ts file.
+ */
+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());
+    }
+    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.
+ */
+function generateIndexFile(ctx) {
+    const project = createGenerationProject();
+    const sourceFile = project.createSourceFile(`${OpenApiRqFiles.index}.ts`, undefined, { overwrite: true });
+    const exports = [
+        {
+            kind: StructureKind.ExportDeclaration,
+            moduleSpecifier: "./common",
+        },
+        {
+            kind: StructureKind.ExportDeclaration,
+            moduleSpecifier: "./queries",
+        },
+        {
+            kind: StructureKind.ExportDeclaration,
+            moduleSpecifier: "./queryOptions",
+        },
+    ];
+    sourceFile.addExportDeclarations(exports);
+    return sourceFile.getFullText();
+}
+/**
+ * Generate the common.ts file content.
+ */
+function generateCommonFile(operations, ctx) {
+    const project = createGenerationProject();
+    const sourceFile = project.createSourceFile(`${OpenApiRqFiles.common}.ts`, undefined, { overwrite: true });
+    // Add imports
+    sourceFile.addImportDeclarations(buildCommonFileImports(ctx));
+    // Group operations by HTTP method
+    const getOperations = operations.filter((op) => op.httpMethod === "GET");
+    const mutationOperations = operations.filter((op) => ["POST", "PUT", "PATCH", "DELETE"].includes(op.httpMethod));
+    // Add query types and keys
+    for (const op of getOperations) {
+        sourceFile.addTypeAlias(buildDefaultResponseType(op));
+        sourceFile.addTypeAlias(buildQueryResultType(op));
+        sourceFile.addVariableStatement(buildQueryKeyConst(op));
+        sourceFile.addVariableStatement(buildQueryKeyFn(op, ctx));
+    }
+    // Add dedicated infinite query types and keys for paginatable operations
+    for (const op of getOperations.filter((o) => o.isPaginatable)) {
+        sourceFile.addTypeAlias(buildInfiniteClientOptionsType(op, ctx));
+        sourceFile.addVariableStatement(buildInfiniteQueryKeyConst(op));
+        sourceFile.addVariableStatement(buildInfiniteQueryKeyFn(op));
+    }
+    // Add mutation types and keys
+    for (const op of mutationOperations) {
+        sourceFile.addTypeAlias(buildMutationResultType(op));
+        sourceFile.addVariableStatement(buildMutationKeyConst(op));
+        sourceFile.addVariableStatement(buildMutationKeyFn(op));
+    }
+    return sourceFile.getFullText();
+}
+/**
+ * Generate the queries.ts file content.
+ */
+function generateQueriesFile(operations, ctx) {
+    const project = createGenerationProject();
+    const sourceFile = project.createSourceFile(`${OpenApiRqFiles.queries}.ts`, undefined, { overwrite: true });
+    // Add imports
+    sourceFile.addImportDeclarations(buildHookFileImports(ctx));
+    // Group operations
+    const getOperations = operations.filter((op) => op.httpMethod === "GET");
+    const mutationOperations = operations.filter((op) => ["POST", "PUT", "PATCH", "DELETE"].includes(op.httpMethod));
+    // Add useQuery hooks
+    for (const op of getOperations) {
+        sourceFile.addVariableStatement(buildUseQueryHook(op, ctx));
+    }
+    // Add useMutation hooks
+    for (const op of mutationOperations) {
+        sourceFile.addVariableStatement(buildUseMutationHook(op, ctx));
+    }
+    return sourceFile.getFullText();
+}
+/**
+ * Generate the queryOptions.ts file content.
+ */
+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);
+    // 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);
+        }
+    }
+    return sourceFile.getFullText();
+}
+/**
+ * Generate the suspense.ts file content.
+ */
+function generateSuspenseFile(operations, ctx) {
+    const project = createGenerationProject();
+    const sourceFile = project.createSourceFile(`${OpenApiRqFiles.suspense}.ts`, undefined, { overwrite: true });
+    // Add imports
+    sourceFile.addImportDeclarations(buildHookFileImports(ctx));
+    // Only GET operations for suspense
+    const getOperations = operations.filter((op) => op.httpMethod === "GET");
+    // Add useSuspenseQuery hooks
+    for (const op of getOperations) {
+        sourceFile.addVariableStatement(buildUseSuspenseQueryHook(op, ctx));
+    }
+    return sourceFile.getFullText();
+}
+/**
+ * Generate the infiniteQueries.ts file content.
+ */
+function generateInfiniteQueriesFile(operations, ctx) {
+    const project = createGenerationProject();
+    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);
+    // Add useInfiniteQuery hooks
+    for (const op of paginatableOperations) {
+        const hook = buildUseInfiniteQueryHook(op, ctx);
+        if (hook) {
+            sourceFile.addVariableStatement(hook);
+        }
+    }
+    return sourceFile.getFullText();
+}
+/**
+ * Generate the prefetch.ts file content.
+ */
+function generatePrefetchFile(operations, ctx) {
+    const project = createGenerationProject();
+    const sourceFile = project.createSourceFile(`${OpenApiRqFiles.prefetch}.ts`, undefined, { overwrite: true });
+    // Add imports
+    sourceFile.addImportDeclarations(buildHookFileImports(ctx));
+    // Only GET operations for prefetch
+    const getOperations = operations.filter((op) => op.httpMethod === "GET");
+    // Add prefetch functions
+    for (const op of getOperations) {
+        sourceFile.addVariableStatement(buildPrefetchFn(op, ctx));
+    }
+    return sourceFile.getFullText();
+}
+/**
+ * Generate the ensureQueryData.ts file content.
+ */
+function generateEnsureQueryDataFile(operations, ctx) {
+    const project = createGenerationProject();
+    const sourceFile = project.createSourceFile(`${OpenApiRqFiles.ensureQueryData}.ts`, undefined, { overwrite: true });
+    // Add imports
+    sourceFile.addImportDeclarations(buildHookFileImports(ctx));
+    // Only GET operations for ensure
+    const getOperations = operations.filter((op) => op.httpMethod === "GET");
+    // Add ensureQueryData functions
+    for (const op of getOperations) {
+        sourceFile.addVariableStatement(buildEnsureQueryDataFn(op, ctx));
+    }
+    return sourceFile.getFullText();
+}
+/**
+ * Add the generated header comment to file content.
+ */
+function addHeaderComment(content, version) {
+    const comment = `// generated with @7nohe/openapi-react-query-codegen@${version} \n\n`;
+    return comment + content;
+}
+/**
+ * Generate all files using ts-morph.
+ */
+export function generateAllFiles(operations, ctx) {
+    return [
+        {
+            name: `${OpenApiRqFiles.index}.ts`,
+            content: addHeaderComment(generateIndexFile(ctx), ctx.version),
+        },
+        {
+            name: `${OpenApiRqFiles.common}.ts`,
+            content: addHeaderComment(generateCommonFile(operations, ctx), ctx.version),
+        },
+        {
+            name: `${OpenApiRqFiles.queries}.ts`,
+            content: addHeaderComment(generateQueriesFile(operations, ctx), ctx.version),
+        },
+        {
+            name: `${OpenApiRqFiles.queryOptions}.ts`,
+            content: addHeaderComment(generateQueryOptionsFile(operations, ctx), ctx.version),
+        },
+        {
+            name: `${OpenApiRqFiles.suspense}.ts`,
+            content: addHeaderComment(generateSuspenseFile(operations, ctx), ctx.version),
+        },
+        {
+            name: `${OpenApiRqFiles.infiniteQueries}.ts`,
+            content: addHeaderComment(generateInfiniteQueriesFile(operations, ctx), ctx.version),
+        },
+        {
+            name: `${OpenApiRqFiles.prefetch}.ts`,
+            content: addHeaderComment(generatePrefetchFile(operations, ctx), ctx.version),
+        },
+        {
+            name: `${OpenApiRqFiles.ensureQueryData}.ts`,
+            content: addHeaderComment(generateEnsureQueryDataFile(operations, ctx), ctx.version),
+        },
+    ];
+}

package/dist/tsmorph/index.mjs

@@ -0,0 +1,5 @@
+export { generateAllFiles } from "./generateFiles.mjs";
+export { createGenerationProject } from "./projectFactory.mjs";
+export * from "./buildCommon.mjs";
+export * from "./buildQueryHooks.mjs";
+export * from "./buildMutationHooks.mjs";