@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/transform/parseExpr.js

@@ -58,7 +58,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
           return { 'cast': [ xpr.cast, { [castKeys[0]]: xpr[castKeys[0]] } ] };
         }
         else {
-          for(let n in xpr) {
+          for(const n in xpr) {
             // xpr could be an array with polluted prototype
             if (Object.hasOwnProperty.call(xpr, n))
               xpr[n] = Cast(xpr[n], state)
@@ -214,7 +214,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
       while(i < e && xpr[i] !== 'and') i++;
       const a = i < e ? i : -1;
       if(b >= 0) {
-        let token = [ 'between' ];
+        const token = [ 'between' ];
         not = (xpr[b-1] === 'not');
         if(not)
           token.splice(0,0, 'not');
@@ -312,7 +312,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
     if (typeof xpr === 'object') {
       // if(xpr?.func && funkyfuncs.includes(xpr?.func))
       //   return xpr;
-      for(let n in xpr) {
+      for(const n in xpr) {
         // xpr could be an array with polluted prototype
         if (!Object.hasOwnProperty.call(xpr, n))
           continue;
@@ -349,7 +349,7 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
         s = p+tl;
         [tl, p] = findToken(s, e);
         while(p >= 0) {
-          let rhs = next(xpr, s, p, state);
+          const rhs = next(xpr, s, p, state);
           naryExpr.push(...op, rhs);
           if(state.array)
             lhs = [ lhs, ...op, rhs ];

package/lib/transform/transformUtils.js

@@ -162,14 +162,14 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   // Note that this must happen after struct flattening(flattenStructuredElement) - both fot elements and foreign keys.
   // Return the newly generated foreign key element.
   function createForeignKeyElement(assoc, assocName, foreignKey, artifact, artifactName, path) {
-    let result = {};
+    const result = {};
 
     // FIXME: Duplicate code (postfix is added herein, can this be optimized?)
     // Assemble foreign key element name from assoc name, '_' and foreign key name/alias
-    let foreignKeyElementName = `${assocName.replace(/\./g, pathDelimiter)}${pathDelimiter}${foreignKey.as || foreignKey.ref.join(pathDelimiter)}`;
+    const foreignKeyElementName = `${assocName.replace(/\./g, pathDelimiter)}${pathDelimiter}${foreignKey.as || foreignKey.ref.join(pathDelimiter)}`;
 
 
-    let fkArtifact = inspectRef(path).art;
+    const fkArtifact = inspectRef(path).art;
     newForeignKey(fkArtifact, foreignKeyElementName);
 
     function processAssociationOrComposition(fkArtifact,foreignKeyElementName) {
@@ -188,7 +188,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         return;
       }
 
-      let foreignKeyElement = createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName);
+      const foreignKeyElement = createRealFK(fkArtifact, assoc, assocName, foreignKey, path, foreignKeyElementName);
 
       // FIXME: must this code go into createRealFK?
       // Not present in getForeignKeyArtifact
@@ -229,7 +229,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   //          length: 42 },
   // }
   function flattenStructuredElement(elem, elemName, parentElementPath=[], pathInCsn=[]) {
-    let elementPath=parentElementPath.concat(elemName); // elementPath contains only element names without the csn structure node names
+    const elementPath=parentElementPath.concat(elemName); // elementPath contains only element names without the csn structure node names
     // in case the element is of user defined type => take the definition of the type
     // for type of 'x' -> elem.type is an object, not a string -> use directly
     let elemType;
@@ -241,7 +241,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     // Collect all child elements (recursively) into 'result'
     // TODO: Do not report collisions in the generated elements here, but instead
     //       leave that work to the receiver of this result
-    let result = Object.create(null);
+    const result = Object.create(null);
     const addGeneratedFlattenedElement = (e, eName) => {
       if (result[eName])
         error('name-duplicate-element', pathInCsn, { '#': 'flatten-element-gen', name: eName })
@@ -251,10 +251,10 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     forEach(struct, (childName, childElem) => {
       if (isStructured(childElem)) {
         // Descend recursively into structured children
-        let grandChildElems = flattenStructuredElement(childElem, childName, elementPath, pathInCsn.concat('elements',childName));
-        for (let grandChildName in grandChildElems) {
-          let flatElemName = elemName + pathDelimiter + grandChildName;
-          let flatElem = grandChildElems[grandChildName];
+        const grandChildElems = flattenStructuredElement(childElem, childName, elementPath, pathInCsn.concat('elements',childName));
+        for (const grandChildName in grandChildElems) {
+          const flatElemName = elemName + pathDelimiter + grandChildName;
+          const flatElem = grandChildElems[grandChildName];
           addGeneratedFlattenedElement(flatElem, flatElemName);
           // TODO: check with values. In CSN such elements have only "@Core.Computed": true
           // If the original element had a value, construct one for the flattened element
@@ -265,8 +265,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         }
       } else {
         // Primitive child - clone it and restore its cross references
-        let flatElemName = elemName + pathDelimiter + childName;
-        let flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
+        const flatElemName = elemName + pathDelimiter + childName;
+        const flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
@@ -302,7 +302,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       // 'localized' is needed for OData
       if(options.toOdata)
         props.push('localized');
-      for (let p of props) {
+      for (const p of props) {
         if (elem[p]) {
           flatElem[p] = elem[p];
         }
@@ -324,12 +324,14 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    * @param {string} [scope] Pre-resolved scope for the given ref - if not provided, will be calculated JIT
    * @param {WeakMap} [resolvedLinkTypes=new WeakMap()] A WeakMap with already resolved types for each link-step - safes an `artifactRef` call
    * @param {bool} [suspend] suspend flattening by caller until association path step
-   * @returns {string[]}
+   * @param {int} [suspendPos] suspend if starting pos is lower or equal to suspendPos and suspend is true
+   * @param {bool} [revokeAtSuspendPos] revoke suspension after suspendPos (binding parameter path use case)
+   * @returns [string[], bool]
    */
-  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), suspend=false, suspendPos=0) {
+  function flattenStructStepsInRef(ref, path, links, scope, resolvedLinkTypes=new WeakMap(), suspend=false, suspendPos=0, revokeAtSuspendPos=false) {
     // Refs of length 1 cannot contain steps - no need to check
     if (ref.length < 2 || (scope === '$self' && ref.length === 2)) {
-      return ref;
+      return [ ref, false ];
     }
 
     const result = scope === '$self' ? [ref[0]] : [];
@@ -340,7 +342,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       scope = res.scope;
     }
     if (scope === '$magic')
-      return ref;
+      return [ ref, false ];
 
     // Don't process a leading $self - it will a .art with .elements!
     let i = scope === '$self' ? 1 : 0;
@@ -351,7 +353,8 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
      effectiveType(links[i].art)[propName] ||
      (resolvedLinkTypes.get(links[i])||{})[propName]);
 
-    let flattenStep = false;
+     let refChanged = false
+     let flattenStep = false;
     suspend = !!art('items') || (suspend && i <= suspendPos);
     for(; i < links.length; i++) {
 
@@ -363,14 +366,16 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
           ref[i].id = result[result.length-1];
           result[result.length-1] = ref[i];
         }
+        refChanged = true;
         // suspend flattening if the next path step has some 'items'
         suspend = !!art('items');
       }
       else {
         result.push(ref[i]);
+        suspend ||= !!art('items');
       }
       // revoke items suspension for next assoc step
-      if(suspend && art('target'))
+      if(suspend && art('target') || (revokeAtSuspendPos && i === suspendPos))
         suspend = false;
 
       flattenStep = !links[i].art?.kind &&
@@ -378,7 +383,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
         !links[i].art?.from &&
         art('elements');
     }
-    return result;
+    return [ result, refChanged ];
   }
 
   /**
@@ -471,11 +476,11 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   // Add the created projection to the model and complain if artifact already exists.
   // Used by Draft generation
   function createExposingProjection(art, artName, projectionId, service) {
-    let projectionAbsoluteName = `${service}.${projectionId}`;
+    const projectionAbsoluteName = `${service}.${projectionId}`;
     // Create elements matching the artifact's elements
-    let elements = Object.create(null);
+    const elements = Object.create(null);
     art.elements && Object.entries(art.elements).forEach(([elemName, artElem]) => {
-      let elem = Object.assign({}, artElem);
+      const elem = Object.assign({}, artElem);
       // Transfer xrefs, that are redirected to the projection
       // TODO: shall we remove the transferred elements from the original?
       // if (artElem._xref) {
@@ -485,7 +490,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       elements[elemName] = elem;
     });
 
-    let query = {
+    const query = {
       'SELECT': {
         'from': {
           'ref': [
@@ -495,13 +500,13 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       }
     };
     // Assemble the projection itself and add it into the model
-    let projection = {
+    const projection = {
       'kind': 'entity',
       projection: query.SELECT, // it is important that projection and query refer to the same object!
       elements
     };
     // copy annotations from art to projection
-    for (let a of Object.keys(art).filter(x => x.startsWith('@'))) {
+    for (const a of Object.keys(art).filter(x => x.startsWith('@'))) {
       projection[a] = art[a];
     }
     model.definitions[projectionAbsoluteName] = projection;
@@ -606,7 +611,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if (!isBuiltinType(typeName) && !model.definitions[typeName]) {
       throw new ModelError('Expecting valid type name: ' + typeName);
     }
-    let result = {
+    const result = {
       [elemName]: {
         type: typeName
       }
@@ -634,16 +639,16 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   //     keys: [{ ref: ['id'] }]
   // } }
   function createAssociationElement(elemName, target, isManaged = false) {
-    let elem = createScalarElement(elemName, 'cds.Association', false, undefined);
-    let assoc = elem[elemName];
+    const elem = createScalarElement(elemName, 'cds.Association', false, undefined);
+    const assoc = elem[elemName];
     assoc.target = target;
 
     if (isManaged) {
       assoc.keys = [];
-      let targetArt = getCsnDef(target);
+      const targetArt = getCsnDef(target);
       targetArt.elements && Object.entries(targetArt.elements).forEach(([keyElemName, keyElem]) => {
         if (keyElem.key) {
-          let foreignKey = createForeignKey(keyElemName, keyElem);
+          const foreignKey = createForeignKey(keyElemName, keyElem);
           addForeignKey(foreignKey, assoc);
         }
       });
@@ -700,7 +705,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if (!artifact.elements) {
       throw new ModelError('Expecting artifact with elements: ' + JSON.stringify(artifact));
     }
-    let elemName = Object.keys(elem)[0];
+    const elemName = Object.keys(elem)[0];
     // Element must not exist
     if (artifact.elements[elemName]) {
       let path = null;
@@ -737,7 +742,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       error(null, path, { name: elementName }, 'Generated element $(NAME) conflicts with existing element');
     }
 
-    let result = Object.create(null);
+    const result = Object.create(null);
     result[elementName] = {};
     elem && Object.entries(elem).forEach(([prop, value]) => {
       result[elementName][prop] = value;
@@ -750,13 +755,13 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
   // of type name 'paramTypeName'
   function createAction(actionName, returnTypeName = undefined, paramName = undefined, paramTypeName = undefined) {
     // Assemble the action
-    let result = {
+    const result = {
       [actionName]: {
         kind: 'action'
       }
     };
 
-    let action = result[actionName];
+    const action = result[actionName];
 
     if (returnTypeName) {
       if (!isBuiltinType(returnTypeName) && !model.definitions[returnTypeName])
@@ -791,7 +796,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       artifact.actions = Object.create(null);
     }
 
-    let actionName = Object.keys(action)[0];
+    const actionName = Object.keys(action)[0];
     // Element must not exist
     if (!artifact.actions[actionName]) {
       // Add the action
@@ -808,7 +813,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    *                    second field if it has @cds.valid.to. Default value is [] for each field.
    */
   function extractValidFromToKeyElement(element, path) {
-    let validFroms = [], validTos = [], validKeys = [];
+    const validFroms = [], validTos = [], validKeys = [];
     if (hasAnnotationValue(element, '@cds.valid.from')) {
       validFroms.push({ element, path: [...path] });
     }
@@ -878,7 +883,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
    */
   function recurseElements(artifact, path, callback) {
     callback(artifact, path);
-    let elements = artifact.elements;
+    const elements = artifact.elements;
     if (elements) {
       path.push('elements', null);
       forEach(elements, (name, obj) => {
@@ -892,7 +897,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
 
   // Rename annotation 'fromName' in 'node' to 'toName' (both names including '@')
   function renameAnnotation(node, fromName, toName) {
-    let annotation = node && node[fromName];
+    const annotation = node && node[fromName];
     // Sanity checks
     if (!fromName.startsWith('@')) {
       throw new CompilerAssertion('Annotation name should start with "@": ' + fromName);
@@ -1039,7 +1044,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
     if(art) {
       if(art && !((art.items && art.items.elements) || art.elements)) {
         if(followMgdAssoc && art.target && art.keys) {
-          let rc = [];
+          const rc = [];
           for(const k of art.keys) {
             const nps = { ref: k.ref.map(p => fullRef ? { id: p } : p ) };
             setProp(nps, '_art', k._art);
@@ -1057,7 +1062,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       }
       const elements = art.items && art.items.elements || art.elements;
       if(elements) {
-        let rc = []
+        const rc = []
         Object.entries(elements).forEach(([en, elt]) => {
           const nps = { ref: [ (fullRef ? { id: en, _art: elt } : en )] };
           setProp(nps, '_art', elt);
@@ -1106,7 +1111,7 @@ function getTransformers(model, options, msgFunctions, pathDelimiter = '_') {
       Flattening stops on all non-structured types.
     */
     function expand(expr, location) {
-      let rc = [];
+      const rc = [];
       for(let i = 0; i < expr.length; i++)
       {
         if(Array.isArray(expr[i]))

package/lib/transform/translateAssocsToJoins.js

@@ -29,10 +29,10 @@ function translateAssocsToJoinsCSN(csn, options){
   // Use the effective elements list as columns
   forEachDefinition(model, art => {
     if (art.$queries) {
-      for (let query of art.$queries) {
+      for (const query of art.$queries) {
         query.columns = Object.values(query.elements);
         // TODO: Remove viaAll
-        for (let elemName in query.elements) {
+        for (const elemName in query.elements) {
           const elem = query.elements[elemName];
           if (elem.$inferred === '*')
             delete elem.$inferred;
@@ -172,8 +172,8 @@ 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)
   {
-    let fqat = env.lead.$tableAliases[fromPathNode.name.id].$fqat;
-    let joinTree = createJoinTree(env, undefined, fqat, 'inner', '$fqat', undefined);
+    const fqat = env.lead.$tableAliases[fromPathNode.name.id].$fqat;
+    const joinTree = createJoinTree(env, undefined, fqat, 'inner', '$fqat', undefined);
 
     replaceTableAliasInPlace( fromPathNode, joinTree);
   }
@@ -185,11 +185,11 @@ function translateAssocsToJoins(model, inputOptions = {})
     {
       env.lead = query;
       let joinTree = query.from;
-      for(let tan in query.$tableAliases)
+      for(const tan in query.$tableAliases)
       {
         if(query.$tableAliases[tan].kind !== '$self') // don't drive into $projection/$self tableAlias (yet)
         {
-          let ta = query.$tableAliases[tan];
+          const ta = query.$tableAliases[tan];
           joinTree = createJoinTree(env, joinTree, ta.$qat, 'left', '$qat', ta.$QA);
         }
       }
@@ -207,9 +207,9 @@ function translateAssocsToJoins(model, inputOptions = {})
   */
   function createQAForFromClauseSubQuery(query, env)
   {
-    for (let taName in query.$tableAliases) {
+    for (const taName in query.$tableAliases) {
       if (query.$tableAliases[taName].kind !== '$self') {
-        let ta = query.$tableAliases[taName];
+        const ta = query.$tableAliases[taName];
         if(!ta.$QA) {
           let alias = taName;
           if (ta.name.$inferred === '$internal') {
@@ -306,8 +306,8 @@ function translateAssocsToJoins(model, inputOptions = {})
     if(env.location === 'onCondFrom')
     {
       if(checkPathDictionary(pathNode, env)) {
-        let [ tableAlias, tail ] = constructTableAliasAndTailPath(pathNode.path);
-        let pathStr = translateONCondPath(tail).map(ps => ps.id).join(pathDelimiter);
+        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 } ]));
       }
@@ -329,11 +329,11 @@ function translateAssocsToJoins(model, inputOptions = {})
         tail = pathNode.path;
       // if tail.length > 1, search bottom up for QA
       // default to rootQA, _parent.$QA has precedence
-      let [QA, ps] = rightMostQA(tail, head._navigation._parent.$QA || head._navigation.$QA);
+      const [QA, ps] = rightMostQA(tail, head._navigation._parent.$QA || head._navigation.$QA);
       if(!QA) {
         error(null, pathNode.$location,
           { name: pathName(pathNode.path) },
-          'Please debug me: No QA found for generic path rewriting in $(NAME)')
+          '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,
@@ -360,7 +360,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             // const revealInternalProperties = require('../model/revealInternalProperties.js');
             // console.log('++++++++ Path tail: ', revealInternalProperties(tail[tail.length-1]._artifact));
             // console.log('******** Flat FKs\n', tail[i]._artifact.$flatSrcFKs.map(f => revealInternalProperties(f._artifact)));
-            throw new CompilerAssertion('Please debug me: No flat FK found for FK rewriting');
+            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);
@@ -431,7 +431,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   */
   function createJoinTree(env, joinTree, parentQat, joinType, qatAttribName, lastAssocQA)
   {
-    for(let childQatId in parentQat)
+    for(const childQatId in parentQat)
     {
       const childQat = parentQat[childQatId];
 
@@ -454,10 +454,10 @@ function translateAssocsToJoins(model, inputOptions = {})
             if(childQat._filter)
             {
               // Filter conditions are unique for each JOIN, they don't need to be copied
-              let filter = childQat._filter;
+              const filter = childQat._filter;
               rewritePathsInFilterExpression(filter, function(pathNode) {
                 return [ /* tableAlias=> */ constructTableAliasPathStep(childQat.$QA),
-                        /* filterPath=> */ pathNode.path ]; // eslint-disable-line indent-legacy
+                        /* filterPath=> */ pathNode.path ];
               }, env);
 
               if(!env.lead.$startFilters)
@@ -486,28 +486,28 @@ function translateAssocsToJoins(model, inputOptions = {})
 
   function createJoinQA(joinType, lhs, rhs, assocQAT, assocSourceQA, env)
   {
-    let node = { op: { val: 'join' }, join: { val: joinType }, args: [ lhs, rhs ] };
+    const node = { op: { val: 'join' }, join: { val: joinType }, args: [ lhs, rhs ] };
     const assoc = assocQAT._origin;
     if(isBetaEnabled(options, 'mapAssocToJoinCardinality')) {
       node.cardinality = mapAssocToJoinCardinality(assoc);
     }
     // 'path steps' for the src/tgt table alias
-    let srcTableAlias = constructTableAliasPathStep(assocSourceQA);
-    let tgtTableAlias = constructTableAliasPathStep(assocQAT.$QA);
+    const srcTableAlias = constructTableAliasPathStep(assocSourceQA);
+    const tgtTableAlias = constructTableAliasPathStep(assocQAT.$QA);
 
     node.on = createOnCondition(assoc, srcTableAlias, tgtTableAlias, options.tenantDiscriminator);
 
     if(assocQAT._filter)
     {
       // Filter conditions are unique for each JOIN, they don't need to be copied
-      let filter = assocQAT._filter;
+      const filter = assocQAT._filter;
       rewritePathsInFilterExpression(filter, function(pathNode) {
         return [ 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
-      let onCond = (Array.isArray(node.on) ? node.on[0] : node.on);
+      const onCond = (Array.isArray(node.on) ? node.on[0] : node.on);
 
       if(onCond.op.val === 'and')
         onCond.args.push(parenthesise(filter));
@@ -567,7 +567,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     // produce the ON condition for a given association
     function createOnCondition(assoc, srcAlias, tgtAlias, compareTenants)
     {
-      let prefixes = [ assoc.name.id ];
+      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:
 
@@ -600,12 +600,12 @@ function translateAssocsToJoins(model, inputOptions = {})
           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.
         */
-        let args = compareTenants && addTenantComparison(assoc) || [];
+        const args = compareTenants && addTenantComparison(assoc) || [];
         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] ] ) ] });   // eslint-disable-line indent-legacy
+                    constructPathNode( [ tgtAlias, assoc.$flatTgtFKs[i] ] ) ] });
         }
         return parenthesise((args.length > 1 ? { op: { val: 'and' }, args: [ ...args.map(parenthesise) ] } : args[0] ));
       }
@@ -761,7 +761,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         // 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) {
-          let x = clone(expr);
+          const x = clone(expr);
           if(expr.args)
             x.args = expr.args.map(cloneOnCondition);
           return x;
@@ -845,7 +845,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             $projection must be removed from $projection.yid (get's aliased with the mixinAssocQAT.$QA)
             */
             if(env.assocStack.length < 2) {
-              let value = env.lead.elements[path[0].id].value;
+              const value = env.lead.elements[path[0].id].value;
               /*
                 If the value is an expression in the select block, return the unmodified
                 expression. rewriteGenericPaths will check and rewrite these paths later
@@ -957,7 +957,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             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
-              let elt = env.lead._combined[path[0].id];
+              const elt = env.lead._combined[path[0].id];
 
               if(elt) {
                 if(Array.isArray(elt)) {
@@ -1008,7 +1008,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             path = translateONCondPath(path, !hasDollarSelfPrefix ? assoc.$elementPrefix : undefined);
           }
         }
-        let pathStr = path.map(ps => ps.id).join(pathDelimiter);
+        const pathStr = path.map(ps => ps.id).join(pathDelimiter);
         return constructPathNode([ tableAlias, { id: pathStr, _artifact: pathNode._artifact } ]);
       }
 
@@ -1209,11 +1209,11 @@ function translateAssocsToJoins(model, inputOptions = {})
    */
   function constructTableAliasAndTailPath(path, navigation=undefined)
   {
-    let [head, ...tail] = path;
+    const [head, ...tail] = path;
     if(navigation === undefined)
       navigation = head._navigation;
 
-    let QA = navigation.$QA || navigation._parent.$QA;
+    const QA = navigation.$QA || navigation._parent.$QA;
 
     // First path step is table alias, use and pop it off
     if(navigation.$QA && tail.length > 0)
@@ -1251,7 +1251,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   {
     if(!pathStr)
       pathStr = '';
-    let assocStep = path.find(ps => {
+    const assocStep = path.find(ps => {
       if(pathStr.length > 0)
         pathStr += pathDelimiter;
       pathStr += ps.id;
@@ -1303,7 +1303,7 @@ function translateAssocsToJoins(model, inputOptions = {})
         pathStr += fk.name.id;
       }
 
-      let 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)
         return substituteFKAliasForPath(fk.targetElement, tail, pathStr);
@@ -1377,7 +1377,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       if(ps._artifact && ps._artifact.target)
       {
         // if this is not the last path step, complain
-        let la1 = pathDict.path[pathDict.path.indexOf(ps)+1];
+        const la1 = pathDict.path[pathDict.path.indexOf(ps)+1];
         if(la1) {
           if(ps._artifact.on)
           {
@@ -1438,7 +1438,7 @@ function translateAssocsToJoins(model, inputOptions = {})
   */
   function mergePathIntoQAT(pathDict, env)
   {
-    let path = pathDict.path;
+    const path = pathDict.path;
 
     if(path.length === 0)
       return;
@@ -1505,7 +1505,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     if(qatParent == undefined)
       throw new CompilerAssertion('table alias/qathost not found for path: ' +  pathAsStr(path));
 
-    let rootQat = qatParent;
+    const rootQat = qatParent;
 
     // Create the very first QAT if it doesn't exist
     // (filter condition for table alias prefix not allowed)
@@ -1526,7 +1526,7 @@ function translateAssocsToJoins(model, inputOptions = {})
       }
       if(pathStep.args) {
         // sort named arguments
-        let sortedNamedArgs = Object.create(null);
+        const sortedNamedArgs = Object.create(null);
         Object.keys(pathStep.args).sort().forEach(p => {
           sortedNamedArgs[p] = compactExpr(pathStep.args[p]);
         })
@@ -1687,10 +1687,10 @@ function translateAssocsToJoins(model, inputOptions = {})
   // eslint-disable-next-line no-unused-vars
   function printPath(pathDict, env)
   {
-    let alias = (pathDict.name && pathDict.name.id) || '<undefined>'
-    let path = pathDict.path;
-    let s = pathAsStr(path, '"');
-    let me = env.lead && (env.lead.name.id || env.lead.op);
+    const alias = (pathDict.name && pathDict.name.id) || '<undefined>'
+    const path = pathDict.path;
+    const s = pathAsStr(path, '"');
+    const me = env.lead && (env.lead.name.id || env.lead.op);
     // eslint-disable-next-line no-console
     console.log(me + ': ' + env.location + ': ' + s + ' alias: ' + alias);
   }
@@ -1708,9 +1708,9 @@ function translateAssocsToJoins(model, inputOptions = {})
     else
       newObj = {};
 
-    let props =  Object.getOwnPropertyNames(obj);  // clone own properties only, not inherited ones
-    for (let p of props) {
-      let pd = Object.getOwnPropertyDescriptor(obj, p);
+    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)
       {
         pd.value = obj[p]; // don't copy references
@@ -1740,10 +1740,10 @@ function translateAssocsToJoins(model, inputOptions = {})
  */
 function constructPathNode(pathSteps, alias, rewritten=true)
 {
-  let node = {
+  const node = {
     $rewritten: rewritten,
     path : pathSteps.map(p => {
-      let o = {};
+      const o = {};
       Object.keys(p).forEach(k => {
         if(!(rewritten && ['_'].includes(k[0])))
           o[k] = p[k];
@@ -1784,7 +1784,7 @@ function walkQuery(query, env)
     env.location = 'select';
     if(env.walkover[env.location])
     {
-      for(let alias in query.elements)
+      for(const alias in query.elements)
         walk(query.elements[alias].value, env);
 
       env.location = 'Where';
@@ -1809,7 +1809,7 @@ function walkQuery(query, env)
 
   function walkFrom(fromBlock)
   {
-    let aliases = [];
+    const aliases = [];
     env.position = fromBlock;
     if(fromBlock)
     {