@sap/cds-compiler 4.9.0 → 4.9.4

package/CHANGELOG.md

@@ -7,6 +7,23 @@
 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.4 - 2024-05-21
+
+### Fixed
+
+- to.sql:
+  + always include `tenant` column in foreign key references.
+  + reject `tenantDiscriminator` option only if sql dialect is `hana` and if  `withHanaAssociations` option is set.
+
+## Version 4.9.2 - 2024-05-13
+
+### Fixed
+
+- compiler: Rewriting annotation expression paths in structures of projections has been improved.
+- to.edm(x):
+  + Operator `/` represents `DivBy` operator, explicit `DivBy` is replaced with `Div` as integer division.
+- to.sql: consider all associations in tenant dependent entity for referential constraint generation
+
 ## Version 4.9.0 - 2024-04-25
 
 ### Added

package/bin/cdsc.js

@@ -578,22 +578,12 @@ function executeCommandLine( command, options, args ) {
   // Depending on 'options.rawOutput', the model is either compacted to 'name.json' or
   // written in raw form to '<name>_raw.txt'.
   function displayNamedXsn( xsn, name ) {
-    if (options.rawOutput) {
+    if (options.rawOutput)
       writeToFileOrDisplay(options.out, `${name}_raw.txt`, util.inspect(reveal(xsn, options.rawOutput), false, null), true);
-    }
-    else if (options.internalMsg) {
+    else if (options.internalMsg)
       writeToFileOrDisplay(options.out, `${name}_raw.txt`, util.inspect(reveal(xsn).messages, { depth: null, maxArrayLength: null }), true);
-    }
-    else if (!options.parseOnly) { // no output if parseOnly but not rawOutput
-      const csn = compactModel(xsn, options);
-      if (command === 'toCsn' && options.tenantDiscriminator)
-        addTenantFields(csn, options);
-      if (command === 'toCsn' && options.withLocalized)
-        addLocalizationViews(csn, options);
-      if (options.enrichCsn)
-        enrichCsn( csn, options );
-      writeToFileOrDisplay(options.out, `${name}.json`, csn, true);
-    }
+    else if (!options.parseOnly) // no output if parseOnly but not rawOutput
+      displayNamedCsn(compactModel(xsn, options), name);
   }
 
   /**
@@ -603,12 +593,22 @@ function executeCommandLine( command, options, args ) {
   function displayNamedCsn( csn, name ) {
     if (!csn) // only print CSN if it is set.
       return;
+
+    if (command === 'toCsn' ) {
+      // If requested, run some CSN postprocessing.
+      if (options.tenantDiscriminator)
+        addTenantFields(csn, options); // always _before_ localized convenience views are added
+      if (options.withLocalized)
+        addLocalizationViews(csn, options);
+    }
+
+    if (options.enrichCsn)
+      enrichCsn( csn, options );
+
     if (options.internalMsg) {
       writeToFileOrDisplay(options.out, `${name}_raw.txt`, options.messages, true);
     }
     else if (!options.internalMsg) {
-      if (command === 'toCsn' && options.withLocalized)
-        addLocalizationViews(csn, options);
       writeToFileOrDisplay(options.out, `${name}.json`, csn, true);
     }
   }

package/lib/api/main.js

@@ -1293,7 +1293,7 @@ function lazyload( moduleName ) {
  * @param {object} messageFunctions Message functions
  */
 function handleTenantDiscriminator( options, internalOptions, messageFunctions ) {
-  if (options.tenantDiscriminator && options.withHanaAssociations) {
+  if (options.tenantDiscriminator && options.withHanaAssociations && internalOptions.sqlDialect === 'hana') {
     messageFunctions.error('api-invalid-combination', null, {
       option: 'tenantDiscriminator',
       prop: 'withHanaAssociations',

package/lib/api/options.js

@@ -172,6 +172,7 @@ module.exports = {
     },
     hdi: (options) => {
       const hardOptions = { src: 'hdi', toSql: true, forHana: true };
+      // TODO: sqlDialect should be a hard option!
       const defaultOptions = {
         sqlMapping: 'plain', sqlDialect: 'hana', generatedByComment: false, withHanaAssociations: true,
       };
@@ -179,6 +180,7 @@ module.exports = {
     },
     hdbcds: (options) => {
       const hardOptions = { forHana: true };
+      // TODO: sqlDialect should be a hard option!
       const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
       return translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdbcds');
     },

package/lib/base/message-registry.js

@@ -298,8 +298,9 @@ const centralMessageTexts = {
   },
 
   'anno-missing-rewrite': {
-    std: 'Assign a value for $(ANNO); the value inherited from $(ART) would contain invalid or unrelated references like $(ELEMREF)',
+    std: 'Assign a value for $(ANNO); the value inherited from $(ART) can\'t be rewritten due to $(ELEMREF)',
     unsupported: 'Assign a value for $(ANNO); the value inherited from $(ART) can\'t be rewritten due to unsupported $(ELEMREF)',
+    param: 'Assign a value for $(ANNO); the value inherited from $(ART) can\'t be rewritten due to parameter reference $(ELEMREF)',
   },
 
   'chained-array-of': '"Array of"/"many" must not be chained with another "array of"/"many" inside a service',
@@ -717,6 +718,8 @@ const centralMessageTexts = {
     min: 'Expecting argument $(PROP) for type $(TYPE) to be greater than or equal to $(NUMBER)',
     'incorrect-type': 'Expected $(NAMES) for argument $(PROP), but found $(CODE)',
   },
+  'type-unexpected-foreign-keys': 'A managed aspect composition can\'t have a foreign keys specification. Use composition-of-entity or remove foreign keys',
+  'type-unexpected-on-condition': 'A managed aspect composition can\'t have a specified ON-condition. Use composition-of-entity or remove the ON-condition',
 
   'type-invalid-items': {
     std: 'Unexpected $(PROP)', // unused
@@ -876,7 +879,7 @@ const centralMessageTexts = {
     sub: 'Expecting an entity as target; a target aspect can\'t be specified for a sub element',
   },
   'ref-invalid-include': {
-    std: 'A type, entity, aspect or event with direct elements is expected here',
+    std: 'An explicitly structured entity, type, aspect, or event is expected here',
     bare : 'An aspect without elements is expected here',
     param: 'A type, entity, aspect or event without parameters is expected here',
   },
@@ -1166,7 +1169,8 @@ const centralMessageTexts = {
   }
   ,
   'odata-anno-xpr-type': {
-    'std': 'Expected one qualified type name for $(OP) in $(ANNO)'
+    'std': 'Expected one qualified type name for $(OP) in $(ANNO)',
+    'edm': 'Expected a qualified EDM type name for $(OP) in $(ANNO) but found $(TYPE)'
   },
   'odata-anno-xpr-args': {
     'std': 'Unexpected arguments for $(OP) in $(ANNO)',

package/lib/base/messages.js

@@ -890,7 +890,7 @@ function transformElementRef( arg ) {
     return quoted( arg );
   // Can be used by CSN backends or compiler to create a simple path such as E:elem
   return quoted(
-    (arg.param ? ':' : '') +
+    ((arg.scope === 'param' || arg.param) ? ':' : '') +
     ref.map(
       item => (typeof item !== 'string'
                ? `${ item.id }${item.args ? '(…)' : ''}${item.where ? '[…]' : ''}`

package/lib/compiler/assert-consistency.js

@@ -207,7 +207,7 @@ function assertConsistency( model, stage ) {
           optional: [
             'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
             '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
-            '$calcDepElement', '$filtered', '_parent',
+            '$calcDepElement', '$filtered', '$enclosed', '_parent',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -261,6 +261,7 @@ function assertConsistency( model, stage ) {
     foreignKeys: { kind: true, inherits: 'definitions', instanceOf: 'ignore' },
     $keysNavigation: { kind: true, test: TODO },
     $filtered: { kind: true, inherits: 'value' }, // for assoc+filter
+    $enclosed: { kind: true, inherits: 'value' }, // for comp+filter
     params: { kind: true, inherits: 'definitions' },
     _extendType: { kind: true, test: TODO },
     mixin: { inherits: 'definitions' },

package/lib/compiler/define.js

@@ -1024,15 +1024,11 @@ function define( model ) {
     const { targetAspect } = obj;
     if (targetAspect) {
       if (obj.foreignKeys) {
-        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ],
-               {},
-               'A managed aspect composition can\'t have a foreign keys specification' );
+        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ] );
         delete obj.foreignKeys; // continuation semantics: not specified
       }
       if (obj.on && !obj.target) {
-        error( 'type-unexpected-on-condition', [ obj.on.location, construct ],
-               {},
-               'A managed aspect composition can\'t have a specified ON-condition' );
+        error( 'type-unexpected-on-condition', [ obj.on.location, construct ] );
         delete obj.on;          // continuation semantics: not specified
       }
       if (targetAspect.elements)
@@ -1182,8 +1178,8 @@ function define( model ) {
       // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
       createAndLinkCalcDepElement( elem );
 
-      // Special case (hack) for calculated elements that use associations+filter:
-      // See "Notes on `$filtered`" in `ExposingAssocWithFilter.md` for details.
+      // Special case (hack) for calculated elements that use composition+filter:
+      // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
       if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
         delete elem.type;
         delete elem.on;

package/lib/compiler/populate.js

@@ -617,8 +617,6 @@ function populate( model ) {
 
     function resolveTabRef( alias ) {
       // effectiveType() must not be called on $self, is unnecessary for mixins:
-      // TODO: have a test for `select from E { a, $self.a as b, $self.{ b as c } }`
-      // TODO: have a negative test for `select from E { $self.*, assoc.* }`
       // (we might have those already)
       if (alias.kind === 'mixin' || alias.kind === '$self')
         return;

package/lib/compiler/propagator.js

@@ -56,7 +56,8 @@ function propagate( model ) {
     enum: expensive,
     params: expensive,          // actually only with parent action
     returns,
-    $filtered: annotation,
+    $filtered: annotation, // TODO(v5): Remove
+    $enclosed: annotation,
   };
   const ruleToFunction = {
     __proto__: null,
@@ -281,7 +282,7 @@ function propagate( model ) {
     if (target.targetAspect)
       return;
     if (target.type?._artifact === model.definitions['cds.Association'])
-      return; // don't propagate targetAspect to associations (e.g. via $filtered)
+      return; // don't propagate targetAspect to associations (e.g. via $enclosed)
     const ta = source.targetAspect;
     if (!ta.elements && !ta._origin) { // _origin set for elements in source
       notWithExpand( prop, target, source );

package/lib/compiler/resolve.js

@@ -182,9 +182,12 @@ function resolve( model ) {
           // Path could start with table alias; get start index
           let index = path.indexOf(nav.item);
           if (index === -1)
-            return;
+            return; // should not happen
 
           let navItem = nav.navigation;
+          if (!nav.item._navigation) // first non-table-alias
+            setLink( nav.item, '_navigation', navItem );
+
           if (path[index].where || path[index].args)
             return;
           ++index;
@@ -566,7 +569,7 @@ function resolve( model ) {
       const iType = iTypeArt || inferredElement;
       // FIXME: The coding above returns incorrect iType for expand on associations
 
-      // $filtered may change composition to association; we allow that change here.
+      // $enclosed: maybe composition was changed to association; we allow that change here.
       const compToAssoc = sType === model.definitions['cds.Association'] && inferredElement.target;
 
       // xor: could be missing a type;

package/lib/compiler/tweak-assocs.js

@@ -5,6 +5,7 @@
 const {
   forEachGeneric,
   forEachInOrder,
+  isBetaEnabled,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
@@ -18,6 +19,7 @@ const {
   traverseQueryPost,
   traverseQueryExtra,
   setExpandStatus,
+  getUnderlyingBuiltinType,
 } = require('./utils');
 const { Location } = require('../base/location');
 const { CompilerAssertion } = require('../base/error');
@@ -39,6 +41,12 @@ function tweakAssocs( model ) {
     getOrigin,
   } = model.$functions;
 
+  Object.assign(model.$functions, {
+    firstProjectionForPath,
+  });
+
+  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
+
   // Phase 5: rewrite associations
   model._entities.forEach( rewriteArtifact );
   // Think hard whether an on condition rewrite can lead to a new cyclic
@@ -448,14 +456,27 @@ function tweakAssocs( model ) {
     };
     setArtifactLink( elem.type, assocType._artifact );
 
-    elem.$filtered = {
-      val: true,
-      literal: 'boolean',
-      location,
-      $inferred: '$generated',
-    };
+    if (!isV5preview) { // TODO(v5): Remove, only use $enclosed
+      elem.$filtered = {
+        val: true,
+        literal: 'boolean',
+        location,
+        $inferred: '$generated',
+      };
+    }
+
+    const isComp = (getUnderlyingBuiltinType( assoc )?.name?.id === 'cds.Composition');
+    if (isComp) {
+      elem.$enclosed = {
+        val: true,
+        literal: 'boolean',
+        location,
+        $inferred: '$generated',
+      };
+    }
   }
 
+
   /**
    * Transform a filter on `assocPathStep` into an ON-condition.
    * Paths inside the filter are rewritten relative to `assoc`, so they can be redirected
@@ -541,7 +562,7 @@ function tweakAssocs( model ) {
       setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1]._artifact );
 
       if (elem.$syntax !== 'calc') { // different to lhs!
-        const projectedFk = firstProjectionForPath( rhs.path, nav.tableAlias, elem );
+        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, elem );
         rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
       }
 
@@ -596,7 +617,8 @@ function tweakAssocs( model ) {
         return;                 // not $self or source element
       if (expr.scope === 'param' || root.kind === '$parameters')
         return;                 // are not allowed anyway - there was an error before
-      const result = firstProjectionForPath( expr.path, tableAlias, assoc );
+      const startIndex = (root.kind === '$self' ? 1 : 0);
+      const result = firstProjectionForPath( expr.path, startIndex, tableAlias, assoc );
       // For `assoc[…]`, ensure that we don't rewrite to another projection on `assoc`.
       if (result.item && assoc._origin === result.item._artifact)
         result.elem = assoc;
@@ -782,51 +804,60 @@ function navProjection( navigation, preferred ) {
 
 
 /**
- * For a path `a.b.c.d`, return a projection for the first path item that is projected.
+ * For a path `a.b.c.d`, return a projection for the first path item that is projected,
+ * starting at `startIndex` in this path using the given navigation (table alias or
+ * navigation element).
  * For example, if a query has multiple projections such as `a.b, a, a.b.c`, the
  * _first_ possible projection will be used and the caller can rewrite `a.b.c.d` to `b.c.d`.
- * This avoids that `extend`s affect the ON-condition.
+ * This avoids `extend`s affect the ON-condition.
  *
- * The returned object `ret` has `ret.item`, which is the path item that is projected.
- * `ret.elem` is the element projection.
+ * The returned object `ret` has `ret.item`, which is the path item at index `ret.index`
+ * that is projected. `ret.elem` is the element projection.
  *
  * @param {any[]} path
- * @param {object} tableAlias
- * @param {object} assoc Preferred association that should be used if projected.
+ * @param {number} startIndex
+ * @param {object} nav
+ * @param {object} elem Preferred association/element that should be used if projected.
  * @return {{elem: object, item: object}|null}
  */
-function firstProjectionForPath( path, tableAlias, assoc ) {
-  const viaSelf = (path[0]._navigation || path[0]._artifact).kind === '$self';
-  const root = viaSelf ? 1 : 0;
-  if (root >= path.length) // e.g. just `$self` path item
+function firstProjectionForPath( path, startIndex, nav, elem ) {
+  if (startIndex >= path.length) // e.g. just `$self` path item
     return { item: undefined, elem: {} };
 
+  let tableAlias = nav;
+  while (tableAlias.kind === '$navElement')
+    tableAlias = tableAlias._parent;
+
   // We want to use the _first_ valid projection that is written by the user (if the preferred
-  // `assoc` is not directly projected).  To achieve that, look into the table alias' elements.
+  // `assoc` is not directly projected).  To achieve that, look into the query's elements.
   const selectedElements = Object.values(tableAlias._parent.elements);
-  const proj = [];
-  let navItem = tableAlias;
-  for (const item of path.slice(root)) {
+
+  let proj = null;
+  let navItem = nav;
+  for (let i = startIndex; i < path.length; ++i) {
+    const item = path[i];
     navItem = item?.id && navItem.elements?.[item.id];
     if (!navItem) {
       break;
     }
     else if (navItem._projections) {
-      const elem = navProjection( navItem, assoc );
-      if (elem && elem === assoc) {
+      const projElem = navProjection( navItem, elem );
+      if (projElem && projElem === elem) {
         // in case the specified association is found, _always_ use it.
-        return { item, elem };
+        return { index: i, item, elem };
       }
-      else if (elem) {
-        const index = selectedElements.indexOf(elem);
-        proj.push({ item, elem, index });
+      else if (projElem) {
+        const queryIndex = selectedElements.indexOf(projElem);
+        if (!proj || queryIndex < proj.queryIndex) {
+          proj = {
+            index: i, item, elem: projElem, queryIndex,
+          };
+        }
       }
     }
   }
 
-  return (proj.length === 0)
-    ? { item: path[root], elem: null }
-    : proj.reduce( (acc, curr) => (acc.index > curr.index ? curr : acc), proj[0] ); // first
+  return proj || { index: startIndex, item: path[startIndex], elem: null };
 }
 
 /**

package/lib/compiler/xpr-rewrite.js

@@ -98,15 +98,21 @@
 //
 // Select Item via Origin
 // ----------------------
-// A bare select item that gets an annotation via propagation from its origin behaves
-// similar to an element that gets it via an include.
+// A bare select item of path length one, that gets an annotation via propagation from
+// its origin, behaves similar to an element that gets it via an include.
 // However, elements may have been renamed or may not be available at all.
 // On top of that, they may be inside nested projections (expand).
+// Or even simpler: sub-elements may have been selected.
 //
 // Instead of changing the path prefix, we need to check if the referenced path
 // was projected or if a prefix was projected (e.g. for structures or associations).
 // The same rules as for ON-condition rewriting apply.
 //
+// Furthermore, as the target is a select item, and this select item belongs to a table
+// alias, we should rewrite all annotation paths only to projected elements of that
+// table alias.  Cross-rewriting between table aliases should not be done.
+// This is the same we do for association rewriting.
+//
 // TODO:
 //   For now, we do not rewrite sub-structure elements.  The whole structure needs
 //   to be projected or the select item isn't considered.  That is, `expand {*}`
@@ -158,6 +164,7 @@ class AnnoRewriteConfig {
   viaExpand;
   viaExpandType;
   isInFilter;
+  tokenExpr;
 }
 
 function xprRewriteFns( model ) {
@@ -167,6 +174,7 @@ function xprRewriteFns( model ) {
     resolvePath,
     navigationEnv,
     resolvePathRoot,
+    firstProjectionForPath,
   } = model.$functions;
 
   return {
@@ -275,6 +283,11 @@ function xprRewriteFns( model ) {
       root._parent.kind !== 'function'))
       return reportAnnoRewriteError( expr, config, 'unsupported' );
 
+    // magic variables / replacement variables are never rewritten; they can't
+    // have filters nor can they point to elements.
+    if (expr._artifact?.kind === 'builtin')
+      return null;
+
     let hasError = false;
     if (config.isViaType || config.isViaCalcElement)
       hasError = adaptPathPrefixViaType( expr, config );
@@ -335,12 +348,41 @@ function xprRewriteFns( model ) {
    */
   function getRootEnv( expr, config ) {
     const { target } = config;
+
+    if (expr.scope === 'param') // path is absolute
+      return navigationEnv( config.targetRoot, null, null, 'nav' );
+
+    // On select items, use navigation elements or table alias
+    // TODO: Expand/inline paths don't have a `_navigation` property on their last
+    //       path step, yet.  We need to implement expand/inline.
+    const isSimpleSelectItem = target.value?.path && target._main?.query && !target._pathHead;
+    if (isSimpleSelectItem) {
+      const isSelfPath = (expr.path[0]?._navigation?.kind === '$self');
+      if (isSelfPath) {
+        // Path is absolute, use table alias to resolve it.
+        let tableAlias = target.value.path[0]._navigation;
+        while (tableAlias && tableAlias.kind === '$navElement')
+          tableAlias = tableAlias._parent;
+        if (tableAlias)
+          return tableAlias;
+      }
+      else {
+        // Path is relative
+        const nav = target.value.path[target.value.path.length - 1]._navigation?._parent;
+        if (nav)
+          return nav;
+      }
+    }
+
+    if (isSimpleSelectItem && model.options.testMode)
+      throw new CompilerAssertion(`select item has no table alias: ${ JSON.stringify(target.value.path) }`);
+
     if (isAnnoPathAbsolute( expr ))
       return navigationEnv( config.targetRoot, null, null, 'nav' );
-    // root item is element reference (others were already rejected)
-    if (isAnnoRootArt( target ))
-      return navigationEnv( target, null, null, 'nav' );
-    return navigationEnv( target._parent, null, null, 'nav' );
+
+    // anno path is relative / element reference (others were already rejected)
+    // if the target is a root artifact, use it. Otherwise, use its parent.
+    return navigationEnv( isAnnoRootArt( target ) ? target : target._parent, null, null, 'nav' );
   }
 
   /**
@@ -350,15 +392,20 @@ function xprRewriteFns( model ) {
    * @returns {boolean}
    */
   function rewriteGenericAnnoPath( expr, config, refCtx ) {
-    const rootIndex = isAnnoPathAbsolute( expr ) ? 1 : 0;
-    let env = getRootEnv( expr, config );
+    const isAbsolute = isAnnoPathAbsolute( expr );
+    const rootIndex = isAbsolute ? 1 : 0;
 
-    // reset artifact link
+    // We get the root environment now, even though below we resolve the root item
+    // again if it was absolute (e.g. $self).  We do so, because for queries, we
+    // want to respect the select item's corresponding table alias.
+    const rootEnv = getRootEnv( expr, config );
+
+    // reset artifact link; we'll set it again
     setArtifactLink( expr, null );
 
     // Adapt root path, as it isn't rewritten in rewriteItem
     const rootItem = expr.path[0];
-    if (rootIndex === 1) {
+    if (isAbsolute) {
       delete rootItem._artifact;
       delete rootItem._navigation;
       // TODO: What about `up_`? Shouldn't we set `_navigation` as well?
@@ -368,10 +415,10 @@ function xprRewriteFns( model ) {
         return reportAnnoRewriteError( expr, config );
     }
 
+    let env = rootEnv;
     let art = rootItem._artifact;
     for (let i = rootIndex; i < expr.path.length; ++i) {
-      const item = expr.path[i];
-      art = rewriteItem( expr, config, env, item );
+      art = rewriteItem( expr, config, env, i );
       if (!art)
         return reportAnnoRewriteError( expr, config );
       env = navigationEnv( art, null, null, 'nav' );
@@ -581,48 +628,74 @@ function xprRewriteFns( model ) {
     return self;
   }
 
-  function rewriteItem( expr, config, env, item ) {
-    const found = setArtifactLink( item, findRewriteTarget( item, env, config.target ));
-    if (found) {
-      if (item.id !== found.name.id) {
-        // Path was rewritten; original token text string is no longer accurate
-        config.tokenExpr.$tokenTexts = true;
-        item.id = found.name.id;
-      }
-      return found;
+  /**
+   * Rewrite the item in `expr.path` at the given index.
+   * This function may splice the array if more than one path segment
+   * is replaced by a single item (e.g. in queries).
+   *
+   * @param {XSN.Expression} expr
+   * @param {AnnoRewriteConfig} config
+   * @param {object} env
+   * @param {number} index
+   * @returns {*|null}
+   */
+  function rewriteItem( expr, config, env, index ) {
+    const item = expr.path[index];
+    const rewriteTarget = findRewriteTarget( expr, index, env, config.target );
+    const found = setArtifactLink( item, rewriteTarget[0] );
+    if (!found)
+      return null;
+
+    if (item.id !== found.name.id) {
+      // Path was rewritten; original token text string is no longer accurate
+      config.tokenExpr.$tokenTexts = true;
+      item.id = found.name.id;
     }
-    return null;
+
+    if (rewriteTarget[1] > index)
+      expr.path.splice(index + 1, rewriteTarget[1] - index);
+
+    return rewriteTarget[0];
   }
 
-  function findRewriteTarget( item, env, target ) {
-    if (!env.query && env.kind !== 'select')
-      return env.elements?.[item.id] || null;
+  function findRewriteTarget( expr, index, env, target ) {
+    if (env.kind === '$navElement' || env.kind === '$tableAlias') {
+      const r = firstProjectionForPath( expr.path, index, env, target );
+      return [ r.elem, r.index ];
+    }
+
+    const item = expr.path[index];
+    // Not a query -> no $navElement -> use `elements`
+    if (!env.query && env.kind !== 'select') {
+      if (env.elements?.[item.id])
+        return [ env.elements[item.id], index ];
+      return [ null, expr.path.length ];
+    }
     const items = (env._leadingQuery || env)._combined?.[item.id];
-    const navs = !items || Array.isArray(items) ? items : [ items ];
+    const allNavs = !items || Array.isArray(items) ? items : [ items ];
+
+    // If the annotation target itself has a table alias, require projections of that
+    // table alias. Of course, that only works if we're talking about the same query.
+    const tableAlias = (target._main?._origin === item._artifact._main &&
+        target.value?.path[0]?._navigation?.kind === '$tableAlias')
+      ? target.value.path[0]._navigation : null;
 
     // Look at all table aliase that could project `item` and only select
     // those that have actual projections.
-    let projected = navs?.filter(p => p._origin === item._artifact && p._projections);
-    if (!projected || projected.length === 0)
-      return null;
-
-    // If the annotation target itself has a table alias, prefer projections
-    // of that table alias over others when rewriting.
-    const tableAlias = target.value?.path[0]?._navigation;
-    if (tableAlias?.kind === '$tableAlias') {
-      // TODO: Is the _parent always a table alias?
-      const taProjected = projected.filter(p => p._parent === tableAlias);
-      if (taProjected.length)
-        projected = taProjected;
+    const navs = allNavs?.filter(p => p._origin === item._artifact &&
+      (!tableAlias || tableAlias === p._parent));
+    if (!navs || navs.length === 0)
+      return [ null, expr.path.length ];
+
+    // If there are multiple navigations for the element, just use the first that matches.
+    // In case of table aliases, it's just one.
+    for (const nav of navs) {
+      const r = firstProjectionForPath( expr.path, index, nav._parent, target );
+      if (r.elem)
+        return [ r.elem, r.index ];
     }
 
-    // Of the possible entries, choose the first one
-    projected = projected[0];
-
-    // If there are multiple projections, check if the annotation target is
-    // projected as well, otherwise, simply take the first one.
-    return projected._projections.find(proj => proj === target) ||
-      projected._projections[0] || null;
+    return [ null, expr.path.length ];
   }
 }
 

package/lib/edm/annotations/edmJson.js

@@ -248,8 +248,15 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   transform['<='] = op('$Le');
   transform.$Le = noOp;
   transform.in = (parent, prop, xpr) => {
-    evalArgs({ min: 1 }, xpr[1].list, prop);
-    parent.$In = [ xpr[0], ...xpr[1].list ];
+    let args = xpr[1].list;
+    if (!args) {
+      if (Array.isArray(xpr[1].xpr))
+        args = xpr[1].xpr;
+      else
+        args = [ xpr[1] ];
+    }
+    evalArgs({ min: 1 }, args, prop);
+    parent.$In = [ xpr[0], args ];
     delete parent[prop];
     transformExpression(parent, undefined, transform);
   };
@@ -293,9 +300,9 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   transform.$Neg = noOp;
   transform['*'] = op('$Mul');
   transform.$Mul = noOp;
-  transform['/'] = op('$Div');
-  transform.$Div = noOp;
-  // $DivBy, $Mod are functions
+  transform['/'] = op('$DivBy');
+  transform.$DivBy = noOp;
+  // $Div, $Mod are functions
   //----------------------------------
   // LITERALS
   transform.val = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
@@ -575,6 +582,15 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             }
           }
           else {
+            // Error out for arbitrary types until we know better
+            // probably todo: Check for reachability of arb type names such as namespace
+            // reqDef entry etc...
+            if (typeDef) { // eslint-disable-line no-lonely-if
+              error('odata-anno-xpr-type', location, {
+                anno, op: `${xpr}(…)`, type: `${typeDef}`, '#': 'edm',
+              });
+            }
+            /*
             typeFacets.forEach((facet) => {
               if (facet.args.length === 1 && facet.args[0].val) {
                 const facetName = facet.func.startsWith('$') ? facet.func.slice(1) : facet.func;
@@ -582,6 +598,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                   parent[`$${facetName}`] = facet.args[0].val;
               }
             });
+            */
           }
 
           delete typeProp.args;
@@ -648,8 +665,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     const funcDefs = {
       $Has: twoArgs,
       Has: [ twoArgs, dollar ],
-      $DivBy: twoArgs,
-      DivBy: [ twoArgs, dollar ],
+      $Div: twoArgs,
+      Div: [ twoArgs, dollar ],
       $Mod: twoArgs,
       Mod: [ twoArgs, dollar ],
       $Apply: () => {

package/lib/edm/annotations/genericTranslation.js

@@ -1034,7 +1034,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         typeName = dTypeName.split('.')[1];
     }
 
-    if (value) {
+    if (typeof value === 'string') {
       // replace all occurrences of '.' by '/' up to first '@'
       value = value.split('@').map((o, i) => (i === 0 ? o.replace(/\./g, '/') : o)).join('@');
     }

package/lib/json/to-csn.js

@@ -93,7 +93,8 @@ const transformers = {
   cardinality,                 // also in pathItem: after 'id', before 'where'
   targetAspect,
   target,
-  $filtered: value,            // assoc+filter
+  $filtered: value,            // assoc+filter v4
+  $enclosed: value,            // comp+filter v5
   foreignKeys,
   enum: enumDict,
   items,

package/lib/model/csnRefs.js

@@ -917,11 +917,11 @@ function csnRefs( csn, universalReady ) {
       : { $aliases: Object.create(null), $next: pcache.$next };
   }
 
-  function initColumnElement( col, colIndex, parentElementOrQueryCache ) {
+  function initColumnElement( col, colIndex, parentElementOrQueryCache, externalElements ) {
     if (col === '*')
       return;
     if (col.inline) {
-      col.inline.map( c => initColumnElement( c, null, parentElementOrQueryCache ) );
+      col.inline.map( c => initColumnElement( c, null, parentElementOrQueryCache, externalElements ) );
       return;
     }
     setCache( col, '_parent',   // not set for query (has property _select)
@@ -936,11 +936,18 @@ function csnRefs( csn, universalReady ) {
 
     while (type.items)
       type = type.items;
+    if (!type.elements) {
+      // in OData backend, the sub elements from a column with expand might have
+      // been “externalized” into a named type.  No backward _column link is
+      // possible this way, of course...
+      type = artifactRef( type.type );
+      externalElements = true;
+    }
     const elem = setCache( col, '_element', type.elements[as] );
-    if (elem)                   // TODO to.sql: something is strange if this is not set
+    if (elem && !externalElements) // TODO to.sql: something is strange if `elem` is not set
       setCache( elem, '_column', col );
     if (col.expand)
-      col.expand.map( c => initColumnElement( c, null, elem ) );
+      col.expand.map( c => initColumnElement( c, null, elem, externalElements ) );
   }
 
   // property name convention in cache:

package/lib/render/toCdl.js

@@ -614,7 +614,7 @@ function csnToCdl( csn, options, msg ) {
     else if (element['#'] !== undefined) { // enum symbol reference
       result += ` = #${element['#']}`;
     }
-    else if (!isCalcElement || !isDirectAssocOrComp(element.type) && !element.$filtered) {
+    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.

package/lib/transform/db/constraints.js

@@ -187,13 +187,23 @@ 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();
@@ -208,7 +218,15 @@ function createReferentialConstraints( csn, options ) {
         validated,
         enforced,
       };
-      dependentKey.$foreignKeyConstraint = constraint;
+      if (tenantForeignKey) {
+        const dontOverwriteUp = dependentKey.$foreignKeyConstraint && dependentKey.$foreignKeyConstraint.some(c => c.sourceAssociation === sourceAssociation && c.parentTable === parentTable);
+        const dontOverwriteTexts = dependentKey.$foreignKeyConstraint && dependentKey.$foreignKeyConstraint.some(c => c.sourceAssociation === 'texts' && c.upLinkFor.texts);
+        if (!dontOverwriteUp && !dontOverwriteTexts)
+          dependentKey.$foreignKeyConstraint = dependentKey.$foreignKeyConstraint ? [ ...dependentKey.$foreignKeyConstraint, constraint ] : [ constraint ];
+      }
+      else {
+        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,21 @@ 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 tenantConstraints = element.$foreignKeyConstraint;
+        delete element.$foreignKeyConstraint;
+        // create (multiple) foreign key constraint(s) for the tenant column with each association in the dependent entity
+        tenantConstraints.forEach((c) => {
+          createReferentialConstraints(c, 'tenant');
+        });
+      }
+    }
+
     for (const elementName in artifact.elements) {
       const element = artifact.elements[elementName];
       if (!element.$foreignKeyConstraint)
@@ -492,16 +525,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 +587,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/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/forRelationalDB.js

@@ -951,7 +951,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
                   if (isFulltextIndex)
                     error(null, path, { name: artName }, 'A fulltext index can\'t be defined on a structured element $(NAME)');
                   // First, compute the name from the path, e.g ['s', 's1', 's2' ] will result in 'S_s1_s2' ...
-                  const refPath = flattenStructStepsInRef(val.ref, path);
+                  const [ refPath ] = flattenStructStepsInRef(val.ref, path);
                   // ... and take this as the prefix for all elements
                   const flattenedElems = flattenStructuredElement(art, refPath, [], ['definitions', artName, 'elements']);
                   Object.keys(flattenedElems).forEach((elem, i, elems) => {
@@ -967,7 +967,7 @@ function transformForRelationalDBWithCsn(csn, options, messageFunctions) {
                 }
                 else {
                   // The reference is not structured, so just replace it by a ref to the combined prefix path
-                  const refPath = flattenStructStepsInRef(val.ref, path);
+                  const [ refPath ] = flattenStructStepsInRef(val.ref, path);
                   flattenedIndex.push({ ref: refPath });
                 }
               }

package/lib/transform/odata/flattening.js

@@ -290,6 +290,7 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
   // Later, the query can/must be rewritten as long as a flat OData CSN is published
   // but this then operates on the entity/view which has all struct infos available
   function flattenAndPrefixExprPaths(carrier, propNames, csnPath, rootPrefix, typeIdx, refParentIsItems = false) {
+
     const refCheck = {
       ref: (elemref, prop, xpr, path) => {
         const { art, scope } = inspectRef(path);
@@ -316,53 +317,60 @@ function allInOneFlattening(csn, refFlattener, adaptRefs, inspectRef, isExternal
         return `${head}`;
     })();
 
+    let refChanged = false;
     const absolutifier = {
       ref : (parent, prop, xpr) => {
         const head = xpr[0].id || xpr[0];
-        if (typeIdx < rootPrefix.length && head === '$self' && !isMagicVariable(head)) {
-          const [xprHead, ...xprTail] = xpr.slice(1, xpr.length);
-          if(xprHead) {
-            if (xprHead.id) {
-              xprHead.id = rootPrefix.slice(1, typeIdx).concat(xprHead.id).join('_');
-              parent[prop] = [ xprHead, ...xprTail ];
+        let isPrefixed = false;
+        if(!isMagicVariable(head)) {
+          if (head === '$self' && typeIdx < rootPrefix.length) {
+            isPrefixed = true;
+            const [xprHead, ...xprTail] = xpr.slice(1, xpr.length);
+            if(xprHead) {
+              if (xprHead.id) {
+                xprHead.id = rootPrefix.slice(1, typeIdx).concat(xprHead.id).join('_');
+                parent[prop] = [ xprHead, ...xprTail ];
+              }
+              else
+                parent[prop] = [ rootPrefix.slice(1, typeIdx).concat(xprHead).join('_'), ...xprTail];
+            }
+          }
+          else if (head !== '$self' && !parent.param && rootPrefix.length > 2) {
+            isPrefixed = true;
+            const [xprHead, ...xprTail] = xpr;
+            if (!refParentIsItems) {
+              if (xprHead.id) {
+                xprHead.id = rootPrefix.slice(1, -1).concat(xprHead.id).join('_');
+                parent[prop] = [ xprHead, ...xprTail ];
+              }
+              else
+                parent[prop] = [ rootPrefix.slice(1, -1).concat(xprHead).join('_'), ...xprTail];
             }
             else
-              parent[prop] = [ rootPrefix.slice(1, typeIdx).concat(xprHead).join('_'), ...xprTail];
+              parent[prop] = [ ...rootPrefix.slice(0, rootPrefix.length-1), ...xpr];
+          }
+          if(isPrefixed) {
             if (carrier.$scope === 'params')
               parent.param = true;
             else
               parent[prop].unshift('$self');
           }
         }
-        else if (rootPrefix.length > 2 && head !== '$self' && !parent.param && !isMagicVariable(head)) {
-          const [xprHead, ...xprTail] = xpr;
-          if (!refParentIsItems) {
-            if (xprHead.id) {
-              xprHead.id = rootPrefix.slice(1, -1).concat(xprHead.id).join('_');
-              parent[prop] = [ xprHead, ...xprTail ];
-            }
-            else
-              parent[prop] = [ rootPrefix.slice(1, -1).concat(xprHead).join('_'), ...xprTail];
-          }
-          else
-            parent[prop] = [ ...rootPrefix.slice(0, rootPrefix.length-1), ...xpr];
-          if (carrier.$scope === 'params')
-            parent.param = true;
-          else
-            parent[prop].unshift('$self');
-        }
+        if(isPrefixed)
+          refChanged = isPrefixed;
       }
     }
-
     propNames.forEach(pn => {
+      refChanged = false;
       refCheck.anno = pn;
       transformExpression(carrier, pn, [ refCheck, refFlattener ], csnPath);
-    });
-    adaptRefs.forEach(fn => fn(refParentIsItems));
-    adaptRefs.length = 0;
-    propNames.forEach(pn => {
+      adaptRefs.forEach(fn =>
+        { if( fn(refParentIsItems)) refChanged = true });
+      adaptRefs.length = 0;
       transformExpression(carrier, pn, absolutifier, csnPath)
-    })
+      if(refChanged && carrier[pn]['='])
+      carrier[pn]['='] = true;
+    });
   }
 
   // TODO: This should be part of the generic path rewriting algorithm
@@ -437,13 +445,17 @@ function flattenAllStructStepsInRefs( csn, refFlattener, adaptRefs, inspectRef,
   typeNames.forEach(tn => {
     forEachMemberRecursively(csn.definitions[tn], (member, memberName, prop, csnPath) => {
       Object.keys(member).filter(pn => pn[0] === '@').forEach(pn => {
+        let refChanged = false;
         refCheck.anno = pn;
         transformExpression(member, pn, [ refCheck, refFlattener ], csnPath);
+        adaptRefs.forEach(fn => {
+          if (fn(true, 1)) refChanged = true });
+        adaptRefs.length = 0;
+        if(refChanged && member[pn]['='])
+          member[pn]['='] = true;
       });
     }, [ 'definitions', tn ]);
   })
-  adaptRefs.forEach(fn => fn(true, 1));
-  adaptRefs.length = 0;
 }
 
 function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, options, resolved, pathDelimiter) {
@@ -468,6 +480,7 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
   const adaptRefs = [];
   const transformer = {
     ref: (parent, prop, ref, path) => {
+      let refChanged = false;
       const { links, art, scope } = inspectRef(path);
       const resolvedLinkTypes = resolveLinkTypes(links);
       setProp(parent, '$path', [ ...path ]);
@@ -480,7 +493,7 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
           //       full path into target, uncomment this line and
           //       comment/remove setProp in expansion.js
           // setProp(parent, '$structRef', parent.ref);
-          parent.ref = flattenStructStepsInRef(ref,
+          [ parent.ref, refChanged ] = flattenStructStepsInRef(ref,
               scopedPath, links, scope, resolvedLinkTypes,
               suspend, suspendPos, parent.$bparam);
           resolved.set(parent, { links, art, scope });
@@ -496,9 +509,10 @@ function getStructRefFlatteningTransformer(csn, inspectRef, effectiveType, optio
                       (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
                       !parent.as) {
             parent.as = lastRef;
-          }  
+          }
+          return refChanged;
         }
-
+        return false;
         /**
          * Return true if the path points inside columns
          *

package/lib/transform/transformUtils.js

@@ -326,12 +326,12 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    * @param {bool} [suspend] suspend flattening by caller until association path step
    * @param {int} [suspendPos] suspend if starting pos is lower or equal to suspendPos and suspend is true
    * @param {bool} [revokeAtSuspendPos] revoke suspension after suspendPos (binding parameter path use case)
-   * @returns {string[]}
+   * @returns [string[], bool]
    */
   function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), suspend=false, suspendPos=0, revokeAtSuspendPos=false) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
-      return ref;
+      return [ ref, false ];
     }
 
     const result = scope === '$self' ? [ref[0]] : [];
@@ -342,7 +342,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       scope = res.scope;
     }
     if (scope === '$magic')
-      return ref;
+      return [ ref, false ];
 
     // Don't process a leading $self - it will a .art with .elements!
     let i = scope === '$self' ? 1 : 0;
@@ -353,7 +353,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
      effectiveType(links[i].art)[propName] ||
      (resolvedLinkTypes.get(links[i])||{})[propName]);
 
-    let flattenStep = false;
+     let refChanged = false
+     let flattenStep = false;
     suspend = !!art('items') || (suspend && i <= suspendPos);
     for(; i < links.length; i++) {
 
@@ -365,6 +366,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
           ref[i].id = result[result.length-1];
           result[result.length-1] = ref[i];
         }
+        refChanged = true;
         // suspend flattening if the next path step has some 'items'
         suspend = !!art('items');
       }
@@ -381,7 +383,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         !links[i].art?.from &&
         art('elements');
     }
-    return result;
+    return [ result, refChanged ];
   }
 
   /**

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -280,7 +280,8 @@ module.exports = (csn, options) => {
       },
       params: (parent, prop, params) => {
         forEachValue(params, (param) => {
-          const propagateToParams = typeof param.type === 'string' ? csn.definitions[param.type]?.kind !== 'entity' : true;
+          const propagateToParams = (param.type !== '$self' || csn.definitions.$self) &&
+            (typeof param.type !== 'string' || csn.definitions[param.type]?.kind !== 'entity');
           propagateMemberPropsFromOrigin(param, {
             '@': !propagateToParams, items: true, elements: true, enum: true, virtual: true,
           });
@@ -339,8 +340,8 @@ module.exports = (csn, options) => {
             copyProperties(origin, target, getMemberPropagationRuleFor, except, force);
 
             // For a `type of` with .items, we want to take stuff from types (which we skip for "normal" propagation, see specialItemsRules).
-            // So for a type of we also propagate stuff from the virtual origin (which we don't give a "kind", therefore skipping that part of the check)
-            if (target.type && target.type.ref)
+            // So for a `type of` we also propagate stuff from the virtual origin (which we don't give a "kind", therefore skipping that part of the check)
+            if (target.type?.ref)
               copyProperties(virtualOrigin, target, getMemberPropagationRuleFor, except);
 
             if (!target.kind)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "4.9.0",
+  "version": "4.9.4",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",