@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/render/utils/common.js

@@ -2,6 +2,8 @@
 
 'use strict';
 
+const { ModelError } = require('../../base/error');
+
 const functionsWithoutParams = {
   hana: {
     CURRENT_CONNECTION: {},
@@ -277,15 +279,27 @@ const cdsToSqlTypes = {
     'cds.hana.BINARY': 'BINARY',
     'cds.hana.SMALLDECIMAL': 'DECIMAL',
   },
+  postgres: {
+    // TODO: Type mapping for binary types is not correct, yet.
+    // We can't use text types for binary on PostgreSQL due to NUL!
+    'cds.String': 'VARCHAR',
+    'cds.LargeString': 'text',
+    'cds.hana.CLOB': 'text',
+    'cds.LargeBinary': 'bytea',
+    'cds.Binary': 'VARCHAR',
+    'cds.hana.BINARY': 'VARCHAR',
+    'cds.Double': 'double precision',
+    'cds.hana.TINYINT': 'INTEGER',
+  },
 };
 
 /**
-   * 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;
@@ -341,16 +355,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();
 }
 
 /**
@@ -368,6 +383,120 @@ function getSqlSnippets(options, obj) {
   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
+ * @property {boolean} [inline]
+ * @property {boolean} [nestedExpr]
+ */
+
+/**
+ * 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)}`);
+    }
+  };
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
@@ -386,6 +515,7 @@ function getSqlSnippets(options, obj) {
 
 module.exports = {
   renderFunc,
+  getExpressionRenderer,
   beautifyExprArray,
   getNamespace,
   getRealName,

package/lib/render/utils/sql.js

@@ -40,18 +40,18 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
   }
 
   const renderAsHdbconstraint = options.transformation === 'hdbcds' ||
-                                (options.toSql && options.toSql.src === 'hdi') ||
+                                options.src === 'hdi' ||
                                 (options.manageConstraints && options.manageConstraints.src === 'hdi');
 
-  const { names } = options.forHana;
-  const forSqlite = options.toSql && options.toSql.dialect === 'sqlite';
+  const { sqlMapping } = options;
+  const forSqlite = options.sqlDialect === 'sqlite';
   let result = '';
   result += `${indent}CONSTRAINT ${quoteId(constraint.identifier)}\n`;
   if (renderAsHdbconstraint)
-    result += `${indent}ON ${quoteId(getResultingName(csn, names, constraint.dependentTable))}\n`;
+    result += `${indent}ON ${quoteId(getResultingName(csn, sqlMapping, constraint.dependentTable))}\n`;
   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`;
+    result += `${indent}REFERENCES ${quoteId(getResultingName(csn, sqlMapping, 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
@@ -65,12 +65,13 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     }
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
-  if (options.toSql && options.toSql.dialect !== 'sqlite') {
+  // Does not include HDBCDS.
+  if (options.toSql && !forSqlite) {
     result += `${indent}${!constraint.validated ? 'NOT ' : ''}VALIDATED\n`;
     result += `${indent}${!constraint.enforced ? 'NOT ' : ''}ENFORCED\n`;
   }
   // for sqlite, the DEFERRABLE keyword is required
-  result += `${indent}${options.toSql && options.toSql.dialect === 'sqlite' ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
+  result += `${indent}${forSqlite ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
   return result;
 }
 
@@ -85,9 +86,9 @@ function getIdentifierUtils(options) {
   /**
    * Return 'name' with appropriate "-quotes.
    * Additionally perform the following conversions on 'name'
-   * If 'options.toSql.names' is 'plain'
+   * If 'options.sqlMapping' is 'plain'
    *   - replace '.' or '::' by '_'
-   * else if 'options.toSql.names' is 'quoted'
+   * else if 'options.sqlMapping' is 'quoted'
    *   - replace '::' by '.'
    * Complain about names that collide with known SQL keywords or functions
    *
@@ -97,13 +98,13 @@ function getIdentifierUtils(options) {
   function quoteSqlId(name) {
     name = prepareIdentifier(name);
 
-    switch (options.toSql.names) {
+    switch (options.sqlMapping) {
       case 'plain':
-        return smartId(name, options.toSql.dialect);
+        return smartId(name, options.sqlDialect);
       case 'quoted':
-        return delimitedId(name, options.toSql.dialect);
+        return delimitedId(name, options.sqlDialect);
       case 'hdbcds':
-        return delimitedId(name, options.toSql.dialect);
+        return delimitedId(name, options.sqlDialect);
       default:
         return undefined;
     }
@@ -111,9 +112,9 @@ function getIdentifierUtils(options) {
 
   /**
      * Prepare an identifier:
-     * If 'options.toSql.names' is 'plain'
+     * If 'options.sqlMapping' is 'plain'
      *   - replace '.' or '::' by '_'
-     * else if 'options.toSql.names' is 'quoted'
+     * else if 'options.sqlMapping' is 'quoted'
      *  - replace '::' by '.'
      *
      * @param {string} name Identifier to prepare
@@ -121,11 +122,11 @@ function getIdentifierUtils(options) {
      */
   function prepareIdentifier(name) {
     // Sanity check
-    if (options.toSql.dialect === 'sqlite' && options.toSql.names !== 'plain')
-      throw new ModelError(`Not expecting ${options.toSql.names} names for 'sqlite' dialect`);
+    if (options.sqlDialect === 'sqlite' && options.sqlMapping !== 'plain')
+      throw new ModelError(`Not expecting ${options.sqlMapping} names for 'sqlite' dialect`);
 
 
-    switch (options.toSql.names) {
+    switch (options.sqlMapping) {
       case 'plain':
         return name.replace(/(\.|::)/g, '_');
       case 'quoted':
@@ -133,7 +134,7 @@ function getIdentifierUtils(options) {
       case 'hdbcds':
         return name;
       default:
-        throw new ModelError(`No matching rendering found for naming mode ${options.toSql.names}`);
+        throw new ModelError(`No matching rendering found for naming mode ${options.sqlMapping}`);
     }
   }
 }

package/lib/sql-identifier.js

@@ -45,6 +45,12 @@ const sqlDialects = {
     effectiveName: name => name,
     asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
   },
+  postgres: {
+    regularRegex: /^[A-Za-z_][A-Za-z_$0-9]*$/,
+    reservedWords: keywords.postgres,
+    effectiveName: name => name.toLowerCase(),
+    asDelimitedId: name => `"${ name.replace(/"/g, '""')}"`,
+  },
   hana: {
     regularRegex: /^[A-Za-z_][A-Za-z_$#0-9]*$/,
     reservedWords: keywords.hana,

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

@@ -8,7 +8,7 @@
     "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",
@@ -17,15 +17,16 @@
     "sonarjs/prefer-single-boolean-return": "off",
     // Very whiny and nitpicky
     "sonarjs/cognitive-complexity": "off",
+    "sonarjs/no-duplicate-string": "off",
     // Does not recognize TS types
     "jsdoc/no-undefined-types": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   "settings": {

package/lib/transform/db/associations.js

@@ -37,7 +37,7 @@ function attachOnConditions(csn, pathDelimiter) {
   /**
    * Create the foreign key elements for a managed association and build the on-condition
    *
-   * @param {Object} elem The association to process
+   * @param {object} elem The association to process
    * @param {string} elemName
    * @returns {void}
    */
@@ -167,7 +167,7 @@ function getManagedAssocStepsInOnConditionFinalizer(csn, pathDelimiter) {
      *
      * @param {Array} links
      * @param {number} startIndex
-     * @returns {Object| undefined} CSN definition of the source of the managed association
+     * @returns {object | undefined} CSN definition of the source of the managed association
      */
     function findSource(links, startIndex) {
       for (let i = startIndex; i >= 0; i--) {

package/lib/transform/db/cdsPersistence.js

@@ -81,26 +81,16 @@ function getAssocToSkippedIgnorer(csn, options, messageFunctions) {
    * @todo Why do we check for @cds.persistence.exists here if the parent-function only calls this for skip/abstract?
    */
   function ignore(member, memberName, prop, path) {
-    if (options.sqlDialect === 'hana' && !member._ignore && member.target && isAssocOrComposition(member.type) && isUnreachableAssociationTarget(csn.definitions[member.target])) {
-      const targetAnnotation = hasAnnotationValue(csn.definitions[member.target], exists) ? exists : '@cds.persistence.skip';
+    if (options.sqlDialect === 'hana' &&
+       !member._ignore && member.target &&
+       isAssocOrComposition(member.type) &&
+       !isPersistedOnDatabase(csn.definitions[member.target])) {
       info(null, path,
-           { target: member.target, anno: targetAnnotation },
+           { target: member.target, anno: '@cds.persistence.skip' },
            'Association has been removed as it\'s target $(TARGET) is annotated with $(ANNO)');
       member._ignore = true;
     }
   }
-
-  /**
-   * Check whether the given artifact is an unreachable association target because it will not "realy" hit the database:
-   * - @cds.persistence.skip/exists
-   * - abstract
-   *
-   * @param {CSN.Artifact} art
-   * @returns {boolean}
-   */
-  function isUnreachableAssociationTarget(art) {
-    return !isPersistedOnDatabase(art) || hasAnnotationValue(art, exists);
-  }
 }
 
 /**

package/lib/transform/db/constraints.js

@@ -277,7 +277,9 @@ function createReferentialConstraints(csn, options) {
     // no constraint if either dependent or parent is not persisted
     if (
       hasAnnotationValue(parent, '@cds.persistence.skip') ||
-      hasAnnotationValue(dependent, '@cds.persistence.skip')
+      hasAnnotationValue(dependent, '@cds.persistence.skip') ||
+      hasAnnotationValue(parent, '@cds.persistence.exists') ||
+      hasAnnotationValue(dependent, '@cds.persistence.exists')
     )
       return true;
 
@@ -515,7 +517,7 @@ function createReferentialConstraints(csn, options) {
         onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
       referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.sourceAssociation}`] = {
         // constraint identifier start with `c__` to avoid name clashes
-        identifier: `c__${getResultingName(csn, options.forHana.names, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
+        identifier: `c__${getResultingName(csn, options.sqlMapping, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`,
         foreignKey: dependentKey,
         parentKey,
         dependentTable: artifactName,

package/lib/transform/db/expansion.js

@@ -8,6 +8,7 @@ const {
 } = require('../../model/csnUtils');
 const { csnRefs, implicitAs } = require('../../model/csnRefs');
 const { setProp, isBetaEnabled } = require('../../base/model');
+const { forEach } = require('../../utils/objectUtils');
 
 /**
  * For keys, columns, groupBy and orderBy, expand structured things.
@@ -19,14 +20,15 @@ const { setProp, isBetaEnabled } = require('../../base/model');
  * @param {object} messageFunctions
  * @param {Function} messageFunctions.error
  * @param {Function} messageFunctions.info
- * @param {Function} messageFunctions.throwWithError
+ * @param {Function} messageFunctions.throwWithAnyError
  * @param {object} iterateOptions
  */
-function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithError }, iterateOptions = {}) {
+function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {}) {
+  const csnUtils = getUtils(csn);
   const {
-    isStructured, get$combined, getFinalBaseType, getServiceName,
-  } = getUtils(csn);
-  let { effectiveType, inspectRef } = csnRefs(csn);
+    isStructured, get$combined, getFinalBaseTypeWithProps, getServiceName,
+  } = csnUtils;
+  let { effectiveType, inspectRef } = csnUtils;
 
   if (isBetaEnabled(options, 'nestedProjections'))
     rewriteExpandInline();
@@ -182,7 +184,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     }
 
     // We would be broken if we continue with assoc usage to now skipped
-    throwWithError();
+    throwWithAnyError();
 
 
     for (const {
@@ -211,7 +213,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       while (stack.length > 0) {
         const [ a, n ] = stack.pop();
         if (a[_dependents]) {
-          Object.entries(a[_dependents]).forEach(([ dependentName, dependent ]) => {
+          forEach(a[_dependents], (dependentName, dependent) => {
             stack.push([ dependent, dependentName ]);
           });
         }
@@ -238,13 +240,13 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      */
     function nextBase(parent, base) {
       if (parent.ref) {
-        const finalBaseType = getFinalBaseType(parent._art.type);
+        const finalBaseType = getFinalBaseTypeWithProps(parent._art.type);
         const art = parent._art;
 
-        if (finalBaseType === 'cds.Association' || finalBaseType === 'cds.Composition')
+        if (finalBaseType && (finalBaseType.type === 'cds.Association' || finalBaseType.type === 'cds.Composition'))
           return csn.definitions[art.target].elements;
 
-        return art.elements || finalBaseType.elements;
+        return art.elements || finalBaseType?.elements;
       }
 
       return base;
@@ -253,7 +255,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     /**
      * Rewrite expand and inline to "normal" refs
      *
-     * @param {CSN.Artifact} root All elements visible fromt he query source ($combined)
+     * @param {CSN.Artifact} root All elements visible from the query source ($combined)
      * @param {CSN.Column[]} columns
      * @param {string[]} excluding
      * @returns {{columns: Array, toMany: Array}} Object with rewritten columns (.expand/.inline) and with any .expand + to-many
@@ -261,8 +263,12 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
     function rewrite(root, columns, excluding) {
       const allToMany = [];
       const newThing = [];
-      // Replace stars - needs to happen here since the .expand/.inline first path step affects the root *
-      columns = replaceStar(root, columns, excluding);
+      const containsExpandInline = columns.some(col => col.expand || col.inline);
+      if (containsExpandInline) // Replace stars - needs to happen before resolving .expand/.inline since the .expand/.inline first path step affects the root *
+        columns = replaceStar(root, columns, excluding);
+      else
+        return { columns, toMany: [] };
+
       for (const col of columns) {
         if (col.expand) {
           // TODO: Can col.ref be empty without an as? Assumption is it cannot - if it has, it's an error, we throw, compiler checks.
@@ -402,8 +408,8 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @returns {string|null} Name of any entity
      */
     function findAnEntity() {
-      for (const [ name, artifact ] of Object.entries(csn.definitions)) {
-        if (artifact.kind === 'entity' && !artifact.query)
+      for (const name in csn.definitions) {
+        if (Object.hasOwnProperty.call(csn.definitions, name) && csn.definitions[name].kind === 'entity' && !csn.definitions[name].query)
           return name;
       }
       return null;
@@ -544,7 +550,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
   /**
    * Replace the star and correctly put shadowed things in the right place.
    *
-   * @param {Object} base The raw set of things a * can expand to
+   * @param {object} base The raw set of things a * can expand to
    * @param {Array} subs Things - the .expand/.inline or .columns
    * @param {string[]} [excluding=[]]
    * @returns {Array} If there was a star, expand it and handle shadowing/excluding, else just return subs