@sap/cds-compiler 4.8.0 → 4.9.0

package/CHANGELOG.md

@@ -7,6 +7,33 @@
 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.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 +66,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 +107,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 ) {

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`

package/lib/api/main.js

@@ -26,10 +26,7 @@ const baseError = lazyload('../base/error');
 const csnToEdm = lazyload('../edm/csn2edm');
 const trace = lazyload('./trace');
 const cloneCsn = lazyload('../model/cloneCsn');
-
-const { forEach, forEachKey } = require('../utils/objectUtils');
-const { makeMessageFunction } = require('../base/messages');
-const { sortCsnForTests } = require('../model/cloneCsn');
+const objectUtils = lazyload('../utils/objectUtils');
 
 /**
  * Return the artifact name for use for the hdbresult object
@@ -59,18 +56,18 @@ const warnAboutMismatchOdata = [ 'odataVersion' ];
 function attachTransformerCharacteristics( csn, transformation, options,
                                            relevantOptionNames, optionalOptionNames = [] ) {
   const relevant = {};
-  for (const name of relevantOptionNames ) {
+  for (const name of relevantOptionNames) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
 
-  for (const name of optionalOptionNames ) {
+  for (const name of optionalOptionNames) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
 
   // eslint-disable-next-line sonarjs/no-empty-collection
-  for (const name of relevantGeneralOptions ) {
+  for (const name of relevantGeneralOptions) {
     if (options[name] !== undefined)
       relevant[name] = options[name];
   }
@@ -142,7 +139,7 @@ function isPreTransformed( csn, transformation ) {
 function odataInternal( csn, internalOptions, messageFunctions ) {
   internalOptions.transformation = 'odata';
   let oDataCsn = forOdataNew.transform4odataWithCsn(csn, internalOptions, messageFunctions);
-  oDataCsn = sortCsnForTests(oDataCsn, internalOptions);
+  oDataCsn = cloneCsn.sortCsnForTests(oDataCsn, internalOptions);
   messageFunctions.setModel(oDataCsn);
   attachTransformerCharacteristics(oDataCsn, 'odata', internalOptions, relevantOdataOptions, warnAboutMismatchOdata);
   return oDataCsn;
@@ -273,13 +270,12 @@ function forHdbcds( csn, options, messageFunctions ) {
  *
  * @param {CSN.Model} csn Plain input CSN
  * @param {EffectiveCsnOptions} options Options
+ * @param {EffectiveCsnOptions} internalOptions Options that were already processed
  * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
  * @returns {CSN.Model} CSN transformed
  * @private
  */
-function forEffective( csn, options, messageFunctions ) {
-  const internalOptions = prepareOptions.for.effective(options);
-  internalOptions.transformation = 'effective';
+function forEffectiveInternal( csn, options, internalOptions, messageFunctions ) {
   messageFunctions.setOptions( internalOptions );
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
@@ -294,6 +290,40 @@ function forEffective( csn, options, messageFunctions ) {
   return cloneCsn.sortCsnForTests(eCsn, internalOptions);
 }
 
+/**
+ * SEAL CSN transformation
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {EffectiveCsnOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} CSN transformed
+ * @private
+ */
+function forSeal( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.seal(options);
+  internalOptions.transformation = 'effective';
+  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+}
+
+/**
+ * Effective CSN transformation
+ *
+ * @param {CSN.Model} csn Plain input CSN
+ * @param {EffectiveCsnOptions} options Options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @returns {CSN.Model} CSN transformed
+ * @private
+ */
+function forEffective( csn, options, messageFunctions ) {
+  const internalOptions = prepareOptions.for.effective(options);
+  internalOptions.transformation = 'effective';
+  // for.effective is still beta mode
+  if (!baseModel.isBetaEnabled(options, 'effectiveCsn'))
+    throw new baseError.CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
+
+  return forEffectiveInternal(csn, options, internalOptions, messageFunctions);
+}
+
 /**
  * Process the given CSN into SQL.
  *
@@ -352,7 +382,7 @@ function hdi( csn, options, messageFunctions ) {
     const sqlArtifactsWithCSNNamesToSort = Object.create(null);
     const sqlArtifactsNotToSort = Object.create(null);
 
-    forEach(flat, (key) => {
+    objectUtils.forEach(flat, (key) => {
       const artifactNameLikeInCsn = key.replace(/\.[^/.]+$/, '');
       nameMapping[artifactNameLikeInCsn] = key;
       if (key.endsWith('.hdbtable') || key.endsWith('.hdbview'))
@@ -370,7 +400,7 @@ function hdi( csn, options, messageFunctions ) {
       }, Object.create(null));
 
     // now add the not-sorted stuff, like indices
-    forEach(sqlArtifactsNotToSort, (key) => {
+    objectUtils.forEach(sqlArtifactsNotToSort, (key) => {
       sorted[remapName(key, sqlCSN, k => !k.endsWith('.hdbindex'))] = sqlArtifactsNotToSort[key];
     });
 
@@ -392,7 +422,7 @@ function hdi( csn, options, messageFunctions ) {
 function remapNames( dict, csn, filter ) {
   const result = Object.create(null);
 
-  forEach(dict, (key, value) => {
+  objectUtils.forEach(dict, (key, value) => {
     const name = remapName(key, csn, filter);
     result[name] = value;
   });
@@ -540,7 +570,7 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
   const createAndAlterSqls = [];
   // Turn the structured result into just a flat dictionary of "artifact name": "sql"
   const flatSqlDict = Object.values(hdbkinds).reduce((prev, curr) => {
-    forEach(curr, (name, value) => {
+    objectUtils.forEach(curr, (name, value) => {
       prev[name] = value;
     });
     return prev;
@@ -629,9 +659,9 @@ function hdiMigration( csn, options, messageFunctions, beforeImage ) {
  */
 function createSqlDefinitions( hdbkinds, afterImage ) {
   const result = [];
-  forEach(hdbkinds, (kind, artifacts) => {
+  objectUtils.forEach(hdbkinds, (kind, artifacts) => {
     const suffix = `.${ kind }`;
-    forEach(artifacts, (name, sqlStatement) => {
+    objectUtils.forEach(artifacts, (name, sqlStatement) => {
       if ( kind !== 'hdbindex' )
         result.push({ name: getFileName(name, afterImage), suffix, sql: sqlStatement });
       else
@@ -649,7 +679,7 @@ function createSqlDefinitions( hdbkinds, afterImage ) {
  */
 function createSqlDeletions( deletions, beforeImage ) {
   const result = [];
-  forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
+  objectUtils.forEach(deletions, name => result.push({ name: getFileName(name, beforeImage), suffix: '.hdbtable' }));
   return result;
 }
 /**
@@ -661,7 +691,7 @@ function createSqlDeletions( deletions, beforeImage ) {
  */
 function createSqlMigrations( migrations, afterImage ) {
   const result = [];
-  forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
+  objectUtils.forEach(migrations, (name, changeset) => result.push({ name: getFileName(name, afterImage), suffix: '.hdbmigrationtable', changeset }));
   return result;
 }
 
@@ -682,6 +712,10 @@ function hdbcds( csn, options, messageFunctions ) {
   internalOptions.transformation = 'hdbcds';
   messageFunctions.setOptions( internalOptions );
 
+  // no "isBetaEnabled", because this warning must also appear with "deprecated" flags
+  if (internalOptions.betaMode || internalOptions.beta?.v5preview)
+    messageFunctions.warning('api-deprecated-v5', null, null);
+
   if (options.tenantDiscriminator) {
     messageFunctions.error('api-invalid-option', null, {
       '#': 'forbidden',
@@ -1012,10 +1046,10 @@ function preparedCsnToEdmAll( csn, options, messageFunctions ) {
  */
 function flattenResultStructure( toProcess ) {
   const result = {};
-  forEach(toProcess, (fileType, artifacts) => {
+  objectUtils.forEach(toProcess, (fileType, artifacts) => {
     if (fileType === 'messages')
       return;
-    forEach(artifacts, (filename) => {
+    objectUtils.forEach(artifacts, (filename) => {
       result[`${ filename }.${ fileType }`] = artifacts[filename];
     });
   });
@@ -1039,14 +1073,15 @@ module.exports = {
   for_hdi: publishCsnProcessor(forHdi, 'for.hdi'),
   for_hdbcds: publishCsnProcessor(forHdbcds, 'for.hdbcds'),
   for_effective: publishCsnProcessor(forEffective, 'for.effective'),
+  for_seal: publishCsnProcessor(forSeal, 'for.seal'),
 
   /* Deprecated, will be removed in cds-compiler@v5 */ // TODO(v5): Remove
   preparedCsnToEdmx(csn, service, options) {
-    preparedCsnToEdmx(csn, service, options, makeMessageFunction( csn, options, 'to.edmx' ));
+    preparedCsnToEdmx(csn, service, options, messages.makeMessageFunction( csn, options, 'to.edmx' ));
   },
   /* Deprecated, will be removed in cds-compiler@v5 */ // TODO(v5): Remove
   preparedCsnToEdm(csn, service, options) {
-    preparedCsnToEdm(csn, service, options, makeMessageFunction( csn, options, 'to.edm' ));
+    preparedCsnToEdm(csn, service, options, messages.makeMessageFunction( csn, options, 'to.edm' ));
   },
 };
 
@@ -1160,7 +1195,7 @@ function checkOutdatedOptions( options, messageFunctions ) {
     });
   }
 
-  forEachKey(options.variableReplacements || {}, (name) => {
+  objectUtils.forEachKey(options.variableReplacements || {}, (name) => {
     if (!name.startsWith('$') && name !== 'user' && name !== 'locale') {
       messageFunctions.error('api-invalid-variable-replacement', null, {
         '#': 'noDollar', option: 'variableReplacements', code: '$', name,