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

package/src/core/import-rewrite/services/BuildProfileUpdater.ts

@@ -0,0 +1,145 @@
+/*
+ * 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 { ITaskContext, Logger } from '../..';
+import { ITargetContext } from '../../../json-plugin/interfaces/ITargetContext';
+import SerializationPathUtil from '../../utils/SerializationPathUtil';
+
+/**
+ * build-profile.json5 配置更新服务实现
+ */
+export class BuildProfileUpdaterImpl {
+
+  updateSourceRoots(targetContext: ITargetContext): void {
+    try {
+      // 获取模块根目录和 build-profile.json5 路径
+      const moduleRoot = this.getModuleRootFromContext(targetContext);
+      const buildProfilePath = SerializationPathUtil.join(moduleRoot, 'build-profile.json5');
+
+      Logger.debug(`准备更新 build-profile.json5: ${buildProfilePath}`);
+
+      if (!SerializationPathUtil.exist(buildProfilePath)) {
+        Logger.warn(`build-profile.json5 文件不存在: ${buildProfilePath}`);
+        return;
+      }
+
+      // 读取现有配置
+      const config = targetContext.context.buildProfileOpt;
+      Logger.debug(`当前配置: ${JSON.stringify(config, null, 2)}`);
+
+      // 更新 sourceRoots 配置
+      const updated = this.updateSourceRootsConfig(config);
+
+      if (updated) {
+        // 写回配置文件
+        this.writeBuildProfile(targetContext, buildProfilePath, config);
+        Logger.info(`已更新 build-profile.json5 的 sourceRoots 配置: ${buildProfilePath}`);
+      } else {
+        Logger.debug('sourceRoots 配置无需更新');
+      }
+
+    } catch (error) {
+      Logger.error(`更新 build-profile.json5 失败: ${error}`);
+      throw error;
+    }
+  }
+
+  /**
+   * 从任务上下文获取模块根目录
+   */
+  private getModuleRootFromContext(context: ITargetContext): string {
+    // 通过输出根目录推断模块根目录
+    // 输出根目录通常是 moduleName/src/generated
+    // 模块根目录应该是 moduleName/
+    const outputRoot = context.getOutputRoot();
+
+    // 向上查找包含 build-profile.json5 的目录
+    let currentDir = SerializationPathUtil.dirname(outputRoot);
+
+    while (currentDir && currentDir !== SerializationPathUtil.dirname(currentDir)) {
+      const buildProfilePath = SerializationPathUtil.join(currentDir, 'build-profile.json5');
+      if (SerializationPathUtil.exist(buildProfilePath)) {
+        return currentDir;
+      }
+      currentDir = SerializationPathUtil.dirname(currentDir);
+    }
+
+    // 如果找不到，使用输出根目录的父目录的父目录作为fallback
+    return SerializationPathUtil.dirname(SerializationPathUtil.dirname(outputRoot));
+  }
+
+  /**
+   * 读取 build-profile.json5 配置
+   */
+  private readBuildProfile(buildProfilePath: string): any {
+    try {
+      // 使用继承自 FileUtil 的方法读取 JSON5
+      return SerializationPathUtil.readJson5(buildProfilePath);
+    } catch (error) {
+      Logger.error(`读取 build-profile.json5 失败: ${buildProfilePath}, 错误: ${error}`);
+      throw new Error(`无法读取配置文件: ${buildProfilePath}`);
+    }
+  }
+
+  /**
+   * 写入 build-profile.json5 配置
+   */
+  private writeBuildProfile(targetContext: ITargetContext, buildProfilePath: string, config: any): void {
+    try {
+      // 不需要修改源代码，仅重写构建过程中的buildProfile文件，修改源码方式SerializationPathUtil.writeFileSync(buildProfilePath, JSON.stringify(config, null, 2));
+      targetContext.context.moduleContext.setBuildProfileOpt(config);
+    } catch (error) {
+      Logger.error(`写入 build-profile.json5 失败: ${buildProfilePath}, 错误: ${error}`);
+      throw new Error(`无法写入配置文件: ${buildProfilePath}`);
+    }
+  }
+
+  /**
+   * 更新 sourceRoots 配置
+   * @param config 配置对象
+   * @returns 是否进行了更新
+   */
+  private updateSourceRootsConfig(config: any): boolean {
+    let updated = false;
+    const generatedSourceRoot = "./src/generated";
+    Logger.info(`target.source.sourceRoots start`);
+
+    // 更新 targets 中的 source.sourceRoots
+    if (config.targets && Array.isArray(config.targets)) {
+      for (const target of config.targets) {
+        Logger.info(`target.source.sourceRoots is target: ${target}`);
+        if (!target.source) {
+          target.source = {};
+        }
+        if (!target.source.sourceRoots) {
+          target.source.sourceRoots = [];
+        }
+
+        if (!Array.isArray(target.source.sourceRoots)) {
+          Logger.warn('target.source.sourceRoots 不是数组，将重置为数组');
+          target.source.sourceRoots = [];
+        }
+
+        if (!target.source.sourceRoots.includes(generatedSourceRoot)) {
+          target.source.sourceRoots.unshift(generatedSourceRoot);
+          Logger.info(`添加 target.source.sourceRoots: ${generatedSourceRoot}`);
+          updated = true;
+        }
+      }
+    }
+
+    return updated;
+  }
+}

package/src/core/import-rewrite/services/ImportRewriteService.ts

@@ -0,0 +1,129 @@
+/*
+ * 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 { ITaskContext, ImportRewriteOptions, Logger } from '../..';
+import { GeneratedFileInfo, ImportRewriteService as IImportRewriteService } from '../types/ImportRewriteTypes';
+import { ImportTransformServiceImpl } from './ImportTransformService';
+import SerializationPathUtil from '../../utils/SerializationPathUtil';
+import { BuildProfileUpdaterImpl } from './BuildProfileUpdater';
+import { ITargetContext } from '../../../json-plugin/interfaces/ITargetContext';
+
+/**
+ * 导入重写主服务实现
+ * 协调扫描策略和转换服务
+ */
+export class ImportRewriteServiceImpl implements IImportRewriteService {
+  private readonly transformService: ImportTransformServiceImpl;
+
+  constructor() {
+    this.transformService = new ImportTransformServiceImpl();
+  }
+
+  /**
+   * 重写项目中的导入语句
+   * @param context 任务上下文
+   * @param generatedFileInfos 生成文件信息列表
+   * @param options 导入重写选项
+   */
+  rewriteImports(
+    context: ITaskContext,
+    generatedFileInfos: GeneratedFileInfo[],
+    options: ImportRewriteOptions
+  ): void {
+    // 1. 扫描找到需要修改的文件
+    const filesToUpdate = this.scanFilesWithModelImports(options.scanPaths, generatedFileInfos, context);
+
+    if (filesToUpdate.length === 0) {
+      Logger.info('未找到需要重写导入的文件');
+      return;
+    }
+
+    Logger.info(`找到 ${filesToUpdate.length} 个文件需要重写导入`);
+
+    // 2. 为每个文件重写导入语句
+    let successCount = 0;
+    let errorCount = 0;
+
+    for (const filePath of filesToUpdate) {
+      try {
+        this.transformService.rewriteFileImports(
+          filePath,
+          context,
+          generatedFileInfos,
+          options.preserveOriginalImports
+        );
+        successCount++;
+      } catch (error: any) {
+        errorCount++;
+      }
+    }
+
+    Logger.info(`导入重写完成: 成功 ${successCount} 个，失败 ${errorCount} 个`);
+  }
+
+  /**
+   * 扫描找到包含模型导入的文件
+   * @param scanPaths 扫描路径列表
+   * @param generatedFileInfos 生成文件信息列表
+   * @param context 任务上下文
+   * @returns 需要更新的文件路径列表
+   */
+  private scanFilesWithModelImports(
+    scanPaths: string[],
+    generatedFileInfos: GeneratedFileInfo[],
+    context: ITaskContext
+  ): string[] {
+    const filesToUpdate: string[] = [];
+
+    for (const scanPath of scanPaths) {
+      const absoluteScanPath = SerializationPathUtil.isAbsolute(scanPath)
+        ? scanPath
+        : SerializationPathUtil.pathResolve(context.getModulePath(), scanPath);
+
+      if (!SerializationPathUtil.exist(absoluteScanPath)) {
+        Logger.warn(`扫描路径不存在: ${absoluteScanPath}`);
+        continue;
+      }
+
+      const files = SerializationPathUtil.scanEtsFiles(absoluteScanPath);
+
+      // 过滤出可能包含需要重写导入的文件
+      for (const filePath of files) {
+        if (this.shouldCheckFile(filePath, generatedFileInfos)) {
+          filesToUpdate.push(filePath);
+        }
+      }
+    }
+
+    // 添加Index.ets文件
+    const IndexFilePath = SerializationPathUtil.pathResolve(context.getModulePath(), 'Index.ets');
+    if (SerializationPathUtil.exist(IndexFilePath)) {
+      filesToUpdate.push(IndexFilePath);
+    }
+
+    return filesToUpdate;
+  }
+
+  /**
+   * 判断文件是否应该被检查
+   * 排除生成的文件本身
+   */
+  private shouldCheckFile(filePath: string, generatedFileInfos: GeneratedFileInfo[]): boolean {
+    // 排除生成文件目录中的文件
+    return !generatedFileInfos.some(info =>
+      filePath.startsWith(SerializationPathUtil.dirname(info.generatedFilePath))
+    );
+  }
+}

package/src/core/import-rewrite/services/ImportTransformService.ts

@@ -0,0 +1,200 @@
+/*
+ * 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 { ImportDeclaration, ExportDeclaration, SourceFile } from 'ts-morph';
+import { ITaskContext, Logger } from '../..';
+import { GeneratedFileInfo, ImportTransformService } from '../types/ImportRewriteTypes';
+import { ImportScanStrategyImpl } from '../strategies/ImportScanStrategy';
+import SerializationPathUtil from '../../utils/SerializationPathUtil';
+import { ErrorCodes } from '../../utils/CustomError';
+import { TsMorphUtil } from '../../utils/TsMorphUtil';
+
+/**
+ * 导入转换服务实现
+ * 基于 ts-morph 的导入语句重写服务
+ */
+export class ImportTransformServiceImpl implements ImportTransformService {
+  private readonly scanStrategy: ImportScanStrategyImpl;
+
+  constructor() {
+    this.scanStrategy = new ImportScanStrategyImpl();
+  }
+
+  rewriteFileImports(
+    filePath: string,
+    context: ITaskContext,
+    generatedFileInfos: GeneratedFileInfo[],
+    preserveOriginalImports: boolean = false
+  ): void {
+    try {
+      const sourceFile = TsMorphUtil.getProject().addSourceFileAtPath(filePath);
+
+      const importRewriteCount = this.processImportDeclarations(
+        sourceFile,
+        context,
+        generatedFileInfos,
+        preserveOriginalImports
+      );
+
+      const exportRewriteCount = this.processExportDeclarations(
+        sourceFile,
+        context,
+        generatedFileInfos,
+        preserveOriginalImports
+      );
+
+      const totalRewriteCount = importRewriteCount + exportRewriteCount;
+      this.handleRewriteResult(sourceFile, filePath, totalRewriteCount);
+    } catch (error) {
+      this.handleRewriteError(error, filePath);
+      throw error;
+    }
+  }
+
+  private processImportDeclarations(
+    sourceFile: SourceFile,
+    context: ITaskContext,
+    generatedFileInfos: GeneratedFileInfo[],
+    preserveOriginalImports: boolean
+  ): number {
+    const importDeclarations = sourceFile.getImportDeclarations();
+    let rewriteCount = 0;
+
+    for (const importDecl of importDeclarations) {
+      // 传递 context 到扫描策略，以支持模块化导入处理
+      const matchedInfo = this.scanStrategy.shouldRewriteImport(
+        importDecl,
+        sourceFile.getFilePath(),
+        generatedFileInfos,
+        context
+      );
+
+      if (matchedInfo) {
+        this.rewriteSingleImport(importDecl, context, matchedInfo, preserveOriginalImports);
+        rewriteCount++;
+      }
+    }
+
+    return rewriteCount;
+  }
+
+  private processExportDeclarations(
+    sourceFile: SourceFile,
+    context: ITaskContext,
+    generatedFileInfos: GeneratedFileInfo[],
+    preserveOriginalImports: boolean
+  ): number {
+    const exportDeclarations = sourceFile.getExportDeclarations();
+    let rewriteCount = 0;
+
+    for (const exportDecl of exportDeclarations) {
+      const moduleSpecifier = exportDecl.getModuleSpecifierValue();
+
+      // 没有 moduleSpecifier 说明没有 from 子句，跳过
+      if (!moduleSpecifier) {
+        continue;
+      }
+
+      // 使用相同的扫描策略检查导出
+      const matchedInfo = this.scanStrategy.shouldRewriteExport(
+        moduleSpecifier,
+        sourceFile.getFilePath(),
+        generatedFileInfos,
+        context
+      );
+
+      if (matchedInfo) {
+        this.rewriteSingleExport(exportDecl, context, matchedInfo, preserveOriginalImports);
+        rewriteCount++;
+      }
+    }
+
+    return rewriteCount;
+  }
+
+  private rewriteSingleExport(
+    exportDecl: ExportDeclaration,
+    context: ITaskContext,
+    matchedInfo: GeneratedFileInfo,
+    preserveOriginalImports: boolean
+  ): void {
+    const originalModuleSpecifier = exportDecl.getModuleSpecifierValue();
+    if (!originalModuleSpecifier) {
+      // 如果没有 moduleSpecifier，说明没有 from 子句，不应该到这里
+      return;
+    }
+
+    const newModuleSpecifier = SerializationPathUtil.calculateModularImportPath(matchedInfo.generatedFilePath, context);
+
+    if (preserveOriginalImports) {
+      this.replaceWithCommentedOriginal(exportDecl, originalModuleSpecifier, newModuleSpecifier);
+    } else {
+      exportDecl.setModuleSpecifier(newModuleSpecifier);
+    }
+  }
+
+  private rewriteSingleImport(
+    importDecl: ImportDeclaration,
+    context: ITaskContext,
+    matchedInfo: GeneratedFileInfo,
+    preserveOriginalImports: boolean
+  ): void {
+    const originalModuleSpecifier = importDecl.getModuleSpecifierValue();
+    const newModuleSpecifier = SerializationPathUtil.calculateModularImportPath(matchedInfo.generatedFilePath, context);
+
+    if (preserveOriginalImports) {
+      this.replaceWithCommentedOriginal(importDecl, originalModuleSpecifier, newModuleSpecifier);
+    } else {
+      importDecl.setModuleSpecifier(newModuleSpecifier);
+    }
+  }
+
+  private replaceWithCommentedOriginal(
+    importDecl: any,
+    originalModuleSpecifier: string,
+    newModuleSpecifier: string
+  ): void {
+    const originalImportText = importDecl.getFullText().trim();
+    const commentedOriginal = `// ${originalImportText}`;
+
+    const newImportText = importDecl
+      .getFullText()
+      .replace(new RegExp(`(['"]?)${this.escapeRegExp(originalModuleSpecifier)}\\1`, 'g'), `'${newModuleSpecifier}'`);
+
+    importDecl.replaceWithText(`${commentedOriginal}\n${newImportText.trim()}`);
+  }
+
+  private handleRewriteResult(sourceFile: any, filePath: string, rewriteCount: number): void {
+    if (rewriteCount > 0) {
+      sourceFile.saveSync();
+      Logger.info(`文件 ${filePath} 重写了 ${rewriteCount} 个导入语句`);
+    }
+    sourceFile.forget();
+  }
+
+  private handleRewriteError(error: unknown, filePath: string): void {
+    if (error instanceof Error) {
+      Logger.error(`Error: ${error.constructor.name}: ${ErrorCodes.REWRITE_IMPORT_FAIL}`);
+      Logger.error(`Error Message: 重写文件导入失败: ${filePath}`);
+      Logger.error(`错误信息: ${error.message}\n${error.stack}`);
+    } else {
+      Logger.error(`重写文件导入失败: ${filePath}, 未知错误: ${error}`);
+    }
+  }
+
+  private escapeRegExp(string: string): string {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+}