@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/transform/universalCsn/utils.js

@@ -0,0 +1,63 @@
+'use strict';
+
+const {
+  applyTransformations,
+} = require('../../model/csnUtils');
+const { setProp } = require('../../base/model');
+
+/**
+ * Set the annotation on the carrier if it is not already present.
+ *
+ * @param {object} carrier Object having/getting the annotation
+ * @param {string} name Name of the annotations
+ * @param {any} value Value of the annotation
+ */
+function setAnnotationIfNotDefined(carrier, name, value) {
+  if (carrier[name] === undefined)
+    carrier[name] = value;
+}
+
+/**
+ * Strip/change the CSN to ensure compatibility with what we have in the client CSN
+ * - Removes every occurrence of '$origin', '$generated' and '$source'
+ * - elements of subqueries become non-enumerable
+ * - remove `actions|params|virtual|notNull: null`, this stops the inheritance of the actions/params/virtual
+ *   along the $origin chain, this can be ignored for the comparison in our tests.
+ *
+ * @param {CSN.Model} csn
+ */
+function makeClientCompatible(csn) {
+  applyTransformations(csn, {
+    actions: removeNullProperty,
+    notNull: removeNullProperty,
+    params: removeNullProperty,
+    virtual: removeNullProperty,
+    $origin: (parent, prop) => delete parent[prop],
+    $generated: (parent, prop) => delete parent[prop],
+    $source: (parent, prop) => delete parent[prop],
+    SELECT: (parent, prop, query) => {
+      if (query.elements)
+        setProp(query, 'elements', query.elements);
+    },
+    SET: (parent, prop, query) => {
+      if (query.elements)
+        setProp(query, 'elements', query.elements);
+    },
+  });
+}
+
+/**
+ * Removes the `prop` from the `node` if `prop === null`
+ *
+ * @param {object} node
+ * @param {string} prop
+ */
+function removeNullProperty(node, prop) {
+  if (node[prop] === null)
+    delete node[prop];
+}
+
+module.exports = {
+  setAnnotationIfNotDefined,
+  makeClientCompatible,
+};

package/lib/utils/moduleResolve.js

@@ -28,13 +28,18 @@ const extensions = [ '.cds', '.csn', '.json' ];
  *   - Why a global?  The Umbrella could pass it as an option.
  *
  * @param {string} modulePath
+ * @param {CSN.Options} options
  * @returns {string}
  */
-function adaptCdsModule(modulePath) {
-  // eslint-disable-next-line
-  if (global['cds'] && global['cds'].home && modulePath.startsWith( '@sap/cds/' ))
+function adaptCdsModule(modulePath, options = {}) {
+  if (modulePath.startsWith( '@sap/cds/' )) {
+    if (options.cdsHome)
+      return options.cdsHome + modulePath.slice(8);
     // eslint-disable-next-line
-    return global['cds'].home + modulePath.slice(8)
+    if (global['cds'] && global['cds'].home)
+      // eslint-disable-next-line
+      return global['cds'].home + modulePath.slice(8);
+  }
   return modulePath;
 }
 
@@ -42,6 +47,7 @@ function adaptCdsModule(modulePath) {
  * @param {object} dep
  * @param {object} fileCache
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  */
 function resolveModule( dep, fileCache, options, messageFunctions ) {
   const _fs = cdsFs(fileCache, options.traceFs);
@@ -58,7 +64,7 @@ function resolveModule( dep, fileCache, options, messageFunctions ) {
     realpath: _fs.realpath,
   };
   return new Promise( (fulfill, reject) => {
-    const lookupPath = adaptCdsModule(dep.module);
+    const lookupPath = adaptCdsModule(dep.module, options);
     resolveCDS( lookupPath, opts, (err, res) => {
       // console.log('RESOLVE', dep, res, err)
       if (err) {
@@ -105,6 +111,7 @@ function resolveModule( dep, fileCache, options, messageFunctions ) {
  * @param {object} dep
  * @param {object} fileCache
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  */
 function resolveModuleSync( dep, fileCache, options, messageFunctions ) {
   const _fs = cdsFs(fileCache, options.traceFs);
@@ -118,7 +125,7 @@ function resolveModuleSync( dep, fileCache, options, messageFunctions ) {
 
   let result = null;
   let error = null;
-  const lookupPath = adaptCdsModule(dep.module);
+  const lookupPath = adaptCdsModule(dep.module, options);
 
   resolveCDS( lookupPath, opts, (err, res) => {
     if (err)

package/lib/utils/objectUtils.js

@@ -42,8 +42,38 @@ function forEach(obj, callback) {
   }
 }
 
+/**
+ * Loops over all elements in an object and calls the specified callback(o[key]) for each key
+ * --> can be used as substitute for `Object.values(…).forEach(…)`
+ *
+ * @param  {object} o the object which values should be iterated
+ * @param  {Function} callback
+ */
+function forEachValue(o, callback) {
+  for (const key in o) {
+    if (Object.hasOwnProperty.call(o, key))
+      callback(o[key]);
+  }
+}
+
+/**
+ * Loops over all elements in an object and calls the specified callback(key) for each key
+ * --> can be used as substitute for `Object.keys(…).forEach(…)`
+ *
+ * @param  {object} o the object which keys should be iterated
+ * @param  {Function} callback
+ */
+function forEachKey(o, callback) {
+  for (const key in o) {
+    if (Object.hasOwnProperty.call(o, key))
+      callback(key);
+  }
+}
+
 module.exports = {
   copyPropIfExist,
   createDict,
   forEach,
+  forEachValue,
+  forEachKey,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.12.0",
+  "version": "2.15.2",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",

package/share/messages/README.md

@@ -30,3 +30,29 @@ Furthermore:
   If users open the message in a terminal, it is often 80 characters wide.
   Even if that was not the case, longer lines are harder to read, so keep them
   short.
+
+## Example Structure
+
+```markdown
+# ‹message-id›
+
+Longer message text.  Some background info.
+Usually mentions the severity.
+
+## Example
+
+Code which also lead to the current message,
+with an explanation why it is problematic.
+
+## How to Fix
+
+Description of options how the issue can be fixed, using the example.
+
+## Notes on …
+
+Optional: more background info.
+
+## Related messages
+
+ - Optional: message ids for similar issues.
+```

package/share/messages/message-explanations.json

@@ -9,6 +9,7 @@
     "extend-unrelated-layer",
     "redirected-to-ambiguous",
     "redirected-to-unrelated",
-    "rewrite-not-supported"
+    "rewrite-not-supported",
+    "syntax-expected-integer"
   ]
 }

package/share/messages/syntax-expected-integer.md

@@ -0,0 +1,37 @@
+# syntax-expected-integer
+
+The compiler expects a safe integer here.
+The last safe Integer is `2^53 - 1` or `9007199254740991`.
+
+A safe integer is an integer that
+
+- can be exactly represented as an IEEE-754 double precision number, and
+- whose IEEE-754 representation cannot be the result of rounding any
+  other integer to fit the IEEE-754 representation.
+
+The message's severity is `Error`.
+
+## Example
+
+Erroneous code example:
+
+```cdl
+type LengthIsUnsafe : String(9007199254740992);
+type NotAnInteger : String(42.1);
+```
+
+In the above example, the string length for the type `LengthIsUnsafe` is not a
+safe Integer. It is too large.
+Likewise, the string length for the type `NotAnInteger` is a decimal.
+
+## How to Fix
+
+To fix the issue, you have to provide a safe integer:
+
+```cdl
+type LengthIsSafe : String(9007199254740991);
+type AnInteger : String(42);
+```
+
+If not feasible, a string representation of the number needs to be used,
+e.g. in annotation values.