@sap/cds-compiler 4.8.0 → 4.9.2

package/CHANGELOG.md

@@ -7,6 +7,42 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 4.9.2 - 2024-05-13
+
+### Fixed
+
+- compiler: Rewriting annotation expression paths in structures of projections has been improved.
+- to.edm(x):
+  + Operator `/` represents `DivBy` operator, explicit `DivBy` is replaced with `Div` as integer division.
+- to.sql: consider all associations in tenant dependent entity for referential constraint generation
+
+## Version 4.9.0 - 2024-04-25
+
+### Added
+
+- compiler: Annotations with expressions are now rewritten when propagated.
+- for.seal: Added API function that produces a CSN for SEAL.
+- for.odata/to.edm(x): Support annotation path expressions including path flattening.
+
+### Changed
+
+- parser: A space between `.` and `*`/`{` (nested projections) is now a warning.  
+  Use `bin/cds_remove_invalid_whitespace.js` to automatically fix this warning.
+- compiler:
+  + Published compositions with filters are changed to associations.
+  + Expressions as annotation values are rejected for few known annotations that don't expect them.
+- Update OData vocabularies: 'Aggregation', 'Capabilities', 'Common', 'Hierarchy', 'PersonalData', 'Session', 'UI'.
+- to.edm(x): Exposed anonymous parameter types are now prefixed with `ap`, `bap` and `ep` for actions, bound actions and entities.
+
+### Fixed
+
+- compiler:
+  + Deprecated `$parameters` is no longer proposed in code completion.
+  + Duplicate mixin definitions lead to failing name resolution.
+- to.cdl: Types were always rendered for associations with filters, even if it would lead to a compilation failure.
+- to.edm(x):
+  + Fix a recursion bug in entity parameter handling.
+  + Fix event exclusion in service preprocessing.
 
 ## Version 4.8.0 - 2024-03-21
 
@@ -39,9 +75,6 @@ The compiler behavior concerning `beta` features can change at any time without
   + Turn types and aspects into dummies to reduce CSN size.
   + Correctly detect a removed `.default` and forcefully set the default to `null`.
 
-### Removed
-
-
 ## Version 4.7.6 - 2024-02-29
 
 ### Fixed
@@ -83,7 +116,8 @@ The compiler behavior concerning `beta` features can change at any time without
 - compiler: published associations with filters sometimes had the filter applied twice
   if used in inline aspect compositions
 - to.sql|hdi|hdbcds[.migration]:
-  + With `withHanaAssociations`: `false`, remove the association elements from the final CSN in order to correctly detect them during migration scenarios and
+  + With `withHanaAssociations`: `false`, remove the association elements from the final CSN in order
+    to correctly detect them during migration scenarios and
   with generated `hdbcds`.
   + Skip expensive processing (for calculated elements and nested projections) if the model doesn't use it.
   + Don't greedily set alias on subqueries if not required.

package/bin/cds_remove_invalid_whitespace.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+// Remove whitespace where the compiler does not expect it and will
+// emit an error in the next major version.
+//
+// This script removes whitespace where necessary.
+// It does not remove comments, even though they count as whitespace.
+//
+// Example CDS:
+//    entity P as projection on E { s. * };
+// will become:
+//    entity P as projection on E { s.* };
+//
+// Usage:
+//   ./cds_remove_invalid_whitespace.js my_file.cds
+//
+// If you want to update all files in a directory, you can use
+// this shell script:
+//   find . -type f -iname '*.cds' -exec ./cds_remove_invalid_whitespace.js {} \;
+//
+// Note that you need to update the path to this script in the commands above.
+//
+
+'use strict';
+
+const parseLanguage = require('../lib/language/antlrParser');
+const { createMessageFunctions } = require('../lib/base/messages');
+
+const fs = require('fs');
+const path = require('path');
+
+const cliArgs = process.argv.slice(2);
+const filepath = cliArgs[0];
+
+if (filepath === '--help' || filepath === '-h')
+  exitError();
+
+if (cliArgs.length !== 1)
+  exitError(`Expected exactly one argument, ${cliArgs.length} given`);
+
+if (!filepath)
+  exitError('Expected non-empty filepath as argument!');
+
+// Do not use allow-list approach.
+// There may be CDS files with other extensions than `.cds`.
+if (filepath.endsWith('.csn') || filepath.endsWith('.json'))
+  exitError('Only CDS files can be passed! Found CSN file!');
+
+const sourceStr = fs.readFileSync(filepath, 'utf-8');
+const newSourceStr = modernizeWhitespace(sourceStr, filepath);
+if (newSourceStr !== sourceStr)
+  fs.writeFileSync(filepath, newSourceStr);
+process.exit(0); // success
+
+// --------------------------------------------------------
+
+function modernizeWhitespace( source, filename ) {
+  const options = { messages: [], attachTokens: true };
+  const messageFunctions = createMessageFunctions( options, 'parse', null );
+
+  // parseLanguage does not throw on CompilationError, so
+  // we do not need a try...catch block.
+  const ast = parseLanguage(source, filename, options, messageFunctions);
+
+  // To avoid spam, only report errors.
+  // Users should use the compiler to get all messages.
+  const errors = options.messages.filter(msg => (msg.severity === 'Error'));
+  if (errors.length > 0) {
+    errors.forEach((msg) => {
+      console.error(msg.toString());
+    });
+    console.error(`Found ${errors.length} errors! \n`);
+    exitError('The CDS parser emitted errors. Fix them first and try again.');
+  }
+
+  if (!ast.artifacts)
+    return source;
+
+  let currentOffset = 0;
+
+  const { tokens } = ast.tokenStream;
+  for (let i = 0; i < tokens.length; ++i) {
+    const token = tokens[i];
+    const next = tokens[i + 1];
+    if (next && token.type === ast.tokenStream.DOTbeforeBRACE &&
+      (next.type === ast.tokenStream.ASTERISK || next.type === ast.tokenStream.BRACE))
+      updateWhitespace(token, next);
+  }
+
+  return source;
+
+  // -----------------------------------------------
+
+  function updateWhitespace( dot, braceOrAsterisk ) {
+    if (dot.stop === braceOrAsterisk.start)
+      return;
+
+    const from = dot.stop + currentOffset + 1; // end points at the position *before* the character
+    const to = braceOrAsterisk.start + currentOffset;
+
+    source = replaceSliceInSource(source, from, to, '');
+
+    currentOffset -= to - from;
+  }
+}
+
+/**
+ * Replaces a given span with @p replaceWith
+ *
+ * @param {string} source
+ * @param {number} startIndex
+ * @param {number} endIndex
+ * @param {string} replaceWith
+ * @return {string}
+ */
+function replaceSliceInSource( source, startIndex, endIndex, replaceWith ) {
+  return source.substring(0, startIndex) +
+          replaceWith +
+          source.substring(endIndex);
+}
+
+/**
+ * @param {string} [msg]
+ */
+function exitError( msg ) {
+  if (msg)
+    console.error(msg);
+  usage();
+  process.exit(1);
+}
+
+function usage() {
+  console.error('');
+  console.error(`usage: ${path.basename(process.argv[1])} <filename>`);
+}

package/bin/cds_update_annotations.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+// Update CDS Annotation References to use v4 expression syntax.
+//
+// This script replaces bare, unchecked references in annotation assignments
+// with the new syntax using `(`.
+//
+// Example CDS:
+//    @anno: ID entity E { key ID : String; };
+// will become:
+//    @anno: (ID) entity E { key ID : String; };
+//
+// Usage:
+//   ./cds_update_annotations.js my_file.cds
+//
+// If you want to update all identifiers in a directory, you can use
+// this Shell script:
+//   find . -type f -iname '*.cds' -exec ./cds_update_annotations.js {} \;
+//
+// Note that you need to update the path to this script in the commands above.
+//
+
+'use strict';
+
+const parseLanguage = require('../lib/language/antlrParser');
+const { createMessageFunctions } = require('../lib/base/messages');
+
+const fs = require('fs');
+const path = require('path');
+const { forEachMemberRecursively } = require('../lib/base/model');
+
+const cliArgs = process.argv.slice(2);
+const filepath = cliArgs[0];
+
+if (filepath === '--help' || filepath === '-h')
+  exitError();
+
+if (cliArgs.length !== 1)
+  exitError(`Expected exactly one argument, ${cliArgs.length} given`);
+
+if (!filepath)
+  exitError('Expected non-empty filepath as argument!');
+
+// Do not use allow-list approach.
+// There may be CDS files with other extensions than `.cds`.
+if (filepath.endsWith('.csn') || filepath.endsWith('.json'))
+  exitError('Only CDS files can be passed! Found CSN file!');
+
+const sourceStr = fs.readFileSync(filepath, 'utf-8');
+const newSourceStr = modernizeAnnotationExpressions(sourceStr, filepath);
+if (newSourceStr !== sourceStr)
+  fs.writeFileSync(filepath, newSourceStr);
+process.exit(0); // success
+
+// --------------------------------------------------------
+
+function modernizeAnnotationExpressions( source, filename ) {
+  const options = { messages: [], attachTokens: true };
+  const messageFunctions = createMessageFunctions( options, 'parse', null );
+
+  // parseLanguage does not throw on CompilationError, so
+  // we do not need a try...catch block.
+  const ast = parseLanguage(source, filename, options, messageFunctions);
+
+  // To avoid spam, only report errors.
+  // Users should use the compiler to get all messages.
+  const errors = options.messages.filter(msg => (msg.severity === 'Error'));
+  if (errors.length > 0) {
+    errors.forEach((msg) => {
+      console.error(msg.toString());
+    });
+    console.error(`Found ${errors.length} errors! \n`);
+    exitError('The parser emitted errors. Please fix them first and try again.');
+  }
+
+  if (!ast.artifacts)
+    return source;
+
+  let currentOffset = 0;
+
+  for (const artName in ast.artifacts) {
+    const art = ast.artifacts[artName];
+    updateAnnosOfArtifact(art);
+    forEachMemberRecursively(art, updateAnnosOfArtifact);
+  }
+  for (const vocName in ast.vocabularies) {
+    const voc = ast.vocabularies[vocName];
+    updateAnnosOfArtifact(voc);
+    forEachMemberRecursively(voc, updateAnnosOfArtifact);
+  }
+  for (const ext of ast.extensions)
+    updateAnnosOfArtifact(ext);
+
+  return source;
+
+  // -----------------------------------------------
+
+  function updateAnnosOfArtifact( art ) {
+    for (const prop in art) {
+      if (prop.charAt(0) === '@')
+        updateAnno(art[prop]);
+    }
+  }
+
+  function updateAnno( anno ) {
+    if (anno.literal === 'array') {
+      anno.val.forEach(val => updateAnno( val ));
+    }
+    else if (anno.literal === 'struct') {
+      const struct = Object.values(anno.struct);
+      struct.forEach(val => updateAnno( val ));
+    }
+    else if (!anno.$tokenTexts && anno.path) {
+      const first = anno.path[0];
+      const last = anno.path[anno.path.length - 1];
+      insertParentheses(first, last);
+    }
+  }
+
+  function findTokenFor( node ) {
+    const loc = node.location;
+    // We use slow linear search; we could do binary search, but not performance critical.
+    const { tokens } = ast.tokenStream;
+    for (const token of tokens) {
+      if (token.column + 1 === loc.col && token.line === loc.line)
+        return token;
+    }
+    return null;
+  }
+
+  function insertParentheses( first, last ) {
+    const firstToken = findTokenFor(first);
+    const lastToken = findTokenFor(last);
+
+    if (!firstToken?.stop || !lastToken?.stop)
+      throw new Error(`INTERNAL ERROR: Identifier at ${firstToken?.start} or ${lastToken?.start} has no end! (${filepath})`);
+
+    const start = firstToken.start + currentOffset;
+    const end = lastToken.stop + currentOffset + 1; // end points at the position *before* the character
+
+    const original = source.substring(start, end);
+    if (original.includes('@'))
+      return; // we ignore annotation references for now
+
+    const newSource = `( ${original} )`;
+    source = replaceSliceInSource(source, start, end, newSource);
+
+    currentOffset += (newSource.length - original.length);
+  }
+}
+
+/**
+ * Replaces a given span with @p replaceWith
+ *
+ * @param {string} source
+ * @param {number} startIndex
+ * @param {number} endIndex
+ * @param {string} replaceWith
+ * @return {string}
+ */
+function replaceSliceInSource( source, startIndex, endIndex, replaceWith ) {
+  return source.substring(0, startIndex) +
+          replaceWith +
+          source.substring(endIndex);
+}
+
+/**
+ * @param {string} [msg]
+ */
+function exitError( msg ) {
+  if (msg)
+    console.error(msg);
+  usage();
+  process.exit(1);
+}
+
+function usage() {
+  console.error('');
+  console.error(`usage: ${path.basename(process.argv[1])} <filename>`);
+}

package/bin/cds_update_identifiers.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 
-//
 // Update CDS Delimited Identifiers
 //
 // This script replaces the old delimited identifier style with the new one
@@ -12,11 +11,11 @@
 //    entity ![My Entity] { ... }
 //
 // Usage:
-//   cds_update_identifiers.js my_file.cds
+//   ./cds_update_identifiers.js my_file.cds
 //
 // If you want to update all identifiers in a directory, you can use
 // this Shell script:
-//   find . -type f -iname '*.cds' -exec cds_update_identifiers.js {} \;
+//   find . -type f -iname '*.cds' -exec ./cds_update_identifiers.js {} \;
 //
 // Note that you need to update the path to this script in the commands above.
 //
@@ -70,7 +69,7 @@ function modernizeIdentifierStyle( source, filename ) {
       console.error(msg.toString());
     });
     console.error(`Found ${errors.length} errors! \n`);
-    exitError('The parser emitted errors. Please fix them first and try again.');
+    exitError('The CDS parser emitted errors. Fix them first and try again.');
   }
 
   let currentOffset = 0;

package/bin/cdsc.js

@@ -278,6 +278,7 @@ function executeCommandLine( command, options, args ) {
     toSql,
     inspect,
     toEffectiveCsn,
+    forSeal,
   };
   const commandsWithoutCompilation = {
     explain,
@@ -318,7 +319,7 @@ function executeCommandLine( command, options, args ) {
   }
 
   function toEffectiveCsn( model ) {
-    const features = [ 'resolveSimpleTypes', 'resolveProjections' ];
+    const features = [ 'resolveSimpleTypes', 'resolveProjections', 'remapOdataAnnotations', 'keepLocalized' ];
     for (const feature of features) {
       if (options[feature]) // map to boolean equivalent
         options[feature] = options[feature] === 'true';
@@ -329,6 +330,18 @@ function executeCommandLine( command, options, args ) {
     return model;
   }
 
+  function forSeal( model ) {
+    const features = [ 'remapOdataAnnotations' ];
+    for (const feature of features) {
+      if (options[feature]) // map to boolean equivalent
+        options[feature] = options[feature] === 'true';
+    }
+    const csn = options.directBackend ? model : compactModel(model, options);
+    displayNamedCsn(main.for.seal(csn, options), 'seal');
+
+    return model;
+  }
+
   // Execute the command line option 'toCsn' and display the results.
   // Return the original model (for chaining)
   function toCsn( model ) {
@@ -565,22 +578,12 @@ function executeCommandLine( command, options, args ) {
   // Depending on 'options.rawOutput', the model is either compacted to 'name.json' or
   // written in raw form to '<name>_raw.txt'.
   function displayNamedXsn( xsn, name ) {
-    if (options.rawOutput) {
+    if (options.rawOutput)
       writeToFileOrDisplay(options.out, `${name}_raw.txt`, util.inspect(reveal(xsn, options.rawOutput), false, null), true);
-    }
-    else if (options.internalMsg) {
+    else if (options.internalMsg)
       writeToFileOrDisplay(options.out, `${name}_raw.txt`, util.inspect(reveal(xsn).messages, { depth: null, maxArrayLength: null }), true);
-    }
-    else if (!options.parseOnly) { // no output if parseOnly but not rawOutput
-      const csn = compactModel(xsn, options);
-      if (command === 'toCsn' && options.tenantDiscriminator)
-        addTenantFields(csn, options);
-      if (command === 'toCsn' && options.withLocalized)
-        addLocalizationViews(csn, options);
-      if (options.enrichCsn)
-        enrichCsn( csn, options );
-      writeToFileOrDisplay(options.out, `${name}.json`, csn, true);
-    }
+    else if (!options.parseOnly) // no output if parseOnly but not rawOutput
+      displayNamedCsn(compactModel(xsn, options), name);
   }
 
   /**
@@ -590,12 +593,22 @@ function executeCommandLine( command, options, args ) {
   function displayNamedCsn( csn, name ) {
     if (!csn) // only print CSN if it is set.
       return;
+
+    if (command === 'toCsn' ) {
+      // If requested, run some CSN postprocessing.
+      if (options.tenantDiscriminator)
+        addTenantFields(csn, options); // always _before_ localized convenience views are added
+      if (options.withLocalized)
+        addLocalizationViews(csn, options);
+    }
+
+    if (options.enrichCsn)
+      enrichCsn( csn, options );
+
     if (options.internalMsg) {
       writeToFileOrDisplay(options.out, `${name}_raw.txt`, options.messages, true);
     }
     else if (!options.internalMsg) {
-      if (command === 'toCsn' && options.withLocalized)
-        addLocalizationViews(csn, options);
       writeToFileOrDisplay(options.out, `${name}.json`, csn, true);
     }
   }

package/doc/CHANGELOG_BETA.md

@@ -8,6 +8,25 @@ Note: `beta` fixes, changes and features are listed in this ChangeLog just for i
 The compiler behavior concerning `beta` features can change at any time without notice.
 **Don't use `beta` fixes, changes and features in productive mode.**
 
+## Version 4.9.0 - 2024-04-25
+
+## Removed `odataAnnotationExpressions`
+
+It is now enabled by default.
+
+## Removed `odataPathsInAnnotationExpressions`
+
+It is now enabled by default.
+
+## Removed `annotationExpressions`
+
+It is now enabled by default.
+
+## Added `temporalRawProjection`
+
+Enables revocation of temporal where clause in projections of temporal entities if the
+`@cds.valid { from, to }` annotations on the projection elements have falsy values.
+
 ## Version 4.8.0 - 2024-03-21
 
 ### Removed `vectorType`