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

package/README.md

@@ -2,13 +2,15 @@
 
 > Node.js library that generates [React Query (also called TanStack Query)](https://tanstack.com/query) hooks based on an OpenAPI specification file.
 
+[![npm version](https://badge.fury.io/js/%407nohe%2Fopenapi-react-query-codegen.svg)](https://badge.fury.io/js/%407nohe%2Fopenapi-react-query-codegen)
+
 ## 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)
+- Generates custom react hooks that use React Query's `useQuery`, `useSuspenseQuery` and `useMutation` hooks
+- Generates query keys and functions for query caching
+- Generates pure TypeScript clients generated by [@hey-api/openapi-ts](https://github.com/hey-api/openapi-ts)
 
-## Install
+## Installation
 
 ```
 $ npm install -D @7nohe/openapi-react-query-codegen
@@ -45,37 +47,45 @@ 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', 'response'] (default: "body")
+  --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
+### Example Usage
 
-### Command
+#### Command
 
 ```
 $ openapi-rq -i ./petstore.yaml
 ```
 
-### Output directory structure
+#### Output directory structure
 
 ```
 - openapi
   - queries
-    - index.ts <- main file that exports common types, variables, and hooks
+    - 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
 ```
 
-### In your app
+- [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
@@ -86,11 +96,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>
   );
 }
@@ -98,7 +104,7 @@ function App() {
 export default App;
 ```
 
-You can also use pure TS clients.
+##### Using the generated typescript client
 
 ```tsx
 import { useQuery } from "@tanstack/react-query";
@@ -121,7 +127,7 @@ function App() {
 export default App;
 ```
 
-You can also use suspense hooks.
+##### Using Suspense Hooks
 
 ```tsx
 // App.tsx
@@ -129,13 +135,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() {
@@ -160,6 +160,34 @@ function App() {
 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

@@ -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,23 @@ 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"])
+        .default("body"))
         .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,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

@@ -1,5 +1,6 @@
 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();
@@ -9,6 +10,7 @@ export const createExports = (service) => {
     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));
@@ -36,6 +38,10 @@ export const createExports = (service) => {
         .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
@@ -49,5 +55,9 @@ export const createExports = (service) => {
          * 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

@@ -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/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

@@ -1,9 +1,10 @@
 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";
-import { Project } from "ts-morph";
-import { join } from "path";
 const createSourceFile = async (outputPath, serviceEndName) => {
     const project = new Project({
         // Optionally specify compiler options, tsconfig.json, in-memory file system, and more here.
@@ -21,53 +22,63 @@ const createSourceFile = async (outputPath, serviceEndName) => {
     });
     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("./common"), undefined);
-    const commonExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral("./common"), undefined);
-    const queriesExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral("./queries"), undefined);
+    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("queries.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const commonFile = ts.createSourceFile("common.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const suspenseFile = ts.createSourceFile("suspense.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
-    const indexFile = ts.createSourceFile("index.ts", "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+    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 } = await createSourceFile(outputPath, serviceEndName);
-    const commonResult = `// generated with @7nohe/openapi-react-query-codegen@${version} \n` +
+    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 = `// 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);
+    const prefetchResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, prefetchSource, prefetchFile);
     return [
         {
-            name: "index.ts",
+            name: `${OpenApiRqFiles.index}.ts`,
             content: indexResult,
         },
         {
-            name: "common.ts",
+            name: `${OpenApiRqFiles.common}.ts`,
             content: commonResult,
         },
         {
-            name: "queries.ts",
+            name: `${OpenApiRqFiles.queries}.ts`,
             content: mainResult,
         },
         {
-            name: "suspense.ts",
+            name: `${OpenApiRqFiles.suspense}.ts`,
             content: suspenseResult,
         },
+        {
+            name: `${OpenApiRqFiles.prefetch}.ts`,
+            content: prefetchResult,
+        },
     ];
 };

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
@@ -85,11 +73,11 @@ export function createQueryKeyExport({ className, methodName, queryKey, }) {
         ts.factory.createVariableDeclaration(ts.factory.createIdentifier(queryKey), undefined, undefined, ts.factory.createStringLiteral(`${className}${capitalizeFirstLetter(methodName)}`)),
     ], ts.NodeFlags.Const));
 }
-function hookNameFromMethod({ method, className, }) {
+export function hookNameFromMethod({ method, className, }) {
     const methodName = getNameFromMethod(method);
     return `use${className}${capitalizeFirstLetter(methodName)}`;
 }
-function createQueryKeyFromMethod({ method, className, }) {
+export function createQueryKeyFromMethod({ method, className, }) {
     const customHookName = hookNameFromMethod({ method, className });
     const queryKey = `${customHookName}Key`;
     return queryKey;
@@ -99,7 +87,7 @@ function createQueryKeyFromMethod({ method, className, }) {
  * @param queryString The type of query to use from react-query
  * @param suffix The suffix to append to the hook name
  */
-function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, }) {
+export function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, }) {
     const methodName = getNameFromMethod(method);
     const customHookName = hookNameFromMethod({ method, className });
     const queryKey = createQueryKeyFromMethod({ method, className });
@@ -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.1",
   "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"
   }
 }