NEW @W-17875752@ Added unused temporary directories

packages/ENGINE-TEMPLATE/package.json

@@ -14,7 +14,7 @@
   "types": "dist/index.d.ts",
   "dependencies": {
     "@types/node": "^20.0.0",
-    "@salesforce/code-analyzer-engine-api": "0.27.0"
+    "@salesforce/code-analyzer-engine-api": "0.28.0-SNAPSHOT"
   },
   "devDependencies": {
     "@eslint/js": "^9.32.0",
@@ -60,4 +60,4 @@
       "!src/index.ts"
     ]
   }
-}
+}

packages/T-E-M-P-L-A-T-E/package.json

@@ -14,7 +14,7 @@
   "types": "dist/index.d.ts",
   "dependencies": {
     "@types/node": "^20.0.0",
-    "@salesforce/code-analyzer-engine-api": "0.27.0"
+    "@salesforce/code-analyzer-engine-api": "0.28.0-SNAPSHOT"
   },
   "devDependencies": {
     "@eslint/js": "^9.32.0",
@@ -60,4 +60,4 @@
       "!src/index.ts"
     ]
   }
-}
+}

packages/code-analyzer-core/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@salesforce/code-analyzer-core",
   "description": "Core Package for the Salesforce Code Analyzer",
-  "version": "0.33.0",
+  "version": "0.34.0-SNAPSHOT",
   "author": "The Salesforce Code Analyzer Team",
   "license": "BSD-3-Clause",
   "homepage": "https://developer.salesforce.com/docs/platform/salesforce-code-analyzer/overview",
@@ -13,7 +13,7 @@
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
-    "@salesforce/code-analyzer-engine-api": "0.27.0",
+    "@salesforce/code-analyzer-engine-api": "0.28.0-SNAPSHOT",
     "@types/node": "^20.0.0",
     "csv-stringify": "^6.6.0",
     "js-yaml": "^4.1.0",
@@ -69,4 +69,4 @@
       "!src/index.ts"
     ]
   }
-}
+}

packages/code-analyzer-core/src/code-analyzer.ts

@@ -1,4 +1,5 @@
 import {pathToFileURL} from "node:url";
+import os from "node:os";
 import {RuleImpl, RuleSelection, RuleSelectionImpl} from "./rules"
 import {
     EngineRunResults,
@@ -24,7 +25,13 @@ import * as engApi from "@salesforce/code-analyzer-engine-api"
 import {Clock, RealClock} from '@salesforce/code-analyzer-engine-api/utils';
 import {EventEmitter} from "node:events";
 import {CodeAnalyzerConfig, ConfigDescription, EngineOverrides, FIELDS, RuleOverride} from "./config";
-import {EngineProgressAggregator, RuntimeUniqueIdGenerator, toAbsolutePath, UniqueIdGenerator} from "./utils";
+import {
+    EngineProgressAggregator,
+    FileSystemHandler,
+    RuntimeFileSystemHandler,
+    RuntimeUniqueIdGenerator,
+    toAbsolutePath,
+    UniqueIdGenerator} from "./utils";
 import fs from "node:fs";
 import path from 'node:path';
 
@@ -95,13 +102,15 @@ export class CodeAnalyzer {
     private readonly config: CodeAnalyzerConfig;
     private clock: Clock = new RealClock();
     private uniqueIdGenerator: UniqueIdGenerator = new RuntimeUniqueIdGenerator();
+    private fileSystemHandler: FileSystemHandler = new RuntimeFileSystemHandler();
     private readonly eventEmitter: EventEmitter = new EventEmitter();
     private readonly engines: Map<string, engApi.Engine> = new Map();
     private readonly uninstantiableEnginesMap: Map<string, Error> = new Map();
     private readonly engineConfigs: Map<string, EngineConfig> = new Map();
     private readonly engineConfigDescriptions: Map<string, ConfigDescription> = new Map();
     private readonly rulesCache: Map<string, RuleImpl[]> = new Map();
     private readonly engineRuleDiscoveryProgressAggregator: EngineProgressAggregator = new EngineProgressAggregator();
+    private workingFolderRoot?: string;
 
     constructor(config: CodeAnalyzerConfig, version: string = process.version) {
         this.validateEnvironment(version);
@@ -124,6 +133,9 @@ export class CodeAnalyzer {
     _setUniqueIdGenerator(uniqueIdGenerator: UniqueIdGenerator) {
         this.uniqueIdGenerator = uniqueIdGenerator;
     }
+    _setFileSystemHandler(fileSystemHandler: FileSystemHandler): void {
+        this.fileSystemHandler = fileSystemHandler;
+    }
 
     /**
      * Convenience method to return the same CodeAnalyzerConfig instance that was provided to the constructor
@@ -296,15 +308,16 @@ export class CodeAnalyzer {
         //  called a second time before the first call to run hasn't finished. This can occur if someone builds
         //  up a bunch of RunResults promises and then does a Promise.all on them. Otherwise, the progress events may
         //  override each other.
-
-        const engineRunOptions: engApi.RunOptions = extractEngineRunOptions(runOptions, this.config.getLogFolder());
+        const tmpDirRoot: string = path.join(await this.getWorkingFolderRoot(), `run-${this.clock.formatToDateTimeString()}`);
+        await this.fileSystemHandler.createDirectory(tmpDirRoot);
+        const workspace: engApi.Workspace = toEngApiWorkspace(runOptions.workspace);
         this.emitLogEvent(LogLevel.Debug, getMessage('RunningWithWorkspace', JSON.stringify({
             filesAndFolders: runOptions.workspace.getRawFilesAndFolders(),
             targets: runOptions.workspace.getRawTargets()
         })));
 
         const runPromises: Promise<EngineRunResults>[] = ruleSelection.getEngineNames().map(
-            engineName => this.runEngineAndValidateResults(engineName, ruleSelection, engineRunOptions));
+            engineName => this.runEngineAndValidateResults(engineName, ruleSelection, this.config.getLogFolder(), workspace, tmpDirRoot));
         const engineRunResultsList: EngineRunResults[] = await Promise.all(runPromises);
 
         const runResults: RunResultsImpl = new RunResultsImpl(this.clock);
@@ -331,16 +344,27 @@ export class CodeAnalyzer {
     private async getAllRules(workspace?: Workspace): Promise<RuleImpl[]> {
         const cacheKey: string = workspace ? workspace.getWorkspaceId() : process.cwd();
         if (!this.rulesCache.has(cacheKey)) {
+            // TODO: THIS WILL BE CONFIGURABLE SOON.
+            const tmpDirRoot: string = path.join(await this.getWorkingFolderRoot(), `describe-${this.clock.formatToDateTimeString()}`);
+            await this.fileSystemHandler.createDirectory(tmpDirRoot);
             this.engineRuleDiscoveryProgressAggregator.reset(this.getEngineNames());
             const engApiWorkspace: engApi.Workspace | undefined = workspace ? toEngApiWorkspace(workspace) : undefined;
+
             const rulePromises: Promise<RuleImpl[]>[] = this.getEngineNames().map(engineName =>
-                this.getAllRulesFor(engineName, {workspace: engApiWorkspace, logFolder: this.config.getLogFolder()}));
+                this.getAllRulesFor(engineName, engApiWorkspace, tmpDirRoot, this.config.getLogFolder()));
             this.rulesCache.set(cacheKey, (await Promise.all(rulePromises)).flat());
         }
         return this.rulesCache.get(cacheKey)!;
     }
 
-    private async getAllRulesFor(engineName: string, describeOptions: engApi.DescribeOptions): Promise<RuleImpl[]> {
+    private async getAllRulesFor(engineName: string, workspace: engApi.Workspace | undefined, tmpDirRoot: string, logFolder: string): Promise<RuleImpl[]> {
+        const workingFolder: string = path.join(tmpDirRoot, engineName);
+        await this.fileSystemHandler.createDirectory(workingFolder);
+        const describeOptions: engApi.DescribeOptions = {
+            workspace,
+            workingFolder,
+            logFolder
+        };
         this.emitLogEvent(LogLevel.Debug, getMessage('GatheringRulesFromEngine', engineName));
         let ruleDescriptions: engApi.RuleDescription[] = [];
         try {
@@ -366,7 +390,14 @@ export class CodeAnalyzer {
         this.emitEvent({type: EventType.RuleSelectionProgressEvent, timestamp: this.clock.now(), percentComplete: aggregatedPerc});
     }
 
-    private async runEngineAndValidateResults(engineName: string, ruleSelection: RuleSelection, engineRunOptions: engApi.RunOptions): Promise<EngineRunResults> {
+    private async runEngineAndValidateResults(engineName: string, ruleSelection: RuleSelection, logFolder: string, workspace: engApi.Workspace, tmpDirRoot: string): Promise<EngineRunResults> {
+        const workingFolder: string = path.join(tmpDirRoot, engineName);
+        await this.fileSystemHandler.createDirectory(workingFolder);
+        const engineRunOptions: engApi.RunOptions = {
+            logFolder,
+            workspace,
+            workingFolder
+        };
         this.emitEvent<EngineRunProgressEvent>({
             type: EventType.EngineRunProgressEvent, timestamp: this.clock.now(), engineName: engineName, percentComplete: 0
         });
@@ -539,6 +570,17 @@ export class CodeAnalyzer {
     private getEngine(engineName: string): engApi.Engine {
         return this.engines.get(engineName)!;
     }
+
+    private async getWorkingFolderRoot(): Promise<string> {
+        if (!this.workingFolderRoot) {
+            const workingFolderRoot: string = path.join(os.tmpdir(), 'code-analyzer');
+            if (!this.fileSystemHandler.directoryExists(workingFolderRoot)) {
+                await this.fileSystemHandler.createDirectory(workingFolderRoot);
+            }
+            this.workingFolderRoot = workingFolderRoot;
+        }
+        return this.workingFolderRoot;
+    }
 }
 
 /**
@@ -602,13 +644,6 @@ function validateRuleDescriptions(ruleDescriptions: engApi.RuleDescription[], en
     }
 }
 
-function extractEngineRunOptions(runOptions: RunOptions, logFolder: string): engApi.RunOptions {
-    return {
-        logFolder: logFolder,
-        workspace: toEngApiWorkspace(runOptions.workspace),
-    };
-}
-
 async function validateFileOrFolder(fileOrFolder: string): Promise<string> {
     const absFileOrFolder: string = toAbsolutePath(fileOrFolder);
     try {
@@ -692,6 +727,7 @@ function validateViolationCodeLocations(violation: engApi.Violation, engineName:
                     engineName, violation.ruleName, codeLocation.endLine, codeLocation.startLine));
             }
 
+            // istanbul ignore else
             if (codeLocation.endColumn !== undefined) {
                 if (!isValidLineOrColumn(codeLocation.endColumn)) {
                     throw new Error(getMessage('EngineReturnedViolationWithCodeLocationWithInvalidLineOrColumn',