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

package/lib/index.mjs

@@ -305,14 +305,14 @@ function removeUndefined(t) {
 
 // src/generators/react-hooks.ts
 var createBinding = ({
-  operationDefinition: { verb, path: path4, operation },
+  operationDefinition: { verb, path: path4 },
   overrides,
   isLazy = false
 }) => factory.createBindingElement(
   void 0,
   void 0,
   factory.createIdentifier(
-    `use${isLazy ? "Lazy" : ""}${capitalize(getOperationName(verb, path4, operation.operationId))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
+    `use${isLazy ? "Lazy" : ""}${capitalize(getOperationName(verb, path4, void 0))}${isQuery(verb, overrides) ? "Query" : "Mutation"}`
   ),
   void 0
 );
@@ -366,8 +366,8 @@ function defaultIsDataResponse(code, includeDefault) {
   const parsedCode = Number(code);
   return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
 }
-function getOperationName2({ verb, path: path4, operation }) {
-  return _getOperationName(verb, path4, operation.operationId);
+function getOperationName2({ verb, path: path4 }) {
+  return _getOperationName(verb, path4, void 0);
 }
 function getTags({ verb, pathItem }) {
   return verb ? pathItem[verb]?.tags || [] : [];
@@ -441,41 +441,154 @@ async function generateApi(spec, {
     useEnumType,
     mergeReadWriteOnly
   });
+  const schemeTypeNames = /* @__PURE__ */ new Set();
+  function addSchemeTypeName(name) {
+    schemeTypeNames.add(name);
+    schemeTypeNames.add(camelCase(name));
+    schemeTypeNames.add(capitalize(camelCase(name)));
+  }
   if (sharedTypesFile) {
+    const resultFile2 = ts4.createSourceFile(
+      "sharedTypes.ts",
+      "",
+      ts4.ScriptTarget.Latest,
+      /*setParentNodes*/
+      false,
+      ts4.ScriptKind.TS
+    );
+    const printer2 = ts4.createPrinter({ newLine: ts4.NewLineKind.LineFeed });
+    const allTypeDefinitions = [];
+    const definedTypeNames = /* @__PURE__ */ new Set();
     const components = v3Doc.components;
     if (components) {
-      const resultFile2 = ts4.createSourceFile(
-        "sharedTypes.ts",
-        "",
-        ts4.ScriptTarget.Latest,
-        /*setParentNodes*/
-        false,
-        ts4.ScriptKind.TS
-      );
-      const printer2 = ts4.createPrinter({ newLine: ts4.NewLineKind.LineFeed });
-      const typeDefinitions = Object.entries(components).flatMap(([_, componentDefs]) => {
-        return Object.entries(componentDefs).map(([name, def]) => {
-          const typeNode = apiGen.getTypeFromSchema(def);
+      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));
           return factory.createTypeAliasDeclaration(
             [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
-            factory.createIdentifier(name),
+            factory.createIdentifier(typeName),
             void 0,
             typeNode
           );
         });
-      });
-      const output = printer2.printNode(
-        ts4.EmitHint.Unspecified,
-        factory.createSourceFile(
-          typeDefinitions,
-          factory.createToken(ts4.SyntaxKind.EndOfFileToken),
-          ts4.NodeFlags.None
-        ),
-        resultFile2
+        allTypeDefinitions.push(
+          factory.createModuleDeclaration(
+            [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier("Scheme"),
+            factory.createModuleBlock(typeEntries),
+            ts4.NodeFlags.Namespace
+          )
+        );
+      }
+    }
+    const enumEntries = [
+      ...apiGen.enumAliases.filter((e) => ts4.isEnumDeclaration(e)),
+      ...apiGen.enumAliases.filter((e) => ts4.isTypeAliasDeclaration(e))
+    ].map((enumDecl) => {
+      if (ts4.isEnumDeclaration(enumDecl)) {
+        return factory.createEnumDeclaration(
+          [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+          enumDecl.name,
+          enumDecl.members
+        );
+      } else if (ts4.isTypeAliasDeclaration(enumDecl)) {
+        return factory.createTypeAliasDeclaration(
+          [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+          enumDecl.name,
+          enumDecl.typeParameters,
+          enumDecl.type
+        );
+      }
+      return enumDecl;
+    });
+    const unionTypeEnums = apiGen.aliases.filter((alias) => {
+      if (ts4.isTypeAliasDeclaration(alias) && alias.type) {
+        return ts4.isUnionTypeNode(alias.type);
+      }
+      return false;
+    }).map((alias) => {
+      if (ts4.isTypeAliasDeclaration(alias)) {
+        return factory.createTypeAliasDeclaration(
+          [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+          alias.name,
+          alias.typeParameters,
+          alias.type
+        );
+      }
+      return alias;
+    });
+    const allEnumEntries = [...enumEntries, ...unionTypeEnums];
+    if (allEnumEntries.length > 0) {
+      allTypeDefinitions.push(
+        factory.createModuleDeclaration(
+          [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+          factory.createIdentifier("Enum"),
+          factory.createModuleBlock(allEnumEntries),
+          ts4.NodeFlags.Namespace
+        )
       );
-      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 (ts4.isTypeAliasDeclaration(alias)) {
+          const isDefinedInComponents = definedTypeNames.has(alias.name.text);
+          const isUnionTypeEnum = ts4.isUnionTypeNode(alias.type);
+          return !isDefinedInComponents && !isUnionTypeEnum;
+        }
+        return false;
+      }).map((alias) => {
+        if (ts4.isTypeAliasDeclaration(alias)) {
+          return factory.createTypeAliasDeclaration(
+            [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+            alias.name,
+            alias.typeParameters,
+            alias.type
+          );
+        }
+        return alias;
+      });
+      if (aliasEntries.length > 0) {
+        const existingSchemeIndex = allTypeDefinitions.findIndex(
+          (def) => ts4.isModuleDeclaration(def) && ts4.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(ts4.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier("Scheme"),
+            factory.createModuleBlock(mergedMembers),
+            ts4.NodeFlags.Namespace
+          );
+        } else {
+          allTypeDefinitions.push(
+            factory.createModuleDeclaration(
+              [factory.createModifier(ts4.SyntaxKind.ExportKeyword)],
+              factory.createIdentifier("Scheme"),
+              factory.createModuleBlock(aliasEntries),
+              ts4.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(
+      ts4.EmitHint.Unspecified,
+      factory.createSourceFile(
+        allTypeDefinitions,
+        factory.createToken(ts4.SyntaxKind.EndOfFileToken),
+        ts4.NodeFlags.None
+      ),
+      resultFile2
+    );
+    await fs2.writeFile(sharedTypesFile, output, "utf-8");
   }
   if (apiGen.spec.components?.schemas) {
     apiGen.preprocessComponents(apiGen.spec.components.schemas);
@@ -506,16 +619,13 @@ async function generateApi(spec, {
       apiFile = apiFile.replace(/\\/g, "/");
       if (!apiFile.startsWith(".")) apiFile = `./${apiFile}`;
     }
-    if (sharedTypesFile && sharedTypesFile.startsWith(".")) {
-      sharedTypesFile = path2.relative(path2.dirname(outputFile), sharedTypesFile);
-      sharedTypesFile = sharedTypesFile.replace(/\\/g, "/");
-      if (!sharedTypesFile.startsWith(".")) sharedTypesFile = `./${sharedTypesFile}`;
-    }
   }
   apiFile = apiFile.replace(/\.[jt]sx?$/, "");
-  if (sharedTypesFile) {
-    sharedTypesFile = sharedTypesFile.replace(/\.[jt]sx?$/, "");
-  }
+  const sharedTypesImportPath = sharedTypesFile && outputFile ? (() => {
+    let rel = path2.relative(path2.dirname(outputFile), sharedTypesFile).replace(/\\/g, "/").replace(/\.[jt]sx?$/, "");
+    if (!rel.startsWith(".")) rel = "./" + rel;
+    return rel;
+  })() : "./shared-types";
   return printer.printNode(
     ts4.EmitHint.Unspecified,
     factory.createSourceFile(
@@ -523,16 +633,10 @@ async function generateApi(spec, {
         generateImportNode(apiFile, { [apiImport]: "api" }),
         generateImportNode("@acrool/react-fetcher", { IRestFulEndpointsQueryReturn: "IRestFulEndpointsQueryReturn" }),
         ...sharedTypesFile ? [
-          factory.createImportDeclaration(
-            void 0,
-            factory.createImportClause(
-              false,
-              void 0,
-              factory.createNamespaceImport(factory.createIdentifier("SharedTypes"))
-            ),
-            factory.createStringLiteral(sharedTypesFile),
-            void 0
-          )
+          generateImportNode(sharedTypesImportPath, {
+            Scheme: "Scheme",
+            ...useEnumType ? { Enum: "Enum" } : {}
+          })
         ] : [],
         ...tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : [],
         generateCreateApiCall({
@@ -541,17 +645,14 @@ async function generateApi(spec, {
             operationDefinitions.map(
               (operationDefinition) => generateEndpoint({
                 operationDefinition,
-                overrides: getOverrides(operationDefinition, endpointOverrides)
+                overrides: getOverrides(operationDefinition, endpointOverrides),
+                sharedTypesFile: !!sharedTypesFile
               })
             ),
             true
           )
         }),
-        factory.createExportAssignment(
-          void 0,
-          void 0,
-          factory.createIdentifier(generatedApiName)
-        ),
+        factory.createExportAssignment(void 0, void 0, factory.createIdentifier(generatedApiName)),
         ...Object.values(interfaces),
         ...sharedTypesFile ? [] : [...apiGen.aliases, ...apiGen.enumAliases],
         ...hooks ? [
@@ -580,7 +681,8 @@ async function generateApi(spec, {
   }
   function generateEndpoint({
     operationDefinition,
-    overrides
+    overrides,
+    sharedTypesFile: sharedTypesFile2
   }) {
     const {
       verb,
@@ -589,60 +691,30 @@ async function generateApi(spec, {
       operation,
       operation: { responses, requestBody }
     } = operationDefinition;
-    const operationName = getOperationName2({ verb, path: path4, operation });
+    const operationName = getOperationName2({ verb, path: path4 });
     const tags = tag ? getTags({ verb, pathItem }) : [];
     const isQuery2 = isQuery(verb, overrides);
     const returnsJson = apiGen.getResponseType(responses) === "json";
     let ResponseType = factory.createKeywordTypeNode(ts4.SyntaxKind.UnknownKeyword);
-    function replaceReferences(schema) {
-      if (!schema) return factory.createKeywordTypeNode(ts4.SyntaxKind.UnknownKeyword);
-      const refName = 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(ts4.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]) => {
-          const resolvedResponse = apiGen.resolve(response);
-          if (!resolvedResponse.content?.["application/json"]?.schema) {
-            return [code, resolvedResponse, factory.createKeywordTypeNode(ts4.SyntaxKind.UndefinedKeyword)];
-          }
-          const schema = resolvedResponse.content["application/json"].schema;
-          const type = replaceReferences(schema);
-          return [code, resolvedResponse, type];
-        }
+        ([code, response]) => [
+          code,
+          apiGen.resolve(response),
+          wrapWithSchemeIfComponent(
+            apiGen.getTypeFromResponse(response, "readOnly") || factory.createKeywordTypeNode(ts4.SyntaxKind.UndefinedKeyword)
+          )
+        ]
       ).filter(
         ([status, response]) => isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
-      ).filter(([_1, _2, type]) => type !== keywordType.void).map(
-        ([code, response, type]) => ts4.addSyntheticLeadingComment(
-          { ...type },
+      ).filter(([_1, _2, type]) => type !== keywordType.void).map(([code, response, type]) => {
+        return ts4.addSyntheticLeadingComment(
+          type,
           ts4.SyntaxKind.MultiLineCommentTrivia,
           `* status ${code} ${response.description} `,
           false
-        )
-      );
+        );
+      });
       if (returnTypes.length > 0) {
         ResponseType = factory.createUnionTypeNode(returnTypes);
       }
@@ -677,10 +749,23 @@ 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(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 = replaceReferences(schema);
+      const type = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema));
       const schemaName = camelCase(
         type.name || getReferenceName(schema) || typeof schema === "object" && "title" in schema && schema.title || "body"
       );
@@ -689,24 +774,11 @@ async function generateApi(spec, {
         origin: "body",
         name,
         originalName: schemaName,
-        type,
+        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema, void 0, "writeOnly")),
         required: true,
         body
       };
     }
-    for (const param of parameters) {
-      const name = generateName(param.name, param.in);
-      const paramSchema = 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 isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
@@ -749,10 +821,7 @@ async function generateApi(spec, {
       operationName: operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName,
       type: isQuery2 ? "query" : "mutation",
       Response: ResponseTypeName,
-      QueryArg: factory.createTypeReferenceNode(
-        factory.createIdentifier("IRestFulEndpointsQueryReturn"),
-        [QueryArg]
-      ),
+      QueryArg: factory.createTypeReferenceNode(factory.createIdentifier("IRestFulEndpointsQueryReturn"), [QueryArg]),
       queryFn: generateQueryFn({
         operationDefinition,
         queryArg,
@@ -773,10 +842,18 @@ async function generateApi(spec, {
     encodePathParams: encodePathParams2,
     encodeQueryParams: encodeQueryParams2
   }) {
-    const { path: path4, verb } = operationDefinition;
+    const { path: path4, 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"));
+    function getContentType() {
+      if (operation.requestBody) {
+        const requestBody = apiGen.resolve(operation.requestBody);
+        const contentTypes = Object.keys(requestBody.content || {});
+        return contentTypes[0];
+      }
+      return void 0;
+    }
     function pickParams(paramIn) {
       return Object.values(queryArg).filter((def) => def.origin === "param" && def.param.in === paramIn);
     }
@@ -800,6 +877,7 @@ async function generateApi(spec, {
         factory.createObjectLiteralExpression(properties, true)
       );
     }
+    const contentType = getContentType();
     return factory.createArrowFunction(
       void 0,
       void 0,
@@ -817,9 +895,16 @@ async function generateApi(spec, {
               factory.createIdentifier("method"),
               factory.createStringLiteral(verb.toUpperCase())
             ),
+            contentType ? factory.createPropertyAssignment(
+              factory.createIdentifier("contentType"),
+              factory.createStringLiteral(contentType)
+            ) : void 0,
             bodyParameter === void 0 ? void 0 : factory.createPropertyAssignment(
               factory.createIdentifier("body"),
-              isFlatArg ? variablesObject : factory.createPropertyAccessExpression(variablesObject, factory.createIdentifier(bodyParameter.name))
+              isFlatArg ? variablesObject : factory.createPropertyAccessExpression(
+                variablesObject,
+                factory.createIdentifier(bodyParameter.name)
+              )
             ),
             createObjectLiteralProperty(pickParams("cookie"), "cookies"),
             createObjectLiteralProperty(pickParams("query"), "params"),
@@ -843,6 +928,99 @@ async function generateApi(spec, {
   function generateMutationEndpointProps({}) {
     return {};
   }
+  function wrapWithSchemeIfComponent(typeNode) {
+    if (ts4.isTypeReferenceNode(typeNode) && ts4.isIdentifier(typeNode.typeName)) {
+      const typeName = typeNode.typeName.text;
+      const isEnumType = useEnumType && (apiGen.enumAliases.some((enumDecl) => {
+        if (ts4.isEnumDeclaration(enumDecl) || ts4.isTypeAliasDeclaration(enumDecl)) {
+          return enumDecl.name.text === typeName;
+        }
+        return false;
+      }) || apiGen.aliases.some((alias) => {
+        if (ts4.isTypeAliasDeclaration(alias) && alias.type) {
+          if (ts4.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 (ts4.isArrayTypeNode(typeNode)) {
+      return factory.createArrayTypeNode(wrapWithSchemeIfComponent(typeNode.elementType));
+    }
+    if (ts4.isUnionTypeNode(typeNode)) {
+      const unionTypes = typeNode.types;
+      if (unionTypes.length > 0 && unionTypes.every(
+        (type) => ts4.isLiteralTypeNode(type) && (ts4.isStringLiteral(type.literal) || ts4.isNumericLiteral(type.literal))
+      )) {
+        const enumValues = unionTypes.map((type) => {
+          if (ts4.isLiteralTypeNode(type)) {
+            if (ts4.isStringLiteral(type.literal)) {
+              return type.literal.text;
+            } else if (ts4.isNumericLiteral(type.literal)) {
+              return type.literal.text;
+            }
+          }
+          return null;
+        }).filter(Boolean);
+        const matchingEnum = apiGen.aliases.find((alias) => {
+          if (ts4.isTypeAliasDeclaration(alias) && ts4.isUnionTypeNode(alias.type)) {
+            const aliasValues = alias.type.types.map((type) => {
+              if (ts4.isLiteralTypeNode(type)) {
+                if (ts4.isStringLiteral(type.literal)) {
+                  return type.literal.text;
+                } else if (ts4.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 && ts4.isTypeAliasDeclaration(matchingEnum)) {
+          return typeNode;
+        }
+      }
+      return factory.createUnionTypeNode(typeNode.types.map(wrapWithSchemeIfComponent));
+    }
+    if (ts4.isTypeLiteralNode(typeNode)) {
+      return factory.createTypeLiteralNode(
+        typeNode.members.map((member) => {
+          if (ts4.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 = [];
@@ -870,8 +1048,115 @@ function generatePathExpression(path4, pathParameters, rootObject, isFlatArg, en
 }
 
 // src/index.ts
+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 });
+  }
+}
+function fileExists(filePath) {
+  try {
+    return fs.statSync(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function getApiNameFromDir(dirPath) {
+  const dirName = path3.basename(dirPath);
+  return `${dirName}Api`;
+}
+async function ensureBaseFilesExist(outputDir) {
+  const enhanceEndpointsPath = path3.join(outputDir, "enhanceEndpoints.ts");
+  const indexPath = path3.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 fs.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");
+  }
+}
+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);
+    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] = [];
+      }
+      acc[groupName].push(path4);
+      return acc;
+    }, {});
+    for (const [groupName, paths2] of Object.entries(groupedPaths)) {
+      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;
+        };
+        const groupOptions = {
+          ...commonConfig,
+          outputFile: finalOutputPath,
+          filterEndpoints: pathBasedFilter
+        };
+        await generateSingleEndpoint(groupOptions);
+      } else {
+        const pathBasedFilter = (operationName, operationDefinition) => {
+          const path4 = operationDefinition.path;
+          const pathGroupName = getGroupNameFromPath(path4, pattern);
+          return pathGroupName === groupName;
+        };
+        const groupOptions = {
+          ...commonConfig,
+          outputFile: finalOutputPath,
+          filterEndpoints: pathBasedFilter
+        };
+        await generateSingleEndpoint(groupOptions);
+      }
+    }
+    return;
+  }
+  await generateSingleEndpoint(options);
+}
+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 () => {
@@ -879,8 +1164,12 @@ async function generateEndpoints(options) {
   });
   const { outputFile, prettierConfigFile } = options;
   if (outputFile) {
+    const outputPath = path3.resolve(process.cwd(), outputFile);
+    await ensureDirectoryExists(outputPath);
+    const outputDir = path3.dirname(outputPath);
+    await ensureBaseFilesExist(outputDir);
     fs.writeFileSync(
-      path3.resolve(process.cwd(), outputFile),
+      outputPath,
       await prettify(outputFile, sourceCode, prettierConfigFile)
     );
   } else {
@@ -891,13 +1180,60 @@ function parseConfig(fullConfig) {
   const outFiles = [];
   if ("outputFiles" in fullConfig) {
     const { outputFiles, ...commonConfig } = fullConfig;
-    for (const [outputFile, specificConfig] of Object.entries(outputFiles)) {
-      outFiles.push({
-        ...commonConfig,
-        ...specificConfig,
-        outputFile
-      });
+    let openApiDoc;
+    if (isValidUrl(fullConfig.schemaFile)) {
+      outFiles.push(fullConfig);
+      return outFiles;
+    } else {
+      openApiDoc = JSON.parse(fs.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] = [];
+      }
+      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
+        });
+      }
+    });
   } else {
     outFiles.push(fullConfig);
   }