@7nohe/openapi-react-query-codegen 0.0.0-c7f76ece287f3b22268170498e8fea9b0c797946

package/README.md

@@ -0,0 +1,191 @@
+# OpenAPI React Query Codegen
+
+> Node.js library that generates [React Query (also called TanStack Query)](https://tanstack.com/query) hooks based on an OpenAPI specification file.
+
+## Features
+
+- Supports generation of custom react hooks that use React Query's `useQuery` and `useMutation` hooks
+- Supports generation of query keys for query caching
+- Supports the option to use pure TypeScript clients generated by [@hey-api/openapi-ts](https://github.com/hey-api/openapi-ts)
+
+## Install
+
+```
+$ npm install -D @7nohe/openapi-react-query-codegen
+```
+
+Register the command to the `scripts` property in your package.json file.
+
+```json
+{
+  "scripts": {
+    "codegen": "openapi-rq -i ./petstore.yaml -c axios"
+  }
+}
+```
+
+You can also run the command without installing it in your project using the npx command.
+
+```bash
+$ npx --package @7nohe/openapi-react-query-codegen openapi-rq -i ./petstore.yaml -c axios
+```
+
+## Usage
+
+```
+$ openapi-rq --help
+
+Usage: openapi-rq [options]
+
+Generate React Query code based on OpenAPI
+
+Options:
+  -V, --version              output the version number
+  -i, --input <value>        OpenAPI specification, can be a path, url or string content (required)
+  -o, --output <value>       Output directory (default: "openapi")
+  -c, --client <value>       HTTP client to generate [fetch, xhr, node, axios, angular] (default: "fetch")
+  --request <value>          Path to custom request file
+  --format <value>           Process output folder with formatter? ['biome', 'prettier']
+  --lint   <value>           Process output folder with linter? ['eslint', 'biome']
+  --operationId              Use operation ID to generate operation names?
+  --serviceResponse <value>  Define shape of returned value from service calls ['body', 'response']
+  --base <value>             Manually set base in OpenAPI config instead of inferring from server value
+  --enums <value>            Generate JavaScript objects from enum definitions? ['javascript', 'typescript']
+  --useDateType              Use Date type instead of string for date types for models, this will not convert the data to a Date object
+  --debug                    Enable debug mode
+  --noSchemas                Disable generating schemas for request and response objects
+  --schemaTypes <value>      Define the type of schema generation ['form', 'json'] (default: "json")
+  -h, --help                 display help for command
+```
+
+## Example Usage
+
+### Command
+
+```
+$ openapi-rq -i ./petstore.yaml
+```
+
+### Output directory structure
+
+```
+- openapi
+  - queries
+    - index.ts <- main file that exports common types, variables, and queries. Does not export suspense or prefetch hooks
+    - common.ts <- common types
+    - queries.ts <- generated query hooks
+    - suspenses.ts <- generated suspense hooks
+    - prefetch.ts <- generated prefetch hooks learn more about prefetching in in link below
+  - requests <- output code generated by @hey-api/openapi-ts
+```
+
+- [Prefetching docs](https://tanstack.com/query/latest/docs/framework/react/guides/advanced-ssr#prefetching-and-dehydrating-data)
+
+### In your app
+
+#### Using the generated hooks
+
+```tsx
+// App.tsx
+import { usePetServiceFindPetsByStatus } from "../openapi/queries";
+function App() {
+  const { data } = usePetServiceFindPetsByStatus({ status: ["available"] });
+
+  return (
+    <div className="App">
+      <h1>Pet List</h1>
+      <ul>{data?.map((pet) => <li key={pet.id}>{pet.name}</li>)}</ul>
+    </div>
+  );
+}
+
+export default App;
+```
+
+#### Using the generated typescript client
+
+```tsx
+import { useQuery } from "@tanstack/react-query";
+import { PetService } from "../openapi/requests/services";
+import { usePetServiceFindPetsByStatusKey } from "../openapi/queries";
+
+function App() {
+  // You can still use the auto-generated query key
+  const { data } = useQuery({
+    queryKey: [usePetServiceFindPetsByStatusKey],
+    queryFn: () => {
+      // Do something here
+      return PetService.findPetsByStatus(["available"]);
+    },
+  });
+
+  return <div className="App">{/* .... */}</div>;
+}
+
+export default App;
+```
+
+#### Using Suspense Hooks
+
+```tsx
+// App.tsx
+import { useDefaultClientFindPetsSuspense } from "../openapi/queries/suspense";
+function ChildComponent() {
+  const { data } = useDefaultClientFindPetsSuspense({ tags: [], limit: 10 });
+
+  return <ul>{data?.map((pet, index) => <li key={pet.id}>{pet.name}</li>)}</ul>;
+}
+
+function ParentComponent() {
+  return (
+    <>
+      <Suspense fallback={<>loading...</>}>
+        <ChildComponent />
+      </Suspense>
+    </>
+  );
+}
+
+function App() {
+  return (
+    <div className="App">
+      <h1>Pet List</h1>
+      <ParentComponent />
+    </div>
+  );
+}
+
+export default App;
+```
+
+#### Runtime Configuration
+
+You can modify the default values used by the generated service calls by modifying the OpenAPI configuration singleton object.
+
+It's default location is `openapi/requests/core/OpenAPI.ts` and it is also exported from `openapi/index.ts`
+
+Import the constant into your runtime and modify it before setting up the react app.
+
+```typescript
+/** main.tsx */
+import { OpenAPI as OpenAPIConfig } from './openapi/requests/core/OpenAPI';
+...
+OpenAPIConfig.BASE = 'www.domain.com/api';
+OpenAPIConfig.HEADERS = {
+  'x-header-1': 'value-1',
+  'x-header-2': 'value-2',
+};
+...
+ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
+  <React.StrictMode>
+    <QueryClientProvider client={queryClient}>
+      <App />
+    </QueryClientProvider>
+  </React.StrictMode>
+);
+
+```
+
+## License
+
+MIT

package/dist/cli.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { generate } from "./generate.mjs";
+import { Command, Option } from "commander";
+import { readFile } from "fs/promises";
+import { dirname, join } from "path";
+import { fileURLToPath } from "node:url";
+import { defaultOutputPath } from "./constants.mjs";
+const program = new Command();
+async function setupProgram() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const file = await readFile(join(__dirname, "../package.json"), "utf-8");
+    const packageJson = JSON.parse(file);
+    const version = packageJson.version;
+    program
+        .name("openapi-rq")
+        .version(version)
+        .description("Generate React Query code based on OpenAPI")
+        .requiredOption("-i, --input <value>", "OpenAPI specification, can be a path, url or string content (required)")
+        .option("-o, --output <value>", "Output directory", defaultOutputPath)
+        .addOption(new Option("-c, --client <value>", "HTTP client to generate")
+        .choices(["angular", "axios", "fetch", "node", "xhr"])
+        .default("fetch"))
+        .option("--request <value>", "Path to custom request file")
+        .addOption(new Option("--format <value>", "Process output folder with formatter?").choices(["biome", "prettier"]))
+        .addOption(new Option("--lint <value>", "Process output folder with linter?").choices(["biome", "eslint"]))
+        .option("--operationId", "Use operation ID to generate operation names?")
+        .addOption(new Option("--serviceResponse <value>", "Define shape of returned value from service calls").choices(["body", "response"]))
+        .option("--base <value>", "Manually set base in OpenAPI config instead of inferring from server value")
+        .addOption(new Option("--enums <value>", "Generate JavaScript objects from enum definitions?").choices(["javascript", "typescript"]))
+        .option("--useDateType", "Use Date type instead of string for date types for models, this will not convert the data to a Date object")
+        .option("--debug", "Run in debug mode?")
+        .option("--noSchemas", "Disable generating JSON schemas")
+        .addOption(new Option("--schemaType <value>", "Type of JSON schema [Default: 'json']").choices(["form", "json"]))
+        .parse();
+    const options = program.opts();
+    await generate(options, version);
+}
+setupProgram();

package/dist/common.mjs

@@ -0,0 +1,135 @@
+import { stat } from "fs/promises";
+import ts from "typescript";
+import path from "path";
+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 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);
+};
+export const lowercaseFirstLetter = (str) => {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+};
+export const getNameFromMethod = (method) => {
+    const methodName = method.getName();
+    if (!methodName) {
+        throw new Error("Method name not found");
+    }
+    return methodName;
+};
+export async function exists(f) {
+    try {
+        await stat(f);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const Common = "Common";
+/**
+ * Build a common type name by prepending the Common namespace.
+ */
+export function BuildCommonTypeName(name) {
+    if (typeof name === "string") {
+        return ts.factory.createIdentifier(`${Common}.${name}`);
+    }
+    return ts.factory.createIdentifier(`${Common}.${name.text}`);
+}
+/**
+ * Safely parse a value into a number. Checks for NaN and Infinity.
+ * Returns NaN if the string is not a valid number.
+ * @param value The value to parse.
+ * @returns The parsed number or NaN if the value is not a valid number.
+ */
+export function safeParseNumber(value) {
+    const parsed = Number(value);
+    if (!isNaN(parsed) && isFinite(parsed)) {
+        return parsed;
+    }
+    return NaN;
+}
+export function extractPropertiesFromObjectParam(param) {
+    const referenced = param.findReferences()[0];
+    const def = referenced.getDefinition();
+    const paramNodes = def
+        .getNode()
+        .getType()
+        .getProperties()
+        .map((prop) => ({
+        name: prop.getName(),
+        optional: prop.isOptional(),
+        type: prop.getValueDeclaration()?.getType(),
+    }));
+    return paramNodes;
+}
+/**
+ * Replace the import("...") surrounding the type if there is one.
+ * This can happen when the type is imported from another file, but
+ * we are already importing all the types from that file.
+ *
+ * https://regex101.com/r/3DyHaQ/1
+ *
+ * TODO: Replace with a more robust solution.
+ */
+export function getShortType(type) {
+    return type.replaceAll(/import\(".*"\)\./g, "");
+}
+export function getClassesFromService(node) {
+    const klasses = node.getClasses();
+    if (!klasses.length) {
+        throw new Error("No classes found");
+    }
+    return klasses.map((klass) => {
+        const className = klass.getName();
+        if (!className) {
+            throw new Error("Class name not found");
+        }
+        return {
+            className,
+            klass,
+        };
+    });
+}
+export function getClassNameFromClassNode(klass) {
+    const className = klass.getName();
+    if (!className) {
+        throw new Error("Class name not found");
+    }
+    return className;
+}
+export function formatOptions(options) {
+    // loop through properties on the options object
+    // if the property is a string of number then convert it to a number
+    // if the property is a string of boolean then convert it to a boolean
+    const formattedOptions = Object.entries(options).reduce((acc, [key, value]) => {
+        const typedKey = key;
+        const typedValue = value;
+        const parsedNumber = safeParseNumber(typedValue);
+        if (value === "true" || value === true) {
+            acc[typedKey] = true;
+        }
+        else if (value === "false" || value === false) {
+            acc[typedKey] = false;
+        }
+        else if (!isNaN(parsedNumber)) {
+            acc[typedKey] = parsedNumber;
+        }
+        else {
+            acc[typedKey] = typedValue;
+        }
+        return acc;
+    }, options);
+    return formattedOptions;
+}
+export function buildRequestsOutputPath(outputPath) {
+    return path.join(outputPath, requestsOutputPath);
+}
+export function buildQueriesOutputPath(outputPath) {
+    return path.join(outputPath, queriesOutputPath);
+}

package/dist/constants.mjs

@@ -0,0 +1,12 @@
+export const defaultOutputPath = "openapi";
+export const queriesOutputPath = "queries";
+export const requestsOutputPath = "requests";
+export const serviceFileName = "services.gen";
+export const modalsFileName = "types.gen";
+export const OpenApiRqFiles = {
+    queries: "queries",
+    common: "common",
+    suspense: "suspense",
+    index: "index",
+    prefetch: "prefetch",
+};

package/dist/createExports.mjs

@@ -0,0 +1,63 @@
+import { createUseQuery } from "./createUseQuery.mjs";
+import { createUseMutation } from "./createUseMutation.mjs";
+import { createPrefetch } from "./createPrefetch.mjs";
+export const createExports = (service) => {
+    const { klasses } = service;
+    const methods = klasses.map((k) => k.methods).flat();
+    const allGet = methods.filter((m) => m.httpMethodName.toUpperCase().includes("GET"));
+    const allPost = methods.filter((m) => m.httpMethodName.toUpperCase().includes("POST"));
+    const allPut = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PUT"));
+    const allPatch = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PATCH"));
+    const allDelete = methods.filter((m) => m.httpMethodName.toUpperCase().includes("DELETE"));
+    const allGetQueries = allGet.map((m) => createUseQuery(m));
+    const allPrefetchQueries = allGet.map((m) => createPrefetch(m));
+    const allPostMutations = allPost.map((m) => createUseMutation(m));
+    const allPutMutations = allPut.map((m) => createUseMutation(m));
+    const allPatchMutations = allPatch.map((m) => createUseMutation(m));
+    const allDeleteMutations = allDelete.map((m) => createUseMutation(m));
+    const allQueries = [...allGetQueries];
+    const allMutations = [
+        ...allPostMutations,
+        ...allPutMutations,
+        ...allPatchMutations,
+        ...allDeleteMutations,
+    ];
+    const commonInQueries = allQueries
+        .map(({ apiResponse, returnType, key }) => [apiResponse, returnType, key])
+        .flat();
+    const commonInMutations = allMutations
+        .map(({ mutationResult }) => [mutationResult])
+        .flat();
+    const allCommon = [...commonInQueries, ...commonInMutations];
+    const mainQueries = allQueries.map(({ queryHook }) => [queryHook]).flat();
+    const mainMutations = allMutations
+        .map(({ mutationHook }) => [mutationHook])
+        .flat();
+    const mainExports = [...mainQueries, ...mainMutations];
+    const suspenseQueries = allQueries
+        .map(({ suspenseQueryHook }) => [suspenseQueryHook])
+        .flat();
+    const suspenseExports = [...suspenseQueries];
+    const allPrefetches = allPrefetchQueries
+        .map(({ prefetchHook }) => [prefetchHook])
+        .flat();
+    const allPrefetchExports = [...allPrefetches];
+    return {
+        /**
+         * Common types and variables between queries (regular and suspense) and mutations
+         */
+        allCommon,
+        /**
+         * Main exports are the hooks that are used in the components
+         */
+        mainExports,
+        /**
+         * Suspense exports are the hooks that are used in the suspense components
+         */
+        suspenseExports,
+        /**
+         * Prefetch exports are the hooks that are used in the prefetch components
+         */
+        allPrefetchExports,
+    };
+};

package/dist/createImports.mjs

@@ -0,0 +1,42 @@
+import ts from "typescript";
+import { posix } from "path";
+import { modalsFileName, serviceFileName } from "./constants.mjs";
+const { join } = posix;
+export const createImports = ({ serviceEndName, project, }) => {
+    const modelsFile = project
+        .getSourceFiles()
+        .find((sourceFile) => sourceFile.getFilePath().includes(modalsFileName));
+    const serviceFile = project.getSourceFileOrThrow(`${serviceFileName}.ts`);
+    if (!modelsFile) {
+        console.warn(`
+⚠️ WARNING: No models file found.
+  This may be an error if \`.components.schemas\` or \`.components.parameters\` is defined in your OpenAPI input.`);
+    }
+    const modelNames = modelsFile
+        ? Array.from(modelsFile.getExportedDeclarations().keys())
+        : [];
+    const serviceExports = Array.from(serviceFile.getExportedDeclarations().keys());
+    const serviceNames = serviceExports.filter((name) => name.endsWith(serviceEndName));
+    const imports = [
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useQuery")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useSuspenseQuery")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useMutation")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseQueryResult")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseQueryOptions")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseMutationOptions")),
+            ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("UseMutationResult")),
+        ])), ts.factory.createStringLiteral("@tanstack/react-query"), undefined),
+        ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            // import all class names from service file
+            ...serviceNames.map((serviceName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(serviceName))),
+        ])), ts.factory.createStringLiteral(join("../requests", serviceFileName)), undefined),
+    ];
+    if (modelsFile) {
+        // import all the models by name
+        imports.push(ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
+            ...modelNames.map((modelName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(modelName))),
+        ])), ts.factory.createStringLiteral(join("../requests/", modalsFileName)), undefined));
+    }
+    return imports;
+};

package/dist/createPrefetch.mjs

@@ -0,0 +1,58 @@
+import ts from "typescript";
+import { BuildCommonTypeName, extractPropertiesFromObjectParam, getNameFromMethod, } from "./common.mjs";
+import { createQueryKeyFromMethod, getRequestParamFromMethod, hookNameFromMethod, } from "./createUseQuery.mjs";
+import { addJSDocToNode } from "./util.mjs";
+/**
+ * Creates a prefetch function for a query
+ */
+function createPrefetchHook({ requestParams, method, className, }) {
+    const methodName = getNameFromMethod(method);
+    const queryName = hookNameFromMethod({ method, className });
+    const customHookName = `prefetch${queryName.charAt(0).toUpperCase() + queryName.slice(1)}`;
+    const queryKey = createQueryKeyFromMethod({ method, className });
+    // const
+    const hookExport = ts.factory.createVariableStatement(
+    // export
+    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(customHookName), undefined, undefined, ts.factory.createArrowFunction(undefined, undefined, [
+            ts.factory.createParameterDeclaration(undefined, undefined, "queryClient", undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("QueryClient"))),
+            ...requestParams,
+        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier("queryClient.prefetchQuery"), undefined, [
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createArrayLiteralExpression([
+                    BuildCommonTypeName(queryKey),
+                    method.getParameters().length
+                        ? ts.factory.createArrayLiteralExpression([
+                            ts.factory.createObjectLiteralExpression(method
+                                .getParameters()
+                                .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                                .flat()),
+                        ])
+                        : ts.factory.createArrayLiteralExpression([]),
+                ], false)),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined, method.getParameters().length
+                    ? [
+                        ts.factory.createObjectLiteralExpression(method
+                            .getParameters()
+                            .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                            .flat()),
+                    ]
+                    : undefined))),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    return hookExport;
+}
+export const createPrefetch = ({ className, method, jsDoc, }) => {
+    const requestParam = getRequestParamFromMethod(method);
+    const requestParams = requestParam ? [requestParam] : [];
+    const prefetchHook = createPrefetchHook({
+        requestParams,
+        method,
+        className,
+    });
+    const hookWithJsDoc = addJSDocToNode(prefetchHook, jsDoc);
+    return {
+        prefetchHook: hookWithJsDoc,
+    };
+};

package/dist/createSource.mjs

@@ -0,0 +1,84 @@
+import ts from "typescript";
+import { Project } from "ts-morph";
+import { join } from "path";
+import { OpenApiRqFiles } from "./constants.mjs";
+import { createImports } from "./createImports.mjs";
+import { createExports } from "./createExports.mjs";
+import { getServices } from "./service.mjs";
+const createSourceFile = async (outputPath, serviceEndName) => {
+    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({
+        serviceEndName,
+        project,
+    });
+    const exports = createExports(service);
+    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 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);
+    return {
+        commonSource,
+        mainSource,
+        suspenseSource,
+        indexSource,
+        prefetchSource,
+    };
+};
+export const createSource = async ({ outputPath, version, serviceEndName, }) => {
+    const queriesFile = ts.createSourceFile(`${OpenApiRqFiles.queries}.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 printer = ts.createPrinter({
+        newLine: ts.NewLineKind.LineFeed,
+        removeComments: false,
+    });
+    const { commonSource, mainSource, suspenseSource, indexSource, prefetchSource, } = await createSourceFile(outputPath, serviceEndName);
+    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 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);
+    return [
+        {
+            name: `${OpenApiRqFiles.index}.ts`,
+            content: indexResult,
+        },
+        {
+            name: `${OpenApiRqFiles.common}.ts`,
+            content: commonResult,
+        },
+        {
+            name: `${OpenApiRqFiles.queries}.ts`,
+            content: mainResult,
+        },
+        {
+            name: `${OpenApiRqFiles.suspense}.ts`,
+            content: suspenseResult,
+        },
+        {
+            name: `${OpenApiRqFiles.prefetch}.ts`,
+            content: prefetchResult,
+        },
+    ];
+};

package/dist/createUseMutation.mjs

@@ -0,0 +1,85 @@
+import ts from "typescript";
+import { BuildCommonTypeName, TContext, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, } from "./common.mjs";
+import { addJSDocToNode } from "./util.mjs";
+/**
+ *  Awaited<ReturnType<typeof myClass.myMethod>>
+ */
+function generateAwaitedReturnType({ className, methodName, }) {
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReturnType"), [
+            ts.factory.createTypeQueryNode(ts.factory.createQualifiedName(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined),
+        ]),
+    ]);
+}
+export const createUseMutation = ({ className, method, jsDoc, }) => {
+    const methodName = getNameFromMethod(method);
+    const awaitedResponseDataType = generateAwaitedReturnType({
+        className,
+        methodName,
+    });
+    const mutationResult = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${className}${capitalizeFirstLetter(methodName)}MutationResult`), undefined, awaitedResponseDataType);
+    const responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(mutationResult.name)));
+    const methodParameters = method.getParameters().length !== 0
+        ? ts.factory.createTypeLiteralNode(method
+            .getParameters()
+            .map((param) => {
+            const paramNodes = extractPropertiesFromObjectParam(param);
+            return paramNodes.map((refParam) => ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(refParam.name), refParam.optional
+                ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+                : undefined, ts.factory.createTypeReferenceNode(getShortType(refParam.type.getText(param)))));
+        })
+            .flat())
+        : ts.factory.createKeywordTypeNode(ts.SyntaxKind.VoidKeyword);
+    const exportHook = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`use${className}${capitalizeFirstLetter(methodName)}`), undefined, undefined, ts.factory.createArrowFunction(undefined, ts.factory.createNodeArray([
+            responseDataType,
+            ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+            ts.factory.createTypeParameterDeclaration(undefined, TContext, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+        ]), [
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("options"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Omit"), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("UseMutationOptions"), [
+                    ts.factory.createTypeReferenceNode(TData),
+                    ts.factory.createTypeReferenceNode(TError),
+                    methodParameters,
+                    ts.factory.createTypeReferenceNode(TContext),
+                ]),
+                ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("mutationFn")),
+            ]), undefined),
+        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier("useMutation"), [
+            ts.factory.createTypeReferenceNode(TData),
+            ts.factory.createTypeReferenceNode(TError),
+            methodParameters,
+            ts.factory.createTypeReferenceNode(TContext),
+        ], [
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("mutationFn"), ts.factory.createArrowFunction(undefined, undefined, method.getParameters().length !== 0
+                    ? [
+                        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(method
+                            .getParameters()
+                            .map((param) => {
+                            const paramNodes = extractPropertiesFromObjectParam(param);
+                            return paramNodes.map((refParam) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(refParam.name), undefined));
+                        })
+                            .flat()), undefined, undefined, undefined),
+                    ]
+                    : [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createAsExpression(ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined, method.getParameters().length !== 0
+                    ? [
+                        ts.factory.createObjectLiteralExpression(method
+                            .getParameters()
+                            .map((params) => {
+                            const paramNodes = extractPropertiesFromObjectParam(params);
+                            return paramNodes.map((refParam) => ts.factory.createShorthandPropertyAssignment(refParam.name));
+                        })
+                            .flat()),
+                    ]
+                    : []), ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Promise"), [ts.factory.createTypeReferenceNode(TData)])))),
+                ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    const hookWithJsDoc = addJSDocToNode(exportHook, jsDoc);
+    return {
+        mutationResult,
+        mutationHook: hookWithJsDoc,
+    };
+};

package/dist/createUseQuery.mjs

@@ -0,0 +1,186 @@
+import ts from "typescript";
+import { BuildCommonTypeName, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, queryKeyConstraint, queryKeyGenericType, TData, TError, } from "./common.mjs";
+import { addJSDocToNode } from "./util.mjs";
+export const createApiResponseType = ({ className, methodName, }) => {
+    /** Awaited<ReturnType<typeof myClass.myMethod>> */
+    const awaitedResponseDataType = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Awaited"), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("ReturnType"), [
+            ts.factory.createTypeQueryNode(ts.factory.createQualifiedName(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined),
+        ]),
+    ]);
+    /** DefaultResponseDataType
+     * export type MyClassMethodDefaultResponse = Awaited<ReturnType<typeof myClass.myMethod>>
+     */
+    const apiResponse = ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(className)}${capitalizeFirstLetter(methodName)}DefaultResponse`), undefined, awaitedResponseDataType);
+    const responseDataType = ts.factory.createTypeParameterDeclaration(undefined, TData.text, undefined, ts.factory.createTypeReferenceNode(BuildCommonTypeName(apiResponse.name)));
+    return {
+        /** DefaultResponseDataType
+         * export type MyClassMethodDefaultResponse = Awaited<ReturnType<typeof myClass.myMethod>>
+         */
+        apiResponse,
+        /**
+         * will be the name of the type of the response type of the method
+         * MyClassMethodDefaultResponse
+         */
+        responseDataType,
+    };
+};
+export function getRequestParamFromMethod(method) {
+    if (!method.getParameters().length) {
+        return null;
+    }
+    const params = method
+        .getParameters()
+        .map((param) => {
+        const paramNodes = extractPropertiesFromObjectParam(param);
+        return paramNodes.map((refParam) => ({
+            name: refParam.name,
+            typeName: getShortType(refParam.type.getText()),
+            optional: refParam.optional,
+        }));
+    })
+        .flat();
+    const areAllPropertiesOptional = params.every((param) => param.optional);
+    return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(params.map((refParam) => ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier(refParam.name), undefined))), undefined, ts.factory.createTypeLiteralNode(params.map((refParam) => {
+        return ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(refParam.name), refParam.optional
+            ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+            : undefined, ts.factory.createTypeReferenceNode(refParam.typeName));
+    })), 
+    // 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);
+}
+/**
+ * Return Type
+ * export const classNameMethodNameQueryResult<TData = MyClassMethodDefaultResponse, TError = unknown> = UseQueryResult<TData, TError>;
+ */
+export function createReturnTypeExport({ className, methodName, defaultApiResponse, }) {
+    return ts.factory.createTypeAliasDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(`${capitalizeFirstLetter(className)}${capitalizeFirstLetter(methodName)}QueryResult`), [
+        ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(defaultApiResponse.name)),
+        ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+    ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("UseQueryResult"), [
+        ts.factory.createTypeReferenceNode(TData),
+        ts.factory.createTypeReferenceNode(TError),
+    ]));
+}
+/**
+ * QueryKey
+ */
+export function createQueryKeyExport({ className, 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(`${className}${capitalizeFirstLetter(methodName)}`)),
+    ], ts.NodeFlags.Const));
+}
+export function hookNameFromMethod({ method, className, }) {
+    const methodName = getNameFromMethod(method);
+    return `use${className}${capitalizeFirstLetter(methodName)}`;
+}
+export function createQueryKeyFromMethod({ method, className, }) {
+    const customHookName = hookNameFromMethod({ method, className });
+    const queryKey = `${customHookName}Key`;
+    return queryKey;
+}
+/**
+ * Creates a custom hook for a query
+ * @param queryString The type of query to use from react-query
+ * @param suffix The suffix to append to the hook name
+ */
+export function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, }) {
+    const methodName = getNameFromMethod(method);
+    const customHookName = hookNameFromMethod({ method, className });
+    const queryKey = createQueryKeyFromMethod({ method, className });
+    const hookExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`${customHookName}${suffix}`), undefined, undefined, ts.factory.createArrowFunction(undefined, ts.factory.createNodeArray([
+            responseDataType,
+            ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
+            ts.factory.createTypeParameterDeclaration(undefined, "TQueryKey", queryKeyConstraint, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))),
+        ]), [
+            ...requestParams,
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("queryKey"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), queryKeyGenericType),
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("options"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Omit"), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("UseQueryOptions"), [
+                    ts.factory.createTypeReferenceNode(TData),
+                    ts.factory.createTypeReferenceNode(TError),
+                ]),
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryKey")),
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryFn")),
+                ]),
+            ])),
+        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier(queryString), [
+            ts.factory.createTypeReferenceNode(TData),
+            ts.factory.createTypeReferenceNode(TError),
+        ], [
+            ts.factory.createObjectLiteralExpression([
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createArrayLiteralExpression([
+                    BuildCommonTypeName(queryKey),
+                    ts.factory.createSpreadElement(ts.factory.createParenthesizedExpression(ts.factory.createBinaryExpression(ts.factory.createIdentifier("queryKey"), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), method.getParameters().length
+                        ? ts.factory.createArrayLiteralExpression([
+                            ts.factory.createObjectLiteralExpression(method
+                                .getParameters()
+                                .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                                .flat()),
+                        ])
+                        : ts.factory.createArrayLiteralExpression([])))),
+                ], false)),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, [], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createAsExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(className), ts.factory.createIdentifier(methodName)), undefined, method.getParameters().length
+                    ? [
+                        ts.factory.createObjectLiteralExpression(method
+                            .getParameters()
+                            .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                            .flat()),
+                    ]
+                    : undefined), ts.factory.createTypeReferenceNode(TData)))),
+                ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
+            ]),
+        ]))),
+    ], ts.NodeFlags.Const));
+    return hookExport;
+}
+export const createUseQuery = ({ className, method, jsDoc, }) => {
+    const methodName = getNameFromMethod(method);
+    const queryKey = createQueryKeyFromMethod({ method, className });
+    const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
+        className,
+        methodName,
+    });
+    const requestParam = getRequestParamFromMethod(method);
+    const requestParams = requestParam ? [requestParam] : [];
+    const queryHook = createQueryHook({
+        queryString: "useQuery",
+        suffix: "",
+        responseDataType,
+        requestParams,
+        method,
+        className,
+    });
+    const suspenseQueryHook = createQueryHook({
+        queryString: "useSuspenseQuery",
+        suffix: "Suspense",
+        responseDataType,
+        requestParams,
+        method,
+        className,
+    });
+    const hookWithJsDoc = addJSDocToNode(queryHook, jsDoc);
+    const suspenseHookWithJsDoc = addJSDocToNode(suspenseQueryHook, jsDoc);
+    const returnTypeExport = createReturnTypeExport({
+        className,
+        methodName,
+        defaultApiResponse,
+    });
+    const queryKeyExport = createQueryKeyExport({
+        className,
+        methodName,
+        queryKey,
+    });
+    return {
+        apiResponse: defaultApiResponse,
+        returnType: returnTypeExport,
+        key: queryKeyExport,
+        queryHook: hookWithJsDoc,
+        suspenseQueryHook: suspenseHookWithJsDoc,
+    };
+};

package/dist/format.mjs

@@ -0,0 +1,21 @@
+import { IndentationText, NewLineKind, Project, QuoteKind } from "ts-morph";
+export const formatOutput = async (outputPath) => {
+    const project = new Project({
+        skipAddingFilesFromTsConfig: true,
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces,
+            newLineKind: NewLineKind.LineFeed,
+            quoteKind: QuoteKind.Double,
+            usePrefixAndSuffixTextForRename: false,
+            useTrailingCommas: true,
+        },
+    });
+    const sourceFiles = project.addSourceFilesAtPaths(`${outputPath}/**/*`);
+    const tasks = sourceFiles.map((sourceFile) => {
+        sourceFile.formatText();
+        sourceFile.fixMissingImports();
+        sourceFile.organizeImports();
+        return sourceFile.save();
+    });
+    await Promise.all(tasks);
+};

package/dist/generate.mjs

@@ -0,0 +1,44 @@
+import { createClient } from "@hey-api/openapi-ts";
+import { print } from "./print.mjs";
+import { createSource } from "./createSource.mjs";
+import { buildQueriesOutputPath, buildRequestsOutputPath, formatOptions, } from "./common.mjs";
+import { formatOutput } from "./format.mjs";
+export async function generate(options, version) {
+    const openApiOutputPath = buildRequestsOutputPath(options.output);
+    const formattedOptions = formatOptions(options);
+    const config = {
+        base: formattedOptions.base,
+        client: formattedOptions.client,
+        debug: formattedOptions.debug,
+        dryRun: false,
+        enums: formattedOptions.enums,
+        exportCore: true,
+        format: formattedOptions.format,
+        input: formattedOptions.input,
+        lint: formattedOptions.lint,
+        output: openApiOutputPath,
+        request: formattedOptions.request,
+        schemas: {
+            export: !formattedOptions.noSchemas,
+            type: formattedOptions.schemaType,
+        },
+        services: {
+            export: true,
+            response: formattedOptions.serviceResponse,
+        },
+        types: {
+            dates: formattedOptions.useDateType,
+            export: true,
+        },
+        useOptions: true,
+    };
+    await createClient(config);
+    const source = await createSource({
+        outputPath: openApiOutputPath,
+        version,
+        serviceEndName: "Service", // we are hard coding this because changing the service end name was depreciated in @hey-api/openapi-ts
+    });
+    await print(source, formattedOptions);
+    const queriesOutputPath = buildQueriesOutputPath(options.output);
+    await formatOutput(queriesOutputPath);
+}

package/dist/print.mjs

@@ -0,0 +1,22 @@
+import { mkdir, writeFile } from "fs/promises";
+import path from "path";
+import { buildQueriesOutputPath, exists } from "./common.mjs";
+async function printGeneratedTS(result, options) {
+    const dir = buildQueriesOutputPath(options.output);
+    const dirExists = await exists(dir);
+    if (!dirExists) {
+        await mkdir(dir, { recursive: true });
+    }
+    await writeFile(path.join(dir, result.name), result.content);
+}
+export async function print(results, options) {
+    const outputPath = options.output;
+    const dirExists = await exists(outputPath);
+    if (!dirExists) {
+        await mkdir(outputPath);
+    }
+    const promises = results.map(async (result) => {
+        await printGeneratedTS(result, options);
+    });
+    await Promise.all(promises);
+}

package/dist/service.mjs

@@ -0,0 +1,79 @@
+import ts from "typescript";
+import { getClassNameFromClassNode, getClassesFromService, } from "./common.mjs";
+import { serviceFileName } from "./constants.mjs";
+export async function getServices(project) {
+    const node = project
+        .getSourceFiles()
+        .find((sourceFile) => sourceFile.getFilePath().includes(serviceFileName));
+    if (!node) {
+        throw new Error("No service node found");
+    }
+    const klasses = getClassesFromService(node);
+    return {
+        klasses: klasses.map(({ klass, className }) => ({
+            className,
+            klass,
+            methods: getMethodsFromService(node, klass),
+        })),
+        node,
+    };
+}
+function getMethodsFromService(node, klass) {
+    const methods = klass.getMethods();
+    if (!methods.length) {
+        throw new Error("No methods found");
+    }
+    return methods.map((method) => {
+        const methodBlockNode = method.compilerNode
+            .getChildren(node.compilerNode)
+            .find((child) => child.kind === ts.SyntaxKind.Block);
+        if (!methodBlockNode) {
+            throw new Error("Method block not found");
+        }
+        const methodBlock = methodBlockNode;
+        const foundReturnStatement = methodBlock.statements.find((s) => s.kind === ts.SyntaxKind.ReturnStatement);
+        if (!foundReturnStatement) {
+            throw new Error("Return statement not found");
+        }
+        const returnStatement = foundReturnStatement;
+        const foundCallExpression = returnStatement.expression;
+        if (!foundCallExpression) {
+            throw new Error("Call expression not found");
+        }
+        const callExpression = foundCallExpression;
+        const properties = callExpression.arguments[1].properties;
+        const httpMethodName = properties
+            .find((p) => p.name?.getText(node.compilerNode) === "method")
+            ?.initializer?.getText(node.compilerNode);
+        if (!httpMethodName) {
+            throw new Error("httpMethodName not found");
+        }
+        const getAllChildren = (tsNode) => {
+            const childItems = tsNode.getChildren(node.compilerNode);
+            if (childItems.length) {
+                const allChildren = childItems.map(getAllChildren);
+                return [tsNode].concat(allChildren.flat());
+            }
+            return [tsNode];
+        };
+        const children = getAllChildren(method.compilerNode);
+        // get all JSDoc comments
+        // this should be an array of 1 or 0
+        const jsDocs = children
+            .filter((c) => c.kind === ts.SyntaxKind.JSDoc)
+            .map((c) => c.getText(node.compilerNode));
+        // get the first JSDoc comment
+        const jsDoc = jsDocs?.[0];
+        const isDeprecated = children.some((c) => c.kind === ts.SyntaxKind.JSDocDeprecatedTag);
+        const className = getClassNameFromClassNode(klass);
+        return {
+            className,
+            node,
+            method,
+            methodBlock,
+            httpMethodName,
+            jsDoc,
+            isDeprecated,
+        };
+    });
+}

package/dist/util.mjs

@@ -0,0 +1,16 @@
+import ts from "typescript";
+export function addJSDocToNode(node, jsDoc) {
+    if (!jsDoc) {
+        return node;
+    }
+    // replace the first /** with *
+    // we do this because ts.addSyntheticLeadingComment will add /* to the beginning but we want /**
+    const removedFirstLine = jsDoc.trim().replace(/^\/\*\*/, "*");
+    // remove the last */ because ts.addSyntheticLeadingComment will add it
+    const removedSecondLine = removedFirstLine.replace(/\*\/$/, "");
+    const split = removedSecondLine.split("\n");
+    const trimmed = split.map((line) => line.trim());
+    const joined = trimmed.join("\n");
+    const nodeWithJSDoc = ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, joined, true);
+    return nodeWithJSDoc;
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@7nohe/openapi-react-query-codegen",
+  "version": "0.0.0-c7f76ece287f3b22268170498e8fea9b0c797946",
+  "description": "OpenAPI React Query Codegen",
+  "bin": {
+    "openapi-rq": "dist/cli.mjs"
+  },
+  "type": "module",
+  "workspaces": [
+    "examples/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/7nohe/openapi-react-query-codegen.git"
+  },
+  "homepage": "https://github.com/7nohe/openapi-react-query-codegen",
+  "bugs": "https://github.com/7nohe/openapi-react-query-codegen/issues",
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "codegen",
+    "react-query",
+    "react",
+    "openapi",
+    "swagger",
+    "typescript",
+    "openapi-typescript-codegen",
+    "@hey-api/openapi-ts"
+  ],
+  "author": "Daiki Urata (@7nohe)",
+  "license": "MIT",
+  "devDependencies": {
+    "@hey-api/openapi-ts": "0.42.1",
+    "@types/node": "^20.10.6",
+    "@vitest/coverage-v8": "^1.5.0",
+    "commander": "^12.0.0",
+    "glob": "^10.3.10",
+    "rimraf": "^5.0.5",
+    "ts-morph": "^22.0.0",
+    "typescript": "^5.3.3",
+    "vitest": "^1.5.0"
+  },
+  "peerDependencies": {
+    "@hey-api/openapi-ts": "0.42.1",
+    "commander": "12.x",
+    "glob": "10.x",
+    "ts-morph": "22.x",
+    "typescript": "5.x"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "scripts": {
+    "build": "rimraf dist && tsc -p tsconfig.json",
+    "preview": "npm run build && npm -C examples/react-app run generate:api",
+    "release": "npx git-ensure -a && npx bumpp --commit --tag --push",
+    "test": "vitest --coverage.enabled true"
+  }
+}