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

package/README.md

@@ -160,6 +160,80 @@ function App() {
 export default App;
 ```
 
+##### Using Mutation hooks
+
+```tsx
+// App.tsx
+import { usePetServiceAddPet } from "../openapi/queries";
+
+function App() {
+  const { mutate } = usePetServiceAddPet();
+
+  const handleAddPet = () => {
+    mutate({ name: "Fluffy", status: "available" });
+  };
+
+  return (
+    <div className="App">
+      <h1>Add Pet</h1>
+      <button onClick={handleAddPet}>Add Pet</button>
+    </div>
+  );
+}
+
+export default App;
+```
+
+##### Invalidating queries after mutation
+
+Invalidating queries after a mutation is important to ensure the cache is updated with the new data. This is done by calling the `queryClient.invalidateQueries` function with the query key used by the query hook.
+
+Learn more about invalidating queries [here](https://tanstack.com/query/latest/docs/framework/react/guides/query-invalidation).
+
+To ensure the query key is created the same way as the query hook, you can use the query key function exported by the generated query hooks.
+
+```tsx
+import {
+  usePetServiceFindPetsByStatus,
+  usePetServiceAddPet,
+  UsePetServiceFindPetsByStatusKeyFn,
+} from "../openapi/queries";
+
+// App.tsx
+function App() {
+  const [status, setStatus] = React.useState(["available"]);
+  const { data } = usePetServiceFindPetsByStatus({ status });
+  const { mutate } = usePetServiceAddPet({
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        // Call the query key function to get the query key
+        // This is important to ensure the query key is created the same way as the query hook
+        // This insures the cache is invalidated correctly and is typed correctly
+        queryKey: [UsePetServiceFindPetsByStatusKeyFn({
+          status
+        })],
+      });
+    },
+  });
+
+  return (
+    <div className="App">
+      <h1>Pet List</h1>
+      <ul>{data?.map((pet) => <li key={pet.id}>{pet.name}</li>)}</ul>
+      <button
+        onClick={() => {
+          mutate({ name: "Fluffy", status: "available" });
+        }}
+      >
+        Add Pet
+      </button>
+    </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.
@@ -188,6 +262,39 @@ ReactDOM.createRoot(document.getElementById("root") as HTMLElement).render(
 
 ```
 
+## Development
+
+### Install dependencies
+
+```bash
+pnpm install
+```
+
+### Run tests
+```bash
+pnpm test
+```
+
+### Run linter
+```bash
+pnpm lint
+```
+
+### Run linter and fix
+```bash
+pnpm lint:fix
+```
+
+### Update snapshots
+```bash
+pnpm snapshot
+```
+
+### Build example and validate generated code
+```bash
+npm run build && pnpm --filter @7nohe/react-app generate:api && pnpm --filter @7nohe/react-app test:generated 
+```
+
 ## License
 
 MIT

package/dist/cli.mjs

@@ -1,10 +1,10 @@
 #!/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 { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { Command, Option } from "commander";
 import { defaultOutputPath } from "./constants.mjs";
+import { generate } from "./generate.mjs";
 const program = new Command();
 async function setupProgram() {
     const __filename = fileURLToPath(import.meta.url);

package/dist/common.mjs

@@ -1,10 +1,12 @@
-import { stat } from "fs/promises";
+import { stat } from "node:fs/promises";
+import path from "node:path";
 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 EqualsOrGreaterThanToken = ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken);
+export const QuestionToken = ts.factory.createToken(ts.SyntaxKind.QuestionToken);
 export const queryKeyGenericType = ts.factory.createTypeReferenceNode("TQueryKey");
 export const queryKeyConstraint = ts.factory.createTypeReferenceNode("Array", [
     ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
@@ -49,10 +51,10 @@ export function BuildCommonTypeName(name) {
  */
 export function safeParseNumber(value) {
     const parsed = Number(value);
-    if (!isNaN(parsed) && isFinite(parsed)) {
+    if (!Number.isNaN(parsed) && Number.isFinite(parsed)) {
         return parsed;
     }
-    return NaN;
+    return Number.NaN;
 }
 export function extractPropertiesFromObjectParam(param) {
     const referenced = param.findReferences()[0];
@@ -117,7 +119,7 @@ export function formatOptions(options) {
         else if (value === "false" || value === false) {
             acc[typedKey] = false;
         }
-        else if (!isNaN(parsedNumber)) {
+        else if (!Number.isNaN(parsedNumber)) {
             acc[typedKey] = parsedNumber;
         }
         else {

package/dist/createExports.mjs

@@ -1,9 +1,9 @@
-import { createUseQuery } from "./createUseQuery.mjs";
-import { createUseMutation } from "./createUseMutation.mjs";
 import { createPrefetch } from "./createPrefetch.mjs";
+import { createUseMutation } from "./createUseMutation.mjs";
+import { createUseQuery } from "./createUseQuery.mjs";
 export const createExports = (service) => {
     const { klasses } = service;
-    const methods = klasses.map((k) => k.methods).flat();
+    const methods = klasses.flatMap((k) => k.methods);
     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"));
@@ -22,25 +22,28 @@ export const createExports = (service) => {
         ...allPatchMutations,
         ...allDeleteMutations,
     ];
-    const commonInQueries = allQueries
-        .map(({ apiResponse, returnType, key }) => [apiResponse, returnType, key])
-        .flat();
-    const commonInMutations = allMutations
-        .map(({ mutationResult }) => [mutationResult])
-        .flat();
+    const commonInQueries = allQueries.flatMap(({ apiResponse, returnType, key, queryKeyFn }) => [
+        apiResponse,
+        returnType,
+        key,
+        queryKeyFn,
+    ]);
+    const commonInMutations = allMutations.flatMap(({ mutationResult }) => [
+        mutationResult,
+    ]);
     const allCommon = [...commonInQueries, ...commonInMutations];
-    const mainQueries = allQueries.map(({ queryHook }) => [queryHook]).flat();
-    const mainMutations = allMutations
-        .map(({ mutationHook }) => [mutationHook])
-        .flat();
+    const mainQueries = allQueries.flatMap(({ queryHook }) => [queryHook]);
+    const mainMutations = allMutations.flatMap(({ mutationHook }) => [
+        mutationHook,
+    ]);
     const mainExports = [...mainQueries, ...mainMutations];
-    const suspenseQueries = allQueries
-        .map(({ suspenseQueryHook }) => [suspenseQueryHook])
-        .flat();
+    const suspenseQueries = allQueries.flatMap(({ suspenseQueryHook }) => [
+        suspenseQueryHook,
+    ]);
     const suspenseExports = [...suspenseQueries];
-    const allPrefetches = allPrefetchQueries
-        .map(({ prefetchHook }) => [prefetchHook])
-        .flat();
+    const allPrefetches = allPrefetchQueries.flatMap(({ prefetchHook }) => [
+        prefetchHook,
+    ]);
     const allPrefetchExports = [...allPrefetches];
     return {
         /**

package/dist/createImports.mjs

@@ -1,5 +1,5 @@
+import { posix } from "node:path";
 import ts from "typescript";
-import { posix } from "path";
 import { modalsFileName, serviceFileName } from "./constants.mjs";
 const { join } = posix;
 export const createImports = ({ serviceEndName, project, }) => {
@@ -19,6 +19,7 @@ export const createImports = ({ serviceEndName, project, }) => {
     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(true, undefined, ts.factory.createIdentifier("QueryClient")),
             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")),

package/dist/createPrefetch.mjs

@@ -25,8 +25,7 @@ function createPrefetchHook({ requestParams, method, className, }) {
                         ? ts.factory.createArrayLiteralExpression([
                             ts.factory.createObjectLiteralExpression(method
                                 .getParameters()
-                                .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
-                                .flat()),
+                                .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
                         ])
                         : ts.factory.createArrayLiteralExpression([]),
                 ], false)),
@@ -34,8 +33,7 @@ function createPrefetchHook({ requestParams, method, className, }) {
                     ? [
                         ts.factory.createObjectLiteralExpression(method
                             .getParameters()
-                            .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
-                            .flat()),
+                            .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
                     ]
                     : undefined))),
             ]),

package/dist/createSource.mjs

@@ -1,9 +1,9 @@
-import ts from "typescript";
+import { join } from "node:path";
 import { Project } from "ts-morph";
-import { join } from "path";
+import ts from "typescript";
 import { OpenApiRqFiles } from "./constants.mjs";
-import { createImports } from "./createImports.mjs";
 import { createExports } from "./createExports.mjs";
+import { createImports } from "./createImports.mjs";
 import { getServices } from "./service.mjs";
 const createSourceFile = async (outputPath, serviceEndName) => {
     const project = new Project({

package/dist/createUseMutation.mjs

@@ -20,15 +20,12 @@ export const createUseMutation = ({ className, method, jsDoc, }) => {
     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) => {
+        ? ts.factory.createTypeLiteralNode(method.getParameters().flatMap((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([
@@ -54,23 +51,17 @@ export const createUseMutation = ({ className, method, jsDoc, }) => {
             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) => {
+                        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern(method.getParameters().flatMap((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, 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) => {
+                        ts.factory.createObjectLiteralExpression(method.getParameters().flatMap((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")),

package/dist/createUseQuery.mjs

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { BuildCommonTypeName, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, queryKeyConstraint, queryKeyGenericType, TData, TError, } from "./common.mjs";
+import { BuildCommonTypeName, EqualsOrGreaterThanToken, QuestionToken, TData, TError, capitalizeFirstLetter, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, queryKeyConstraint, queryKeyGenericType, } from "./common.mjs";
 import { addJSDocToNode } from "./util.mjs";
 export const createApiResponseType = ({ className, methodName, }) => {
     /** Awaited<ReturnType<typeof myClass.myMethod>> */
@@ -14,12 +14,15 @@ export const createApiResponseType = ({ className, methodName, }) => {
     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
+        /**
+         * DefaultResponseDataType
+         *
          * export type MyClassMethodDefaultResponse = Awaited<ReturnType<typeof myClass.myMethod>>
          */
         apiResponse,
         /**
-         * will be the name of the type of the response type of the method
+         * This will be the name of the type of the response type of the method
+         *
          * MyClassMethodDefaultResponse
          */
         responseDataType,
@@ -29,17 +32,14 @@ export function getRequestParamFromMethod(method) {
     if (!method.getParameters().length) {
         return null;
     }
-    const params = method
-        .getParameters()
-        .map((param) => {
+    const params = method.getParameters().flatMap((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
@@ -54,6 +54,7 @@ export function getRequestParamFromMethod(method) {
 }
 /**
  * Return Type
+ *
  * export const classNameMethodNameQueryResult<TData = MyClassMethodDefaultResponse, TError = unknown> = UseQueryResult<TData, TError>;
  */
 export function createReturnTypeExport({ className, methodName, defaultApiResponse, }) {
@@ -109,28 +110,24 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
                     ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryFn")),
                 ]),
             ])),
-        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier(queryString), [
+        ], undefined, EqualsOrGreaterThanToken, 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.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createCallExpression(BuildCommonTypeName(getQueryKeyFnName(queryKey)), undefined, method.getParameters().length
+                    ? [
+                        ts.factory.createObjectLiteralExpression(method
+                            .getParameters()
+                            .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
+                        ts.factory.createIdentifier("queryKey"),
+                    ]
+                    : [])),
+                ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, [], undefined, EqualsOrGreaterThanToken, 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()),
+                            .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
                     ]
                     : undefined), ts.factory.createTypeReferenceNode(TData)))),
                 ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
@@ -176,11 +173,42 @@ export const createUseQuery = ({ className, method, jsDoc, }) => {
         methodName,
         queryKey,
     });
+    const queryKeyFn = createQueryKeyFnExport(queryKey, method);
     return {
         apiResponse: defaultApiResponse,
         returnType: returnTypeExport,
         key: queryKeyExport,
         queryHook: hookWithJsDoc,
         suspenseQueryHook: suspenseHookWithJsDoc,
+        queryKeyFn,
     };
 };
+function getQueryKeyFnName(queryKey) {
+    return `${capitalizeFirstLetter(queryKey)}Fn`;
+}
+function createQueryKeyFnExport(queryKey, method) {
+    const params = getRequestParamFromMethod(method);
+    // override key is used to allow the user to override the the queryKey values
+    const overrideKey = ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("queryKey"), QuestionToken, ts.factory.createTypeReferenceNode("Array<unknown>", []));
+    return ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+        ts.factory.createVariableDeclaration(ts.factory.createIdentifier(getQueryKeyFnName(queryKey)), undefined, undefined, ts.factory.createArrowFunction(undefined, undefined, params ? [params, overrideKey] : [], undefined, EqualsOrGreaterThanToken, queryKeyFn(queryKey, method))),
+    ], ts.NodeFlags.Const));
+}
+function queryKeyFn(queryKey, method) {
+    const params = getRequestParamFromMethod(method);
+    if (!params) {
+        return ts.factory.createArrayLiteralExpression([
+            ts.factory.createIdentifier(queryKey),
+        ]);
+    }
+    return ts.factory.createArrayLiteralExpression([
+        ts.factory.createIdentifier(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()
+                    .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
+            ])
+            : ts.factory.createArrayLiteralExpression([])))),
+    ], false);
+}

package/dist/generate.mjs

@@ -1,8 +1,8 @@
 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 { createSource } from "./createSource.mjs";
 import { formatOutput } from "./format.mjs";
+import { print } from "./print.mjs";
 export async function generate(options, version) {
     const openApiOutputPath = buildRequestsOutputPath(options.output);
     const formattedOptions = formatOptions(options);
@@ -11,7 +11,6 @@ export async function generate(options, version) {
         client: formattedOptions.client,
         debug: formattedOptions.debug,
         dryRun: false,
-        enums: formattedOptions.enums,
         exportCore: true,
         format: formattedOptions.format,
         input: formattedOptions.input,
@@ -29,6 +28,7 @@ export async function generate(options, version) {
         types: {
             dates: formattedOptions.useDateType,
             export: true,
+            enums: formattedOptions.enums,
         },
         useOptions: true,
     };

package/dist/print.mjs

@@ -1,5 +1,5 @@
-import { mkdir, writeFile } from "fs/promises";
-import path from "path";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
 import { buildQueriesOutputPath, exists } from "./common.mjs";
 async function printGeneratedTS(result, options) {
     const dir = buildQueriesOutputPath(options.output);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "1.2.1",
+  "version": "1.3.0",
   "description": "OpenAPI React Query Codegen",
   "bin": {
     "openapi-rq": "dist/cli.mjs"
@@ -30,19 +30,22 @@
   ],
   "author": "Daiki Urata (@7nohe)",
   "license": "MIT",
+  "dependencies": {
+    "@hey-api/openapi-ts": "0.43.0"
+  },
   "devDependencies": {
-    "@hey-api/openapi-ts": "0.42.1",
+    "@biomejs/biome": "^1.7.2",
     "@types/node": "^20.10.6",
     "@vitest/coverage-v8": "^1.5.0",
     "commander": "^12.0.0",
     "glob": "^10.3.10",
+    "lefthook": "^1.6.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",
@@ -53,8 +56,11 @@
   },
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.json",
+    "lint": "biome check .",
+    "lint:fix": "biome check --apply .",
     "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"
+    "test": "vitest --coverage.enabled true",
+    "snapshot": "vitest --update"
   }
 }