@sap/cds-compiler 5.3.0 → 5.4.0

package/lib/parsers/Lexer.js

@@ -177,9 +177,9 @@ function string( text, lexer, parser, beg ) {
   }
   else {                        // try with previous date/time/timestamp/x
     prefix = parser.tokens[parser.tokens.length - 1];
-    if (prefix.location.endLine !== lexer.location.line ||
+    if (prefix && (prefix.location.endLine !== lexer.location.line ||
         prefix.location.endCol !== lexer.location.col ||
-        !quotedLiterals.includes( prefix.keyword ))
+        !quotedLiterals.includes( prefix.keyword )))
       prefix = null;
     while (re.test( lexer.input ) && lexer.input[re.lastIndex] === "'")
       esc = ++re.lastIndex;
@@ -192,7 +192,7 @@ function string( text, lexer, parser, beg ) {
     const before = (lastIndex) ? 'string' : 'multi';
     // eslint-disable-next-line cds-compiler/message-texts
     parser.error( 'syntax-missing-token-end', lexer.location,
-                  { '#': before, newCode: text }, {
+                  { '#': before, newcode: text }, {
                     string: 'The string literal must end with $(NEWCODE) before the end of line',
                     multi: 'The multi-line string literal must end with $(NEWCODE)',
                   } );

package/lib/parsers/identifiers.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/** RegEx identifying undelimited identifiers in CDL */
+const undelimitedIdentifierRegex = /^[$_\p{ID_Start}][$\p{ID_Continue}\u200C\u200D]*$/u;
+
+/**
+ * Functions without parentheses in CDL (common standard SQL-92 functions)
+ * (do not add more - make it part of the SQL renderer to remove parentheses for
+ * other funny SQL functions like CURRENT_UTCTIMESTAMP).
+ */
+const functionsWithoutParentheses = [
+  'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
+  'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
+];
+
+// CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
+// Keep in sync with reserved keywords in language.g4
+const cdlKeywords = [
+  'ALL',
+  'ANY',
+  'AS',
+  'BY',
+  'CASE',
+  'CAST',
+  'DISTINCT',
+  'EXISTS',
+  'EXTRACT',
+  'FALSE', // boolean
+  'FROM',
+  'IN',
+  'KEY',
+  'NEW',
+  'NOT',
+  'NULL',
+  'OF',
+  'ON',
+  'SELECT',
+  'SOME',
+  'TRIM',
+  'TRUE', // boolean
+  'WHEN',
+  'WHERE',
+  'WITH',
+];
+
+function isSimpleCdlIdentifier( id ) {
+  if (undelimitedIdentifierRegex.test(id))
+    return true;
+  const upperId = id.toUpperCase();
+  return !cdlKeywords.includes(upperId) &&
+    !functionsWithoutParentheses.includes(upperId);
+}
+
+module.exports = {
+  undelimitedIdentifierRegex,
+  cdlKeywords,
+  functionsWithoutParentheses,
+  isSimpleCdlIdentifier,
+};

package/lib/render/toCdl.js

@@ -18,8 +18,8 @@ const {
 const { isBuiltinType } = require('../base/builtins');
 const { cloneFullCsn } = require('../model/cloneCsn');
 const { getKeysDict } = require('../model/csnRefs');
+const { undelimitedIdentifierRegex } = require('../parsers/identifiers');
 
-const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
 const specialFunctionKeywords = Object.create(null);
 
 /**
@@ -2104,7 +2104,7 @@ function csnToCdl( csn, options, msg ) {
     return path.split('.').map((step, index) => {
       if (index === 0)
         return quoteNonIdentifierOrKeyword(step, env);
-      else if (!identifierRegex.test(step))
+      else if (!undelimitedIdentifierRegex.test(step))
         return delimitedId(step, env);
       return step;
     }).join('.');
@@ -2142,7 +2142,7 @@ function csnToCdl( csn, options, msg ) {
    * @return {string}
    */
   function quoteNonIdentifier( id, env ) {
-    if (!identifierRegex.test(id))
+    if (!undelimitedIdentifierRegex.test(id))
       return delimitedId(id, env);
     return id;
   }
@@ -2262,7 +2262,7 @@ function removeTrailingNewline( str ) {
  * @return {boolean}
  */
 function requiresQuotingForCdl( id, additionalKeywords ) {
-  return !identifierRegex.test(id) ||
+  return !undelimitedIdentifierRegex.test(id) ||
     keywords.cdl.includes(id.toUpperCase()) ||
     keywords.cdl_functions.includes(id.toUpperCase()) ||
     additionalKeywords.includes(id.toUpperCase());
@@ -2523,7 +2523,7 @@ function apiSmartId( id, insideFunction = null ) {
  */
 function apiSmartFunctionId( funcName ) {
   const funcId = funcName.toUpperCase();
-  const requiresQuoting = !identifierRegex.test(funcName) ||
+  const requiresQuoting = !undelimitedIdentifierRegex.test(funcName) ||
     (keywords.cdl.includes(funcId) && !specialFunctions[funcId]);
   if (requiresQuoting)
     return apiDelimitedId(funcName);

package/lib/render/utils/common.js

@@ -263,6 +263,7 @@ const cdsToSqlTypes = {
     'cds.hana.ST_POINT': 'CHAR', // CHAR is implicit fallback used in toSql - make it explicit here
     'cds.hana.ST_GEOMETRY': 'CHAR', // CHAR is implicit fallback used in toSql - make it explicit here
     'cds.Vector': 'NVARCHAR', // Not supported; see #11725
+    'cds.Map': 'NCLOB', // Not supported; see #13149
   },
   hana: {
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
@@ -270,6 +271,7 @@ const cdsToSqlTypes = {
     'cds.hana.ST_POINT': 'ST_POINT',
     'cds.hana.ST_GEOMETRY': 'ST_GEOMETRY',
     'cds.Vector': 'REAL_VECTOR', // FIXME: test me
+    'cds.Map': 'NCLOB',
   },
   sqlite: {
     'cds.Date': 'DATE_TEXT',
@@ -280,6 +282,7 @@ const cdsToSqlTypes = {
     'cds.hana.BINARY': 'BINARY_BLOB',
     'cds.hana.SMALLDECIMAL': 'SMALLDECIMAL',
     'cds.Vector': 'BINARY_BLOB', // Not supported; see #11725
+    'cds.Map': 'JSON',
   },
   plain: {
     'cds.Binary': 'VARBINARY',
@@ -292,6 +295,7 @@ const cdsToSqlTypes = {
     'cds.DecimalFloat': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
     'cds.DateTime': 'TIMESTAMP(0)',
     'cds.Timestamp': 'TIMESTAMP(7)',
+    'cds.Map': 'JSON',
   },
   postgres: {
     // See <https://www.postgresql.org/docs/current/datatype.html>
@@ -302,6 +306,7 @@ const cdsToSqlTypes = {
     'cds.Double': 'FLOAT8',
     'cds.UInt8': 'INTEGER', // Not equivalent
     'cds.Vector': 'VARCHAR', // Not supported; see #11725
+    'cds.Map': 'JSONB',
   },
 };
 

package/lib/render/utils/delta.js

@@ -179,10 +179,8 @@ class DeltaRendererPostgres extends DeltaRenderer {
    */
   alterColumns(artifactName, columnName, delta, definitionsStr, eltName, env) {
     const sqls = [];
-    if (delta.new.notNull === true || delta.new.key === true)
-      definitionsStr = definitionsStr.replace(' NOT NULL', ''); // TODO: Is this robust enough?
-    else if (delta.new.notNull === false || delta.new.$notNull === false)
-      definitionsStr = definitionsStr.replace(' NULL', ''); // TODO: Is this robust enough?
+
+    definitionsStr = this.#removeNullabilityFromElementString(delta, definitionsStr);
 
     if (delta.old.default && !delta.old.value) // Drop old default if any exists
       sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER COLUMN ${columnName} DROP DEFAULT;`);
@@ -190,7 +188,7 @@ class DeltaRendererPostgres extends DeltaRenderer {
     if (delta.new.default && !delta.new.value ) { // Alter column with default
       const df = delta.new.default;
       delete delta.new.default;
-      const eltStrNoDefault = this.scopedFunctions.renderElement(eltName, delta.new, null, null, env);
+      const eltStrNoDefault = this.#removeNullabilityFromElementString(delta, this.scopedFunctions.renderElement(eltName, delta.new, null, null, env));
       delta.new.default = df;
       sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER ${eltStrNoDefault};`);
       sqls.push(`ALTER TABLE ${this.scopedFunctions.renderArtifactName(artifactName)} ALTER COLUMN ${columnName} SET DEFAULT ${this.scopedFunctions.renderExpr(delta.new.default, env.withSubPath('default'))};`);
@@ -206,6 +204,26 @@ class DeltaRendererPostgres extends DeltaRenderer {
 
     return sqls;
   }
+
+  /**
+   * Postgres does not support changing a column AND doing [NOT] NULL things in one statement.
+   * So we filter it from the SQL String and render the appropriate SET/DROP for the NOT NULL separately.
+   *
+   * @param {object} delta
+   * @param {string} string
+   * @returns {string}
+   */
+  #removeNullabilityFromElementString(delta, string) {
+    if (delta.new.notNull === true || delta.new.key === true)
+      string = string.replace(' NOT NULL', ''); // TODO: Is this robust enough?
+    else if (delta.new.notNull === false || delta.new.$notNull === false)
+      string = string.replace(' NULL', ''); // TODO: Is this robust enough?
+    else if (delta.new.notNull === delta.old.notNull)
+      string = string.replace( delta.new.notNull ? ' NOT NULL' : ' NULL', ''); // TODO: Is this robust enough?
+
+
+    return string;
+  }
 }
 
 class DeltaRendererH2 extends DeltaRenderer {

package/lib/transform/db/expansion.js

@@ -596,7 +596,8 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     while (stack.length > 0) {
       const [ current, currentRef, currentAlias ] = stack.pop();
       if (csnUtils.isStructured(current)) {
-        const elements = Object.entries(current.elements || csnUtils.effectiveType(current).elements).reverse();
+        // `cds.Map` may also be used
+        const elements = Object.entries(current.elements || csnUtils.effectiveType(current).elements || {}).reverse();
         for (const [ name, elem ] of elements)
           stack.push([ elem, currentRef.concat(name), currentAlias.concat(name) ]);
       }

package/lib/transform/db/rewriteCalculatedElements.js

@@ -660,11 +660,12 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
 
 /**
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  */
-function processCalculatedElementsInEntities( csn ) {
+function processCalculatedElementsInEntities( csn, options ) {
   forEachDefinition(csn, (artifact, definitionName) => {
     if (artifact.kind === 'entity' && !(artifact.query || artifact.projection))
-      removeDummyValueInEntity(artifact, [ 'definitions', definitionName ]);
+      removeDummyValueInEntity(artifact, [ 'definitions', definitionName ], options);
   });
 }
 
@@ -674,14 +675,19 @@ function processCalculatedElementsInEntities( csn ) {
  *
  * @param {CSN.Artifact} artifact
  * @param {CSN.Path} path
+ * @param {CSN.Options} options
  * @todo calculated elements that "live" on the database?
  * @todo error when artifact is empty afterwards? Probably better as a CSN check!
  */
-function removeDummyValueInEntity( artifact, path ) {
+function removeDummyValueInEntity( artifact, path, options ) {
   applyTransformationsOnDictionary(artifact.elements, {
     value: (parent, prop, value, p, elements) => {
-      if (!value.stored)
-        delete elements[p[p.length - 1]];
+      if (!value.stored) {
+        if (options.transformation === 'effective' && parent.on)
+          delete parent.value;
+        else
+          delete elements[p.at(-1)];
+      }
     },
   }, {}, path.concat( 'elements' ));
 }

package/lib/transform/db/transformExists.js

@@ -409,6 +409,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
   }
 
   /**
+   *
    * Translate an `EXISTS <unmanaged assoc>` into a part of a WHERE condition.
    *
    * A valid $self-backlink is handled in translateDollarSelfToWhere.
@@ -428,64 +429,89 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
    */
   function translateUnmanagedAssocToWhere( root, target, isPrefixedWithTableAlias, base, current ) {
     const whereExtension = [];
-    for (let j = 0; j < root.on.length; j++) {
-      const part = root.on[j];
+
+    for (let j = 0; j < root.on.length; j++)
+      j = processExpressionPart(root.on, root.$path.concat('on'), j, whereExtension);
+
+    return whereExtension;
+
+    /**
+     * Process the given expression and apply the steps described above.
+     *
+     * @param {Array} expression Expression we are processing
+     * @param {CSN.Path} path Path to the expression
+     * @param {number} expressionIndex Index in the current expression, imporant for paths and stuff
+     * @param {Array} collector Array to collect the processed expressionparts into
+     * @returns {number} How far along expression we have processed - so the main loop can jump ahead
+     */
+    function processExpressionPart(expression, path, expressionIndex, collector) {
+      const part = expression[expressionIndex];
+
+      if (part?.xpr) {
+        const xpr = { xpr: [] };
+        for (let i = 0; i < part.xpr.length; i++)
+          i = processExpressionPart(part.xpr, path.concat(expressionIndex, 'xpr'), i, xpr.xpr);
+
+        collector.push(xpr);
+        return expressionIndex;
+      }
 
       // we can only resolve stuff on refs - skip literals like =
       // but also keep along stuff like null and undefined, so compiler
       // can have a chance to complain/ we can fail later nicely maybe
       if (!(part && part.ref)) {
-        whereExtension.push(part);
-        continue;
+        collector.push(part);
+        return expressionIndex;
       }
 
       // root.$path should be safe - we can only reference things in exists that exist when we enrich
       // so all of them should have a $path.
-      const { art, links } = inspectRef(root.$path.concat([ 'on', j ]));
+      const { art, links } = inspectRef(path.concat(expressionIndex));
       // Dollar Self Backlink
-      if (isValidDollarSelf(root.on[j], root.$path.concat([ 'on', j ]), root.on[j + 1], root.on[j + 2], root.$path.concat([ 'on', j + 2 ]))) {
-        if (root.on[j].ref[0] === '$self' && root.on[j].ref.length === 1)
-          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j + 2], root.$path.concat([ 'on', j + 2 ])));
+      if (isValidDollarSelf(expression[expressionIndex], path.concat(expressionIndex), expression[expressionIndex + 1], expression[expressionIndex + 2], path.concat(expressionIndex + 2 ))) {
+        if (expression[expressionIndex].ref[0] === '$self' && expression[expressionIndex].ref.length === 1)
+          collector.push(...translateDollarSelfToWhere(base, target, expression[expressionIndex + 2], path.concat(expressionIndex + 2 )));
         else
-          whereExtension.push(...translateDollarSelfToWhere(base, target, root.on[j], root.$path.concat([ 'on', j ])));
+          collector.push(...translateDollarSelfToWhere(base, target, expression[expressionIndex], path.concat(expressionIndex)));
 
-        j += 2;
+        return expressionIndex + 2;
       }
       else if (links && links[0].art === root) { // target side
-        whereExtension.push({ ref: [ target, ...part.ref.slice(1) ] });
+        collector.push({ ref: [ target, ...part.ref.slice(1) ] });
       }
       else if (part.$scope === '$self') { // source side - "absolute" scope
         const column = part._art._column;
         if (column && column.as) { // Replace with the "original" expression (the .ref, .xpr etc.)
-          whereExtension.push(translateToSourceSide(column));
+          collector.push(translateToSourceSide(column));
         }
         else {
-          whereExtension.push(assignAndDeleteAs({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
+          collector.push(assignAndDeleteAsAndKey({}, part, { ref: [ base, ...part.ref.slice(1) ] }));
         }
       }
       else if (art) { // source side - with local scope
         if (isPrefixedWithTableAlias || part.$scope === 'alias')
-          whereExtension.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
+          collector.push({ ref: [ ...current.ref.slice(0, -1), ...part.ref ] });
         else
-          whereExtension.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
+          collector.push({ ref: [ base, ...current.ref.slice(0, -1), ...part.ref ] });
       }
       else { // operator - or any other leftover
-        whereExtension.push(part);
+        collector.push(part);
       }
-    }
 
-    return whereExtension;
+      return expressionIndex;
+    }
 
 
     /**
-     * Run Object.assign on all of the passed in parameters and delete a .as at the end
+     * Run Object.assign on all of the passed in parameters and delete a .as and .key at the end
      *
      * @param {...any} args
-     * @returns {object} The merged args without an .as property
+     * @returns {object} The merged args without an .as and .key property
      */
-    function assignAndDeleteAs( ...args ) {
+    function assignAndDeleteAsAndKey( ...args ) {
       const obj = Object.assign.apply(null, args);
       delete obj.as;
+      delete obj.key;
       return obj;
     }
     /**
@@ -503,19 +529,19 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           const column = obj._art._column;
           if (column && column.as)
             return translateToSourceSide(column);
-          return assignAndDeleteAs({}, obj, { ref: [ base, ...obj.ref.slice(1) ] });
+          return assignAndDeleteAsAndKey({}, obj, { ref: [ base, ...obj.ref.slice(1) ] });
         }
         else if (typeof obj.$env === 'string') {
-          return assignAndDeleteAs({}, obj, { ref: [ obj.$env, ...obj.ref ] });
+          return assignAndDeleteAsAndKey({}, obj, { ref: [ obj.$env, ...obj.ref ] });
         }
 
-        return assignAndDeleteAs({}, obj, { ref: [ ...obj.ref ] });
+        return assignAndDeleteAsAndKey({}, obj, { ref: [ ...obj.ref ] });
       }
       else if (obj.xpr) { // we need to drill further down into .xpr
-        return assignAndDeleteAs({}, obj, { xpr: obj.xpr.map(translateToSourceSide) });
+        return assignAndDeleteAsAndKey({}, obj, { xpr: obj.xpr.map(translateToSourceSide) });
       }
       else if (obj.args) {
-        return assignAndDeleteAs({}, obj, { args: obj.args.map(translateToSourceSide) });
+        return assignAndDeleteAsAndKey({}, obj, { args: obj.args.map(translateToSourceSide) });
       }
 
       return obj;

package/lib/transform/effective/annotations.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { CompilerAssertion } = require('../../base/error');
+const { forEach } = require('../../utils/objectUtils');
 
 const directMappings = {
   '@Common.IsDayOfCalendarMonth': replace('@Semantics.calendar.dayOfMonth'),
@@ -190,6 +191,152 @@ function remapODataAnnotations( csn ) {
   };
 }
 
+/**
+ * Do the .texts anno magic if we can be reasonably sure that we are actually dealing with a .texts entity.
+ *
+ * @param {CSN.Model} csn
+ * @param {string} artifactName
+ * @param {CSN.Artifact} artifact
+ */
+function sealAnnoMagicForTexts(csn, artifactName, artifact) {
+  if (artifactName.endsWith('.texts') && artifact.elements?.locale) {
+    const firstNonKey = getFirstNonKeyElement(artifact);
+    if (firstNonKey && firstNonKey.type === 'cds.String') {
+      artifact['@ObjectModel.supportedCapabilities'] ??= [];
+      if (!artifact['@ObjectModel.supportedCapabilities'].find(part => part['#'] === 'LANGUAGE_DEPENDENT_TEXT'))
+        artifact['@ObjectModel.supportedCapabilities'].push({ '#': 'LANGUAGE_DEPENDENT_TEXT' });
+      if (artifact.elements.locale['@Semantics.language'] === undefined)
+        artifact.elements.locale['@Semantics.language'] = true;
+      if (firstNonKey['@Semantics.text'] === undefined)
+        firstNonKey['@Semantics.text'] = true;
+    }
+  }
+}
+
+/**
+ *
+ * @param {CSN.Artifact} artifact
+ * @returns {CSN.Element|null}
+ */
+function getFirstNonKeyElement(artifact) {
+  for (const elementName in artifact.elements) {
+    if (Object.prototype.hasOwnProperty.call(artifact.elements, elementName)) {
+      if (!artifact.elements[elementName].key)
+        return artifact.elements[elementName];
+    }
+  }
+
+  return null;
+}
+
+/**
+ *
+ * @param {CSN.Model} csn
+ * @returns {object} Transfomer object for applyTransformations
+ */
+function sealAnnoMagic(csn) {
+  return {
+    '@ObjectModel.supportedCapabilities': (parent, prop, anno, path) => {
+      // Filter only for values we care about
+      const filteredAnno = anno.filter(value => value['#'] === 'ANALYTICAL_DIMENSION' || value['#'] === 'LANGUAGE_DEPENDENT_TEXT' || value['#'] === 'ANALYTICAL_PROVIDER');
+      if (filteredAnno.filter(value => value['#'] === 'ANALYTICAL_PROVIDER').length > 0 && parent.kind === 'entity' && isPartOfINAService(csn, path[1]) && parent.elements) {
+        forEach(parent.elements, (elementName, element) => {
+          if (element.target && csn.definitions[element.target]['@ObjectModel.supportedCapabilities']?.filter(value => value['#'] === 'ANALYTICAL_DIMENSION').length > 0) {
+            const tuples = getOnConditionAsComparisonTuples(element.on, elementName);
+            const targetEntity = csn.definitions[element.target];
+            if (element.on.length === 3 && tuples.length > 0 ) {
+              tuples.forEach(({ source }) => {
+                const sourceElement = parent.elements[source.ref[0]];
+                if (!sourceElement.target && sourceElement['@ObjectModel.foreignKey.association'] === undefined)
+                  sourceElement['@ObjectModel.foreignKey.association'] = { '=': elementName };
+              });
+            }
+
+            else if (element.on.length > 3 && tuples.length > 0 && targetEntity['@ObjectModel.representativeKey']) {
+              tuples.forEach(({ source, target }) => {
+                if (target.ref[1] === targetEntity['@ObjectModel.representativeKey']['=']) {
+                  const sourceElement = parent.elements[source.ref[0]];
+                  if (!sourceElement.target && sourceElement['@ObjectModel.foreignKey.association'] === undefined)
+                    sourceElement['@ObjectModel.foreignKey.association'] = { '=': elementName };
+                }
+              });
+            }
+          }
+        });
+      }
+
+      if (filteredAnno.filter(value => value['#'] === 'ANALYTICAL_DIMENSION').length > 0 && parent.kind === 'entity' && parent.elements) {
+        forEach(parent.elements, (_elementName, element) => {
+          if (element['@ObjectModel.text.element'] && parent.elements[element['@ObjectModel.text.element']['=']] && parent.elements[element['@ObjectModel.text.element']['=']]['@Semantics.text'] === undefined)
+            parent.elements[element['@ObjectModel.text.element']['=']]['@Semantics.text'] = true;
+        });
+      }
+
+      if (filteredAnno.length === 1 && parent.kind && parent['@ObjectModel.modelingPattern'] === undefined) {
+        if (filteredAnno[0]['#'] === 'ANALYTICAL_PROVIDER')
+          parent['@ObjectModel.modelingPattern'] = { '#': 'ANALYTICAL_CUBE' };
+        else
+          parent['@ObjectModel.modelingPattern'] = { '#': filteredAnno[0]['#'] };
+      }
+    },
+  };
+}
+
+function isPartOfINAService(csn, artifactName) {
+  const parts = artifactName.split('.');
+  if (parts.length === 1)
+    return false; // No dots
+  for (let i = 0; i < parts.length; i++) {
+    const possibleServiceName = parts.slice(0, i).join('.');
+    const possibleDefinition = csn.definitions[possibleServiceName];
+    if (possibleDefinition?.kind === 'service')
+      return possibleDefinition['@protocol'] === 'ina';
+  }
+
+  return false;
+}
+
+/**
+ * Split the given on-condition into bite-sized tuples IF
+ * - the operator is a =
+ * - one of the arguments is of the form <assoc>.<field>
+ * - one of the arguments is of the form <field>
+ * - there are no braces
+ * - each of the comparison tuples is "joined" via "and"
+ *
+ * Return an empty array if we encounter any tuples/things that do NOT match those criteria
+ * @param {CSN.OnCondition} on
+ * @param {string} assocName
+ * @returns {object[]}
+ */
+function getOnConditionAsComparisonTuples(on, assocName) {
+  const validTuples = [];
+  for (let i = 0; i < on.length - 2; i += 4) {
+    let isValid = false;
+    const arg1 = on[i];
+    const operator = on[i + 1];
+    const arg2 = on[i + 2];
+    const possibleAnd = i + 3 < on.length ? on[i + 3] : 'and';
+    if (possibleAnd === 'and' && operator === '=' && (arg1.ref?.length === 1 && arg2.ref?.length === 2 && arg2.ref[0] === assocName || arg1.ref?.length === 2 && arg1.ref[0] === assocName && arg2.ref?.length === 1 )) { // TODO: Do we care about filters? Filters could cause a crash here?
+      if (arg1.ref.length === 1) { // arg1 needs to point to be <field>, arg2 needs to be <assoc>.<field>
+        validTuples.push({ source: arg1, target: arg2 });
+        isValid = true;
+      }
+      else {  // arg1 needs to point to be <assoc>.<field>, arg2 needs to be <field>
+        validTuples.push({ source: arg2, target: arg1 });
+        isValid = true;
+      }
+    }
+
+    if (!isValid)
+      return [];
+  }
+  return validTuples;
+}
+
+
 module.exports = {
   remapODataAnnotations,
+  sealAnnoMagic,
+  sealAnnoMagicForTexts,
 };

package/lib/transform/effective/main.js

@@ -75,15 +75,29 @@ function effectiveCsn( model, options, messageFunctions ) {
   // ensure getElement works on flattened struct_assoc columns
   csnUtils = getUtils(csn, 'init-all');
 
-  processCalculatedElementsInEntities(csn);
+  processCalculatedElementsInEntities(csn, options);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);
-  const transformers = mergeTransformers([ options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {}, options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {}, misc.removeDefinitionsAndProperties(csn, options) ], null);
-  applyTransformations(csn, transformers, [], { skipIgnore: false, processAnnotations: true });
+  const transformers = mergeTransformers([
+    options.addCdsPersistenceName ? misc.attachPersistenceName(csn, options, csnUtils) : {},
+    options.remapOdataAnnotations ? annotations.remapODataAnnotations(csn) : {},
+    misc.removeDefinitionsAndProperties(csn, options),
+    options.deriveAnalyticalAnnotations ? annotations.sealAnnoMagic(csn) : {},
+  ], null);
+
+  const artifactTransformers = [];
+  if (options.deriveAnalyticalAnnotations)
+    artifactTransformers.push(annotations.sealAnnoMagicForTexts);
+
+  applyTransformations(csn, transformers, artifactTransformers, { skipIgnore: false, processAnnotations: true });
 
   if (!options.resolveProjections)
     redoProjections.forEach(fn => fn());
 
+
+  // Remove unapplied extensions/annotations
+  delete csn.extensions;
+
   messageFunctions.throwWithError();
 
   return csn;