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

package/src/generate.ts

@@ -38,8 +38,8 @@ function defaultIsDataResponse(code: string, includeDefault: boolean) {
   return !Number.isNaN(parsedCode) && parsedCode >= 200 && parsedCode < 300;
 }
 
-function getOperationName({ verb, path, operation }: Pick<OperationDefinition, 'verb' | 'path' | 'operation'>) {
-  return _getOperationName(verb, path, operation.operationId);
+function getOperationName({ verb, path }: Pick<OperationDefinition, 'verb' | 'path'>) {
+  return _getOperationName(verb, path, undefined);
 }
 
 function getTags({ verb, pathItem }: Pick<OperationDefinition, 'verb' | 'pathItem'>): string[] {
@@ -128,49 +128,176 @@ export async function generateApi(
     mergeReadWriteOnly,
   });
 
-  // 如果提供了 sharedTypesFile，則將 components 輸出到該文件
+  const schemeTypeNames = new Set<string>();
+
+  function addSchemeTypeName(name: string) {
+    schemeTypeNames.add(name);
+    schemeTypeNames.add(camelCase(name));
+    schemeTypeNames.add(capitalize(camelCase(name)));
+  }
+
   if (sharedTypesFile) {
+    const resultFile = ts.createSourceFile(
+      'sharedTypes.ts',
+      '',
+      ts.ScriptTarget.Latest,
+      /*setParentNodes*/ false,
+      ts.ScriptKind.TS
+    );
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+
+    const allTypeDefinitions: ts.Statement[] = [];
+    const definedTypeNames = new Set<string>();
+
     const components = v3Doc.components;
     if (components) {
-      const resultFile = ts.createSourceFile(
-        'sharedTypes.ts',
-        '',
-        ts.ScriptTarget.Latest,
-        /*setParentNodes*/ false,
-        ts.ScriptKind.TS
-      );
-      const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-
-      // 將 components 轉換為 TypeScript 類型定義
-      const typeDefinitions = Object.entries(components).flatMap(([_, componentDefs]) => {
-        return Object.entries(componentDefs as Record<string, unknown>).map(([name, def]) => {
-          const typeNode = apiGen.getTypeFromSchema(def as OpenAPIV3.SchemaObject);
+      // 只處理 schemas，其他 component 類型暫時不處理
+      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 as OpenAPIV3.SchemaObject));
           return factory.createTypeAliasDeclaration(
             [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-            factory.createIdentifier(name),
+            factory.createIdentifier(typeName),
             undefined,
             typeNode
           );
         });
+
+        allTypeDefinitions.push(
+          factory.createModuleDeclaration(
+            [factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+            factory.createIdentifier('Scheme'),
+            factory.createModuleBlock(typeEntries),
+            ts.NodeFlags.Namespace
+          )
+        );
+      }
+    }
+
+    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 output = printer.printNode(
-        ts.EmitHint.Unspecified,
-        factory.createSourceFile(
-          typeDefinitions,
-          factory.createToken(ts.SyntaxKind.EndOfFileToken),
-          ts.NodeFlags.None
-        ),
-        resultFile
+    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
+        )
       );
+    }
+
+    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'
+        );
 
-      // 寫入文件
-      const fs = await import('node:fs/promises');
-      await fs.writeFile(sharedTypesFile, output, 'utf-8');
+        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(
+        allTypeDefinitions,
+        factory.createToken(ts.SyntaxKind.EndOfFileToken),
+        ts.NodeFlags.None
+      ),
+      resultFile
+    );
+
+    await fs.writeFile(sharedTypesFile, output, 'utf-8');
   }
 
-  // temporary workaround for https://github.com/oazapfts/oazapfts/issues/491
   if (apiGen.spec.components?.schemas) {
     apiGen.preprocessComponents(apiGen.spec.components.schemas);
   }
@@ -187,6 +314,7 @@ export async function generateApi(
   const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
 
   const interfaces: Record<string, ts.InterfaceDeclaration | ts.TypeAliasDeclaration> = {};
+
   function registerInterface(declaration: ts.InterfaceDeclaration | ts.TypeAliasDeclaration) {
     const name = declaration.name.escapedText.toString();
     if (name in interfaces) {
@@ -203,17 +331,20 @@ export async function generateApi(
       apiFile = apiFile.replace(/\\/g, '/');
       if (!apiFile.startsWith('.')) apiFile = `./${apiFile}`;
     }
-    // 處理 sharedTypesFile 的路徑
-    if (sharedTypesFile && sharedTypesFile.startsWith('.')) {
-      sharedTypesFile = path.relative(path.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 = path
+            .relative(path.dirname(outputFile), sharedTypesFile)
+            .replace(/\\/g, '/')
+            .replace(/\.[jt]sx?$/, '');
+          if (!rel.startsWith('.')) rel = './' + rel;
+          return rel;
+        })()
+      : './shared-types';
 
   return printer.printNode(
     ts.EmitHint.Unspecified,
@@ -221,18 +352,14 @@ export async function generateApi(
       [
         generateImportNode(apiFile, { [apiImport]: 'api' }),
         generateImportNode('@acrool/react-fetcher', { IRestFulEndpointsQueryReturn: 'IRestFulEndpointsQueryReturn' }),
-        ...(sharedTypesFile ? [
-          factory.createImportDeclaration(
-            undefined,
-            factory.createImportClause(
-              false,
-              undefined,
-              factory.createNamespaceImport(factory.createIdentifier('SharedTypes'))
-            ),
-            factory.createStringLiteral(sharedTypesFile),
-            undefined
-          )
-        ] : []),
+        ...(sharedTypesFile
+          ? [
+              generateImportNode(sharedTypesImportPath, {
+                Scheme: 'Scheme',
+                ...(useEnumType ? { Enum: 'Enum' } : {}),
+              }),
+            ]
+          : []),
         ...(tag ? [generateTagTypes({ addTagTypes: extractAllTagTypes({ operationDefinitions }) })] : []),
         generateCreateApiCall({
           tag,
@@ -241,16 +368,13 @@ export async function generateApi(
               generateEndpoint({
                 operationDefinition,
                 overrides: getOverrides(operationDefinition, endpointOverrides),
+                sharedTypesFile: !!sharedTypesFile,
               })
             ),
             true
           ),
         }),
-        factory.createExportAssignment(
-          undefined,
-          undefined,
-          factory.createIdentifier(generatedApiName)
-        ),
+        factory.createExportAssignment(undefined, undefined, factory.createIdentifier(generatedApiName)),
         ...Object.values(interfaces),
         ...(sharedTypesFile ? [] : [...apiGen.aliases, ...apiGen.enumAliases]),
         ...(hooks
@@ -285,9 +409,11 @@ export async function generateApi(
   function generateEndpoint({
     operationDefinition,
     overrides,
+    sharedTypesFile,
   }: {
     operationDefinition: OperationDefinition;
     overrides?: EndpointOverrides;
+    sharedTypesFile: boolean;
   }) {
     const {
       verb,
@@ -296,73 +422,37 @@ export async function generateApi(
       operation,
       operation: { responses, requestBody },
     } = operationDefinition;
-    const operationName = getOperationName({ verb, path, operation });
+    const operationName = getOperationName({ verb, path });
     const tags = tag ? getTags({ verb, pathItem }) : [];
     const isQuery = testIsQuery(verb, overrides);
 
     const returnsJson = apiGen.getResponseType(responses) === 'json';
     let ResponseType: ts.TypeNode = factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
-
-    function replaceReferences(schema: any): ts.TypeNode {
-      if (!schema) return factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
-      
-      const refName = getReferenceName(schema);
-      if (refName && sharedTypesFile) {
-        return factory.createTypeReferenceNode(
-          factory.createQualifiedName(
-            factory.createIdentifier('SharedTypes'),
-            factory.createIdentifier(refName)
-          ),
-          undefined
-        );
-      }
-
-      if (schema.type === 'object' && schema.properties) {
-        const members = Object.entries(schema.properties).map(([key, value]: [string, any]) => {
-          return factory.createPropertySignature(
-            undefined,
-            factory.createIdentifier(key),
-            schema.required?.includes(key) ? undefined : factory.createToken(ts.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(ts.SyntaxKind.UndefinedKeyword)] as const;
-            }
-            
-            const schema = resolvedResponse.content['application/json'].schema;
-            const type = replaceReferences(schema);
-            
-            return [code, resolvedResponse, type] as const;
-          }
+          ([code, response]) =>
+            [
+              code,
+              apiGen.resolve(response),
+              wrapWithSchemeIfComponent(
+                apiGen.getTypeFromResponse(response, 'readOnly') ||
+                  factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword)
+              ),
+            ] as const
         )
         .filter(([status, response]) =>
           isDataResponse(status, includeDefault, apiGen.resolve(response), responses || {})
         )
         .filter(([_1, _2, type]) => type !== keywordType.void)
-        .map(([code, response, type]) =>
-          ts.addSyntheticLeadingComment(
-            { ...type },
+        .map(([code, response, type]) => {
+          return ts.addSyntheticLeadingComment(
+            type,
             ts.SyntaxKind.MultiLineCommentTrivia,
             `* status ${code} ${response.description} `,
             false
-          )
-        );
+          );
+        });
       if (returnTypes.length > 0) {
         ResponseType = factory.createUnionTypeNode(returnTypes);
       }
@@ -386,34 +476,45 @@ export async function generateApi(
 
     const parameters = supportDeepObjects([...pathItemParameters, ...operationParameters])
       .filter(argumentMatches(overrides?.parameterFilter))
-      .filter(param => param.in !== 'header');
+      .filter((param) => param.in !== 'header');
 
     const allNames = parameters.map((p) => p.name);
     const queryArg: QueryArgDefinitions = {};
+
     function generateName(name: string, potentialPrefix: string) {
       const isPureSnakeCase = /^[a-zA-Z][a-zA-Z0-9_]*$/.test(name);
-      // prefix with `query`, `path` or `body` if there are multiple paramters with the same name
       const hasNamingConflict = allNames.filter((n) => n === name).length > 1;
       if (hasNamingConflict) {
         name = `${potentialPrefix}_${name}`;
       }
-      // convert to camelCase if the name is pure snake_case and there are no naming conflicts
       const camelCaseName = camelCase(name);
       if (isPureSnakeCase && !allNames.includes(camelCaseName)) {
         name = camelCaseName;
       }
-      // if there are still any naming conflicts, prepend with underscore
       while (name in queryArg) {
         name = `_${name}`;
       }
       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, undefined, '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 as any).name ||
           getReferenceName(schema) ||
@@ -426,27 +527,12 @@ export async function generateApi(
         origin: 'body',
         name,
         originalName: schemaName,
-        type,
+        type: wrapWithSchemeIfComponent(apiGen.getTypeFromSchema(schema, undefined, '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: string | ts.PropertyName): ts.PropertyName => {
       if (typeof name === 'string') {
         return isValidIdentifier(name) ? factory.createIdentifier(name) : factory.createStringLiteral(name);
@@ -498,10 +584,7 @@ export async function generateApi(
       operationName: operationNameSuffix ? capitalize(operationName + operationNameSuffix) : operationName,
       type: isQuery ? 'query' : 'mutation',
       Response: ResponseTypeName,
-      QueryArg: factory.createTypeReferenceNode(
-        factory.createIdentifier('IRestFulEndpointsQueryReturn'),
-        [QueryArg]
-      ),
+      QueryArg: factory.createTypeReferenceNode(factory.createIdentifier('IRestFulEndpointsQueryReturn'), [QueryArg]),
       queryFn: generateQueryFn({
         operationDefinition,
         queryArg,
@@ -532,13 +615,24 @@ export async function generateApi(
     encodePathParams: boolean;
     encodeQueryParams: boolean;
   }) {
-    const { path, verb } = operationDefinition;
+    const { path, 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'));
 
+    // 提取 content type 的輔助函數
+    function getContentType(): string | undefined {
+      if (operation.requestBody) {
+        const requestBody = apiGen.resolve(operation.requestBody);
+        const contentTypes = Object.keys(requestBody.content || {});
+        // 直接返回第一個可用的 content type
+        return contentTypes[0];
+      }
+      return undefined;
+    }
+
     function pickParams(paramIn: string) {
       return Object.values(queryArg).filter((def) => def.origin === 'param' && def.param.in === paramIn);
     }
@@ -547,8 +641,8 @@ export async function generateApi(
       if (parameters.length === 0) return undefined;
 
       const properties = parameters.map((param) => {
-        const value = isFlatArg 
-          ? variablesObject 
+        const value = isFlatArg
+          ? variablesObject
           : factory.createPropertyAccessExpression(variablesObject, factory.createIdentifier(param.name));
 
         const encodedValue =
@@ -573,6 +667,8 @@ export async function generateApi(
       );
     }
 
+    const contentType = getContentType();
+
     return factory.createArrowFunction(
       undefined,
       undefined,
@@ -592,13 +688,22 @@ export async function generateApi(
                   factory.createIdentifier('method'),
                   factory.createStringLiteral(verb.toUpperCase())
                 ),
+            contentType
+              ? factory.createPropertyAssignment(
+                  factory.createIdentifier('contentType'),
+                  factory.createStringLiteral(contentType)
+                )
+              : undefined,
             bodyParameter === undefined
               ? undefined
               : factory.createPropertyAssignment(
                   factory.createIdentifier('body'),
                   isFlatArg
                     ? variablesObject
-                    : factory.createPropertyAccessExpression(variablesObject, factory.createIdentifier(bodyParameter.name))
+                    : factory.createPropertyAccessExpression(
+                        variablesObject,
+                        factory.createIdentifier(bodyParameter.name)
+                      )
                 ),
             createObjectLiteralProperty(pickParams('cookie'), 'cookies'),
             createObjectLiteralProperty(pickParams('query'), 'params'),
@@ -617,14 +722,132 @@ export async function generateApi(
     );
   }
 
-  // eslint-disable-next-line no-empty-pattern
   function generateQueryEndpointProps({}: { operationDefinition: OperationDefinition }): ObjectPropertyDefinitions {
-    return {}; /* TODO needs implementation - skip for now */
+    return {};
   }
 
-  // eslint-disable-next-line no-empty-pattern
   function generateMutationEndpointProps({}: { operationDefinition: OperationDefinition }): ObjectPropertyDefinitions {
-    return {}; /* TODO needs implementation - skip for now */
+    return {};
+  }
+
+  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(factory.createIdentifier('Scheme'), typeNode.typeName),
+          typeNode.typeArguments?.map(wrapWithSchemeIfComponent)
+        );
+      }
+      if (typeNode.typeArguments) {
+        return factory.createTypeReferenceNode(
+          typeNode.typeName,
+          typeNode.typeArguments.map(wrapWithSchemeIfComponent)
+        );
+      }
+    }
+    if (ts.isArrayTypeNode(typeNode)) {
+      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)) {
+      return factory.createTypeLiteralNode(
+        typeNode.members.map((member) => {
+          if (ts.isPropertySignature(member) && member.type) {
+            return factory.updatePropertySignature(
+              member,
+              member.modifiers,
+              member.name,
+              member.questionToken,
+              wrapWithSchemeIfComponent(member.type)
+            );
+          }
+          return member;
+        })
+      );
+    }
+    return typeNode;
   }
 }
 
@@ -656,8 +879,8 @@ function generatePathExpression(
     ? factory.createTemplateExpression(
         factory.createTemplateHead(head),
         expressions.map(([prop, literal], index) => {
-          const value = isFlatArg 
-            ? rootObject 
+          const value = isFlatArg
+            ? rootObject
             : factory.createPropertyAccessExpression(rootObject, factory.createIdentifier(prop));
           const encodedValue = encodePathParams
             ? factory.createCallExpression(factory.createIdentifier('encodeURIComponent'), undefined, [