@7nohe/openapi-react-query-codegen 1.1.0 → 1.2.0

package/README.md

@@ -45,13 +45,16 @@ Options:
   -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
-  --useDateType              Use Date type instead of string for date types for models, this will not convert the data to a Date object
-  --enums <value>            Generate JavaScript objects from enum definitions? ['javascript', 'typescript']
-  --base <value>             Manually set base in OpenAPI config instead of inferring from server value
-  --serviceResponse <value>  Define shape of returned value from service calls ['body', 'generics', 'response']
+  --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?
-  --lint                     Process output folder with linter?
-  --format                   Process output folder with formatter?
+  --serviceResponse <value>  Define shape of returned value from service calls ['body', 'generics', '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
 ```
 
@@ -86,11 +89,7 @@ function App() {
   return (
     <div className="App">
       <h1>Pet List</h1>
-      <ul>
-        {data?.map((pet) => (
-          <li key={pet.id}>{pet.name}</li>
-        ))}
-      </ul>
+      <ul>{data?.map((pet) => <li key={pet.id}>{pet.name}</li>)}</ul>
     </div>
   );
 }
@@ -129,13 +128,7 @@ 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>
-  );
+  return <ul>{data?.map((pet, index) => <li key={pet.id}>{pet.name}</li>)}</ul>;
 }
 
 function ParentComponent() {

package/dist/cli.mjs

@@ -4,6 +4,7 @@ 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);
@@ -16,18 +17,21 @@ async function setupProgram() {
         .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", "openapi")
+        .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")
-        .option("--format", "Process output folder with formatter?")
-        .option("--lint", "Process output folder with linter?")
+        .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", "generics", "response"]))
+        .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);

package/dist/common.mjs

@@ -1,5 +1,7 @@
 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");
@@ -14,7 +16,11 @@ export const lowercaseFirstLetter = (str) => {
     return str.charAt(0).toLowerCase() + str.slice(1);
 };
 export const getNameFromMethod = (method) => {
-    return method.getName();
+    const methodName = method.getName();
+    if (!methodName) {
+        throw new Error("Method name not found");
+    }
+    return methodName;
 };
 export async function exists(f) {
     try {
@@ -62,3 +68,68 @@ export function extractPropertiesFromObjectParam(param) {
     }));
     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

@@ -1,3 +1,5 @@
 export const defaultOutputPath = "openapi";
 export const queriesOutputPath = "queries";
 export const requestsOutputPath = "requests";
+export const serviceFileName = "services.gen";
+export const modalsFileName = "types.gen";

package/dist/createImports.mjs

@@ -1,27 +1,22 @@
 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("models.ts"));
-    const serviceFile = project
-        .getSourceFiles()
-        .find((sourceFile) => sourceFile.getFilePath().includes("services.ts"));
+        .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.`);
     }
-    if (!serviceFile) {
-        throw new Error("No service file found");
-    }
     const modelNames = modelsFile
         ? Array.from(modelsFile.getExportedDeclarations().keys())
         : [];
     const serviceExports = Array.from(serviceFile.getExportedDeclarations().keys());
     const serviceNames = serviceExports.filter((name) => name.endsWith(serviceEndName));
-    const serviceNamesData = serviceExports.filter((name) => name.endsWith("Data"));
     const imports = [
         ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([
             ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier("useQuery")),
@@ -35,15 +30,13 @@ export const createImports = ({ serviceEndName, project, }) => {
         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))),
-            // import all data objects from service file
-            ...serviceNamesData.map((dataName) => ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(dataName))),
-        ])), ts.factory.createStringLiteral(join("../requests")), undefined),
+        ])), 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/models")), undefined));
+        ])), ts.factory.createStringLiteral(join("../requests/", modalsFileName)), undefined));
     }
     return imports;
 };

package/dist/createSource.mjs

@@ -44,13 +44,14 @@ export const createSource = async ({ outputPath, version, serviceEndName, }) =>
         removeComments: false,
     });
     const { commonSource, mainSource, suspenseSource, indexSource } = await createSourceFile(outputPath, serviceEndName);
-    const commonResult = `// generated with @7nohe/openapi-react-query-codegen@${version} \n` +
+    const comment = `// generated with @7nohe/openapi-react-query-codegen@${version} \n\n`;
+    const commonResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, commonSource, commonFile);
-    const mainResult = `// generated with @7nohe/openapi-react-query-codegen@${version} \n` +
+    const mainResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, mainSource, queriesFile);
-    const suspenseResult = `// generated with @7nohe/openapi-react-query-codegen@${version} \n` +
+    const suspenseResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, suspenseSource, suspenseFile);
-    const indexResult = `// generated with @7nohe/openapi-react-query-codegen@${version} \n` +
+    const indexResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, indexSource, indexFile);
     return [
         {

package/dist/createUseMutation.mjs

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { BuildCommonTypeName, TContext, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, } from "./common.mjs";
+import { BuildCommonTypeName, TContext, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, } from "./common.mjs";
 import { addJSDocToNode } from "./util.mjs";
 /**
  *  Awaited<ReturnType<typeof myClass.myMethod>>
@@ -11,7 +11,7 @@ function generateAwaitedReturnType({ className, methodName, }) {
         ]),
     ]);
 }
-export const createUseMutation = ({ node, className, method, jsDoc = [], isDeprecated = false, }) => {
+export const createUseMutation = ({ className, method, jsDoc, }) => {
     const methodName = getNameFromMethod(method);
     const awaitedResponseDataType = generateAwaitedReturnType({
         className,
@@ -26,22 +26,9 @@ export const createUseMutation = ({ node, className, method, jsDoc = [], isDepre
             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, 
-            // refParam.questionToken ?? refParam.initializer
-            //   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-            //   : refParam.questionToken,
-            ts.factory.createTypeReferenceNode(refParam.type.getText(param))));
+                : undefined, ts.factory.createTypeReferenceNode(getShortType(refParam.type.getText(param)))));
         })
-            .flat()
-        // return ts.factory.createPropertySignature(
-        //   undefined,
-        //   ts.factory.createIdentifier(param.getName()),
-        //   param.compilerNode.questionToken ?? param.compilerNode.initializer
-        //     ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-        //     : param.compilerNode.questionToken,
-        //   param.compilerNode.type
-        // );
-        )
+            .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([
@@ -90,7 +77,7 @@ export const createUseMutation = ({ node, className, method, jsDoc = [], isDepre
             ]),
         ]))),
     ], ts.NodeFlags.Const));
-    const hookWithJsDoc = addJSDocToNode(exportHook, node, isDeprecated, jsDoc);
+    const hookWithJsDoc = addJSDocToNode(exportHook, jsDoc);
     return {
         mutationResult,
         mutationHook: hookWithJsDoc,

package/dist/createUseQuery.mjs

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { BuildCommonTypeName, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, queryKeyConstraint, queryKeyGenericType, TData, TError, } from "./common.mjs";
+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>> */
@@ -25,14 +25,6 @@ export const createApiResponseType = ({ className, methodName, }) => {
         responseDataType,
     };
 };
-/**
- * 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.
- */
-function getShortType(type) {
-    return type.replaceAll(/import\("[a-zA-Z\/\.-]*"\)\./g, "");
-}
 export function getRequestParamFromMethod(method) {
     if (!method.getParameters().length) {
         return null;
@@ -52,11 +44,7 @@ export function getRequestParamFromMethod(method) {
     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, 
-        // param.hasQuestionToken() ?? param.getInitializer()?.compilerNode
-        //   ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-        //   : param.getQuestionTokenNode()?.compilerNode,
-        ts.factory.createTypeReferenceNode(refParam.typeName));
+            : 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
@@ -151,7 +139,7 @@ function createQueryHook({ queryString, suffix, responseDataType, requestParams,
     ], ts.NodeFlags.Const));
     return hookExport;
 }
-export const createUseQuery = ({ node, className, method, jsDoc = [], isDeprecated: deprecated = false, }) => {
+export const createUseQuery = ({ className, method, jsDoc, }) => {
     const methodName = getNameFromMethod(method);
     const queryKey = createQueryKeyFromMethod({ method, className });
     const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
@@ -176,8 +164,8 @@ export const createUseQuery = ({ node, className, method, jsDoc = [], isDeprecat
         method,
         className,
     });
-    const hookWithJsDoc = addJSDocToNode(queryHook, node, deprecated, jsDoc);
-    const suspenseHookWithJsDoc = addJSDocToNode(suspenseQueryHook, node, deprecated, jsDoc);
+    const hookWithJsDoc = addJSDocToNode(queryHook, jsDoc);
+    const suspenseHookWithJsDoc = addJSDocToNode(suspenseQueryHook, jsDoc);
     const returnTypeExport = createReturnTypeExport({
         className,
         methodName,

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

@@ -1,40 +1,36 @@
 import { createClient } from "@hey-api/openapi-ts";
 import { print } from "./print.mjs";
-import path from "path";
 import { createSource } from "./createSource.mjs";
-import { defaultOutputPath, requestsOutputPath } from "./constants.mjs";
-import { safeParseNumber } from "./common.mjs";
+import { buildQueriesOutputPath, buildRequestsOutputPath, formatOptions, } from "./common.mjs";
+import { formatOutput } from "./format.mjs";
 export async function generate(options, version) {
-    const openApiOutputPath = path.join(options.output ?? defaultOutputPath, requestsOutputPath);
-    // 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 (!isNaN(parsedNumber)) {
-            acc[typedKey] = parsedNumber;
-        }
-        else if (value === "true") {
-            acc[typedKey] = true;
-        }
-        else if (value === "false") {
-            acc[typedKey] = false;
-        }
-        else {
-            acc[typedKey] = typedValue;
-        }
-        return acc;
-    }, options);
+    const openApiOutputPath = buildRequestsOutputPath(options.output);
+    const formattedOptions = formatOptions(options);
     const config = {
-        ...formattedOptions,
+        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,
-        exportCore: true,
-        exportModels: true,
-        exportServices: true,
-        write: true,
     };
     await createClient(config);
     const source = await createSource({
@@ -43,4 +39,6 @@ export async function generate(options, 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

@@ -1,9 +1,8 @@
 import { mkdir, writeFile } from "fs/promises";
 import path from "path";
-import { defaultOutputPath, queriesOutputPath } from "./constants.mjs";
-import { exists } from "./common.mjs";
+import { buildQueriesOutputPath, exists } from "./common.mjs";
 async function printGeneratedTS(result, options) {
-    const dir = path.join(options.output ?? defaultOutputPath, queriesOutputPath);
+    const dir = buildQueriesOutputPath(options.output);
     const dirExists = await exists(dir);
     if (!dirExists) {
         await mkdir(dir, { recursive: true });
@@ -11,7 +10,7 @@ async function printGeneratedTS(result, options) {
     await writeFile(path.join(dir, result.name), result.content);
 }
 export async function print(results, options) {
-    const outputPath = options.output ?? defaultOutputPath;
+    const outputPath = options.output;
     const dirExists = await exists(outputPath);
     if (!dirExists) {
         await mkdir(outputPath);

package/dist/service.mjs

@@ -1,8 +1,10 @@
 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("services.ts"));
+        .find((sourceFile) => sourceFile.getFilePath().includes(serviceFileName));
     if (!node) {
         throw new Error("No service node found");
     }
@@ -16,29 +18,6 @@ export async function getServices(project) {
         node,
     };
 }
-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,
-        };
-    });
-}
-function getClassNameFromClassNode(klass) {
-    const className = klass.getName();
-    if (!className) {
-        throw new Error("Class name not found");
-    }
-    return className;
-}
 function getMethodsFromService(node, klass) {
     const methods = klass.getMethods();
     if (!methods.length) {
@@ -78,7 +57,13 @@ function getMethodsFromService(node, klass) {
             return [tsNode];
         };
         const children = getAllChildren(method.compilerNode);
-        const jsDoc = method.getJsDocs().map((jsDoc) => jsDoc);
+        // 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 {

package/dist/util.mjs

@@ -1,28 +1,16 @@
 import ts from "typescript";
-export function addJSDocToNode(node, sourceFile, deprecated, jsDoc = []) {
-    const deprecatedString = deprecated ? "@deprecated" : "";
-    const jsDocString = [deprecatedString]
-        .concat(jsDoc.map((comment) => {
-        if (typeof comment === "string") {
-            return comment;
-        }
-        if (Array.isArray(comment)) {
-            return comment.map((c) => c.getText(sourceFile)).join("\n");
-        }
-        return "";
-    }))
-        // remove empty lines
-        .filter(Boolean)
-        // trim
-        .map((comment) => comment.trim())
-        // add * to each line
-        .map((comment) => `* ${comment}`)
-        // join lines
-        .join("\n")
-        // replace new lines with \n *
-        .replace(/\n/g, "\n * ");
-    const nodeWithJSDoc = jsDocString
-        ? ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, `*\n ${jsDocString}\n `, true)
-        : node;
+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

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "OpenAPI React Query Codegen",
   "bin": {
     "openapi-rq": "dist/cli.mjs"
@@ -31,20 +31,22 @@
   "author": "Daiki Urata (@7nohe)",
   "license": "MIT",
   "devDependencies": {
-    "@hey-api/openapi-ts": "0.36.0",
+    "@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"
+    "typescript": "^5.3.3",
+    "vitest": "^1.5.0"
   },
   "peerDependencies": {
-    "@hey-api/openapi-ts": "0.36.0",
-    "commander": ">= 11 < 13",
-    "glob": ">= 10",
-    "ts-morph": ">= 22 < 23",
-    "typescript": ">= 4.8.3"
+    "@hey-api/openapi-ts": "0.42.1",
+    "commander": "12.x",
+    "glob": "10.x",
+    "ts-morph": "22.x",
+    "typescript": "5.x"
   },
   "engines": {
     "node": ">=14"
@@ -52,6 +54,7 @@
   "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"
+    "release": "npx git-ensure -a && npx bumpp --commit --tag --push",
+    "test": "vitest --coverage.enabled true"
   }
 }