@sap/cds-compiler 4.1.2 → 4.2.2

package/lib/compiler/resolve.js

@@ -62,13 +62,14 @@ const {
   testExpr,
   targetMaxNotOne,
   traverseQueryPost,
+  linkToOrigin,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
 
-const $location = Symbol.for('cds.$location');
+const $location = Symbol.for( 'cds.$location' );
 
-const $inferred = Symbol.for('cds.$inferred');
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 // TODO: make this part of specExpected in shared.js
 // (standard: not possible on last if !ref.$expected → ref.scope: '$exists')
@@ -99,7 +100,7 @@ function resolve( model ) {
   } );
 
   const ignoreSpecifiedElements
-    = isDeprecatedEnabled(model.options, 'ignoreSpecifiedQueryElements');
+    = isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' );
 
   return doResolve();
 
@@ -134,9 +135,9 @@ function resolve( model ) {
           std: 'Illegal circular reference to $(ART)',
           element: 'Illegal circular reference to element $(MEMBER) of $(ART)',
           target: 'Illegal circular reference to target $(ART)',
-        });
+        } );
       }
-    });
+    } );
     if (model.$assert) {
       error( '$internal-expecting-cyclic', null, {},
              'INTERNAL: the compiler should have issued an Error[ref-cyclic]' );
@@ -157,22 +158,52 @@ function resolve( model ) {
           return;
         // TODO: what about elements where _origin is set without value?
         // TODO: or should we push elems with `expand` sibling to extra list for
-        // better messages?  (Whatever that means exactly.)
+        //       better messages?  (Whatever that means exactly.)
         const nav = pathNavigation( elem.value );
         const { path } = elem.value;
-        const item = path[path.length - 1];
-        if (nav.navigation && nav.item === item) {
-          // sourceElem, alias.sourceElem, mixin:
-          // redirectImplicitly( elem, origin );
-          pushLink( nav.navigation, '_projections', elem );
-        }
-        else if (elem._pathHead?.kind === '$inline' && path.length === 1) {
+
+        if (elem._pathHead?.kind === '$inline' && path.length === 1) {
+          const item = path[0];
           const hpath = elem._pathHead.value?.path;
           const head = hpath?.length === 1 && hpath[0]._navigation;
           // Alias .{ elem } - but not with Alias.{ $magic }: consider for ON-rewrite
           if (head?.kind === '$tableAlias' && item.id.charAt(0) !== '$')
             pushLink( head.elements[item.id], '_projections', elem );
         }
+        else if (nav.navigation) { // not set for $self.…
+          // Path could start with table alias; get start index
+          let index = path.indexOf(nav.item);
+          if (index === -1)
+            return;
+
+          let navItem = nav.navigation;
+          if (path[index].where || path[index].args)
+            return;
+          ++index;
+          while (navItem && index < path.length) {
+            const step = path[index];
+            if (!step?.id || step.where || step.args)
+              break;
+            if (!navItem.elements?.[step.id]) {
+              const elements = navItem._origin?.elements ||
+                navItem._origin?.target?._artifact?.elements;
+              if (!elements)
+                break;
+              // Only link available path steps (navigation tree).
+              const origin = elements[step.id];
+              const member = linkToOrigin( origin, step.id, navItem, 'elements',
+                                           navItem.path?.location, true );
+              member.$inferred = 'expanded';
+              member.kind = '$navElement';
+            }
+            navItem = navItem.elements[step.id];
+            setLink( step, '_navigation', navItem );
+            ++index;
+          }
+          // Last path step, if found, is a simple projection
+          if (index === path.length && navItem)
+            pushLink( navItem, '_projections', elem );
+        }
       } );
     }
   }
@@ -361,7 +392,7 @@ function resolve( model ) {
       for (const include of art.includes) {
         const struct = include._artifact;
         if (struct && struct.kind !== 'type' && struct.elements &&
-            Object.values( struct.elements ).some( e => e.targetAspect)) {
+            Object.values( struct.elements ).some( e => e.targetAspect )) {
           message( 'type-managed-composition', [ include.location, art ],
                    { '#': struct.kind, art: struct } );
         }
@@ -385,7 +416,7 @@ function resolve( model ) {
     }
     if (obj.items) {            // TODO: make this a while in v2 (also items proxy)
       obj = obj.items || obj; // the object which has type properties
-      effectiveType(obj);
+      effectiveType( obj );
     }
     if (obj.type) {             // TODO: && !obj.type.$inferred ?
       if (obj !== (art.returns || art)) // not already checked
@@ -412,13 +443,13 @@ function resolve( model ) {
         if (elemtype.category === 'relation' && obj.type.path.length > 0 &&
           !obj.target && !obj.targetAspect) {
           const isCsn = (obj._block && obj._block.$frontend === 'json');
-          error('type-missing-target', [ obj.type.location, obj ],
-                { '#': isCsn ? 'csn' : 'std', type: elemtype.name.absolute }, {
-                  // We don't say "use 'association to <target>" because the type could be used
-                  // in action parameters, etc. as well.
-                  std: 'The type $(TYPE) can\'t be used directly because it\'s compiler internal',
-                  csn: 'Type $(TYPE) is missing a target',
-                });
+          error( 'type-missing-target', [ obj.type.location, obj ],
+                 { '#': isCsn ? 'csn' : 'std', type: elemtype.name.absolute }, {
+                   // We don't say "use 'association to <target>" because the type could be used
+                   // in action parameters, etc. as well.
+                   std: 'The type $(TYPE) can\'t be used directly because it\'s compiler internal',
+                   csn: 'Type $(TYPE) is missing a target',
+                 } );
         }
       }
     }
@@ -454,7 +485,7 @@ function resolve( model ) {
     }
     if (obj.foreignKeys) {       // silent dependencies
       // Avoid strange ref-cyclic if managed composition is key (check comes later)
-      // TODO: the following is already done by addimplicitforeignkeys()!
+      // TODO: the following is already done by addImplicitForeignKeys()!
       if (obj.$inferred !== 'aspect-composition') {
         forEachGeneric( obj, 'foreignKeys', (elem) => {
           dependsOnSilent( art, elem );
@@ -470,9 +501,9 @@ function resolve( model ) {
       inferTypePropertiesFromCast( art );
     if (art.value) {
       if (art.$syntax === 'calc')
-        checkCalculatedElement(art);
+        checkCalculatedElement( art );
       else if (art.type && !art.$inferred )
-        checkStructureCast(art);
+        checkStructureCast( art );
     }
 
     forEachMember( art, resolveRefs, art.targetAspect );
@@ -482,8 +513,8 @@ function resolve( model ) {
 
     if (!ignoreSpecifiedElements && art.elements$ && art.elements) {
       for (const id in art.elements$) {
-        resolveRefs(art.elements$[id]);
-        checkSpecifiedElement(art.elements[id], art.elements$[id]);
+        resolveRefs( art.elements$[id] );
+        checkSpecifiedElement( art.elements[id], art.elements$[id] );
       }
     }
 
@@ -508,96 +539,97 @@ function resolve( model ) {
 
       // Check explicit types: If either side has one, so must the other.
       const sType = specifiedElement.type?._artifact;
-      const iType = getInferredPropFromOrigin('type')?._artifact || inferredElement;
+      const iType = getInferredPropFromOrigin( 'type' )?._artifact || inferredElement;
 
       // xor: could be missing a type;
       // FIXME: The coding above returns incorrect iType for expand on associations
       if (!specifiedElement.type && inferredElement.type) {
-        error('query-mismatched-element', [ specifiedElement.location, user ], {
+        error( 'query-mismatched-element', [ specifiedElement.location, user ], {
           '#': !specifiedElement.type ? 'missing' : 'extra', name: user.name.id, prop: 'type',
-        });
+        } );
         return;
       }
       // If specified type is `null`, type could not be resolved.
       else if (sType && sType !== iType) {
         const typeName = iType?.name && sType?.name ? 'typeName' : 'type';
-        error('query-mismatched-element', [
+        const othertype = typeName !== 'type' && iType || '';
+        error( 'query-mismatched-element', [
           specifiedElement.type.location || specifiedElement.location, user,
         ], {
           '#': typeName,
           name: user.name.id,
           type: sType,
-          othertype: iType,
-        });
+          othertype,
+        } );
         return;
       }
 
       // This relies on (element) expansion!  Check that both sides have the following properties.
       // On the inferred side, they are likely expanded.
-      if (!hasXorPropMismatch('elements') && !hasXorPropMismatch('items') &&
-        !hasXorPropMismatch('target') && !hasXorPropMismatch('enum')) {
+      if (!hasXorPropMismatch( 'elements' ) && !hasXorPropMismatch( 'items' ) &&
+        !hasXorPropMismatch( 'target' ) && !hasXorPropMismatch( 'enum' )) {
         // Element are already traversed via elements$ merging.
 
         // only check items, if the specified one is not expanded/inferred
         if (specifiedElement.items && !specifiedElement.items.$inferred)
-          checkSpecifiedElement(inferredElement.items, specifiedElement.items, specifiedElement);
+          checkSpecifiedElement( inferredElement.items, specifiedElement.items, specifiedElement );
 
-        if (specifiedElement.target &&
+        if (specifiedElement.target?._artifact && inferredElement.target?._artifact &&
             specifiedElement.target._artifact !== inferredElement.target._artifact) {
-          error('query-mismatched-element', [
+          error( 'query-mismatched-element', [
             specifiedElement.target.location || specifiedElement.location, user,
           ], {
             '#': 'target',
             name: user.name.id,
             target: specifiedElement.target,
             art: inferredElement.target,
-          });
+          } );
         }
 
         if (specifiedElement.foreignKeys) {
-          const sKeys = Object.keys(specifiedElement.foreignKeys);
+          const sKeys = Object.keys( specifiedElement.foreignKeys );
           /** @type {any} */
           let iKeys = inferredElement;
           if (inferredElement._effectiveType !== 0) {
             while (iKeys._origin && !iKeys.foreignKeys)
               iKeys = iKeys._origin;
           }
-          iKeys = Object.keys(iKeys.foreignKeys || {});
-          if (sKeys.length !== iKeys.length || sKeys.some( fkey => !iKeys.includes(fkey))) {
-            error('query-mismatched-element', [
+          iKeys = Object.keys( iKeys.foreignKeys || {} );
+          if (sKeys.length !== iKeys.length || sKeys.some( fkey => !iKeys.includes( fkey ) )) {
+            error( 'query-mismatched-element', [
               specifiedElement.foreignKeys.location || specifiedElement.location, user,
             ], {
               '#': 'foreignKeys',
               name: user.name.id,
               target: specifiedElement.target,
               art: inferredElement.target,
-            });
+            } );
           }
         }
 
         if (specifiedElement.virtual) {
-          const iVirtual = getInferredPropFromOrigin('virtual')?.val || false;
+          const iVirtual = getInferredPropFromOrigin( 'virtual' )?.val || false;
           if (!specifiedElement.virtual.val !== !iVirtual) {
-            error('query-mismatched-element', [
+            error( 'query-mismatched-element', [
               specifiedElement.virtual.location || specifiedElement.location, user,
             ], {
               '#': 'prop', prop: 'virtual', name: user.name.id,
-            });
+            } );
           }
         }
 
         // If cardinality is not specified, the compiler uses the inferred one.
         if (specifiedElement.cardinality) {
           const sCardinality = specifiedElement.cardinality;
-          const iCardinality = getInferredPropFromOrigin('cardinality');
+          const iCardinality = getInferredPropFromOrigin( 'cardinality' );
           if (!iCardinality) {
-            error('query-mismatched-element', [
+            error( 'query-mismatched-element', [
               sCardinality.location || specifiedElement.location, user,
             ], {
               '#': 'extra',
               prop: 'cardinality',
               name: user.name.id,
-            });
+            } );
           }
           else {
             // Note: Cardinality does not have sourceMin (CSN "srcmin").
@@ -609,7 +641,7 @@ function resolve( model ) {
             for (const prop in props) {
               if (sCardinality[prop]?.val === iCardinality[prop]?.val)
                 continue;
-              error('query-mismatched-element', [
+              error( 'query-mismatched-element', [
                 sCardinality[prop]?.location || sCardinality.location || specifiedElement.location,
                 user,
               ], {
@@ -617,29 +649,29 @@ function resolve( model ) {
                 '#': !sCardinality[prop] ? 'missing' : (iCardinality[prop] ? 'prop' : 'extra'),
                 prop: `cardinality.${ props[prop] }`,
                 name: user.name.id,
-              });
+              } );
             }
           }
         }
 
         if (specifiedElement.value) {
-          error('query-unexpected-property', [
+          error( 'query-unexpected-property', [
             specifiedElement.value.location || specifiedElement.location, user,
           ], {
             '#': 'calculatedElement', prop: 'value', name: user.name.id,
-          });
+          } );
         }
 
         if (specifiedElement.key) { // TODO: `|| inferredElement.key?.val`, once to.sql is fixed
           // TODO: Do not use _origin chain for key; has been propagated in propagateKeyProps().
-          const iKey = getInferredPropFromOrigin('key')?.val;
+          const iKey = getInferredPropFromOrigin( 'key' )?.val;
           // If "key" is specified or truthy in the inferred element, the values must match.
           if (!iKey !== !specifiedElement.key?.val) {
-            error('query-mismatched-element', [
+            error( 'query-mismatched-element', [
               specifiedElement.key?.location || specifiedElement.location, user,
             ], {
               '#': specifiedElement.key ? 'prop' : 'missing', prop: 'key', name: user.name.id,
-            });
+            } );
           }
         }
 
@@ -653,9 +685,9 @@ function resolve( model ) {
             const sEnumEntry = sEnumValues[name];
             const iEnumEntry = iEnumValues[name]?._effectiveType || iEnumValues[name];
             if (!iEnumEntry) {
-              error('query-mismatched-element', [ specifiedElement.location, user ], {
+              error( 'query-mismatched-element', [ specifiedElement.location, user ], {
                 '#': 'enumExtra', name: user.name.id, id: name,
-              });
+              } );
               break;
             }
             else {
@@ -663,9 +695,9 @@ function resolve( model ) {
               const iVal = iEnumEntry.value?.val || iEnumEntry.value?.['#'] || name;
               const sVal = sEnumEntry.value?.val || sEnumEntry.value?.['#'] || name;
               if (iVal !== sVal) {
-                error('query-mismatched-element', [ specifiedElement.location, user ], {
+                error( 'query-mismatched-element', [ specifiedElement.location, user ], {
                   '#': 'enumVal', name: user.name.id, id: name,
-                });
+                } );
                 break;
               }
             }
@@ -682,7 +714,7 @@ function resolve( model ) {
           !inferredElement.value?.[prop] !== !specifiedElement[prop]) {
           error( 'query-mismatched-element', [ specifiedElement.location, specifiedElement ], {
             '#': specifiedElement[prop] ? 'extra' : 'missing', name: user.name.id, prop,
-          });
+          } );
           return true;
         }
         return false;
@@ -692,8 +724,8 @@ function resolve( model ) {
         // Inferred property via _origin chain (0 === circular).
         let element = inferredElement;
         if (element._effectiveType !== 0) {
-          while (getOrigin(element) && !element[prop])
-            element = getOrigin(element);
+          while (getOrigin( element ) && !element[prop])
+            element = getOrigin( element );
         }
         return element[prop];
       }
@@ -731,21 +763,21 @@ function resolve( model ) {
     while (parent.kind === 'element')
       parent = parent._parent;
 
-    if (!allowedInKind.includes(art._main.kind)) {
+    if (!allowedInKind.includes( art._main.kind )) {
       if (art.$inferred === 'include') {
         // even for include-chains, we find the correct ref due to element-expansion.
-        const include = art._main.includes.find(i => i._artifact === art._origin._main);
-        error('ref-invalid-calc-elem', [ include.location || art.value.location, art ],
-              { '#': art._main.kind });
+        const include = art._main.includes.find( i => i._artifact === art._origin._main );
+        error( 'ref-invalid-calc-elem', [ include.location || art.value.location, art ],
+               { '#': art._main.kind } );
       }
       else {
         error( 'def-invalid-calc-elem', loc, { '#': art._main.kind } );
       }
     }
-    else if (!allowedInKind.includes(parent.kind)) {
+    else if (!allowedInKind.includes( parent.kind )) {
       error( 'def-invalid-calc-elem', loc, { '#': parent.kind } );
     }
-    else if (effectiveType(art)?.elements) {
+    else if (effectiveType( art )?.elements) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
       if (!art.$inferred) {
         if (art.type)
@@ -754,7 +786,7 @@ function resolve( model ) {
           error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
       }
     }
-    else if (effectiveType(art)?.items) {
+    else if (effectiveType( art )?.items) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
       if (!art.$inferred) {
         const isCast = art.type?.$inferred === 'cast';
@@ -770,7 +802,7 @@ function resolve( model ) {
         if (art[prop]?.val) {
           // probably better than a parse error (which is good for DEFAULT vs calc),
           // also appears with parse-cdl:
-          error('def-invalid-calc-elem', loc, { '#': prop });
+          error( 'def-invalid-calc-elem', loc, { '#': prop } );
           return; // one error is enough
         }
       }
@@ -782,22 +814,19 @@ function resolve( model ) {
       ? art.value.args[0]?._artifact
       : art.value._artifact;
     if (elem && art.type) { // has explicit type
-      if (art.type._artifact?.elements) {
-        error('type-cast-to-structured', [ art.type.location, art ], {},
-              'Can\'t cast to structured element');
-      }
-      else if (elem.elements) { // TODO: calc elements
-        error('type-cast-structured', [ art.type.location, art ], {},
-              'Structured elements can\'t be cast to a different type');
-      }
+      if (art.type._artifact?.elements)
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'to-structure' } );
+      else if (elem.elements) // TODO: calc elements
+        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-structure' } );
     }
   }
 
-  // Return type containing the assoc spec (keys, on); note that no
-  // propagation/rewrite has been done yet, cyclic dependency must have been
-  // checked before!
+  /**
+   * Return type containing the assoc spec (keys, on); note that no
+   * propagation/rewrite has been done yet, cyclic dependency must have been
+   * checked before!
+   */
   function getAssocSpec( type ) {
-    // only to be called without cycles
     let unmanaged = null;
     while (type) {
       if (type.on)              // if unmanaged, continue trying to find targetAspect
@@ -857,6 +886,11 @@ function resolve( model ) {
       // (we could downgrade it to a warning if name is equal to unique source element name)
       // TODO: Some helping text mentioning an alias name would be useful
     }
+    for (const limit of query.$limit || []) // LIMIT from UNION:
+      resolveLimit( limit );
+    if (query.limit)
+      resolveLimit( query.limit );
+
     return;
 
     function resolveJoinOn( join ) {
@@ -864,27 +898,35 @@ function resolve( model ) {
         for (const j of join.args)
           resolveJoinOn( j );
         if (join.on)
-          resolveExpr( join.on, 'join-on', query );
-          // TODO: check restrictions according to join "query"
+          resolveExpr( join.on, 'join-on', join );
       }
     }
 
-    // Note the strange name resolution (dynamic part) for ORDER BY: the same
-    // as for select items if it is an expression, but first look at select
-    // item alias (i.e. like `$projection.NAME` if it is a path.  If it is an
-    // ORDER BY of an UNION, do not allow any dynamic path in an expression,
-    // and only allow the elements of the leading query if it is a path.
-    //
-    // This seems to be similar, but different in SQLite 3.22.0: ORDER BY seems
-    // to bind stronger than UNION (see <SQLite>/src/parse.y), and the name
-    // resolution seems to use select item aliases from all SELECTs of the
-    // UNION (see <SQLite>/test/tkt2822.test).
+    /**
+     * Note the strange name resolution (dynamic part) for ORDER BY: the same
+     * as for select items if it is an expression, but first look at select
+     * item alias (i.e. like `$projection.NAME` if it is a path.  If it is an
+     * ORDER BY of an UNION, do not allow any dynamic path in an expression,
+     * and only allow the elements of the leading query if it is a path.
+     *
+     * This seems to be similar, but different in SQLite 3.22.0: ORDER BY seems
+     * to bind stronger than UNION (see <SQLite>/src/parse.y), and the name
+     * resolution seems to use select item aliases from all SELECTs of the
+     * UNION (see <SQLite>/test/tkt2822.test).
+     */
     function resolveBy( array, refMode, exprMode ) {
       for (const value of array ) {
         if (value)
           resolveExpr( value, (value.path ? refMode : exprMode), query );
       }
     }
+
+    function resolveLimit( limit ) {
+      if (limit.rows)
+        resolveExpr( limit.rows, 'limit-rows', query );
+      if (limit.offset)
+        resolveExpr( limit.offset, 'limit-offset', query );
+    }
   }
 
   function resolveTarget( art, obj ) {
@@ -915,7 +957,7 @@ function resolve( model ) {
                  { '#': isComposition ? 'comp' : 'std' }, {
                    std: 'An unmanaged association can\'t be defined as type',
                    comp: 'An unmanaged composition can\'t be defined as type',
-                 });
+                 } );
         // TODO: also warning if inside structure
       }
       else {
@@ -973,7 +1015,7 @@ function resolve( model ) {
       const serviceKeys = keyElementNames( issue.target.elements );
       const modelKeys = keyElementNames( modelTarget.elements );
       if (modelKeys.length !== serviceKeys.length) {
-        issue.id = modelKeys.find( id => !serviceKeys.includes( id ));
+        issue.id = modelKeys.find( id => !serviceKeys.includes( id ) );
         issue['#'] = 'missing';
       }
       else if (!modelKeys.every( (id, index) => id === serviceKeys[index] )) {
@@ -1026,7 +1068,7 @@ function resolve( model ) {
   }
 
   function addImplicitForeignKeys( art, obj, target ) {
-    obj.foreignKeys = Object.create(null);
+    obj.foreignKeys = Object.create( null );
     forEachInOrder( target, 'elements', ( elem, name ) => {
       if (elem.key && elem.key.val) {
         const { location } = obj.target;
@@ -1042,14 +1084,14 @@ function resolve( model ) {
         // the following should be done automatically, since we run resolveRefs after that
         setArtifactLink( key.targetElement, elem );
         setArtifactLink( key.targetElement.path[0], elem );
-        setLink( key, '_effectiveType', effectiveType(elem) );
-        dependsOn(key, elem, location);
+        setLink( key, '_effectiveType', effectiveType( elem ) );
+        dependsOn( key, elem, location );
         // TODO TMP: instead, make managed composition of aspects and unmanaged
         // assocs not depend on their `on` condition (empty `_deps` after resolve)
         if (art.$inferred !== 'aspect-composition')
           dependsOnSilent( art, key );
       }
-    });
+    } );
     obj.foreignKeys[$inferred] = 'keys';
   }
 
@@ -1078,7 +1120,7 @@ function resolve( model ) {
    * for derived association like for `type DerivedT: T`, or exposed ones.
    */
   function addForeignKeyNavigations( art, silent = false ) {
-    art.$keysNavigation = Object.create(null);
+    art.$keysNavigation = Object.create( null );
     const keys = [];
     // Basically sort foreign keys according to length of target element ref.
     // This way, we complain about ref to sub element (`elem.sub`) even if it
@@ -1089,7 +1131,7 @@ function resolve( model ) {
         const arr = keys[path.length] || (keys[path.length] = []);
         arr.push( key );
       }
-    });
+    } );
     for (const key of keys.flat()) {
       let dict = art.$keysNavigation;
       const { path } = key.targetElement;
@@ -1102,7 +1144,7 @@ function resolve( model ) {
           if (item === last)
             setArtifactLink( nav, key );
           else
-            nav.$keysNavigation = Object.create(null);
+            nav.$keysNavigation = Object.create( null );
         }
         else if (item === last || nav._artifact) {
           if (silent)
@@ -1187,7 +1229,7 @@ function resolve( model ) {
                 target: 'The redirected target $(ART) is a complex view',
                 // eslint-disable-next-line max-len
                 targetOp: 'The redirected target $(ART) is a complex view with $(KEYWORD)',
-              });
+              } );
         break;
       }
       target = from._artifact;
@@ -1203,7 +1245,7 @@ function resolve( model ) {
     let redirected = null;
     chain.reverse();
     let news = [ { chain, sources: [ target ] } ];
-    const dict = Object.create(null);
+    const dict = Object.create( null );
     while (news.length) {
       const outer = news;
       news = [];
@@ -1328,7 +1370,7 @@ function resolve( model ) {
   function resolveParamsAndWhere( step, expected, user, isLast ) {
     const alias = (step._navigation?.kind === '$tableAlias') ? step._navigation : null;
     const type = alias || effectiveType( step._artifact );
-    const art = (type && type.target) ? type.target._artifact : type;
+    const art = type?.target ? type.target._artifact : type;
     if (!art)
       return;
     const entity = art.kind === 'entity' &&
@@ -1361,8 +1403,8 @@ function resolve( model ) {
 
   function resolveParams( dict, art, entity, expected, user, stepLocation ) {
     if (!entity || !entity.params) {
-      let first = dict[Object.keys(dict)[0]];
-      if (Array.isArray(first))
+      let first = dict[Object.keys( dict )[0]];
+      if (Array.isArray( first ))
         first = first[0];
       error( 'expr-unexpected-argument',
              [ dict[$location] || dictLocation( dict, first?.name?.location || stepLocation ),
@@ -1377,7 +1419,7 @@ function resolve( model ) {
       return;
     }
     const exp = (expected === 'from') ? 'from-args' : expected;
-    if (Array.isArray(dict)) {
+    if (Array.isArray( dict )) {
       const loc = [ dict[0] && dict[0].location || stepLocation, user ];
       error( 'expr-expected-named-argument', loc, {},
              'Expected named parameters for the entity' );
@@ -1389,7 +1431,7 @@ function resolve( model ) {
     for (const name in dict) {
       const param = art.params[name];
       const arg = dict[name];
-      for (const a of Array.isArray(arg) ? arg : [ arg ]) {
+      for (const a of Array.isArray( arg ) ? arg : [ arg ]) {
         setArtifactLink( a.name, param );
         if (!param) {
           error( 'expr-undefined-param', [ a.name.location, user ], { art, id: name },
@@ -1401,20 +1443,22 @@ function resolve( model ) {
   }
 }
 
-// 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
+/**
+ * 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