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

package/lib/index.mjs

@@ -4,13 +4,13 @@ var getFilename = () => fileURLToPath(import.meta.url);
 var __filename = /* @__PURE__ */ getFilename();
 
 // src/index.ts
-import fs from "node:fs";
+import fs2 from "node:fs";
 import { createRequire } from "node:module";
-import path3 from "node:path";
+import path4 from "node:path";
 
 // src/generate.ts
 import camelCase from "lodash.camelcase";
-import path2 from "node:path";
+import path3 from "node:path";
 import ApiGenerator, {
   getOperationName as _getOperationName,
   getReferenceName,
@@ -202,16 +202,54 @@ function capitalize(str) {
   return str.replace(str[0], str[0].toUpperCase());
 }
 
+// src/utils/downloadSchema.ts
+import fs from "node:fs";
+import path from "node:path";
+
+// src/utils/isValidUrl.ts
+function isValidUrl(string) {
+  try {
+    new URL(string);
+  } catch (_) {
+    return false;
+  }
+  return true;
+}
+
+// src/utils/downloadSchema.ts
+async function downloadSchemaFile(remoteFile, targetPath) {
+  if (!isValidUrl(remoteFile)) {
+    throw new Error(`remoteFile must be a valid URL: ${remoteFile}`);
+  }
+  try {
+    const dir = path.dirname(targetPath);
+    if (!fs.existsSync(dir)) {
+      await fs.promises.mkdir(dir, { recursive: true });
+    }
+    const response = await fetch(remoteFile);
+    if (!response.ok) {
+      throw new Error(`Failed to download schema from ${remoteFile}: ${response.statusText}`);
+    }
+    const content = await response.text();
+    await fs.promises.writeFile(targetPath, content, "utf-8");
+    console.log(`Schema downloaded from ${remoteFile} to ${targetPath}`);
+    return targetPath;
+  } catch (error) {
+    console.error(`Error downloading schema from ${remoteFile}:`, error);
+    throw error;
+  }
+}
+
 // src/types.ts
 var operationKeys = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
 
 // src/utils/getOperationDefinitions.ts
 function getOperationDefinitions(v3Doc) {
   return Object.entries(v3Doc.paths).flatMap(
-    ([path4, pathItem]) => !pathItem ? [] : Object.entries(pathItem).filter(
+    ([path5, pathItem]) => !pathItem ? [] : Object.entries(pathItem).filter(
       (arg) => operationKeys.includes(arg[0])
     ).map(([verb, operation]) => ({
-      path: path4,
+      path: path5,
       verb,
       pathItem,
       operation
@@ -238,25 +276,18 @@ async function getV3Doc(spec, httpResolverOptions) {
 }
 
 // src/utils/isQuery.ts
-function isQuery(verb, overrides) {
+function isQuery(verb, path5, overrides, queryMatch) {
+  if (queryMatch) {
+    return queryMatch(verb, path5);
+  }
   if (overrides?.type) {
     return overrides.type === "query";
   }
   return verb === "get";
 }
 
-// src/utils/isValidUrl.ts
-function isValidUrl(string) {
-  try {
-    new URL(string);
-  } catch (_) {
-    return false;
-  }
-  return true;
-}
-
 // src/utils/prettier.ts
-import path from "node:path";
+import path2 from "node:path";
 import prettier from "prettier";
 var EXTENSION_TO_PARSER = {
   ts: "typescript",
@@ -279,7 +310,7 @@ async function prettify(filePath, content, prettierConfigFile) {
   let config = null;
   let parser = "typescript";
   if (filePath) {
-    const fileExtension = path.extname(filePath).slice(1);
+    const fileExtension = path2.extname(filePath).slice(1);
     parser = EXTENSION_TO_PARSER[fileExtension];
     config = await prettier.resolveConfig(process.cwd(), {
       useCache: true,
@@ -305,24 +336,26 @@ function removeUndefined(t) {
 
 // src/generators/react-hooks.ts
 var createBinding = ({
-  operationDefinition: { verb, path: path4 },
+  operationDefinition: { verb, path: path5 },
   overrides,
-  isLazy = false
+  isLazy = false,
+  queryMatch
 }) => factory.createBindingElement(
   void 0,
   void 0,
   factory.createIdentifier(
-    `use${isLazy ? "Lazy" : ""}${capitalize(getOperationName(verb, path4, void 0))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
+    `use${isLazy ? "Lazy" : ""}${capitalize(getOperationName(verb, path5, void 0))}${isQuery(verb, path5, overrides, queryMatch) ? "Query" : "Mutation"}`
   ),
   void 0
 );
-var getReactHookName = ({ operationDefinition, endpointOverrides, config }) => {
+var getReactHookName = ({ operationDefinition, endpointOverrides, config, queryMatch }) => {
   const overrides = getOverrides(operationDefinition, endpointOverrides);
   const baseParams = {
     operationDefinition,
-    overrides
+    overrides,
+    queryMatch
   };
-  const _isQuery = isQuery(operationDefinition.verb, overrides);
+  const _isQuery = isQuery(operationDefinition.verb, operationDefinition.path, overrides, queryMatch);
   if (typeof config === "boolean") {
     return createBinding(baseParams);
   }
@@ -338,14 +371,15 @@ var generateReactHooks = ({
   exportName,
   operationDefinitions,
   endpointOverrides,
-  config
+  config,
+  queryMatch
 }) => factory.createVariableStatement(
   [factory.createModifier(ts3.SyntaxKind.ExportKeyword)],
   factory.createVariableDeclarationList(
     [
       factory.createVariableDeclaration(
         factory.createObjectBindingPattern(
-          operationDefinitions.map((operationDefinition) => getReactHookName({ operationDefinition, endpointOverrides, config })).flat()
+          operationDefinitions.map((operationDefinition) => getReactHookName({ operationDefinition, endpointOverrides, config, queryMatch })).flat()
         ),
         void 0,
         void 0,
@@ -366,8 +400,8 @@ function defaultIsDataResponse(code, includeDefault) {
   const parsedCode = Number(code);
   return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
 }
-function getOperationName2({ verb, path: path4 }) {
-  return _getOperationName(verb, path4, void 0);
+function getOperationName2({ verb, path: path5 }) {
+  return _getOperationName(verb, path5, void 0);
 }
 function getTags({ verb, pathItem }) {
   return verb ? pathItem[verb]?.tags || [] : [];
@@ -433,7 +467,9 @@ async function generateApi(spec, {
   useEnumType = false,
   mergeReadWriteOnly = false,
   httpResolverOptions,
-  sharedTypesFile
+  sharedTypesFile,
+  queryMatch,
+  endpointsQueryReturnTypeFile = "./endpointsQueryReturnType"
 }) {
   const v3Doc = v3DocCache[spec] ??= await getV3Doc(spec, httpResolverOptions);
   const apiGen = new ApiGenerator(v3Doc, {
@@ -575,10 +611,10 @@ async function generateApi(spec, {
         }
       }
     }
-    const fs2 = await import("node:fs/promises");
-    const path4 = await import("node:path");
-    const sharedTypesDir = path4.dirname(sharedTypesFile);
-    await fs2.mkdir(sharedTypesDir, { recursive: true });
+    const fs3 = await import("node:fs/promises");
+    const path5 = await import("node:path");
+    const sharedTypesDir = path5.dirname(sharedTypesFile);
+    await fs3.mkdir(sharedTypesDir, { recursive: true });
     const output = printer2.printNode(
       ts4.EmitHint.Unspecified,
       factory.createSourceFile(
@@ -588,7 +624,7 @@ async function generateApi(spec, {
       ),
       resultFile2
     );
-    await fs2.writeFile(sharedTypesFile, output, "utf-8");
+    await fs3.writeFile(sharedTypesFile, output, "utf-8");
   }
   if (apiGen.spec.components?.schemas) {
     apiGen.preprocessComponents(apiGen.spec.components.schemas);
@@ -613,25 +649,32 @@ async function generateApi(spec, {
     return declaration;
   }
   if (outputFile) {
-    outputFile = path2.resolve(process.cwd(), outputFile);
+    outputFile = path3.resolve(process.cwd(), outputFile);
     if (apiFile.startsWith(".")) {
-      apiFile = path2.relative(path2.dirname(outputFile), apiFile);
+      apiFile = path3.relative(path3.dirname(outputFile), apiFile);
       apiFile = apiFile.replace(/\\/g, "/");
       if (!apiFile.startsWith(".")) apiFile = `./${apiFile}`;
     }
+    if (endpointsQueryReturnTypeFile.startsWith(".")) {
+      endpointsQueryReturnTypeFile = path3.relative(path3.dirname(outputFile), endpointsQueryReturnTypeFile);
+      endpointsQueryReturnTypeFile = endpointsQueryReturnTypeFile.replace(/\\/g, "/");
+      if (!endpointsQueryReturnTypeFile.startsWith(".")) endpointsQueryReturnTypeFile = `./${endpointsQueryReturnTypeFile}`;
+    }
   }
   apiFile = apiFile.replace(/\.[jt]sx?$/, "");
+  endpointsQueryReturnTypeFile = endpointsQueryReturnTypeFile.replace(/\.[jt]sx?$/, "");
   const sharedTypesImportPath = sharedTypesFile && outputFile ? (() => {
-    let rel = path2.relative(path2.dirname(outputFile), sharedTypesFile).replace(/\\/g, "/").replace(/\.[jt]sx?$/, "");
+    let rel = path3.relative(path3.dirname(outputFile), sharedTypesFile).replace(/\\/g, "/").replace(/\.[jt]sx?$/, "");
     if (!rel.startsWith(".")) rel = "./" + rel;
     return rel;
   })() : "./shared-types";
-  return printer.printNode(
+  const operationNames = [];
+  const sourceCode = printer.printNode(
     ts4.EmitHint.Unspecified,
     factory.createSourceFile(
       [
         generateImportNode(apiFile, { [apiImport]: "api" }),
-        generateImportNode("@acrool/react-fetcher", { IRestFulEndpointsQueryReturn: "IRestFulEndpointsQueryReturn" }),
+        generateImportNode(endpointsQueryReturnTypeFile, { IRestFulEndpointsQueryReturn: "IRestFulEndpointsQueryReturn" }),
         ...sharedTypesFile ? [
           generateImportNode(sharedTypesImportPath, {
             Scheme: "Scheme",
@@ -642,13 +685,17 @@ async function generateApi(spec, {
         generateCreateApiCall({
           tag,
           endpointDefinitions: factory.createObjectLiteralExpression(
-            operationDefinitions.map(
-              (operationDefinition) => generateEndpoint({
+            operationDefinitions.map((operationDefinition) => {
+              const operationName = getOperationName2({ 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
-              })
-            ),
+                sharedTypesFile: !!sharedTypesFile,
+                queryMatch
+              });
+            }),
             true
           )
         }),
@@ -660,7 +707,8 @@ async function generateApi(spec, {
             exportName: generatedApiName,
             operationDefinitions,
             endpointOverrides,
-            config: hooks
+            config: hooks,
+            queryMatch
           })
         ] : []
       ],
@@ -669,6 +717,10 @@ async function generateApi(spec, {
     ),
     resultFile
   );
+  return {
+    sourceCode,
+    operationNames
+  };
   function extractAllTagTypes({ operationDefinitions: operationDefinitions2 }) {
     const allTagTypes = /* @__PURE__ */ new Set();
     for (const operationDefinition of operationDefinitions2) {
@@ -682,18 +734,19 @@ async function generateApi(spec, {
   function generateEndpoint({
     operationDefinition,
     overrides,
-    sharedTypesFile: sharedTypesFile2
+    sharedTypesFile: sharedTypesFile2,
+    queryMatch: queryMatch2
   }) {
     const {
       verb,
-      path: path4,
+      path: path5,
       pathItem,
       operation,
       operation: { responses, requestBody }
     } = operationDefinition;
-    const operationName = getOperationName2({ verb, path: path4 });
+    const operationName = getOperationName2({ verb, path: path5 });
     const tags = tag ? getTags({ verb, pathItem }) : [];
-    const isQuery2 = isQuery(verb, overrides);
+    const isQuery2 = isQuery(verb, path5, overrides, queryMatch2);
     const returnsJson = apiGen.getResponseType(responses) === "json";
     let ResponseType = factory.createKeywordTypeNode(ts4.SyntaxKind.UnknownKeyword);
     if (returnsJson) {
@@ -842,7 +895,7 @@ async function generateApi(spec, {
     encodePathParams: encodePathParams2,
     encodeQueryParams: encodeQueryParams2
   }) {
-    const { path: path4, verb, operation } = operationDefinition;
+    const { path: path5, 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"));
@@ -889,7 +942,7 @@ async function generateApi(spec, {
           [
             factory.createPropertyAssignment(
               factory.createIdentifier("url"),
-              generatePathExpression(path4, pickParams("path"), variablesObject, isFlatArg, encodePathParams2)
+              generatePathExpression(path5, pickParams("path"), variablesObject, isFlatArg, encodePathParams2)
             ),
             isQuery2 && verb.toUpperCase() === "GET" ? void 0 : factory.createPropertyAssignment(
               factory.createIdentifier("method"),
@@ -1022,12 +1075,12 @@ async function generateApi(spec, {
     return typeNode;
   }
 }
-function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, encodePathParams) {
+function generatePathExpression(path5, pathParameters, rootObject, isFlatArg, encodePathParams) {
   const expressions = [];
-  const head = path4.replace(/\{(.*?)}(.*?)(?=\{|$)/g, (_, expression, literal) => {
+  const head = path5.replace(/\{(.*?)}(.*?)(?=\{|$)/g, (_, expression, literal) => {
     const param = pathParameters.find((p) => p.originalName === expression);
     if (!param) {
-      throw new Error(`path parameter ${expression} does not seem to be defined in '${path4}'!`);
+      throw new Error(`path parameter ${expression} does not seem to be defined in '${path5}'!`);
     }
     expressions.push([param.name, literal]);
     return "";
@@ -1051,82 +1104,81 @@ function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, en
 import camelCase2 from "lodash.camelcase";
 var require2 = createRequire(__filename);
 async function ensureDirectoryExists(filePath) {
-  const dirname = path3.dirname(filePath);
-  if (!fs.existsSync(dirname)) {
-    await fs.promises.mkdir(dirname, { recursive: true });
+  const dirname = path4.dirname(filePath);
+  if (!fs2.existsSync(dirname)) {
+    await fs2.promises.mkdir(dirname, { recursive: true });
   }
 }
 function fileExists(filePath) {
   try {
-    return fs.statSync(filePath).isFile();
+    return fs2.statSync(filePath).isFile();
   } catch {
     return false;
   }
 }
 function getApiNameFromDir(dirPath) {
-  const dirName = path3.basename(dirPath);
+  const dirName = path4.basename(dirPath);
   return `${dirName}Api`;
 }
-async function ensureBaseFilesExist(outputDir) {
-  const enhanceEndpointsPath = path3.join(outputDir, "enhanceEndpoints.ts");
-  const indexPath = path3.join(outputDir, "index.ts");
+async function ensureBaseFilesExist(outputDir, operationNames) {
+  const enhanceEndpointsPath = path4.join(outputDir, "enhanceEndpoints.ts");
+  const indexPath = path4.join(outputDir, "index.ts");
   const apiName = getApiNameFromDir(outputDir);
   if (!fileExists(enhanceEndpointsPath)) {
+    const operationNamesString = operationNames.map((name) => `        ${name}: {},`).join("\n");
     const enhanceEndpointsContent = `import api from './query.generated';
 
 const enhancedApi = api.enhanceEndpoints({
     endpoints: {
+${operationNamesString}
     },
 });
 
 export default enhancedApi;
 `;
-    await fs.promises.writeFile(enhanceEndpointsPath, enhanceEndpointsContent, "utf-8");
+    await fs2.promises.writeFile(enhanceEndpointsPath, enhanceEndpointsContent, "utf-8");
   }
   if (!fileExists(indexPath)) {
     const indexContent = `export * from './query.generated';
 export {default as ${apiName}} from './enhanceEndpoints';
 `;
-    await fs.promises.writeFile(indexPath, indexContent, "utf-8");
+    await fs2.promises.writeFile(indexPath, indexContent, "utf-8");
   }
 }
-function getGroupNameFromPath(path4, pattern) {
-  const match = path4.match(pattern);
-  if (match && match[1]) {
-    return camelCase2(match[1]);
-  }
-  return "common";
-}
 async function generateEndpoints(options) {
-  const schemaLocation = options.schemaFile;
-  const schemaAbsPath = isValidUrl(options.schemaFile) ? options.schemaFile : path3.resolve(process.cwd(), schemaLocation);
-  if (isValidUrl(options.schemaFile) && "outputFiles" in options) {
-    const { outputFiles, ...commonConfig } = options;
-    const openApiDoc = await getV3Doc(options.schemaFile, options.httpResolverOptions);
+  let actualSchemaFile = options.schemaFile;
+  if (options.remoteFile) {
+    actualSchemaFile = await downloadSchemaFile(options.remoteFile, options.schemaFile);
+  }
+  const updatedOptions = {
+    ...options,
+    schemaFile: actualSchemaFile
+  };
+  const schemaLocation = updatedOptions.schemaFile;
+  const schemaAbsPath = path4.resolve(process.cwd(), schemaLocation);
+  if ("outputFiles" in options) {
+    const { outputFiles, ...commonConfig } = updatedOptions;
+    const openApiDoc = await getV3Doc(actualSchemaFile, updatedOptions.httpResolverOptions);
     const paths = Object.keys(openApiDoc.paths);
-    const outputFilesEntries = Object.entries(outputFiles);
-    const [outputPath, config] = outputFilesEntries[0];
-    const patterns = config.groupMatch;
-    const filterEndpoint = config.filterEndpoint;
-    const pattern = patterns;
-    const groupedPaths = paths.reduce((acc, path4) => {
-      const groupName = getGroupNameFromPath(path4, pattern);
-      if (!acc[groupName]) {
-        acc[groupName] = [];
+    const { groupKeyMatch, outputDir, filterEndpoint, queryMatch } = outputFiles;
+    const groupedPaths = paths.reduce((acc, path5) => {
+      const groupKey = camelCase2(groupKeyMatch(path5));
+      if (!acc[groupKey]) {
+        acc[groupKey] = [];
       }
-      acc[groupName].push(path4);
+      acc[groupKey].push(path5);
       return acc;
     }, {});
-    for (const [groupName, paths2] of Object.entries(groupedPaths)) {
-      const finalOutputPath = outputPath.replace("$1", groupName);
+    for (const [groupKey, paths2] of Object.entries(groupedPaths)) {
+      const finalOutputPath = `${outputDir}/${groupKey}/query.generated.ts`;
       if (filterEndpoint) {
         const pathBasedFilter = (operationName, operationDefinition) => {
-          const path4 = operationDefinition.path;
-          const pathGroupName = getGroupNameFromPath(path4, pattern);
-          if (pathGroupName !== groupName) {
+          const path5 = operationDefinition.path;
+          const pathGroupKey = camelCase2(groupKeyMatch(path5));
+          if (pathGroupKey !== groupKey) {
             return false;
           }
-          const endpointFilter = filterEndpoint(groupName);
+          const endpointFilter = filterEndpoint(groupKey);
           if (endpointFilter instanceof RegExp) {
             return endpointFilter.test(operationName);
           }
@@ -1135,45 +1187,49 @@ async function generateEndpoints(options) {
         const groupOptions = {
           ...commonConfig,
           outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter
+          sharedTypesFile: `${outputDir}/shared-types.ts`,
+          filterEndpoints: pathBasedFilter,
+          queryMatch
         };
         await generateSingleEndpoint(groupOptions);
       } else {
         const pathBasedFilter = (operationName, operationDefinition) => {
-          const path4 = operationDefinition.path;
-          const pathGroupName = getGroupNameFromPath(path4, pattern);
-          return pathGroupName === groupName;
+          const path5 = operationDefinition.path;
+          const pathGroupKey = camelCase2(groupKeyMatch(path5));
+          return pathGroupKey === groupKey;
         };
         const groupOptions = {
           ...commonConfig,
           outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter
+          sharedTypesFile: `${outputDir}/shared-types.ts`,
+          filterEndpoints: pathBasedFilter,
+          queryMatch
         };
         await generateSingleEndpoint(groupOptions);
       }
     }
     return;
   }
-  await generateSingleEndpoint(options);
+  await generateSingleEndpoint(updatedOptions);
 }
 async function generateSingleEndpoint(options) {
   const schemaLocation = options.schemaFile;
-  const schemaAbsPath = isValidUrl(options.schemaFile) ? options.schemaFile : path3.resolve(process.cwd(), schemaLocation);
-  const sourceCode = await enforceOazapftsTsVersion(async () => {
+  const schemaAbsPath = path4.resolve(process.cwd(), schemaLocation);
+  const result = await enforceOazapftsTsVersion(async () => {
     return generateApi(schemaAbsPath, options);
   });
   const { outputFile, prettierConfigFile } = options;
   if (outputFile) {
-    const outputPath = path3.resolve(process.cwd(), outputFile);
+    const outputPath = path4.resolve(process.cwd(), outputFile);
     await ensureDirectoryExists(outputPath);
-    const outputDir = path3.dirname(outputPath);
-    await ensureBaseFilesExist(outputDir);
-    fs.writeFileSync(
+    const outputDir = path4.dirname(outputPath);
+    await ensureBaseFilesExist(outputDir, result.operationNames);
+    fs2.writeFileSync(
       outputPath,
-      await prettify(outputFile, sourceCode, prettierConfigFile)
+      await prettify(outputFile, result.sourceCode, prettierConfigFile)
     );
   } else {
-    return await prettify(null, sourceCode, prettierConfigFile);
+    return await prettify(null, result.sourceCode, prettierConfigFile);
   }
 }
 function parseConfig(fullConfig) {
@@ -1181,36 +1237,32 @@ function parseConfig(fullConfig) {
   if ("outputFiles" in fullConfig) {
     const { outputFiles, ...commonConfig } = fullConfig;
     let openApiDoc;
-    if (isValidUrl(fullConfig.schemaFile)) {
+    if (fullConfig.remoteFile) {
       outFiles.push(fullConfig);
       return outFiles;
     } else {
-      openApiDoc = JSON.parse(fs.readFileSync(fullConfig.schemaFile, "utf-8"));
+      openApiDoc = JSON.parse(fs2.readFileSync(fullConfig.schemaFile, "utf-8"));
     }
     const paths = Object.keys(openApiDoc.paths);
-    const outputFilesEntries = Object.entries(outputFiles);
-    const [outputPath, config] = outputFilesEntries[0];
-    const patterns = config.groupMatch;
-    const filterEndpoint = config.filterEndpoint;
-    const pattern = patterns;
-    const groupedPaths = paths.reduce((acc, path4) => {
-      const groupName = getGroupNameFromPath(path4, pattern);
-      if (!acc[groupName]) {
-        acc[groupName] = [];
+    const { groupKeyMatch, outputDir, filterEndpoint, queryMatch } = outputFiles;
+    const groupedPaths = paths.reduce((acc, path5) => {
+      const groupKey = camelCase2(groupKeyMatch(path5));
+      if (!acc[groupKey]) {
+        acc[groupKey] = [];
       }
-      acc[groupName].push(path4);
+      acc[groupKey].push(path5);
       return acc;
     }, {});
-    Object.entries(groupedPaths).forEach(([groupName, paths2]) => {
-      const finalOutputPath = outputPath.replace("$1", groupName);
+    Object.entries(groupedPaths).forEach(([groupKey, paths2]) => {
+      const finalOutputPath = `${outputDir}/${groupKey}/query.generated.ts`;
       if (filterEndpoint) {
         const pathBasedFilter = (operationName, operationDefinition) => {
-          const path4 = operationDefinition.path;
-          const pathGroupName = getGroupNameFromPath(path4, pattern);
-          if (pathGroupName !== groupName) {
+          const path5 = operationDefinition.path;
+          const pathGroupKey = camelCase2(groupKeyMatch(path5));
+          if (pathGroupKey !== groupKey) {
             return false;
           }
-          const endpointFilter = filterEndpoint(groupName);
+          const endpointFilter = filterEndpoint(groupKey);
           if (endpointFilter instanceof RegExp) {
             return endpointFilter.test(operationName);
           }
@@ -1219,18 +1271,22 @@ function parseConfig(fullConfig) {
         outFiles.push({
           ...commonConfig,
           outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter
+          sharedTypesFile: `${outputDir}/shared-types.ts`,
+          filterEndpoints: pathBasedFilter,
+          queryMatch
         });
       } else {
         const pathBasedFilter = (operationName, operationDefinition) => {
-          const path4 = operationDefinition.path;
-          const pathGroupName = getGroupNameFromPath(path4, pattern);
-          return pathGroupName === groupName;
+          const path5 = operationDefinition.path;
+          const pathGroupKey = camelCase2(groupKeyMatch(path5));
+          return pathGroupKey === groupKey;
         };
         outFiles.push({
           ...commonConfig,
           outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter
+          sharedTypesFile: `${outputDir}/shared-types.ts`,
+          filterEndpoints: pathBasedFilter,
+          queryMatch
         });
       }
     });