Rework CDS project-only compilation & CDL.qll

Reworks the CDS extractor such that it only does project-level
compilation, which allows for consistently generating a single
model.cds.json file in the base/root directory of its associated
project, which allows for matching file paths relative to the
project base directory.

Updates the `CDL.qll` library file to use location/path values
that are relative to the project base directory rather than relative
to the source root directory.

Author: data-douser

extractors/cds/tools/cds-extractor.ts

@@ -99,7 +99,7 @@ try {
     for (const [projectDir, project] of dependencyGraph.projects.entries()) {
       cdsExtractorLog(
         'info',
-        `Project: ${projectDir}, Status: ${project.status}, CDS files: ${project.cdsFiles.length}, Compilations to run: ${project.cdsFilesToCompile.length}`,
+        `Project: ${projectDir}, Status: ${project.status}, CDS files: ${project.cdsFiles.length}, Compilation targets: ${project.compilationTargets.length}`,
       );
     }
   } else {

extractors/cds/tools/dist/cds-extractor.bundle.js

@@ -1,7 +1,5 @@
 import { spawnSync, SpawnSyncOptions } from 'child_process';
-import { resolve, join, delimiter, relative } from 'path';
-
-import { globSync } from 'glob';
+import { resolve, join, delimiter, relative, dirname, basename } from 'path';
 
 import { CdsCompilationResult } from './types';
 import { getCdsVersion } from './version';
@@ -22,12 +20,43 @@ function parseCommandForSpawn(commandString: string): { executable: string; base
 }
 
 /**
- * Compiles a CDS file to JSON using robust, project-aware compilation only.
- * This function has been refactored to align with the autobuild.md vision by removing all
- * forms of individual file compilation and ensuring only project-aware compilation is used.
+ * Determines compilation targets for a CDS project according to the new project-only compilation approach.
+ * @param project The CDS project
+ * @param sourceRoot The source root directory
+ * @returns Array of compilation targets (directories or files relative to project base)
+ */
+function determineCompilationTargets(project: BasicCdsProject, sourceRoot: string): string[] {
+  const projectAbsolutePath = join(sourceRoot, project.projectDir);
+
+  // Check for standard CAP directories
+  const capDirectories = ['db', 'srv', 'app'];
+  const existingCapDirs = capDirectories.filter(dir => dirExists(join(projectAbsolutePath, dir)));
+
+  if (existingCapDirs.length > 0) {
+    // Use standard CAP directories
+    return existingCapDirs;
+  }
+
+  // Check for root-level CDS files
+  const rootCdsFiles = project.cdsFiles
+    .filter(file => dirname(join(sourceRoot, file)) === projectAbsolutePath)
+    .map(file => basename(file));
+
+  if (rootCdsFiles.length > 0) {
+    // Use root-level files
+    return rootCdsFiles;
+  }
+
+  // Use all CDS files with their relative paths
+  return project.cdsFiles.map(file => relative(projectAbsolutePath, join(sourceRoot, file)));
+}
+
+/**
+ * Compiles a CDS project to JSON using project-level compilation only.
+ * This function has been simplified to only use project-level compilation,
+ * eliminating all individual file compilation logic and standardizing output
+ * to a single model.cds.json file per project.
  *
- * For root files, this will compile them to their 1:1 .cds.json representation if and only
- * if the file is a true root file in a project.
  *
  * @param cdsFilePath The path to the CDS file to compile, relative to the `sourceRoot`.
  * @param sourceRoot The source root directory scanned by the CDS extractor.
@@ -73,131 +102,54 @@ export function compileCdsToJson(
     }
 
     const project = projectMap.get(projectDir);
-    const relativePath = relative(sourceRoot, resolvedCdsFilePath);
-
-    // Check if this is a project-level compilation marker.
-    if (shouldUseProjectLevelCompilation(project)) {
-      return compileProjectLevel(
-        resolvedCdsFilePath,
-        sourceRoot,
-        projectDir,
-        cdsCommand,
-        spawnOptions,
-        versionInfo,
-      );
-    }
 
-    // Check if this file is in the list of files to compile for this project.
-    if (!shouldCompileIndividually(project, relativePath)) {
-      cdsExtractorLog(
-        'info',
-        `${resolvedCdsFilePath} is imported by other files - will be compiled as part of a project ${versionInfo}...`,
-      );
-      const cdsJsonOutPath = `${resolvedCdsFilePath}.json`;
-      return {
-        success: true,
-        outputPath: cdsJsonOutPath,
-        compiledAsProject: true,
-        message: 'File was compiled as part of a project-based compilation',
-      };
-    } else {
-      // This is a root file - compile it using project-aware approach to its 1:1 representation
-      cdsExtractorLog(
-        'info',
-        `${resolvedCdsFilePath} identified as a root CDS file - using project-aware compilation for root file ${versionInfo}...`,
-      );
-      return compileRootFileAsProject(
-        resolvedCdsFilePath,
-        sourceRoot,
-        projectDir,
-        cdsCommand,
-        spawnOptions,
-      );
-    }
+    // Always use project-level compilation
+    return compileProject(sourceRoot, projectDir, cdsCommand, spawnOptions, versionInfo, project!);
   } catch (error) {
     return { success: false, message: String(error) };
   }
 }
 
 /**
- * Handles project-level compilation for CAP projects with typical directory structure.
+ * Handles project-level compilation for CAP projects.
  * CRITICAL: Uses the project base directory as cwd and calculates paths relative to project base directory.
  *
- * @param resolvedCdsFilePath The resolved CDS file path that triggered this compilation
  * @param sourceRoot The source root directory
  * @param projectDir The project directory (relative to sourceRoot)
  * @param cdsCommand The CDS command to use
  * @param spawnOptions Pre-configured spawn options with project base directory as cwd
  * @param versionInfo Version information for logging
+ * @param project The CDS project instance
  * @returns Compilation result
  */
-function compileProjectLevel(
-  resolvedCdsFilePath: string,
+function compileProject(
   sourceRoot: string,
   projectDir: string,
   cdsCommand: string,
   spawnOptions: SpawnSyncOptions,
   versionInfo: string,
+  project: BasicCdsProject,
 ): CdsCompilationResult {
   cdsExtractorLog(
     'info',
-    `${resolvedCdsFilePath} is part of a CAP project - using project-aware compilation ${versionInfo}...`,
+    `Compiling CDS project using project-level compilation ${versionInfo}...`,
   );
 
-  // For project-level compilation, compile the entire project together
-  // This follows the CAP best practice of compiling db and srv directories together
-  const projectAbsolutePath = join(sourceRoot, projectDir);
-
-  // Common directories in CAP projects that should be compiled together
-  const capDirectories = ['db', 'srv', 'app'];
-  const existingDirectories: string[] = [];
-
-  for (const dir of capDirectories) {
-    const dirPath = join(projectAbsolutePath, dir);
-    if (dirExists(dirPath)) {
-      existingDirectories.push(dir);
-    }
-  }
+  // Determine compilation targets using the new centralized logic
+  const compilationTargets = determineCompilationTargets(project, sourceRoot);
 
-  // Check if there are any CDS files in the project at all before proceeding
-  const allCdsFiles = globSync(join(projectAbsolutePath, '**/*.cds'), {
-    nodir: true,
-    ignore: ['**/node_modules/**'],
-  });
-
-  if (allCdsFiles.length === 0) {
+  if (compilationTargets.length === 0) {
     throw new Error(
       `Project directory '${projectDir}' does not contain any CDS files and cannot be compiled`,
     );
   }
 
-  if (existingDirectories.length === 0) {
-    // If no standard directories, check if there are CDS files in the root of the project.
-    const rootCdsFiles = globSync(join(projectAbsolutePath, '*.cds'));
-    if (rootCdsFiles.length > 0) {
-      existingDirectories.push('.');
-    } else {
-      // Find directories that contain `.cds` files.
-      const cdsFileParents = new Set(
-        allCdsFiles.map((file: string) => {
-          const relativePath = relative(projectAbsolutePath, file);
-          const firstDir = relativePath.split('/')[0];
-          return firstDir === relativePath ? '.' : firstDir;
-        }),
-      );
-      existingDirectories.push(...Array.from(cdsFileParents));
-    }
-  }
-
-  // Generate output path for the compiled model - relative to project base directory.
+  // Generate output path for the compiled model - always model.cds.json in project base directory
   const projectJsonOutPath = join(sourceRoot, projectDir, 'model.cds.json');
 
-  // Convert directories to be relative to project base directory.
-  const projectRelativeDirectories = existingDirectories;
-
   const compileArgs = [
     'compile',
-    ...projectRelativeDirectories, // Use paths relative to project base directory.
+    ...compilationTargets,
     '--to',
     'json',
     '--dest',
@@ -207,7 +159,7 @@ function compileProjectLevel(
     'warn',
   ];
 
-  cdsExtractorLog('info', `Compiling CAP project directories: ${existingDirectories.join(', ')}`);
+  cdsExtractorLog('info', `Compiling CDS project targets: ${compilationTargets.join(', ')}`);
   cdsExtractorLog(
     'info',
     `Running compilation task for CDS project '${projectDir}': command='${cdsCommand}' args='${JSON.stringify(compileArgs)}'`,
@@ -270,107 +222,6 @@ function compileProjectLevel(
   };
 }
 
-/**
- * Compiles a root CDS file using project-aware approach for 1:1 .cds.json representation.
- * This follows the autobuild.md vision of project-aware compilation only.
- *
- * @param resolvedCdsFilePath The resolved CDS file path
- * @param sourceRoot The source root directory
- * @param projectDir The project directory
- * @param cdsCommand The CDS command to use
- * @param spawnOptions Pre-configured spawn options
- * @param versionInfo Version information for logging
- * @returns The {@link CdsCompilationResult}
- */
-function compileRootFileAsProject(
-  resolvedCdsFilePath: string,
-  sourceRoot: string,
-  projectDir: string,
-  cdsCommand: string,
-  spawnOptions: SpawnSyncOptions,
-): CdsCompilationResult {
-  // Calculate project base directory and file path relative to project
-  const projectBaseDir = join(sourceRoot, projectDir);
-  const relativeCdsPath = relative(projectBaseDir, resolvedCdsFilePath);
-  const cdsJsonOutPath = `${resolvedCdsFilePath}.json`;
-
-  // Use project-aware compilation with specific file target
-  const compileArgs = [
-    'compile',
-    relativeCdsPath, // Compile the specific file relative to project base directory
-    '--to',
-    'json',
-    '--dest',
-    `${relativeCdsPath}.json`,
-    '--locations',
-    '--log-level',
-    'warn',
-  ];
-
-  cdsExtractorLog(
-    'info',
-    `Compiling root CDS file using project-aware approach: ${relativeCdsPath}`,
-  );
-  cdsExtractorLog(
-    'info',
-    `Executing CDS command: command='${cdsCommand}' args='${JSON.stringify(compileArgs)}'`,
-  );
-
-  // Execute the compilation
-  // Parse command for proper spawnSync execution
-  const { executable, baseArgs } = parseCommandForSpawn(cdsCommand);
-  const allArgs = [...baseArgs, ...compileArgs];
-
-  const result = spawnSync(executable, allArgs, spawnOptions);
-
-  if (result.error) {
-    cdsExtractorLog('error', `SpawnSync error: ${result.error.message}`);
-    throw new Error(`Error executing CDS compiler: ${result.error.message}`);
-  }
-
-  // Log stderr for debugging even on success
-  if (result.stderr && result.stderr.length > 0) {
-    cdsExtractorLog('warn', `CDS stderr output: ${result.stderr.toString()}`);
-  }
-
-  if (result.status !== 0) {
-    cdsExtractorLog('error', `CDS command failed with status ${result.status}`);
-    cdsExtractorLog(
-      'error',
-      `Command: ${cdsCommand} ${compileArgs.map(arg => (arg.includes(' ') ? `"${arg}"` : arg)).join(' ')}`,
-    );
-    cdsExtractorLog('error', `Stdout: ${result.stdout?.toString() || 'No stdout'}`);
-    cdsExtractorLog('error', `Stderr: ${result.stderr?.toString() || 'No stderr'}`);
-    throw new Error(
-      `Could not compile the root CDS file ${relativeCdsPath}.\nReported error(s):\n\`\`\`\n${
-        result.stderr?.toString() || 'Unknown error'
-      }\n\`\`\``,
-    );
-  }
-
-  if (!fileExists(cdsJsonOutPath) && !dirExists(cdsJsonOutPath)) {
-    throw new Error(
-      `Root CDS file '${relativeCdsPath}' was not compiled to JSON. Expected output: ${cdsJsonOutPath}`,
-    );
-  }
-
-  // Handle directory output if the CDS compiler generated a directory
-  if (dirExists(cdsJsonOutPath)) {
-    cdsExtractorLog('info', `CDS compiler generated JSON to output directory: ${cdsJsonOutPath}`);
-    // Recursively rename all .json files to have a .cds.json extension
-    recursivelyRenameJsonFiles(cdsJsonOutPath);
-  } else {
-    cdsExtractorLog('info', `CDS compiler generated JSON to file: ${cdsJsonOutPath}`);
-  }
-
-  return {
-    success: true,
-    outputPath: cdsJsonOutPath,
-    compiledAsProject: true,
-    message: 'Root file compiled using project-aware compilation',
-  };
-}
-
 /**
  * Creates spawn options for CDS compilation processes.
  * CRITICAL: Always sets cwd to project base directory to ensure generated JSON paths are relative to project base directory.
@@ -425,27 +276,3 @@ function createSpawnOptions(
 
   return spawnOptions;
 }
-
-/**
- * Determines if a file should be compiled individually or skipped because it's part of a project.
- *
- * @param project The CDS project
- * @param relativePath The relative path of the file being checked
- * @returns true if the file should be compiled individually
- */
-function shouldCompileIndividually(
-  project: BasicCdsProject | undefined,
-  relativePath: string,
-): boolean {
-  return project?.cdsFilesToCompile?.includes(relativePath) ?? true;
-}
-
-/**
- * Determines if the given project should use project-level compilation.
- *
- * @param project The CDS project to check
- * @returns true if project-level compilation should be used
- */
-function shouldUseProjectLevelCompilation(project: BasicCdsProject | undefined): boolean {
-  return project?.cdsFilesToCompile?.includes('__PROJECT_LEVEL_COMPILATION__') ?? false;
-}