@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/transform/parseExpr.js

@@ -1,11 +1,17 @@
+// @ts-nocheck
+
 'use strict'
 
+// const funkyfuncs = Object.keys(require('../compiler/builtins.js').
+//   specialFunctions).filter(n => n.length).map(n=>n.toLowerCase());
+
 /**
- * parseExpr accepts any JSON object and tries to convert a token stream expression
+ * parseExpr() accepts any JSON object and tries to convert a token stream expression
  * array into an AST like expression with CDL operator precedence.
  *
  * The following operators are supported:
  *
+ * Unary:                      +/-
  * Multiplication/Division:    '*', '/'
  * Addition/Subtraction:       '+', '-'
  * Concatenation:              '||'
@@ -13,7 +19,7 @@
  * Unary:                      'is [not] null', 'not'
  * Conditional:                'case [when then]+ [else]? end', 'and', 'or'
  *
- * Not yet implmemented:       'new'
+ * Not yet implemented:        'new'
  *
  * This is not an optimized LL(1) parser but a token 'sniffer'. A stream is
  * cracked up in sub streams and passed down to the next higher function.
@@ -27,95 +33,122 @@
  * This parser intentionally does no error handling. If a clause is malformed, it is accepted as is.
  *
  * @param {any} xpr A JSON object.
- * @param {Boolean} array Bias AST representation.
+ * @param {Object} state Objet
+ *  anno: Don't eliminate arrays with single entry in statetations as they are collections
+ *  array: Bias AST representation.
+ *  nary: return n-ary or binary tree
  */
 
-function parseExpr(xpr, array=true) {
-  return parseExprInt(xpr);
+function parseExpr(xpr, state = { anno: 0, array: true, nary: true }) {
+  // Notes:
+  //  - Variables `s` and `e` are used as index variables into `xpr`s for start and end.
+  //  - xpr's are our CSN expressions, see <https://pages.github.tools.sap/cap/docs/cds/cxn>
+
+  return parseExprInt(xpr, state);
 
-  function parseExprInt(xpr) {
-    return conditionOR(...CaseWhen(xpr));
+  function parseExprInt(xpr, state) {
+    return conditionOR(...CaseWhen(xpr), state);
   }
 
   function CaseWhen(xpr) {
-    if(Array.isArray(xpr))
-      inner(xpr);
+    if(Array.isArray(xpr)) {
+      recurseIntoCases();
+    }
     return [xpr, 0, Array.isArray(xpr) ? xpr.length : 1];
 
-    // replace case/end from inner to outer
-    function inner(pxpr, lvl=0) {
-      const s = pxpr.findIndex(t => t === 'case');
-      if(s >= 0) {
-        let e = findLastIndex(pxpr, 'end');
-        pxpr = pxpr.slice(s+1, e);
-        const dist = inner(pxpr, lvl+1);
-        e -= dist;
-        if(dist > 0)
-          pxpr = xpr.slice(s+1, e+1);
-        const caseTree = array ? [ 'case' ] : { 'case': [] };
-        let i = pxpr.findIndex(t => t === 'else');
-        let elseCond = undefined;
-        if(i >= 0) {
-          elseCond = pxpr.slice(i+1);
-          pxpr = pxpr.slice(0, i);
+    function recurseIntoCases(casePos=-1, lvl=-1) {
+      for(let c = casePos+1; c < xpr.length; c++) {
+        if(xpr[c] === 'case') {
+          recurseIntoCases(c, lvl+1)
         }
-        i = pxpr.findIndex(t => t === 'when');
-        while(i >= 0) {
-          pxpr = pxpr.slice(i+1);
-          const when = { 'when': [] };
-          if(array)
-            caseTree.push('when');
-          else
-            caseTree.case.push(when);
-          i = pxpr.findIndex(t => t === 'then');
-          if(i >= 0) {
-            const arg = pxpr.slice(0, i);
-            if(array)
-              caseTree.push(arg);
-            else
-              when.when.push(arg.length === 1 ? arg[0] : arg);
-          }
-          pxpr = pxpr.slice(i+1);
-          i = pxpr.findIndex(t => t === 'when');
-          const arg = ((i >= 0) ? pxpr.slice(0, i) : pxpr);
-          if(array)
-            caseTree.push('then', arg);
+      }
+      if(lvl > -1) {
+        let endPos = casePos;
+        while(xpr[endPos] !== 'end' && endPos < xpr.length) endPos++;
+        if(xpr[endPos] === 'end') {
+          const caseTree = rewriteCaseBlock(casePos, endPos);
+          if(casePos === 0 && endPos === xpr.length-1)
+            xpr = caseTree;
           else
-            when.when.push(arg.length === 1 ? arg[0] : arg);
+            xpr.splice(casePos, endPos-casePos+1, caseTree);
         }
-        if(elseCond) {
-          if(array)
-            caseTree.push('else', elseCond);
+      }
+    }
+
+    /**
+     * @param {number} casePos
+     * @param {number} endPos
+     * @return {Array|object}
+     */
+    function rewriteCaseBlock(casePos, endPos) {
+      const caseTree = state.array ? [ 'case' ] : { 'case': [] };
+      
+      let elsePos = endPos;
+      let whenPos = casePos;
+
+      while(xpr[elsePos] !== 'else' && elsePos > casePos) elsePos--;
+      let elseCond = undefined;
+      if(xpr[elsePos] === 'else') {
+        elseCond = xpr.slice(elsePos+1, endPos);
+        endPos = elsePos;
+      }
+
+      while(xpr[whenPos] !== 'when' && whenPos < endPos) whenPos++;
+      if(xpr[whenPos] === 'when' && whenPos - (casePos+1) >= 1) {
+        const arg = xpr.slice(casePos+1, whenPos)
+        if(state.array)
+          caseTree.push(arg);
+        else
+            caseTree.case.push(arg);
+      }
+
+      while(xpr[whenPos] === 'when') {
+        const when = { 'when': [] };
+        if(state.array)
+          caseTree.push('when');
+        else
+          caseTree.case.push(when);
+
+        let thenPos = whenPos+1;
+        while(xpr[thenPos] !== 'then' && thenPos < endPos) thenPos++;
+        if(xpr[thenPos] === 'then') {
+          const when = xpr.slice(whenPos+1, thenPos);
+          if(state.array)
+            caseTree.push(when);
           else
-            caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
+            when.when.push(when.length === 1 ? when[0] : when);
         }
-        if(array)
-          caseTree.push('end');
-        if(lvl > 0)
-          xpr.splice(s+1, e-s+1, caseTree);
-        else {
-          xpr = caseTree;
+
+        whenPos = thenPos+1;
+        while(xpr[whenPos] !== 'when' && whenPos < endPos) whenPos++;
+        if(xpr[whenPos] === 'when' || whenPos === endPos) {
+          const then = xpr.slice(thenPos+1, whenPos);
+          if(state.array)
+            caseTree.push('then', then);
+          else
+            when.when.push(then.length === 1 ? then[0] : then);
         }
-        return e-s+1;
       }
-      else
-        return 0;
-    }
-
-    function findLastIndex(expr, token, l=expr.length-1) {
-      while(l >= 0 && expr[l] !== token) l--;
-      return l;
+      if(elseCond) {
+        if(state.array)
+          caseTree.push('else', elseCond);
+        else
+            caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
+      }
+      if(state.array)
+        caseTree.push('end');
+      return caseTree;
     }
   }
 
-  function conditionOR(xpr, s, e) {
-    return binaryExpr(xpr, ['or'], conditionAnd, s, e);
+  function conditionOR(xpr, s, e, state) {
+    return binaryExpr(xpr, ['or'], conditionAnd, s, e, state);
   }
-  function conditionAnd(xpr, s, e) {
+  
+  function conditionAnd(xpr, s, e, state) {
     return binaryExpr(xpr, (xpr, s, e) => {
       let a = s-1;
       let b;
-      // scan for 'and', skip 'between/and'
       do {
         b = false;
         for(a++; xpr[a] !== 'and' && a < e; a++) {
@@ -128,26 +161,31 @@ function parseExpr(xpr, array=true) {
         return [1, a]
       else
         return [1, -1];
-    }, conditionTerm, s, e);
+    }, conditionTerm, s, e, state);
   }
 
-  function conditionTerm(xpr, s, e) {
+  function conditionTerm(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
       if(xpr.length >= 3 && xpr[s+1] === 'is') {
+        const isnull = conditionOR(xpr[s], state);
         if(xpr[s+2] === 'null')
-          return array ? [ conditionOR(xpr[s]), 'is', 'null' ] :  { 'isNull': conditionOR(xpr[s]) };
+          return state.array ? [ isnull, 'is', 'null' ] :  { 'isNull': isnull };
         else if(xpr[s+2] === 'not' && xpr[s+3] === 'null')
-          return array ? [ conditionOR(xpr[s]), 'is', 'not', 'null' ] : { 'isNotNull': conditionOR(xpr[s]) };
+          return state.array ? [ isnull, 'is', 'not', 'null' ] : { 'isNotNull': isnull };
+      }
+      if(xpr[s] === 'not') {
+        const  not = conditionTerm(xpr, s+1, e, state)
+        return state.array ? [ 'not',  not ] : { 'not':  not };
+      }
+      if(xpr[s] === 'exists') {
+        const exists = conditionTerm(xpr, s+1, e, state)
+        return state.array ? [ 'exists', exists ] : { 'exists': exists };
       }
-      if(xpr[s] === 'not')
-        return array ? [ 'not', conditionTerm(xpr, s+1, e) ] : { 'not': conditionTerm(xpr, s+1, e) };
-      if(xpr[s] === 'exists')
-        return array ? [ 'exists', conditionOR(xpr[s+1]) ] : { 'exists': conditionOR(xpr[s+1]) };
     }
-    return compareTerm(xpr, s, e);
+    return compareTerm(xpr, s, e, state);
   }
 
-  function compareTerm(xpr, s, e) {
+  function compareTerm(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
       let i = s;
       while(i < e && xpr[i] !== 'between') i++;
@@ -155,20 +193,26 @@ function parseExpr(xpr, array=true) {
       while(i < e && xpr[i] !== 'and') i++;
       const a = i < e ? i : -1;
       if(b >= 0) {
-        const expr = expression(xpr, s, b);
-        const between = array ? [ expr, 'between' ] : { 'between': [ expr ] };
+        let token = [ 'between' ];
+        const not = (xpr[b-1] === 'not');
+        if(not)
+          token.splice(0,0, 'not');
+        const expr = expression(xpr, s, not ? b-1 : b, state);
+        const between = state.array
+          ? [ expr, ...token ]
+          : { 'between': [ expr ] };
         if(a >= 0) {
-          const lower = expression(xpr, b+1, a);
-          const upper = expression(xpr, a+1, e);
-          if(array)
+          const lower = expression(xpr, b+1, a, state);
+          const upper = expression(xpr, a+1, e, state);
+          if(state.array)
             between.push(lower, 'and', upper);
           else {
             between.between.push(lower, upper);
           }
         }
         else {
-          const unspec = expression(xpr, b+1, e);
-          if(array)
+          const unspec = expression(xpr, b+1, e, state);
+          if(state.array)
             between.push(unspec);
           else
             between.between.push(unspec);
@@ -176,55 +220,114 @@ function parseExpr(xpr, array=true) {
         return between;
       }
     }
-    return binaryExpr(xpr, ['=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in'], expression, s, e);
+    return binaryExpr(xpr, (xpr, s, e) => {
+      const token = ['=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in'];
+      while(s < e && !token.includes(xpr[s])) s++;
+      if(s < e) {
+        if(xpr[s-1] === 'not' && (xpr[s] === 'in' || xpr[s] === 'like'))
+          return [2, s-1];
+        else
+          return [1, s];
+      }
+      return [1, -1];
+    }, expression, s, e, state);
   }
 
-  function expression(xpr, s, e) {
-    return binaryExpr(xpr, ['||'], exprAddSub, s, e);
+  function expression(xpr, s, e, state) {
+    return binaryExpr(xpr, ['||'], exprAddSub, s, e, state);
   }
 
-  function exprAddSub(xpr, s, e) {
-    return binaryExpr(xpr, ['+', '-'], exprMulDiv, s, e);
+  function exprAddSub(xpr, s, e, state) {
+    return binaryExpr(xpr, (xpr, s, e) => {
+      const skips = [ '+', '-', '*', '/' ];
+      let found = false;
+      let p=s;
+      while(!found && p < e) {
+        found = ((xpr[p] === '+' || xpr[p] === '-') && p > s && !skips.includes(xpr[p-1]) && p < e);
+        if(!found) p++;
+      }
+      if(found)
+        return [1, p];
+      return [1, -1];
+    }, exprMulDiv, s, e, state);
+  }
+
+  function exprMulDiv(xpr, s, e, state) {
+    return binaryExpr(xpr, ['*', '/'], unary, s, e, state);
   }
 
-  function exprMulDiv(xpr, s, e) {
-    return binaryExpr(xpr, ['*', '/'], terminal, s, e);
+  function unary(xpr, s, e, state) {
+    if(Array.isArray(xpr)) {
+      if(xpr[s] === '+' || xpr[s] === '-') {
+        return [ xpr[s], unary(xpr, s+1, e, state) ];
+      }
+    }
+    return terminal(xpr, s, e, state);
   }
+  function terminal(xpr, s, e, state) {
+    const csnarray = [
+      'ref', 'args', 'columns', 'keys', 'expand', 'inline',
+      'requires', 'extensions', 'includes', 'excluding'
+    ];
+    const xprarray = [
+      'xpr', 'on', 'where', 'orderBy', 'groupBy', 'having' ];
 
-  function terminal(xpr, s, e) {
     if(Array.isArray(xpr) && xpr.length > 0) {
-      if(e-s <= 1)
-        return parseExprInt(xpr[e-1]);
+      if(e-s <= 1 && state.anno === 0)
+        return parseExprInt(xpr[e-1], state);
       else
-        return xpr.slice(s, e).map(parseExprInt);
+        return xpr.slice(s, e).map(ix => parseExprInt(ix, state));
     }
     if (typeof xpr === 'object') {
+      // if(xpr?.func && funkyfuncs.includes(xpr?.func))
+      //   return xpr;
       for(let n in xpr) {
-        xpr[n] = parseExprInt(xpr[n]);
+        const x = xpr[n];
+        if(n[0] === '@')
+          state.anno++;
+        if(Array.isArray(x)) {
+          if(csnarray.includes(n) || state.anno !== 0)
+            xpr[n] = x.map(ix => parseExprInt(ix, state));
+          else if(xprarray.includes(n) && x.length === 1)
+            xpr[n] = x.map(ix => parseExprInt(ix, state));
+          else
+            xpr[n] = parseExprInt(x, state);
+        }
+        else
+          xpr[n] = parseExprInt(x, state);
+        if(n[0] === '@')
+          state.anno--;
       }
     }
     return xpr;
   }
 
-  function binaryExpr(xpr, token, next, s, e) {
+  function binaryExpr(xpr, token, next, s, e, state) {
+    const expr = [];
     if (Array.isArray(xpr)) {
       let [tl, p] = findToken(s, e);
       if (p >= 0) {
-        let lhs = next(xpr, s, p);
-        let op = xpr[p];
+        let lhs = next(xpr, s, p, state);
+        expr.push(lhs);
+        let op = xpr.slice(p, p+tl);
         s = p+tl;
         [tl, p] = findToken(s, e);
         while(p >= 0) {
-          let rhs = next(xpr, s, p);
-          lhs = array ? [ lhs, op, rhs ] : { [op]: [lhs, rhs] };
-          op = xpr[p];
+          let rhs = next(xpr, s, p, state);
+          expr.push(...op, rhs);
+          lhs = state.array ? [ lhs, ...op, rhs ] : { [op.join('')]: [lhs, rhs] };
+          op = xpr.slice(p, p+tl);
           s = p+tl;
           [tl, p] = findToken(s, e);
         }
-        return array ? [ lhs, op, next(xpr, s, e) ] : { [op]: [lhs, next(xpr, s, e)] };
+        expr.push(...op, next(xpr, s, e, state));
+        if (state.array)
+          return (state.nary ? expr : [ lhs, ...op, next(xpr, s, e, state) ])
+        else
+          return { [op.join('')]: [lhs, next(xpr, s, e, state)] };
       }
     }
-    return next(xpr, s, e);
+    return next(xpr, s, e, state);
 
     function findToken(s, e) {
       if(typeof token === 'function')

package/lib/transform/transformUtilsNew.js

@@ -10,9 +10,9 @@ const { setProp } = require('../base/model');
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
 const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnUtils');
 const { typeParameters, isBuiltinType } = require('../compiler/builtins');
-const { ModelError } = require("../base/error");
+const { ModelError } = require('../base/error');
 const { forEach } = require('../utils/objectUtils');
-const { pathName } = require("../compiler/utils");
+const { pathName } = require('../compiler/utils');
 
 const RestrictedOperators = ['<', '>', '>=', '<='];
 const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
@@ -1220,17 +1220,24 @@ function getTransformers(model, options, pathDelimiter = '_') {
             }
             // t_0 OR ... OR t_n with t = (a <not equal> b)
             const bop = (op === 'is' && not) || op === '!=' || op === '<>' ? 'or' : 'and';
-            rc.push('(');
+            const xpr = { xpr: [] };
             xrefvalues.filter(x => x.lhs && x.rhs).forEach((x,i) => {
-              if(i>0)
-                rc.push(bop);
-              rc.push(x.lhs);
-              rc.push(op);
+              xpr.i = i;
+              if(i>0) {
+                xpr.xpr.push(bop);
+              }
+              xpr.xpr.push(x.lhs);
+              xpr.xpr.push(op);
               if(not)
-                rc.push('not')
-              rc.push(x.rhs);
+                xpr.xpr.push('not')
+              xpr.xpr.push(x.rhs);
             });
-            rc.push(')');
+            if(xpr.i > 0) {
+              delete xpr.i;
+              rc.push(xpr);
+            }
+            else
+              rc.push(...xpr.xpr);
             i += not ? 3 : 2;
           }
           else

package/lib/transform/translateAssocsToJoins.js

@@ -12,16 +12,16 @@ const { timetrace } = require('../utils/timetrace');
 const internalArtifactKinds = ['builtin', '$parameters', 'param'];
 
 function translateAssocsToJoinsCSN(csn, options){
-  timetrace.start('Recompiling model');
+  timetrace.start('A2J: Recompiling model');
   // Do not re-complain about localized
   const compileOptions = { ...options, $skipNameCheck: true };
   delete compileOptions.csnFlavor;
   const model = recompileX(csn, compileOptions);
-  timetrace.stop();
-  timetrace.start('Translating associations to joins');
+  timetrace.stop('A2J: Recompiling model');
+  timetrace.start('A2J: Translating associations to joins');
   translateAssocsToJoins(model, options);
-  timetrace.stop();
-  timetrace.start('Post-processing columns');
+  timetrace.stop('A2J: Translating associations to joins');
+  timetrace.start('A2J: Post-processing columns');
   // Use the effective elements list as columns
   forEachDefinition(model, art => {
     if (art.$queries) {
@@ -36,7 +36,7 @@ function translateAssocsToJoinsCSN(csn, options){
       }
     }
   });
-  timetrace.stop();
+  timetrace.stop('A2J: Post-processing columns');
 
   if (options.messages) {
     // Make sure that we don't complain twice about the same things
@@ -46,8 +46,7 @@ function translateAssocsToJoinsCSN(csn, options){
   // If A2J reports error - end! Continuing with a broken CSN makes no sense
   makeMessageFunction(model, options).throwWithAnyError();
   // FIXME: Move this somewhere more appropriate
-  const compact = compactModel(model, compileOptions);
-  return compact;
+  return compactModel(model, compileOptions);
 }
 
 function translateAssocsToJoins(model, inputOptions = {})
@@ -329,9 +328,10 @@ function translateAssocsToJoins(model, inputOptions = {})
 
       for(let i = 0; i < tail.length-1; i++) {
         if(tail[i]._navigation && tail[i]._navigation.$njr) {
-          // the correct flattened foreign key must match the leaf artifact of this path
+          // 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 fk = tail[i]._artifact.$flatSrcFKs.find(f => f._artifact === leafArt);
+          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) {
             // const revealInternalProperties = require('../model/revealInternalProperties.js');
             // console.log('++++++++ Path tail: ', revealInternalProperties(tail[tail.length-1]._artifact));
@@ -565,7 +565,7 @@ function translateAssocsToJoins(model, inputOptions = {})
           QATs until a QA has been found).
         */
         if(!assoc.$flatSrcFKs)
-          setProp(assoc, '$flatSrcFKs', flattenElement(assoc, true, assoc.name.id));
+          setProp(assoc, '$flatSrcFKs', flattenElement(assoc, true, assoc.name.id, assoc.name.id));
         if(!assoc.$flatTgtFKs)
           setProp(assoc, '$flatTgtFKs', flattenElement(assoc, false));
 
@@ -664,7 +664,8 @@ function translateAssocsToJoins(model, inputOptions = {})
           }
           // 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] === '=' && args[i+2].path)
+          else if(i < args.length-2 && args[i].path &&
+                  args[i+1]?.literal === 'token' && args[i+1]?.val === '=' && args[i+2].path)
           {
             let fwdAssoc = getForwardAssociation(args[i].path, args[i+2].path);
             if(fwdAssoc)
@@ -1088,11 +1089,11 @@ 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)
+  function flattenElement(element, srcSide, prefix, acc)
   {
     // terminate if element is unstructured
     if(!element.foreignKeys && !element.elements)
-      return [ { id: prefix, _artifact: element } ];
+      return [ { id: prefix, _artifact: element, acc } ];
 
     let paths = [];
     // get paths of managed assocs (unmanaged assocs are not allowed in FK paths)
@@ -1103,7 +1104,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         let fk = element.foreignKeys[fkn];
         // once a fk is to be followed, treat all sub patsh as srcSide, this will add fk.name.id only
         if(srcSide)
-          paths = paths.concat(flattenElement(fk.targetElement._artifact, true,  fk.name.id));
+          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
@@ -1113,7 +1114,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             [tail, fkPrefix] = substituteFKAliasForPath(assocStep, tail, fkPrefix);
             [assocStep, tail, fkPrefix] = pathAsStringUpToAssoc(tail, fkPrefix);
           }
-          paths = paths.concat(flattenElement(fk.targetElement._artifact, true, fkPrefix));
+          paths = paths.concat(flattenElement(fk.targetElement._artifact, true, fkPrefix, fk.targetElement.path.map(ps => ps.id).join(pathDelimiter)));
         }
       }
     }
@@ -1123,11 +1124,15 @@ function translateAssocsToJoins(model, inputOptions = {})
       for(let n in element.elements)
       {
         let elt = element.elements[n];
-        paths = paths.concat(flattenElement(elt, true, elt.name.id));
+        paths = paths.concat(flattenElement(elt, true, elt.name.id, elt.name.id));
       }
     }
     return paths.map(p => {
-      return { id: (prefix ? prefix + pathDelimiter : '' ) + p.id, _artifact: p._artifact }
+      return {
+        id: (prefix ? prefix + pathDelimiter : '' ) + p.id, 
+        acc: (acc ? acc + pathDelimiter : '') + p.acc,
+        _artifact: p._artifact
+      }
     } );
   }
 
@@ -1556,7 +1561,7 @@ function translateAssocsToJoins(model, inputOptions = {})
           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));
+            setProp(art, '$flatSrcFKs', flattenElement(art, true, art.name.id, art.name.id));
           }
         }
         else {