@hadss/turbo-trans-json-plugin 1.0.0-rc.0

package/src/core/services/CodeGenerationService/generators/SerializerGenerator.ts

@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { SourceFile } from 'ts-morph';
+import { ImportManager } from '../shared/ImportManager';
+import {
+  ClassAnalysis,
+  ClassDetails,
+  DependencySource,
+  DeserializationMode,
+  GenerationContext,
+  InterfaceAnalysis,
+  InterfaceDetails,
+  ITaskContext,
+  Logger,
+  PropertyAnalysis,
+  PropertyGenerationInfo,
+  PropertyKind,
+  StringConstants,
+  TypeDependency,
+  TypeKind,
+  TypeStructure
+} from '../../..';
+import { HandlebarsTemplateEngine } from '../../../template/HandlebarsTemplateEngine';
+import { ConfigManager } from '../../../utils/ConfigManager';
+import { ClassAnalyzer } from '../../../analyzers/ClassAnalyzer';
+import { TempSerializerGenerator } from './TempSerializerGenerator';
+import { TypeHandlerRegistry } from '../../../handlers';
+import SerializationPathUtil from '../../../utils/SerializationPathUtil';
+
+export class SerializerGenerator {
+  private readonly importManager: ImportManager;
+  private readonly templateEngine: HandlebarsTemplateEngine;
+  private readonly registry = TypeHandlerRegistry.getInstance();
+
+  constructor(importManager: ImportManager) {
+    this.importManager = importManager;
+    this.templateEngine = new HandlebarsTemplateEngine();
+  }
+
+  generate(sourceFile: SourceFile, result: ClassAnalysis | InterfaceAnalysis, context: ITaskContext): GenerationContext | string {
+    // 检查是否使用自定义序列化器
+    if (result.decorators?.serializable?.with) {
+      sourceFile.addStatements(this.generateBuiltinSerializerRegistrationForSupplementary(context, result as ClassAnalysis));
+      // 使用自定义序列化器，仅生成注册语句
+      return this.generateCustomSerializerRegistration(sourceFile, result as ClassAnalysis);
+    }
+
+    // 1. 注册必要的导入
+    this.registerImports(result);
+
+    // 2. 使用模板引擎生成代码
+    const templateContext: GenerationContext = {
+      class: result,
+      properties: this.propertyAnalysisToPropertyGenerationInfo(result.properties),
+      serialNameConstant: this.generateSerialNameConstant(result, context)
+    };
+    const templateMode = result.decorators?.serializable?.deserializationMode
+      ? result.decorators.serializable?.deserializationMode
+      : ConfigManager.getInstance().getConfig().deserializationMode;
+
+    const generatedCode = this.templateEngine.render(templateMode, templateContext);
+
+    // 3. 将生成的代码添加到源文件
+    sourceFile.addStatements(generatedCode);
+
+    return templateContext;
+  }
+
+  /**
+   * 生成注册语句
+   * @param sourceFile
+   * @param content
+   */
+  generateRegistration(sourceFile: SourceFile, content: GenerationContext | string): void {
+    // 添加到源文件
+    if (typeof content === 'string') {
+      sourceFile.addStatements(content);
+    } else {
+      const generatedCode = this.templateEngine.renderRegister(content);
+      sourceFile.addStatements(generatedCode);
+    }
+  }
+
+  private registerImports(result: ClassAnalysis | InterfaceAnalysis): void {
+    Logger.debug('SerializerGenerator', 'registerImports', `注册导入: ${result.className}`);
+
+    // 收集所有需要的内置序列化器
+    const requiredBuiltinSerializers = this.getAllRequiredSerializers(result.properties);
+
+    // 基础导入 + 动态内置序列化器导入
+    this.importManager.registerCoreImports([
+      'Serializer', 'SerialDescriptor', 'buildClassSerialDescriptor',
+      'Encoder', 'Decoder', 'registerAutoGeneratedSerializerEntry', 'registerAutoGeneratedSerializerEntryProviderForSupplementary',
+      ...requiredBuiltinSerializers
+    ]);
+
+    this.registerDecoratorsImports(result);
+
+    const deserializationMode =
+      result.decorators?.serializable?.deserializationMode ||
+      ConfigManager.getInstance().getConfig().deserializationMode;
+
+    // PreciseTemplate 需要的额外导入
+    if (deserializationMode === DeserializationMode.STRICT) {
+      this.importManager.registerCoreImports([
+        'SerializationError', 'SerializationErrorCodes',
+        'TypeUtils', 'DecodedElementIndex', 'TurboTransLogger'
+      ]);
+    }
+
+    if (result.generics.isGeneric) {
+      this.importManager.registerCoreImports(['BaseSerializerFactory']);
+    }
+
+    this.registerPropertyImports(result);
+
+    this.registerInheritancePropertyImports(result);
+  }
+
+  private registerDecoratorsImports(result: ClassAnalysis | InterfaceAnalysis): void {
+    // 注册装饰器导入
+    result.ownProperties.forEach(property => {
+      if (property.decorators?.serialName) {
+        this.importManager.registerCoreImports(['SerialName']);
+      }
+      if (property.decorators?.isRequired) {
+        this.importManager.registerCoreImports(['Required']);
+      }
+      if (property.decorators?.isTransient) {
+        this.importManager.registerCoreImports(['Transient']);
+      }
+    });
+  }
+
+  private registerInheritancePropertyImports(result: ClassAnalysis | InterfaceAnalysis): void {
+    const baseClass = result.inheritance.baseClassAnalysis;
+    // 注册继承类导入
+    if (baseClass && baseClass.sourceFilePath !== result.sourceFilePath) {
+      // 导入继承的类
+      this.importManager.registerCustomTypeImport(baseClass.sourceFilePath, baseClass.className);
+
+      // 导入继承类中属性需要的导入
+      baseClass.ownProperties.forEach(property => {
+        this.execInheritancePropertyImports(property.type.dependencies);
+      });
+    }
+  }
+
+  private execInheritancePropertyImports(dependencies: TypeDependency[]): void {
+    dependencies.forEach((dependency: TypeDependency) => {
+      const source = dependency.source;
+      if (source.type === 'local') {
+        this.importManager.registerCustomTypeImport(source.sourceFilePath!, dependency.typeName);
+
+        const classDetails = dependency.details as ClassDetails;
+        const tempClassAnalysis = ClassAnalyzer.analyzeClass(classDetails.classDecl);
+
+        if (!tempClassAnalysis.decorators.serializable) {
+          TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
+        }
+
+        const serializerName = classDetails.isGeneric ? StringConstants.SERIALIZER_FACTORY :
+          StringConstants.SERIALIZER;
+
+        if (tempClassAnalysis.decorators.serializable) {
+          this.importManager.registerCustomTypeImport(
+            source.sourceFilePath!,
+            `${dependency.typeName}${serializerName}`
+          );
+        }
+      }
+    });
+  }
+
+  private registerPropertyImports(result: ClassAnalysis | InterfaceAnalysis): void {
+    // 根据属性注册序列化器导入
+    for (const property of result.properties) {
+      if (property.decorators?.isTransient) {
+        continue;
+      }
+
+      if (property.decorators?.with) {
+        if (this.containsGenericType(property.type)) {
+          this.importManager.registerCoreImports(['WithEntrySerializer']);
+        } else {
+          this.importManager.registerCoreImports(['WithEntryContextualSerializer']);
+        }
+      }
+
+      // 注册属性相关的序列化器导入
+      this.execPropertyImports(property.type.dependencies);
+    }
+  }
+
+  private execPropertyImports(dependencies: TypeDependency[]): void {
+    dependencies.forEach((dependency: TypeDependency) => {
+      this.processDependency(dependency);
+    });
+  }
+
+  private processDependency(dependency: TypeDependency): void {
+    const source = dependency.source;
+
+    // 提前返回，减少嵌套
+    if (source.type !== 'imported' && source.type !== 'local') {
+      return;
+    }
+
+    if (source.type === 'imported') {
+      this.importManager.registerCustomTypeImport(source.sourceFilePath!, dependency.typeName);
+    }
+
+    // 根据类型种类分别处理
+    switch (dependency.typeKind) {
+      case TypeKind.CLASS:
+        this.processClassDependency(dependency, source);
+        break;
+
+      case TypeKind.INTERFACE:
+        this.processInterfaceDependency(dependency);
+        break;
+    }
+  }
+
+  private processClassDependency(dependency: TypeDependency, source: DependencySource): void {
+    const classDetails = dependency.details as ClassDetails;
+    const tempClassAnalysis = ClassAnalyzer.analyzeClass(classDetails.classDecl);
+
+    if (!tempClassAnalysis.decorators.serializable) {
+      TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
+    }
+
+    const serializerName = classDetails.isGeneric ? StringConstants.SERIALIZER_FACTORY :
+      StringConstants.SERIALIZER;
+
+    if (tempClassAnalysis.decorators.serializable) {
+      this.handleSerializableClass(dependency, source, serializerName);
+    } else {
+      // 从 tempSerializer 目录（index.ets）导入
+      this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
+    }
+  }
+
+  private handleSerializableClass(dependency: TypeDependency, source: DependencySource, serializerName: string): void {
+    if (source.type === 'imported') {
+      this.importManager.registerCustomTypeImport(
+        source.sourceFilePath!,
+        `${dependency.typeName}${serializerName}`
+      );
+    }
+  }
+
+  private processInterfaceDependency(dependency: TypeDependency): void {
+    const interfaceDetails = dependency.details as InterfaceDetails;
+    const tempClassAnalysis = ClassAnalyzer.analyzeInterface(interfaceDetails.interfaceDecl);
+    TempSerializerGenerator.getInstance().generateSerializer(tempClassAnalysis);
+
+    const serializerName = (dependency.details as ClassDetails).isGeneric ? StringConstants.SERIALIZER_FACTORY :
+      StringConstants.SERIALIZER;
+
+    // 从 tempSerializer 目录（index.ets）导入
+    this.importManager.registerTempSerializerImport(`${dependency.typeName}${serializerName}`);
+  }
+
+  private generateCustomSerializerRegistration(sourceFile: SourceFile, result: ClassAnalysis): string {
+    this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntry']);
+
+    const customSerializer = result.decorators.serializable!.with;
+    const registrationCode = `registerAutoGeneratedSerializerEntry(${result.className}, ${customSerializer});`;
+
+    return registrationCode;
+  }
+
+  private generateBuiltinSerializerRegistrationForSupplementary(context: ITaskContext, result: ClassAnalysis): string {
+    this.importManager.registerCoreImports(['registerAutoGeneratedSerializerEntryProviderForSupplementary']);
+    const serialNameConstant = this.generateSerialNameConstant(result, context);
+
+    const customSerializer = result.decorators.serializable!.with;
+    const registrationCode = `const ${result.className}_SERIAL_NAME = '${serialNameConstant}';\n
+    registerAutoGeneratedSerializerEntryProviderForSupplementary(${result.className}_SERIAL_NAME, () => [${result.className}, ${customSerializer}]);`;
+
+    return registrationCode;
+  }
+
+  private getAllRequiredSerializers(properties: PropertyAnalysis[]): string[] {
+    const requiredSerializers = new Set<string>();
+
+    properties.forEach(property => {
+      // 递归检查所有属性中需要的序列化器
+      const nestedSerializers = this.analyzeNestedSerializers(property.type);
+      nestedSerializers.forEach(serializer => requiredSerializers.add(serializer));
+    });
+
+    return Array.from(requiredSerializers);
+  }
+
+  private analyzeNestedSerializers(structure: TypeStructure): string[] {
+    const requiredSerializers = new Set<string>();
+
+    // 递归分析函数
+    const analyzeType = (type: TypeStructure): void => {
+      // 容错机制：跳过 UNKNOWN 类型
+      if (type.kind === PropertyKind.UNKNOWN) {
+        return;
+      }
+
+      if (type.kind === PropertyKind.GENERIC) {
+        return; // 跳过类和泛型，这俩没有内置序列化器
+      }
+      // 获取当前类型的序列化器名称
+      const handler = this.registry.getHandlerForKind(type.kind);
+      const metadata = handler.getSerializerMetadata(type);
+      Logger.debug(`Analyzing type ${type.sourceText}, metadata ${metadata.name}`);
+      if (type.kind !== PropertyKind.OBJECT) { // Object类型需要判断泛型类型对应序列化器
+        requiredSerializers.add(metadata.name);
+      }
+
+      // 递归分析泛型参数
+      if (type.args && type.args.length > 0) {
+        type.args.forEach(arg => analyzeType(arg));
+      }
+
+      // 递归分析联合类型成员
+      if (type.unionDetails && type.unionDetails.length > 0) {
+        type.unionDetails.forEach(member => analyzeType(member));
+      }
+    };
+
+    // 开始递归分析
+    analyzeType(structure);
+    return Array.from(requiredSerializers);
+  }
+
+  private containsGenericType(structure: TypeStructure): boolean {
+    // 检查当前节点是否为泛型
+    if (structure.kind === PropertyKind.GENERIC) {
+      return true;
+    }
+
+    // 递归检查泛型参数（如 Array<T>, Map<K,V>）
+    if (structure.args) {
+      return structure.args.some(arg => this.containsGenericType(arg));
+    }
+
+    // 递归检查联合类型的成员（如 T | string | number）
+    if (structure.unionDetails) {
+      return structure.unionDetails.some(member => this.containsGenericType(member));
+    }
+
+    return false;
+  }
+
+  private propertyAnalysisToPropertyGenerationInfo(properties: PropertyAnalysis[]): PropertyGenerationInfo[] {
+    return properties.filter((prop) => {
+      // 排除@Transient的属性
+      if (prop.decorators?.isTransient) {
+        return false;
+      }
+      // 容错机制：排除 UNKNOWN 类型（双保险，理论上分析阶段已强制要求有 @Transient）
+      if (prop.type.kind === PropertyKind.UNKNOWN) {
+        Logger.warn(`属性 ${prop.name} 类型为 UNKNOWN，已自动跳过序列化生成`);
+        return false;
+      }
+      return true;
+    }).map((prop) => {
+      const handler = this.registry.getHandlerForKind(prop.type.kind);
+      // ✅ 传递with参数给Handler，让Handler处理自定义序列化器
+      const serializer = handler.getSerializerMetadata(prop.type, prop.decorators?.with);
+      return { analysis: prop, serializer };
+    });
+  };
+
+  private generateSerialNameConstant(result: ClassAnalysis | InterfaceAnalysis, context: ITaskContext): string {
+    const relativePath = context.calculateSourceRootToModuleRoot(result.sourceFilePath);
+    const serialName = SerializationPathUtil.join(context.getPackageName(), relativePath, result.className + '.class')
+      .replaceAll(SerializationPathUtil.sep, '/');
+    return result.decorators?.serialName || serialName;
+  }
+}

package/src/core/services/CodeGenerationService/generators/TempSerializerGenerator.ts

@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { SourceFile } from 'ts-morph';
+import { ITaskContext, ClassAnalysis, StringConstants, InterfaceAnalysis } from '../../..';
+import { ImportManager } from '../shared/ImportManager';
+import { SerializerGenerator } from './SerializerGenerator';
+import SerializationPathUtil from '../../../utils/SerializationPathUtil';
+import { TsMorphUtil } from '../../../utils/TsMorphUtil';
+
+/**
+ * 序列化器文件信息
+ */
+interface SerializerFileInfo {
+  className: string; // 类名（如 "Person"）
+  isGeneric: boolean;
+  sourceFile: SourceFile; // ts-morph SourceFile
+  importManager: ImportManager; // 独立的导入管理器
+  uniqueFileName: string; // 唯一文件名（如 "model_user_PersonSerializer.ets"）
+  pathPrefix: string; // 路径前缀（如 "model_user"）
+}
+
+export class TempSerializerGenerator {
+  private static INSTANCE: TempSerializerGenerator = new TempSerializerGenerator();
+  private readonly TEMP_SERIALIZER_DIR_NAME: string = 'tempSerializer';
+  private context: ITaskContext | null = null;
+  private serializerFiles: Map<string, SerializerFileInfo> = new Map();
+
+  private constructor() { }
+
+  static getInstance(): TempSerializerGenerator {
+    return this.INSTANCE;
+  }
+
+  init(context: ITaskContext): void {
+    this.context = context;
+    // 确保 tempSerializer 目录存在
+    const tempDir = this.getTempSerializerDir();
+    if (!SerializationPathUtil.exist(tempDir)) {
+      SerializationPathUtil.ensureDirSync(tempDir);
+    }
+
+    // 清空文件映射（支持多次调用init）
+    this.serializerFiles.clear();
+  }
+
+  getTempSerializerDir(): string {
+    return SerializationPathUtil.pathResolve(this.context!.getOutputRoot(), this.TEMP_SERIALIZER_DIR_NAME);
+  }
+
+  /**
+   * 生成单个类的序列化器文件
+   */
+  generateSerializer(classAnalysis: ClassAnalysis | InterfaceAnalysis): void {
+    const uniqueKey = this.getUniqueKey(classAnalysis);
+
+    // 检查是否已生成，避免重复
+    if (this.serializerFiles.has(uniqueKey)) {
+      return;
+    }
+
+    // 生成唯一文件名
+    const uniqueFileName = this.generateUniqueFileName(classAnalysis);
+    const filePath = SerializationPathUtil.pathResolve(this.getTempSerializerDir(), uniqueFileName);
+
+    // 创建独立的 SourceFile 和 ImportManager
+    const sourceFile = TsMorphUtil.getProject().createSourceFile(filePath, '', { overwrite: true });
+    const importManager = new ImportManager();
+    importManager.setContext(this.context!);
+
+    // 注册导入
+    this.registerImports(classAnalysis, importManager);
+
+    // 生成序列化器代码
+    const serializerGenerator = new SerializerGenerator(importManager);
+    const serializableGeneratorContext = serializerGenerator.generate(sourceFile, classAnalysis, this.context!);
+    serializerGenerator.generateRegistration(sourceFile, serializableGeneratorContext);
+
+    // 提取路径前缀用于别名生成
+    const pathPrefix = this.extractPathPrefix(classAnalysis.sourceFilePath);
+
+    // 保存文件信息
+    this.serializerFiles.set(uniqueKey, {
+      className: classAnalysis.className,
+      isGeneric: classAnalysis.generics.isGeneric,
+      sourceFile,
+      importManager,
+      uniqueFileName,
+      pathPrefix
+    });
+  }
+
+  private registerImports(classAnalysis: ClassAnalysis | InterfaceAnalysis, importManager: ImportManager) {
+    // 注册源文件导入
+    importManager.registerCustomTypeImport(classAnalysis.sourceFilePath, classAnalysis.className);
+    // 拷贝源文件导入
+    let sourceFile: SourceFile;
+    if ((classAnalysis as ClassAnalysis).originalClass) {
+      sourceFile = (classAnalysis as ClassAnalysis).originalClass!.getSourceFile();
+    } else {
+      sourceFile = (classAnalysis as InterfaceAnalysis).originalInterface!.getSourceFile();
+    }
+
+    sourceFile.getSourceFile().getImportDeclarations().forEach(importDecl => {
+      const specifier = importDecl.getModuleSpecifierValue();
+      const names = importDecl.getNamedImports().map((names) => names.getName());
+      const defaultImport = importDecl.getDefaultImport();
+      const originalDir = SerializationPathUtil.dirname(classAnalysis.sourceFilePath);
+
+      const importOriginAbs = SerializationPathUtil.pathResolve(originalDir, specifier);
+      if (SerializationPathUtil.exist(importOriginAbs + '.ets')) {
+        // 路径存在，使用模块化路径计算
+        const importOriginAbsWithExt = importOriginAbs + '.ets';
+        names.forEach((name) => {
+          importManager.registerCustomTypeImport(importOriginAbsWithExt, name);
+        });
+        if (defaultImport) {
+          importManager.registerDefaultImport(importOriginAbsWithExt, defaultImport.getText());
+        }
+      } else {
+        // 不存在该路径，说明可能为包名，暂时不动
+        names.forEach((name) => {
+          importManager.registerCustomImport(specifier, name);
+        });
+        if (defaultImport) {
+          importManager.registerDefaultImport(specifier, defaultImport.getText());
+        }
+      }
+    });
+  }
+
+  saveFile(): void {
+    // 1. 保存所有序列化器文件
+    for (const [_, fileInfo] of this.serializerFiles) {
+      // 添加导入语句
+      fileInfo.importManager.getImportDeclarations().forEach((importDeclaration) => {
+        fileInfo.sourceFile.addImportDeclaration({
+          moduleSpecifier: importDeclaration.specifier,
+          namedImports: [...new Set(importDeclaration.names)]
+        });
+      });
+      fileInfo.importManager.getDefaultImport().forEach((importDeclaration) => {
+        fileInfo.sourceFile.addImportDeclaration({
+          moduleSpecifier: importDeclaration.specifier,
+          defaultImport: importDeclaration.name
+        });
+      });
+      // 格式化代码
+      fileInfo.sourceFile.formatText();
+      // 保存文件
+      fileInfo.sourceFile.saveSync();
+    }
+
+    // 2. 生成 index.ets 统一导出文件
+    this.generateIndexFile();
+  }
+
+  private generateIndexFile(): void {
+    const indexFilePath = SerializationPathUtil.pathResolve(this.getTempSerializerDir(), 'index.ets');
+    const indexSourceFile = TsMorphUtil.getProject().createSourceFile(indexFilePath, '', { overwrite: true });
+
+    // 检测类名冲突
+    const classNameMap = new Map<string, SerializerFileInfo[]>();
+    for (const [_, fileInfo] of this.serializerFiles) {
+      const serializerName = `${fileInfo.className}${fileInfo.isGeneric ? StringConstants.SERIALIZER_FACTORY : StringConstants.SERIALIZER}`;
+      if (!classNameMap.has(serializerName)) {
+        classNameMap.set(serializerName, []);
+      }
+      classNameMap.get(serializerName)!.push(fileInfo);
+    }
+
+    // 生成导出语句
+    const exportStatements: string[] = [];
+    for (const [serializerName, fileInfos] of classNameMap) {
+      if (fileInfos.length === 1) {
+        // 无冲突：直接导出
+        const fileInfo = fileInfos[0];
+        const importPath = `./${fileInfo.uniqueFileName.replace('.ets', '')}`;
+        exportStatements.push(`export { ${serializerName} } from '${importPath}';`);
+      } else {
+        // 有冲突：使用别名导出
+        for (const fileInfo of fileInfos) {
+          const alias = this.generateExportAlias(fileInfo);
+          const importPath = `./${fileInfo.uniqueFileName.replace('.ets', '')}`;
+          exportStatements.push(`export { ${serializerName} as ${alias} } from '${importPath}';`);
+        }
+      }
+    }
+
+    // 添加导出语句到 index.ets
+    indexSourceFile.addStatements(exportStatements.join('\n'));
+    indexSourceFile.formatText();
+    indexSourceFile.saveSync();
+  }
+
+  /**
+   * 生成导出别名（用于冲突情况）
+   * 示例：model_user_PersonSerializer → ModelUserPersonSerializer
+   */
+  private generateExportAlias(fileInfo: SerializerFileInfo): string {
+    if (!fileInfo.pathPrefix) {
+      return `${fileInfo.className}${StringConstants.SERIALIZER}`;
+    }
+
+    // 将路径前缀转换为 PascalCase
+    const pascalPrefix = fileInfo.pathPrefix
+      .split('_')
+      .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+      .join('');
+
+    return `${pascalPrefix}${fileInfo.className}${StringConstants.SERIALIZER}`;
+  }
+
+  /**
+   * 生成唯一的序列化器文件名
+   * 示例：model/user/Person.ets → model_user_PersonSerializer.ets
+   */
+  private generateUniqueFileName(classAnalysis: ClassAnalysis | InterfaceAnalysis): string {
+    const prefix = this.extractPathPrefix(classAnalysis.sourceFilePath);
+
+    if (prefix) {
+      return `${prefix}_${classAnalysis.className}${StringConstants.SERIALIZER}.ets`;
+    } else {
+      return `${classAnalysis.className}${StringConstants.SERIALIZER}.ets`;
+    }
+  }
+
+  /**
+   * 从源文件路径提取唯一前缀
+   * 使用 context.calculateSourceRootToModuleRoot() 计算相对路径
+   * @param sourceFilePath 源文件绝对路径
+   * @returns 相对路径的父目录名称（如 "model_user"）
+   */
+  private extractPathPrefix(sourceFilePath: string): string {
+    // 使用 context 的方法计算相对路径（自动剔除 src/main 等前缀）
+    // 例如：E:\project\module\src\main\ets\model\user\Person.ets → ets/model/user/Person.ets
+    const relativePath = this.context!.calculateSourceRootToModuleRoot(sourceFilePath);
+
+    // 提取父目录路径（去掉文件名）
+    const dirPath = SerializationPathUtil.dirname(relativePath);
+
+    // 如果在根目录（例如 ets 或 .），返回空字符串
+    if (dirPath === '.' || dirPath === '' || dirPath === 'ets') {
+      return '';
+    }
+
+    // 去掉 ets/ 前缀（如果存在）
+    let cleanedDirPath = dirPath;
+    if (cleanedDirPath.startsWith('ets/') || cleanedDirPath.startsWith('ets\\')) {
+      cleanedDirPath = cleanedDirPath.substring(4); // 移除 "ets/" 或 "ets\"
+    }
+
+    // 如果清理后为空，返回空字符串
+    if (cleanedDirPath === '' || cleanedDirPath === '.') {
+      return '';
+    }
+
+    // 转换路径分隔符为下划线，仅保留字母数字和下划线
+    return cleanedDirPath.replace(/[\\/]/g, '_').replace(/[^a-zA-Z0-9_]/g, '_');
+  }
+
+  private getUniqueKey(classAnalysis: ClassAnalysis | InterfaceAnalysis): string {
+    return `${classAnalysis.sourceFilePath}#${classAnalysis.className}`;
+  }
+}

package/src/core/services/CodeGenerationService/index.ts

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export { CodeGenerationService } from './CodeGenerationService';