@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/optionProcessor.js

@@ -155,7 +155,8 @@ optionProcessor
        manageConstraints [options] <files...>   (internal) Generate ALTER TABLE statements to
                                                            add / modify referential constraints.
        inspect [options] <files...>             (internal) Inspect the given CDS files.
-       toEffectiveCsn [options] <files...>      (internal) Get an effective CSN for SEAL; requires beta mode
+       toEffectiveCsn [options] <files...>      (internal) Get an effective CSN; requires beta mode
+       forSeal [options] <files...>             (internal) Get a SEAL CSN
 
   Environment variables
     NO_COLOR                If set, compiler messages (/output) will not be colored.
@@ -546,6 +547,8 @@ optionProcessor.command('toEffectiveCsn')
   .option('-h, --help')
   .option('--resolve-simple-types <val>', { valid: ['true', 'false'] } )
   .option('--resolve-projections <val>', { valid: ['true', 'false'] } )
+  .option('--remap-odata-annotations <val>', { valid: ['true', 'false'] } )
+  .option('--keep-localized <val>', { valid: ['true', 'false'] } )
   .positionalArgument('<files...>')
   .help(`
   Usage: cdsc toEffectiveCsn [options] <files...>
@@ -560,8 +563,30 @@ optionProcessor.command('toEffectiveCsn')
                                           true: (default) resolve simple type references to their simple base type
                                           false:          do not resolve simple type references
        --resolve-projections <val>       Resolve projections:
-                                          true: (default) resolve projections to ordinary views with SELECT
+                                          true: (default) transform projections into ordinary views with SELECT
                                           false:          leave them as real projections
+       --remap-odata-annotations <val>   Remap OData annotations to ABAP annotations:
+                                          true:           remap annotations
+                                          false:(default) leave them as is
+       --keep-localized <val>            Keep '.localized' property in the CSN:
+                                          true:           property is kept
+                                          false:(default) property is deleted
+`);
+
+optionProcessor.command('forSeal')
+  .option('-h, --help')
+  .option('--remap-odata-annotations <val>', { valid: ['true', 'false'] } )
+  .positionalArgument('<files...>')
+  .help(`
+  Usage: cdsc forSeal [options] <files...>
+
+  (internal): Get the SEAL CSN model compiled from the provided CDS files.
+
+  Options
+   -h, --help                            Show this help text
+       --remap-odata-annotations <val>   Remap OData annotations to ABAP annotations:
+                                          true: (default)   remap annotations
+                                          false:            leave them as is
 `);
 
 module.exports = {

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 && !element.$enclosed) {
       // 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');
     }
   }
 
@@ -187,28 +187,46 @@ function createReferentialConstraints( csn, options ) {
    * @param {CSN.PathSegment | object} upLinkFor the name of the composition which used this association in a `$self = <comp>.<up_>` comparison
    *                                    it is used for a comment in the constraint, which is only printed out in test-mode
    */
-  function attachConstraintsToDependentKeys( dependentKeys, parentKeys, parentTable, sourceAssociation, upLinkFor = null ) {
+  function attachConstraintsToDependentKeys(
+    dependentKeys,
+    parentKeys,
+    parentTable,
+    sourceAssociation,
+    upLinkFor = null
+  ) {
     while (dependentKeys.length > 0) {
       const dependentKeyValuePair = dependentKeys.pop();
       const dependentKey = dependentKeyValuePair[1];
       // if it already has a dependent key assigned, do not overwrite it.
       // this is the case for <up_> associations in on-conditions of compositions
-      if (Object.prototype.hasOwnProperty.call(dependentKey, '$foreignKeyConstraint'))
+      const { $foreignKeyConstraint } = dependentKey;
+      // in contrast to foreign keys which stem from managed associations,
+      // a tenant foreign key column may have multiple parent keys as partners
+      const tenantForeignKey = isTenant && dependentKeyValuePair[0] === 'tenant';
+      if ($foreignKeyConstraint && (!tenantForeignKey || $foreignKeyConstraint.upLinkFor)) {
         return;
-
-      const parentKeyValuePair = parentKeys.pop();
-      const parentKeyName = parentKeyValuePair[0];
-
-      const constraint = {
-        parentKey: parentKeyName,
-        parentTable,
-        upLinkFor,
-        sourceAssociation,
-        onDelete: upLinkFor ? 'CASCADE' : 'RESTRICT',
-        validated,
-        enforced,
-      };
-      dependentKey.$foreignKeyConstraint = constraint;
+      }
+      else if ($foreignKeyConstraint && tenantForeignKey) {
+        parentKeys.pop();
+        $foreignKeyConstraint.sourceAssociation.push(sourceAssociation);
+      }
+      else {
+        const parentKeyValuePair = parentKeys.pop();
+        const parentKeyName = parentKeyValuePair[0];
+
+        const constraint = {
+          parentKey: parentKeyName,
+          parentTable,
+          upLinkFor,
+          sourceAssociation: tenantForeignKey
+            ? [ sourceAssociation ]
+            : sourceAssociation,
+          onDelete: upLinkFor ? 'CASCADE' : 'RESTRICT',
+          validated,
+          enforced,
+        };
+        dependentKey.$foreignKeyConstraint = constraint;
+      }
     }
   }
 
@@ -473,11 +491,11 @@ function createReferentialConstraints( csn, options ) {
   }
 
   /**
-   * Creates the final referential constraints from all dependent key <-> parent key pairs stemming from the same $sourceAssociation
+   * Creates the final referential constraints from all dependent key <-> parent key pairs stemming from the same sourceAssociation
    * and attaches it to the given artifact.
    *
    * Go over all elements with $foreignKeyConstraint property:
-   *  - Find all other elements in artifact with the same $sourceAssociation
+   *  - Find all other elements in artifact with the same sourceAssociation
    *  - Create constraints with the information supplied by $parentKey, $parentTable and $onDelete
    *
    * @param {CSN.Artifact} artifact
@@ -485,6 +503,23 @@ function createReferentialConstraints( csn, options ) {
    */
   function collectAndAttachReferentialConstraints( artifact, artifactName ) {
     const referentialConstraints = Object.create(null);
+
+    // tenant foreign keys may have multiple parent keys
+    // process tenant foreign key first
+    if (isTenant && artifact.elements?.tenant) {
+      const element = artifact.elements.tenant;
+      if (element.$foreignKeyConstraint) {
+        const $foreignKeyConstraint = Object.assign({}, element.$foreignKeyConstraint);
+        delete element.$foreignKeyConstraint;
+        // create a foreign key constraint for the tenant column with each association in the dependent entity
+        $foreignKeyConstraint.sourceAssociation.forEach((sourceAssociation) => {
+          const copy = Object.assign({}, $foreignKeyConstraint);
+          copy.sourceAssociation = sourceAssociation;
+          createReferentialConstraints(copy, 'tenant');
+        });
+      }
+    }
+
     for (const elementName in artifact.elements) {
       const element = artifact.elements[elementName];
       if (!element.$foreignKeyConstraint)
@@ -492,16 +527,34 @@ function createReferentialConstraints( csn, options ) {
       // copy constraint property, and delete it from the element
       const $foreignKeyConstraint = Object.assign({}, element.$foreignKeyConstraint);
       delete element.$foreignKeyConstraint;
+      createReferentialConstraints($foreignKeyConstraint, elementName);
+    }
+    if (Object.keys(referentialConstraints).length) {
+      if (!('$tableConstraints' in artifact))
+        artifact.$tableConstraints = Object.create(null);
+
+      artifact.$tableConstraints.referential = referentialConstraints;
+    }
+
+    /**
+     * Creates referential constraints for database relationships. This function constructs constraints based on foreign key information and element names,
+     * and determines deletion rules based on the existing constraints and options. It manages dependencies and names for constraints dynamically during
+     * execution.
+     *
+     * @param {object} $foreignKeyConstraint - An object encapsulating details about the foreign key constraint
+     * @param {string} elementName - The name of the dependent element or table that is linked by the foreign key.
+     */
+    function createReferentialConstraints($foreignKeyConstraint, elementName) {
       const { parentTable } = $foreignKeyConstraint;
       const parentKey = [ $foreignKeyConstraint.parentKey ];
       const dependentKey = [ elementName ];
       const onDeleteRules = new Set();
       onDeleteRules.add($foreignKeyConstraint.onDelete);
       forEach(artifact.elements, (foreignKeyName, foreignKey) => {
-        // find all other `$foreignKeyConstraint`s with same `$sourceAssociation` and same `parentTable`
+        // find all other `$foreignKeyConstraint`s with same `sourceAssociation` and same `parentTable`
         const matchingForeignKeyFound = foreignKey.$foreignKeyConstraint &&
-        foreignKey.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
-        foreignKey.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable;
+          foreignKey.$foreignKeyConstraint.sourceAssociation === $foreignKeyConstraint.sourceAssociation &&
+          foreignKey.$foreignKeyConstraint.parentTable === $foreignKeyConstraint.parentTable;
         if (!matchingForeignKeyFound)
           return;
 
@@ -536,12 +589,6 @@ function createReferentialConstraints( csn, options ) {
         enforced: $foreignKeyConstraint.enforced,
       };
     }
-    if (Object.keys(referentialConstraints).length) {
-      if (!('$tableConstraints' in artifact))
-        artifact.$tableConstraints = Object.create(null);
-
-      artifact.$tableConstraints.referential = referentialConstraints;
-    }
   }
 }
 

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/flattening.js

@@ -242,7 +242,7 @@ function flattenAllStructStepsInRefs( csn, options, messageFunctions, resolved,
         //       full path into target, uncomment this line and
         //       comment/remove setProp in expansion.js
         // setProp(parent, '$structRef', parent.ref);
-        parent.ref = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes);
+        [ parent.ref ] = flattenStructStepsInRef(ref, scopedPath, links, scope, resolvedLinkTypes);
         resolved.set(parent, { links, art, scope });
         // Explicitly set implicit alias for things that are now flattened - but only in columns
         // TODO: Can this be done elegantly during expand phase already?
@@ -543,7 +543,7 @@ function handleManagedAssociationsAndCreateForeignKeys( csn, options, messageFun
             if (clone.ref) {
               clone.ref[clone.ref.length - 1] = flatElemName;
               // Now we need to properly flatten the whole ref
-              clone.ref = flattenStructStepsInRef(clone.ref, pathToKey);
+              [ clone.ref ] = flattenStructStepsInRef(clone.ref, pathToKey);
             }
             if (!clone.as) {
               clone.as = flatElemName;

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());