@sap/cds-compiler 4.1.2 → 4.2.4

package/lib/compiler/shared.js

@@ -20,8 +20,8 @@ const {
   artifactRefLocation,
 } = require('./utils');
 
-const $inferred = Symbol.for('cds.$inferred');
-const $location = Symbol.for('cds.$location');
+const $inferred = Symbol.for( 'cds.$inferred' );
+const $location = Symbol.for( 'cds.$location' );
 
 /**
  * Main export function of this file.  Attach "resolve" functions shared for phase
@@ -61,6 +61,7 @@ function fns( model ) {
       lexical: userBlock,
       dynamic: modelDefinitions,
       notFound: undefinedDefinition,
+      accept: acceptRealArtifact,
     },
     _extensions: {
       isMainRef: 'all',
@@ -153,9 +154,17 @@ function fns( model ) {
       notFound: undefinedVariable,
       param: paramUnsupported,
     },
+    'limit-rows': {
+      lexical: null,
+      dollar: true,
+      dynamic: () => Object.create( null ),
+      notFound: undefinedVariable,
+      param: paramSemantics,
+    },
+    'limit-offset': 'limit-rows',
     // general element references -----------------------------------------------
     where: {
-      lexical: tableAliasesIfNotExtendAndSelf,
+      lexical: tableAliasesAndSelf,
       dollar: true,
       dynamic: combinedSourcesOrParentElements,
       notFound: undefinedSourceElement,
@@ -198,7 +207,8 @@ function fns( model ) {
     'join-on': {
       lexical: tableAliasesAndSelf,
       dollar: true,
-      dynamic: combinedSourcesOrParentElements, // TODO: source alone...
+      dynamic: combinedSourcesOrParentElements,
+      rejectRoot: rejectOwnExceptVisibleAliases,
       notFound: undefinedSourceElement,
       param: paramSemantics,
     },
@@ -249,6 +259,7 @@ function fns( model ) {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
       dollar: true,
       dynamic: queryElements,
+      rejectRoot: rejectOwnAliasesAndMixins,
       notFound: undefinedParentElement,
       check: checkOrderByRef,
       param: paramSemantics,
@@ -257,6 +268,7 @@ function fns( model ) {
       lexical: tableAliasesAndSelf, // TODO: reject own tab aliases
       dollar: true,
       dynamic: () => Object.create( null ),
+      rejectRoot: rejectAllOwn,
       notFound: undefinedVariable,
       check: checkRefInQuery,
       param: paramSemantics,
@@ -290,7 +302,7 @@ function fns( model ) {
     }
 
     if (expr.args) {
-      const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
+      const args = Array.isArray( expr.args ) ? expr.args : Object.values( expr.args );
       // TODO: re-think $expected
       if (!callback.traverse?.( args, exprCtx, user, callback ))
         args.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
@@ -326,10 +338,12 @@ function fns( model ) {
     return `${ art.name.absolute }.${ pathName( ref.path.slice(1) ) }`;
   }
 
-  // Return artifact or element referred by the path in `ref`.  The first
-  // environment we search in is `env`.  If no such artifact or element exist,
-  // complain with message and return `undefined`.  Record a dependency from
-  // `user` to the found artifact if `user` is provided.
+  /**
+   * Return artifact or element referred by the path in `ref`.  The first
+   * environment we search in is `env`.  If no such artifact or element exist,
+   * complain with message and return `undefined`.  Record a dependency from
+   * `user` to the found artifact if `user` is provided.
+   */
   function resolvePath( ref, expected, user ) {
     const origUser = user;
     user = user._user || user;
@@ -348,7 +362,7 @@ function fns( model ) {
     const semantics = (typeof s === 'string') ? referenceSemantics[s] : s;
 
     const r = getPathRoot( ref, semantics, origUser );
-    const root = r && acceptPathRoot( r, ref, semantics, user );
+    const root = r && acceptPathRoot( r, ref, semantics, origUser );
     if (!root)
       return setArtifactLink( ref, root );
 
@@ -373,7 +387,7 @@ function fns( model ) {
           dependsOn( user._main, target, location, user );
       }
       else if (art._main && art.kind !== 'select' || path[0]._navigation?.kind !== '$self') {
-        // no real dependency to bare $self (or actually: the underlaying query)
+        // no real dependency to bare $self (or actually: the underlying query)
         dependsOn( user, art, location );
         // Without on-demand resolve, we can simply signal 'undefined "x"'
       // instead of 'illegal cycle' in the following case:
@@ -415,7 +429,7 @@ function fns( model ) {
         if (!artifact[par] && i < args.length)
           artifact[par] = args[i];
       }
-      args = args.slice(parameters.length);
+      args = args.slice( parameters.length );
     }
     else if (args.length > 0 && !typeArtifact?.builtin) {
       // One or two arguments are interpreted as either length or precision/scale.
@@ -480,7 +494,7 @@ function fns( model ) {
         : [ '_$next', '$tableAliases' ];
       // let notApplicable = ...;  // for table aliases in JOIN-ON and UNION orderBy
       for (let env = lexical; env; env = env[nextProp]) {
-        const dict = env[dictProp] || Object.create(null);
+        const dict = env[dictProp] || Object.create( null );
         const r = dict[head.id];
         if (acceptLexical( r, path, semantics, user ))
           return setArtifactLink( head, r );
@@ -542,7 +556,7 @@ function fns( model ) {
       // TOOD: call envFn with location of last item (for dependency error)
       const env = envFn( art, path[index - 1].location, user );
       const found = env && env[item.id];  // not env?.[item.id] ! …we want to keep the 0
-      // Reject `$self.$_column_1`:
+      // Reject `$self.$_column_1`: TODO: necessary to do here again?
       art = setArtifactLink( item, (found?.name?.$inferred === '$internal') ? undefined : found );
 
       if (!art) {
@@ -579,14 +593,13 @@ function fns( model ) {
     // Non-global lexical are table aliases, mixins and $self, $projection, $parameters,
     // Do not accept a lonely table alias and `$projection`
     // TODO: test table alias and mixin named `$projection`
-    if (path.length === 1 && !user.expand && !user.inline) { // accept lonely…
-      // allow mixins, and `up_` in anonymous target aspect:
-      if (art.kind !== '$self' || path[0].id !== '$self')
-        return art.kind === 'mixin' || art.kind === '$navElement';
-      return true;
-    }
-    // return !art.$internal && art;
-    return art.name?.$inferred !== '$internal'; // not a compiler-generated internal alias
+    if (path.length !== 1 || user.expand || user.inline)
+      return art.name?.$inferred !== '$internal'; // not a compiler-generated internal alias
+
+    // allow mixins, $self, and `up_` in anonymous target aspect (is $navElement):
+    return art.kind === 'mixin' ||
+      art.kind === '$self' && path[0].id === '$self' ||
+      art.kind === '$navElement';
   }
 
   function acceptPathRoot( art, ref, semantics, user ) {
@@ -594,6 +607,9 @@ function fns( model ) {
     const [ head ] = path;
     if (Array.isArray( art ))
       return getAmbiguousRefLink( art, head, user );
+    if (semantics.rejectRoot?.( art, user, ref, semantics ))
+      return null;
+
     switch (art.kind) {
       case 'using': {
         const def = model.definitions[art.name.absolute];
@@ -607,8 +623,8 @@ function fns( model ) {
         return setLink( head, '_navigation', art );
       }
       case '$navElement': {
-        if (head.id === user.$extended)
-          path.$prefix = user.$extended;
+        if (head.id === (user._user || user).$extended)
+          path.$prefix = head.id;
         setLink( head, '_navigation', art );
         return setArtifactLink( head, art._origin );
       }
@@ -622,7 +638,7 @@ function fns( model ) {
         // that the corresponding entity should not be put as $origin into the CSN.
         // TODO: remove again, should be easy enough in to-csn without.
         if (path.length === 1 && art.kind === '$tableAlias')
-          user.$noOrigin = true;
+          (user._user || user).$noOrigin = true;
         return art;
       }
       case '$parameters': {     // TODO: remove from CC
@@ -644,14 +660,14 @@ function fns( model ) {
       return false;
     // only complain about ambiguous source elements if we do not have
     // duplicate table aliases, only mention non-ambiguous source elems
-    const uniqueNames = arr.filter( e => !e.$duplicates);
+    const uniqueNames = arr.filter( e => !e.$duplicates );
     if (uniqueNames.length) {
       const names = uniqueNames.filter( e => e._parent.$inferred !== '$internal' )
         .map( e => `${ e.name.alias }.${ e.name.element }` );
       let variant = names.length === uniqueNames.length ? 'std' : 'few';
       if (names.length === 0)
         variant = 'none';
-      error( 'ref-ambiguous', [ head.location, user ], { '#': variant, id: head.id, names });
+      error( 'ref-ambiguous', [ head.location, user ], { '#': variant, id: head.id, names } );
     }
     return false;
   }
@@ -693,7 +709,7 @@ function fns( model ) {
       return user._main || user;
     // query.$tableAliases contains both aliases and $self/$projection
     const aliases = query.$tableAliases;
-    const r = Object.create(null);
+    const r = Object.create( null );
     if (aliases.$self.kind === '$self')
       r.$self = aliases.$self;
     // TODO: disallow $projection for ON conditions all together
@@ -773,7 +789,7 @@ function fns( model ) {
   // default is function `environment`
 
   function artifactsEnv( art ) {
-    return art._subArtifacts || Object.create(null);
+    return art._subArtifacts || Object.create( null );
   }
 
   function staticTarget( prev ) {
@@ -787,7 +803,7 @@ function fns( model ) {
         return target.elements;
       env = resolvePath( env.targetAspect, 'targetAspect', env );
     }
-    return env?.elements || Object.create(null);
+    return env?.elements || Object.create( null );
   }
 
   function targetNavigation( art, location, user ) {
@@ -804,14 +820,14 @@ function fns( model ) {
     // This way (not here though, but later in resolve.js)
     if (env === 0)
       return 0;
-    return env?.elements || Object.create(null);
+    return env?.elements || Object.create( null );
   }
 
   function calcElemNavigation( art, location, user ) {
     const env = navigationEnv( art, location, user, 'calc' );
     if (env === 0)
       return 0;
-    return env?.elements || Object.create(null);
+    return env?.elements || Object.create( null );
   }
 
   // Return effective search environment provided by artifact `art`, i.e. the
@@ -825,7 +841,7 @@ function fns( model ) {
     const env = navigationEnv( art, location, user, 'nav' );
     if (env === 0)
       return 0;
-    return env?.elements || Object.create(null);
+    return env?.elements || Object.create( null );
   }
 
   function navigationEnv( art, location, user, assocSpec ) {
@@ -900,7 +916,7 @@ function fns( model ) {
     const isVar = id.charAt( 0 ) === '$' && id !== '$self';
     // TODO: for wrong $self, also use ref-undefined-var, but with extra msg id
     // otherwise, use s/th like ref-unexpected-element
-    signalNotFound( (isVar ? 'ref-undefined-var' : 'ref-expecting-const'),
+    signalNotFound( ( isVar ? 'ref-undefined-var' : 'ref-expecting-const'),
                     [ head.location, user ],
                     valid, { '#': 'std', id } );
     // TODO: use s/th better than 'ref-expecting-const' !!
@@ -949,7 +965,7 @@ function fns( model ) {
   function undefinedOrderByElement( user, head, valid, dynamicDict, _art, path ) {
     const { id } = head;
     const src = id.charAt( 0 ) !== '$' && user._combined?.[id];
-    if (src && !Array.isArray(src)) {
+    if (src && !Array.isArray( src )) {
       path.$prefix = src.name.alias; // pushing it to path directly could be problematic
       // configurable error:
       signalNotFound( 'ref-deprecated-orderby', [ head.location, user ], valid,
@@ -983,7 +999,7 @@ function fns( model ) {
       const id = (item === path[path.length - 1])
         ? item.id
         : pathName( path.slice( path.indexOf( item ) ) );
-      signalNotFound( (art.$uncheckedElements ? 'ref-unknown-var' : 'ref-undefined-var'),
+      signalNotFound( ( art.$uncheckedElements ? 'ref-unknown-var' : 'ref-undefined-var'),
                       [ item.location, user ], valid,
                       { id: `${ art.name.element }.${ id }` } );
     }
@@ -1003,6 +1019,56 @@ function fns( model ) {
   // function arguments ( art, user, ref, semantics ),
   // default (for elements only): acceptElemOrVar
 
+  function rejectOwnAliasesAndMixins( art, user, ref, semantics ) { // orderBy-set-ref
+    switch (art.kind) {
+      case '$tableAlias':
+      case 'mixin':
+        if (art._parent !== user)
+          return false;
+        break;
+      case '$self':
+        if (!semantics)         // orderBy-set-expr
+          break;
+        // FALLTHROUGH
+      default:
+        return false;
+    }
+    error( 'ref-invalid-element', [ ref.path[0].location, user._user ],
+           { '#': art.kind, id: art.name.id } );
+    return true;
+  }
+
+  function rejectAllOwn( art, user, ref ) { // orderBy-set-expr
+    return rejectOwnAliasesAndMixins( art, user, ref, null );
+  }
+
+  function rejectOwnExceptVisibleAliases( art, user, ref ) { // for join-on
+    switch (art.kind) {
+      case '$navElement':
+        art = art._parent;
+        // FALLTHROUGH
+      case '$tableAlias':
+      case 'mixin':
+        if (art._parent !== user._user || user.$tableAliases[art.name.id])
+          return false;
+        break;
+      case '$self':
+        // in the SQL backend, the $self.elem references are replaced by the
+        // corresponding column expression; this might have references to elements
+        // of invisible table aliases; at least one stakeholder uses this,
+        // so it can't be an error (yet).
+        warning( 'ref-deprecated-self-element', [ ref.path[0].location, user._user ], {},
+                 // eslint-disable-next-line max-len
+                 'Referring to the query\'s own elements here might lead to invalid SQL references; use source elements only' );
+        return false;
+      default:
+        return false;
+    }
+    error( 'ref-invalid-element', [ ref.path[0].location, user._user ],
+           { '#': art.kind, id: art.name.id } );
+    return true;
+  }
+
   function acceptElemOrVarOrSelf( art, user, ref ) {
     // TODO: make $self._artifact point to the $self alias, not the entity
     return (!(art._main && art.kind !== 'select') && ref.path[0]._navigation?.kind === '$self')
@@ -1020,7 +1086,7 @@ function fns( model ) {
       }
       else if (art.$requireElementAccess) { // on some CDS variables
         // Path with only one item, but we expect an element, e.g. `$at.from`.
-        signalMissingElementAccess(art, [ path[0].location, user ]);
+        signalMissingElementAccess( art, [ path[0].location, user ] );
         return null;
       }
       else if (art.$autoElement) {
@@ -1045,6 +1111,15 @@ function fns( model ) {
     return art;
   }
 
+  function acceptRealArtifact( art, user, ref ) {
+    // For compatibility, we accept `extend Unknown` without elements/actions/includes
+    if (art.kind !== 'namespace' || !(user.elements || user.actions || user.includes))
+      return art;
+    const { location } = ref.path[ref.path.length - 1];
+    signalNotFound( 'ref-undefined-def', [ location, user ], null, { art } );
+    return false;
+  }
+
   function acceptStructOrBare( art, user, ref ) { // for includes[]
     // It had been checked before that `includes` is already forbidden for
     // non-entity/aspect/type/event.
@@ -1069,9 +1144,11 @@ function fns( model ) {
       // Remark: it is not necessary to test for user.elements[$inferred], because
       // the type could only have inferred elements if it has a type expression.
       // Including aspects with elements is forbidden for aspects without the
-      // `elements` property (TODO: ensure that, see #11346).  Testing for the length of
-      // `art.elements` requires that we have applied potential `includes` of
-      // `art` before!
+      // `elements` property.  Testing for the length of `art.elements` requires
+      // that we have applied potential `includes` of `art` before!
+      // We might allow includes with elements in the future, they'd probably
+      // count as specified elements with lower priority, i.e. annos, types, key
+      // etc on columns beat those inherited from the include.
       if (art.kind === 'aspect' &&
           (!art.elements || base.query && !Object.keys( art.elements ).length))
         return art;
@@ -1482,10 +1559,10 @@ function fns( model ) {
     const err = message( 'ref-expected-element', location,
                          { '#': 'magicVar', id: art.name.id } );
     // Mapping for better valid names: from -> $at.from
-    const valid = Object.keys(art.elements || {}).reduce((prev, curr) => {
+    const valid = Object.keys( art.elements || {} ).reduce( (prev, curr) => {
       prev[`${ art.name.id }.${ curr }`] = true;
       return prev;
-    }, Object.create(null));
+    }, Object.create( null ) );
     attachAndEmitValidNames( err, valid );
   }
 
@@ -1508,14 +1585,14 @@ function fns( model ) {
       // ignore internal types such as cds.Association, ignore names with dot for
       // CDL references to main artifacts:
       if (!art.internal && !art.deprecated && art.name?.$inferred !== '$internal' &&
-          (viaCdl ? art._main || !name.includes('.') : art.kind !== 'namespace'))
+          (viaCdl ? art._main || !name.includes( '.' ) : art.kind !== 'namespace'))
         msg.validNames[name] = art;
     }
 
     if (options.testMode && !options.$recompile) {
       // no semantic location => either first of [loc, semantic loc] pair or just location.
       const loc = msg.$location[0] || msg.$location;
-      const names = Object.keys(msg.validNames);
+      const names = Object.keys( msg.validNames );
       names.sort();
       if (names.length > 22) {
         names.length = 20;
@@ -1523,7 +1600,7 @@ function fns( model ) {
       }
       info( null, [ loc, null ],
             { '#': !names.length ? 'zero' : 'std' },
-            { std: `Valid: ${ names.join(', ') }`, zero: 'No valid names' });
+            { std: `Valid: ${ names.join( ', ' ) }`, zero: 'No valid names' } );
     }
   }
 }

package/lib/compiler/tweak-assocs.js

@@ -22,8 +22,8 @@ const {
 } = require('./utils');
 const { CsnLocation } = require('./classes');
 
-const $location = Symbol.for('cds.$location');
-const $inferred = Symbol.for('cds.$inferred');
+const $location = Symbol.for( 'cds.$location' );
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 // Export function of this file.
 function tweakAssocs( model ) {
@@ -118,7 +118,7 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociationCheck( element ) {
-    const elem = element.items || element; // TODO v2: nested items
+    const elem = element.items || element; // TODO v5: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociationCheck );
     if (!elem.target)
@@ -201,7 +201,7 @@ function tweakAssocs( model ) {
   }
 
   function assocWithExplicitSpec( assoc ) {
-    while (assoc.foreignKeys && inferredForeignKeys( assoc.foreignKeys, 'keys') ||
+    while (assoc.foreignKeys && inferredForeignKeys( assoc.foreignKeys, 'keys' ) ||
            assoc.on && assoc.on.$inferred)
       assoc = getOrigin( assoc );
     return assoc;
@@ -264,7 +264,7 @@ function tweakAssocs( model ) {
       fk.$inferred = 'rewrite'; // Override existing value; TODO: other $inferred value?
       // TODO: re-check for case that foreign key is managed association
       if (orig._effectiveType !== undefined)
-        setLink( fk, '_effectiveType', orig._effectiveType);
+        setLink( fk, '_effectiveType', orig._effectiveType );
       const te = copyExpr( orig.targetElement, elem.location );
       if (elem._redirected) {
         const i = te.path[0];   // TODO: or also follow path like for ON?
@@ -273,7 +273,7 @@ function tweakAssocs( model ) {
           setArtifactLink( te, state );
       }
       fk.targetElement = te;
-    });
+    } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
   }
@@ -288,14 +288,14 @@ function tweakAssocs( model ) {
     // same (TODO later: set status whether rewrite changes anything),
     // especially problematic are refs starting with $self:
     setExpandStatus( elem, 'target' );
-    if (elem._parent && elem._parent.kind === 'element') {
+    if (elem._parent?.kind === 'element') {
       // managed association as sub element not supported yet
       error( null, [ elem.location, elem ], {},
         // eslint-disable-next-line max-len
              'Rewriting the ON-condition of unmanaged association in sub element is not supported' );
       return;
     }
-    const nav = (elem._main && elem._main.query && elem.value)
+    const nav = (elem._main?.query && elem.value)
       ? pathNavigation( elem.value ) // redirected source elem or mixin
       : { navigation: assoc };       // redirected user-provided
     const cond = copyExpr( assoc.on,
@@ -347,15 +347,13 @@ function tweakAssocs( model ) {
     if (tableAlias) { // from ON cond of element in source ref/d by table alias
       const source = tableAlias._origin;
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
-      // console.log( info(null, [assoc.name.location, assoc],
-      //                   { names: expr.path.map(i=>i.id), art: root }, 'TA').toString())
+      // console.log( info(null, [ assoc.name.location, assoc ],
+      //                   { names: expr.path.map(i => i.id), art: root }, 'TA').toString());
       if (!root || root._main !== source)
         return;                 // not $self or source element
       if (expr.scope === 'param' || root.kind === '$parameters')
         return;                 // are not allowed anyway - there was an error before
-      const item = expr.path[root.kind === '$self' ? 1 : 0];
-      // console.log('YE', assoc.name, item, root.name, expr.path)
-      const elem = navProjection( item && tableAlias.elements[item.id], assoc );
+      const { item, elem } = firstProjectionForPath( expr.path, tableAlias, assoc );
       rewritePath( expr, item, assoc, elem, assoc.value.location );
     }
     else if (assoc._main.query) { // from ON cond of mixin element in query
@@ -386,7 +384,7 @@ function tweakAssocs( model ) {
         return;                                   // just $self
       // corresponding elem in including structure
       const elem = (assoc._main.items || assoc._main).elements[item.id];
-      if (!(Array.isArray(elem) ||              // no msg for redefs
+      if (!(Array.isArray( elem ) ||            // no msg for redefs
             elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {
         const art = assoc._origin;
@@ -399,7 +397,7 @@ function tweakAssocs( model ) {
                    element: 'This element is not originally referred to in the ON-condition of association $(MEMBER) of $(ART)',
                  } );
       }
-      rewritePath( expr, item, assoc, (Array.isArray(elem) ? false : elem), null );
+      rewritePath( expr, item, assoc, (Array.isArray( elem ) ? false : elem), null );
     }
   }
 
@@ -408,13 +406,12 @@ function tweakAssocs( model ) {
     let root = path[0];
     if (!elem) {
       if (location) {
-        error( 'rewrite-not-projected', [ location, assoc ],
-               { name: assoc.name.id, art: item._artifact }, {
-                 // eslint-disable-next-line max-len
-                 std: 'Projected association $(NAME) uses non-projected element $(ART)',
-                 // eslint-disable-next-line max-len
-                 element: 'Projected association $(NAME) uses non-projected element $(MEMBER) of $(ART)',
-               } );
+        error( 'rewrite-not-projected', [ location, assoc ], {
+          name: assoc.name.id, art: item._artifact, elemref: { ref: path },
+        }, {
+          std: 'Projected association $(NAME) uses non-projected element $(ELEMREF)',
+          element: 'Projected association $(NAME) uses non-projected element $(MEMBER) of $(ART)',
+        } );
       }
       delete root._navigation;
       setArtifactLink( root, elem );
@@ -422,9 +419,15 @@ function tweakAssocs( model ) {
       return;
     }
     if (item !== root) {
+      // e.g. mixin ON-condition: Base.foo -> $self.foo or multi-path projection,
+      // $projection -> $self
       root.id = '$self';
       setLink( root, '_navigation', assoc._parent.$tableAliases.$self );
       setArtifactLink( root, assoc._parent );
+      if (item) {
+        const i = path.indexOf(item);
+        ref.path = [ root, ...path.slice( i, path.length ) ];
+      }
     }
     else if (elem.name.id.charAt(0) === '$') {
       root = { id: '$self', location: item.location };
@@ -470,14 +473,13 @@ function tweakAssocs( model ) {
         // consider intermediate "preferred" elements - not just `assoc`,
         // but its origins, too.
         const proj = navProjection( alias.elements[name], assoc );
-        name = proj && proj.name && proj.name.id;
+        name = proj?.name?.id;
         if (!name) {
           if (!forKeys)
             break;
           setArtifactLink( item, null );
           const culprit = elem.target && !elem.target.$inferred && elem.target ||
-                          (elem.value && elem.value.path &&
-                           elem.value.path[elem.value.path.length - 1]) ||
+                          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
@@ -495,7 +497,7 @@ function tweakAssocs( model ) {
       env = env.target._artifact?._effectiveType;
     elem = setArtifactLink( item, env?.elements?.[name] );
 
-    if (elem && !Array.isArray(elem))
+    if (elem && !Array.isArray( elem ))
       return elem;
     // TODO: better (extra message), TODO: do it
     error( 'query-undefined-element', [ item.location, assoc ],
@@ -516,20 +518,71 @@ function navProjection( navigation, preferred ) {
     : navigation._projections[0] || null;
 }
 
-// Return condensed info about reference in select item
-// - tableAlias.elem       -> { navigation: navElem, item: path[1], tableAlias }
-// - sourceElem (in query) -> { navigation: navElem, item: path[0], tableAlias }
-// - mixinElem             -> { navigation: mixinElement, item: path[0] }
-// - $projection.elem      -> also $self.item -> { item: path[1], tableAlias: $self }
-// - $self                 -> { item: undefined, tableAlias: $self }
-// - $parameters.P, :P     -> {}
-// - $now, current_date    -> {}
-// - undef, redef          -> {}
-// With 'navigation': store that navigation._artifact is projected
-// With 'navigation': rewrite its ON condition
-// With navigation: Do KEY propagation
-//
-// TODO: re-think this function, copied in populate.js and tweak-assocs.js
+
+/**
+ * For a path `a.b.c.d`, return a projection for the first path item that is projected.
+ * 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.
+ *
+ * The returned object `ret` has `ret.item`, which is the path item 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.
+ * @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
+    return { item: undefined, elem: {} };
+
+  // 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.
+  const selectedElements = Object.values(tableAlias._parent.elements);
+  const proj = [];
+  let navItem = tableAlias;
+  for (const item of path.slice(root)) {
+    navItem = item?.id && navItem.elements?.[item.id];
+    if (!navItem) {
+      break;
+    }
+    else if (navItem._projections) {
+      const elem = navProjection( navItem, assoc );
+      if (elem && elem === assoc) {
+        // in case the specified association is found, _always_ use it.
+        return { item, elem };
+      }
+      else if (elem) {
+        const index = selectedElements.indexOf(elem);
+        proj.push({ item, elem, index });
+      }
+    }
+  }
+
+  return (proj.length === 0)
+    ? { item: path[root], elem: null }
+    : proj.reduce( (acc, curr) => (acc.index > curr.index ? curr : acc), proj[0] ); // first
+}
+
+/**
+ * Return condensed info about reference in select item
+ * - tableAlias.elem       -> { navigation: navElem, item: path[1], tableAlias }
+ * - sourceElem (in query) -> { navigation: navElem, item: path[0], tableAlias }
+ * - mixinElem             -> { navigation: mixinElement, item: path[0] }
+ * - $projection.elem      -> also $self.item -> { item: path[1], tableAlias: $self }
+ * - $self                 -> { item: undefined, tableAlias: $self }
+ * - $parameters.P, :P     -> {}
+ * - $now, current_date    -> {}
+ * - undef, redef          -> {}
+ * With 'navigation': store that navigation._artifact is projected
+ * With 'navigation': rewrite its ON condition
+ * With navigation: Do KEY propagation
+ *
+ * TODO: re-think this function, copied in populate.js and tweak-assocs.js
+ */
 function pathNavigation( ref ) {
   // currently, indirectly projectable elements are not included - we might
   // keep it this way!  If we want them to be included - be aware: cycles