CDS extractor tests for compiler & packageManager

Adds more extensive unit tests of CDS extractor code related to the
use of the `cds` compiler.

Adds unit tests for CDS extractor functions in "projectMapping.ts".

Author: data-douser

extractors/cds/tools/cds-extractor.ts

@@ -1,9 +1,8 @@
-import { join } from 'path';
-
 import {
   buildCdsProjectDependencyGraph,
   compileCdsToJson,
   determineCdsCommand,
+  findProjectForCdsFile,
   writeParserDebugInfo,
 } from './src/cds';
 import { runJavaScriptExtractor } from './src/codeql';
@@ -102,21 +101,9 @@ console.log('Detecting CDS projects and analyzing their structure...');
 // Build the project dependency graph using the project-aware parser
 const projectMap = buildCdsProjectDependencyGraph(sourceRoot, runMode);
 
-// Extract all package.json directories that need dependency installation
-const packageJsonDirs = new Set<string>();
-projectMap.forEach(project => {
-  if (
-    project.packageJson &&
-    (project.packageJson.dependencies?.['@sap/cds'] ||
-      project.packageJson.devDependencies?.['@sap/cds'])
-  ) {
-    packageJsonDirs.add(join(sourceRoot, project.projectDir));
-  }
-});
-
-// Install node dependencies in each directory.
-console.log('Pre-installing required CDS compiler versions ...');
-installDependencies(packageJsonDirs, codeqlExePath);
+// Install dependencies using the new caching approach
+console.log('Installing required CDS compiler versions using cached approach...');
+const projectCacheDirMap = installDependencies(projectMap, sourceRoot, codeqlExePath);
 
 // Determine the CDS command to use.
 const cdsCommand = determineCdsCommand();
@@ -126,8 +113,15 @@ console.log('Processing CDS files to JSON ...');
 // Compile each `.cds` file to create a `.cds.json` file.
 for (const rawCdsFilePath of cdsFilePathsToProcess) {
   try {
+    // Find which project this CDS file belongs to, to use the correct cache directory
+    const projectDir = findProjectForCdsFile(rawCdsFilePath, sourceRoot, projectMap);
+    const cacheDir = projectDir ? projectCacheDirMap.get(projectDir) : undefined;
+    if (cacheDir) {
+      console.log(`Using cache directory for ${rawCdsFilePath}: ${cacheDir}`);
+    }
+
     // Use resolved path directly instead of passing through getArg
-    const compilationResult = compileCdsToJson(rawCdsFilePath, sourceRoot, cdsCommand);
+    const compilationResult = compileCdsToJson(rawCdsFilePath, sourceRoot, cdsCommand, cacheDir);
 
     if (!compilationResult.success && compilationResult.message) {
       console.error(

extractors/cds/tools/src/cds/compiler/functions.ts

@@ -1,5 +1,5 @@
-import { execFileSync, spawnSync, SpawnSyncReturns } from 'child_process';
-import { resolve } from 'path';
+import { execFileSync, spawnSync, SpawnSyncOptions } from 'child_process';
+import { resolve, join, delimiter } from 'path';
 
 import { CdsCompilationResult } from './types';
 import { fileExists, dirExists, recursivelyRenameJsonFiles } from '../../filesystem';
@@ -29,12 +29,14 @@ export function determineCdsCommand(): string {
  * @param cdsFilePath Path to the CDS file
  * @param sourceRoot The source root directory
  * @param cdsCommand The CDS command to use
+ * @param cacheDir Optional path to a directory containing installed dependencies
  * @returns Result of the compilation
  */
 export function compileCdsToJson(
   cdsFilePath: string,
   sourceRoot: string,
   cdsCommand: string,
+  cacheDir?: string,
 ): CdsCompilationResult {
   try {
     const resolvedCdsFilePath = resolve(cdsFilePath);
@@ -45,7 +47,25 @@ export function compileCdsToJson(
     const cdsJsonOutPath = `${resolvedCdsFilePath}.json`;
     console.log(`Processing CDS file ${resolvedCdsFilePath} to ${cdsJsonOutPath} ...`);
 
-    const result: SpawnSyncReturns<Buffer> = spawnSync(
+    // Prepare spawn options
+    const spawnOptions: SpawnSyncOptions = {
+      cwd: sourceRoot,
+      shell: true,
+      stdio: 'pipe',
+    };
+
+    // If a cache directory is provided, set NODE_PATH to use that cache
+    if (cacheDir) {
+      const nodePath = join(cacheDir, 'node_modules');
+      spawnOptions.env = {
+        ...process.env,
+        NODE_PATH: `${nodePath}${delimiter}${process.env.NODE_PATH ?? ''}`,
+        PATH: `${join(nodePath, '.bin')}${delimiter}${process.env.PATH}`,
+      };
+      console.log(`Using cached dependencies from: ${cacheDir}`);
+    }
+
+    const result = spawnSync(
       cdsCommand,
       [
         'compile',
@@ -58,7 +78,7 @@ export function compileCdsToJson(
         '--log-level',
         'warn',
       ],
-      { cwd: sourceRoot, shell: true, stdio: 'pipe' },
+      spawnOptions,
     );
 
     if (result.error) {

extractors/cds/tools/src/cds/compiler/index.ts

@@ -1,2 +1,3 @@
 export * from './functions';
 export * from './types';
+export * from './projectMapping';

extractors/cds/tools/src/cds/compiler/projectMapping.ts

@@ -0,0 +1,34 @@
+/**
+ * Helper functions for mapping CDS files to their projects and cache directories
+ */
+
+/**
+ * Find the project directory for a CDS file
+ * @param cdsFilePath Path to the CDS file
+ * @param sourceRoot Source root directory
+ * @param projectMap Map of project directories to project objects
+ * @returns The project directory the file belongs to, or undefined if not found
+ */
+export function findProjectForCdsFile(
+  cdsFilePath: string,
+  sourceRoot: string,
+  projectMap: Map<string, { cdsFiles: string[] }>,
+): string | undefined {
+  // Get the relative path to the project directory for this CDS file
+  const relativeCdsFilePath = cdsFilePath.startsWith(sourceRoot)
+    ? cdsFilePath.substring(sourceRoot.length + 1)
+    : cdsFilePath;
+
+  // Find the project this file belongs to
+  for (const [projectDir, project] of projectMap.entries()) {
+    if (
+      project.cdsFiles.some(
+        cdsFile => cdsFile === relativeCdsFilePath || relativeCdsFilePath.startsWith(projectDir),
+      )
+    ) {
+      return projectDir;
+    }
+  }
+
+  return undefined;
+}