@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/transform/translateAssocsToJoins.js

@@ -1,18 +1,20 @@
-'use strict'
+'use strict';
 
-const { setProp, forEachGeneric, forEachDefinition, isBetaEnabled } = require('../base/model');
+const {
+  setProp, forEachGeneric, forEachDefinition, isBetaEnabled,
+} = require('../base/model');
 const { makeMessageFunction } = require('../base/messages');
 const { recompileX } = require('../compiler/index');
 const { linkToOrigin, pathName } = require('../compiler/utils');
-const  {compactModel, compactExpr} = require('../json/to-csn');
+const { compactModel, compactExpr } = require('../json/to-csn');
 const { deduplicateMessages } = require('../base/messages');
 const { timetrace } = require('../utils/timetrace');
-const {CompilerAssertion} = require('../base/error');
+const { CompilerAssertion } = require('../base/error');
 // Paths that start with an artifact of protected kind are special
 // either ignore them in QAT building or in path rewriting
-const internalArtifactKinds = ['builtin', '$parameters', 'param'];
+const internalArtifactKinds = [ 'builtin', '$parameters', 'param' ];
 
-function translateAssocsToJoinsCSN(csn, options){
+function translateAssocsToJoinsCSN(csn, options) {
   timetrace.start('A2J: Recompiling model');
   // Do not re-complain about localized
   const compileOptions = { ...options, $skipNameCheck: true };
@@ -24,7 +26,7 @@ function translateAssocsToJoinsCSN(csn, options){
   translateAssocsToJoins(model, options);
   timetrace.stop('A2J: Translating associations to joins');
   // Use the effective elements list as columns
-  forEachDefinition(model, art => {
+  forEachDefinition(model, (art) => {
     if (art.$queries) {
       for (const query of art.$queries) {
         query.columns = Object.values(query.elements);
@@ -46,8 +48,7 @@ function translateAssocsToJoinsCSN(csn, options){
   return compactModel(model, compileOptions);
 }
 
-function translateAssocsToJoins(model, inputOptions = {})
-{
+function translateAssocsToJoins(model, inputOptions = {}) {
   const { error, warning, throwWithError } = makeMessageFunction(model, inputOptions, 'a2j');
 
   const options = model.options || inputOptions;
@@ -66,32 +67,27 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   return model;
 
-  function prepareAssociations(art)
-  {
-    if(art.kind === 'element' && art.target)
-    {
+  function prepareAssociations(art) {
+    if (art.kind === 'element' && art.target) {
       /* Create the prefix string up to the main artifact which is
          prepended to all source side paths of the resulting ON condition
          (cut off name.id from name.element)
       */
       art.$elementPrefix = '';
-      for(let parent = art._parent; parent?.kind === 'element'; parent = parent._parent)
+      for (let parent = art._parent; parent?.kind === 'element'; parent = parent._parent)
         art.$elementPrefix = parent.name.id + pathDelimiter + art.$elementPrefix;
 
       /*
         Create path prefix tree for Foreign Keys, required to substitute
         aliases in ON cond calculation, also very useful to detect fk overlaps.
       */
-      if(art.foreignKeys && !art.$fkPathPrefixTree)
-      {
+      if (art.foreignKeys && !art.$fkPathPrefixTree) {
         art.$fkPathPrefixTree = { children: Object.create(null) };
-        forEachGeneric(art, 'foreignKeys', fk => {
+        forEachGeneric(art, 'foreignKeys', (fk) => {
           let ppt = art.$fkPathPrefixTree;
-          fk.targetElement.path.forEach(ps => {
-            if(!ppt.children[ps.id])
-              ppt = ppt.children[ps.id] = { children: Object.create(null) };
-            else
-              ppt = ppt.children[ps.id];
+          fk.targetElement.path.forEach((ps) => {
+            ppt.children[ps.id] ??= { children: Object.create(null) };
+            ppt = ppt.children[ps.id];
           });
           ppt._fk = fk;
         });
@@ -101,14 +97,13 @@ function translateAssocsToJoins(model, inputOptions = {})
     forEachGeneric(art, 'elements', prepareAssociations);
   }
 
-  function transformQueries(art)
-  {
-    if(art.$queries === undefined)
+  function transformQueries(art) {
+    if (art.$queries === undefined)
       return;
 
     function forEachQuery(callback, env) {
-      art.$queries.forEach((q,i) => {
-        if(env !== undefined)
+      art.$queries.forEach((q, i) => {
+        if (env !== undefined)
           env.queryIndex = i;
         callback(q, env);
       });
@@ -116,7 +111,9 @@ function translateAssocsToJoins(model, inputOptions = {})
 
     const env = {
       aliasCount: 0,
-      walkover: { from: true, onCondFrom:true, select:true, filter: true },
+      walkover: {
+        from: true, onCondFrom: true, select: true, filter: true,
+      },
     };
     /*
       Setup QAs for mixins
@@ -140,7 +137,9 @@ function translateAssocsToJoins(model, inputOptions = {})
     forEachQuery(createQAForFromClauseSubQuery, env);
 
     // 2) Walk over each from table path, transform it into a join tree
-    env.walkover = { from:true, onCondFrom:false, select: false, filter: false };
+    env.walkover = {
+      from: true, onCondFrom: false, select: false, filter: false,
+    };
     env.callback = createInnerJoins;
     forEachQuery(walkQuery, env);
 
@@ -152,7 +151,9 @@ function translateAssocsToJoins(model, inputOptions = {})
     // 4) Rewrite ON condition paths that are part of the original FROM block
     //    (same rewrite as (injected) assoc ON cond paths but with different table alias).
     // 5) Prepend table alias to all remaining paths
-    env.walkover = { from:false, onCondFrom:true, select: true, filter: false };
+    env.walkover = {
+      from: false, onCondFrom: true, select: true, filter: false,
+    };
     env.callback = substituteDollarSelf;
     forEachQuery(walkQuery, env);
     env.callback = rewriteGenericPaths;
@@ -163,8 +164,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   }
 
   // Transform each FROM table path into a join tree and attach the tree to the path object
-  function createInnerJoins(fromPathNode, env)
-  {
+  function createInnerJoins(fromPathNode, env) {
     const fqat = env.lead.$tableAliases[fromPathNode.name.id].$fqat;
     const joinTree = createJoinTree(env, undefined, fqat, 'inner', '$fqat', undefined);
 
@@ -172,16 +172,12 @@ function translateAssocsToJoins(model, inputOptions = {})
   }
 
   // Translate all other join relevant query paths into left outer join tree and attach it to the lead query
-  function createLeftOuterJoins(query, env)
-  {
-    if(query.op.val === 'SELECT')
-    {
+  function createLeftOuterJoins(query, env) {
+    if (query.op.val === 'SELECT') {
       env.lead = query;
       let joinTree = query.from;
-      for(const tan in query.$tableAliases)
-      {
-        if(query.$tableAliases[tan].kind !== '$self') // don't drive into $projection/$self tableAlias (yet)
-        {
+      for (const tan in query.$tableAliases) {
+        if (query.$tableAliases[tan].kind !== '$self') { // don't drive into $projection/$self tableAlias (yet)
           const ta = query.$tableAliases[tan];
           joinTree = createJoinTree(env, joinTree, ta.$qat, 'left', '$qat', ta.$QA);
         }
@@ -198,12 +194,11 @@ function translateAssocsToJoins(model, inputOptions = {})
     must be created and added separately to the lead query $tableAlias'es.
     Also, the name of the subquery (the alias) needs to be set to the final QA alias name.
   */
-  function createQAForFromClauseSubQuery(query, env)
-  {
+  function createQAForFromClauseSubQuery(query, env) {
     for (const taName in query.$tableAliases) {
       if (query.$tableAliases[taName].kind !== '$self') {
         const ta = query.$tableAliases[taName];
-        if(!ta.$QA) {
+        if (!ta.$QA) {
           let alias = taName;
           if (ta.name.$inferred === '$internal') {
             // query has no explicit table alias, i.e. is internal: make it visible and remove `$`
@@ -213,9 +208,8 @@ function translateAssocsToJoins(model, inputOptions = {})
           }
           ta.$QA = createQA(env, ta._origin, alias, undefined);
           incAliasCount(env, ta.$QA);
-          if(ta.name && ta.name.id) {
+          if (ta.name && ta.name.id)
             ta.name.id = ta.$QA.name.id;
-          }
         }
       }
     }
@@ -238,15 +232,12 @@ function translateAssocsToJoins(model, inputOptions = {})
     aliases.
 
   */
-  function createQAForMixinAssoc(query, env)
-  {
-    if(query.op.val === 'SELECT')
-    {
+  function createQAForMixinAssoc(query, env) {
+    if (query.op.val === 'SELECT') {
       env.lead = query;
       // use view as QA origin
-      forEachGeneric(query, 'mixin', art => {
-        if(!art.$QA)
-        {
+      forEachGeneric(query, 'mixin', (art) => {
+        if (!art.$QA) {
           art.$QA = createQA(env, art.target._artifact, art.name.id );
           art.$QA.mixin = true;
         }
@@ -257,29 +248,28 @@ function translateAssocsToJoins(model, inputOptions = {})
   /*
     Substitute $self/$projection expression with its value
   */
-  function substituteDollarSelf(pathNode, env)
-  {
+  function substituteDollarSelf(pathNode, env) {
     // do not substitute $self values for outer order by clauses
     if (env?.location === 'UnionOuterOrderBy')
       return;
 
     let pathValue = pathNode;
-    let [head, ...tail] = pathValue.path;
-    while(tail.length && head._navigation?.kind === '$self') {
+    let [ head, ...tail ] = pathValue.path;
+    while (tail.length && head._navigation?.kind === '$self') {
       const self = head;
-      [head, ...tail] = tail;
-      if(head) {
+      [ head, ...tail ] = tail;
+      if (head) {
         pathValue = self._navigation._origin.elements[head.id].value;
         // core compiler has already caught $self.<assoc>.<postfix> and
         // non-path $self expressions with postfix path
-        if(pathValue.path) {
-          if(tail.length)
-            pathValue = constructPathNode([...pathValue.path, ...tail], pathValue.alias, false);
-          [head, ...tail] = pathValue.path;
+        if (pathValue.path) {
+          if (tail.length)
+            pathValue = constructPathNode([ ...pathValue.path, ...tail ], pathValue.alias, false);
+          [ head, ...tail ] = pathValue.path;
         }
       }
     }
-    if(head)
+    if (head)
       replaceNodeContent(pathNode, pathValue);
   }
 
@@ -291,51 +281,50 @@ function translateAssocsToJoins(model, inputOptions = {})
     the respective FK aliases.
     No flattening of structured leaf types necessary, this is done in renderer
   */
-  function rewriteGenericPaths(pathNode, env)
-  {
-    if(pathNode.$rewritten)
+  function rewriteGenericPaths(pathNode, env) {
+    if (pathNode.$rewritten)
       return;
 
-    if(env.location === 'onCondFrom')
-    {
-      if(checkPathDictionary(pathNode, env)) {
+    if (env.location === 'onCondFrom') {
+      if (checkPathDictionary(pathNode, env)) {
         const [ tableAlias, tail ] = constructTableAliasAndTailPath(pathNode.path);
         const pathStr = translateONCondPath(tail).map(ps => ps.id).join(pathDelimiter);
         replaceNodeContent(pathNode,
-          constructPathNode([ tableAlias, { id: pathStr, _artifact: pathNode._artifact } ]));
+                           constructPathNode([ tableAlias, { id: pathStr, _artifact: pathNode._artifact } ]));
       }
     }
-    else
-    {
+    else {
       // Paths without _navigation in ORDER BY are select item aliases, they must
       // be rendered verbatim
-      let [head, ...tail] = pathNode.path;
-      if((env.location === 'OrderBy' && !head._navigation)||
-         env.location === 'UnionOuterOrderBy' && (!head._navigation || ['$self', '$projection'].includes(head.id)))
+      // eslint-disable-next-line prefer-const
+      let [ head, ...tail ] = pathNode.path;
+      if ((env.location === 'OrderBy' && !head._navigation) ||
+         env.location === 'UnionOuterOrderBy' && (!head._navigation || [ '$self', '$projection' ].includes(head.id)))
         return;
 
       // path outside ON cond:
       // spin the crystal ball to identify the correct table alias
 
       // pop ta ps
-      if(head._navigation.kind !== '$tableAlias')
+      if (head._navigation.kind !== '$tableAlias')
         tail = pathNode.path;
+      const rootQA = head._navigation._parent.$QA || head._navigation.$QA;
       // if tail.length > 1, search bottom up for QA
       // default to rootQA, _parent.$QA has precedence
-      const [QA, ps] = rightMostQA(tail, head._navigation._parent.$QA || head._navigation.$QA);
-      if(!QA) {
+      const [ QA, ps ] = rightMostJoinRelevantQA(tail, rootQA);
+      if (!QA) {
         error(null, pathNode.$location,
-          { name: pathName(pathNode.path) },
-          'Debug me: No QA found for generic path rewriting in $(NAME)')
+              { name: pathName(pathNode.path) },
+              'Debug me: No QA found for generic path rewriting in $(NAME)');
         return;
       }
       // if the found QA is the mixin QA and if the path length is one,
       // this indicates the publishing of a mixin assoc, don't rewrite the path
-      if(QA.mixin && tail.length === 1)
+      if (QA.mixin && tail.length === 1)
         return;
       let pos = tail.indexOf(ps);
       // cut off ps if it's a join relevant association with postfix
-      if(tail.length-(pos+1) > 0 && ps._artifact.target && !ps._navigation.$njr)
+      if (tail.length - (pos + 1) > 0 && ps._artifact.target && (rootQA.mixin || rootQA !== QA))
         pos++;
       // QA + tail is the rewritten path
       tail = tail.slice(pos);
@@ -343,32 +332,41 @@ function translateAssocsToJoins(model, inputOptions = {})
       // if so, substitute path with pregenerated foreign key, prepend by optional
       // (to be flattened) prefix
 
-      for(let i = 0; i < tail.length-1; i++) {
-        if(tail[i]._navigation && tail[i]._navigation.$njr) {
+      for (let i = 0; i < tail.length - 1; i++) {
+        if (tail[i]._navigation) {
           // the correct flattened foreign key must match the leaf artifact and access path prefix of this path
-          const leafArt = tail[tail.length-1]._artifact;
-          const tailPath = tail.map(p=>p.id).join(pathDelimiter);
-          const fk = tail[i]._artifact.$flatSrcFKs.find(f => f._artifact === leafArt && f.acc.startsWith(tailPath));
-          if (!fk)
-            throw new CompilerAssertion('Debug me: No flat FK found for FK rewriting');
-          // replace tail path with flattened foreign key including prefix
-          tail.splice(i, tail.length, fk);
+          const fk = findForeignKey(tail[i], tail[i + 1]);
+
+          // if the assoc is not join relevant, we should have found the foreign key
+          if (tail[i]._navigation.$njr && !fk)
+            throw new CompilerAssertion('Debug me: No FK found for FK rewriting');
+
+          if (fk && fk.name.id !== tail[i + 1].id)
+            tail[i + 1].id = fk.name.id; // fk renamed
         }
       }
       tail = [
-        { id: tail.map(p => p.id).join(pathDelimiter),
-          _artifact: tail[tail.length-1]._artifact
-        }
+        {
+          id: tail.map(p => p.id).join(pathDelimiter),
+          _artifact: tail[tail.length - 1]._artifact,
+        },
       ];
       replaceNodeContent(pathNode,
-        constructPathNode([ constructTableAliasPathStep(QA), ...tail ]));
+                         constructPathNode([ constructTableAliasPathStep(QA), ...tail ]));
+    }
+
+    function findForeignKey(assoc, fk) {
+      return Object.values(assoc._artifact.foreignKeys).find(k => k.targetElement._artifact === fk._artifact);
     }
 
-    function rightMostQA(path, rootQA) {
-      // iterate over the path and search for first QA that
-      // either matches a $tableAlias or an association,
-      // if no QA could be found, return rootQA
-      // this is the table alias
+    /**
+     * Search right-to-left for first QA that matches either
+     * - a $tableAlias
+     * - or an association (skip this QA if postfix path is foreign key)
+     *
+     * If no QA found, return rootQA with first path step.
+     */
+    function rightMostJoinRelevantQA(path, rootQA) {
       /*
         Search right to left to find first QA in QAT tree
         Start with n-1st path element (to not find QA for exposed
@@ -376,16 +374,20 @@ function translateAssocsToJoins(model, inputOptions = {})
         If no QA could be found, return rootQA with first path
         step.
       */
-      let QA = undefined;
-      let pl = path.length-1;
+      let QA;
+      let pl = path.length - 1;
       let ps = path[pl]; // return [null, ps] for pl==0
-      while(!QA && pl > 0)
-      {
+      while (!QA && pl > 0) {
+        const next = ps;
         ps = path[--pl];
-        if(ps._navigation)
+        if (ps._navigation) {
+          const tailIsFk = !ps.where && !ps.args && ps._artifact.foreignKeys && findForeignKey(ps, next);
+          if (tailIsFk)
+            continue;
           QA = ps._navigation.$QA;
+        }
       }
-      return [(QA ? QA : rootQA), ps];
+      return [ (QA || rootQA), ps ];
     }
   }
 
@@ -394,21 +396,19 @@ function translateAssocsToJoins(model, inputOptions = {})
     If WHERE does not exist, create a new one. This step must be done after rewriteGenericPaths()
     as the filter expressions would be traversed twice.
   */
-  function attachFirstFilterConditions(query)
-  {
-    if(query.$startFilters)
-    {
-      if(query.where)
-      {
-        if(query.where.op.val === 'and')
+  function attachFirstFilterConditions(query) {
+    if (query.$startFilters) {
+      if (query.where) {
+        if (query.where.op.val === 'and')
           query.where.args.push(...query.$startFilters.map(parenthesise));
         else
-          query.where = { op: {val: 'and' }, args: [ parenthesise(query.where),  ...query.$startFilters.map(parenthesise) ] };
+          query.where = { op: { val: 'and' }, args: [ parenthesise(query.where), ...query.$startFilters.map(parenthesise) ] };
       }
-      else
+      else {
         query.where = query.$startFilters.length > 1
-          ? { op: {val: 'and' }, args: query.$startFilters.map(parenthesise) }
+          ? { op: { val: 'and' }, args: query.$startFilters.map(parenthesise) }
           : parenthesise(query.$startFilters[0]);
+      }
     }
   }
 
@@ -418,48 +418,41 @@ function translateAssocsToJoins(model, inputOptions = {})
     case QAT.origin is an association, create a new JOIN node using
     the existing joinTree as LHS and the QAT.QA as RHS.
   */
-  function createJoinTree(env, joinTree, parentQat, joinType, qatAttribName, lastAssocQA)
-  {
-    for(const childQatId in parentQat)
-    {
+  function createJoinTree(env, joinTree, parentQat, joinType, qatAttribName, lastAssocQA) {
+    for (const childQatId in parentQat) {
       const childQat = parentQat[childQatId];
 
       // If this QAT is not join relevant, don't drill down any further but
       // continue with current parentQat
-      if(!childQat.$njr) {
+      if (!childQat.$njr) {
         let newAssocLHS = lastAssocQA;
         const art = childQat._origin;
-        if(art.kind === 'entity')
-        {
-          if(!childQat.$QA)
+        if (art.kind === 'entity') {
+          if (!childQat.$QA)
             childQat.$QA = createQA(env, art, art.name.id.split('.').pop(), childQat._namedArgs);
           incAliasCount(env, childQat.$QA);
           newAssocLHS = childQat.$QA;
 
-          if(joinTree === undefined) // This is the first artifact in the JOIN tree
-          {
+          if (joinTree === undefined) { // This is the first artifact in the JOIN tree
             joinTree = childQat.$QA;
             // Collect the toplevel filters and add them to the where condition
-            if(childQat._filter)
-            {
+            if (childQat._filter) {
               // Filter conditions are unique for each JOIN, they don't need to be copied
               const filter = childQat._filter;
-              rewritePathsInFilterExpression(filter, function(pathNode) {
-                return [ /* tableAlias=> */ constructTableAliasPathStep(childQat.$QA),
-                        /* filterPath=> */ pathNode.path ];
-              }, env);
+              rewritePathsInFilterExpression(filter, pathNode => [ /* tableAlias=> */ constructTableAliasPathStep(childQat.$QA),
+                /* filterPath=> */ pathNode.path ], env);
 
-              if(!env.lead.$startFilters)
+              if (!env.lead.$startFilters)
                 env.lead.$startFilters = [];
               env.lead.$startFilters.push( filter );
             }
           }
         }
-        else if(art.target) { // it's not an artifact, so it should be an assoc step
-          if(joinTree === undefined)
+        else if (art.target) { // it's not an artifact, so it should be an assoc step
+          if (joinTree === undefined)
             throw new CompilerAssertion('Can\'t follow Associations without starting Entity');
 
-          if(!childQat.$QA)
+          if (!childQat.$QA)
             childQat.$QA = createQA(env, art.target._artifact, art.name.id, childQat._namedArgs);
 
           incAliasCount(env, childQat.$QA);
@@ -473,32 +466,28 @@ function translateAssocsToJoins(model, inputOptions = {})
     return joinTree;
   }
 
-  function createJoinQA(joinType, lhs, rhs, assocQAT, assocSourceQA, env)
-  {
+  function createJoinQA(joinType, lhs, rhs, assocQAT, assocSourceQA, env) {
     const node = { op: { val: 'join' }, join: { val: joinType }, args: [ lhs, rhs ] };
     const assoc = assocQAT._origin;
-    if(isBetaEnabled(options, 'mapAssocToJoinCardinality')) {
+    if (isBetaEnabled(options, 'mapAssocToJoinCardinality'))
       node.cardinality = mapAssocToJoinCardinality(assoc);
-    }
+
     // 'path steps' for the src/tgt table alias
     const srcTableAlias = constructTableAliasPathStep(assocSourceQA);
     const tgtTableAlias = constructTableAliasPathStep(assocQAT.$QA);
 
     node.on = createOnCondition(assoc, srcTableAlias, tgtTableAlias, options.tenantDiscriminator);
 
-    if(assocQAT._filter)
-    {
+    if (assocQAT._filter) {
       // Filter conditions are unique for each JOIN, they don't need to be copied
       const filter = assocQAT._filter;
-      rewritePathsInFilterExpression(filter, function(pathNode) {
-        return [ tgtTableAlias, pathNode.path ];
-      }, env);
+      rewritePathsInFilterExpression(filter, pathNode => [ tgtTableAlias, pathNode.path ], env);
 
       // If toplevel ON cond op is AND add filter condition to the args array,
       // create a new toplevel AND op otherwise
       const onCond = (Array.isArray(node.on) ? node.on[0] : node.on);
 
-      if(onCond.op.val === 'and')
+      if (onCond.op.val === 'and')
         onCond.args.push(parenthesise(filter));
       else
         node.on = parenthesise({ op: { val: 'and' }, args: [ parenthesise(onCond), parenthesise(filter) ] });
@@ -529,33 +518,33 @@ function translateAssocsToJoins(model, inputOptions = {})
     function mapAssocToJoinCardinality(assoc) {
       /** @type {object} */
       const xsnCard = {
-        targetMax : { literal: 'number', val: 1 }
+        targetMax: { literal: 'number', val: 1 },
       };
-      if(assoc.type._artifact._effectiveType.name.id === 'cds.Composition') {
+      if (assoc.type._artifact._effectiveType.name.id === 'cds.Composition') {
         xsnCard.sourceMin = { literal: 'number', val: 1 };
         xsnCard.sourceMax = { literal: 'number', val: 1 };
       }
       else {
-        xsnCard.sourceMax = { literal: 'string', val: '*' }
+        xsnCard.sourceMax = { literal: 'string', val: '*' };
       }
 
-      if(assoc.cardinality) {
-        if(assoc.cardinality.sourceMax && assoc.cardinality.sourceMax.val === 1) {
+      if (assoc.cardinality) {
+        if (assoc.cardinality.sourceMax && assoc.cardinality.sourceMax.val === 1) {
           xsnCard.sourceMax.literal = 'number';
           xsnCard.sourceMax.val = 1;
         }
-        if(assoc.cardinality.targetMax && assoc.cardinality.targetMax.val !== 1) {
+        if (assoc.cardinality.targetMax && assoc.cardinality.targetMax.val !== 1) {
           xsnCard.targetMax.literal = 'string';
           xsnCard.targetMax.val = '*';
         }
-        else if(assoc.cardinality.targetMin && assoc.cardinality.targetMin.val === 1)
+        else if (assoc.cardinality.targetMin && assoc.cardinality.targetMin.val === 1) {
           xsnCard.targetMin = { literal: 'number', val: 1 };
+        }
       }
       return xsnCard;
     }
     // produce the ON condition for a given association
-    function createOnCondition(assoc, srcAlias, tgtAlias, compareTenants)
-    {
+    function createOnCondition(assoc, srcAlias, tgtAlias, compareTenants) {
       const prefixes = [ assoc.name.id ];
       /* This is no art and can be removed once ON cond for published
           and renamed backlink assocs are publicly available. Example:
@@ -565,82 +554,82 @@ function translateAssocsToJoins(model, inputOptions = {})
         This requires ON cond rewritten to: $self = foo.toE but instead its still $self = toEb.toE,
         so prefix 'foo' won't match....
       */
-      if(assoc._origin && !prefixes.includes(assoc._origin.name.id))
+      if (assoc._origin && !prefixes.includes(assoc._origin.name.id))
         prefixes.push(assoc._origin.name.id);
 
       // produce the ON condition of the managed association
-      if(assoc.foreignKeys)
-      {
+      if (assoc.foreignKeys) {
         /*
           Get both the source and the target column names for the EQ term.
           For the src side provide a path prefix for all paths that is the assocElement name itself preceded by
           the path up to the first lead artifact (usually the entity or view) (or in QAT speak: follow the parent
           QATs until a QA has been found).
         */
-        if(!assoc.$flatSrcFKs)
+        if (!assoc.$flatSrcFKs)
           setProp(assoc, '$flatSrcFKs', flattenElement(assoc, true, assoc.name.id, assoc.name.id));
-        if(!assoc.$flatTgtFKs)
+        if (!assoc.$flatTgtFKs)
           setProp(assoc, '$flatTgtFKs', flattenElement(assoc, false));
 
-        if(assoc.$flatSrcFKs.length != assoc.$flatTgtFKs.length)
-          throw new CompilerAssertion('srcPaths length ['+assoc.$flatSrcFKs.length+'] != tgtPaths length ['+assoc.$flatTgtFKs.length+']');
+        if (assoc.$flatSrcFKs.length !== assoc.$flatTgtFKs.length)
+          throw new CompilerAssertion(`srcPaths length [${ assoc.$flatSrcFKs.length }] != tgtPaths length [${ assoc.$flatTgtFKs.length }]`);
 
         /*
           Put all src/tgt path siblings into the EQ term and create the proper path objects
           with the src/tgt table alias path steps in front.
         */
         const args = compareTenants && addTenantComparison(assoc) || [];
-        for(let i = 0; i < assoc.$flatSrcFKs.length; i++)
-        {
-          args.push({op: {val: '=' },
+        for (let i = 0; i < assoc.$flatSrcFKs.length; i++) {
+          args.push({
+            op: { val: '=' },
             args: [ constructPathNode( [ srcAlias, prefixFK(assoc.$elementPrefix, assoc.$flatSrcFKs[i]) ] ),
-                    constructPathNode( [ tgtAlias, assoc.$flatTgtFKs[i] ] ) ] });
+              constructPathNode( [ tgtAlias, assoc.$flatTgtFKs[i] ] ) ],
+          });
         }
         // TODO: why inner "parenthesise" - comparison in `and`?
         return parenthesise((args.length > 1 ? { op: { val: 'and' }, args: [ ...args.map(parenthesise) ] } : args[0] ));
       }
       else if (assoc.on) {
-        if(env.assocStack === undefined) {
+        if (env.assocStack === undefined) {
           env.assocStack = [];
-          env.assocStack.head = function() {
-            return this[this.length-1];
-          }
-          env.assocStack.id = function() {
+          env.assocStack.head = function head() {
+            return this[this.length - 1];
+          };
+          env.assocStack.id = function id() {
             return (this.head() && this.head().name.id);
-          }
-          env.assocStack.element = function() {
+          };
+          env.assocStack.element = function element() {
             return (this.head() && (this.head().name.element || this.head().name.id));
-          }
-          env.assocStack.stripAssocPrefix = function(path) {
+          };
+          env.assocStack.stripAssocPrefix = function stripAssocPrefix(path) {
             return this.stripPrefix(path);
-          }
+          };
 
           // offset must be a negative value to indicate prefix length
           // offset=0 includes the element assoc id itself
-          env.assocStack.stripPrefix = function(path, offset=0) {
+          env.assocStack.stripPrefix = function stripPrefix(path, offset = 0) {
             const elt = this.element();
             const id = this.id();
-            if(elt) {
+            if (elt) {
               let found = true;
-              const epath = [elt];
-              const epl = epath.length+offset;
-              if(epl < path.length) {
-                for(let i = 0; i < epl && found; i++) {
+              const epath = [ elt ];
+              const epl = epath.length + offset;
+              if (epl < path.length) {
+                for (let i = 0; i < epl && found; i++)
                   found = epath[i] === path[i].id;
-                }
-                if(found)
+
+                if (found)
                   return path.slice(epl);
               }
             }
-            if(id) {
+            if (id) {
               let found = true;
-              const epath = [id];
-              const epl = epath.length+offset;
-              if(epl < path.length) {
-                for(let i = 0; i < epl && found; i++) {
+              const epath = [ id ];
+              const epl = epath.length + offset;
+              if (epl < path.length) {
+                for (let i = 0; i < epl && found; i++)
                   found = epath[i] === path[i].id;
-                }
-                if(found)
+
+                if (found)
                   return path.slice(epl);
               }
             }
@@ -651,12 +640,13 @@ function translateAssocsToJoins(model, inputOptions = {})
         const onCond = cloneOnCondition(assoc.on);
         env.assocStack.pop();
         return compareTenants ? addTenantComparison(assoc, onCond) : onCond;
-
-      } else if (!hasPersistenceSkipAnnotation(assoc._main)) {
+      }
+      else if (!hasPersistenceSkipAnnotation(assoc._main)) {
         // TODO: exclude non-persisted entities from SQL generation; they may have
         //       to-many associations without foreign keys nor ON-condition.
-        throw new CompilerAssertion(`Association must have either ON-condition or foreign keys: ${assoc.name.id} at ${JSON.stringify(assoc.location)}`);
-      } else {
+        throw new CompilerAssertion(`Association must have either ON-condition or foreign keys: ${ assoc.name.id } at ${ JSON.stringify(assoc.location) }`);
+      }
+      else {
         return null;
       }
 
@@ -666,13 +656,13 @@ function translateAssocsToJoins(model, inputOptions = {})
         // the current query must also be (check in addTenantFields).  If we allow
         // assocs from tenant-independent entities to tenant-dependent ones, we
         // also need to use the current query = `env.lead`.
-        if(annotationVal(assoc.target._artifact['@cds.tenant.independent']))
+        if (annotationVal(assoc.target._artifact['@cds.tenant.independent']))
           return cond;
 
         const args = [ constructPathNode([ srcAlias ]), constructPathNode([ tgtAlias ]) ];
         args[0].path.push({ id: 'tenant' }); // no need for _artifact
         args[1].path.push({ id: 'tenant' }); // no need for _artifact
-        const comparison = { op: {val: '=' }, args };
+        const comparison = { op: { val: '=' }, args };
         if (!cond)              // for managed assoc
           return [ comparison ];
         return { op: { val: 'and' }, args: [ comparison, parenthesise(cond) ] };
@@ -680,41 +670,36 @@ function translateAssocsToJoins(model, inputOptions = {})
 
       // make foreign key absolute to its main entity
       function prefixFK(prefix, fk) {
-        return prefix ? { id: prefix+fk.id, _artifact: fk._artifact } : fk
+        return prefix ? { id: prefix + fk.id, _artifact: fk._artifact } : fk;
       }
       // clone ON condition with rewritten paths and substituted backlink conditions
-      function cloneOnCondition(expr)
-      {
+      function cloneOnCondition(expr) {
         const op = expr.op?.val;
-        if(op === 'xpr' || op === 'ixpr' || op === 'nary')
+        if (op === 'xpr' || op === 'ixpr' || op === 'nary')
           return cloneOnCondExprStream(expr);
-        else
-          return cloneOnCondExprTree(expr);
+        return cloneOnCondExprTree(expr);
       }
 
       function cloneOnCondExprStream(expr) {
-        const args = expr.args;
+        const { args } = expr;
         const result = { op: { val: expr.op.val }, args: [ ] };
-        for(let i = 0; i < args.length; i++)
-        {
+        for (let i = 0; i < args.length; i++) {
           const op = args[i].op?.val;
-          if(op === 'xpr' || op === 'ixpr' || op === 'nary')
-          {
+          if (op === 'xpr' || op === 'ixpr' || op === 'nary') {
             result.args.push(cloneOnCondition(args[i]));
           }
           // If this is a backlink condition, produce the
           // ON cond of the forward assoc with swapped src/tgt aliases
-          else if(i < args.length-2 && args[i].path &&
-                  args[i+1]?.literal === 'token' && args[i+1]?.val === '=' && args[i+2].path)
-          {
-            const fwdAssoc = getForwardAssociation(args[i].path, args[i+2].path);
-            if(fwdAssoc)
-            {
-              //env.assocStack.includes(fwdAssoc) => recursion
-              if(env.assocStack.length === 2) {
-                error('type-invalid-self', [env.assocStack[0].location, env.assocStack[0]], { name: '$self' });
+          else if (i < args.length - 2 && args[i].path &&
+                  args[i + 1]?.literal === 'token' && args[i + 1]?.val === '=' && args[i + 2].path) {
+            const fwdAssoc = getForwardAssociation(args[i].path, args[i + 2].path);
+            if (fwdAssoc) {
+              // env.assocStack.includes(fwdAssoc) => recursion
+              if (env.assocStack.length === 2) {
+                error('type-invalid-self', [ env.assocStack[0].location, env.assocStack[0] ], { name: '$self' });
                 // don't check these paths again
-                args[i].$check = args[i+2].$check = false;
+                args[i].$check = false;
+                args[i + 2].$check = false;
               }
               else {
                 result.args.push(createOnCondition(fwdAssoc, ...swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias)));
@@ -722,11 +707,13 @@ function translateAssocsToJoins(model, inputOptions = {})
               i += 2; // skip next two tokens and continue with loop
               continue;
             }
-            else // it's ensured that it's a path
+            else { // it's ensured that it's a path
               result.args.push(rewritePathNode(args[i]));
+            }
           }
-          else // could be `{op:…}`, clone generically
+          else { // could be `{op:…}`, clone generically
             result.args.push(cloneOnCondition(args[i]));
+          }
         }
         return result;
       }
@@ -734,30 +721,32 @@ function translateAssocsToJoins(model, inputOptions = {})
       function cloneOnCondExprTree(expr) {
         // TODO: This function is not covered by an tests, only cloneOnCondExprStream is.
         // keep parentheses intact
-        if(Array.isArray(expr))
+        if (Array.isArray(expr))
           return expr.map(cloneOnCondition);
 
         // If this is a backlink condition, produce the
         // ON cond of the forward assoc with swapped src/tgt aliases
         const fwdAssoc = getForwardAssociationExpr(expr);
-        if(fwdAssoc) {
-          if(env.assocStack.length === 2) {
+        if (fwdAssoc) {
+          if (env.assocStack.length === 2) {
             // reuse (ugly) error message from forHana
-            error(null, expr.location, 'An association that uses “$self” in its ON-condition can\'t be compared to “$self”');
+            error(null, expr.location, { id: '$self' },
+                  'An association that uses $(ID) in its ON-condition can\'t be compared to $(ID)');
             // don't check these paths again
-            expr.args.forEach(x => x.$check = false );
+            expr.args.forEach((x) => {
+              x.$check = false;
+            } );
             return expr;
           }
-          else {
-            return createOnCondition(fwdAssoc, ...swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias));
-          }
+
+          return createOnCondition(fwdAssoc, ...swapTableAliasesForFwdAssoc(fwdAssoc, srcAlias, tgtAlias));
         }
 
         // If this is an ordinary expression, clone it and mangle its arguments
         // this will substitute multiple backlink conditions ($self = ... AND $self = ...AND ...)
-        if(expr.op) {
+        if (expr.op) {
           const x = clone(expr);
-          if(expr.args)
+          if (expr.args)
             x.args = expr.args.map(cloneOnCondition);
           return x;
         }
@@ -778,7 +767,7 @@ function translateAssocsToJoins(model, inputOptions = {})
 
         let i = 0;
         let fwdOrigin = fwdAssoc;
-        while(fwdOrigin._origin) {
+        while (fwdOrigin._origin) {
           fwdOrigin = fwdOrigin._origin;
           i++;
         }
@@ -786,52 +775,50 @@ function translateAssocsToJoins(model, inputOptions = {})
         // points to the signature of the current view and ensures that the ON cond is
         // resolvable) make sure that the original assoc target is contained in the local
         // query source
-        if(assoc.kind === 'mixin' && i > 0 && fwdOrigin.kind !== 'mixin') {
+        if (assoc.kind === 'mixin' && i > 0 && fwdOrigin.kind !== 'mixin') {
           const tas = Object.values(env.lead.$tableAliases);
           const i = tas.findIndex(ta => ta._artifact === fwdOrigin.target._artifact);
-          if(i >= 0 && tas[i].$QA) {
+          if (i >= 0 && tas[i].$QA) {
             newTgtAlias.id = tas[i].$QA.name.id;
             newTgtAlias._artifact = tas[i]._effectiveType;
             newTgtAlias._navigation = tas[i].$QA.path[0]._navigation;
           }
           else {
             error(null, [ assocQAT._origin.location, assocQAT._origin ], { name: fwdOrigin.target._artifact.name.id, art: assoc.name.id },
-                    'Expected association target $(NAME) of association $(ART) to be a query source');
+                  'Expected association target $(NAME) of association $(ART) to be a query source');
             newTgtAlias = Object.assign(newTgtAlias, srcAlias);
           }
         }
         else {
           newTgtAlias = Object.assign(newTgtAlias, srcAlias);
         }
-        return [newSrcAlias, newTgtAlias];
+        return [ newSrcAlias, newTgtAlias ];
       }
 
-      function rewritePathNode(pathNode)
-      {
+      function rewritePathNode(pathNode) {
         let tableAlias;
-        let path = pathNode.path;
-        if(!path) // it's not a path return it
+        let { path } = pathNode;
+        if (!path) // it's not a path return it
           return pathNode;
 
-        let [head, ...tail] = path;
+        let [ head, ...tail ] = path;
 
         // don't rewrite path
-        if(internalArtifactKinds.includes(head._artifact.kind))
+        if (internalArtifactKinds.includes(head._artifact.kind))
           return pathNode;
 
         // strip the absolute path indicators
         let hasDollarSelfPrefix = false;
-        if (['$projection', '$self'].includes(head.id) && tail.length) {
+        if ([ '$projection', '$self' ].includes(head.id) && tail.length) {
           hasDollarSelfPrefix = true;
           path = tail;
         }
 
-        if(!checkPathDictionary(pathNode, env)) {
+        if (!checkPathDictionary(pathNode, env))
           return pathNode;
-        }
 
-        if(rhs.mixin)
-        {
+
+        if (rhs.mixin) {
           if (hasDollarSelfPrefix) {
             /* Do the $projection resolution ONLY in own query not for referenced forward ON condition
             view YP as select from Y mixin ( toXP: association to XP on $projection.yid = toXP.xid; } into { yid };
@@ -839,22 +826,21 @@ function translateAssocsToJoins(model, inputOptions = {})
             X join Y ON ($self = toYP.toXP) => ($projection.yid = toXP.xid) => (Y.yid = X.xid)
             $projection must be removed from $projection.yid (get's aliased with the mixinAssocQAT.$QA)
             */
-            if(env.assocStack.length < 2) {
-              const value = env.lead.elements[path[0].id].value;
+            if (env.assocStack.length < 2) {
+              const { value } = env.lead.elements[path[0].id];
               /*
                 If the value is an expression in the select block, return the unmodified
                 expression. rewriteGenericPaths will check and rewrite these paths later
                 to the correct ON condition expression.
               */
 
-              if(!value.path)
+              if (!value.path)
                 return value;
-              else {
-                // check for associations, not allowed at this time, trouble in resolving
-                // and addressing the correct foreign key (tuple)
-                [ head, ...tail ] = path;
-                path = value.path.concat(tail);
-              }
+
+              // check for associations, not allowed at this time, trouble in resolving
+              // and addressing the correct foreign key (tuple)
+              [ head, ...tail ] = path;
+              path = value.path.concat(tail);
             }
           }
           else {
@@ -889,20 +875,21 @@ function translateAssocsToJoins(model, inputOptions = {})
             'toTgt.elt' must now be rendered for each JOIN using the correct QA clone.
           */
 
-          if(assocQAT.$QA.mixin)
+          if (assocQAT.$QA.mixin)
             assocQAT._parent.$QA = assocQAT.$QA;
 
           /* if the $projection path has association path steps make sure to address the
              element by its last table alias name. Search from the end upwards
              to the top for the first association path step and cut off path here.
            */
-          let i = path.length-1;
-          while(i >= 0 && !path[i--]._artifact.target);
+          let i = path.length - 1;
+          while (i >= 0 && !path[i--]._artifact.target)
+            ;
           // if this mixin ON condition path had a $projection/$self prefix, it could be
           // that the path of the select list had many many associations, we're only interested in
           // the last one (see MixinUsage2.cds V.toX as an example)
-          if(hasDollarSelfPrefix)
-            path.splice(0, i+1);
+          if (hasDollarSelfPrefix)
+            path.splice(0, i + 1);
 
           /*
             If the mixin is a backlink to some forward association, the forward ON condition
@@ -946,58 +933,60 @@ function translateAssocsToJoins(model, inputOptions = {})
               lead to V.query[0].$tableAliases.$A. Instead we need to lookup the element in the
               combined list of elements made available by the from clause.
           */
-          let _navigation = undefined; // don't modify original path
-          if(env.assocStack.length === 2) {
+          let _navigation; // don't modify original path
+          if (env.assocStack.length === 2) {
             // a mixin assoc cannot have a structure prefix, it's sufficient to check head
-            if(head.id === env.assocStack.id()) {
+            if (head.id === env.assocStack.id()) {
               // source side from view point of view (target side from forward point of view)
               path = tail; // pop assoc step
               const elt = env.lead._combined[path[0].id];
 
-              if(elt) {
-                if(Array.isArray(elt)) {
+              if (elt) {
+                if (Array.isArray(elt)) {
                   const names = elt.map(e => (e._origin._main || e._origin).name.id);
-                  error(null, [ assocQAT._origin.location, assocQAT._origin ], { elemref: path[0].id, id: assoc.name.id, art: assoc._main, names },
-                    'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) is available from multiple query sources $(NAMES)');
+                  error(null, [ assocQAT._origin.location, assocQAT._origin ], {
+                    elemref: path[0].id, id: assoc.name.id, art: assoc._main, names,
+                  },
+                        'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) is available from multiple query sources $(NAMES)');
                   return pathNode.path;
-                } else {
-                  // check if element has same origin on both ends
-                  if(elt._origin._main !== path[0]._artifact._origin._main) {
-                    warning(null, [ assocQAT._origin.location, assocQAT._origin ], {
-                      elemref: path[0].id,
-                      id: assoc.name.id, art: assoc._main.name.id,
-                      name: path[0]._artifact._origin._main.name.id,
-                      alias: elt._origin._main.name.id,
-                      source: elt._main.name.id,
-                    }, 'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) originates from $(NAME) and from $(ALIAS) in $(SOURCE)');
-                  }
-                  _navigation = elt._parent;
                 }
-              } else {
+                // check if element has same origin on both ends
+                if (elt._origin._main !== path[0]._artifact._origin._main) {
+                  warning(null, [ assocQAT._origin.location, assocQAT._origin ], {
+                    elemref: path[0].id,
+                    id: assoc.name.id,
+                    art: assoc._main.name.id,
+                    name: path[0]._artifact._origin._main.name.id,
+                    alias: elt._origin._main.name.id,
+                    source: elt._main.name.id,
+                  }, 'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) originates from $(NAME) and from $(ALIAS) in $(SOURCE)');
+                }
+                _navigation = elt._parent;
+              }
+              else {
                 error(null, [ assocQAT._origin.location, assocQAT._origin ], { elemref: path[0].id, id: assoc.name.id, art: (assoc._main || assoc) },
-                  'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) has not been found');
+                      'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) has not been found');
                 return pathNode.path;
               }
-            } else {
+            }
+            else {
               // target side from view point of view (source side from forward point of view)
-              //if(assocQAT.$QA._artifact === path[0]._artifact._parent)
+              // if(assocQAT.$QA._artifact === path[0]._artifact._parent)
               _navigation = assocQAT;
             }
           }
           [ tableAlias, path ] = constructTableAliasAndTailPath(path, _navigation);
         }
-        else // ON condition of non-mixin association
-        {
+        else { // ON condition of non-mixin association
           // strip a structure prefix from this ON cond path (offset -1)
-          [ head, ...tail ] = path = env.assocStack.stripPrefix(path, -1);
-          if(prefixes.includes(head.id)) // target side
-          {
+          path = env.assocStack.stripPrefix(path, -1);
+          [ head, ...tail ] = path;
+          if (prefixes.includes(head.id)) { // target side
             // no element prefix on target side
             path = translateONCondPath(tail);
             tableAlias = tgtAlias;
           }
-          else // source side
-          {
+          else { // source side
             tableAlias = srcAlias;
             // if path is not an absolute path, prepend element prefix
             path = translateONCondPath(path, !hasDollarSelfPrefix ? assoc.$elementPrefix : undefined);
@@ -1009,25 +998,25 @@ function translateAssocsToJoins(model, inputOptions = {})
 
       // Return the original association if expr is a backlink term, undefined otherwise
       function getForwardAssociationExpr(expr) {
-        if(expr.op && expr.op.val === '=' && expr.args.length === 2) {
+        if (expr.op && expr.op.val === '=' && expr.args.length === 2)
           return getForwardAssociation(expr.args[0].path, expr.args[1].path);
-        }
+
         return undefined;
       }
 
       function getForwardAssociation(lhs, rhs) {
         // [alpha.]BACKLINK.[beta.]FORWARD
-        if(lhs && rhs) {
-          if(rhs.length === 1 && rhs[0].id === '$self' &&
+        if (lhs && rhs) {
+          if (rhs.length === 1 && rhs[0].id === '$self' &&
               lhs.length > 1 && hasPrefix(lhs))
-            return lhs[lhs.length-1]._artifact;
-          if(lhs.length === 1 && lhs[0].id === '$self' &&
+            return lhs[lhs.length - 1]._artifact;
+          if (lhs.length === 1 && lhs[0].id === '$self' &&
               rhs.length > 1 && hasPrefix(rhs))
-            return rhs[rhs.length-1]._artifact;
+            return rhs[rhs.length - 1]._artifact;
         }
 
         function hasPrefix(path) {
-          return path.reduce((rc, ps) => !rc ? (ps.id == env.assocStack.id()) : rc, false);
+          return path.reduce((rc, ps) => (!rc ? (ps.id === env.assocStack.id()) : rc), false);
         }
         return undefined;
       }
@@ -1038,41 +1027,38 @@ function translateAssocsToJoins(model, inputOptions = {})
     A QA (QueryArtifact) is a representative for a table/view that must appear
     in the FROM clause either named directly or indirectly through an association.
    */
-  function createQA(env, artifact, alias, namedArgs=undefined)
-  {
-    if(alias === undefined) {
+  function createQA(env, artifact, alias, namedArgs = undefined) {
+    if (alias === undefined)
       throw new CompilerAssertion('no alias provided');
-    }
+
 
     const pathStep = {
       id: (artifact._main || artifact).name.id,
       _artifact: artifact,
-      _navigation : { name: { select: env.queryIndex + 1 } } // ???
+      _navigation: { name: { select: env.queryIndex + 1 } }, // ???
     };
 
-    if(namedArgs)
+    if (namedArgs)
       pathStep.args = namedArgs;
-    if(isBooleanAnnotation(artifact['@cds.persistence.udf'], true))
+    if (isBooleanAnnotation(artifact['@cds.persistence.udf'], true))
       pathStep.$syntax = 'udf';
-    if(isBooleanAnnotation(artifact['@cds.persistence.calcview'], true))
+    if (isBooleanAnnotation(artifact['@cds.persistence.calcview'], true))
       pathStep.$syntax = 'calcview';
 
-    const node = constructPathNode( [ pathStep  ], alias );
+    const node = constructPathNode( [ pathStep ], alias );
     return node;
   }
 
   // Remark CW: why boolean and not just truthy/falsy as usual?  See annotationVal() below
-  function isBooleanAnnotation(prop, val=true) {
+  function isBooleanAnnotation(prop, val = true) {
     return prop && prop.val !== undefined && prop.val === val && prop.literal === 'boolean';
   }
 
-  function incAliasCount(env, QA)
-  {
-    if(!QA.numberedAlias)
-    {
+  function incAliasCount(env, QA) {
+    if (!QA.numberedAlias) {
       // Debug only:
       // QA.name.id += '_' + (QA.path[0]._navigation === undefined ? '***navigation_missing***' : QA.path[0]._navigation.name.select) + '_' + env.aliasCount++;
-      QA.name.id += '_' + env.aliasCount++;
+      QA.name.id += `_${ env.aliasCount++ }`;
       QA.numberedAlias = true;
     }
   }
@@ -1088,8 +1074,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     tableAlias = [ aliasName, _artifact, _navigation ]
     path = [ { id: ..., _artifact: ... (unused) } ]
   */
-  function rewritePathsInFilterExpression(node, getTableAliasAndPathSteps, env)
-  {
+  function rewritePathsInFilterExpression(node, getTableAliasAndPathSteps, env) {
     const innerEnv = {
       lead: env.lead,
       location: env.location,
@@ -1097,10 +1082,10 @@ function translateAssocsToJoins(model, inputOptions = {})
       aliasCount: env.aliasCount,
       walkover: {},
       callback: [
-        function(pathNode) {
-          if(checkPathDictionary(pathNode, env)) {
+        function rewritePathNode(pathNode) {
+          if (checkPathDictionary(pathNode, env)) {
             const head = pathNode.path[0];
-            if(head._navigation?.kind === '$self') {
+            if (head._navigation?.kind === '$self') {
               substituteDollarSelf(pathNode);
             }
             else {
@@ -1109,14 +1094,14 @@ function translateAssocsToJoins(model, inputOptions = {})
               const leafArtifact = path.at(-1)._artifact;
               // Walk from left to right and search for first assoc. If assocs in filters become join relevant in the future,
               // i.e. not only fk-access, we need to revisit this
-              for(let i = 0; i < path.length; i++) {
+              for (let i = 0; i < path.length; i++) {
                 const pathStep = path[i];
-                if(pathStep._artifact?.foreignKeys) {
+                if (pathStep._artifact?.foreignKeys) {
                   const possibleNonAliasedFkName = path.slice(i).map(ps => ps.id).join(pathDelimiter);
-                  if(!pathStep._artifact.$flatSrcFKs)
-                      setProp(pathStep._artifact, '$flatSrcFKs', flattenElement(pathStep._artifact, true, pathStep._artifact.name.id, pathStep._artifact.name.id));
+                  if (!pathStep._artifact.$flatSrcFKs)
+                    setProp(pathStep._artifact, '$flatSrcFKs', flattenElement(pathStep._artifact, true, pathStep._artifact.name.id, pathStep._artifact.name.id));
                   const fk = pathStep._artifact.$flatSrcFKs.find(f => f._artifact === leafArtifact && f.acc.startsWith(possibleNonAliasedFkName));
-                  if(fk) {
+                  if (fk) {
                     rewrittenPath.push(fk);
                     i = path.length;
                     continue;
@@ -1128,7 +1113,8 @@ function translateAssocsToJoins(model, inputOptions = {})
               replaceNodeContent(pathNode, constructPathNode([ tableAlias, { id: rewrittenPath.map(ps => ps.id).join(pathDelimiter), _artifact: pathNode._artifact } ]));
             }
           }
-        } ]
+        },
+      ],
     };
     walk(node, innerEnv);
   }
@@ -1139,11 +1125,11 @@ function translateAssocsToJoins(model, inputOptions = {})
     If newNode is a path => oldNode._artifact === newNode._artifact, no need to
     exchange _artifact (as non-iterable property it is not assigned).
   */
-  function replaceNodeContent(oldNode, newNode)
-  {
-    if(!newNode.path) {
-      Object.keys(oldNode).forEach(k => {
-        delete oldNode[k] });
+  function replaceNodeContent(oldNode, newNode) {
+    if (!newNode.path) {
+      Object.keys(oldNode).forEach((k) => {
+        delete oldNode[k];
+      });
       delete oldNode._artifact;
     }
     Object.assign(oldNode, newNode);
@@ -1157,7 +1143,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     if (tableAlias._joinParent)
       tableAlias._joinParent.args[tableAlias.$joinArgsIndex] = replacementNode;
     else
-        tableAlias._parent.from = replacementNode;
+      tableAlias._parent.from = replacementNode;
   }
 
   /*
@@ -1165,72 +1151,63 @@ function translateAssocsToJoins(model, inputOptions = {})
     respecting the src or the target side of the ON condition.
     Return an array of column names and it's leaf element.
    */
-  function flattenElement(element, srcSide, prefix, acc)
-  {
+  function flattenElement(element, srcSide, prefix, acc) {
     // terminate if element is unstructured
-    if(!element.foreignKeys && !element.elements)
+    if (!element.foreignKeys && !element.elements)
       return [ { id: prefix, _artifact: element, acc } ];
 
     let paths = [];
     // get paths of managed assocs (unmanaged assocs are not allowed in FK paths)
-    if(element.foreignKeys)
-    {
-      for(const fkn in element.foreignKeys)
-      {
+    if (element.foreignKeys) {
+      for (const fkn in element.foreignKeys) {
         const fk = element.foreignKeys[fkn];
         // ignore an unmanaged association
-        if(fk.targetElement._artifact.target &&
+        if (fk.targetElement._artifact.target &&
            fk.targetElement._artifact.on &&
            !fk.targetElement._artifact.foreignKeys)
           continue;
         // once a fk is to be followed, treat all sub-paths as srcSide, this will add fk.name.id only
-        if(srcSide)
-          paths = paths.concat(flattenElement(fk.targetElement._artifact, true,  fk.name.id, fk.targetElement.path.map(ps => ps.id).join(pathDelimiter)));
-        else
-        {
+        if (srcSide) {
+          paths = paths.concat(flattenElement(fk.targetElement._artifact, true, fk.name.id, fk.targetElement.path.map(ps => ps.id).join(pathDelimiter)));
+        }
+        else {
           // consume path segments until the next assoc and substitute against fk alias until path is eaten up
           let [ assocStep, tail, fkPrefix ] = pathAsStringUpToAssoc(fk.targetElement.path);
-          while(assocStep && tail.length)
-          {
-            [tail, fkPrefix] = substituteFKAliasForPath(assocStep, tail, fkPrefix);
-            [assocStep, tail, fkPrefix] = pathAsStringUpToAssoc(tail, fkPrefix);
+          while (assocStep && tail.length) {
+            [ tail, fkPrefix ] = substituteFKAliasForPath(assocStep, tail, fkPrefix);
+            [ assocStep, tail, fkPrefix ] = pathAsStringUpToAssoc(tail, fkPrefix);
           }
           paths = paths.concat(flattenElement(fk.targetElement._artifact, true, fkPrefix, fk.targetElement.path.map(ps => ps.id).join(pathDelimiter)));
         }
       }
     }
     // get paths of plain structured elements
-    else if(element.elements)
-    {
-      for(const n in element.elements)
-      {
+    else if (element.elements) {
+      for (const n in element.elements) {
         const elt = element.elements[n];
         paths = paths.concat(flattenElement(elt, true, elt.name.id, elt.name.id));
       }
     }
-    return paths.map(p => {
-      return {
-        id: (prefix ? prefix + pathDelimiter : '' ) + p.id,
-        acc: (acc ? acc + pathDelimiter : '') + p.acc,
-        _artifact: p._artifact
-      }
-    } );
+    return paths.map(p => ({
+      id: (prefix ? prefix + pathDelimiter : '' ) + p.id,
+      acc: (acc ? acc + pathDelimiter : '') + p.acc,
+      _artifact: p._artifact,
+    }) );
   }
 
 
   /*
     Construct both the TA path step and the path tail for a given AST path array
    */
-  function constructTableAliasAndTailPath(path, navigation=undefined)
-  {
-    const [head, ...tail] = path;
-    if(navigation === undefined)
+  function constructTableAliasAndTailPath(path, navigation = undefined) {
+    const [ head, ...tail ] = path;
+    if (navigation === undefined)
       navigation = head._navigation;
 
     const QA = navigation.$QA || navigation._parent.$QA;
 
     // First path step is table alias, use and pop it off
-    if(navigation.$QA && tail.length > 0)
+    if (navigation.$QA && tail.length > 0)
       path = tail;
 
     return [ constructTableAliasPathStep(QA), path ];
@@ -1242,15 +1219,13 @@ function translateAssocsToJoins(model, inputOptions = {})
   /*
     Translate ON cond paths and substitute FK aliases
   */
-  function translateONCondPath(path, prefix)
-  {
+  function translateONCondPath(path, prefix) {
     let [ assocStep, tail, fkPrefix ] = pathAsStringUpToAssoc(path);
-    while(assocStep && tail.length)
-    {
-      [tail, fkPrefix] = substituteFKAliasForPath(assocStep, tail, fkPrefix);
-      [assocStep, tail, fkPrefix] = pathAsStringUpToAssoc(tail, fkPrefix);
+    while (assocStep && tail.length) {
+      [ tail, fkPrefix ] = substituteFKAliasForPath(assocStep, tail, fkPrefix);
+      [ assocStep, tail, fkPrefix ] = pathAsStringUpToAssoc(tail, fkPrefix);
     }
-    return [ { id: (prefix ? prefix + fkPrefix : fkPrefix), _artifact: path[path.length-1]._artifact } ];
+    return [ { id: (prefix ? prefix + fkPrefix : fkPrefix), _artifact: path[path.length - 1]._artifact } ];
   }
 
   /*
@@ -1261,17 +1236,16 @@ function translateAssocsToJoins(model, inputOptions = {})
 
     Return assocPathStep, the remaining tail path and the path string
   */
-  function pathAsStringUpToAssoc(path, pathStr)
-  {
-    if(!pathStr)
+  function pathAsStringUpToAssoc(path, pathStr) {
+    if (!pathStr)
       pathStr = '';
-    const assocStep = path.find(ps => {
-      if(pathStr.length > 0)
+    const assocStep = path.find((ps) => {
+      if (pathStr.length > 0)
         pathStr += pathDelimiter;
       pathStr += ps.id;
       return (ps._artifact.target); // true if it has a target => is assoc => terminate find
     });
-    return [ assocStep, path.slice(path.indexOf(assocStep)+1), pathStr ];
+    return [ assocStep, path.slice(path.indexOf(assocStep) + 1), pathStr ];
   }
 
   /*
@@ -1291,18 +1265,15 @@ function translateAssocsToJoins(model, inputOptions = {})
    * @param {any[]}   path
    * @param {string} [pathStr='']
    */
-  function substituteFKAliasForPath(assocStep, path, pathStr='')
-  {
-    if(assocStep && assocStep._artifact && assocStep._artifact.$fkPathPrefixTree) {
+  function substituteFKAliasForPath(assocStep, path, pathStr = '') {
+    if (assocStep && assocStep._artifact && assocStep._artifact.$fkPathPrefixTree) {
       let ppt = assocStep._artifact.$fkPathPrefixTree.children;
       /** @type any */
-      let fk = undefined; // last found FK
-      let fkPs = undefined; // last path step that found FK
-      path.forEach(ps => {
-        if(ppt[ps.id])
-        {
-          if(ppt[ps.id]._fk)
-          {
+      let fk; // last found FK
+      let fkPs; // last path step that found FK
+      path.forEach((ps) => {
+        if (ppt[ps.id]) {
+          if (ppt[ps.id]._fk) {
             fk = ppt[ps.id]._fk;
             fkPs = ps;
           }
@@ -1310,24 +1281,21 @@ function translateAssocsToJoins(model, inputOptions = {})
         }
       });
 
-      if(fk)
-      {
-        if(pathStr.length)
+      if (fk) {
+        if (pathStr.length)
           pathStr += pathDelimiter;
         pathStr += fk.name.id;
       }
 
-      const tail = path.slice(path.indexOf(fkPs)+1);
+      const tail = path.slice(path.indexOf(fkPs) + 1);
       // If foreign key is an association itself, apply substituteFKAliasForPath on tail
-      if(fk && fk.targetElement._artifact.target && tail.length)
+      if (fk && fk.targetElement._artifact.target && tail.length)
         return substituteFKAliasForPath(fk.targetElement, tail, pathStr);
-      else
-        return [ tail, pathStr ];
-    }
-    else {
-      //error(null, assocStep.location, `No fkPrefixTree for association, please report this error`);
-      return [ path, pathStr ];
+      return [ tail, pathStr ];
     }
+
+    // error(null, assocStep.location, `No fkPrefixTree for association, please report this error`);
+    return [ path, pathStr ];
   }
 
   /*
@@ -1340,25 +1308,24 @@ function translateAssocsToJoins(model, inputOptions = {})
     4) $self, $projection without suffix should not appear here anymore
     Returns true on success, false otherwise
   */
-  function checkPathDictionary(pathDict, env)
-  {
-    if(pathDict.$check !== undefined)
+  function checkPathDictionary(pathDict, env) {
+    if (pathDict.$check !== undefined)
       return pathDict.$check;
 
     pathDict.$check = true;
 
     // all leaf types must be scalar in a query
-    let path = pathDict.path;
-    let [head, ...tail] = path;
+    let { path } = pathDict;
+    let [ head, ...tail ] = path;
 
     // pop head again if it is a table alias or $projection
-    if(['$projection', '$self'].includes(head.id)) {
+    if ([ '$projection', '$self' ].includes(head.id)) {
       path = tail;
-      [head, ...tail] = path;
+      [ head, ...tail ] = path;
     }
-    if(head && env.tableAliases && env.tableAliases.includes(head.id)) {
+    if (head && env.tableAliases && env.tableAliases.includes(head.id))
       path = tail;
-    }
+
     // assocStack eventually undefined => head is not Assoc
     // assoc prefix can be something structured or just the id, the core
     // compiler decides if it wants to add 'element' or only 'id' to the XSN
@@ -1369,52 +1336,51 @@ function translateAssocsToJoins(model, inputOptions = {})
     const lead = env.art || env.lead;
     path.forEach((ps) => {
       /* checks for all path steps */
-      if(ps.args) {
-        error(null, [pathDict.location, lead],
-          { art: lead._main || lead, id: ps.id },
-          '$(ART): $(ID) must not have parameters');
+      if (ps.args) {
+        error(null, [ pathDict.location, lead ],
+              { art: lead._main || lead, id: ps.id },
+              '$(ART): $(ID) must not have parameters');
         pathDict.$check = false;
       }
-      if(ps.where) {
-        error(null, [pathDict.location, lead],
-          { art: lead._main || lead, id: ps.id },
-          '$(ART): $(ID) must not have a filter');
+      if (ps.where) {
+        error(null, [ pathDict.location, lead ],
+              { art: lead._main || lead, id: ps.id },
+              '$(ART): $(ID) must not have a filter');
         pathDict.$check = false;
       }
-      if(ps._artifact.virtual) {
-        error(null, [pathDict.location, lead],
-          { art: lead._main || lead, id: ps.id },
-          '$(ART): $(ID) must not be virtual');
+      if (ps._artifact.virtual) {
+        error(null, [ pathDict.location, lead ],
+              { art: lead._main || lead, id: ps.id },
+              '$(ART): $(ID) must not be virtual');
         pathDict.$check = false;
       }
       // checks for all path steps except the first one (if it is the name of the defining association)
-      if(ps._artifact && ps._artifact.target)
-      {
+      if (ps._artifact && ps._artifact.target) {
         // if this is not the last path step, complain
-        const la1 = pathDict.path[pathDict.path.indexOf(ps)+1];
-        if(la1) {
-          if(ps._artifact.on)
-          {
-            error(null, [pathDict.location, lead],
-              { art: lead._main || lead, id: ps.id, alias: pathAsStr(pathDict.path) },
-              '$(ART): $(ID) in path $(ALIAS) must not be an unmanaged association');
+        const la1 = pathDict.path[pathDict.path.indexOf(ps) + 1];
+        if (la1) {
+          if (ps._artifact.on) {
+            error(null, [ pathDict.location, lead ],
+                  { art: lead._main || lead, id: ps.id, alias: pathAsStr(pathDict.path) },
+                  '$(ART): $(ID) in path $(ALIAS) must not be an unmanaged association');
             pathDict.$check = false;
           }
-          else if(ps._artifact.$fkPathPrefixTree)// must be managed
-          {
-            if(!ps._artifact.$fkPathPrefixTree.children[la1.id]) {
-              error(null, [pathDict.location, lead],
-                { art: lead._main || lead, id: la1.id, name: ps.id, alias: pathAsStr(pathDict.path) },
-                '$(ART): $(ID) is not foreign key of managed association $(NAME) in path $(ALIAS)' );
+          else if (ps._artifact.$fkPathPrefixTree) { // must be managed
+            if (!ps._artifact.$fkPathPrefixTree.children[la1.id]) {
+              error(null, [ pathDict.location, lead ],
+                    {
+                      art: lead._main || lead, id: la1.id, name: ps.id, alias: pathAsStr(pathDict.path),
+                    },
+                    '$(ART): $(ID) is not foreign key of managed association $(NAME) in path $(ALIAS)' );
               pathDict.$check = false;
             }
           }
         }
         else {
           // it is the last path step => no association
-          error(null, [pathDict.location, lead],
-            { art: lead._main || lead, id: ps.id, alias: pathAsStr(pathDict.path) },
-            '$(ART): $(ID) in path $(ALIAS) must not be an association');
+          error(null, [ pathDict.location, lead ],
+                { art: lead._main || lead, id: ps.id, alias: pathAsStr(pathDict.path) },
+                '$(ART): $(ID) in path $(ALIAS) must not be an association');
           pathDict.$check = false;
         }
       }
@@ -1423,9 +1389,9 @@ function translateAssocsToJoins(model, inputOptions = {})
     const lastSegment = path[path.length - 1];
     const artifact = lastSegment && lastSegment._artifact && lastSegment._artifact.type && lastSegment._artifact.type._artifact && lastSegment._artifact.type._artifact;
     if (artifact && artifact.elements) {
-      error(null, [pathDict.location, lead],
-        { art: lead._main || lead, id: lastSegment.id },
-        '$(ART): $(ID) must have scalar type');
+      error(null, [ pathDict.location, lead ],
+            { art: lead._main || lead, id: lastSegment.id },
+            '$(ART): $(ID) must have scalar type');
       pathDict.$check = false;
     }
     return pathDict.$check;
@@ -1450,23 +1416,23 @@ function translateAssocsToJoins(model, inputOptions = {})
     A node in the path prefix tree is abbreviated as QAT (which stands for Query Association Tree,
     a term originating from way back in time).
   */
-  function mergePathIntoQAT(pathDict, env)
-  {
-    const path = pathDict.path;
+  function mergePathIntoQAT(pathDict, env) {
+    const { path } = pathDict;
 
-    if(path.length === 0)
+    if (path.length === 0)
       return;
 
     let qatChildrenName = '$qat';
-    if(env.location === 'from')
+    if (env.location === 'from')
       qatChildrenName = '$fqat';
-    if(env.location === 'onCondFrom')
+    if (env.location === 'onCondFrom')
       return;
 
-    let [head, ...tail] = path;
+    // eslint-disable-next-line prefer-const
+    let [ head, ...tail ] = path;
 
     // qatParent is the node where the starting qat is attached to
-    let qatParent = undefined;
+    let qatParent;
 
     // Note: If head is $self, we would need to resolve it if the path follows associations.
     //       However, that is already rejected by SQL backend checks. For example $self paths
@@ -1474,17 +1440,16 @@ function translateAssocsToJoins(model, inputOptions = {})
 
     // FROM and filter paths do not have a _navigation, but for filter paths
     // the corresponding path step (to where the filter was attached to) is in env.pathStep
-    if(!head._navigation)
-    {
+    if (!head._navigation) {
       // speciality for OrderBy: If path has no _navigation don't merge it.
       // Path is alias to select item expression
-      if(['OrderBy', 'UnionOuterOrderBy'].includes(env.location))
+      if ([ 'OrderBy', 'UnionOuterOrderBy' ].includes(env.location))
         return;
 
       // env.pathStep is set in walkPath for walk on filter conditions
-      if(env.pathStep)
+      if (env.pathStep)
         qatParent = env.pathStep._navigation;
-      else if(pathDict.name) // from table path with its alias
+      else if (pathDict.name) // from table path with its alias
         qatParent = env.lead.$tableAliases[pathDict.name.id];
       else
         // tableAlias not found yet, last resort is head.id => published Assoc
@@ -1492,32 +1457,28 @@ function translateAssocsToJoins(model, inputOptions = {})
       tail = path; // start with the full path
     }
     // All other paths have a _navigation attribute
-    else if(head._navigation)
-    {
+    else if (head._navigation) {
       /*
         Always start with QAT merge at $tableAlias, even if path doesn't start there.
         First identify $tableAlias (must be either head or head's parent) The resolver
         sets a _navigation at the very first path step that either points to $tableAlias
         or to a top level element from _combined which itself parent's to $tableAlias).
       */
-      if(head._navigation.kind === '$navElement')
-      {
+      if (head._navigation.kind === '$navElement') {
         qatParent = head._navigation._parent;
         tail = path; // Start with the full path (no table alias prefix)
       }
-      else if(head._navigation.kind === 'mixin') // This is a mixin assoc
-      {
+      else if (head._navigation.kind === 'mixin') { // This is a mixin assoc
         qatParent = head._navigation;
         tail = path;
       }
-      else // Head is a table alias already
-      {
+      else { // Head is a table alias already
         qatParent = head._navigation;
       }
     }
 
-    if(qatParent == undefined)
-      throw new CompilerAssertion('table alias/qathost not found for path: ' +  pathAsStr(path));
+    if (qatParent === undefined || qatParent === null)
+      throw new CompilerAssertion(`table alias/qathost not found for path: ${ pathAsStr(path) }`);
 
     const rootQat = qatParent;
 
@@ -1535,22 +1496,21 @@ function translateAssocsToJoins(model, inputOptions = {})
       */
       let qatName = pathStep.id;
 
-      if(pathStep.where) {
-        qatName  += JSON.stringify(compactExpr(pathStep.where));
-      }
-      if(pathStep.args) {
+      if (pathStep.where)
+        qatName += JSON.stringify(compactExpr(pathStep.where));
+
+      if (pathStep.args) {
         // sort named arguments
         const sortedNamedArgs = Object.create(null);
-        Object.keys(pathStep.args).sort().forEach(p => {
+        Object.keys(pathStep.args).sort().forEach((p) => {
           sortedNamedArgs[p] = compactExpr(pathStep.args[p]);
-        })
+        });
         qatName += JSON.stringify(sortedNamedArgs);
       }
 
 
       qat = qatChildren[qatName];
-      if (!qat)
-      {
+      if (!qat) {
         qat = linkToOrigin(pathStep._artifact, pathStep.id, qatParent, undefined, pathStep.location);
         /*
           Query filter have precedence over default filters.
@@ -1558,10 +1518,10 @@ function translateAssocsToJoins(model, inputOptions = {})
           TODO: If Filter become JOIN relevant, default filters MUST BE cloned before starting the transformation
                 or the paths won't be added to the QAT and the rewriting would be done on the filter definition.
         */
-        if(pathStep.where /*|| pathStep._artifact.where*/)
-          qat._filter = pathStep.where /*|| clone(pathStep._artifact.where)*/;
-        if(pathStep.args)
-          qat._namedArgs= pathStep.args;
+        if (pathStep.where /* || pathStep._artifact.where */)
+          qat._filter = pathStep.where; /* || clone(pathStep._artifact.where) */
+        if (pathStep.args)
+          qat._namedArgs = pathStep.args;
 
         /*
           If qat._origin has a QA, it must be a mixin association
@@ -1569,9 +1529,9 @@ function translateAssocsToJoins(model, inputOptions = {})
           template to have space for table aliases (if mixin assoc is
           followed with different filter conditions).
         */
-        if(qat._origin.$QA) {
+        if (qat._origin.$QA) {
           qat.$QA = clone(qat._origin.$QA);
-          if(qat._namedArgs)
+          if (qat._namedArgs)
             qat.$QA.path[0].args = qat._namedArgs;
         }
         qat.kind = '$navElement';
@@ -1597,32 +1557,27 @@ function translateAssocsToJoins(model, inputOptions = {})
         so the flattening can either be done right here or very late when rewriting generic paths.
       */
       const art = qat._origin;
-      if(noJoinForFK && qat._origin.target) {
-        if(!pathStep.args && // has no args
+      if (noJoinForFK && qat._origin.target) {
+        if (!pathStep.args && // has no args
           (
             (
               !pathStep.where && // has no filter
               // not leaf + next step is foreign key
-              i < tail.length-1 &&
-              // path terminates on a scalar type
-              // _effectiveType.elements can be removed if forRelationalDB can expand fk paths correctly
-              !(tail[tail.length-1]._artifact._effectiveType.elements || tail[tail.length-1]._artifact._effectiveType.target) &&
+              i < tail.length - 1 &&
               // association is managed
               art.foreignKeys &&
               // n+1st path step is foreign key
-              Object.values(art.foreignKeys).some(fk => fk.targetElement.path[0].id === tail[i+1].id)
-            )
-          ||
+              Object.values(art.foreignKeys).some(fk => fk.targetElement.path[0].id === tail[i + 1].id)
+            ) ||
             (
               // Non-FROM block path terminates on association, e.g. publishing associations
               // with or without filter.
-              i === tail.length-1 &&
+              i === tail.length - 1 &&
               env.location !== 'from'
             )
-          ))
-        {
+          )) {
           // If qat has no children yet mark it njr
-          if(!qat[qatChildrenName]) {
+          if (!qat[qatChildrenName]) {
             setProp(qat, '$njr', true);
             // flatten left hand side ON condition paths ( => foreign keys to the source side)
             setProp(art, '$flatSrcFKs', flattenElement(art, true, art.name.id, art.name.id));
@@ -1637,12 +1592,12 @@ function translateAssocsToJoins(model, inputOptions = {})
       qatChildren = createQATChildren(qat);
       qatParent = qat; // Current qat becomes parent to the next level of children
       // don't destroy $self navigation for later $self substitution
-      if(!pathStep._navigation || pathStep._navigation.kind !== '$self')
+      if (!pathStep._navigation || pathStep._navigation.kind !== '$self')
         setProp( pathStep, '_navigation', qat );
     });
 
-    if(!qat)
-      throw new CompilerAssertion('No leaf qat for head: ' + head + ' tail: ' + pathAsStr(tail, '"') + ' produced');
+    if (!qat)
+      throw new CompilerAssertion(`No leaf qat for head: ${ head } tail: ${ pathAsStr(tail, '"') } produced`);
 
     /*
       If path terminates on an entity or an association (from clause,
@@ -1653,20 +1608,19 @@ function translateAssocsToJoins(model, inputOptions = {})
       only place where the original FROM alias is available.
     */
     let art = qat._origin;
-    if(art._main)               // element (assoc) or sub query
-      if(art.target)
-        art = art.target._artifact;
-      else
-        art = undefined;
+    if (art._main) {          // element (assoc) or sub query
+      if (art.target)
+        art = art.target ? art.target._artifact : undefined;
+    }
 
-    if(art)
-    {
-        // If rootQat ($tableAlias) already has a QA, reuse it, create a new one otherwise.
-      if(!rootQat.$QA)
-      {
+    if (art) {
+      // If rootQat ($tableAlias) already has a QA, reuse it, create a new one otherwise.
+      if (!rootQat.$QA) {
         // Use the original FROM alias if available!
-        if(pathDict.name && pathDict.name.id)
-          rootQat.$QA = qat.$QA = createQA(env, art, pathDict.name.id, qat._namedArgs);
+        if (pathDict.name && pathDict.name.id) {
+          qat.$QA = createQA(env, art, pathDict.name.id, qat._namedArgs);
+          rootQat.$QA = qat.$QA;
+        }
       }
     }
 
@@ -1674,26 +1628,24 @@ function translateAssocsToJoins(model, inputOptions = {})
     // starting with the first $njr=false Qat
     let njr = true;
     do {
-      if(qat.$njr !== undefined && qat.$njr === false)
+      if (qat.$njr !== undefined && qat.$njr === false)
         njr = false;
-      if(qat.$njr !== undefined && !njr)
+      if (qat.$njr !== undefined && !njr)
         qat.$njr = njr;
       qat = qat._parent;
-    } while(qat._parent && qat._parent[qatChildrenName]);
+    } while (qat._parent && qat._parent[qatChildrenName]);
 
 
     // Return or create a new children dictionary for a given QAT
     // Children are grouped under the filter condition that precedes them.
-    function createQATChildren(parentQat)
-    {
-      if(!parentQat[qatChildrenName])
+    function createQATChildren(parentQat) {
+      if (!parentQat[qatChildrenName])
         parentQat[qatChildrenName] = Object.create(null);
       return parentQat[qatChildrenName];
     }
   }
 
-  function pathAsStr(p, delim='')
-  {
+  function pathAsStr(p, delim = '') {
     return p.map(p => delim + p.id + delim).join('.');
   }
 
@@ -1704,28 +1656,28 @@ function translateAssocsToJoins(model, inputOptions = {})
     if (Array.isArray(obj))
       newObj = [];
     else if (obj.constructor) // important for classes, else prototype chain for inheritance will not be correct
-      newObj = new obj.constructor()
+      newObj = new obj.constructor();
     else if (!Object.getPrototypeOf(obj))
       newObj = Object.create(null);  // dictionary
     else
       newObj = {};
 
-    const props =  Object.getOwnPropertyNames(obj);  // clone own properties only, not inherited ones
+    const props = Object.getOwnPropertyNames(obj);  // clone own properties only, not inherited ones
     for (const p of props) {
       const pd = Object.getOwnPropertyDescriptor(obj, p);
-      if (pd && pd.enumerable === false)
-      {
+      if (pd && pd.enumerable === false) {
         pd.value = obj[p]; // don't copy references
         Object.defineProperty(newObj, p, pd);
       }
-      else
+      else {
         newObj[p] = clone(obj[p]);
+      }
     }
     return newObj;
   }
 
   function parenthesise(expr) {
-    if(typeof expr === 'object' && expr.op && expr.args)
+    if (typeof expr === 'object' && expr.op && expr.args)
       setProp(expr, '$parens', [ expr.$location ]);
     return expr;
   }
@@ -1740,53 +1692,50 @@ function translateAssocsToJoins(model, inputOptions = {})
  * @param {boolean} [rewritten=true] If true, mark the objects with $rewritten
  * @returns {object} CSN path
  */
-function constructPathNode(pathSteps, alias, rewritten=true)
-{
+function constructPathNode(pathSteps, alias, rewritten = true) {
   const node = {
     $rewritten: rewritten,
-    path : pathSteps.map(p => {
+    path: pathSteps.map((p) => {
       const o = {};
-      Object.keys(p).forEach(k => {
-        if(!(rewritten && ['_'].includes(k[0])))
+      Object.keys(p).forEach((k) => {
+        if (!(rewritten && [ '_' ].includes(k[0])))
           o[k] = p[k];
       });
       setProp(o, '_artifact', p._artifact );
       setProp(o, '_navigation', p._navigation );
-      return o; })
+      return o;
+    }),
   };
 
-  if(alias)
-    node.name = { id: alias }
+  if (alias)
+    node.name = { id: alias };
 
   // set the leaf artifact
-  setProp(node, '_artifact', pathSteps[pathSteps.length-1]._artifact);
-  if(pathSteps[0]._navigation)
+  setProp(node, '_artifact', pathSteps[pathSteps.length - 1]._artifact);
+  if (pathSteps[0]._navigation)
     setProp(node.path[0], '_navigation', pathSteps[0]._navigation);
   return node;
 }
 
 // Crawl all relevant sections of the query AST for paths
-function walkQuery(query, env)
-{
-  if(!query)
+function walkQuery(query, env) {
+  if (!query)
     return;
 
-  if(!env.walkover)
+  if (!env.walkover)
     env.walkover = {};
   env.location = query.op;
   env.position = query;
 
-  if(query.op.val === 'SELECT')
-  {
+  if (query.op.val === 'SELECT') {
     env.lead = query;
 
     env.location = 'from';
     walkFrom(query.from);
 
     env.location = 'select';
-    if(env.walkover[env.location])
-    {
-      for(const alias in query.elements)
+    if (env.walkover[env.location]) {
+      for (const alias in query.elements)
         walk(query.elements[alias].value, env);
 
       env.location = 'Where';
@@ -1800,7 +1749,7 @@ function walkQuery(query, env)
       env.location = 'UnionOuterOrderBy';
       // outer orderBy's of anonymous union
       walk(query.$orderBy, env);
-      if(query.limit) {
+      if (query.limit) {
         env.location = 'Limit';
         walk(query.limit.rows, env);
         env.location = 'Offset';
@@ -1809,27 +1758,22 @@ function walkQuery(query, env)
     }
   }
 
-  function walkFrom(fromBlock)
-  {
+  function walkFrom(fromBlock) {
     const aliases = [];
     env.position = fromBlock;
-    if(fromBlock)
-    {
-      if(env.walkover[env.location] && walkPath(fromBlock, env))
-      {
-        if(fromBlock.name)
+    if (fromBlock) {
+      if (env.walkover[env.location] && walkPath(fromBlock, env)) {
+        if (fromBlock.name)
           aliases.push(fromBlock.name.id);
       }
-      else
-      {
-        if(fromBlock.args)
-          fromBlock.args.reduce((a, arg) => a.splice(0,...walkFrom(arg)), aliases);
+      else {
+        if (fromBlock.args)
+          fromBlock.args.reduce((a, arg) => a.splice(0, ...walkFrom(arg)), aliases);
 
         env.location = 'onCondFrom';
-        if(env.walkover[env.location])
-        {
+        if (env.walkover[env.location]) {
           env.tableAliases = aliases;
-          walk(fromBlock.on, env)
+          walk(fromBlock.on, env);
           delete env.tableAliases;
         }
         env.location = 'from';
@@ -1844,50 +1788,45 @@ function walkQuery(query, env)
           ...:      any additional payload for the callback
         }
 */
-function walk(node, env)
-{
+function walk(node, env) {
   env.position = node;
   // In some expressions queries can occur, do not follow them as they
   // are walked as member of the queries array
-  if(!env || !node || (node && node.query && !node.query._artifact))
+  if (!env || !node || (node && node.query && !node.query._artifact))
     return;
 
-  if(node.path) {
+  if (node.path) {
     walkPath(node, env);
     return;
   }
 
   // Ask for Array before typeof object (which would also be true for Array)
-  if(Array.isArray(node)) {
+  if (Array.isArray(node)) {
     node.forEach(n => walk(n, env));
   }
   // instanceof Object doesn't respect dictionaries...
-  else if(typeof node === 'object') {
-    Object.entries(node).forEach(([n, v]) => {
-      if(n !== 'type') {
+  else if (typeof node === 'object') {
+    Object.entries(node).forEach(([ n, v ]) => {
+      if (n !== 'type')
         walk(v, env);
-      }
     });
   }
 }
 
-function walkPath(node, env)
-{
-  const path = node.path;
+function walkPath(node, env) {
+  const { path } = node;
   // Ignore paths that have no artifact (function calls etc.) or that are builtins ($now, $user)
   // or that are parameters ($parameters or escaped paths (':')
-  //path.length && path[ path.length-1 ]._artifact
-  const art = path?.length && path[path.length-1]._artifact;
+  // path.length && path[ path.length-1 ]._artifact
+  const art = path?.length && path[path.length - 1]._artifact;
 
   // regardless of the position in the query, ignore paths that have virtual path steps
-  if(art && path.some(ps => ps._artifact?.virtual?.val))
+  if (art && path.some(ps => ps._artifact?.virtual?.val))
     return path;
-  if(art && !internalArtifactKinds.includes(art.kind) && node.scope !== 'param')
-  {
-    if(env.callback)
-    {
+  if (art && !internalArtifactKinds.includes(art.kind) && node.scope !== 'param') {
+    if (env.callback) {
       // an array of callbacks applied to the node
-      if(Array.isArray(env.callback))
+      if (Array.isArray(env.callback))
         env.callback.forEach(cb => cb(node, env));
       else
         env.callback(node, env);