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

package/README.md

@@ -201,12 +201,17 @@ import {
 
 // App.tsx
 function App() {
-  const { data } = usePetServiceFindPetsByStatus({ status: ["available"] });
+  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()],
+        // 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
+        })],
       });
     },
   });
@@ -257,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,6 +1,6 @@
-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");
@@ -51,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];
@@ -119,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,30 +22,28 @@ export const createExports = (service) => {
         ...allPatchMutations,
         ...allDeleteMutations,
     ];
-    const commonInQueries = allQueries
-        .map(({ apiResponse, returnType, key, queryKeyFn }) => [
+    const commonInQueries = allQueries.flatMap(({ apiResponse, returnType, key, queryKeyFn }) => [
         apiResponse,
         returnType,
         key,
         queryKeyFn,
-    ])
-        .flat();
-    const commonInMutations = allMutations
-        .map(({ mutationResult }) => [mutationResult])
-        .flat();
+    ]);
+    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, EqualsOrGreaterThanToken, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, queryKeyConstraint, queryKeyGenericType, QuestionToken, 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>> */
@@ -32,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
@@ -122,8 +119,7 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
                     ? [
                         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.createIdentifier("queryKey"),
                     ]
                     : [])),
@@ -131,8 +127,7 @@ export function createQueryHook({ queryString, suffix, responseDataType, request
                     ? [
                         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")),
@@ -212,8 +207,7 @@ function queryKeyFn(queryKey, method) {
             ? 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);

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.2",
+  "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"
   }
 }