@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/render/utils/common.js

@@ -2,6 +2,8 @@
 
 'use strict';
 
+const { ModelError } = require('../../base/error');
+
 const functionsWithoutParams = {
   hana: {
     CURRENT_CONNECTION: {},
@@ -19,8 +21,6 @@ const {
 } = require('../../model/csnUtils');
 
 const { implicitAs } = require('../../model/csnRefs');
-const { isBetaEnabled } = require('../../base/model');
-
 
 /**
  * Render the given function
@@ -38,7 +38,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
@@ -282,12 +282,12 @@ const cdsToSqlTypes = {
 };
 
 /**
-   * Get the element matching the column
-   *
-   * @param {CSN.Elements} elements Elements of a query
-   * @param {CSN.Column} column Column from the same query
-   * @returns {CSN.Element}
-   */
+ * Get the element matching the column
+ *
+ * @param {CSN.Elements} elements Elements of a query
+ * @param {CSN.Column} column Column from the same query
+ * @returns {CSN.Element}
+ */
 function findElement(elements, column) {
   if (!elements)
     return undefined;
@@ -332,7 +332,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
@@ -343,16 +343,17 @@ function hasHanaComment(obj, options) {
   return !options.disableHanaComments && typeof obj.doc === 'string';
 }
 /**
-   * Return the comment of the given artifact or element.
-   * Uses the first block (everything up to the first empty line (double \n)).
-   * Remove leading/trailing whitespace.
-   *
-   * @param {CSN.Artifact|CSN.Element} obj
-   * @returns {string}
-   * @todo Warning/info to user?
-   */
+ * Return the comment of the given artifact or element.
+ * Uses the first block (everything up to the first empty line (double \n)).
+ * Remove leading/trailing whitespace.
+ * Does not escape any characters.
+ *
+ * @param {CSN.Artifact|CSN.Element} obj
+ * @returns {string}
+ * @todo Warning/info to user?
+ */
 function getHanaComment(obj) {
-  return obj.doc.split('\n\n')[0].trim().replace(/'/g, "''");
+  return obj.doc.split('\n\n')[0].trim();
 }
 
 /**
@@ -364,13 +365,122 @@ function getHanaComment(obj) {
  * @returns {object} object with .front and .back
  */
 function getSqlSnippets(options, obj) {
-  if (isBetaEnabled(options, 'sqlSnippets')) {
-    const front = obj['@sql.prepend'] ? `${obj['@sql.prepend']} ` : '';
-    const back = obj['@sql.append'] ? ` ${obj['@sql.append']}` : '';
+  const front = obj['@sql.prepend'] ? `${obj['@sql.prepend']} ` : '';
+  const back = obj['@sql.append'] ? ` ${obj['@sql.append']}` : '';
 
-    return { front, back };
-  }
-  return { front: '', back: '' };
+  return { front, back };
+}
+
+/**
+ * A function used to render a certain part of an expression object
+ *
+ * @callback renderPart
+ * @param {object||array} expression
+ * @param {CdlRenderEnvironment} env
+ * @this {{inline: Boolean, nestedExpr: Boolean}}
+ * @returns {string}
+ */
+
+/**
+ * The object containing the concrete rendering functions for the different parts
+ * of an expression
+ *
+ * @typedef {object} ExpressionConfiguration
+ * @property {(x: any) => string} finalize The final function to call on the expression(-string) before returning
+ * @property {renderPart} explicitTypeCast
+ * @property {renderPart} val
+ * @property {renderPart} enum
+ * @property {renderPart} ref
+ * @property {renderPart} aliasOnly
+ * @property {renderPart} windowFunction
+ * @property {renderPart} func
+ * @property {renderPart} xpr
+ * @property {renderPart} SELECT
+ * @property {renderPart} SET
+ */
+
+/**
+ * Render an expression (including paths and values) or condition 'x'.
+ * (no trailing LF, don't indent if inline)
+ *
+ * @param {ExpressionConfiguration} renderer
+ * @returns {Function} Rendered expression
+ */
+function getExpressionRenderer(renderer) {
+  /**
+   * Render an expression (including paths and values) or condition 'x'.
+   * (no trailing LF, don't indent if inline)
+   *
+   * @todo Reuse this with toCdl
+   * @param {Array|object|string} expr Expression to render
+   * @param {object} env Render environment
+   * @param {boolean} [inline=true] Whether to render the expression inline
+   * @param {boolean} [nestedExpr=false] Whether to treat the expression as nested
+   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `nestedExpr === false`.
+   *                                           Note: This is a hack for casts() inside groupBy.
+   * @returns {string} Rendered expression
+   */
+  return function renderExpr(expr, env, inline = true, nestedExpr = false, alwaysRenderCast = false) {
+  // Compound expression
+    if (Array.isArray(expr)) {
+      const tokens = expr.map(item => renderExpr(item, env, inline, nestedExpr));
+      return beautifyExprArray(tokens);
+    }
+    else if (typeof expr === 'object' && expr !== null) {
+      if ((nestedExpr || alwaysRenderCast) && expr.cast && expr.cast.type && !expr.cast.target)
+        return renderer.explicitTypeCast.call({ inline, nestedExpr }, expr, env);
+      return renderExprObject(expr);
+    }
+    // Not a literal value but part of an operator, function etc - just leave as it is
+    // FIXME: For the sake of simplicity, we should get away from all this uppercasing in toSql
+    return renderer.finalize.call({ inline, nestedExpr }, expr, env);
+
+
+    /**
+     * Various special cases represented as objects
+     *
+     * @param {object} x Expression
+     * @returns {string} String representation of the expression
+     */
+    function renderExprObject(x) {
+      if (x.list) { // TODO: Does this still exist?
+        return `(${x.list.map(item => renderExpr(item, env, inline, false)).join(', ')})`;
+      }
+      else if (x.val !== undefined) {
+        return renderer.val.call({ inline, nestedExpr }, x, env);
+      }
+      // Enum symbol
+      else if (x['#']) {
+        return renderer.enum.call({ inline, nestedExpr }, x, env);
+      }
+      // Reference: Array of path steps, possibly preceded by ':'
+      else if (x.ref) {
+        return renderer.ref.call({ inline, nestedExpr }, x, env);
+      }
+      // Function call, possibly with args (use '=>' for named args)
+      else if (x.func) {
+        if (x.xpr)
+          return renderer.windowFunction.call({ inline, nestedExpr }, x, env);
+        return renderer.func.call({ inline, nestedExpr }, x, env);
+      }
+      // Nested expression
+      else if (x.xpr) {
+        return renderer.xpr.call({ inline, nestedExpr }, x, env);
+      }
+      // Sub-select
+      else if (x.SELECT) {
+        return renderer.SELECT.call({ inline, nestedExpr }, x, env);
+      }
+      else if (x.SET) {
+        return renderer.SET.call({ inline, nestedExpr }, x, env);
+      }
+      else if (x.as && x.cast && x.cast.type && x.cast.target) {
+        return renderer.aliasOnly.call({ inline, nestedExpr }, x, env);
+      }
+
+      throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
+    }
+  };
 }
 
 /**
@@ -391,6 +501,7 @@ function getSqlSnippets(options, obj) {
 
 module.exports = {
   renderFunc,
+  getExpressionRenderer,
   beautifyExprArray,
   getNamespace,
   getRealName,

package/lib/render/utils/sql.js

@@ -4,13 +4,14 @@
 
 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=false] whether the constraint should be rendered as part of an ALTER TABLE statement
@@ -121,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) {
@@ -132,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/db/.eslintrc.json

@@ -8,11 +8,13 @@
     "prefer-template": "error",
     "no-trailing-spaces": "error",
     "template-curly-spacing":["error", "never"],
-    "complexity": ["warn", 30],
+    "complexity": ["warn", 40],
     "max-len": "off",
     // 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) => {