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

package/src/generate.ts

@@ -147,23 +147,24 @@ export async function generateApi(
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 
     const allTypeDefinitions: ts.Statement[] = [];
+    const definedTypeNames = new Set<string>();
 
     const components = v3Doc.components;
     if (components) {
       const componentDefinitions = Object.entries(components).map(([componentType, componentDefs]) => {
-        const typeEntries = Object.entries(componentDefs as Record<string, unknown>).map(([name, def]) => {
-          addSchemeTypeName(name);
-          
-          const typeName = capitalize(camelCase(name));
-          const typeNode = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(def as OpenAPIV3.SchemaObject));
-          return factory.createTypeAliasDeclaration(
-            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            factory.createIdentifier(typeName),
-            undefined,
-            typeNode
-          );
-        });
-
+        const typeEntries = Object.entries(componentDefs as Record<string, unknown>)
+          .map(([name, def]) => {
+            addSchemeTypeName(name);
+            const typeName = capitalize(camelCase(name));
+            definedTypeNames.add(typeName);
+            const typeNode = wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(def as OpenAPIV3.SchemaObject));
+            return factory.createTypeAliasDeclaration(
+              [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+              factory.createIdentifier(typeName),
+              undefined,
+              typeNode
+            );
+          });
         return factory.createModuleDeclaration(
           [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
           factory.createIdentifier('Scheme'),
@@ -174,12 +175,116 @@ export async function generateApi(
       allTypeDefinitions.push(...componentDefinitions);
     }
 
-    if (useEnumType) {
-      allTypeDefinitions.push(...apiGen.enumAliases);
+    const enumEntries = [
+      ...apiGen.enumAliases.filter(e => ts.isEnumDeclaration(e)),
+      ...apiGen.enumAliases.filter(e => ts.isTypeAliasDeclaration(e)),
+    ].map(enumDecl => {
+      if (ts.isEnumDeclaration(enumDecl)) {
+        return factory.createEnumDeclaration(
+          [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          enumDecl.name,
+          enumDecl.members
+        );
+      } else if (ts.isTypeAliasDeclaration(enumDecl)) {
+        return factory.createTypeAliasDeclaration(
+          [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          enumDecl.name,
+          enumDecl.typeParameters,
+          enumDecl.type
+        );
+      }
+      return enumDecl;
+    });
+    
+    const unionTypeEnums = apiGen.aliases
+      .filter(alias => {
+        if (ts.isTypeAliasDeclaration(alias) && alias.type) {
+          return ts.isUnionTypeNode(alias.type);
+        }
+        return false;
+      })
+      .map(alias => {
+        if (ts.isTypeAliasDeclaration(alias)) {
+          return factory.createTypeAliasDeclaration(
+            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            alias.name,
+            alias.typeParameters,
+            alias.type
+          );
+        }
+        return alias;
+      });
+    
+    const allEnumEntries = [...enumEntries, ...unionTypeEnums];
+    
+    if (allEnumEntries.length > 0) {
+      allTypeDefinitions.push(
+        factory.createModuleDeclaration(
+          [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+          factory.createIdentifier('Enum'),
+          factory.createModuleBlock(allEnumEntries),
+          ts.NodeFlags.Namespace
+        )
+      );
     }
 
-    allTypeDefinitions.push(...apiGen.aliases);
+    if (apiGen.aliases.length > 0) {
+      const aliasEntries = apiGen.aliases
+        .filter(alias => {
+          if (ts.isTypeAliasDeclaration(alias)) {
+            const isDefinedInComponents = definedTypeNames.has(alias.name.text);
+            const isUnionTypeEnum = ts.isUnionTypeNode(alias.type);
+            return !isDefinedInComponents && !isUnionTypeEnum;
+          }
+          return false;
+        })
+        .map(alias => {
+          if (ts.isTypeAliasDeclaration(alias)) {
+            return factory.createTypeAliasDeclaration(
+              [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+              alias.name,
+              alias.typeParameters,
+              alias.type
+            );
+          }
+          return alias;
+        });
+
+      if (aliasEntries.length > 0) {
+        const existingSchemeIndex = allTypeDefinitions.findIndex(def => 
+          ts.isModuleDeclaration(def) && 
+          ts.isIdentifier(def.name) && 
+          def.name.text === 'Scheme'
+        );
+
+        if (existingSchemeIndex >= 0) {
+          const existingScheme = allTypeDefinitions[existingSchemeIndex] as ts.ModuleDeclaration;
+          const mergedMembers = [...(existingScheme.body as ts.ModuleBlock).statements, ...aliasEntries];
+          allTypeDefinitions[existingSchemeIndex] = factory.createModuleDeclaration(
+            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier('Scheme'),
+            factory.createModuleBlock(mergedMembers),
+            ts.NodeFlags.Namespace
+          );
+        } else {
+          allTypeDefinitions.push(
+            factory.createModuleDeclaration(
+              [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+              factory.createIdentifier('Scheme'),
+              factory.createModuleBlock(aliasEntries),
+              ts.NodeFlags.Namespace
+            )
+          );
+        }
+      }
+    }
 
+    const fs = await import('node:fs/promises');
+    const path = await import('node:path');
+    
+    const sharedTypesDir = path.dirname(sharedTypesFile);
+    await fs.mkdir(sharedTypesDir, { recursive: true });
+    
     const output = printer.printNode(
       ts.EmitHint.Unspecified,
       factory.createSourceFile(
@@ -190,7 +295,6 @@ export async function generateApi(
       resultFile
     );
 
-    const fs = await import('node:fs/promises');
     await fs.writeFile(sharedTypesFile, output, 'utf-8');
   }
 
@@ -245,7 +349,12 @@ export async function generateApi(
       [
         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,
@@ -336,25 +445,6 @@ export async function generateApi(
         )
         .filter(([_1, _2, type]) => type !== keywordType.void)
         .map(([code, response, type]) => {
-          if (sharedTypesFile && ts.isTypeReferenceNode(type) && type.typeName) {
-            if (ts.isIdentifier(type.typeName)) {
-              const typeName = type.typeName.text;
-              if (typeName in apiGen.aliases || typeName in apiGen.enumAliases) {
-                return ts.addSyntheticLeadingComment(
-                  factory.createTypeReferenceNode(
-                    factory.createQualifiedName(
-                      factory.createIdentifier('sharedTypes'),
-                      factory.createIdentifier(camelCase(typeName))
-                    ),
-                    type.typeArguments
-                  ),
-                  ts.SyntaxKind.MultiLineCommentTrivia,
-                  `* status ${code} ${response.description} `,
-                  false
-                );
-              }
-            }
-          }
           return ts.addSyntheticLeadingComment(
             type,
             ts.SyntaxKind.MultiLineCommentTrivia,
@@ -620,6 +710,36 @@ export async function generateApi(
   function wrapWithSchemeIfComponent(typeNode: ts.TypeNode): ts.TypeNode {
     if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
       const typeName = typeNode.typeName.text;
+      
+      // 檢查是否為 enum 類型（包括在 enumAliases 和 aliases 中的）
+      const isEnumType = useEnumType && (
+        apiGen.enumAliases.some(enumDecl => {
+          if (ts.isEnumDeclaration(enumDecl) || ts.isTypeAliasDeclaration(enumDecl)) {
+            return enumDecl.name.text === typeName;
+          }
+          return false;
+        }) ||
+        apiGen.aliases.some(alias => {
+          if (ts.isTypeAliasDeclaration(alias) && alias.type) {
+            // 檢查是否為 union type 的 enum
+            if (ts.isUnionTypeNode(alias.type)) {
+              return alias.name.text === typeName;
+            }
+          }
+          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(
@@ -640,6 +760,52 @@ export async function generateApi(
       return factory.createArrayTypeNode(wrapWithSchemeIfComponent(typeNode.elementType));
     }
     if (ts.isUnionTypeNode(typeNode)) {
+      // 檢查是否為 enum 的 union type
+      const unionTypes = typeNode.types;
+      if (unionTypes.length > 0 && unionTypes.every(type => 
+        ts.isLiteralTypeNode(type) && 
+        (ts.isStringLiteral(type.literal) || ts.isNumericLiteral(type.literal))
+      )) {
+        // 這是一個 enum 的 union type，我們需要找到對應的 enum 類型
+        const enumValues = unionTypes.map(type => {
+          if (ts.isLiteralTypeNode(type)) {
+            if (ts.isStringLiteral(type.literal)) {
+              return type.literal.text;
+            } else if (ts.isNumericLiteral(type.literal)) {
+              return type.literal.text;
+            }
+          }
+          return null;
+        }).filter(Boolean);
+        
+        // 查找對應的 enum 類型
+        const matchingEnum = apiGen.aliases.find(alias => {
+          if (ts.isTypeAliasDeclaration(alias) && ts.isUnionTypeNode(alias.type)) {
+            const aliasValues = alias.type.types.map(type => {
+              if (ts.isLiteralTypeNode(type)) {
+                if (ts.isStringLiteral(type.literal)) {
+                  return type.literal.text;
+                } else if (ts.isNumericLiteral(type.literal)) {
+                  return type.literal.text;
+                }
+              }
+              return null;
+            }).filter(Boolean);
+            
+            return aliasValues.length === enumValues.length && 
+                   aliasValues.every(val => enumValues.includes(val));
+          }
+          return false;
+        });
+        
+        // 對於所有的 enum 類型，直接使用字串型別，不轉換為 Enum
+        // 這樣可以避免自動命名造成的變更問題
+        if (matchingEnum && ts.isTypeAliasDeclaration(matchingEnum)) {
+          // 直接返回原始的 union type，不轉換為 Enum
+          return typeNode;
+        }
+      }
+      
       return factory.createUnionTypeNode(typeNode.types.map(wrapWithSchemeIfComponent));
     }
     if (ts.isTypeLiteralNode(typeNode)) {