@7nohe/openapi-react-query-codegen 1.6.0 → 1.6.2

package/README.md

@@ -7,6 +7,7 @@
 ## Features
 
 - Generates custom react hooks that use React Query's `useQuery`, `useSuspenseQuery`, `useMutation` and `useInfiniteQuery` hooks
+- Generates custom functions that use React Query's `ensureQueryData` and `prefetchQuery` functions
 - 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)
 
@@ -42,24 +43,25 @@ Usage: openapi-rq [options]
 Generate React Query code based on OpenAPI
 
 Options:
-  -V, --version              output the version number
-  -i, --input <value>        OpenAPI specification, can be a path, url or string content (required)
-  -o, --output <value>       Output directory (default: "openapi")
-  -c, --client <value>       HTTP client to generate (choices: "angular", "axios", "fetch", "node", "xhr", default: "fetch")
-  --request <value>          Path to custom request file
-  --format <value>           Process output folder with formatter? (choices: "biome", "prettier")
-  --lint <value>             Process output folder with linter? (choices: "biome", "eslint")
-  --operationId              Use operation ID to generate operation names?
-  --serviceResponse <value>  Define shape of returned value from service calls (choices: "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', 'typescript+namespace']
-  --enums <value>            Generate JavaScript objects from enum definitions? (choices: "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                    Run in debug mode?
-  --noSchemas                Disable generating JSON schemas
-  --schemaType <value>       Type of JSON schema [Default: 'json'] (choices: "form", "json")
-  --pageParam <value>        Name of the query parameter used for pagination (default: "page")
-  --nextPageParam <value>    Name of the response parameter used for next page (default: "nextPage")
+  -V, --version               output the version number
+  -i, --input <value>         OpenAPI specification, can be a path, url or string content (required)
+  -o, --output <value>        Output directory (default: "openapi")
+  -c, --client <value>        HTTP client to generate (choices: "angular", "axios", "fetch", "node", "xhr", default: "fetch")
+  --request <value>           Path to custom request file
+  --format <value>            Process output folder with formatter? (choices: "biome", "prettier")
+  --lint <value>              Process output folder with linter? (choices: "biome", "eslint")
+  --operationId               Use operation ID to generate operation names?
+  --serviceResponse <value>   Define shape of returned value from service calls (choices: "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', 'typescript+namespace']
+  --enums <value>             Generate JavaScript objects from enum definitions? (choices: "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                     Run in debug mode?
+  --noSchemas                 Disable generating JSON schemas
+  --schemaType <value>        Type of JSON schema [Default: 'json'] (choices: "form", "json")
+  --pageParam <value>         Name of the query parameter used for pagination (default: "page")
+  --nextPageParam <value>     Name of the response parameter used for next page (default: "nextPage")
+  --initialPageParam <value>  Initial value for the pagination parameter (default: "1")
   -h, --help                 display help for command
 ```
 
@@ -78,9 +80,10 @@ $ openapi-rq -i ./petstore.yaml
   - queries
     - index.ts <- main file that exports common types, variables, and queries. Does not export suspense or prefetch hooks
     - common.ts <- common types
+    - ensureQueryData.ts <- generated ensureQueryData functions
     - queries.ts <- generated query hooks
     - suspenses.ts <- generated suspense hooks
-    - prefetch.ts <- generated prefetch hooks learn more about prefetching in in link below
+    - prefetch.ts <- generated prefetch functions learn more about prefetching in in link below
   - requests <- output code generated by @hey-api/openapi-ts
 ```
 
@@ -241,6 +244,8 @@ export default App;
 
 This feature will generate a function in infiniteQueries.ts when the name specified by the `pageParam` option exists in the query parameters and the name specified by the `nextPageParam` option exists in the response.
 
+The `initialPageParam` option can be specified to set the intial page to load, defaults to 1. The `nextPageParam` supports dot notation for nested values (i.e. `meta.next`).
+
 Example Schema:
 
 ```yml

package/dist/cli.mjs

@@ -36,6 +36,7 @@ async function setupProgram() {
         .addOption(new Option("--schemaType <value>", "Type of JSON schema [Default: 'json']").choices(["form", "json"]))
         .option("--pageParam <value>", "Name of the query parameter used for pagination", "page")
         .option("--nextPageParam <value>", "Name of the response parameter used for next page", "nextPage")
+        .option("--initialPageParam <value>", "Initial page value to query", "1")
         .parse();
     const options = program.opts();
     await generate(options, version);

package/dist/constants.mjs

@@ -10,4 +10,5 @@ export const OpenApiRqFiles = {
     suspense: "suspense",
     index: "index",
     prefetch: "prefetch",
+    ensureQueryData: "ensureQueryData",
 };

package/dist/createExports.mjs

@@ -1,7 +1,7 @@
-import { createPrefetch } from "./createPrefetch.mjs";
+import { createPrefetchOrEnsure } from "./createPrefetchOrEnsure.mjs";
 import { createUseMutation } from "./createUseMutation.mjs";
 import { createUseQuery } from "./createUseQuery.mjs";
-export const createExports = (service, pageParam, nextPageParam) => {
+export const createExports = (service, pageParam, nextPageParam, initialPageParam) => {
     const { klasses } = service;
     const methods = klasses.flatMap((k) => k.methods);
     const allGet = methods.filter((m) => m.httpMethodName.toUpperCase().includes("GET"));
@@ -9,8 +9,9 @@ export const createExports = (service, pageParam, nextPageParam) => {
     const allPut = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PUT"));
     const allPatch = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PATCH"));
     const allDelete = methods.filter((m) => m.httpMethodName.toUpperCase().includes("DELETE"));
-    const allGetQueries = allGet.map((m) => createUseQuery(m, pageParam, nextPageParam));
-    const allPrefetchQueries = allGet.map((m) => createPrefetch(m));
+    const allGetQueries = allGet.map((m) => createUseQuery(m, pageParam, nextPageParam, initialPageParam));
+    const allPrefetchQueries = allGet.map((m) => createPrefetchOrEnsure({ ...m, functionType: "prefetch" }));
+    const allEnsureQueries = allGet.map((m) => createPrefetchOrEnsure({ ...m, functionType: "ensure" }));
     const allPostMutations = allPost.map((m) => createUseMutation(m));
     const allPutMutations = allPut.map((m) => createUseMutation(m));
     const allPatchMutations = allPatch.map((m) => createUseMutation(m));
@@ -44,9 +45,8 @@ export const createExports = (service, pageParam, nextPageParam) => {
         suspenseQueryHook,
     ]);
     const suspenseExports = [...suspenseQueries];
-    const allPrefetches = allPrefetchQueries.flatMap(({ prefetchHook }) => [
-        prefetchHook,
-    ]);
+    const allPrefetches = allPrefetchQueries.flatMap(({ hook }) => [hook]);
+    const allEnsures = allEnsureQueries.flatMap(({ hook }) => [hook]);
     const allPrefetchExports = [...allPrefetches];
     return {
         /**
@@ -69,5 +69,9 @@ export const createExports = (service, pageParam, nextPageParam) => {
          * Prefetch exports are the hooks that are used in the prefetch components
          */
         allPrefetchExports,
+        /**
+         * Ensure exports are the hooks that are used in the loader components
+         */
+        allEnsures,
     };
 };

package/dist/{createPrefetch.mjs → createPrefetchOrEnsure.mjs}

@@ -3,12 +3,15 @@ import { BuildCommonTypeName, extractPropertiesFromObjectParam, getNameFromMetho
 import { createQueryKeyFromMethod, getQueryKeyFnName, getRequestParamFromMethod, hookNameFromMethod, } from "./createUseQuery.mjs";
 import { addJSDocToNode } from "./util.mjs";
 /**
- * Creates a prefetch function for a query
+ * Creates a prefetch/ensure function for a query
  */
-function createPrefetchHook({ requestParams, method, className, }) {
+function createPrefetchOrEnsureHook({ requestParams, method, className, functionType, }) {
     const methodName = getNameFromMethod(method);
     const queryName = hookNameFromMethod({ method, className });
-    const customHookName = `prefetch${queryName.charAt(0).toUpperCase() + queryName.slice(1)}`;
+    let customHookName = `prefetch${queryName.charAt(0).toUpperCase() + queryName.slice(1)}`;
+    if (functionType === "ensure") {
+        customHookName = `ensure${queryName.charAt(0).toUpperCase() + queryName.slice(1)}Data`;
+    }
     const queryKey = createQueryKeyFromMethod({ method, className });
     // const
     const hookExport = ts.factory.createVariableStatement(
@@ -17,7 +20,7 @@ function createPrefetchHook({ requestParams, method, className, }) {
         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, [
+        ], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createCallExpression(ts.factory.createIdentifier(`queryClient.${functionType === "prefetch" ? "prefetchQuery" : "ensureQueryData"}`), undefined, [
             ts.factory.createObjectLiteralExpression([
                 ts.factory.createPropertyAssignment(ts.factory.createIdentifier("queryKey"), ts.factory.createCallExpression(BuildCommonTypeName(getQueryKeyFnName(queryKey)), undefined, method.getParameters().length
                     ? [
@@ -38,16 +41,17 @@ function createPrefetchHook({ requestParams, method, className, }) {
     ], ts.NodeFlags.Const));
     return hookExport;
 }
-export const createPrefetch = ({ className, method, jsDoc, }) => {
+export const createPrefetchOrEnsure = ({ className, method, jsDoc, functionType, }) => {
     const requestParam = getRequestParamFromMethod(method);
     const requestParams = requestParam ? [requestParam] : [];
-    const prefetchHook = createPrefetchHook({
+    const prefetchOrEnsureHook = createPrefetchOrEnsureHook({
         requestParams,
         method,
         className,
+        functionType,
     });
-    const hookWithJsDoc = addJSDocToNode(prefetchHook, jsDoc);
+    const hookWithJsDoc = addJSDocToNode(prefetchOrEnsureHook, jsDoc);
     return {
-        prefetchHook: hookWithJsDoc,
+        hook: hookWithJsDoc,
     };
 };

package/dist/createSource.mjs

@@ -5,7 +5,7 @@ import { OpenApiRqFiles } from "./constants.mjs";
 import { createExports } from "./createExports.mjs";
 import { createImports } from "./createImports.mjs";
 import { getServices } from "./service.mjs";
-const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageParam) => {
+const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageParam, initialPageParam) => {
     const project = new Project({
         // Optionally specify compiler options, tsconfig.json, in-memory file system, and more here.
         // If you initialize with a tsconfig.json, then it will automatically populate the project
@@ -20,7 +20,7 @@ const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageP
         serviceEndName,
         project,
     });
-    const exports = createExports(service, pageParam, nextPageParam);
+    const exports = createExports(service, pageParam, nextPageParam, initialPageParam);
     const commonSource = ts.factory.createSourceFile([...imports, ...exports.allCommon], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
     const commonImport = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, ts.factory.createIdentifier("* as Common"), undefined), ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
     const commonExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
@@ -30,6 +30,7 @@ const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageP
     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);
+    const ensureSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.allEnsures], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
     return {
         commonSource,
         infiniteQueriesSource,
@@ -37,20 +38,22 @@ const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageP
         suspenseSource,
         indexSource,
         prefetchSource,
+        ensureSource,
     };
 };
-export const createSource = async ({ outputPath, version, serviceEndName, pageParam, nextPageParam, }) => {
+export const createSource = async ({ outputPath, version, serviceEndName, pageParam, nextPageParam, initialPageParam, }) => {
     const queriesFile = ts.createSourceFile(`${OpenApiRqFiles.queries}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const infiniteQueriesFile = ts.createSourceFile(`${OpenApiRqFiles.infiniteQueries}.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 ensureQueryDataFile = ts.createSourceFile(`${OpenApiRqFiles.ensureQueryData}.ts`, "", ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
     const printer = ts.createPrinter({
         newLine: ts.NewLineKind.LineFeed,
         removeComments: false,
     });
-    const { commonSource, mainSource, infiniteQueriesSource, suspenseSource, indexSource, prefetchSource, } = await createSourceFile(outputPath, serviceEndName, pageParam, nextPageParam);
+    const { commonSource, mainSource, infiniteQueriesSource, suspenseSource, indexSource, prefetchSource, ensureSource, } = await createSourceFile(outputPath, serviceEndName, pageParam, nextPageParam, initialPageParam);
     const comment = `// generated with @7nohe/openapi-react-query-codegen@${version} \n\n`;
     const commonResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, commonSource, commonFile);
@@ -64,6 +67,8 @@ export const createSource = async ({ outputPath, version, serviceEndName, pagePa
         printer.printNode(ts.EmitHint.Unspecified, indexSource, indexFile);
     const prefetchResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, prefetchSource, prefetchFile);
+    const enqureResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, ensureSource, ensureQueryDataFile);
     return [
         {
             name: `${OpenApiRqFiles.index}.ts`,
@@ -89,5 +94,9 @@ export const createSource = async ({ outputPath, version, serviceEndName, pagePa
             name: `${OpenApiRqFiles.prefetch}.ts`,
             content: prefetchResult,
         },
+        {
+            name: `${OpenApiRqFiles.ensureQueryData}.ts`,
+            content: enqureResult,
+        },
     ];
 };

package/dist/createUseQuery.mjs

@@ -85,12 +85,36 @@ export function createQueryKeyFromMethod({ method, className, }) {
     const queryKey = `${customHookName}Key`;
     return queryKey;
 }
+/**
+ * Extracts the type of the next page parameter from the given properties.
+ *
+ * @param properties The properties to search through.
+ * @param nextPageParam The name of the next page parameter.
+ * @returns The type of the next page parameter, if found.
+ */
+function findNextPageParamType(properties, nextPageParam) {
+    if (!properties)
+        return undefined;
+    for (const property of properties) {
+        if (property.getName() === nextPageParam) {
+            return property?.getDeclarations()?.at(0)?.getType()?.getText();
+        }
+        const type = property.getDeclarations().at(0)?.getType();
+        const nestedProperties = type?.getProperties();
+        if (!type?.isObject() || type.isArray())
+            continue;
+        const result = findNextPageParamType(nestedProperties, nextPageParam);
+        if (result)
+            return result;
+    }
+    return undefined;
+}
 /**
  * Creates a custom hook for a query
  * @param queryString The type of query to use from react-query
  * @param suffix The suffix to append to the hook name
  */
-export function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, pageParam, nextPageParam, }) {
+export function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, pageParam, nextPageParam, initialPageParam, }) {
     const methodName = getNameFromMethod(method);
     const customHookName = hookNameFromMethod({ method, className });
     const queryKey = createQueryKeyFromMethod({ method, className });
@@ -101,6 +125,11 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
     const isInfiniteQuery = queryString === "useInfiniteQuery";
     const responseDataTypeRef = responseDataType.default;
     const responseDataTypeIdentifier = responseDataTypeRef.typeName;
+    const arg = method.getReturnType().getTypeArguments().at(0);
+    const nextPageParamTypePropetires = arg?.getProperties();
+    const nextPageParamType = arg?.isObject() && nextPageParam
+        ? findNextPageParamType(nextPageParamTypePropetires, nextPageParam.split(".").at(-1) ?? "")
+        : undefined;
     const hookExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
         ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`${customHookName}${suffix}`), undefined, undefined, ts.factory.createArrowFunction(undefined, ts.factory.createNodeArray([
             isInfiniteQuery
@@ -151,18 +180,22 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
                         ts.factory.createObjectLiteralExpression(method
                             .getParameters()
                             .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => p.name === pageParam
-                            ? ts.factory.createPropertyAssignment(ts.factory.createIdentifier(p.name), ts.factory.createAsExpression(ts.factory.createIdentifier("pageParam"), ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)))
+                            ? ts.factory.createPropertyAssignment(ts.factory.createIdentifier(p.name), ts.factory.createAsExpression(ts.factory.createIdentifier("pageParam"), ts.factory.createKeywordTypeNode(p.type?.getText() === "number"
+                                ? ts.SyntaxKind
+                                    .NumberKeyword
+                                : ts.SyntaxKind
+                                    .StringKeyword)))
                             : ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
                     ]
                     : undefined), ts.factory.createTypeReferenceNode(TData)))),
-                ...createInfiniteQueryParams(pageParam, nextPageParam),
+                ...createInfiniteQueryParams(pageParam, nextPageParam, initialPageParam, nextPageParamType),
                 ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
             ]),
         ]))),
     ], ts.NodeFlags.Const));
     return hookExport;
 }
-export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPageParam) => {
+export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPageParam, initialPageParam) => {
     const methodName = getNameFromMethod(method);
     const queryKey = createQueryKeyFromMethod({ method, className });
     const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
@@ -206,6 +239,7 @@ export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPage
             className,
             pageParam,
             nextPageParam,
+            initialPageParam,
         })
         : undefined;
     const hookWithJsDoc = addJSDocToNode(queryHook, jsDoc);
@@ -257,16 +291,22 @@ function queryKeyFn(queryKey, method) {
             : ts.factory.createArrayLiteralExpression([])))),
     ], false);
 }
-function createInfiniteQueryParams(pageParam, nextPageParam) {
+function createInfiniteQueryParams(pageParam, nextPageParam, initialPageParam = "1", type) {
     if (pageParam === undefined || nextPageParam === undefined) {
         return [];
     }
     return [
-        ts.factory.createPropertyAssignment(ts.factory.createIdentifier("initialPageParam"), ts.factory.createNumericLiteral(1)),
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier("initialPageParam"), ts.factory.createStringLiteral(initialPageParam)),
         ts.factory.createPropertyAssignment(ts.factory.createIdentifier("getNextPageParam"), 
         // (response) => (response as { nextPage: number }).nextPage,
         ts.factory.createArrowFunction(undefined, undefined, [
             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("response"), undefined, undefined),
-        ], undefined, EqualsOrGreaterThanToken, ts.factory.createPropertyAccessExpression(ts.factory.createParenthesizedExpression(ts.factory.createAsExpression(ts.factory.createIdentifier("response"), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(`{ ${nextPageParam}: number }`)))), ts.factory.createIdentifier(nextPageParam)))),
+        ], undefined, EqualsOrGreaterThanToken, ts.factory.createPropertyAccessExpression(ts.factory.createParenthesizedExpression(ts.factory.createAsExpression(ts.factory.createIdentifier("response"), nextPageParam.split(".").reduceRight((acc, segment) => {
+            return ts.factory.createTypeLiteralNode([
+                ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier(segment), undefined, acc),
+            ]);
+        }, ts.factory.createKeywordTypeNode(type === "number"
+            ? ts.SyntaxKind.NumberKeyword
+            : ts.SyntaxKind.StringKeyword)))), ts.factory.createIdentifier(nextPageParam)))),
     ];
 }

package/dist/generate.mjs

@@ -27,6 +27,7 @@ export async function generate(options, version) {
             export: true,
             response: formattedOptions.serviceResponse,
             asClass: true,
+            operationId: formattedOptions.operationId ?? false,
         },
         types: {
             dates: formattedOptions.useDateType,
@@ -42,6 +43,7 @@ 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
         pageParam: formattedOptions.pageParam,
         nextPageParam: formattedOptions.nextPageParam,
+        initialPageParam: formattedOptions.initialPageParam.toString(),
     });
     await print(source, formattedOptions);
     const queriesOutputPath = buildQueriesOutputPath(options.output);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "OpenAPI React Query Codegen",
   "keywords": [
     "codegen",
@@ -59,9 +59,9 @@
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.json",
     "lint": "biome check .",
-    "lint:fix": "biome check --apply .",
+    "lint:fix": "biome check --write .",
     "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 -b v1 && npx bumpp --commit --tag --push",
     "snapshot": "vitest --update",
     "test": "vitest --coverage.enabled true"
   }