@7nohe/openapi-react-query-codegen 1.4.1 → 1.5.1

package/README.md

@@ -6,7 +6,7 @@
 
 ## Features
 
-- Generates custom react hooks that use React Query's `useQuery`, `useSuspenseQuery` and `useMutation` hooks
+- Generates custom react hooks that use React Query's `useQuery`, `useSuspenseQuery`, `useMutation` and `useInfiniteQuery` 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)
 
@@ -45,18 +45,20 @@ Options:
   -V, --version              output the version number
   -i, --input <value>        OpenAPI specification, can be a path, url or string content (required)
   -o, --output <value>       Output directory (default: "openapi")
-  -c, --client <value>       HTTP client to generate [fetch, xhr, node, axios, angular] (default: "fetch")
+  -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? ['biome', 'prettier']
-  --lint   <value>           Process output folder with linter? ['eslint', 'biome']
+  --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 ['body', 'response'] (default: "body")
+  --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']
+  --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                    Enable debug mode
-  --noSchemas                Disable generating schemas for request and response objects
-  --schemaTypes <value>      Define the type of schema generation ['form', 'json'] (default: "json")
+  --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")
   -h, --help                 display help for command
 ```
 
@@ -234,6 +236,72 @@ function App() {
 export default App;
 ```
 
+##### Using Infinite Query hooks
+
+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.
+
+Example Schema:
+
+```yml
+paths:
+  /paginated-pets:
+    get:
+      description: |
+        Returns paginated pets from the system that the user has access to
+      operationId: findPaginatedPets
+      parameters:
+        - name: page
+          in: query
+          description: page number
+          required: false
+          schema:
+            type: integer
+            format: int32
+        - name: tags
+          in: query
+          description: tags to filter by
+          required: false
+          style: form
+          schema:
+            type: array
+            items:
+              type: string
+        - name: limit
+          in: query
+          description: maximum number of results to return
+          required: false
+          schema:
+            type: integer
+            format: int32
+      responses:
+        '200':
+          description: pet response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  pets:
+                    type: array
+                    items:
+                      $ref: '#/components/schemas/Pet'
+                  nextPage: 
+                    type: integer
+                    format: int32
+                    minimum: 1
+```
+
+Usage of Generated Hooks:
+
+```ts
+import { useDefaultServiceFindPaginatedPetsInfinite } from "@/openapi/queries/infiniteQueries";
+
+const { data, fetchNextPage } = useDefaultServiceFindPaginatedPetsInfinite({
+  limit: 10,
+  tags: [],
+});
+```
+
 ##### Runtime Configuration
 
 You can modify the default values used by the generated service calls by modifying the OpenAPI configuration singleton object.

package/dist/cli.mjs

@@ -34,6 +34,8 @@ async function setupProgram() {
         .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"]))
+        .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")
         .parse();
     const options = program.opts();
     await generate(options, version);

package/dist/common.mjs

@@ -80,7 +80,7 @@ export function extractPropertiesFromObjectParam(param) {
  * TODO: Replace with a more robust solution.
  */
 export function getShortType(type) {
-    return type.replaceAll(/import\(".*"\)\./g, "");
+    return type.replaceAll(/import\(".*?"\)\./g, "");
 }
 export function getClassesFromService(node) {
     const klasses = node.getClasses();

package/dist/constants.mjs

@@ -5,6 +5,7 @@ export const serviceFileName = "services.gen";
 export const modalsFileName = "types.gen";
 export const OpenApiRqFiles = {
     queries: "queries",
+    infiniteQueries: "infiniteQueries",
     common: "common",
     suspense: "suspense",
     index: "index",

package/dist/createExports.mjs

@@ -1,7 +1,7 @@
 import { createPrefetch } from "./createPrefetch.mjs";
 import { createUseMutation } from "./createUseMutation.mjs";
 import { createUseQuery } from "./createUseQuery.mjs";
-export const createExports = (service) => {
+export const createExports = (service, pageParam, nextPageParam) => {
     const { klasses } = service;
     const methods = klasses.flatMap((k) => k.methods);
     const allGet = methods.filter((m) => m.httpMethodName.toUpperCase().includes("GET"));
@@ -9,7 +9,7 @@ export const createExports = (service) => {
     const allPut = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PUT"));
     const allPatch = methods.filter((m) => m.httpMethodName.toUpperCase().includes("PATCH"));
     const allDelete = methods.filter((m) => m.httpMethodName.toUpperCase().includes("DELETE"));
-    const allGetQueries = allGet.map((m) => createUseQuery(m));
+    const allGetQueries = allGet.map((m) => createUseQuery(m, pageParam, nextPageParam));
     const allPrefetchQueries = allGet.map((m) => createPrefetch(m));
     const allPostMutations = allPost.map((m) => createUseMutation(m));
     const allPutMutations = allPut.map((m) => createUseMutation(m));
@@ -37,6 +37,9 @@ export const createExports = (service) => {
         mutationHook,
     ]);
     const mainExports = [...mainQueries, ...mainMutations];
+    const infiniteQueriesExports = allQueries
+        .flatMap(({ infiniteQueryHook }) => [infiniteQueryHook])
+        .filter(Boolean);
     const suspenseQueries = allQueries.flatMap(({ suspenseQueryHook }) => [
         suspenseQueryHook,
     ]);
@@ -54,6 +57,10 @@ export const createExports = (service) => {
          * Main exports are the hooks that are used in the components
          */
         mainExports,
+        /**
+         * Infinite queries exports are the hooks that are used in the infinite scroll components
+         */
+        infiniteQueriesExports,
         /**
          * Suspense exports are the hooks that are used in the suspense components
          */

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) => {
+const createSourceFile = async (outputPath, serviceEndName, pageParam, nextPageParam) => {
     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,25 +20,28 @@ const createSourceFile = async (outputPath, serviceEndName) => {
         serviceEndName,
         project,
     });
-    const exports = createExports(service);
+    const exports = createExports(service, pageParam, nextPageParam);
     const commonSource = ts.factory.createSourceFile([...imports, ...exports.allCommon], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
     const commonImport = ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(false, ts.factory.createIdentifier("* as Common"), undefined), ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
     const commonExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral(`./${OpenApiRqFiles.common}`), undefined);
     const queriesExport = ts.factory.createExportDeclaration(undefined, false, undefined, ts.factory.createStringLiteral(`./${OpenApiRqFiles.queries}`), undefined);
     const mainSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.mainExports], ts.factory.createToken(ts.SyntaxKind.EndOfFileToken), ts.NodeFlags.None);
+    const infiniteQueriesSource = ts.factory.createSourceFile([commonImport, ...imports, ...exports.infiniteQueriesExports], 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,
+        infiniteQueriesSource,
         mainSource,
         suspenseSource,
         indexSource,
         prefetchSource,
     };
 };
-export const createSource = async ({ outputPath, version, serviceEndName, }) => {
+export const createSource = async ({ outputPath, version, serviceEndName, pageParam, nextPageParam, }) => {
     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);
@@ -47,12 +50,14 @@ export const createSource = async ({ outputPath, version, serviceEndName, }) =>
         newLine: ts.NewLineKind.LineFeed,
         removeComments: false,
     });
-    const { commonSource, mainSource, suspenseSource, indexSource, prefetchSource, } = await createSourceFile(outputPath, serviceEndName);
+    const { commonSource, mainSource, infiniteQueriesSource, suspenseSource, indexSource, prefetchSource, } = await createSourceFile(outputPath, serviceEndName, pageParam, nextPageParam);
     const comment = `// generated with @7nohe/openapi-react-query-codegen@${version} \n\n`;
     const commonResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, commonSource, commonFile);
     const mainResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, mainSource, queriesFile);
+    const infiniteQueriesResult = comment +
+        printer.printNode(ts.EmitHint.Unspecified, infiniteQueriesSource, infiniteQueriesFile);
     const suspenseResult = comment +
         printer.printNode(ts.EmitHint.Unspecified, suspenseSource, suspenseFile);
     const indexResult = comment +
@@ -68,6 +73,10 @@ export const createSource = async ({ outputPath, version, serviceEndName, }) =>
             name: `${OpenApiRqFiles.common}.ts`,
             content: commonResult,
         },
+        {
+            name: `${OpenApiRqFiles.infiniteQueries}.ts`,
+            content: infiniteQueriesResult,
+        },
         {
             name: `${OpenApiRqFiles.queries}.ts`,
             content: mainResult,

package/dist/createUseQuery.mjs

@@ -28,13 +28,15 @@ export const createApiResponseType = ({ className, methodName, }) => {
         responseDataType,
     };
 };
-export function getRequestParamFromMethod(method) {
+export function getRequestParamFromMethod(method, pageParam) {
     if (!method.getParameters().length) {
         return null;
     }
     const params = method.getParameters().flatMap((param) => {
         const paramNodes = extractPropertiesFromObjectParam(param);
-        return paramNodes.map((refParam) => ({
+        return paramNodes
+            .filter((p) => p.name !== pageParam)
+            .map((refParam) => ({
             name: refParam.name,
             typeName: getShortType(refParam.type.getText()),
             optional: refParam.optional,
@@ -88,20 +90,33 @@ export 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
  */
-export function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, }) {
+export function createQueryHook({ queryString, suffix, responseDataType, requestParams, method, className, pageParam, nextPageParam, }) {
     const methodName = getNameFromMethod(method);
     const customHookName = hookNameFromMethod({ method, className });
     const queryKey = createQueryKeyFromMethod({ method, className });
+    if (queryString === "useInfiniteQuery" &&
+        (pageParam === undefined || nextPageParam === undefined)) {
+        throw new Error("pageParam and nextPageParam are required for infinite queries");
+    }
+    const isInfiniteQuery = queryString === "useInfiniteQuery";
+    const responseDataTypeRef = responseDataType.default;
+    const responseDataTypeIdentifier = responseDataTypeRef.typeName;
     const hookExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
         ts.factory.createVariableDeclaration(ts.factory.createIdentifier(`${customHookName}${suffix}`), undefined, undefined, ts.factory.createArrowFunction(undefined, ts.factory.createNodeArray([
-            responseDataType,
+            isInfiniteQuery
+                ? ts.factory.createTypeParameterDeclaration(undefined, TData, undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("InfiniteData"), [
+                    ts.factory.createTypeReferenceNode(responseDataTypeIdentifier),
+                ]))
+                : responseDataType,
             ts.factory.createTypeParameterDeclaration(undefined, TError, undefined, ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)),
             ts.factory.createTypeParameterDeclaration(undefined, "TQueryKey", queryKeyConstraint, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword))),
         ]), [
             ...requestParams,
             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("queryKey"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), queryKeyGenericType),
             ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier("options"), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("Omit"), [
-                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("UseQueryOptions"), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(isInfiniteQuery
+                    ? "UseInfiniteQueryOptions"
+                    : "UseQueryOptions"), [
                     ts.factory.createTypeReferenceNode(TData),
                     ts.factory.createTypeReferenceNode(TError),
                 ]),
@@ -110,33 +125,44 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
                     ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral("queryFn")),
                 ]),
             ])),
-        ], undefined, EqualsOrGreaterThanToken, ts.factory.createCallExpression(ts.factory.createIdentifier(queryString), [
-            ts.factory.createTypeReferenceNode(TData),
-            ts.factory.createTypeReferenceNode(TError),
-        ], [
+        ], undefined, EqualsOrGreaterThanToken, ts.factory.createCallExpression(ts.factory.createIdentifier(queryString), isInfiniteQuery
+            ? []
+            : [
+                ts.factory.createTypeReferenceNode(TData),
+                ts.factory.createTypeReferenceNode(TError),
+            ], [
             ts.factory.createObjectLiteralExpression([
                 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.createObjectLiteralExpression(method.getParameters().flatMap((param) => extractPropertiesFromObjectParam(param)
+                            .filter((p) => p.name !== pageParam)
+                            .map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
                         ts.factory.createIdentifier("queryKey"),
                     ]
                     : [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.createPropertyAssignment(ts.factory.createIdentifier("queryFn"), ts.factory.createArrowFunction(undefined, undefined, isInfiniteQuery
+                    ? [
+                        ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createObjectBindingPattern([
+                            ts.factory.createBindingElement(undefined, undefined, ts.factory.createIdentifier("pageParam"), undefined),
+                        ]), 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()
-                            .flatMap((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
+                            .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.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))),
                     ]
                     : undefined), ts.factory.createTypeReferenceNode(TData)))),
+                ...createInfiniteQueryParams(pageParam, nextPageParam),
                 ts.factory.createSpreadAssignment(ts.factory.createIdentifier("options")),
             ]),
         ]))),
     ], ts.NodeFlags.Const));
     return hookExport;
 }
-export const createUseQuery = ({ className, method, jsDoc, }) => {
+export const createUseQuery = ({ className, method, jsDoc }, pageParam, nextPageParam) => {
     const methodName = getNameFromMethod(method);
     const queryKey = createQueryKeyFromMethod({ method, className });
     const { apiResponse: defaultApiResponse, responseDataType } = createApiResponseType({
@@ -144,7 +170,15 @@ export const createUseQuery = ({ className, method, jsDoc, }) => {
         methodName,
     });
     const requestParam = getRequestParamFromMethod(method);
+    const infiniteRequestParam = getRequestParamFromMethod(method, pageParam);
     const requestParams = requestParam ? [requestParam] : [];
+    const requestParamNames = requestParams
+        .filter((p) => p.name.kind === ts.SyntaxKind.ObjectBindingPattern)
+        .map((p) => p.name);
+    const requestParamTexts = requestParamNames
+        .at(0)
+        ?.elements.filter((e) => e.name.kind === ts.SyntaxKind.Identifier)
+        .map((e) => e.name.escapedText);
     const queryHook = createQueryHook({
         queryString: "useQuery",
         suffix: "",
@@ -161,8 +195,24 @@ export const createUseQuery = ({ className, method, jsDoc, }) => {
         method,
         className,
     });
+    const isInfiniteQuery = requestParamTexts?.includes(pageParam) ?? false;
+    const infiniteQueryHook = isInfiniteQuery
+        ? createQueryHook({
+            queryString: "useInfiniteQuery",
+            suffix: "Infinite",
+            responseDataType,
+            requestParams: infiniteRequestParam ? [infiniteRequestParam] : [],
+            method,
+            className,
+            pageParam,
+            nextPageParam,
+        })
+        : undefined;
     const hookWithJsDoc = addJSDocToNode(queryHook, jsDoc);
     const suspenseHookWithJsDoc = addJSDocToNode(suspenseQueryHook, jsDoc);
+    const infiniteHookWithJsDoc = infiniteQueryHook
+        ? addJSDocToNode(infiniteQueryHook, jsDoc)
+        : undefined;
     const returnTypeExport = createReturnTypeExport({
         className,
         methodName,
@@ -180,6 +230,7 @@ export const createUseQuery = ({ className, method, jsDoc, }) => {
         key: queryKeyExport,
         queryHook: hookWithJsDoc,
         suspenseQueryHook: suspenseHookWithJsDoc,
+        infiniteQueryHook: infiniteHookWithJsDoc,
         queryKeyFn,
     };
 };
@@ -206,3 +257,16 @@ function queryKeyFn(queryKey, method) {
             : ts.factory.createArrayLiteralExpression([])))),
     ], false);
 }
+function createInfiniteQueryParams(pageParam, nextPageParam) {
+    if (pageParam === undefined || nextPageParam === undefined) {
+        return [];
+    }
+    return [
+        ts.factory.createPropertyAssignment(ts.factory.createIdentifier("initialPageParam"), ts.factory.createNumericLiteral(1)),
+        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)))),
+    ];
+}

package/dist/generate.mjs

@@ -39,6 +39,8 @@ export async function generate(options, version) {
         outputPath: openApiOutputPath,
         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,
     });
     await print(source, formattedOptions);
     const queriesOutputPath = buildQueriesOutputPath(options.output);

package/package.json

@@ -1,23 +1,7 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "1.4.1",
+  "version": "1.5.1",
   "description": "OpenAPI React Query Codegen",
-  "bin": {
-    "openapi-rq": "dist/cli.mjs"
-  },
-  "type": "module",
-  "workspaces": [
-    "examples/*"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/7nohe/openapi-react-query-codegen.git"
-  },
-  "homepage": "https://github.com/7nohe/openapi-react-query-codegen",
-  "bugs": "https://github.com/7nohe/openapi-react-query-codegen/issues",
-  "files": [
-    "dist"
-  ],
   "keywords": [
     "codegen",
     "react-query",
@@ -28,8 +12,24 @@
     "openapi-typescript-codegen",
     "@hey-api/openapi-ts"
   ],
-  "author": "Daiki Urata (@7nohe)",
+  "homepage": "https://github.com/7nohe/openapi-react-query-codegen",
+  "bugs": "https://github.com/7nohe/openapi-react-query-codegen/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/7nohe/openapi-react-query-codegen.git"
+  },
   "license": "MIT",
+  "author": "Daiki Urata (@7nohe)",
+  "type": "module",
+  "bin": {
+    "openapi-rq": "dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "workspaces": [
+    "examples/*"
+  ],
   "dependencies": {
     "@hey-api/openapi-ts": "0.45.1"
   },
@@ -53,7 +53,8 @@
     "typescript": "5.x"
   },
   "engines": {
-    "node": ">=14"
+    "node": ">=14",
+    "pnpm": ">=9"
   },
   "scripts": {
     "build": "rimraf dist && tsc -p tsconfig.json",
@@ -61,7 +62,7 @@
     "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",
-    "snapshot": "vitest --update"
+    "snapshot": "vitest --update",
+    "test": "vitest --coverage.enabled true"
   }
 }