@sap/cds-compiler 6.2.2 → 6.3.4

package/lib/transform/parseExpr.js

@@ -1,6 +1,6 @@
 // @ts-nocheck
 
-'use strict'
+'use strict';
 
 /**
  * parseExpr() accepts any JSON object and tries to convert a token stream expression
@@ -49,20 +49,19 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
   }
 
   function Cast(xpr, state) {
-    if(xpr != null && !state.array) {
-      if(Array.isArray(xpr))
+    if (xpr != null && !state.array) {
+      if (Array.isArray(xpr))
         return xpr.map(x => Cast(x, state));
-      if(typeof xpr === 'object') {
+      if (typeof xpr === 'object') {
         const castKeys = Object.keys(xpr).filter(k => k !== 'cast');
-        if(xpr.cast != null && castKeys.length === 1) {
-          return { 'cast': [ xpr.cast, { [castKeys[0]]: xpr[castKeys[0]] } ] };
-        }
-        else {
-          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)
-          }
+        if (xpr.cast != null && castKeys.length === 1)
+          return { cast: [ xpr.cast, { [castKeys[0]]: xpr[castKeys[0]] } ] };
+
+
+        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);
         }
       }
     }
@@ -70,26 +69,26 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
   }
 
   function CaseWhen(xpr) {
-    if(Array.isArray(xpr)) {
+    if (Array.isArray(xpr))
       recurseIntoCases();
-    }
-    return [xpr, 0, Array.isArray(xpr) ? xpr.length : 1];
 
-    function recurseIntoCases(casePos=-1, lvl=-1) {
-      for(let c = casePos+1; c < xpr.length; c++) {
-        if(xpr[c] === 'case') {
-          recurseIntoCases(c, lvl+1)
-        }
+    return [ xpr, 0, Array.isArray(xpr) ? xpr.length : 1 ];
+
+    function recurseIntoCases(casePos = -1, lvl = -1) {
+      for (let c = casePos + 1; c < xpr.length; c++) {
+        if (xpr[c] === 'case')
+          recurseIntoCases(c, lvl + 1);
       }
-      if(lvl > -1) {
+      if (lvl > -1) {
         let endPos = casePos;
-        while(xpr[endPos] !== 'end' && endPos < xpr.length) endPos++;
-        if(xpr[endPos] === 'end') {
+        while (xpr[endPos] !== 'end' && endPos < xpr.length)
+          endPos++;
+        if (xpr[endPos] === 'end') {
           const caseTree = rewriteCaseBlock(casePos, endPos);
-          if(casePos === 0 && endPos === xpr.length-1)
+          if (casePos === 0 && endPos === xpr.length - 1)
             xpr = caseTree;
           else
-            xpr.splice(casePos, endPos-casePos+1, caseTree);
+            xpr.splice(casePos, endPos - casePos + 1, caseTree);
         }
       }
     }
@@ -100,197 +99,201 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
      * @return {Array|object}
      */
     function rewriteCaseBlock(casePos, endPos) {
-      const caseTree = state.array ? [ 'case' ] : { 'case': [] };
+      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);
+      while (xpr[elsePos] !== 'else' && elsePos > casePos)
+        elsePos--;
+      let elseCond;
+      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 caseExpr = xpr.slice(casePos+1, whenPos)
-        if(state.array)
+      while (xpr[whenPos] !== 'when' && whenPos < endPos)
+        whenPos++;
+      if (xpr[whenPos] === 'when' && whenPos - (casePos + 1) >= 1) {
+        const caseExpr = xpr.slice(casePos + 1, whenPos);
+        if (state.array)
           caseTree.push(caseExpr);
         else
           caseTree.case.push(caseExpr.length === 1 ? caseExpr[0] : caseExpr);
       }
 
-      while(xpr[whenPos] === 'when') {
-        const when = { 'when': [] };
-        if(state.array)
+      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 whenExpr = xpr.slice(whenPos+1, thenPos);
-          if(state.array)
+        let thenPos = whenPos + 1;
+        while (xpr[thenPos] !== 'then' && thenPos < endPos)
+          thenPos++;
+        if (xpr[thenPos] === 'then') {
+          const whenExpr = xpr.slice(whenPos + 1, thenPos);
+          if (state.array)
             caseTree.push(whenExpr);
           else
             when.when.push(whenExpr.length === 1 ? whenExpr[0] : whenExpr);
         }
 
-        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)
+        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);
         }
       }
-      if(elseCond) {
-        if(state.array)
+      if (elseCond) {
+        if (state.array)
           caseTree.push('else', elseCond);
         else
-            caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
+          caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
       }
-      if(state.array)
+      if (state.array)
         caseTree.push('end');
       return caseTree;
     }
   }
 
   function conditionOR(xpr, s, e, state) {
-    return binaryExpr(xpr, ['or'], conditionAnd, s, e, state);
+    return binaryExpr(xpr, [ 'or' ], conditionAnd, s, e, state);
   }
 
   function conditionAnd(xpr, s, e, state) {
     return binaryExpr(xpr, (xpr, s, e) => {
-      let a = s-1;
+      let a = s - 1;
       let b;
       do {
         b = false;
-        for(a++; xpr[a] !== 'and' && a < e; a++) {
-          if(xpr[a] === 'between')
+        for (a++; xpr[a] !== 'and' && a < e; a++) {
+          if (xpr[a] === 'between')
             b = true;
         }
-      } while(b && a < e)
+      } while (b && a < e);
 
-      if(!b && a < e)
-        return [1, a]
-      else
-        return [1, -1];
+      if (!b && a < e)
+        return [ 1, a ];
+      return [ 1, -1 ];
     }, conditionTerm, s, e, state);
   }
 
   function conditionTerm(xpr, s, e, state) {
-    if(Array.isArray(xpr)) {
-      if(xpr.length >= 3 && xpr[s+1] === 'is') {
+    if (Array.isArray(xpr)) {
+      if (xpr.length >= 3 && xpr[s + 1] === 'is') {
         const isnull = conditionOR(xpr[s], 0, 0, state);
-        if(xpr[s+2] === 'null')
-          return state.array ? [ isnull, 'is', 'null' ] :  { 'isNull': isnull };
-        else if(xpr[s+2] === 'not' && xpr[s+3] === 'null')
-          return state.array ? [ isnull, 'is', 'not', 'null' ] : { 'isNotNull': isnull };
+        if (xpr[s + 2] === 'null')
+          return state.array ? [ isnull, 'is', 'null' ] : { isNull: isnull };
+        else if (xpr[s + 2] === 'not' && xpr[s + 3] === 'null')
+          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] === 'not') {
+        const not = conditionTerm(xpr, s + 1, e, state);
+        return state.array ? [ '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] === 'exists') {
+        const exists = conditionTerm(xpr, s + 1, e, state);
+        return state.array ? [ 'exists', exists ] : { exists };
       }
     }
     return compareTerm(xpr, s, e, state);
   }
 
   function compareTerm(xpr, s, e, state) {
-    if(Array.isArray(xpr)) {
+    if (Array.isArray(xpr)) {
       let i = s;
       let not = false;
       let between;
-      while(i < e && xpr[i] !== 'between') i++;
+      while (i < e && xpr[i] !== 'between')
+        i++;
       const b = i < e ? i : -1;
-      while(i < e && xpr[i] !== 'and') i++;
+      while (i < e && xpr[i] !== 'and')
+        i++;
       const a = i < e ? i : -1;
-      if(b >= 0) {
+      if (b >= 0) {
         const token = [ 'between' ];
-        not = (xpr[b-1] === 'not');
-        if(not)
-          token.splice(0,0, 'not');
-        const expr = expression(xpr, s, not ? b-1 : b, state);
+        not = (xpr[b - 1] === 'not');
+        if (not)
+          token.splice(0, 0, 'not');
+        const expr = expression(xpr, s, not ? b - 1 : b, state);
         between = state.array
           ? [ expr, ...token ]
-          : { 'between': [ expr ] };
-        if(a >= 0) {
-          const lower = expression(xpr, b+1, a, state);
-          const upper = expression(xpr, a+1, e, state);
-          if(state.array)
+          : { between: [ expr ] };
+        if (a >= 0) {
+          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 {
+          else
             between.between.push(lower, upper);
-          }
         }
         else {
-          const unspec = expression(xpr, b+1, e, state);
-          if(state.array)
+          const unspec = expression(xpr, b + 1, e, state);
+          if (state.array)
             between.push(unspec);
           else
             between.between.push(unspec);
         }
-        if(not && !state.array) {
-          between = { 'not': between }
-        }
+        if (not && !state.array)
+          between = { not: between };
+
         return between;
       }
     }
     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];
+      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 ];
+        return [ 1, s ];
       }
-      return [1, -1];
+      return [ 1, -1 ];
     }, expression, s, e, state);
   }
 
   function expression(xpr, s, e, state) {
-    return binaryExpr(xpr, ['||'], exprAddSub, s, e, state);
+    return binaryExpr(xpr, [ '||' ], exprAddSub, s, e, state);
   }
 
   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++;
+      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];
+      if (found)
+        return [ 1, p ];
+      return [ 1, -1 ];
     }, exprMulDiv, s, e, state);
   }
 
   function exprMulDiv(xpr, s, e, state) {
-    return binaryExpr(xpr, ['*', '/'], (state.array ? unary : dot), s, e, state);
+    return binaryExpr(xpr, [ '*', '/' ], (state.array ? unary : dot), s, e, state);
   }
 
   function dot(xpr, s, e, state) {
-    return binaryExpr(xpr, ['.'], unary, s, e, state);
+    return binaryExpr(xpr, [ '.' ], unary, s, e, state);
   }
 
   function unary(xpr, s, e, state) {
-    if(Array.isArray(xpr)) {
-      if(xpr[s] === '+' || xpr[s] === '-' || (!state.array && xpr[s] === 'new')) {
-        if(state.array)
-          return [ xpr[s], unary(xpr, s+1, e, state) ];
-        else
-          return { [xpr[s]]: unary(xpr, s+1, e, state) };
+    if (Array.isArray(xpr)) {
+      if (xpr[s] === '+' || xpr[s] === '-' || (!state.array && xpr[s] === 'new')) {
+        if (state.array)
+          return [ xpr[s], unary(xpr, s + 1, e, state) ];
+        return { [xpr[s]]: unary(xpr, s + 1, e, state) };
       }
     }
     return terminal(xpr, s, e, state);
@@ -298,39 +301,40 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
   function terminal(xpr, s, e, state) {
     const csnarray = [
       'ref', 'args', 'columns', 'keys', 'expand', 'inline',
-      'requires', 'extensions', 'includes', 'excluding'
+      'requires', 'extensions', 'includes', 'excluding',
     ];
     const xprarray = [
-      'xpr', 'on', 'where', 'orderBy', 'groupBy', 'having' ];
+      'xpr', 'on', 'where', 'orderBy', 'groupBy', 'having',
+    ];
 
-    if(Array.isArray(xpr) && xpr.length > 0) {
-      if(e-s <= 1 && state.anno === 0  && typeof xpr[e-1] !== 'string')
-        return parseExprInt(xpr[e-1], state);
-      else
-        return xpr.slice(s, e).map(ix => parseExprInt(ix, state));
+    if (Array.isArray(xpr) && xpr.length > 0) {
+      if (e - s <= 1 && state.anno === 0 && typeof xpr[e - 1] !== 'string')
+        return parseExprInt(xpr[e - 1], state);
+      return xpr.slice(s, e).map(ix => parseExprInt(ix, state));
     }
     if (typeof xpr === 'object') {
       // if(xpr?.func && funkyfuncs.includes(xpr?.func))
       //   return xpr;
-      for(const n in xpr) {
+      for (const n in xpr) {
         // xpr could be an array with polluted prototype
         if (!Object.hasOwnProperty.call(xpr, n))
           continue;
         const x = xpr[n];
         const isAnno = n[0] === '@' && isSimpleAnnoValue(x);
-        if(isAnno)
+        if (isAnno)
           state.anno++;
-        if(Array.isArray(x)) {
-          if(csnarray.includes(n) || state.anno !== 0)
+        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)
+          else if (xprarray.includes(n) && x.length === 1)
             xpr[n] = x.map(ix => parseExprInt(ix, state));
           else
             xpr[n] = parseExprInt(x, state);
         }
-        else
+        else {
           xpr[n] = parseExprInt(x, state);
-        if(isAnno)
+        }
+        if (isAnno)
           state.anno--;
       }
     }
@@ -341,63 +345,62 @@ function parseExpr(xpr, state = { array: true, nary: false }) {
     const naryExpr = [];
     let not = false;
     if (Array.isArray(xpr)) {
-      let [tl, p] = findToken(s, e);
+      let [ tl, p ] = findToken(s, e);
       if (p >= 0) {
         let lhs = next(xpr, s, p, state);
         naryExpr.push(lhs);
-        let op = xpr.slice(p, p+tl);
-        s = p+tl;
-        [tl, p] = findToken(s, e);
-        while(p >= 0) {
+        let op = xpr.slice(p, p + tl);
+        s = p + tl;
+        [ tl, p ] = findToken(s, e);
+        while (p >= 0) {
           const rhs = next(xpr, s, p, state);
           naryExpr.push(...op, rhs);
-          if(state.array)
+          if (state.array) {
             lhs = [ lhs, ...op, rhs ];
+          }
           else {
             not = op.length > 1 && op[0] === 'not';
-            if(not)
+            if (not)
               op = op.slice(1);
             lhs = (not
-                ? { 'not': { [op.join('')]: [lhs, rhs] } }
-                : { [op.join('')]: [lhs, rhs] });
+              ? { not: { [op.join('')]: [ lhs, rhs ] } }
+              : { [op.join('')]: [ lhs, rhs ] });
           }
-          op = xpr.slice(p, p+tl);
-          s = p+tl;
-          [tl, p] = findToken(s, e);
+          op = xpr.slice(p, p + tl);
+          s = p + tl;
+          [ tl, p ] = findToken(s, e);
         }
 
         let rhs = next(xpr, s, e, state);
-        if(Array.isArray(rhs) && rhs.length === 0)
+        if (Array.isArray(rhs) && rhs.length === 0)
           rhs = undefined;
         naryExpr.push(...op, rhs);
 
         if (state.array)
-          return (state.nary ? naryExpr : [ lhs, ...op, rhs ])
-        else {
-          not = op.length > 1 && op[0] === 'not';
-          if(not)
-            op = op.slice(1);
-          return (not
-            ? { 'not': { [op.join('')]: [ lhs, rhs ] } }
-            : { [op.join('')]: [ lhs, rhs ] });
-
-        }
+          return (state.nary ? naryExpr : [ lhs, ...op, rhs ]);
+
+        not = op.length > 1 && op[0] === 'not';
+        if (not)
+          op = op.slice(1);
+        return (not
+          ? { not: { [op.join('')]: [ lhs, rhs ] } }
+          : { [op.join('')]: [ lhs, rhs ] });
       }
     }
     return next(xpr, s, e, state);
 
     function findToken(s, e) {
-      if(typeof token === 'function')
+      if (typeof token === 'function')
         return token(xpr, s, e);
-      else {
-        while(s < e && !token.includes(xpr[s])) s++;
-        if(s < e)
-          return [1, s];
-      }
-      return [1, -1];
+
+      while (s < e && !token.includes(xpr[s]))
+        s++;
+      if (s < e)
+        return [ 1, s ];
+
+      return [ 1, -1 ];
     }
   }
-
 }
 
 function isSimpleAnnoValue(val) {