@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/render/utils/common.js

@@ -20,7 +20,6 @@ const {
 
 const { implicitAs } = require('../../model/csnRefs');
 
-
 /**
  * Render the given function
  *
@@ -37,7 +36,7 @@ function renderFunc( funcName, node, dialect, renderArgs) {
 }
 
 /**
- * Checks wether the given function is to be rendered without parentheses
+ * Checks whether the given function is to be rendered without parentheses
  *
  * @param {object} node Content of the function
  * @param {string} dialect One of 'hana', 'cap' or 'sqlite' - only 'hana' is relevant atm
@@ -205,12 +204,11 @@ function addMissingChildContexts(csn, artifactName, killList) {
       addPossibleGaps(name.slice(artifactName.length + 1).split('.'), artifactName);
   }
 
-  function addPossibleGaps(possibleGaps, artifactName) {
-    let possibleGap = artifactName;
+  function addPossibleGaps(possibleGaps, gapArtifactName) {
     for (const gap of possibleGaps) {
-      possibleGap += `.${gap}`;
-      if (!csn.definitions[possibleGap]) {
-        const contextName = possibleGap;
+      gapArtifactName += `.${gap}`;
+      if (!csn.definitions[gapArtifactName]) {
+        const contextName = gapArtifactName;
         csn.definitions[contextName] = {
           kind: 'context',
         };
@@ -332,7 +330,7 @@ function addIntermediateContexts(csn, killList) {
 }
 
 /**
- * Check wether the given artifact or element has a comment that needs to be rendered.
+ * Check whether the given artifact or element has a comment that needs to be rendered.
  * Things annotated with @cds.persistence.journal (for HANA SQL), should not get a comment.
  *
  * @param {CSN.Artifact} obj
@@ -355,6 +353,21 @@ function getHanaComment(obj) {
   return obj.doc.split('\n\n')[0].trim().replace(/'/g, "''");
 }
 
+/**
+ * Get the @sql.prepend/append if set - already add a space after/before.
+ * If no value is set, use '';
+ *
+ * @param {CSN.Options} options
+ * @param {object} obj
+ * @returns {object} object with .front and .back
+ */
+function getSqlSnippets(options, obj) {
+  const front = obj['@sql.prepend'] ? `${obj['@sql.prepend']} ` : '';
+  const back = obj['@sql.append'] ? ` ${obj['@sql.append']}` : '';
+
+  return { front, back };
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
@@ -383,4 +396,5 @@ module.exports = {
   getHanaComment,
   findElement,
   funcWithoutParen,
+  getSqlSnippets,
 };

package/lib/render/utils/sql.js

@@ -4,20 +4,21 @@
 
 const { getResultingName } = require('../../model/csnUtils');
 const { smartId, delimitedId } = require('../../sql-identifier');
+const { ModelError } = require('../../base/error');
 
 /**
  * Render a given referential constraint as part of a SQL CREATE TABLE statement, or as .hdbconstraint artefact.
  *
  * @param {CSN.ReferentialConstraint} constraint Content of the constraint
  * @param {string} indent Indent to render the SQL with
- * @param {boolean} toUpperCase Wether to uppercase the identifier
+ * @param {boolean} toUpperCase Whether to uppercase the identifier
  * @param {CSN.Model} csn CSN
  * @param {CSN.Options} options is needed for the naming mode and the sql dialect
- * @param {boolean} alterConstraint whether the constraint should be rendered as part of an ALTER TABLE statement
+ * @param {boolean} [alterConstraint=false] whether the constraint should be rendered as part of an ALTER TABLE statement
  *
  * @returns {string} SQL statement which can be used to create the referential constraint on the db.
  */
-function renderReferentialConstraint(constraint, indent, toUpperCase, csn, options, alterConstraint) {
+function renderReferentialConstraint(constraint, indent, toUpperCase, csn, options, alterConstraint = false) {
   let quoteId;
   // for to.hana we can't utilize the sql identifier utils
   if (options.transformation === 'hdbcds') {
@@ -51,14 +52,16 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
   if (!alterConstraint) {
     result += `${indent}FOREIGN KEY(${constraint.foreignKey.map(quoteId).join(', ')})\n`;
     result += `${indent}REFERENCES ${quoteId(getResultingName(csn, names, constraint.parentTable))}(${constraint.parentKey.map(quoteId).join(', ')})\n`;
+    const onDeleteRemark = constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : '';
+
     // omit 'RESTRICT' action for ON UPDATE / ON DELETE, because it interferes with deferred constraint check
     if (forSqlite) {
       if (constraint.onDelete === 'CASCADE' )
-        result += `${indent}ON DELETE ${constraint.onDelete}${constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : ''}\n`;
+        result += `${indent}ON DELETE ${constraint.onDelete}${onDeleteRemark}\n`;
     }
     else {
       result += `${indent}ON UPDATE RESTRICT\n`;
-      result += `${indent}ON DELETE ${constraint.onDelete}${constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : ''}\n`;
+      result += `${indent}ON DELETE ${constraint.onDelete}${onDeleteRemark}\n`;
     }
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
@@ -119,7 +122,7 @@ function getIdentifierUtils(options) {
   function prepareIdentifier(name) {
     // Sanity check
     if (options.toSql.dialect === 'sqlite' && options.toSql.names !== 'plain')
-      throw new Error(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
+      throw new ModelError(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
 
 
     switch (options.toSql.names) {
@@ -130,7 +133,7 @@ function getIdentifierUtils(options) {
       case 'hdbcds':
         return name;
       default:
-        throw new Error(`No matching rendering found for naming mode ${options.toSql.names}`);
+        throw new ModelError(`No matching rendering found for naming mode ${options.toSql.names}`);
     }
   }
 }

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/braceExpression.js

@@ -1,8 +1,10 @@
 'use strict';
 
 function isAlreadyBraced(expression, start, end){
-  const isBraced = start - 1 > -1 && end + 1 < expression.length && expression[start-1] === '(' && expression[end+1] === ')';
-  return isBraced;
+  return start - 1 > -1 &&
+    end + 1 < expression.length &&
+    expression[start-1] === '(' &&
+    expression[end+1] === ')';
 }
 
 function binarycomparison(expression, token, index){

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

@@ -0,0 +1,212 @@
+'use strict';
+
+/**
+ * Module for general (partial) CSN looper functions, respecting dictionaries and allowing
+ * to pass custom callbacks for certain properties like "ref".
+ *
+ * Functions are also published in csnUtils.js for convenience.
+ *
+ * They should stay here due to the stricter linter rules for the time being.
+ *
+ * @module lib/transform/db/applyTransformations
+ */
+const { setProp } = require('../../base/model');
+
+
+/**
+ * @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 {Function[]} [artifactTransformers=[]] Transformations to run on the artifacts, like forEachDefinition
+ * @param {applyTransformationsOptions} [options={}]
+ * @param {CSN.Path} path Path to parent
+ * @returns {object} parent with transformations applied
+ */
+function applyTransformationsInternal(parent, prop, customTransformers, artifactTransformers, options, path = []) {
+  const transformers = {
+    elements: dictionary,
+    definitions: dictionary,
+    actions: dictionary,
+    params: dictionary,
+    enum: dictionary,
+    mixin: dictionary,
+    ref: pathRef,
+    $origin: () => {}, // no-op
+  };
+
+  const csnPath = [ ...path ];
+  if (prop === 'definitions')
+    definitions( parent, 'definitions', parent.definitions );
+  else
+    standard(parent, prop, parent[prop]);
+  return parent;
+
+  /**
+   * Default transformer for things that are not dictionaries, like "type" or "keys".
+   * The customTransformers are applied here (and only here).
+   *
+   * @param {object | Array} _parent the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @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('@')) ||
+        (options.skipIgnore && node._ignore) ||
+        (options.skipStandard && options.skipStandard[_prop])
+    )
+      return;
+
+    csnPath.push( _prop );
+
+    if (Array.isArray(node)) {
+      node.forEach( (n, i) => standard( node, i, n ) );
+    }
+
+    else {
+      for (const name of Object.getOwnPropertyNames( node )) {
+        const trans = transformers[name] || standard;
+        if (customTransformers[name])
+          customTransformers[name](node, name, node[name], csnPath, _parent, _prop);
+
+        trans( node, name, node[name], csnPath );
+      }
+    }
+    csnPath.pop();
+  }
+
+  /**
+   * Transformer for things that are dictionaries - like "elements".
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} dict The value of node[_prop]
+   */
+  function dictionary( node, _prop, dict ) {
+    // Allow skipping dicts like actions in forHanaNew
+    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 ))
+      standard( dict, name, dict[name] );
+
+    if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
+      setProp(node, `$${_prop}`, dict);
+    csnPath.pop();
+  }
+
+  /**
+   * Special version of "dictionary" to apply artifactTransformers.
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {object} dict The value of node[_prop]
+   */
+  function definitions( node, _prop, dict ) {
+    csnPath.push( _prop );
+    for (const name of Object.getOwnPropertyNames( dict )) {
+      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] );
+      }
+    }
+    if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
+      setProp(node, `$${_prop}`, dict);
+    csnPath.pop();
+  }
+
+  /**
+   * Keep looping through the pathRef - because in a .ref we can have .args and .where
+   *
+   * @param {object | Array} node the thing that has _prop
+   * @param {string|number} _prop the name of the current property
+   * @param {any} _path The value of node[_prop]
+   */
+  function pathRef( node, _prop, _path ) {
+    csnPath.push( _prop );
+    _path.forEach( ( s, i ) => {
+      if (s && typeof s === 'object') {
+        csnPath.push( i );
+        if (options.drillRef) {
+          standard(_path, i, s);
+        }
+        else {
+          if (s.args)
+            standard( s, 'args', s.args );
+          if (s.where)
+            standard( s, 'where', s.where );
+        }
+        csnPath.pop();
+      }
+    } );
+    csnPath.pop();
+  }
+}
+
+/**
+ * Loop through the model, applying the custom transformations on the node's matching.
+ *
+ * Each transformer gets:
+ * - the parent having the property
+ * - the name of the property
+ * - the value of the property
+ * - the path to the property
+ *
+ * @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 {applyTransformationsOptions} [options={}]
+ * @returns {object} CSN with transformations applied
+ */
+function applyTransformations( csn, customTransformers = {}, artifactTransformers = [], options = { } ) {
+  if (options.skipIgnore === undefined)
+    options.skipIgnore = true;
+
+  if (csn && csn.definitions)
+    return applyTransformationsInternal(csn, 'definitions', customTransformers, artifactTransformers, options);
+  return csn;
+}
+
+
+/**
+ * Instead of looping through the whole model, start at a given thing (like an on-condition),
+ * as long as it is not a dictionary.
+ *
+ * Each transformer gets:
+ * - the parent having the property
+ * - the name of the property
+ * - the value of the property
+ * - the path to the property
+ *
+ * @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 = {}, 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) => {