@acrool/rtk-query-codegen-openapi 0.0.2-test.9 → 0.0.2

package/lib/index.d.mts

@@ -130,17 +130,13 @@ type EndpointOverrides = {
     type: 'mutation' | 'query';
     parameterFilter: ParameterMatcher;
 }>;
-type OutputFilesConfig = {
-    [outputFile: string]: {
-        groupMatch: RegExp;
-        filterEndpoint?: (groupName: string) => RegExp;
-    };
-};
 type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {
-    outputFiles: OutputFilesConfig;
+    outputFiles: {
+        [outputFile: string]: Omit<OutputFileOptions, 'outputFile'>;
+    };
 }>;
 
 declare function generateEndpoints(options: GenerationOptions): Promise<string | void>;
 declare function parseConfig(fullConfig: ConfigFile): (CommonOptions & OutputFileOptions)[];
 
-export { type ConfigFile, type OutputFilesConfig, generateEndpoints, parseConfig };
+export { type ConfigFile, generateEndpoints, parseConfig };

package/lib/index.d.ts

@@ -130,17 +130,13 @@ type EndpointOverrides = {
     type: 'mutation' | 'query';
     parameterFilter: ParameterMatcher;
 }>;
-type OutputFilesConfig = {
-    [outputFile: string]: {
-        groupMatch: RegExp;
-        filterEndpoint?: (groupName: string) => RegExp;
-    };
-};
 type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {
-    outputFiles: OutputFilesConfig;
+    outputFiles: {
+        [outputFile: string]: Omit<OutputFileOptions, 'outputFile'>;
+    };
 }>;
 
 declare function generateEndpoints(options: GenerationOptions): Promise<string | void>;
 declare function parseConfig(fullConfig: ConfigFile): (CommonOptions & OutputFileOptions)[];
 
-export { type ConfigFile, type OutputFilesConfig, generateEndpoints, parseConfig };
+export { type ConfigFile, generateEndpoints, parseConfig };

package/lib/index.js

@@ -326,14 +326,14 @@ function removeUndefined(t) {
 
 // src/generators/react-hooks.ts
 var createBinding = ({
-  operationDefinition: { verb, path: path4 },
+  operationDefinition: { verb, path: path4, operation },
   overrides,
   isLazy = false
 }) => factory.createBindingElement(
   void 0,
   void 0,
   factory.createIdentifier(
-    `use${isLazy ? "Lazy" : ""}${capitalize((0, import_generate.getOperationName)(verb, path4, void 0))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
+    `use${isLazy ? "Lazy" : ""}${capitalize((0, import_generate.getOperationName)(verb, path4, operation.operationId))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
   ),
   void 0
 );
@@ -387,8 +387,8 @@ function defaultIsDataResponse(code, includeDefault) {
   const parsedCode = Number(code);
   return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
 }
-function getOperationName2({ verb, path: path4 }) {
-  return (0, import_generate3.getOperationName)(verb, path4, void 0);
+function getOperationName2({ verb, path: path4, operation }) {
+  return (0, import_generate3.getOperationName)(verb, path4, operation.operationId);
 }
 function getTags({ verb, pathItem }) {
   return verb ? pathItem[verb]?.tags || [] : [];
@@ -462,153 +462,41 @@ async function generateApi(spec, {
     useEnumType,
     mergeReadWriteOnly
   });
-  const schemeTypeNames = /* @__PURE__ */ new Set();
-  function addSchemeTypeName(name) {
-    schemeTypeNames.add(name);
-    schemeTypeNames.add((0, import_lodash.default)(name));
-    schemeTypeNames.add(capitalize((0, import_lodash.default)(name)));
-  }
   if (sharedTypesFile) {
-    const resultFile2 = import_typescript4.default.createSourceFile(
-      "sharedTypes.ts",
-      "",
-      import_typescript4.default.ScriptTarget.Latest,
-      /*setParentNodes*/
-      false,
-      import_typescript4.default.ScriptKind.TS
-    );
-    const printer2 = import_typescript4.default.createPrinter({ newLine: import_typescript4.default.NewLineKind.LineFeed });
-    const allTypeDefinitions = [];
-    const definedTypeNames = /* @__PURE__ */ new Set();
     const components = v3Doc.components;
     if (components) {
-      const componentDefinitions = Object.entries(components).map(([componentType, componentDefs]) => {
-        const typeEntries = Object.entries(componentDefs).map(([name, def]) => {
-          addSchemeTypeName(name);
-          const typeName = capitalize((0, import_lodash.default)(name));
-          definedTypeNames.add(typeName);
-          const typeNode = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(def));
+      const resultFile2 = import_typescript4.default.createSourceFile(
+        "sharedTypes.ts",
+        "",
+        import_typescript4.default.ScriptTarget.Latest,
+        /*setParentNodes*/
+        false,
+        import_typescript4.default.ScriptKind.TS
+      );
+      const printer2 = import_typescript4.default.createPrinter({ newLine: import_typescript4.default.NewLineKind.LineFeed });
+      const typeDefinitions = Object.entries(components).flatMap(([_, componentDefs]) => {
+        return Object.entries(componentDefs).map(([name, def]) => {
+          const typeNode = apiGen.getTypeFromSchema(def);
           return factory.createTypeAliasDeclaration(
             [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-            factory.createIdentifier(typeName),
+            factory.createIdentifier(name),
             void 0,
             typeNode
           );
         });
-        return factory.createModuleDeclaration(
-          [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-          factory.createIdentifier("Scheme"),
-          factory.createModuleBlock(typeEntries),
-          import_typescript4.default.NodeFlags.Namespace
-        );
       });
-      allTypeDefinitions.push(...componentDefinitions);
-    }
-    const enumEntries = [
-      ...apiGen.enumAliases.filter((e) => import_typescript4.default.isEnumDeclaration(e)),
-      ...apiGen.enumAliases.filter((e) => import_typescript4.default.isTypeAliasDeclaration(e))
-    ].map((enumDecl) => {
-      if (import_typescript4.default.isEnumDeclaration(enumDecl)) {
-        return factory.createEnumDeclaration(
-          [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-          enumDecl.name,
-          enumDecl.members
-        );
-      } else if (import_typescript4.default.isTypeAliasDeclaration(enumDecl)) {
-        return factory.createTypeAliasDeclaration(
-          [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-          enumDecl.name,
-          enumDecl.typeParameters,
-          enumDecl.type
-        );
-      }
-      return enumDecl;
-    });
-    const unionTypeEnums = apiGen.aliases.filter((alias) => {
-      if (import_typescript4.default.isTypeAliasDeclaration(alias) && alias.type) {
-        return import_typescript4.default.isUnionTypeNode(alias.type);
-      }
-      return false;
-    }).map((alias) => {
-      if (import_typescript4.default.isTypeAliasDeclaration(alias)) {
-        return factory.createTypeAliasDeclaration(
-          [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-          alias.name,
-          alias.typeParameters,
-          alias.type
-        );
-      }
-      return alias;
-    });
-    const allEnumEntries = [...enumEntries, ...unionTypeEnums];
-    if (allEnumEntries.length > 0) {
-      allTypeDefinitions.push(
-        factory.createModuleDeclaration(
-          [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-          factory.createIdentifier("Enum"),
-          factory.createModuleBlock(allEnumEntries),
-          import_typescript4.default.NodeFlags.Namespace
-        )
+      const output = printer2.printNode(
+        import_typescript4.default.EmitHint.Unspecified,
+        factory.createSourceFile(
+          typeDefinitions,
+          factory.createToken(import_typescript4.default.SyntaxKind.EndOfFileToken),
+          import_typescript4.default.NodeFlags.None
+        ),
+        resultFile2
       );
+      const fs2 = await import("node:fs/promises");
+      await fs2.writeFile(sharedTypesFile, output, "utf-8");
     }
-    if (apiGen.aliases.length > 0) {
-      const aliasEntries = apiGen.aliases.filter((alias) => {
-        if (import_typescript4.default.isTypeAliasDeclaration(alias)) {
-          const isDefinedInComponents = definedTypeNames.has(alias.name.text);
-          const isUnionTypeEnum = import_typescript4.default.isUnionTypeNode(alias.type);
-          return !isDefinedInComponents && !isUnionTypeEnum;
-        }
-        return false;
-      }).map((alias) => {
-        if (import_typescript4.default.isTypeAliasDeclaration(alias)) {
-          return factory.createTypeAliasDeclaration(
-            [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-            alias.name,
-            alias.typeParameters,
-            alias.type
-          );
-        }
-        return alias;
-      });
-      if (aliasEntries.length > 0) {
-        const existingSchemeIndex = allTypeDefinitions.findIndex(
-          (def) => import_typescript4.default.isModuleDeclaration(def) && import_typescript4.default.isIdentifier(def.name) && def.name.text === "Scheme"
-        );
-        if (existingSchemeIndex >= 0) {
-          const existingScheme = allTypeDefinitions[existingSchemeIndex];
-          const mergedMembers = [...existingScheme.body.statements, ...aliasEntries];
-          allTypeDefinitions[existingSchemeIndex] = factory.createModuleDeclaration(
-            [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-            factory.createIdentifier("Scheme"),
-            factory.createModuleBlock(mergedMembers),
-            import_typescript4.default.NodeFlags.Namespace
-          );
-        } else {
-          allTypeDefinitions.push(
-            factory.createModuleDeclaration(
-              [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
-              factory.createIdentifier("Scheme"),
-              factory.createModuleBlock(aliasEntries),
-              import_typescript4.default.NodeFlags.Namespace
-            )
-          );
-        }
-      }
-    }
-    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 output = printer2.printNode(
-      import_typescript4.default.EmitHint.Unspecified,
-      factory.createSourceFile(
-        allTypeDefinitions,
-        factory.createToken(import_typescript4.default.SyntaxKind.EndOfFileToken),
-        import_typescript4.default.NodeFlags.None
-      ),
-      resultFile2
-    );
-    await fs2.writeFile(sharedTypesFile, output, "utf-8");
   }
   if (apiGen.spec.components?.schemas) {
     apiGen.preprocessComponents(apiGen.spec.components.schemas);
@@ -639,13 +527,16 @@ async function generateApi(spec, {
       apiFile = apiFile.replace(/\\/g, "/");
       if (!apiFile.startsWith(".")) apiFile = `./${apiFile}`;
     }
+    if (sharedTypesFile && sharedTypesFile.startsWith(".")) {
+      sharedTypesFile = import_node_path2.default.relative(import_node_path2.default.dirname(outputFile), sharedTypesFile);
+      sharedTypesFile = sharedTypesFile.replace(/\\/g, "/");
+      if (!sharedTypesFile.startsWith(".")) sharedTypesFile = `./${sharedTypesFile}`;
+    }
   }
   apiFile = apiFile.replace(/\.[jt]sx?$/, "");
-  const sharedTypesImportPath = sharedTypesFile && outputFile ? (() => {
-    let rel = import_node_path2.default.relative(import_node_path2.default.dirname(outputFile), sharedTypesFile).replace(/\\/g, "/").replace(/\.[jt]sx?$/, "");
-    if (!rel.startsWith(".")) rel = "./" + rel;
-    return rel;
-  })() : "./shared-types";
+  if (sharedTypesFile) {
+    sharedTypesFile = sharedTypesFile.replace(/\.[jt]sx?$/, "");
+  }
   return printer.printNode(
     import_typescript4.default.EmitHint.Unspecified,
     factory.createSourceFile(
@@ -653,10 +544,16 @@ async function generateApi(spec, {
         generateImportNode(apiFile, { [apiImport]: "api" }),
         generateImportNode("@acrool/react-fetcher", { IRestFulEndpointsQueryReturn: "IRestFulEndpointsQueryReturn" }),
         ...sharedTypesFile ? [
-          generateImportNode(sharedTypesImportPath, {
-            Scheme: "Scheme",
-            ...useEnumType ? { Enum: "Enum" } : {}
-          })
+          factory.createImportDeclaration(
+            void 0,
+            factory.createImportClause(
+              false,
+              void 0,
+              factory.createNamespaceImport(factory.createIdentifier("SharedTypes"))
+            ),
+            factory.createStringLiteral(sharedTypesFile),
+            void 0
+          )
         ] : [],
         ...tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : [],
         generateCreateApiCall({
@@ -665,8 +562,7 @@ async function generateApi(spec, {
             operationDefinitions.map(
               (operationDefinition) => generateEndpoint({
                 operationDefinition,
-                overrides: getOverrides(operationDefinition, endpointOverrides),
-                sharedTypesFile: !!sharedTypesFile
+                overrides: getOverrides(operationDefinition, endpointOverrides)
               })
             ),
             true
@@ -705,8 +601,7 @@ async function generateApi(spec, {
   }
   function generateEndpoint({
     operationDefinition,
-    overrides,
-    sharedTypesFile: sharedTypesFile2
+    overrides
   }) {
     const {
       verb,
@@ -715,30 +610,60 @@ async function generateApi(spec, {
       operation,
       operation: { responses, requestBody }
     } = operationDefinition;
-    const operationName = getOperationName2({ verb, path: path4 });
+    const operationName = getOperationName2({ verb, path: path4, operation });
     const tags = tag ? getTags({ verb, pathItem }) : [];
     const isQuery2 = isQuery(verb, overrides);
     const returnsJson = apiGen.getResponseType(responses) === "json";
     let ResponseType = factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.UnknownKeyword);
+    function replaceReferences(schema) {
+      if (!schema) return factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.UnknownKeyword);
+      const refName = (0, import_generate3.getReferenceName)(schema);
+      if (refName && sharedTypesFile) {
+        return factory.createTypeReferenceNode(
+          factory.createQualifiedName(
+            factory.createIdentifier("SharedTypes"),
+            factory.createIdentifier(refName)
+          ),
+          void 0
+        );
+      }
+      if (schema.type === "object" && schema.properties) {
+        const members = Object.entries(schema.properties).map(([key, value]) => {
+          return factory.createPropertySignature(
+            void 0,
+            factory.createIdentifier(key),
+            schema.required?.includes(key) ? void 0 : factory.createToken(import_typescript4.default.SyntaxKind.QuestionToken),
+            replaceReferences(value)
+          );
+        });
+        return factory.createTypeLiteralNode(members);
+      }
+      if (schema.type === "array" && schema.items) {
+        return factory.createArrayTypeNode(replaceReferences(schema.items));
+      }
+      return apiGen.getTypeFromSchema(schema);
+    }
     if (returnsJson) {
       const returnTypes = Object.entries(responses || {}).map(
-        ([code, response]) => [
-          code,
-          apiGen.resolve(response),
-          wrapWithSchemeIfComponent(
-            apiGen.getTypeFromResponse(response, "readOnly") || factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.UndefinedKeyword)
-          )
-        ]
+        ([code, response]) => {
+          const resolvedResponse = apiGen.resolve(response);
+          if (!resolvedResponse.content?.["application/json"]?.schema) {
+            return [code, resolvedResponse, factory.createKeywordTypeNode(import_typescript4.default.SyntaxKind.UndefinedKeyword)];
+          }
+          const schema = resolvedResponse.content["application/json"].schema;
+          const type = replaceReferences(schema);
+          return [code, resolvedResponse, type];
+        }
       ).filter(
         ([status, response]) => isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
-      ).filter(([_1, _2, type]) => type !== import_generate3.keywordType.void).map(([code, response, type]) => {
-        return import_typescript4.default.addSyntheticLeadingComment(
-          type,
+      ).filter(([_1, _2, type]) => type !== import_generate3.keywordType.void).map(
+        ([code, response, type]) => import_typescript4.default.addSyntheticLeadingComment(
+          { ...type },
           import_typescript4.default.SyntaxKind.MultiLineCommentTrivia,
           `* status ${code} ${response.description} `,
           false
-        );
-      });
+        )
+      );
       if (returnTypes.length > 0) {
         ResponseType = factory.createUnionTypeNode(returnTypes);
       }
@@ -773,21 +698,10 @@ async function generateApi(spec, {
       }
       return name;
     }
-    for (const param of parameters) {
-      const name = generateName(param.name, param.in);
-      queryArg[name] = {
-        origin: "param",
-        name,
-        originalName: param.name,
-        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema((0, import_generate3.isReference)(param) ? param : param.schema, void 0, "writeOnly")),
-        required: param.required,
-        param
-      };
-    }
     if (requestBody) {
       const body = apiGen.resolve(requestBody);
       const schema = apiGen.getSchemaFromContent(body.content);
-      const type = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema));
+      const type = replaceReferences(schema);
       const schemaName = (0, import_lodash.default)(
         type.name || (0, import_generate3.getReferenceName)(schema) || typeof schema === "object" && "title" in schema && schema.title || "body"
       );
@@ -796,11 +710,24 @@ async function generateApi(spec, {
         origin: "body",
         name,
         originalName: schemaName,
-        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema, void 0, "writeOnly")),
+        type,
         required: true,
         body
       };
     }
+    for (const param of parameters) {
+      const name = generateName(param.name, param.in);
+      const paramSchema = (0, import_generate3.isReference)(param) ? param : param.schema;
+      const type = replaceReferences(paramSchema);
+      queryArg[name] = {
+        origin: "param",
+        name,
+        originalName: param.name,
+        type,
+        required: param.required,
+        param
+      };
+    }
     const propertyName = (name) => {
       if (typeof name === "string") {
         return (0, import_generate3.isValidIdentifier)(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
@@ -937,105 +864,6 @@ async function generateApi(spec, {
   function generateMutationEndpointProps({}) {
     return {};
   }
-  function wrapWithSchemeIfComponent(typeNode) {
-    if (import_typescript4.default.isTypeReferenceNode(typeNode) && import_typescript4.default.isIdentifier(typeNode.typeName)) {
-      const typeName = typeNode.typeName.text;
-      const isEnumType = useEnumType && (apiGen.enumAliases.some((enumDecl) => {
-        if (import_typescript4.default.isEnumDeclaration(enumDecl) || import_typescript4.default.isTypeAliasDeclaration(enumDecl)) {
-          return enumDecl.name.text === typeName;
-        }
-        return false;
-      }) || apiGen.aliases.some((alias) => {
-        if (import_typescript4.default.isTypeAliasDeclaration(alias) && alias.type) {
-          if (import_typescript4.default.isUnionTypeNode(alias.type)) {
-            return alias.name.text === typeName;
-          }
-        }
-        return false;
-      }));
-      if (isEnumType) {
-        return factory.createTypeReferenceNode(
-          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
-          ),
-          typeNode.typeArguments?.map(wrapWithSchemeIfComponent)
-        );
-      }
-      if (typeNode.typeArguments) {
-        return factory.createTypeReferenceNode(
-          typeNode.typeName,
-          typeNode.typeArguments.map(wrapWithSchemeIfComponent)
-        );
-      }
-    }
-    if (import_typescript4.default.isArrayTypeNode(typeNode)) {
-      return factory.createArrayTypeNode(wrapWithSchemeIfComponent(typeNode.elementType));
-    }
-    if (import_typescript4.default.isUnionTypeNode(typeNode)) {
-      const unionTypes = typeNode.types;
-      if (unionTypes.length > 0 && unionTypes.every(
-        (type) => import_typescript4.default.isLiteralTypeNode(type) && (import_typescript4.default.isStringLiteral(type.literal) || import_typescript4.default.isNumericLiteral(type.literal))
-      )) {
-        const enumValues = unionTypes.map((type) => {
-          if (import_typescript4.default.isLiteralTypeNode(type)) {
-            if (import_typescript4.default.isStringLiteral(type.literal)) {
-              return type.literal.text;
-            } else if (import_typescript4.default.isNumericLiteral(type.literal)) {
-              return type.literal.text;
-            }
-          }
-          return null;
-        }).filter(Boolean);
-        const matchingEnum = apiGen.aliases.find((alias) => {
-          if (import_typescript4.default.isTypeAliasDeclaration(alias) && import_typescript4.default.isUnionTypeNode(alias.type)) {
-            const aliasValues = alias.type.types.map((type) => {
-              if (import_typescript4.default.isLiteralTypeNode(type)) {
-                if (import_typescript4.default.isStringLiteral(type.literal)) {
-                  return type.literal.text;
-                } else if (import_typescript4.default.isNumericLiteral(type.literal)) {
-                  return type.literal.text;
-                }
-              }
-              return null;
-            }).filter(Boolean);
-            return aliasValues.length === enumValues.length && aliasValues.every((val) => enumValues.includes(val));
-          }
-          return false;
-        });
-        if (matchingEnum && import_typescript4.default.isTypeAliasDeclaration(matchingEnum)) {
-          return typeNode;
-        }
-      }
-      return factory.createUnionTypeNode(typeNode.types.map(wrapWithSchemeIfComponent));
-    }
-    if (import_typescript4.default.isTypeLiteralNode(typeNode)) {
-      return factory.createTypeLiteralNode(
-        typeNode.members.map((member) => {
-          if (import_typescript4.default.isPropertySignature(member) && member.type) {
-            return factory.updatePropertySignature(
-              member,
-              member.modifiers,
-              member.name,
-              member.questionToken,
-              wrapWithSchemeIfComponent(member.type)
-            );
-          }
-          return member;
-        })
-      );
-    }
-    return typeNode;
-  }
 }
 function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, encodePathParams) {
   const expressions = [];
@@ -1063,55 +891,7 @@ function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, en
 }
 
 // src/index.ts
-var import_lodash2 = __toESM(require("lodash.camelcase"));
 var require2 = (0, import_node_module.createRequire)(__filename);
-async function ensureDirectoryExists(filePath) {
-  const dirname = import_node_path3.default.dirname(filePath);
-  if (!import_node_fs.default.existsSync(dirname)) {
-    await import_node_fs.default.promises.mkdir(dirname, { recursive: true });
-  }
-}
-function fileExists(filePath) {
-  try {
-    return import_node_fs.default.statSync(filePath).isFile();
-  } catch {
-    return false;
-  }
-}
-function getApiNameFromDir(dirPath) {
-  const dirName = import_node_path3.default.basename(dirPath);
-  return `${dirName}Api`;
-}
-async function ensureBaseFilesExist(outputDir) {
-  const enhanceEndpointsPath = import_node_path3.default.join(outputDir, "enhanceEndpoints.ts");
-  const indexPath = import_node_path3.default.join(outputDir, "index.ts");
-  const apiName = getApiNameFromDir(outputDir);
-  if (!fileExists(enhanceEndpointsPath)) {
-    const enhanceEndpointsContent = `import api from './query.generated';
-
-const enhancedApi = api.enhanceEndpoints({
-    endpoints: {
-    },
-});
-
-export default enhancedApi;
-`;
-    await import_node_fs.default.promises.writeFile(enhanceEndpointsPath, enhanceEndpointsContent, "utf-8");
-  }
-  if (!fileExists(indexPath)) {
-    const indexContent = `export * from './query.generated';
-export {default as ${apiName}} from './enhanceEndpoints';
-`;
-    await import_node_fs.default.promises.writeFile(indexPath, indexContent, "utf-8");
-  }
-}
-function getGroupNameFromPath(path4, pattern) {
-  const match = path4.match(pattern);
-  if (match && match[1]) {
-    return (0, import_lodash2.default)(match[1]);
-  }
-  return "common";
-}
 async function generateEndpoints(options) {
   const schemaLocation = options.schemaFile;
   const schemaAbsPath = isValidUrl(options.schemaFile) ? options.schemaFile : import_node_path3.default.resolve(process.cwd(), schemaLocation);
@@ -1120,12 +900,8 @@ async function generateEndpoints(options) {
   });
   const { outputFile, prettierConfigFile } = options;
   if (outputFile) {
-    const outputPath = import_node_path3.default.resolve(process.cwd(), outputFile);
-    await ensureDirectoryExists(outputPath);
-    const outputDir = import_node_path3.default.dirname(outputPath);
-    await ensureBaseFilesExist(outputDir);
     import_node_fs.default.writeFileSync(
-      outputPath,
+      import_node_path3.default.resolve(process.cwd(), outputFile),
       await prettify(outputFile, sourceCode, prettierConfigFile)
     );
   } else {
@@ -1136,53 +912,13 @@ function parseConfig(fullConfig) {
   const outFiles = [];
   if ("outputFiles" in fullConfig) {
     const { outputFiles, ...commonConfig } = fullConfig;
-    const openApiDoc = JSON.parse(import_node_fs.default.readFileSync(fullConfig.schemaFile, "utf-8"));
-    const paths = Object.keys(openApiDoc.paths);
-    const [outputPath, config] = Object.entries(outputFiles)[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] = [];
-      }
-      acc[groupName].push(path4);
-      return acc;
-    }, {});
-    Object.entries(groupedPaths).forEach(([groupName, paths2]) => {
-      const finalOutputPath = outputPath.replace("$1", groupName);
-      if (filterEndpoint) {
-        const pathBasedFilter = (operationName, operationDefinition) => {
-          const path4 = operationDefinition.path;
-          const pathGroupName = getGroupNameFromPath(path4, pattern);
-          if (pathGroupName !== groupName) {
-            return false;
-          }
-          const endpointFilter = filterEndpoint(groupName);
-          if (endpointFilter instanceof RegExp) {
-            return endpointFilter.test(operationName);
-          }
-          return true;
-        };
-        outFiles.push({
-          ...commonConfig,
-          outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter
-        });
-      } else {
-        const pathBasedFilter = (operationName, operationDefinition) => {
-          const path4 = operationDefinition.path;
-          const pathGroupName = getGroupNameFromPath(path4, pattern);
-          return pathGroupName === groupName;
-        };
-        outFiles.push({
-          ...commonConfig,
-          outputFile: finalOutputPath,
-          filterEndpoints: pathBasedFilter
-        });
-      }
-    });
+    for (const [outputFile, specificConfig] of Object.entries(outputFiles)) {
+      outFiles.push({
+        ...commonConfig,
+        ...specificConfig,
+        outputFile
+      });
+    }
   } else {
     outFiles.push(fullConfig);
   }