@sap/cds-compiler 3.3.2 → 3.4.2

package/lib/transform/parseExpr.js

@@ -0,0 +1,245 @@
+'use strict'
+
+/**
+ * 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:
+ *
+ * Multiplication/Division:    '*', '/'
+ * Addition/Subtraction:       '+', '-'
+ * Concatenation:              '||'
+ * Relational:                 '=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in', 'exists', 'between and'
+ * Unary:                      'is [not] null', 'not'
+ * Conditional:                'case [when then]+ [else]? end', 'and', 'or'
+ *
+ * Not yet implmemented:       '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.
+ *
+ * Complex aggregates like case/when/else/end and between are parsed first to pass down the
+ * resulting sub expressions and avoiding 'and' ambiguities.
+ *
+ * Sub expressions are grouped as arrays, the final AST is an array of nested arrays.
+ * Alternatively, an object like AST can be produced by setting argument 'array' to false.
+ *
+ * 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.
+ */
+
+function parseExpr(xpr, array=true) {
+  return parseExprInt(xpr);
+
+  function parseExprInt(xpr) {
+    return conditionOR(...CaseWhen(xpr));
+  }
+
+  function CaseWhen(xpr) {
+    if(Array.isArray(xpr))
+      inner(xpr);
+    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);
+        }
+        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);
+          else
+            when.when.push(arg.length === 1 ? arg[0] : arg);
+        }
+        if(elseCond) {
+          if(array)
+            caseTree.push('else', elseCond);
+          else
+            caseTree.case.push(elseCond.length === 1 ? elseCond[0] : elseCond);
+        }
+        if(array)
+          caseTree.push('end');
+        if(lvl > 0)
+          xpr.splice(s+1, e-s+1, caseTree);
+        else {
+          xpr = caseTree;
+        }
+        return e-s+1;
+      }
+      else
+        return 0;
+    }
+
+    function findLastIndex(expr, token, l=expr.length-1) {
+      while(l >= 0 && expr[l] !== token) l--;
+      return l;
+    }
+  }
+
+  function conditionOR(xpr, s, e) {
+    return binaryExpr(xpr, ['or'], conditionAnd, s, e);
+  }
+  function conditionAnd(xpr, s, e) {
+    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++) {
+          if(xpr[a] === 'between')
+            b = true;
+        }
+      } while(b && a < e)
+
+      if(!b && a < e)
+        return [1, a]
+      else
+        return [1, -1];
+    }, conditionTerm, s, e);
+  }
+
+  function conditionTerm(xpr, s, e) {
+    if(Array.isArray(xpr)) {
+      if(xpr.length >= 3 && xpr[s+1] === 'is') {
+        if(xpr[s+2] === 'null')
+          return array ? [ conditionOR(xpr[s]), 'is', 'null' ] :  { 'isNull': conditionOR(xpr[s]) };
+        else if(xpr[s+2] === 'not' && xpr[s+3] === 'null')
+          return array ? [ conditionOR(xpr[s]), 'is', 'not', 'null' ] : { 'isNotNull': conditionOR(xpr[s]) };
+      }
+      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);
+  }
+
+  function compareTerm(xpr, s, e) {
+    if(Array.isArray(xpr)) {
+      let i = s;
+      while(i < e && xpr[i] !== 'between') i++;
+      const b = i < e ? i : -1;
+      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 ] };
+        if(a >= 0) {
+          const lower = expression(xpr, b+1, a);
+          const upper = expression(xpr, a+1, e);
+          if(array)
+            between.push(lower, 'and', upper);
+          else {
+            between.between.push(lower, upper);
+          }
+        }
+        else {
+          const unspec = expression(xpr, b+1, e);
+          if(array)
+            between.push(unspec);
+          else
+            between.between.push(unspec);
+        }
+        return between;
+      }
+    }
+    return binaryExpr(xpr, ['=', '<>', '>', '>=', '<', '<=', '!=', 'like', 'in'], expression, s, e);
+  }
+
+  function expression(xpr, s, e) {
+    return binaryExpr(xpr, ['||'], exprAddSub, s, e);
+  }
+
+  function exprAddSub(xpr, s, e) {
+    return binaryExpr(xpr, ['+', '-'], exprMulDiv, s, e);
+  }
+
+  function exprMulDiv(xpr, s, e) {
+    return binaryExpr(xpr, ['*', '/'], terminal, s, e);
+  }
+
+  function terminal(xpr, s, e) {
+    if(Array.isArray(xpr) && xpr.length > 0) {
+      if(e-s <= 1)
+        return parseExprInt(xpr[e-1]);
+      else
+        return xpr.slice(s, e).map(parseExprInt);
+    }
+    if (typeof xpr === 'object') {
+      for(let n in xpr) {
+        xpr[n] = parseExprInt(xpr[n]);
+      }
+    }
+    return xpr;
+  }
+
+  function binaryExpr(xpr, token, next, s, e) {
+    if (Array.isArray(xpr)) {
+      let [tl, p] = findToken(s, e);
+      if (p >= 0) {
+        let lhs = next(xpr, s, p);
+        let op = xpr[p];
+        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];
+          s = p+tl;
+          [tl, p] = findToken(s, e);
+        }
+        return array ? [ lhs, op, next(xpr, s, e) ] : { [op]: [lhs, next(xpr, s, e)] };
+      }
+    }
+    return next(xpr, s, e);
+
+    function findToken(s, e) {
+      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];
+    }
+  }
+
+}
+
+module.exports = {
+  parseExpr,
+};

package/lib/transform/transformUtilsNew.js

@@ -12,6 +12,7 @@ const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnU
 const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError } = require("../base/error");
 const { forEach } = require('../utils/objectUtils');
+const { pathName } = require("../compiler/utils");
 
 const RestrictedOperators = ['<', '>', '>=', '<='];
 const RelationalOperators = ['=', '!=', '<>', 'is' /*, 'like'*/,...RestrictedOperators];
@@ -711,7 +712,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       if (artifactName) {
         path = ['definitions', artifactName, 'elements', elemName];
       }
-      error(null, path, { name: elemName }, `Generated element $(NAME) conflicts with existing element`);
+      error(null, path, { name: elemName }, 'Generated element $(NAME) conflicts with existing element');
       return;
     }
 
@@ -865,9 +866,9 @@ function getTransformers(model, options, pathDelimiter = '_') {
     if (array.length > 1) {
       const loc = ['definitions', artifactName];
       if (err === true) {
-        error(null, loc, { anno: annoName }, `Annotation $(ANNO) must be assigned only once`);
+        error(null, loc, { anno: annoName }, 'Annotation $(ANNO) must be assigned only once');
       } else {
-        warning(null, loc, { anno: annoName },`Annotation $(ANNO) must be assigned only once`);
+        warning(null, loc, { anno: annoName },'Annotation $(ANNO) must be assigned only once');
       }
     }
   }
@@ -958,7 +959,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     node[name] = value;
     if(wasOverwritten)
       info(null, path, { anno: name, prop: value, otherprop: oldValue },
-      `Value $(OTHERPROP) of annotation $(ANNO) is overwritten with new value $(PROP)`);
+      'Value $(OTHERPROP) of annotation $(ANNO) is overwritten with new value $(PROP)');
     return wasOverwritten;
   }
 
@@ -1161,42 +1162,50 @@ function getTransformers(model, options, pathDelimiter = '_') {
             const xrefvalues = Object.values(xref);
             let cont = true;
 
-            if(op === 'like' && xrefvalues.reduce((a, v) => { 
+            if(op === 'like' && xrefvalues.reduce((a, v) => {
               return (v.lhs && v.rhs) ? a + 1: a;
             }, 0) === 0) {
               // error if intersection of paths is zero
-              error(null, location, `Expected compatible types for '${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}'`);
+              error(null, location, { lhs: pathName(lhs.ref), op, rhs: pathName(rhs.ref) },
+                'Expected compatible types for $(LHS) $(OP) $(RHS)');
               cont = false;
             }
 
             cont && xrefkeys.forEach(xn => {
               const x = xref[xn];
+              const prefix = `${pathName(lhs.ref)} ${op} ${pathName(rhs.ref)}`;
               // do the paths match?
               if(op !== 'like' && !(x.lhs && x.rhs)) {
-                if(xn.length)
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Sub path '${xn}' not found in ${((x.lhs ? rhs : lhs).ref.join('.'))}`)
-                else
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${((x.lhs ? lhs : rhs).ref.join('.'))}' does not match ${((x.lhs ? rhs : lhs).ref.join('.'))}`)
+                if(xn.length) {
+                  error(null, location, { prefix, name: xn, alias: pathName((x.lhs ? rhs : lhs).ref) },
+                    '$(PREFIX): Sub path $(NAME) not found in $(ALIAS)');
+                }
+                else {
+                  error(null, location, { prefix, name: pathName((x.lhs ? lhs : rhs).ref), alias: pathName((x.lhs ? rhs : lhs).ref) },
+                    '$(PREFIX): Path $(NAME) does not match $(ALIAS)');
+                }
                 cont = false;
               }
               // lhs && rhs are present, consistency checks that affect both ends
               else {
                 // is lhs scalar?
                 if(!lhsIsVal && x.lhs && !isScalarOrNoType(x.lhs._art)) {
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${x.lhs.ref.join('.')}${(xn.length ? '.' + xn : '')}' must end on a scalar type`)
+                  error(null, location, { prefix, name: `${pathName(x.lhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                    '$(PREFIX): Path $(NAME) must end on a scalar type')
                   cont = false;
                 }
                 // is rhs scalar?
                 if(!rhsIsVal && x.rhs && !isScalarOrNoType(x.rhs._art)) {
-                  error(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Path '${x.rhs.ref.join('.')}${(xn.length ? '.' + xn : '')}' must end on a scalar type`)
+                  error(null, location, { prefix, name: `${pathName(x.rhs.ref)}${(xn.length ? '.' + xn : '')}` },
+                    '$(PREFIX): Path $(NAME) must end on a scalar type');
                   cont = false;
                 }
-                // info about type incompatibility if no other errors occured
+                // info about type incompatibility if no other errors occurred
                 if(!(lhsIsVal || rhsIsVal) && x.lhs && x.rhs && xn && cont) {
                   const lhst = getType(x.lhs._art);
                   const rhst = getType(x.rhs._art);
                   if(lhst !== rhst) {
-                    info(null, location, `'${lhs.ref.join('.')} ${op} ${rhs.ref.join('.')}': Types for sub path '${xn}' don't match`)
+                    info(null, location, { prefix, name: xn },'$(PREFIX): Types for sub path $(NAME) don\'t match');
                   }
                 }
               }

package/lib/transform/translateAssocsToJoins.js

@@ -902,29 +902,29 @@ function translateAssocsToJoins(model, inputOptions = {})
               // 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];
-              let err = 'Element "' + path[0].id +
-                '" referred in association "' + assoc.name.id +'" of Artifact "' + assoc.name.absolute +'"';
 
               if(elt) {
                 if(Array.isArray(elt)) {
-                  err += ' is available from multiple query sources ' +
-                    elt.map(e => '"' + e._origin.name.absolute + '"').join(', ');
-                  error(null, assocQAT._origin.location, `${err}`);
+                  const names = elt.map(e => e._origin.name.absolute);
+                  error(null, [ assocQAT._origin.location, assocQAT._origin ], { elemref: path[0].id, id: assoc.name.id, art: assoc.name.absolute, 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) {
-                    err += ' originates from "' +
-                      path[0]._artifact._origin._main.name.absolute+'" and from "' +
-                      elt._origin._main.name.absolute +
-                      '" in "' + elt._main.name.absolute + '"';
-                    warning(null, assocQAT._origin.location, `${err}`);
+                    warning(null, [ assocQAT._origin.location, assocQAT._origin ], {
+                      elemref: path[0].id,
+                      id: assoc.name.id, art: assoc.name.absolute,
+                      name: path[0]._artifact._origin._main.name.absolute,
+                      alias: elt._origin._main.name.absolute,
+                      source: elt._main.name.absolute,
+                    }, 'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) originates from $(NAME) and from $(ALIAS) in $(SOURCE)');
                   }
                   _navigation = elt._parent;
                 }
               } else {
-                err += ' has not been found';
-                error(null, assocQAT._origin.location, `${err}`);
+                error(null, [ assocQAT._origin.location, assocQAT._origin ], { elemref: path[0].id, id: assoc.name.id, art: assoc.name.absolute },
+                  'Element $(ELEMREF) referred in association $(ID) of artifact $(ART) has not been found');
                 return pathNode.path;
               }
             } else {

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -28,6 +28,7 @@ module.exports = (csn, options) => {
     // Properties on definition level that we treat specially.
   const definitionPropagationRules = {
     '@cds.autoexpose': onlyViaArtifact,
+    '@cds.external': skip,
     '@fiori.draft.enabled': onlyViaArtifact,
     '@': nullStopsPropagation,
     // Example: `type E : F;` does not have `elements`, but they are required for e.g. OData.

package/lib/utils/term.js

@@ -1,6 +1,6 @@
 //
 // This file is used for color output to stderr and stdout.
-// Use `term.error`, `term.warn` and `term.info` as they use color output
+// Use `term.asError`, `term.asWarn` and `term.asInfo` as they use color output
 // per default if the process runs in a TTY, i.e. stdout as well as
 // stderr are TTYs.  stderr/stdout are no TTYs if they are
 // (for example) piped into another process or written to file:
@@ -88,10 +88,10 @@ function term(useColor = 'auto') {
     bold,
 
     severity: asSeverity,
-    error: asError,
-    warn: asWarning,
-    info: asInfo,
-    help: asHelp,
+    asError,
+    asWarning,
+    asInfo,
+    asHelp,
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "3.3.2",
+  "version": "3.4.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",
@@ -16,7 +16,7 @@
   "scripts": {
     "download": "node scripts/downloadANTLR.js",
     "gen": "node ./scripts/build.js && node scripts/genGrammarChecksum.js",
-    "xmakeBeforeInstall": "echo \"Due to binary mirror, use sqlite 5.1.1 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.1.1",
+    "xmakeBeforeInstall": "echo \"Due to binary mirror, use sqlite 5.1.2 explicitly\" && npm install --save --save-exact --no-package-lock sqlite3@5.1.2",
     "xmakeAfterInstall": "npm run gen",
     "xmakePrepareRelease": "echo \"$(node scripts/stripReadme.js README.md)\" > README.md && node scripts/assertSnapshotVersioning.js && node scripts/assertChangelog.js && node scripts/cleanup.js --remove-dev",
     "test": "node scripts/verifyGrammarChecksum.js && mocha --reporter min --reporter-option maxDiffSize=0 scripts/testLazyLoading.js && mocha --parallel --reporter min --reporter-option maxDiffSize=0 test/ test3/",

package/share/messages/message-explanations.json

@@ -11,7 +11,7 @@
     "redirected-to-complex",
     "redirected-to-unrelated",
     "rewrite-not-supported",
-    "syntax-expected-integer",
+    "syntax-expecting-integer",
     "wildcard-excluding-one"
   ]
 }

package/share/messages/{syntax-expected-integer.md → syntax-expecting-integer.md}

@@ -1,4 +1,4 @@
-# syntax-expected-integer
+# syntax-expecting-integer
 
 The compiler expects a safe integer here.
 The last safe integer is `2^53 - 1` or `9007199254740991`.