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

package/README.md

@@ -160,6 +160,75 @@ 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 { data } = usePetServiceFindPetsByStatus({ status: ["available"] });
+  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()],
+      });
+    },
+  });
+
+  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.

package/dist/common.mjs

@@ -5,6 +5,8 @@ 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),

package/dist/createExports.mjs

@@ -23,7 +23,12 @@ export const createExports = (service) => {
         ...allDeleteMutations,
     ];
     const commonInQueries = allQueries
-        .map(({ apiResponse, returnType, key }) => [apiResponse, returnType, key])
+        .map(({ apiResponse, returnType, key, queryKeyFn }) => [
+        apiResponse,
+        returnType,
+        key,
+        queryKeyFn,
+    ])
         .flat();
     const commonInMutations = allMutations
         .map(({ mutationResult }) => [mutationResult])

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, capitalizeFirstLetter, EqualsOrGreaterThanToken, extractPropertiesFromObjectParam, getNameFromMethod, getShortType, queryKeyConstraint, queryKeyGenericType, QuestionToken, TData, TError, } 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,
@@ -54,6 +57,7 @@ export function getRequestParamFromMethod(method) {
 }
 /**
  * Return Type
+ *
  * export const classNameMethodNameQueryResult<TData = MyClassMethodDefaultResponse, TError = unknown> = UseQueryResult<TData, TError>;
  */
 export function createReturnTypeExport({ className, methodName, defaultApiResponse, }) {
@@ -109,23 +113,21 @@ 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()
+                            .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                            .flat()),
+                        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()
@@ -176,11 +178,43 @@ 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()
+                    .map((param) => extractPropertiesFromObjectParam(param).map((p) => ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier(p.name))))
+                    .flat()),
+            ])
+            : ts.factory.createArrayLiteralExpression([])))),
+    ], false);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@7nohe/openapi-react-query-codegen",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "OpenAPI React Query Codegen",
   "bin": {
     "openapi-rq": "dist/cli.mjs"