@sap/cds-compiler 5.1.2 → 5.3.0

package/lib/compiler/tweak-assocs.js

@@ -41,10 +41,13 @@ function tweakAssocs( model ) {
     extendForeignKeys,
     createRemainingAnnotateStatements,
     mergeSpecifiedForeignKeys,
+    navigationEnv,
+    redirectionChain,
   } = model.$functions;
 
   Object.assign(model.$functions, {
-    firstProjectionForPath,
+    findRewriteTarget,
+    cachedRedirectionChain,
   });
 
   // Phase 5: rewrite associations
@@ -73,7 +76,6 @@ function tweakAssocs( model ) {
   // Only top-level queries and sub queries in FROM
 
   function rewriteArtifact( art ) {
-    // return;
     if (!art.query) {
       rewriteAssociation( art );
     }
@@ -126,7 +128,7 @@ function tweakAssocs( model ) {
       // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
       info( 'assoc-outside-service', loc, { '#': text, target, service: main._service }, {
         std: 'Association target $(TARGET) is outside any service',
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/js/max-len
         exposed: 'If association is published in service $(SERVICE), its target $(TARGET) is outside any service',
       } );
     }
@@ -143,7 +145,7 @@ function tweakAssocs( model ) {
       if (assoc && assoc.foreignKeys) {
         error( 'rewrite-key-for-unmanaged', [ elem.on.location, elem ],
                { keyword: 'on', art: assocWithExplicitSpec( assoc ) },
-               // eslint-disable-next-line max-len
+               // eslint-disable-next-line @stylistic/js/max-len
                'Do not specify an $(KEYWORD) condition when redirecting the managed association $(ART)' );
       }
       checkIgnoredFilter( elem );
@@ -333,27 +335,62 @@ function tweakAssocs( model ) {
 
     // TODO: split this function: create foreign keys without `targetElement`
     // already in Phase 2: redirectImplicitly()
-    // console.log(message( null, elem.location, elem, {art:assoc,target:assoc.target},
-    //  'Info','FK').toString())
     elem.foreignKeys = Object.create(null); // set already here (also for zero foreign keys)
     forEachInOrder( assoc, 'foreignKeys', ( orig, name ) => {
       const location = weakRefLocation( elem.target );
       const fk = linkToOrigin( orig, name, elem, 'foreignKeys', location );
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
       setLink( fk, '_effectiveType', fk );
-      const te = copyExpr( orig.targetElement, location );
-      if (elem._redirected) {
-        const i = te.path[0];   // TODO: or also follow path like for ON?
-        const state = rewriteItem( elem, i, i.id, elem, true );
-        if (state && state !== true && te.path.length === 1)
-          setArtifactLink( te, state );
-      }
-      fk.targetElement = te;
+      fk.targetElement = copyExpr( orig.targetElement, location );
+      if (elem._redirected)
+        rewriteKey( elem, fk.targetElement );
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
   }
 
+  function rewriteKey( elem, targetElement ) {
+    let projectedKey = null;
+    // rewrite along redirection chain
+    for (const alias of elem._redirected) {
+      if (alias.kind !== '$tableAlias')
+        continue;
+
+      projectedKey = firstProjectionForPath( targetElement.path, 0, alias, null );
+      if (projectedKey.elem) {
+        const item = targetElement.path[projectedKey.index];
+        item.id = projectedKey.elem.name.id;
+        if (projectedKey.index > 0)
+          targetElement.path.splice(0, projectedKey.index);
+      }
+      else {
+        setArtifactLink( targetElement.path[0], null );
+        setArtifactLink( targetElement, null );
+
+        const culprit = !elem.target.$inferred && elem.target ||
+          elem.value?.path?.[elem.value.path.length - 1] ||
+          elem;
+        // TODO: probably better to collect the non-projected foreign keys
+        // and have one message for all
+        error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
+          '#': 'std',
+          id: targetElement.path.map(p => p.id).join('.'),
+          target: alias._main,
+          name: elem.name.id,
+        });
+        return null;
+      }
+    }
+
+    if (projectedKey?.elem) {
+      const item = targetElement.path[0];
+      setArtifactLink( item, projectedKey.elem );
+      setArtifactLink( targetElement, projectedKey.elem );
+      return projectedKey.elem;
+    }
+    return null;
+  }
+
   // TODO: there is no need to rewrite the on condition of non-leading queries,
   // i.e. we could just have on = {…}
   // TODO: re-check $self rewrite (with managed composition of aspects),
@@ -364,11 +401,18 @@ function tweakAssocs( model ) {
     // same (TODO later: set status whether rewrite changes anything),
     // especially problematic are refs starting with $self:
     setExpandStatus( elem, 'target' );
+
+    // There were previous issues in resolving the target artifact.
+    // Avoid further compiler messages.
+    if (!elem.target._artifact)
+      return;
+
     if (elem._parent?.kind === 'element') {
       // managed association as sub element not supported yet
       // TODO: Only report once for multi-include chains, see
       //       Associations/SubElements/UnmanagedInSubElement.err.cds
       error( 'type-unsupported-rewrite', [ elem.location, elem ], { '#': 'sub-element' } );
+      removeArtifactLinks();
       return;
     }
     const nav = (elem._main?.query && elem.value)
@@ -380,31 +424,45 @@ function tweakAssocs( model ) {
     elem.on.$inferred = 'copy';
 
     const { navigation } = nav;
-    if (!navigation) // TODO: what about $projection.assoc as myAssoc ?
+    if (!navigation) { // TODO: what about $projection.assoc as myAssoc ?
+      if (elem._columnParent) {
+        error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
+        removeArtifactLinks();
+      }
       return;                 // should not happen: $projection, $magic, or ref to const
-
-    // Currently, having an unmanaged association inside a struct is not
-    // supported by this function:
-    if (navigation !== assoc && navigation._origin !== assoc) { // TODO: re-check
-      // For "assoc1.assoc2" and "struct.elem1.assoc2"
-      if (elem._redirected !== null) // null = already reported
-        error( 'rewrite-not-supported', [ elem.target.location, elem ] );
     }
-    else if (!nav.tableAlias || nav.tableAlias.path) {
+
+    if (!nav.tableAlias || nav.tableAlias.path) {
+      const navEnv = followNavigationPath( elem.value?.path, nav ) || nav.tableAlias;
       traverseExpr( elem.on, 'rewrite-on', elem,
-                    expr => rewriteExpr( expr, elem, nav.tableAlias ) );
+                    expr => rewriteExpr( expr, elem, nav.tableAlias, navEnv ) );
     }
-    else if (elem._pathHead) {
-      error( 'rewrite-not-supported', [ elem.target.location, elem ] );
+    else if (elem._columnParent) {
+      error( 'rewrite-not-supported', [ elem.target.location, elem ], { '#': 'inline-expand' } );
+      removeArtifactLinks();
+      return;
     }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
+      removeArtifactLinks();
+      return;
     }
 
     addConditionFromAssocPublishing( elem, assoc, nav );
     elem.on.$inferred = 'rewrite';
+
+    /**
+     * Clear all `_artifact` links in the ON-condition to avoid follow-up
+     * issues during ON-condition rewriting of associations that inherit
+     * the ON-condition.
+     */
+    function removeArtifactLinks() {
+      traverseExpr( elem.on, 'rewrite-on', elem, (expr) => {
+        setArtifactLink( expr, null );
+      } );
+    }
   }
 
   /**
@@ -495,6 +553,7 @@ function tweakAssocs( model ) {
   function filterToCondition( assocPathStep, elem, nav ) {
     const cond = copyExpr( assocPathStep.where );
     cond.$parens = [ assocPathStep.location ];
+    const navEnv = nav && followNavigationPath( elem.value?.path, nav ) || nav?.tableAlias;
     traverseExpr( cond, 'rewrite-filter', elem, (expr) => {
       if (!expr.path || expr.path.length === 0)
         return;
@@ -518,7 +577,7 @@ function tweakAssocs( model ) {
           setLink( expr.path[0], '_navigation', assocPathStep._navigation );
         }
         // up to here, filter is relative to original association
-        rewriteExpr( expr, elem, nav?.tableAlias );
+        rewriteExpr( expr, elem, nav?.tableAlias, navEnv );
       }
     } );
 
@@ -528,7 +587,7 @@ function tweakAssocs( model ) {
 
   // Caller must ensure ON-condition correctness via rewriteExpr()!
   function foreignKeysToOnCondition( elem, assoc, nav ) {
-    if (model.options.testMode && !nav.tableAlias && !elem._pathHead && elem.$syntax !== 'calc')
+    if (model.options.testMode && !nav.tableAlias && !elem._columnParent && elem.$syntax !== 'calc')
       throw new CompilerAssertion('rewriting keys to cond: no tableAlias but not inline/calc');
 
     if ((!nav.tableAlias && elem.$syntax !== 'calc') || elem._parent?.kind === 'element' ||
@@ -571,8 +630,11 @@ function tweakAssocs( model ) {
       setLink( rhs.path[0], '_artifact', assoc );
       setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1]._artifact );
 
-      if (elem.$syntax !== 'calc') { // different to lhs!
-        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, elem );
+      if (elem.$syntax !== 'calc') {
+        // Not passing an element, as we don't want to use our own filtered association here!
+        // That's done for lhs.
+        const projectedFk = firstProjectionForPath( rhs.path, 0, nav.tableAlias, null );
+        // different to lhs!
         rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
       }
 
@@ -607,33 +669,33 @@ function tweakAssocs( model ) {
     return cond;
   }
 
-  function rewriteExpr( expr, assoc, tableAlias ) {
+  /**
+   * @param expr
+   * @param assoc
+   * @param tableAlias
+   * @param navEnv Navigation element / table alias, used to traverse/rewrite the path.
+   */
+  function rewriteExpr( expr, assoc, tableAlias, navEnv = tableAlias ) {
     // Rewrite ON condition (resulting in outside perspective) for association
     // 'assoc' in query or including entity from ON cond of mixin element /
     // element in included structure / element in source ref/d by table alias.
 
     // TODO: complain about $self (unclear semantics)
-    // console.log( info(null, [assoc.name.location, assoc],
-    //       { art: expr._artifact, names: expr.path.map(i=>i.id) }, 'A').toString(), expr.path)
 
     if (!expr.path || !expr._artifact)
       return;
     if (!assoc._main)
       return;
-    if (tableAlias) { // from ON cond of element in source ref/d by table alias
-      const source = tableAlias._origin;
+    if (navEnv) { // from ON cond of element in source ref/d by table alias
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
-      if (!root || root._main !== source)
-        return;                 // not $self or source element
+      if (!root || root.kind === 'builtin')
+        return; // not $self or source element, e.g. builtin
+
+      // parameters are not allowed in ON-conditions; error emitted elsewhere already
       if (expr.scope === 'param' || root.kind === '$parameters')
-        return;                 // are not allowed anyway - there was an error before
-      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;
+        return;
 
-      rewritePath( expr, result.item, assoc, result.elem, assoc.value.location );
+      rewritePathForEnv( expr, navEnv, assoc );
     }
     else if (assoc._main.query) { // from ON cond of mixin element in query
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
@@ -641,15 +703,16 @@ function tweakAssocs( model ) {
         if (assoc.$errorReported !== 'assoc-unexpected-scope') {
           error( 'assoc-unexpected-scope', [ assoc.value.location, assoc ],
                  { id: assoc.value._artifact.name.id },
-                 // eslint-disable-next-line max-len
+                 // eslint-disable-next-line @stylistic/js/max-len
                  'Association $(ID) can\'t be projected because its ON-condition refers to a parameter' );
           assoc.$errorReported = 'assoc-unexpected-scope';
         }
         return;
       }
-      const nav = pathNavigation( expr );
-      if (nav.navigation || nav.tableAlias) { // rewrite src elem, mixin, $self[.elem]
+      if (expr.path[0]._navigation) { // rewrite src elem, mixin, $self[.elem]
+        const nav = pathNavigation( expr );
         const elem = (assoc._origin === root) ? assoc : navProjection( nav.navigation, assoc );
+        // TODO: Use rewritePathForEnv(); make it handle mixins
         rewritePath( expr, nav.item, assoc, elem,
                      nav.item ? nav.item.location : expr.path[0].location );
       }
@@ -673,11 +736,11 @@ function tweakAssocs( model ) {
       if (!(elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {
         const art = assoc._origin;
-        // eslint-disable-next-line max-len
+        // eslint-disable-next-line @stylistic/js/max-len
         warning( 'rewrite-shadowed', [ elem.name.location, elem ], { art: art && effectiveType( art ) }, {
-          // eslint-disable-next-line max-len
+          // eslint-disable-next-line @stylistic/js/max-len
           std: 'This element is not originally referred to in the ON-condition of association $(ART)',
-          // eslint-disable-next-line max-len
+          // eslint-disable-next-line @stylistic/js/max-len
           element: 'This element is not originally referred to in the ON-condition of association $(MEMBER) of $(ART)',
         } );
       }
@@ -685,17 +748,147 @@ function tweakAssocs( model ) {
     }
   }
 
+  /**
+   * Rewrite the given reference by using projected elements of the given
+   * navigation environment.
+   *
+   * @param {XSN.Expression} ref
+   * @param {object} navEnv
+   * @param {XSN.Artifact} user
+   */
+  function rewritePathForEnv( ref, navEnv, user ) {
+    // TODO: combine with rewriteGenericAnnoPath() of xpr-rewrite
+
+    // reset artifact link; we'll set it again if there are no errors
+    setArtifactLink( ref, null );
+
+    const rootItem = ref.path[0];
+    const root = ref.path[0]._navigation || ref.path[0]._artifact;
+    const startIndex = (root.kind === '$self' ? 1 : 0);
+
+    if (root.kind === '$self') {
+      let rootEnv = navEnv;
+      while (rootEnv?.kind === '$navElement') {
+        if (rootEnv._origin?.target?._artifact === root._origin)
+          break;
+        rootEnv = rootEnv._parent;
+      }
+      navEnv = rootEnv;
+    }
+
+    // Store the original artifact, so that we can use it to
+    // calculate a redirection chain later on.
+    ref.path.forEach((item) => {
+      if (item._artifact)
+        setLink( item, '_originalArtifact', item._artifact );
+    });
+
+    let env = navEnv;
+    let art = rootItem._artifact;
+    let isTargetSide = null;
+
+    for (let i = startIndex; i < ref.path.length; ++i) {
+      if (i > startIndex && art.target) {
+        // if the current artifact is an association, we need to respect the redirection
+        // chain from original target to new one.
+        // FIXME: Won't work with associations in projected structures.
+        const origTarget = ref.path[i - 1]?._originalArtifact?.target?._artifact;
+        const chain = cachedRedirectionChain( art, origTarget );
+        if (!chain) {
+          missingProjection( ref, i, user, false );
+          return;
+        }
+        for (const alias of chain) {
+          art = rewritePathItemForEnv( ref, alias, i, user );
+          isTargetSide ??= (art === user);
+          if (!art) {
+            missingProjection( ref, i, user, isTargetSide );
+            return;
+          }
+        }
+      }
+
+      art = rewritePathItemForEnv( ref, env, i, user );
+      isTargetSide ??= (art === user);
+      if (!art) {
+        missingProjection( ref, i, user, isTargetSide );
+        return;
+      }
+      env = navigationEnv( art, null, null, 'nav' );
+    }
+    setArtifactLink( ref, art );
+
+    if (startIndex === 0 && rootItem.id.startsWith('$')) {
+      // TODO: What about filters? Also rewritten there?
+      // After rewriting, if an element starts with `$` -> add root prefix
+      // FIXME: "user" not correct for association inside sub-element,
+      //        because `user._parent` is assumed to be the query
+      prependSelfToPath( ref.path, user );
+    }
+  }
+
+  function rewritePathItemForEnv( ref, navEnv, index, user ) {
+    const rewriteTarget = findRewriteTarget( ref, index, navEnv, user );
+    const found = rewriteTarget[0];
+    if (!found) {
+      setArtifactLink( ref.path[index], found );
+      return found;
+    }
+
+    if (rewriteTarget[1] > index) {
+      // we keep the last segment, in case it has non-enumerable properties
+      ref.path[index] = ref.path[rewriteTarget[1]];
+      ref.path.splice(index + 1, rewriteTarget[1] - index);
+    }
+
+    const item = ref.path[index];
+    if (item.id !== found.name.id || (rewriteTarget[1] - index) !== 0)
+      item.id = found.name.id;
+
+    return setArtifactLink( ref.path[index], found );
+  }
+
+  /**
+   * @param {XSN.Path} ref
+   * @param {number} index
+   * @param {XSN.Artifact} user
+   * @param {boolean} isTargetSide
+   */
+  function missingProjection( ref, index, user, isTargetSide ) {
+    const item = ref.path[index];
+    if (!isTargetSide) {
+      const { location } = user.value;
+      const rootItem = ref.path[0];
+      const elemref = rootItem._navigation?.kind === '$self' ? ref.path.slice(1) : ref.path;
+      // TODO: Fix message for sub-elements: `s: { a: Association on x=1, x: Integer};` for x
+      error( 'rewrite-not-projected', [ location, user ], {
+        name: user.name.id,
+        art: item._artifact || item._originalArtifact,
+        elemref: { ref: elemref },
+      } );
+    }
+    else {
+      const isExplicit = user.target && !user.target.$inferred;
+      const loc = isExplicit ? user.target.location : item.location;
+      error( 'query-undefined-element', [ loc, user ], {
+        '#': isExplicit ? 'redirected' : 'std',
+        id: item.id,
+        name: user.name.id,
+        target: user.target._artifact,
+        keyword: 'redirected to',
+      } );
+    }
+  }
+
   function rewritePath( ref, item, assoc, elem, location ) {
     const { path } = ref;
     const root = path[0];
     if (!elem) {
       if (location) {
         const elemref = root._navigation?.kind === '$self' ? path.slice(1) : path;
+        // TODO: Fix message for sub-elements: `s: { a: Association on x=1, x: Integer};` for x
         error( 'rewrite-not-projected', [ location, assoc ], {
-          name: assoc.name.id, art: item._artifact, elemref: { ref: elemref },
-        }, {
-          std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
-          element: 'Projected association $(NAME) uses non-projected element $(ELEMREF) of $(ART)',
+          name: assoc.name.id, art: elemref[0]._artifact, elemref: { ref: elemref },
         } );
       }
       delete root._navigation;
@@ -729,14 +922,11 @@ function tweakAssocs( model ) {
         if (i === item)
           state = setArtifactLink( i, elem );
       }
-      else if (i) {
-        state = rewriteItem( state, i, i.id, assoc, false );
+      else {
+        state = rewriteItem( state, i, assoc );
         if (!state || state === true)
           break;
       }
-      else {
-        return;
-      }
     }
     if (state !== true)
       setArtifactLink( ref, state );
@@ -749,9 +939,15 @@ function tweakAssocs( model ) {
     path.unshift( root );
   }
 
-  function rewriteItem( elem, item, name, assoc, forKeys ) {
+  /**
+   * @param elem "Navigation environment" (element) for `item`.
+   * @param item Path segment to rewrite.
+   * @param assoc Published association of query.
+   */
+  function rewriteItem( elem, item, assoc ) {
     if (!elem._redirected)
       return true;
+    let name = item.id;
     for (const alias of elem._redirected) {
       // TODO: a message for the same situation as msg 'rewrite-shadowed'?
       if (alias.kind === '$tableAlias') { // _redirected also contains structures for includes
@@ -760,21 +956,8 @@ function tweakAssocs( model ) {
         // but its origins, too.
         const proj = navProjection( alias.elements[name], assoc );
         name = proj?.name?.id;
-        if (!name) {
-          if (!forKeys)
-            break;
-          setArtifactLink( item, null );
-          const culprit = elem.target && !elem.target.$inferred && elem.target ||
-                          elem.value?.path?.[elem.value.path.length - 1] ||
-                          elem;
-          // TODO: probably better to collect the non-projected foreign keys
-          // and have one message for all
-          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), assoc ], {
-            '#': 'std', id: item.id, target: alias._main, name: assoc.name.id,
-          });
-          // ''
-          return null;
-        }
+        if (!name)
+          break;
         item.id = name;
         // TODO: Why not break here? Test test3/scenarios/AFC/db/view/consumption/C_ScopedRole.cds
       }
@@ -798,20 +981,98 @@ function tweakAssocs( model ) {
     } );
     return null;
   }
+
+  /**
+   * Get the redirection chain between the element's target and the original target.
+   * Returns `null` if there is no valid chain.
+   * Uses `_redirected` if valid.
+   *
+   * @param {XSN.Artifact} elem
+   * @param {XSN.Artifact} origTarget
+   * @returns {null|XSN.Artifact[]}
+   */
+  function cachedRedirectionChain( elem, origTarget ) {
+    const target = elem.target?._artifact;
+    if (!target || !origTarget)
+      return null;
+    if (target === origTarget)
+      return [];
+
+    if (elem._redirected === null) {
+      // means: "don't touch paths after assoc"
+      // TODO: figure out if we can assume that here as well
+      return [];
+    }
+
+    if (elem._redirected) {
+      // No need to recalculate if the original target is already in '_redirected'.
+      const i = elem._redirected.findIndex(ta => ta._origin === origTarget);
+      if (i > -1)
+        return elem._redirected.slice(i); // TODO: check if it is always "i===0".
+    }
+
+    return redirectionChain( elem, target, origTarget, true );
+  }
 }
 
 function navProjection( navigation, preferred ) {
   // TODO: Info if more than one possibility?
-  // console.log(navigation,navigation._projections)
   if (!navigation)
     return {};
-  else if (!navigation._projections)
+
+  if (!navigation._projections && !navigation._complexProjections)
     return null;
-  return (preferred && navigation._projections.includes( preferred ))
-    ? preferred
-    : navigation._projections[0] || null;
+
+  // _complexProjections contains projections that are not "simple",
+  // i.e. contain a filter or arguments. Only used if it contains our
+  // preferred association.
+  if (preferred && ( navigation._complexProjections?.includes( preferred ) ||
+    navigation._projections?.includes( preferred )))
+    return preferred;
+
+  return navigation._projections?.[0] || null;
 }
 
+function findRewriteTarget( expr, index, env, user ) {
+  if (env.kind === '$navElement' || env.kind === '$tableAlias') {
+    const r = firstProjectionForPath( expr.path, index, env, user );
+    return [ r.elem, r.index ];
+  }
+
+  const item = expr.path[index];
+  // If the artifact is already in the same definition, we must not check the query.
+  // Or if it is not a query -> no $navElement -> use `elements`
+  if (item._artifact?._main === env || !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 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 = (user._main?._origin === item._artifact?._main &&
+    user.value?.path[0]?._navigation?.kind === '$tableAlias')
+    ? user.value.path[0]._navigation : null;
+
+  // Look at all table aliase that could project `item` and only select
+  // those that have actual projections.
+  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, user );
+    if (r.elem)
+      return [ r.elem, r.index ];
+  }
+
+  return [ null, expr.path.length ];
+}
 
 /**
  * For a path `a.b.c.d`, return a projection for the first path item that is projected,
@@ -824,6 +1085,9 @@ function navProjection( navigation, preferred ) {
  * 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.
  *
+ * If nothing was found, `ret.elem` is null, and `ret.item` is the last segment for which
+ * there was a $navElement.
+ *
  * @param {any[]} path
  * @param {number} startIndex
  * @param {object} nav
@@ -844,32 +1108,72 @@ function firstProjectionForPath( path, startIndex, nav, elem ) {
 
   let proj = null;
   let navItem = nav;
-  for (let i = startIndex; i < path.length; ++i) {
-    const item = path[i];
+  let navIndex = startIndex;
+  for (; navIndex < path.length; ++navIndex) {
+    const item = path[navIndex];
     navItem = item?.id && navItem.elements?.[item.id];
     if (!navItem) {
       break;
     }
-    else if (navItem._projections) {
+    else if (navItem._projections || navItem._complexProjections) {
       const projElem = navProjection( navItem, elem );
       if (projElem && projElem === elem) {
         // in case the specified association is found, _always_ use it.
-        return { index: i, item, elem };
+        return { index: navIndex, item, elem };
       }
       else if (projElem) {
         const queryIndex = selectedElements.indexOf(projElem);
         if (!proj || queryIndex < proj.queryIndex) {
           proj = {
-            index: i, item, elem: projElem, queryIndex,
+            index: navIndex, item, elem: projElem, queryIndex,
           };
         }
       }
     }
   }
+  if (proj)
+    return proj;
 
-  return proj || { index: startIndex, item: path[startIndex], elem: null };
+  const index = (navIndex - 1) <= startIndex ? startIndex : (navIndex - 1);
+  return { index, item: path[index], elem: null };
 }
 
+/**
+ * Follow the navigation along the given path to its N-1 path step, so
+ * that the last step can be resolved against the returned navigation like
+ * `returnValue.elements[last.id]`.
+ *
+ * @param {XSN.Path} path
+ * @param {object} nav
+ * @returns {object|null}
+ */
+function followNavigationPath( path, nav ) {
+  if (!nav.item || !path || path.length === 1)
+    return nav.tableAlias;
+
+  const startIndex = path.indexOf(nav.item);
+  if (startIndex === -1)
+    return null;
+
+  // navigation is already at last path step
+  if (startIndex === path.length - 1) {
+    return nav.navigation?.kind === '$navElement'
+      ? nav.navigation._parent
+      : nav.tableAlias;
+  }
+
+  let navItem = nav.navigation || nav.tableAlias;
+  for (let i = startIndex + 1; i < path.length - 1; ++i) {
+    const item = path[i];
+    navItem = item?.id && navItem.elements?.[item.id];
+    if (!navItem)
+      return null;
+  }
+
+  return navItem;
+}
+
+
 /**
  * Return condensed info about reference in select item
  * - tableAlias.elem       -> { navigation: navElem, item: path[1], tableAlias }