@7nohe/openapi-react-query-codegen 2.1.0 → 3.0.0-beta.1

package/dist/tsmorph/buildQueryHooks.mjs

@@ -0,0 +1,237 @@
+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";
+    }
+}
+/**
+ * Build the client options parameter string.
+ */
+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 } }"
+ */
+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 = ctx.modelNames.includes(`${op.capitalizedMethodName}Data`)
+        ? `${op.capitalizedMethodName}Data`
+        : "unknown";
+    const defaultValue = op.allParamsOptional ? " = {}" : "";
+    const clientOptionsParam = `clientOptions: Options<${dataTypeName}, true>${defaultValue}`;
+    // Build the queryFn with pageParam handling
+    const queryFn = `({ pageParam }) => ${op.methodName}({ ...clientOptions, query: { ...clientOptions.query, ${ctx.pageParam}: pageParam as number } }).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}KeyFn(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/generateFiles.mjs

@@ -0,0 +1,205 @@
+import { StructureKind, } from "ts-morph";
+import { OpenApiRqFiles } from "../constants.mjs";
+import { buildDefaultResponseType, buildMutationKeyConst, buildMutationKeyFn, buildMutationResultType, buildQueryKeyConst, buildQueryKeyFn, buildQueryResultType, } from "./buildCommon.mjs";
+import { buildUseMutationHook } from "./buildMutationHooks.mjs";
+import { buildEnsureQueryDataFn, buildPrefetchFn, buildUseInfiniteQueryHook, buildUseQueryHook, buildUseSuspenseQueryHook, } from "./buildQueryHooks.mjs";
+import { buildAxiosErrorImport, buildClientImport, buildCommonImport, buildModelImport, buildQueryImport, 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",
+        },
+    ];
+    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 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 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.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";

package/dist/tsmorph/projectFactory.mjs

@@ -0,0 +1,121 @@
+import { IndentationText, NewLineKind, Project, QuoteKind, StructureKind, } from "ts-morph";
+/**
+ * Create a shared ts-morph Project for code generation.
+ * Uses consistent formatting settings to match existing output.
+ */
+export function createGenerationProject() {
+    return new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: {
+            strict: true,
+        },
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces,
+            newLineKind: NewLineKind.LineFeed,
+            quoteKind: QuoteKind.Double,
+            useTrailingCommas: true,
+        },
+    });
+}
+/**
+ * Build import structure for the Options type.
+ * sdk.gen re-exports Options extended with `client` and `meta`, which the
+ * base client Options lacks; hooks must accept those properties.
+ */
+export function buildClientImport(_ctx) {
+    return {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "../requests/sdk.gen",
+        namedImports: [{ name: "Options", isTypeOnly: true }],
+    };
+}
+/**
+ * Build import structure for TanStack Query.
+ */
+export function buildQueryImport() {
+    return {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "@tanstack/react-query",
+        namedImports: [
+            { name: "QueryClient", isTypeOnly: true },
+            { name: "useQuery" },
+            { name: "useSuspenseQuery" },
+            { name: "useInfiniteQuery" },
+            { name: "useMutation" },
+            { name: "UseQueryResult" },
+            { name: "UseQueryOptions" },
+            { name: "UseInfiniteQueryOptions" },
+            { name: "UseMutationOptions" },
+            { name: "UseMutationResult" },
+            { name: "UseSuspenseQueryOptions" },
+            { name: "InfiniteData" },
+        ],
+    };
+}
+/**
+ * Build import structure for services.
+ */
+export function buildServiceImport(ctx) {
+    return {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "../requests/sdk.gen",
+        namedImports: ctx.serviceNames.map((name) => ({ name })),
+    };
+}
+/**
+ * Build import structure for models.
+ */
+export function buildModelImport(ctx) {
+    if (ctx.modelNames.length === 0) {
+        return null;
+    }
+    return {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "../requests/types.gen",
+        namedImports: ctx.modelNames.map((name) => ({ name })),
+    };
+}
+/**
+ * Build import structure for axios error type.
+ */
+export function buildAxiosErrorImport() {
+    return {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "axios",
+        namedImports: [{ name: "AxiosError" }],
+    };
+}
+/**
+ * Build import for Common namespace.
+ */
+export function buildCommonImport() {
+    return {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "./common",
+        namespaceImport: "Common",
+    };
+}
+/**
+ * Build all imports needed for the common file.
+ */
+export 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 all imports needed for hook files (queries, suspense, infinite).
+ */
+export function buildHookFileImports(ctx) {
+    return [buildCommonImport(), ...buildCommonFileImports(ctx)];
+}

package/dist/types.mjs

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "2.1.0",
+  "version": "3.0.0-beta.1",
   "description": "OpenAPI React Query Codegen",
   "bin": {
     "openapi-rq": "dist/cli.mjs"
@@ -39,7 +39,7 @@
   "license": "MIT",
   "author": "Daiki Urata (@7nohe)",
   "dependencies": {
-    "@hey-api/openapi-ts": "0.92.3",
+    "@hey-api/openapi-ts": "0.99.0",
     "cross-spawn": "^7.0.3"
   },
   "devDependencies": {
@@ -51,17 +51,17 @@
     "commander": "^12.0.0",
     "lefthook": "^1.6.10",
     "rimraf": "^5.0.5",
-    "ts-morph": "^27.0.2",
-    "typescript": "^5.9.3",
+    "ts-morph": "^28.0.0",
+    "typescript": "^6.0.3",
     "vitest": "^1.5.0"
   },
   "peerDependencies": {
     "commander": "12.x",
-    "ts-morph": "27.x",
-    "typescript": "5.x"
+    "ts-morph": "28.x",
+    "typescript": "5.x || 6.x"
   },
   "engines": {
-    "node": ">=20.19.0",
+    "node": ">=22.18.0",
     "pnpm": ">=9"
   },
   "scripts": {