First attempt at project-aware CDS compilation

Initial attempt to use the `cds compile` CLI command in a way that
allows for de-duplication of individual `.cds` files that are already
included by another `.cds` file in the project.

Author: data-douser

extractors/cds/tools/cds-extractor.ts

@@ -111,7 +111,15 @@ for (const rawCdsFilePath of cdsFilePathsToProcess) {
     const cdsCommand = determineCdsCommand(cacheDir);
 
     // Use resolved path directly instead of passing through getArg
-    const compilationResult = compileCdsToJson(rawCdsFilePath, sourceRoot, cdsCommand, cacheDir);
+    // Pass the project dependency information to enable project-aware compilation
+    const compilationResult = compileCdsToJson(
+      rawCdsFilePath,
+      sourceRoot,
+      cdsCommand,
+      cacheDir,
+      projectMap,
+      projectDir,
+    );
 
     if (!compilationResult.success && compilationResult.message) {
       console.error(

extractors/cds/tools/package.json

@@ -9,7 +9,7 @@
     "clean": "rm -rf out coverage",
     "prebuild": "npm run clean",
     "lint": "eslint --ext .ts src/",
-    "lint:fix": "eslint --ext .ts --fix src/",
+    "lint:fix": "eslint --ext .ts --fix cds-extractor.ts src/",
     "format": "prettier --write 'src/**/*.ts'",
     "test": "jest",
     "test:watch": "jest --watch",

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

@@ -1,5 +1,5 @@
 import { execFileSync, spawnSync, SpawnSyncOptions } from 'child_process';
-import { resolve, join, delimiter } from 'path';
+import { resolve, join, delimiter, relative } from 'path';
 
 import { CdsCompilationResult } from './types';
 import { fileExists, dirExists, recursivelyRenameJsonFiles } from '../../filesystem';
@@ -87,13 +87,24 @@ export function getCdsVersion(cdsCommand: string, cacheDir?: string): string | u
  * @param sourceRoot The source root directory
  * @param cdsCommand The CDS command to use
  * @param cacheDir Optional path to a directory containing installed dependencies
+ * @param projectMap Optional map of project directories to project objects with dependency information
+ * @param projectDir Optional project directory this CDS file belongs to
  * @returns Result of the compilation
  */
 export function compileCdsToJson(
   cdsFilePath: string,
   sourceRoot: string,
   cdsCommand: string,
   cacheDir?: string,
+  projectMap?: Map<
+    string,
+    {
+      projectDir: string;
+      cdsFiles: string[];
+      imports?: Map<string, Array<{ resolvedPath?: string }>>;
+    }
+  >,
+  projectDir?: string,
 ): CdsCompilationResult {
   try {
     const resolvedCdsFilePath = resolve(cdsFilePath);
@@ -106,7 +117,6 @@ export function compileCdsToJson(
     // Get and log the CDS version
     const cdsVersion = getCdsVersion(cdsCommand, cacheDir);
     const versionInfo = cdsVersion ? `with CDS v${cdsVersion}` : '';
-    console.log(`Processing CDS file ${resolvedCdsFilePath} ${versionInfo}...`);
 
     // Prepare spawn options
     const spawnOptions: SpawnSyncOptions = {
@@ -128,25 +138,93 @@ export function compileCdsToJson(
         // Add NPM configuration to ensure dependencies are resolved from the cache directory
         npm_config_prefix: cacheDir,
       };
+    }
+
+    // Determine if we should compile this file directly or as part of a project
+    // Check if the projectMap and projectDir are provided
+    const isProjectAware = projectMap && projectDir && projectMap.get(projectDir);
+    let isRootCdsFile = false;
+    let projectBasedCompilation = false;
+
+    if (isProjectAware) {
+      const project = projectMap.get(projectDir);
+      const relativePath = relative(sourceRoot, resolvedCdsFilePath);
+
+      // Check if this is a root CDS file (not imported by other files)
+      if (project?.cdsFiles) {
+        // Create a map to track imported files in the project
+        const importedFiles = new Map<string, boolean>();
 
-      console.log(`Using cached dependencies from: ${cacheDir}`);
+        // First pass: collect all imported files in the project
+        for (const file of project.cdsFiles) {
+          try {
+            const absoluteFilePath = join(sourceRoot, file);
+            if (fileExists(absoluteFilePath)) {
+              // Get imports for this file
+              const imports = project.imports?.get(file) ?? [];
+
+              // Mark imported files
+              for (const importInfo of imports) {
+                if (importInfo.resolvedPath) {
+                  importedFiles.set(importInfo.resolvedPath, true);
+                }
+              }
+            }
+          } catch (error) {
+            console.warn(`Warning: Error processing imports for ${file}: ${String(error)}`);
+          }
+        }
+
+        // Check if current file is not imported by any other file in the project
+        isRootCdsFile = !importedFiles.has(relativePath);
+
+        // If the file is a root CDS file, we'll use a project-based compilation approach
+        if (isRootCdsFile) {
+          projectBasedCompilation = true;
+          console.log(
+            `${resolvedCdsFilePath} identified as a root CDS file - using project-aware compilation ${versionInfo}...`,
+          );
+        } else {
+          console.log(
+            `${resolvedCdsFilePath} is imported by other files - will be compiled as part of a project ${versionInfo}...`,
+          );
+        }
+      }
+    } else {
+      // Fallback to individual file compilation if project information is not available
+      console.log(`Processing individual CDS file ${resolvedCdsFilePath} ${versionInfo}...`);
+    }
+
+    // If it's not a root file and project-based compilation is enabled,
+    // return success without additional processing since it will be compiled as part of its root file
+    if (isProjectAware && !isRootCdsFile) {
+      return {
+        success: true,
+        outputPath: cdsJsonOutPath,
+        compiledAsProject: true,
+        message: 'File was compiled as part of a project-based compilation',
+      };
     }
 
-    const result = spawnSync(
-      cdsCommand,
-      [
-        'compile',
-        resolvedCdsFilePath,
-        '--to',
-        'json',
-        '--dest',
-        cdsJsonOutPath,
-        '--locations',
-        '--log-level',
-        'warn',
-      ],
-      spawnOptions,
-    );
+    // Compile the file
+    const compileArgs = [
+      'compile',
+      resolvedCdsFilePath,
+      '--to',
+      'json',
+      '--dest',
+      cdsJsonOutPath,
+      '--locations',
+      '--log-level',
+      'warn',
+    ];
+
+    // For root CDS files in project-aware mode, add --parse flag to ensure complete model
+    if (projectBasedCompilation) {
+      compileArgs.push('--parse');
+    }
+
+    const result = spawnSync(cdsCommand, compileArgs, spawnOptions);
 
     if (result.error) {
       throw new Error(`Error executing CDS compiler: ${result.error.message}`);
@@ -175,7 +253,11 @@ export function compileCdsToJson(
       console.log(`CDS compiler generated JSON to file: ${cdsJsonOutPath}`);
     }
 
-    return { success: true, outputPath: cdsJsonOutPath };
+    return {
+      success: true,
+      outputPath: cdsJsonOutPath,
+      compiledAsProject: projectBasedCompilation,
+    };
   } catch (error) {
     return { success: false, message: String(error) };
   }

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

@@ -5,4 +5,6 @@ export interface CdsCompilationResult {
   success: boolean;
   message?: string;
   outputPath?: string;
+  /** Flag indicating if this file was compiled directly or as part of a project */
+  compiledAsProject?: boolean;
 }