@acrool/rtk-query-codegen-openapi 0.0.6 → 0.0.9

package/src/generate.ts

@@ -23,6 +23,7 @@ import type {
   ParameterDefinition,
   ParameterMatcher,
   TextMatcher,
+  GenerateApiResult,
 } from './types';
 import { capitalize, getOperationDefinitions, getV3Doc, removeUndefined, isQuery as testIsQuery } from './utils';
 import { factory } from './utils/factory';
@@ -38,7 +39,7 @@ function defaultIsDataResponse(code: string, includeDefault: boolean) {
   return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
 }
 
-function getOperationName({ verb, path }: Pick<OperationDefinition, 'verb' | 'path' >) {
+function getOperationName({ verb, path }: Pick<OperationDefinition, 'verb' | 'path'>) {
   return _getOperationName(verb, path, undefined);
 }
 
@@ -118,8 +119,10 @@ export async function generateApi(
     mergeReadWriteOnly = false,
     httpResolverOptions,
     sharedTypesFile,
+    queryMatch,
+    endpointsQueryReturnTypeFile = './endpointsQueryReturnType',
   }: GenerationOptions
-) {
+): Promise<GenerateApiResult> {
   const v3Doc = (v3DocCache[spec] ??= await getV3Doc(spec, httpResolverOptions));
 
   const apiGen = new ApiGenerator(v3Doc, {
@@ -151,34 +154,36 @@ export async function generateApi(
 
     const components = v3Doc.components;
     if (components) {
-      const componentDefinitions = Object.entries(components).map(([componentType, componentDefs]) => {
-        const typeEntries = Object.entries(componentDefs as Record<string, unknown>)
-          .map(([name, def]) => {
-            addSchemeTypeName(name);
-            const typeName = capitalize(camelCase(name));
-            definedTypeNames.add(typeName);
-            const typeNode = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(def as OpenAPIV3.SchemaObject));
-            return factory.createTypeAliasDeclaration(
-              [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-              factory.createIdentifier(typeName),
-              undefined,
-              typeNode
-            );
-          });
-        return factory.createModuleDeclaration(
-          [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-          factory.createIdentifier('Scheme'),
-          factory.createModuleBlock(typeEntries),
-          ts.NodeFlags.Namespace
+      // 只處理 schemas，其他 component 類型暫時不處理
+      if (components.schemas) {
+        const typeEntries = Object.entries(components.schemas).map(([name, def]) => {
+          addSchemeTypeName(name);
+          const typeName = capitalize(camelCase(name));
+          definedTypeNames.add(typeName);
+          const typeNode = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(def as OpenAPIV3.SchemaObject));
+          return factory.createTypeAliasDeclaration(
+            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier(typeName),
+            undefined,
+            typeNode
+          );
+        });
+
+        allTypeDefinitions.push(
+          factory.createModuleDeclaration(
+            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier('Scheme'),
+            factory.createModuleBlock(typeEntries),
+            ts.NodeFlags.Namespace
+          )
         );
-      });
-      allTypeDefinitions.push(...componentDefinitions);
+      }
     }
 
     const enumEntries = [
-      ...apiGen.enumAliases.filter(e => ts.isEnumDeclaration(e)),
-      ...apiGen.enumAliases.filter(e => ts.isTypeAliasDeclaration(e)),
-    ].map(enumDecl => {
+      ...apiGen.enumAliases.filter((e) => ts.isEnumDeclaration(e)),
+      ...apiGen.enumAliases.filter((e) => ts.isTypeAliasDeclaration(e)),
+    ].map((enumDecl) => {
       if (ts.isEnumDeclaration(enumDecl)) {
         return factory.createEnumDeclaration(
           [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
@@ -195,15 +200,15 @@ export async function generateApi(
       }
       return enumDecl;
     });
-    
+
     const unionTypeEnums = apiGen.aliases
-      .filter(alias => {
+      .filter((alias) => {
         if (ts.isTypeAliasDeclaration(alias) && alias.type) {
           return ts.isUnionTypeNode(alias.type);
         }
         return false;
       })
-      .map(alias => {
+      .map((alias) => {
         if (ts.isTypeAliasDeclaration(alias)) {
           return factory.createTypeAliasDeclaration(
             [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
@@ -214,9 +219,9 @@ export async function generateApi(
         }
         return alias;
       });
-    
+
     const allEnumEntries = [...enumEntries, ...unionTypeEnums];
-    
+
     if (allEnumEntries.length > 0) {
       allTypeDefinitions.push(
         factory.createModuleDeclaration(
@@ -230,7 +235,7 @@ export async function generateApi(
 
     if (apiGen.aliases.length > 0) {
       const aliasEntries = apiGen.aliases
-        .filter(alias => {
+        .filter((alias) => {
           if (ts.isTypeAliasDeclaration(alias)) {
             const isDefinedInComponents = definedTypeNames.has(alias.name.text);
             const isUnionTypeEnum = ts.isUnionTypeNode(alias.type);
@@ -238,7 +243,7 @@ export async function generateApi(
           }
           return false;
         })
-        .map(alias => {
+        .map((alias) => {
           if (ts.isTypeAliasDeclaration(alias)) {
             return factory.createTypeAliasDeclaration(
               [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
@@ -251,10 +256,8 @@ export async function generateApi(
         });
 
       if (aliasEntries.length > 0) {
-        const existingSchemeIndex = allTypeDefinitions.findIndex(def => 
-          ts.isModuleDeclaration(def) && 
-          ts.isIdentifier(def.name) && 
-          def.name.text === 'Scheme'
+        const existingSchemeIndex = allTypeDefinitions.findIndex(
+          (def) => ts.isModuleDeclaration(def) && ts.isIdentifier(def.name) && def.name.text === 'Scheme'
         );
 
         if (existingSchemeIndex >= 0) {
@@ -281,10 +284,10 @@ export async function generateApi(
 
     const fs = await import('node:fs/promises');
     const path = await import('node:path');
-    
+
     const sharedTypesDir = path.dirname(sharedTypesFile);
     await fs.mkdir(sharedTypesDir, { recursive: true });
-    
+
     const output = printer.printNode(
       ts.EmitHint.Unspecified,
       factory.createSourceFile(
@@ -314,6 +317,7 @@ export async function generateApi(
   const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 
   const interfaces: Record<string, ts.InterfaceDeclaration | ts.TypeAliasDeclaration> = {};
+
   function registerInterface(declaration: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
     const name = declaration.name.escapedText.toString();
     if (name in interfaces) {
@@ -330,50 +334,64 @@ export async function generateApi(
       apiFile = apiFile.replace(/\\/g, '/');
       if (!apiFile.startsWith('.')) apiFile = `./${apiFile}`;
     }
+    if (endpointsQueryReturnTypeFile.startsWith('.')) {
+      endpointsQueryReturnTypeFile = path.relative(path.dirname(outputFile), endpointsQueryReturnTypeFile);
+      endpointsQueryReturnTypeFile = endpointsQueryReturnTypeFile.replace(/\\/g, '/');
+      if (!endpointsQueryReturnTypeFile.startsWith('.')) endpointsQueryReturnTypeFile = `./${endpointsQueryReturnTypeFile}`;
+    }
   }
   apiFile = apiFile.replace(/\.[jt]sx?$/, '');
-
-  const sharedTypesImportPath = sharedTypesFile && outputFile
-    ? (() => {
-        let rel = path.relative(path.dirname(outputFile), sharedTypesFile)
-          .replace(/\\/g, '/')
-          .replace(/\.[jt]sx?$/, '');
-        if (!rel.startsWith('.')) rel = './' + rel;
-        return rel;
-      })()
-    : './shared-types';
-
-  return printer.printNode(
+  endpointsQueryReturnTypeFile = endpointsQueryReturnTypeFile.replace(/\.[jt]sx?$/, '');
+
+  const sharedTypesImportPath =
+    sharedTypesFile && outputFile
+      ? (() => {
+          let rel = path
+            .relative(path.dirname(outputFile), sharedTypesFile)
+            .replace(/\\/g, '/')
+            .replace(/\.[jt]sx?$/, '');
+          if (!rel.startsWith('.')) rel = './' + rel;
+          return rel;
+        })()
+      : './shared-types';
+
+  // 收集操作名稱
+  const operationNames: string[] = [];
+
+  const sourceCode = printer.printNode(
     ts.EmitHint.Unspecified,
     factory.createSourceFile(
       [
         generateImportNode(apiFile, { [apiImport]: 'api' }),
-        generateImportNode('@acrool/react-fetcher', { IRestFulEndpointsQueryReturn: 'IRestFulEndpointsQueryReturn' }),
-        ...(sharedTypesFile ? [
-          generateImportNode(sharedTypesImportPath, { 
-            Scheme: 'Scheme',
-            ...(useEnumType ? { Enum: 'Enum' } : {})
-          })
-        ] : []),
+        generateImportNode(endpointsQueryReturnTypeFile, { IRestFulEndpointsQueryReturn: 'IRestFulEndpointsQueryReturn' }),
+        ...(sharedTypesFile
+          ? [
+              generateImportNode(sharedTypesImportPath, {
+                Scheme: 'Scheme',
+                ...(useEnumType ? { Enum: 'Enum' } : {}),
+              }),
+            ]
+          : []),
         ...(tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : []),
         generateCreateApiCall({
           tag,
           endpointDefinitions: factory.createObjectLiteralExpression(
-            operationDefinitions.map((operationDefinition) =>
-              generateEndpoint({
+            operationDefinitions.map((operationDefinition) => {
+              const operationName = getOperationName({ verb: operationDefinition.verb, path: operationDefinition.path });
+              const finalOperationName = operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName;
+              operationNames.push(finalOperationName);
+              
+              return generateEndpoint({
                 operationDefinition,
                 overrides: getOverrides(operationDefinition, endpointOverrides),
                 sharedTypesFile: !!sharedTypesFile,
-              })
-            ),
+                queryMatch,
+              });
+            }),
             true
           ),
         }),
-        factory.createExportAssignment(
-          undefined,
-          undefined,
-          factory.createIdentifier(generatedApiName)
-        ),
+        factory.createExportAssignment(undefined, undefined, factory.createIdentifier(generatedApiName)),
         ...Object.values(interfaces),
         ...(sharedTypesFile ? [] : [...apiGen.aliases, ...apiGen.enumAliases]),
         ...(hooks
@@ -383,6 +401,7 @@ export async function generateApi(
                 operationDefinitions,
                 endpointOverrides,
                 config: hooks,
+                queryMatch,
               }),
             ]
           : []),
@@ -393,6 +412,11 @@ export async function generateApi(
     resultFile
   );
 
+  return {
+    sourceCode,
+    operationNames,
+  };
+
   function extractAllTagTypes({ operationDefinitions }: { operationDefinitions: OperationDefinition[] }) {
     const allTagTypes = new Set<string>();
 
@@ -409,10 +433,12 @@ export async function generateApi(
     operationDefinition,
     overrides,
     sharedTypesFile,
+    queryMatch,
   }: {
     operationDefinition: OperationDefinition;
     overrides?: EndpointOverrides;
     sharedTypesFile: boolean;
+    queryMatch?: (method: string, path: string) => boolean;
   }) {
     const {
       verb,
@@ -423,7 +449,7 @@ export async function generateApi(
     } = operationDefinition;
     const operationName = getOperationName({ verb, path });
     const tags = tag ? getTags({ verb, pathItem }) : [];
-    const isQuery = testIsQuery(verb, overrides);
+    const isQuery = testIsQuery(verb, path, overrides, queryMatch);
 
     const returnsJson = apiGen.getResponseType(responses) === 'json';
     let ResponseType: ts.TypeNode = factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
@@ -475,10 +501,11 @@ export async function generateApi(
 
     const parameters = supportDeepObjects([...pathItemParameters, ...operationParameters])
       .filter(argumentMatches(overrides?.parameterFilter))
-      .filter(param => param.in !== 'header');
+      .filter((param) => param.in !== 'header');
 
     const allNames = parameters.map((p) => p.name);
     const queryArg: QueryArgDefinitions = {};
+
     function generateName(name: string, potentialPrefix: string) {
       const isPureSnakeCase = /^[a-zA-Z][a-zA-Z0-9_]*$/.test(name);
       const hasNamingConflict = allNames.filter((n) => n === name).length > 1;
@@ -501,7 +528,9 @@ export async function generateApi(
         origin: 'param',
         name,
         originalName: param.name,
-        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(isReference(param) ? param : param.schema, undefined, 'writeOnly')),
+        type: wrapWithSchemeIfComponent(
+          apiGen.getTypeFromSchema(isReference(param) ? param : param.schema, undefined, 'writeOnly')
+        ),
         required: param.required,
         param,
       };
@@ -580,10 +609,7 @@ export async function generateApi(
       operationName: operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName,
       type: isQuery ? 'query' : 'mutation',
       Response: ResponseTypeName,
-      QueryArg: factory.createTypeReferenceNode(
-        factory.createIdentifier('IRestFulEndpointsQueryReturn'),
-        [QueryArg]
-      ),
+      QueryArg: factory.createTypeReferenceNode(factory.createIdentifier('IRestFulEndpointsQueryReturn'), [QueryArg]),
       queryFn: generateQueryFn({
         operationDefinition,
         queryArg,
@@ -614,13 +640,24 @@ export async function generateApi(
     encodePathParams: boolean;
     encodeQueryParams: boolean;
   }) {
-    const { path, verb } = operationDefinition;
+    const { path, verb, operation } = operationDefinition;
 
     const bodyParameter = Object.values(queryArg).find((def) => def.origin === 'body');
 
     const rootObject = factory.createIdentifier('queryArg');
     const variablesObject = factory.createPropertyAccessExpression(rootObject, factory.createIdentifier('variables'));
 
+    // 提取 content type 的輔助函數
+    function getContentType(): string | undefined {
+      if (operation.requestBody) {
+        const requestBody = apiGen.resolve(operation.requestBody);
+        const contentTypes = Object.keys(requestBody.content || {});
+        // 直接返回第一個可用的 content type
+        return contentTypes[0];
+      }
+      return undefined;
+    }
+
     function pickParams(paramIn: string) {
       return Object.values(queryArg).filter((def) => def.origin === 'param' && def.param.in === paramIn);
     }
@@ -629,8 +666,8 @@ export async function generateApi(
       if (parameters.length === 0) return undefined;
 
       const properties = parameters.map((param) => {
-        const value = isFlatArg 
-          ? variablesObject 
+        const value = isFlatArg
+          ? variablesObject
           : factory.createPropertyAccessExpression(variablesObject, factory.createIdentifier(param.name));
 
         const encodedValue =
@@ -655,6 +692,8 @@ export async function generateApi(
       );
     }
 
+    const contentType = getContentType();
+
     return factory.createArrowFunction(
       undefined,
       undefined,
@@ -674,13 +713,22 @@ export async function generateApi(
                   factory.createIdentifier('method'),
                   factory.createStringLiteral(verb.toUpperCase())
                 ),
+            contentType
+              ? factory.createPropertyAssignment(
+                  factory.createIdentifier('contentType'),
+                  factory.createStringLiteral(contentType)
+                )
+              : undefined,
             bodyParameter === undefined
               ? undefined
               : factory.createPropertyAssignment(
                   factory.createIdentifier('body'),
                   isFlatArg
                     ? variablesObject
-                    : factory.createPropertyAccessExpression(variablesObject, factory.createIdentifier(bodyParameter.name))
+                    : factory.createPropertyAccessExpression(
+                        variablesObject,
+                        factory.createIdentifier(bodyParameter.name)
+                      )
                 ),
             createObjectLiteralProperty(pickParams('cookie'), 'cookies'),
             createObjectLiteralProperty(pickParams('query'), 'params'),
@@ -710,42 +758,36 @@ export async function generateApi(
   function wrapWithSchemeIfComponent(typeNode: ts.TypeNode): ts.TypeNode {
     if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
       const typeName = typeNode.typeName.text;
-      
+
       // 檢查是否為 enum 類型（包括在 enumAliases 和 aliases 中的）
-      const isEnumType = useEnumType && (
-        apiGen.enumAliases.some(enumDecl => {
+      const isEnumType =
+        useEnumType &&
+        (apiGen.enumAliases.some((enumDecl) => {
           if (ts.isEnumDeclaration(enumDecl) || ts.isTypeAliasDeclaration(enumDecl)) {
             return enumDecl.name.text === typeName;
           }
           return false;
         }) ||
-        apiGen.aliases.some(alias => {
-          if (ts.isTypeAliasDeclaration(alias) && alias.type) {
-            // 檢查是否為 union type 的 enum
-            if (ts.isUnionTypeNode(alias.type)) {
-              return alias.name.text === typeName;
+          apiGen.aliases.some((alias) => {
+            if (ts.isTypeAliasDeclaration(alias) && alias.type) {
+              // 檢查是否為 union type 的 enum
+              if (ts.isUnionTypeNode(alias.type)) {
+                return alias.name.text === typeName;
+              }
             }
-          }
-          return false;
-        })
-      );
-      
+            return false;
+          }));
+
       if (isEnumType) {
         return factory.createTypeReferenceNode(
-          factory.createQualifiedName(
-            factory.createIdentifier('Enum'),
-            typeNode.typeName
-          ),
+          factory.createQualifiedName(factory.createIdentifier('Enum'), typeNode.typeName),
           typeNode.typeArguments?.map(wrapWithSchemeIfComponent)
         );
       }
-      
+
       if (schemeTypeNames.has(typeName)) {
         return factory.createTypeReferenceNode(
-          factory.createQualifiedName(
-            factory.createIdentifier('Scheme'),
-            typeNode.typeName
-          ),
+          factory.createQualifiedName(factory.createIdentifier('Scheme'), typeNode.typeName),
           typeNode.typeArguments?.map(wrapWithSchemeIfComponent)
         );
       }
@@ -762,42 +804,48 @@ export async function generateApi(
     if (ts.isUnionTypeNode(typeNode)) {
       // 檢查是否為 enum 的 union type
       const unionTypes = typeNode.types;
-      if (unionTypes.length > 0 && unionTypes.every(type => 
-        ts.isLiteralTypeNode(type) && 
-        (ts.isStringLiteral(type.literal) || ts.isNumericLiteral(type.literal))
-      )) {
+      if (
+        unionTypes.length > 0 &&
+        unionTypes.every(
+          (type) =>
+            ts.isLiteralTypeNode(type) && (ts.isStringLiteral(type.literal) || ts.isNumericLiteral(type.literal))
+        )
+      ) {
         // 這是一個 enum 的 union type，我們需要找到對應的 enum 類型
-        const enumValues = unionTypes.map(type => {
-          if (ts.isLiteralTypeNode(type)) {
-            if (ts.isStringLiteral(type.literal)) {
-              return type.literal.text;
-            } else if (ts.isNumericLiteral(type.literal)) {
-              return type.literal.text;
+        const enumValues = unionTypes
+          .map((type) => {
+            if (ts.isLiteralTypeNode(type)) {
+              if (ts.isStringLiteral(type.literal)) {
+                return type.literal.text;
+              } else if (ts.isNumericLiteral(type.literal)) {
+                return type.literal.text;
+              }
             }
-          }
-          return null;
-        }).filter(Boolean);
-        
+            return null;
+          })
+          .filter(Boolean);
+
         // 查找對應的 enum 類型
-        const matchingEnum = apiGen.aliases.find(alias => {
+        const matchingEnum = apiGen.aliases.find((alias) => {
           if (ts.isTypeAliasDeclaration(alias) && ts.isUnionTypeNode(alias.type)) {
-            const aliasValues = alias.type.types.map(type => {
-              if (ts.isLiteralTypeNode(type)) {
-                if (ts.isStringLiteral(type.literal)) {
-                  return type.literal.text;
-                } else if (ts.isNumericLiteral(type.literal)) {
-                  return type.literal.text;
+            const aliasValues = alias.type.types
+              .map((type) => {
+                if (ts.isLiteralTypeNode(type)) {
+                  if (ts.isStringLiteral(type.literal)) {
+                    return type.literal.text;
+                  } else if (ts.isNumericLiteral(type.literal)) {
+                    return type.literal.text;
+                  }
                 }
-              }
-              return null;
-            }).filter(Boolean);
-            
-            return aliasValues.length === enumValues.length && 
-                   aliasValues.every(val => enumValues.includes(val));
+                return null;
+              })
+              .filter(Boolean);
+
+            return aliasValues.length === enumValues.length && aliasValues.every((val) => enumValues.includes(val));
           }
           return false;
         });
-        
+
         // 對於所有的 enum 類型，直接使用字串型別，不轉換為 Enum
         // 這樣可以避免自動命名造成的變更問題
         if (matchingEnum && ts.isTypeAliasDeclaration(matchingEnum)) {
@@ -805,12 +853,12 @@ export async function generateApi(
           return typeNode;
         }
       }
-      
+
       return factory.createUnionTypeNode(typeNode.types.map(wrapWithSchemeIfComponent));
     }
     if (ts.isTypeLiteralNode(typeNode)) {
       return factory.createTypeLiteralNode(
-        typeNode.members.map(member => {
+        typeNode.members.map((member) => {
           if (ts.isPropertySignature(member) && member.type) {
             return factory.updatePropertySignature(
               member,
@@ -856,8 +904,8 @@ function generatePathExpression(
     ? factory.createTemplateExpression(
         factory.createTemplateHead(head),
         expressions.map(([prop, literal], index) => {
-          const value = isFlatArg 
-            ? rootObject 
+          const value = isFlatArg
+            ? rootObject
             : factory.createPropertyAccessExpression(rootObject, factory.createIdentifier(prop));
           const encodedValue = encodePathParams
             ? factory.createCallExpression(factory.createIdentifier('encodeURIComponent'), undefined, [

package/src/generators/react-hooks.ts

@@ -11,39 +11,43 @@ type GetReactHookNameParams = {
   operationDefinition: OperationDefinition;
   endpointOverrides: EndpointOverrides[] | undefined;
   config: HooksConfigOptions;
+  queryMatch?: (method: string, path: string) => boolean;
 };
 
 type CreateBindingParams = {
   operationDefinition: OperationDefinition;
   overrides?: EndpointOverrides;
   isLazy?: boolean;
+  queryMatch?: (method: string, path: string) => boolean;
 };
 
 const createBinding = ({
   operationDefinition: { verb, path },
   overrides,
   isLazy = false,
+  queryMatch,
 }: CreateBindingParams) =>
   factory.createBindingElement(
     undefined,
     undefined,
     factory.createIdentifier(
       `use${isLazy ? 'Lazy' : ''}${capitalize(getOperationName(verb, path, undefined))}${
-        isQuery(verb, overrides) ? 'Query' : 'Mutation'
+        isQuery(verb, path, overrides, queryMatch) ? 'Query' : 'Mutation'
       }`
     ),
     undefined
   );
 
-const getReactHookName = ({ operationDefinition, endpointOverrides, config }: GetReactHookNameParams) => {
+const getReactHookName = ({ operationDefinition, endpointOverrides, config, queryMatch }: GetReactHookNameParams) => {
   const overrides = getOverrides(operationDefinition, endpointOverrides);
 
   const baseParams = {
     operationDefinition,
     overrides,
+    queryMatch,
   };
 
-  const _isQuery = isQuery(operationDefinition.verb, overrides);
+  const _isQuery = isQuery(operationDefinition.verb, operationDefinition.path, overrides, queryMatch);
 
   // If `config` is true, just generate everything
   if (typeof config === 'boolean') {
@@ -66,12 +70,14 @@ type GenerateReactHooksParams = {
   operationDefinitions: OperationDefinition[];
   endpointOverrides: EndpointOverrides[] | undefined;
   config: HooksConfigOptions;
+  queryMatch?: (method: string, path: string) => boolean;
 };
 export const generateReactHooks = ({
   exportName,
   operationDefinitions,
   endpointOverrides,
   config,
+  queryMatch,
 }: GenerateReactHooksParams) =>
   factory.createVariableStatement(
     [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
@@ -80,7 +86,7 @@ export const generateReactHooks = ({
         factory.createVariableDeclaration(
           factory.createObjectBindingPattern(
             operationDefinitions
-              .map((operationDefinition) => getReactHookName({ operationDefinition, endpointOverrides, config }))
+              .map((operationDefinition) => getReactHookName({ operationDefinition, endpointOverrides, config, queryMatch }))
               .flat()
           ),
           undefined,