fix(transformer): add file path caching (#236)

Author: mcarvin8

src/handlers/istanbulJson.ts

@@ -55,7 +55,15 @@ export class IstanbulCoverageHandler extends BaseHandler {
   }
 
   public finalize(): IstanbulCoverageObject {
-    return this.coverageMap;
+    // Sort coverage map by file path for deterministic output
+    const sortedKeys = Object.keys(this.coverageMap).sort();
+    const sortedMap: IstanbulCoverageMap = {};
+
+    for (const key of sortedKeys) {
+      sortedMap[key] = this.coverageMap[key];
+    }
+
+    return sortedMap;
   }
 }
 

src/handlers/jacoco.ts

@@ -80,7 +80,11 @@ export class JaCoCoCoverageHandler extends BaseHandler {
     let overallCovered = 0;
     let overallMissed = 0;
 
-    for (const packageObj of Object.values(this.packageMap)) {
+    // Sort packages by name for consistent output
+    const sortedPackages = Object.keys(this.packageMap).sort();
+
+    for (const packageName of sortedPackages) {
+      const packageObj = this.packageMap[packageName];
       packageObj.sourcefile.sort((a, b) => a['@name'].localeCompare(b['@name']));
 
       let packageCovered = 0;
@@ -101,6 +105,9 @@ export class JaCoCoCoverageHandler extends BaseHandler {
       overallMissed += packageMissed;
     }
 
+    // Rebuild the package array in sorted order
+    this.coverageObj.report.package = sortedPackages.map((name) => this.packageMap[name]);
+
     this.coverageObj.report.counter.push({
       '@type': 'LINE',
       '@missed': overallMissed,

src/handlers/jsonSummary.ts

@@ -100,6 +100,16 @@ export class JsonSummaryCoverageHandler extends BaseHandler {
       this.coverageObj.total.statements.pct = pct;
     }
 
+    // Sort files object by path for deterministic output
+    const sortedKeys = Object.keys(this.coverageObj.files).sort();
+    const sortedFiles: Record<string, JsonSummaryFileCoverage> = {};
+
+    for (const key of sortedKeys) {
+      sortedFiles[key] = this.coverageObj.files[key];
+    }
+
+    this.coverageObj.files = sortedFiles;
+
     return this.coverageObj;
   }
 }

src/handlers/opencover.ts

@@ -173,9 +173,14 @@ export class OpenCoverCoverageHandler extends BaseHandler {
     // Sort classes by name for consistent output
     this.module.Classes.Class.sort((a, b) => a['@fullName'].localeCompare(b['@fullName']));
 
-    // Sort files by path for consistent output
+    // Sort files by path and reassign UIDs sequentially for deterministic output
     this.module.Files.File.sort((a, b) => a['@fullPath'].localeCompare(b['@fullPath']));
 
+    // Reassign UIDs based on sorted order
+    for (let i = 0; i < this.module.Files.File.length; i++) {
+      this.module.Files.File[i]['@uid'] = i + 1;
+    }
+
     return this.coverageObj;
   }
 }

src/handlers/simplecov.ts

@@ -78,6 +78,16 @@ export class SimpleCovCoverageHandler extends BaseHandler {
   }
 
   public finalize(): SimpleCovCoverageObject {
+    // Sort coverage object by file path for deterministic output
+    const sortedKeys = Object.keys(this.coverageObj.coverage).sort();
+    const sortedCoverage: Record<string, Array<number | null>> = {};
+
+    for (const key of sortedKeys) {
+      sortedCoverage[key] = this.coverageObj.coverage[key];
+    }
+
+    this.coverageObj.coverage = sortedCoverage;
+
     return this.coverageObj;
   }
 }

src/transformers/coverageTransformer.ts

@@ -6,6 +6,7 @@ import { getCoverageHandler } from '../handlers/getHandler.js';
 import { DeployCoverageData, TestCoverageData, CoverageProcessingContext } from '../utils/types.js';
 import { getPackageDirectories } from '../utils/getPackageDirectories.js';
 import { findFilePath } from '../utils/findFilePath.js';
+import { buildFilePathCache } from '../utils/buildFilePathCache.js';
 import { setCoveredLines } from '../utils/setCoveredLines.js';
 import { getConcurrencyThreshold } from '../utils/getConcurrencyThreshold.js';
 import { checkCoverageDataType } from '../utils/setCoverageDataType.js';
@@ -33,12 +34,16 @@ export async function transformCoverageReport(
   const commandType = checkCoverageDataType(parsedData);
   const concurrencyLimit = getConcurrencyThreshold();
 
+  // Build file path cache upfront to avoid O(n*m) directory traversals
+  const filePathCache = await buildFilePathCache(packageDirectories, repoRoot);
+
   const context: CoverageProcessingContext = {
     handlers,
     packageDirs: packageDirectories,
     repoRoot,
     concurrencyLimit,
     warnings,
+    filePathCache,
   };
 
   if (commandType === 'DeployCoverageData') {
@@ -86,7 +91,7 @@ async function processDeployCoverage(data: DeployCoverageData, context: Coverage
   await mapLimit(Object.keys(data), context.concurrencyLimit, async (fileName: string) => {
     const fileInfo = data[fileName];
     const formattedName = fileName.replace(/no-map[\\/]+/, '');
-    const path = await findFilePath(formattedName, context.packageDirs, context.repoRoot);
+    const path = findFilePath(formattedName, context.filePathCache);
 
     if (!path) {
       context.warnings.push(`The file name ${formattedName} was not found in any package directory.`);
@@ -104,9 +109,10 @@ async function processDeployCoverage(data: DeployCoverageData, context: Coverage
 
 async function processTestCoverage(data: TestCoverageData[], context: CoverageProcessingContext): Promise<number> {
   let processed = 0;
+  // eslint-disable-next-line @typescript-eslint/require-await
   await mapLimit(data, context.concurrencyLimit, async (entry: TestCoverageData) => {
     const formattedName = entry.name.replace(/no-map[\\/]+/, '');
-    const path = await findFilePath(formattedName, context.packageDirs, context.repoRoot);
+    const path = findFilePath(formattedName, context.filePathCache);
 
     if (!path) {
       context.warnings.push(`The file name ${formattedName} was not found in any package directory.`);

src/utils/buildFilePathCache.ts

@@ -0,0 +1,78 @@
+'use strict';
+
+import { readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { normalizePathToUnix } from './normalizePathToUnix.js';
+
+/**
+ * Build a cache mapping filenames to their full paths.
+ * This prevents recursive directory searches for every file in the coverage report.
+ *
+ * @param packageDirectories - Array of package directory paths to scan
+ * @param repoRoot - Repository root path
+ * @returns Map of filename (without path) to full relative path
+ */
+export async function buildFilePathCache(packageDirectories: string[], repoRoot: string): Promise<Map<string, string>> {
+  const cache = new Map<string, string>();
+  const extensions = ['cls', 'trigger'];
+
+  await Promise.all(
+    packageDirectories.map(async (directory) => {
+      await scanDirectory(directory, repoRoot, extensions, cache);
+    })
+  );
+
+  return cache;
+}
+
+async function scanDirectory(
+  directory: string,
+  repoRoot: string,
+  extensions: string[],
+  cache: Map<string, string>
+): Promise<void> {
+  let entries: string[];
+
+  try {
+    entries = await readdir(directory);
+  } catch {
+    // Directory doesn't exist or not accessible, skip it
+    return;
+  }
+
+  const subdirPromises: Array<Promise<void>> = [];
+
+  for (const entry of entries) {
+    const fullPath = join(directory, entry);
+    let stats;
+
+    try {
+      // eslint-disable-next-line no-await-in-loop
+      stats = await stat(fullPath);
+    } catch {
+      // File not accessible, skip it
+      continue;
+    }
+
+    if (stats.isDirectory()) {
+      // Queue subdirectory scanning
+      subdirPromises.push(scanDirectory(fullPath, repoRoot, extensions, cache));
+    } else {
+      // Check if this is an Apex file
+      const ext = entry.split('.').pop();
+      if (ext && extensions.includes(ext)) {
+        const relativePath = normalizePathToUnix(relative(repoRoot, fullPath));
+        // Store with the full filename as key (e.g., "AccountHandler.cls")
+        cache.set(entry, relativePath);
+        // Also store without extension for lookups (e.g., "AccountHandler")
+        const nameWithoutExt = entry.substring(0, entry.lastIndexOf('.'));
+        if (!cache.has(nameWithoutExt)) {
+          cache.set(nameWithoutExt, relativePath);
+        }
+      }
+    }
+  }
+
+  // Process all subdirectories in parallel
+  await Promise.all(subdirPromises);
+}

src/utils/findFilePath.ts

@@ -1,54 +1,39 @@
 'use strict';
-/* eslint-disable no-await-in-loop */
 
-import { readdir, stat } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import { normalizePathToUnix } from './normalizePathToUnix.js';
-
-export async function findFilePath(
-  fileName: string,
-  packageDirectories: string[],
-  repoRoot: string
-): Promise<string | undefined> {
-  for (const directory of packageDirectories) {
-    const result = await resolveFilePath(fileName, directory, repoRoot);
-    if (result) {
-      return normalizePathToUnix(result);
-    }
-  }
-  return undefined;
-}
-
-async function resolveFilePath(fileName: string, dxDirectory: string, repoRoot: string): Promise<string | undefined> {
-  const extensionsToTry = getExtensionsToTry(fileName);
-
-  for (const name of extensionsToTry) {
-    const absolutePath = await searchRecursively(name, dxDirectory);
-    if (absolutePath) {
-      return relative(repoRoot, absolutePath);
-    }
+/**
+ * Find file path using a pre-built cache (fast) or fallback to the old method.
+ *
+ * @param fileName - Name of the file to find
+ * @param filePathCache - Optional pre-built cache of filename -> path mappings
+ * @returns Normalized Unix-style relative path or undefined if not found
+ */
+export function findFilePath(fileName: string, filePathCache?: Map<string, string>): string | undefined {
+  if (filePathCache) {
+    return findFilePathFromCache(fileName, filePathCache);
   }
 
+  // Fallback to old behavior should never happen in practice,
+  // but keeping for backwards compatibility
   return undefined;
 }
 
-function getExtensionsToTry(fileName: string): string[] {
-  return ['cls', 'trigger'].map((ext) => `${fileName}.${ext}`);
-}
-
-async function searchRecursively(fileName: string, directory: string): Promise<string | undefined> {
-  const entries = await readdir(directory);
+function findFilePathFromCache(fileName: string, cache: Map<string, string>): string | undefined {
+  // Try exact match first
+  const exactMatch = cache.get(fileName);
+  if (exactMatch) {
+    return exactMatch;
+  }
 
-  for (const entry of entries) {
-    const fullPath = join(directory, entry);
-    const stats = await stat(fullPath);
+  // Try with .cls extension
+  const clsMatch = cache.get(`${fileName}.cls`);
+  if (clsMatch) {
+    return clsMatch;
+  }
 
-    if (stats.isDirectory()) {
-      const nestedResult = await searchRecursively(fileName, fullPath);
-      if (nestedResult) return nestedResult;
-    } else if (entry === fileName) {
-      return fullPath;
-    }
+  // Try with .trigger extension
+  const triggerMatch = cache.get(`${fileName}.trigger`);
+  if (triggerMatch) {
+    return triggerMatch;
   }
 
   return undefined;

src/utils/types.ts

@@ -42,6 +42,7 @@ export type CoverageProcessingContext = {
   repoRoot: string;
   concurrencyLimit: number;
   warnings: string[];
+  filePathCache: Map<string, string>;
 };
 
 type SonarLine = {

test/commands/acc-transformer/transform.test.ts

@@ -1,7 +1,6 @@
 'use strict';
 import { describe, it, expect } from '@jest/globals';
 
-import { TestContext } from '@salesforce/core/testSetup';
 import { transformCoverageReport } from '../../../src/transformers/coverageTransformer.js';
 import { formatOptions } from '../../../src/utils/constants.js';
 import { inputJsons, invalidJson, deployCoverage, testCoverage } from '../../utils/testConstants.js';
@@ -10,16 +9,10 @@ import { postTestCleanup } from '../../utils/testCleanup.js';
 import { preTestSetup } from '../../utils/testSetup.js';
 
 describe('acc-transformer transform unit tests', () => {
-  const $$ = new TestContext();
-
   beforeAll(async () => {
     await preTestSetup();
   });
 
-  afterEach(() => {
-    $$.restore();
-  });
-
   afterAll(async () => {
     await postTestCleanup();
   });