@sap/cds-compiler 2.12.0 → 2.13.6

package/lib/render/utils/stringEscapes.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const controlCharacters = /[\u{0000}-\u{001F}]/u;
+const highSurrogate = /[\u{D800}-\u{DBFF}]/u;
+const lowSurrogate = /[\u{DC00}-\u{DFFF}]/u;
+// Either a high surrogate that is NOT followed by a low one or
+// a low surrogate not preceded by a high one.
+const unpairedSurrogate = /[^\u{D800}-\u{DBFF}][\u{DC00}-\u{DFFF}]|[\u{D800}-\u{DBFF}][^\u{DC00}-\u{DFFF}]/u;
+
+/**
+ * Returns true if the string contains an unpaired unicode surrogate.
+ * See <https://en.wikipedia.org/wiki/UTF-16#U+D800_to_U+DFFF>.
+ * As a surrogate pair MUST consist of a high one followed by a low surrogate,
+ * an unpaired surrogate MUST be escaped.
+ *
+ * @param {string} str
+ * @return {boolean}
+ */
+function hasUnpairedUnicodeSurrogate(str) {
+  return unpairedSurrogate.test(str);
+}
+
+/**
+ * Returns true if the string contains control characters such as LF or NUL.
+ *
+ * @param {string} str
+ * @return {boolean}
+ */
+function hasControlCharacters(str) {
+  return controlCharacters.test(str);
+}
+
+/**
+ * Escape the given string according to the given specification in `escapes`.
+ *
+ * `escapes` is an object where the entries are either:
+ *   - a mapping from character to string, e.g. `{ '"': '&quot;' }`
+ *   - `control: (codePoint) => str`
+ *     A function that returns an escape sequence for the given control character.
+ *   - `unpairedSurrogate: (codePoint) => str`
+ *     A function that returns an escape sequence for the given unpaired unicode surrogate.
+ *
+ * Multi-character keys are not allowed.
+ *
+ * Character escapes take precedence over `control` and `unpairedSurrogate` escapes,
+ * i.e. if you do not want to encode LF (`\n`), add an explicit mapping for it, e.g.
+ * `{ '\n': '\n' }`.
+ *
+ * @example
+ *   You can use `escapeString()` like this:
+ *   ```js
+ *   let escaped = escapeString(str, {
+ *     '"': '\\"',
+ *     control: (c) => `\\u{${c.toString(16)}}`;
+ *     unpairedSurrogate: (c) => `\\u{${c.toString(16)}}`;
+ *   });
+ *   ```
+ *
+ * @param {string} str
+ * @param {object} escapes
+ * @returns {string}
+ */
+function escapeString(str, escapes) {
+  const output = [];
+
+  for (let i = 0; i < str.length; ++i) {
+    const char = str[i];
+
+    if (char in escapes) {
+      output.push(escapes[char]);
+      continue;
+    }
+
+    // Control Characters: C0
+    // See <https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Basic_ASCII_control_codes>
+    if (controlCharacters.test(char)) {
+      output.push(escapes.control ? escapes.control(char.codePointAt(0)) : char);
+      continue;
+    }
+
+    // Unicode Surrogates
+    // These characters appear in _pairs_.  A high surrogate must be followed by a low surrogate.
+    // If this is not the case, either needs to be encoded.  This is also done by JSON.
+    // See also <https://docs.microsoft.com/en-us/globalization/encoding/surrogate-pairs>
+    if (highSurrogate.test(char)) {
+      if (i + 1 >= str.length || !lowSurrogate.test(str[i + 1])) {
+        output.push(escapes.unpairedSurrogate ? escapes.unpairedSurrogate(char.codePointAt(0)) : char);
+      }
+      else {
+        output.push(char);
+        ++i;
+        output.push(str[i]);
+      }
+    }
+    else if (lowSurrogate.test(char)) {
+      output.push(escapes.unpairedSurrogate ? escapes.unpairedSurrogate(char.codePointAt(0)) : char);
+    }
+    else {
+      // unhandled / non-special character
+      output.push(char);
+    }
+  }
+
+  return output.join('');
+}
+
+module.exports = {
+  escapeString,
+  hasUnpairedUnicodeSurrogate,
+  hasControlCharacters,
+};

package/lib/sql-identifier.js

@@ -9,7 +9,7 @@
 //    an identifier such that the effective name (the one in the DB schema) is
 //    the same as the name used in CDS.
 //  - 'quoted' and 'hdbcds' for HANA only: similar to the non-provided previous
-//    mode, with different adoptations to HANA CDS and XS (classic) restrictions.
+//    mode, with different adaptations to HANA CDS and XS (classic) restrictions.
 
 // The main objective of this file is to support the 'plain' mode in a “smart”
 // manner.  If we would use the CDS name (after `.` to `_` replacements)

package/lib/transform/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "no-shadow": "off"
+  }
+}

package/lib/transform/db/.eslintrc.json

@@ -13,6 +13,8 @@
     // Don't enforce stupid descriptions
     "jsdoc/require-param-description": "off",
     "jsdoc/require-returns-description": "off",
+    // Sometimes if-else's are more specific
+    "sonarjs/prefer-single-boolean-return": "off",
     // Very whiny and nitpicky
     "sonarjs/cognitive-complexity": "off",
     // Does not recognize TS types

package/lib/transform/db/applyTransformations.js

@@ -18,12 +18,11 @@ const { setProp } = require('../../base/model');
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
  * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {boolean} [skipIgnore=true] Wether to skip _ignore elements or not
- * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
+ * @param {applyTransformationsOptions} [options={}]
  * @param {CSN.Path} path Path to parent
  * @returns {object} parent with transformations applied
  */
-function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, skipIgnore, options, path = []) {
+function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, options, path = []) {
   const transformers = {
     elements: dictionary,
     definitions: dictionary,
@@ -32,6 +31,7 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
     enum: dictionary,
     mixin: dictionary,
     ref: pathRef,
+    $origin: () => {}, // no-op
   };
 
   const csnPath = [ ...path ];
@@ -50,7 +50,12 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
    * @param {object} node The value of node[_prop]
    */
   function standard( _parent, _prop, node ) {
-    if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( _parent, _prop ) || (typeof _prop === 'string' && _prop.startsWith('@')) || (skipIgnore && node._ignore))
+    if (!node || typeof node !== 'object' ||
+        !{}.propertyIsEnumerable.call( _parent, _prop ) ||
+        (typeof _prop === 'string' && _prop.startsWith('@')) ||
+        (options.skipIgnore && node._ignore) ||
+        (options.skipStandard && options.skipStandard[_prop])
+    )
       return;
 
     csnPath.push( _prop );
@@ -80,7 +85,7 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
    */
   function dictionary( node, _prop, dict ) {
     // Allow skipping dicts like actions in forHanaNew
-    if (options.skipDict && options.skipDict[_prop])
+    if (options.skipDict && options.skipDict[_prop] || dict === null || dict === undefined) // with universal CSN, dicts might be null
       return;
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict ))
@@ -101,7 +106,10 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
   function definitions( node, _prop, dict ) {
     csnPath.push( _prop );
     for (const name of Object.getOwnPropertyNames( dict )) {
-      const skip = options && options.skipArtifact && options.skipArtifact(dict[name], name) || false;
+      const skip = (options && options.allowArtifact && !options.allowArtifact(dict[name], name)) ||
+                   (options && options.skipArtifact && options.skipArtifact(dict[name], name)) ||
+                   (options && options.skip && options.skip.includes(dict[name].kind)) ||
+                   false;
       if (!skip) {
         artifactTransformers.forEach(fn => fn(dict, name, dict[name]));
         standard( dict, name, dict[name] );
@@ -152,13 +160,15 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
  * @param {object} csn CSN to enrich in-place
  * @param {object} customTransformers Map of _prop to transform and function to apply
  * @param {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
- * @param {boolean} [skipIgnore=true] Wether to skip _ignore elements or not
- * @param {object} [options={}] "skipArtifact": (artifact, name) => Boolean to skip certain artifacts, drillRef: boolean - whether to drill into infix/args
+ * @param {applyTransformationsOptions} [options={}]
  * @returns {object} CSN with transformations applied
  */
-function applyTransformations( csn, customTransformers = {}, artifactTransformers = [], skipIgnore = true, options = {} ) {
+function applyTransformations( csn, customTransformers = {}, artifactTransformers = [], options = { } ) {
+  if (options.skipIgnore === undefined)
+    options.skipIgnore = true;
+
   if (csn && csn.definitions)
-    return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, skipIgnore, options);
+    return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, options);
   return csn;
 }
 
@@ -176,14 +186,27 @@ function applyTransformations( csn, customTransformers = {}, artifactTransformer
  * @param {object} parent The "parent" of which we transform a property of
  * @param {string} prop The property of parent to start at
  * @param {object} customTransformers Map of prop to transform and function to apply
+ * @param {applyTransformationsOptions} [options={}]
  * @param {CSN.Path} path Path pointing to parent
  * @returns {object} parent[prop] with transformations applied
  */
-function applyTransformationsOnNonDictionary(parent, prop, customTransformers = {}, path = []) {
-  return applyTransformationsInternal(parent, prop, customTransformers, [], true, {}, path)[prop];
+function applyTransformationsOnNonDictionary(parent, prop, customTransformers = {}, options = {}, path = []) {
+  return applyTransformationsInternal(parent, prop, customTransformers, [], options, path)[prop];
 }
 
 module.exports = {
   applyTransformations,
   applyTransformationsOnNonDictionary,
 };
+
+
+/**
+ * @typedef {object} applyTransformationsOptions
+ * @property {(artifact, name) => boolean} [allowArtifact] to only allow certain artifacts
+ * @property {(artifact, name) => boolean} [skipArtifact] to skip certain artifacts
+ * @property {boolean} [drillRef] whether to drill into infix/args
+ * @property {string[]} [skip] skip definitions from certain kind
+ * @property {object} [skipStandard] stop drill-down on certain "standard" props
+ * @property {object} [skipDict] stop drill-down on certain "dictionary" props
+ * @property {boolean} [skipIgnore=true] Whether to skip _ignore elements or not
+ */

package/lib/transform/db/assertUnique.js

@@ -158,7 +158,7 @@ function processAssertUnique(csn, options, error, info) {
     function toRef(val) {
       let ref = val.split('.');
       const [ head, ...tail ] = ref;
-      if ([ '$self', '$projection' ].includes(head))
+      if (head === '$self' || head === '$projection')
         ref = tail;
       return {
         ref: ref.map((ps) => {