@sap/cds-compiler 4.8.0 → 4.9.0

package/lib/render/DuplicateChecker.js

@@ -97,12 +97,12 @@ class DuplicateChecker {
           else
             namingMode = 'plain';
 
-          error(null, [ 'definitions', artifact.modelName ],
-                { name: collidesWith.modelName, prop: namingMode, '#': artifact.modelName.includes('.') ? 'dots' : 'std' },
-                {
-                  std: 'Artifact name can\'t be mapped to a SQL compliant identifier in naming mode $(PROP) because it conflicts with existing definition $(NAME)',
-                  dots: 'Artifact name containing dots can\'t be mapped to a SQL compliant identifier in naming mode $(PROP) because it conflicts with existing definition $(NAME)',
-                });
+          error(null, [ 'definitions', artifact.modelName ], {
+            name: collidesWith.modelName, prop: namingMode, '#': artifact.modelName.includes('.') ? 'dots' : 'std',
+          }, {
+            std: 'Artifact name can\'t be mapped to a SQL compliant identifier in naming mode $(PROP) because it conflicts with existing definition $(NAME)',
+            dots: 'Artifact name containing dots can\'t be mapped to a SQL compliant identifier in naming mode $(PROP) because it conflicts with existing definition $(NAME)',
+          });
         });
       }
       artifacts.forEach((artifact) => {

package/lib/render/manageConstraints.js

@@ -32,6 +32,7 @@ function alterConstraintsWithCsn( csn, options, messageFunctions ) {
     warning(null, null, { prop: sqlDialect || 'plain' }, 'Referential Constraints are not available for sql dialect $(PROP)');
 
   if (drop && alter)
+    // eslint-disable-next-line cds-compiler/message-no-quotes
     error(null, null, 'Option “--drop” can\'t be combined with “--alter”');
 
   // Of course, we want the database constraints

package/lib/render/toCdl.js

@@ -614,10 +614,12 @@ function csnToCdl( csn, options, msg ) {
     else if (element['#'] !== undefined) { // enum symbol reference
       result += ` = #${element['#']}`;
     }
-    else if (!isCalcElement || !isDirectAssocOrComp(element.type)) {
+    else if (!isCalcElement || !isDirectAssocOrComp(element.type) && !element.$filtered) {
       // If the element is a calculated element _and_ a direct association or
       // composition, we'd render `Association to F on (cond) = calcValue;` which
       // would alter the ON-condition.
+      // If it is a calculated element _and_ an indirect association (via type chain),
+      // we'd get a cast to an association.
       const props = renderTypeReferenceAndProps(element, env);
       if (props !== '')
         result += ` : ${props}`;

package/lib/transform/db/applyTransformations.js

@@ -344,7 +344,40 @@ function transformExpression( parent, propName, transformers, path = [] ) {
   return parent;
 }
 
+/**
+ * Merge an array of transformer-objects into a single one, set the this-value of every subfunction to "that"
+ *
+ * @param {object[]} transformers transformers
+ * @param {object} that Value for this
+ * @returns {object} Remapped transformers.
+ */
+function mergeTransformers( transformers, that ) {
+  const remapped = {};
+  for (const transformer of transformers) {
+    for (const [ n, fns ] of Object.entries(transformer)) {
+      if (!remapped[n])
+        remapped[n] = [];
+
+      if (Array.isArray(fns)) {
+        remapped[n].push((parent, name, prop, path, parentParent) => fns.forEach(
+          fn => fn.bind(that)(parent, name, prop, path, parentParent)
+        ));
+      }
+      else {
+        remapped[n].push((parent, name, prop, path, parentParent) => fns.bind(that)(parent, name, prop, path, parentParent));
+      }
+    }
+  }
+
+  for (const [ n, fns ] of Object.entries(remapped))
+    remapped[n] = (parent, name, prop, path, parentParent) => fns.forEach(fn => fn.bind(that)(parent, name, prop, path, parentParent));
+
+
+  return remapped;
+}
+
 module.exports = {
+  mergeTransformers,
   transformExpression,
   applyTransformations,
   applyTransformationsOnNonDictionary,

package/lib/transform/db/constraints.js

@@ -116,7 +116,7 @@ function createReferentialConstraints( csn, options ) {
         foreignKeyConstraintForAssociation(up_, dependent, [ 'definitions', composition.target, 'elements', upLinkName ], path[path.length - 1] );
     }
     else if (!onCondition && composition.keys.length > 0) {
-      throw new CompilerAssertion('Please debug me, an on-condition was expected here, but only found keys');
+      throw new CompilerAssertion('Debug me, an on-condition was expected here, but only found keys');
     }
   }
 

package/lib/transform/db/expansion.js

@@ -98,7 +98,9 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           */
           if (rewritten.toMany.length > 0 && !options.toOdata) {
             markAsToDummify(artifact, path[1]);
-            error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME)');
+            rewritten.toMany.forEach(({ art }) => {
+              error( null, art.$path || [ 'definitions', path[1] ], { name: `${art.$env || path[1]}:${art.ref.map(r => r.id || r)}` }, 'Unexpected .expand with to-many association $(NAME)');
+            });
           }
           else {
             parent.columns = rewritten.columns;
@@ -175,8 +177,11 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           const target = art.target ? art.target : pathStep;
           if (toDummify.indexOf(target) !== -1) {
             error( null, obj.$path, {
-              id: pathStep, elemref: obj, name,
-            }, 'Unexpected “@cds.persistence.skip” annotation on Association target $(NAME) of $(ID) in path $(ELEMREF) was skipped because of .expand in conjunction with to-many');
+              id: pathStep,
+              elemref: obj,
+              name,
+              anno: '@cds.persistence.skip',
+            }, 'Unexpected $(ANNO) annotation on Association target $(NAME) of $(ID) in path $(ELEMREF) was skipped because of .expand in conjunction with to-many');
           }
         }
 

package/lib/transform/db/groupByOrderBy.js

@@ -28,8 +28,8 @@ function replaceAssociationsInGroupByOrderBy( inputQuery, options, inspectRef, e
             // (230 c) If we keep associations as they are (hdbcds naming convention), we can't have associations in GROUP BY
             if (options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds') {
               error(null, groupByPath,
-                    { $reviewed: true },
-                    'Unexpected managed association in GROUP BY for naming mode “hdbcds”');
+                    { $reviewed: true, keyword: 'GROUP BY', value: 'hdbcds' },
+                    'Unexpected managed association in $(KEYWORD) for naming mode $(VALUE)');
               continue;
             }
             const pathPrefix = query.groupBy[i].ref.slice(0, -1);

package/lib/transform/db/temporal.js

@@ -4,7 +4,7 @@ const {
   getNormalizedQuery, hasAnnotationValue, forEachMember,
 } = require('../../model/csnUtils');
 const { implicitAs } = require('../../model/csnRefs');
-const { setProp } = require('../../base/model');
+const { setProp, isBetaEnabled } = require('../../base/model');
 const { getTransformers } = require('../transformUtils');
 
 const validToString = '@cds.valid.to';
@@ -21,9 +21,10 @@ const validFromString = '@cds.valid.from';
  * @param {object} messageFunctions
  * @param {Function} messageFunctions.info
  * @param {object} csnUtils
+ * @param {object} options
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition applying the where-condition to views.
  */
-function getViewDecorator( csn, messageFunctions, csnUtils ) {
+function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
   const { info } = messageFunctions;
   const { get$combined } = csnUtils;
   return addTemporalWhereConditionToView;
@@ -52,7 +53,9 @@ function getViewDecorator( csn, messageFunctions, csnUtils ) {
       if (from.length === 1 && to.length === 1) {
         // and both are from the same origin
         if (from[0].source === to[0].source && from[0].parent === to[0].parent) {
-          if (!hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0])) {
+          const omitWhereClause = isBetaEnabled(options, 'temporalRawProjection') &&
+            hasFalsyTemporalAnnotations(normalizedQuery.query.SELECT, artifact.elements, from[0], to[0]);
+          if (!omitWhereClause) {
             const fromPath = {
               ref: [
                 from[0].parent,

package/lib/transform/db/transformExists.js

@@ -616,10 +616,10 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       else if (typeof xpr.$env === 'number') {
         if (xpr.$scope === 'mixin')
           return '';
-        return error(null, xpr.$path, '$env with number is not handled yet - please report this error!');
+        return error(null, xpr.$path, '$env with number is not handled yet - report this error!');
       }
 
-      return error(null, xpr.$path, 'Boolean $env is not handled yet - please report this error!');
+      return error(null, xpr.$path, 'Boolean $env is not handled yet - report this error!');
     }
     else if (xpr.ref) {
       throw new ModelError('Missing $env and missing leading artifact ref - throwing to trigger recompilation!');

package/lib/transform/effective/annotations.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const { CompilerAssertion } = require('../../base/error');
+
+const directMappings = {
+  '@Common.IsDayOfCalendarMonth': replace('@Semantics.calendar.dayOfMonth'),
+  '@Common.IsDayOfCalendarYear': replace('@Semantics.calendar.dayOfYear'),
+  '@Common.IsCalendarWeek': replace('@Semantics.calendar.week'),
+  '@Common.IsCalendarMonth': replace('@Semantics.calendar.month'),
+  '@Common.IsCalendarQuarter': replace('@Semantics.calendar.quarter'),
+  '@Common.IsCalendarHalfyear': replace('@Semantics.calendar.halfyear'),
+  '@Common.IsCalendarYear': replace('@Semantics.calendar.year'),
+  '@Common.IsCalendarYearWeek': replace('@Semantics.calendar.yearWeek'),
+  '@Common.IsCalendarYearMonth': replace('@Semantics.calendar.yearMonth'),
+  '@Common.IsCalendarYearQuarter': replace('@Semantics.calendar.yearQuarter'),
+  '@Common.IsCalendarYearHalfyear': replace('@Semantics.calendar.yearHalfyear'),
+  '@Common.IsCalendarDate': replace('@Semantics.date'),
+  '@Common.IsFiscalYearVariant': replace('@Semantics.yearVariant'),
+  '@Common.IsFiscalPeriod': replace('@Semantics.period'),
+  '@Common.IsFiscalYear': replace('@Semantics.year'),
+  '@Common.IsFiscalYearPeriod': replace('@Semantics.yearPeriod'),
+  '@Common.IsFiscalQuarter': replace('@Semantics.quarter'),
+  '@Common.IsFiscalYearQuarter': replace('@Semantics.yearQuarter'),
+  '@Common.IsFiscalWeek': replace('@Semantics.week'),
+  '@Common.IsFiscalYearWeek': replace('@Semantics.yearWeek'),
+  '@Common.IsDayOfFiscalYear': replace('@Semantics.dayOfYear'),
+  '@Measures.ISOCurrency': (csn, artifact, element, oldAnno) => {
+    const { targetElement } = getAnnoRefTarget(csn, artifact, element[oldAnno]);
+    if (refPointsToThisArtifact(csn, artifact, element, oldAnno)) {
+      replace('@Semantics.amount.currencyCode')(csn, artifact, element, oldAnno);
+      if (targetElement && targetElement['@Semantics.currencyCode'] === undefined)
+        targetElement['@Semantics.currencyCode'] = true;
+    }
+  },
+  '@Measures.Unit': (csn, artifact, element, oldAnno) => {
+    const { targetElement } = getAnnoRefTarget(csn, artifact, element[oldAnno]);
+    if (refPointsToThisArtifact(csn, artifact, element, oldAnno)) {
+      replace('@Semantics.quantity.unitOfMeasure')(csn, artifact, element, oldAnno);
+      if (targetElement && targetElement['@Semantics.unitOfMeasure'] === undefined)
+        targetElement['@Semantics.unitOfMeasure'] = true;
+    }
+  },
+  '@UI.IsImageURL': replace('@Semantics.imageUrl'),
+  '@Common.ValueList.CollectionPath': (csn, artifact, element) => {
+    if (!element.target && element['@Consumption.valueHelpDefinition'] === undefined) {
+      if (element['@Common.ValueList.Parameters'] && Array.isArray(element['@Common.ValueList.Parameters'])) {
+        const InOutParameters = element['@Common.ValueList.Parameters'].filter(param => param.$Type === 'Common.ValueListParameterInOut');
+
+        if (InOutParameters.length === 1) {
+          element['@Consumption.valueHelpDefinition'] = [ {
+            name: element['@Common.ValueList.CollectionPath'],
+          } ];
+
+          delete element['@Common.ValueList.CollectionPath'];
+          delete element['@Common.ValueList.Label'];
+
+          element['@Consumption.valueHelpDefinition'][0].element = element['@Common.ValueList.Parameters'][0].ValueListProperty;
+          delete element['@Common.ValueList.Parameters'];
+        }
+      }
+    }
+  },
+  '@Common.TextFor': replace('@Semantics.text', true),
+  '@Common.IsLanguageIdentifier': replaceIf('@Semantics.language', true, (csn, artifact, element, anno) => !!element[anno]),
+  // We need to set two different annos here, depending on the value -> need a custom replacer
+  '@Common.Text': (csn, artifact, element, oldAnno) => {
+    const { targetArtifact, targetElement } = getAnnoRefTarget(csn, artifact, element[oldAnno]);
+    if (targetArtifact === artifact && !element['@ObjectModel.text.element'] && !targetElement['@Semantics.text']) {
+      element['@ObjectModel.text.element'] = element[oldAnno];
+      if (targetElement['@Semantics.text'] === undefined)
+        targetElement['@Semantics.text'] = true;
+      delete element['@Common.Text'];
+    }
+    else if (targetArtifact && targetElement && !element['@ObjectModel.text.association'] && !targetElement['@Semantics.text']) {
+      element['@ObjectModel.text.association'] = element[oldAnno];
+      if (targetElement['@Semantics.text'] === undefined)
+        targetElement['@Semantics.text'] = true;
+      delete element['@Common.Text'];
+    }
+  },
+};
+
+/**
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Artifact} artifact
+ * @param {CSN.Element} element
+ * @param {object} anno
+ * @returns {boolean}
+ */
+function refPointsToThisArtifact( csn, artifact, element, anno ) {
+  const { targetArtifact } = getAnnoRefTarget(csn, artifact, element[anno]);
+  return targetArtifact && targetArtifact === artifact;
+}
+
+/**
+ * Walk the possible annotation ref and return the artifact and element it points to
+ *
+ * @param {CSN.Model} csn
+ * @param {CSN.Artifact} startArtifact
+ * @param {object} annoValue
+ * @returns {object}
+ */
+function getAnnoRefTarget( csn, startArtifact, annoValue ) {
+  if (!annoValue || !annoValue['='])
+    return { targetArtifact: undefined, targetElement: undefined };
+
+  const steps = annoValue['='].split('.');
+  let base = startArtifact;
+  let element;
+  for (const step of steps) {
+    if (!base.elements)
+      return { targetArtifact: undefined, targetElement: undefined };
+    element = base.elements[step];
+    if (!element)
+      return { targetArtifact: undefined, targetElement: undefined };
+    if (element.target)
+      base = csn.definitions[element.target];
+  }
+
+  return { targetArtifact: base, targetElement: element };
+}
+
+/**
+ * Get the function to replace oldAnno with newAnno on carrier.
+ *
+ * - If available, use "replacement" as value.
+ * - Only do replacement if "condition" returns true
+ * - Possibly set additional annotations via "additional"
+ * @param {string} newAnno
+ * @param {any} replacement
+ * @param {Function} [condition]
+ * @param {Function} [additional]
+ * @returns {Function}
+ */
+function replace( newAnno, replacement, condition = () => true, additional = () => true ) {
+  return function replaceAnnotationPrefix(csn, artifact, carrier, oldAnno) {
+    if (carrier[newAnno] === undefined && condition(csn, artifact, carrier, oldAnno, newAnno)) {
+      carrier[newAnno] = replacement || carrier[oldAnno];
+      additional(carrier, oldAnno, newAnno);
+      delete carrier[oldAnno];
+    }
+  };
+}
+
+/**
+ * Get the function to replace oldAnno with newAnno on carrier.
+ *
+ * - If available, use "replacement" as value.
+ * - Only do replacement if "condition" returns true
+ *
+ * @param {string} newAnno
+ * @param {any} replacement
+ * @param {Function} condition
+ * @returns {Function}
+ */
+function replaceIf( newAnno, replacement, condition ) {
+  return replace( newAnno, replacement, condition );
+}
+
+/**
+ *
+ * @param {CSN.Model} csn
+ * @returns {object} Transfomer object for applyTransformations
+ */
+function remapODataAnnotations( csn ) {
+  /**
+   *
+   * @param {CSN.Artifact} artifact
+   * @param {CSN.Element} element Element to process
+   */
+  function remapAnnotationsOnElement( artifact, element ) {
+    if (element.elements && !element.$ignore) // We expect to only be called on flattened CSN - error if we encounter .elements!
+      throw new CompilerAssertion(`Expected a flat model. Found element with subelements: ${JSON.stringify(element)}`);
+    for (const prop in element) {
+      if (directMappings[prop])
+        directMappings[prop](csn, artifact, element, prop);
+    }
+  }
+
+  return {
+    elements: (parent, prop, elements, path) => {
+      const artifact = csn.definitions[path[1]];
+      if (artifact?.kind === 'entity') {
+        for (const elementName in elements)
+          remapAnnotationsOnElement(artifact, elements[elementName]);
+      }
+    },
+  };
+}
+
+module.exports = {
+  remapODataAnnotations,
+};

package/lib/transform/effective/main.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const { isBetaEnabled } = require('../../base/model');
-const { CompilerAssertion } = require('../../base/error');
-const { getUtils, isAspect } = require('../../model/csnUtils');
+const {
+  getUtils, isAspect, mergeTransformers, applyTransformations,
+} = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const flattening = require('../db/flattening');
 const types = require('./types');
@@ -14,6 +14,7 @@ const associations = require('./associations');
 const generateDrafts = require('../draft/db');
 const handleExists = require('../db/transformExists');
 const misc = require('./misc');
+const annotations = require('./annotations');
 const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities } = require('../db/rewriteCalculatedElements');
 const { cloneFullCsn } = require('../../model/cloneCsn');
 
@@ -30,9 +31,6 @@ const { cloneFullCsn } = require('../../model/cloneCsn');
  * @returns {CSN.Model}
  */
 function effectiveCsn( model, options, messageFunctions ) {
-  if (!isBetaEnabled(options, 'effectiveCsn'))
-    throw new CompilerAssertion('effective CSN is only supported with beta flag `effectiveCsn`!');
-
   const csn = cloneFullCsn(model, options);
   delete csn.vocabularies; // must not be set for effective CSN
   messageFunctions.setModel(csn);
@@ -80,8 +78,8 @@ function effectiveCsn( model, options, messageFunctions ) {
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
   generateDrafts(csn, options, '_', messageFunctions);
-  misc.attachPersistenceName(csn, options, csnUtils);
-  misc.removeDefinitionsAndProperties(csn, options);
+  const transformers = mergeTransformers([ misc.attachPersistenceName(csn, options, csnUtils), options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
+  applyTransformations(csn, transformers, [], { skipIgnore: false });
 
   if (!options.resolveProjections)
     redoProjections.forEach(fn => fn());

package/lib/transform/effective/misc.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  forEachDefinition, forEachMemberRecursively, getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
+  getArtifactDatabaseNameOf, getElementDatabaseNameOf,
 } = require('../../model/csnUtils');
 /**
  * Attach @cds.persistence.name to all artifacts and "things".
@@ -9,17 +9,34 @@ const {
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
  * @param {object} csnUtils
+ * @returns {object}
  */
 function attachPersistenceName( csn, options, csnUtils ) {
   const { addStringAnnotationTo } = csnUtils;
 
-  forEachDefinition(csn, (artifact, artifactName) => {
-    if (artifact.kind === 'entity') {
-      addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
-
-      forEachMemberRecursively(artifact, (member, memberName) => addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member), [ 'definitions', artifactName ]);
+  /**
+   *
+   * @param {object} parent
+   * @param {string} prop
+   * @param {object} dict
+   * @param {CSN.Path} path
+   */
+  function addToEachMember( parent, prop, dict, path ) {
+    const artifact = csn.definitions[path[1]];
+    if (artifact?.kind === 'entity') {
+      for (const memberName in dict)
+        addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), dict[memberName]);
     }
-  });
+  }
+
+  return {
+    kind: (parent, prop, kind, path) => {
+      if (kind === 'entity')
+        addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(path[1], options.sqlMapping, csn, options.sqlDialect), parent);
+    },
+    elements: addToEachMember,
+    params: addToEachMember,
+  };
 }
 
 /**
@@ -42,10 +59,11 @@ function killProp( parent, prop ) {
  * - localized
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
+ * @returns {object}
  * @todo Callback-like architecture and merge with persistence name?
  */
 function _removeDefinitionsAndProperties( csn, options ) {
-  const killers = {
+  const transformers = {
     $ignore: (a, b, c, path, parentParent) => {
       const tail = path[path.length - 1];
       delete parentParent[tail];
@@ -74,13 +92,16 @@ function _removeDefinitionsAndProperties( csn, options ) {
     // Set when we remove .key from temporal things, used in localized.js
     $key: killProp,
     includes: killProp,
-    localized: killProp,
     enum: killProp,
     keys: killProp,
     excluding: killProp, // * is resolved, so has no effect anymore
+    targetAspect: killProp,
   };
 
-  applyTransformations(csn, killers, [], { skipIgnore: false });
+  if (!options.keepLocalized)
+    transformers.localized = killProp;
+
+  return transformers;
 }
 
 

package/lib/transform/forOdata.js

@@ -73,7 +73,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   timetrace.start('OData transformation');
 
   // copy the model as we don't want to change the input model
-  let csn = cloneFullCsn(inputModel, options);
+  const csn = cloneFullCsn(inputModel, options);
   messageFunctions.setModel(csn);
 
   const { message, error, warning, info, throwWithAnyError } = messageFunctions;
@@ -184,14 +184,19 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
   if (!structuredOData) {
-    expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
+    expansion.expandStructureReferences(csn, options, '_',
+      { error, info, throwWithAnyError }, csnUtils,
+      { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
 
     const { inspectRef, effectiveType } = csnRefs(csn);
-    const { adaptRefs, transformer: refFlattener } = flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
+    const { adaptRefs, transformer: refFlattener } =
+      flattening.getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, '_');
 
-    flattening.allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternalServiceMember, error, csnUtils, options);
-    flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs, inspectRef, effectiveType, csnUtils, error, options,
+    flattening.allInOneFlattening(csn, refFlattener, adaptRefs,
+        inspectRef, isExternalServiceMember, error, csnUtils, options);
+    flattening.flattenAllStructStepsInRefs(csn, refFlattener, adaptRefs,
+        inspectRef, effectiveType, csnUtils, error, options,
       { //skip: ['action', 'aspect', 'event', 'function', 'type'],
         skipArtifact: isExternalServiceMember,
       });
@@ -208,12 +213,22 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
           def[an] = av; 
         })
       }
+      if(def.actions) {
+        Object.values(def.actions).forEach((action) => {
+          if(action.$flatAnnotations) {
+            Object.entries(action.$flatAnnotations).forEach(([an, av]) => {
+              action[an] = av;
+            });
+          }
+        });
+      }
     });
   }
 
   // TODO: add the generated foreign keys to the columns when we are in a view
   // see db/views.js::addForeignKeysToColumns
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_', !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, messageFunctions, '_',
+    !structuredOData, csnUtils,{ skipArtifact: isExternalServiceMember });
 
   // Allow using managed associations as steps in on-conditions to access their fks
   // To be done after handleManagedAssociationsAndCreateForeignKeys,
@@ -252,7 +267,8 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
     // Annotate artifacts with their DB names if requested.
     // Skip artifacts that have no DB equivalent anyway
     if (options.sqlMapping && !(def.kind in skipPersNameKinds))
-      def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana'); // hana to allow naming mode "hdbcds"
+       // hana to allow naming mode "hdbcds"
+      def['@cds.persistence.name'] = getArtifactDatabaseNameOf(defName, options.sqlMapping, csn, 'hana');
 
     forEachMemberRecursively(def, (member, memberName, propertyName) => {
       // Annotate elements, foreign keys, parameters, etc. with their DB names if requested

package/lib/transform/forRelationalDB.js

@@ -183,7 +183,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
   forEachDefinition(csn, [
     // (001) Add a temporal where condition to views where applicable before assoc2join
     //       assoc2join eventually rewrites the table aliases
-    temporal.getViewDecorator(csn, messageFunctions, csnUtils),
+    temporal.getViewDecorator(csn, messageFunctions, csnUtils, options),
     // check unique constraints - further processing is done in rewriteUniqueConstraints
     assertUnique.prepare(csn, options, messageFunctions)
   ]);

package/lib/transform/localized.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { makeMessageFunction } = require('../base/messages');
-const { setProp, isDeprecatedEnabled} = require('../base/model');
+const { setProp, isDeprecatedEnabled, isBetaEnabled} = require('../base/model');
 const { forEachKey } = require('../utils/objectUtils');
 const { cleanSymbols } = require('../base/cleanSymbols.js');
 const {
@@ -747,7 +747,7 @@ function copyLocation(target, source) {
 }
 
 /**
- * Copy @cds.persistence.exists/skip annotations from the source to
+ * Copy @cds.persistence.skip annotations from the source to
  * the target.  Ignores existing annotations on the _target_.
  *
  * @param {CSN.Artifact} target
@@ -755,14 +755,15 @@ function copyLocation(target, source) {
  * @param {CSN.Options} options
  */
 function copyPersistenceAnnotations(target, source, options) {
-  const doNotCopyExists = isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+  const copyExists = !isBetaEnabled(options, 'v5preview') &&
+    !isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
   forEachKey(source, anno => {
     // Note:
-    //   Because `.exists` is copied to the convenience view, it could
+    //   v3/v4: Because `.exists` is copied to the convenience view, it could
     //   lead to some localization views referencing non-existing ones.
     //   But that is the contract: User says that it already exists!
-    //   In v2, `.exists` was never copied.
-    if (anno === annoPersistenceSkip || (!doNotCopyExists && anno === '@cds.persistence.exists'))
+    //   v2/>=v5, `.exists` is never copied.
+    if (anno === annoPersistenceSkip || (copyExists && anno === '@cds.persistence.exists'))
       target[anno] = source[anno];
   });
 }