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

package/lib/index.d.mts

@@ -133,7 +133,7 @@ type EndpointOverrides = {
 type OutputFilesConfig = {
     [outputFile: string]: {
         groupMatch: RegExp;
-        filterEndpoint: (groupName: string) => RegExp;
+        filterEndpoint?: (groupName: string) => RegExp;
     };
 };
 type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {

package/lib/index.d.ts

@@ -133,7 +133,7 @@ type EndpointOverrides = {
 type OutputFilesConfig = {
     [outputFile: string]: {
         groupMatch: RegExp;
-        filterEndpoint: (groupName: string) => RegExp;
+        filterEndpoint?: (groupName: string) => RegExp;
     };
 };
 type ConfigFile = Id<Require<CommonOptions & OutputFileOptions, 'outputFile'>> | Id<Omit<CommonOptions, 'outputFile'> & {

package/lib/index.js

@@ -479,12 +479,14 @@ async function generateApi(spec, {
     );
     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));
           return factory.createTypeAliasDeclaration(
             [factory.createModifier(import_typescript4.default.SyntaxKind.ExportKeyword)],
@@ -502,10 +504,101 @@ async function generateApi(spec, {
       });
       allTypeDefinitions.push(...componentDefinitions);
     }
-    if (useEnumType) {
-      allTypeDefinitions.push(...apiGen.enumAliases);
+    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
+        )
+      );
+    }
+    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
+            )
+          );
+        }
+      }
     }
-    allTypeDefinitions.push(...apiGen.aliases);
+    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(
@@ -515,7 +608,6 @@ async function generateApi(spec, {
       ),
       resultFile2
     );
-    const fs2 = await import("node:fs/promises");
     await fs2.writeFile(sharedTypesFile, output, "utf-8");
   }
   if (apiGen.spec.components?.schemas) {
@@ -560,7 +652,12 @@ async function generateApi(spec, {
       [
         generateImportNode(apiFile, { [apiImport]: "api" }),
         generateImportNode("@acrool/react-fetcher", { IRestFulEndpointsQueryReturn: "IRestFulEndpointsQueryReturn" }),
-        ...sharedTypesFile ? [generateImportNode(sharedTypesImportPath, { Scheme: "Scheme" })] : [],
+        ...sharedTypesFile ? [
+          generateImportNode(sharedTypesImportPath, {
+            Scheme: "Scheme",
+            ...useEnumType ? { Enum: "Enum" } : {}
+          })
+        ] : [],
         ...tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : [],
         generateCreateApiCall({
           tag,
@@ -635,25 +732,6 @@ async function generateApi(spec, {
       ).filter(
         ([status, response]) => isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
       ).filter(([_1, _2, type]) => type !== import_generate3.keywordType.void).map(([code, response, type]) => {
-        if (sharedTypesFile2 && import_typescript4.default.isTypeReferenceNode(type) && type.typeName) {
-          if (import_typescript4.default.isIdentifier(type.typeName)) {
-            const typeName = type.typeName.text;
-            if (typeName in apiGen.aliases || typeName in apiGen.enumAliases) {
-              return import_typescript4.default.addSyntheticLeadingComment(
-                factory.createTypeReferenceNode(
-                  factory.createQualifiedName(
-                    factory.createIdentifier("sharedTypes"),
-                    factory.createIdentifier((0, import_lodash.default)(typeName))
-                  ),
-                  type.typeArguments
-                ),
-                import_typescript4.default.SyntaxKind.MultiLineCommentTrivia,
-                `* status ${code} ${response.description} `,
-                false
-              );
-            }
-          }
-        }
         return import_typescript4.default.addSyntheticLeadingComment(
           type,
           import_typescript4.default.SyntaxKind.MultiLineCommentTrivia,
@@ -862,6 +940,28 @@ async function generateApi(spec, {
   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(
@@ -882,6 +982,40 @@ async function generateApi(spec, {
       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)) {
@@ -1018,12 +1152,36 @@ function parseConfig(fullConfig) {
     }, {});
     Object.entries(groupedPaths).forEach(([groupName, paths2]) => {
       const finalOutputPath = outputPath.replace("$1", groupName);
-      const filterEndpoints = filterEndpoint(groupName);
-      outFiles.push({
-        ...commonConfig,
-        outputFile: finalOutputPath,
-        filterEndpoints: [filterEndpoints]
-      });
+      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);