@sap/cds-compiler 3.3.2 → 3.4.0

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/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.0",
   "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`.