@sap/cds-compiler 2.5.0 → 2.10.4

package/lib/render/DuplicateChecker.js

@@ -8,8 +8,6 @@
 
 'use strict';
 
-const walker = require('../json/walker');
-
 /**
  * database name - uppercase if not quoted
  *
@@ -87,13 +85,13 @@ class DuplicateChecker {
    * @param {CSN.Options} options Options used for the compilation
    */
   check(error, options = null) {
-    walker.forEach(this.seenArtifacts, (artifactName, artifacts) => {
+    forEach(this.seenArtifacts, (artifactName, artifacts) => {
       if (artifacts.length > 1) {
         artifacts.slice(1).forEach((artifact) => { // report all colliding artifacts, except the first one
           const collidesWith = this.seenArtifacts[artifactName].find( art => art !== artifact );
           let namingMode;
           if (options)
-            namingMode = options.toHana ? options.toHana.names : options.toSql.names;
+            namingMode = options.sqlMapping;
           else
             namingMode = 'plain';
 
@@ -106,7 +104,7 @@ class DuplicateChecker {
         });
       }
       artifacts.forEach((artifact) => {
-        walker.forEach(artifact.elements, (elementName, elements) => {
+        forEach(artifact.elements, (elementName, elements) => {
           if (elements.length > 1) {
             elements.forEach((element) => { // report all colliding elements
               error(null,
@@ -123,4 +121,9 @@ class DuplicateChecker {
   }
 }
 
+function forEach(obj, callback) {
+  for (const key in obj)
+    callback(key, obj[key]);
+}
+
 module.exports = DuplicateChecker;

package/lib/render/toCdl.js

@@ -8,11 +8,13 @@ const {
   isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
-const { renderFunc, processExprArray, findElement } = require('./utils/common');
+const { renderFunc, beautifyExprArray, findElement } = require('./utils/common');
 const { checkCSNVersion } = require('../json/csnVersion');
 const timetrace = require('../utils/timetrace');
 const { csnRefs } = require('../model/csnRefs');
 const { forEachDefinition } = require('../model/csnUtils');
+const enrichUniversalCsn = require('../transform/universalCsnEnricher');
+const { isBetaEnabled } = require('../base/model');
 
 /**
  * Render the CSN model 'model' to CDS source text. One source is created per
@@ -33,6 +35,9 @@ function toCdsSourceCsn(csn, options) {
   // Skip compactModel if already using CSN
   // const csn = cloneCsn(model, options);
 
+  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
+    enrichUniversalCsn(csn, options);
+
   checkCSNVersion(csn, options);
 
   const result = Object.create(null);
@@ -50,16 +55,20 @@ function toCdsSourceCsn(csn, options) {
       result[main] += `${sourceStr}\n`;
   });
 
-  // Apply possible subelement annotations with an "annotate X with"
+  // Apply possible subelement/action return annotations with an "annotate X with"
+  // Some of them appear in csn.extensions, some not...
   if (subelementAnnotates.length > 0) {
-    for (const [ artName, element, elementName ] of subelementAnnotates) {
-      let sourceStr = `annotate ${artName} with {\n`;
-      sourceStr += `  ${elementName} {\n`;
+    for (const [ artName, element, elementName, suffix ] of subelementAnnotates) {
+      // Suffix is used with action return annotations
+      let sourceStr = `annotate ${artName} with ${suffix ? `${suffix} ` : ''}{\n`;
+      if (elementName) // action returns do not have element name - we need less {} there
+        sourceStr += `  ${elementName} {\n`;
       const env = increaseIndent(increaseIndent(createEnv()));
       const subelements = renderSubelementAnnotates(element, env);
       if (subelements !== '') {
         sourceStr += `${subelements}\n`;
-        sourceStr += '  }\n';
+        if (elementName) // action returns do not have element name - we need less {} there
+          sourceStr += '  }\n';
         sourceStr += '}\n';
         result[main] += `${sourceStr}\n`;
       }
@@ -145,6 +154,12 @@ function toCdsSourceCsn(csn, options) {
       if (ext.elements)
         result += renderElementExtensions(ext.elements, env);
 
+      // Returns annotations
+      if (ext.returns) {
+        const childEnv = increaseIndent(env);
+        result += ` with returns${renderElementExtensions(ext.returns.elements, childEnv)}`;
+      }
+
       // Action annotations
       if (ext.actions) {
         result += ' actions {\n';
@@ -162,10 +177,19 @@ function toCdsSourceCsn(csn, options) {
 
             result += `${paramAnnotations.join(',\n')}\n${childEnv.indent})`;
           }
+          // Annotations on action returns
+          if (action.returns && action.returns.elements) {
+            const grandChildEnv = increaseIndent(childEnv);
+            result += ` returns${renderElementExtensions(action.returns.elements, grandChildEnv)}`;
+          }
+
+
           result += ';\n';
         }
         result += `${env.indent}}`;
       }
+
+
       result += ';';
       return result;
     }).join('\n');
@@ -205,6 +229,7 @@ function toCdsSourceCsn(csn, options) {
   function renderArtifact(artifactName, art, env) {
     // FIXME: Correctly build the paths during runtime to give better locations
     env.path = [ 'definitions', artifactName ];
+    env.artifactName = artifactName;
 
     switch (art.kind) {
       case 'entity':
@@ -509,6 +534,7 @@ function toCdsSourceCsn(csn, options) {
    * @param {Boolean} [isSubElement]
    */
   function renderElement(elementName, elm, env, isSubElement) {
+    env.elementName = elementName;
     let result = renderDocComment(elm, env) + renderAnnotationAssignments(elm, env);
     const quotedElementName = quoteOrUppercaseId(elementName);
     result += `${env.indent + (elm.virtual ? 'virtual ' : '') +
@@ -516,10 +542,11 @@ function toCdsSourceCsn(csn, options) {
                          ((elm.masked && !elm._ignoreMasked) ? 'masked ' : '') +
                          quotedElementName} : ${
       renderTypeReference(elm, env, undefined)
-    }${renderNullability(elm)}`;
+    }${elm.on ? '' : renderNullability(elm)}`;
     if (elm.default)
       result += ` default ${renderExpr(elm.default, env)}`;
 
+    delete env.elementName;
     return `${result};\n`;
   }
 
@@ -688,7 +715,7 @@ function toCdsSourceCsn(csn, options) {
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
-      result += `(${renderArgs(path.ref[0].args, ':', env)})`;
+      result += `(${renderArgs(path.ref[0], ':', env)})`;
 
     if (path.ref[0].where)
       result += `[${path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : ''}${renderExpr(path.ref[0].where, env, true, true)}]`;
@@ -739,17 +766,13 @@ function toCdsSourceCsn(csn, options) {
       result += 'virtual ';
 
     const key = col.key ? 'key ' : '';
-    result += key + renderExpr(col, env, true);
+    // Use special rendering for .expand/.inline - renderExpr cannot easily handle some cases
+    result += key + ((col.expand || col.inline) ? renderInlineExpand(col, env) : renderExpr(col, env, true));
 
-    if (col.as)
+    // Alias is already handled by renderInlineExpand
+    if (!col.inline && !col.expand && col.as)
       result += ` as ${quoteOrUppercaseId(col.as)}`;
 
-    if (col.inline)
-      renderInlineExpand('inline');
-
-    if (col.expand)
-      renderInlineExpand('expand');
-
     // Explicit type provided for the view element?
     if (col.cast) {
       // Special case: Explicit association type is actually a redirect
@@ -764,24 +787,69 @@ function toCdsSourceCsn(csn, options) {
       }
     }
     return result;
+  }
 
-    /**
-     * For the current column, render a (nested) inline/expand.
-     *
-     * @param {'inline'|'expand'} prop
-     */
-    function renderInlineExpand(prop) {
-      if (prop === 'inline')
+  /**
+   * For the current column, render a (nested) inline/expand. If the current column
+   * does not have an .expand/.inline, '' is returned
+   *
+   * @param {object} col Thing with .expand or .inline
+   * @param {CdlRenderEnvironment} parentEnv
+   * @returns {string}
+   */
+  function renderInlineExpand(col, parentEnv) {
+    if (!col.inline && !col.expand)
+      return '';
+
+    return renderIX(col, parentEnv);
+
+    function renderIX(obj, env) {
+      // No expression to render for { * } as alias
+      let result = (obj.as && obj.expand && !obj.ref) ? '' : renderExpr(obj, env);
+
+      // s as alias { * }
+      if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
+        result += ` as ${obj.as}`;
+
+      // We found a leaf - no further drilling
+      if (!obj.inline && !obj.expand) {
+        if (obj.cast && obj.cast.type) {
+          result += ` : ${renderTypeReference(obj.cast, createEnv())}`;
+        }
+        else if (obj.cast && obj.cast.target) { // test tbd
+          result += ` : redirected to ${renderAbsoluteNameWithQuotes(obj.cast.target)}`;
+          if (obj.cast.on)
+            result += ` on ${renderExpr(obj.cast.on, env, true, true)}`;
+          else if (obj.cast.keys)
+            result += ` { ${Object.keys(obj.cast.keys).map(name => renderForeignKey(obj.cast.keys[name], env)).join(', ')} }`;
+        }
+        return result;
+      }
+
+      if (obj.inline)
         result += '.{\n';
       else
-        result += ' {\n';
+        result += result !== '' ? ' {\n' : '{\n';
 
-      col[prop].forEach((elm, i) => {
-        result += `${renderViewColumn(elm, increaseIndent(env))}`;
-        if (i < col[prop].length - 1)
+      // Drill down and render children of the expand/inline
+      const childEnv = increaseIndent(env);
+      const expandInline = obj.expand || obj.inline;
+      expandInline.forEach((elm, i) => {
+        result += `${childEnv.indent}${renderIX(elm, childEnv)}`;
+        if (i < expandInline.length - 1)
           result += ',\n';
       });
       result += `\n${env.indent}}`;
+
+      // Don't forget about the .excluding
+      if (obj.excluding)
+        result += ` excluding { ${obj.excluding.join(',')} }`;
+
+      // { * } as expand
+      if (!obj.ref && obj.as)
+        result += ` as ${obj.as}`;
+
+      return result;
     }
   }
 
@@ -1015,8 +1083,11 @@ function toCdsSourceCsn(csn, options) {
     const childEnv = increaseIndent(env);
     const parameters = Object.keys(act.params || []).map(name => renderParameter(name, act.params[name], childEnv)).join(',\n');
     result += (parameters === '') ? '()' : `(\n${parameters}\n${env.indent})`;
-    if (act.returns)
+    if (act.returns) {
+      if (act.returns.type && act.returns.elements) // action returns annotations
+        subelementAnnotates.push([ actionName, act.returns, '', 'returns' ]);
       result += ` returns ${renderTypeReference(act.returns, env)}${renderNullability(act.returns)}`;
+    }
 
     result += ';\n';
     return result;
@@ -1092,6 +1163,10 @@ function toCdsSourceCsn(csn, options) {
       let rc = `many ${renderTypeReference(elm.items, env)}`;
       if (elm.items.notNull != null)
         rc += elm.items.notNull ? ' not null' : ' null';
+      // many sub element annotates
+      if (elm.items.type && elm.items.elements && env.artifactName)
+        subelementAnnotates.push([ env.artifactName, elm.items, env.elementName ]);
+
       return rc;
     }
 
@@ -1275,7 +1350,7 @@ function toCdsSourceCsn(csn, options) {
   function renderExpr(x, env, inline = true, inExpr = false) {
     // Compound expression
     if (Array.isArray(x))
-      return processExprArray(x, renderExpr, env, inline, inExpr);
+      return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
 
     if (typeof x === 'object' && x !== null) {
       if (inExpr && x.cast && x.cast.type)
@@ -1399,18 +1474,19 @@ function toCdsSourceCsn(csn, options) {
 
         // Not really a path step but an object-like function call
         if (s.func)
-          return `${s.func}(${renderArgs(s.args, '=>', env)})`;
+          return `${s.func}(${renderArgs(s, '=>', env)})`;
 
         // Path step, possibly with view parameters and/or filters
         let result = `${quoteOrUppercaseId(s.id)}`;
         if (s.args) {
           // View parameters
-          result += `(${renderArgs(s.args, ':', env)})`;
+          result += `(${renderArgs(s, ':', env)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality
           result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
         }
+
         return result;
       }
 
@@ -1422,12 +1498,13 @@ function toCdsSourceCsn(csn, options) {
    * Render function arguments or view parameters (positional if array, named if object/dict),
    * using 'sep' as separator for positional parameters
    *
-   * @param {object[]|object} args (Un)Named arguments
+   * @param {object} node with `args` to render
    * @param {string} sep
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderArgs(args, sep, env) {
+  function renderArgs(node, sep, env) {
+    const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
       return args.map(arg => renderExpr(arg, env)).join(', ');
@@ -1819,6 +1896,8 @@ function toCdsSourceCsn(csn, options) {
  *
  * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
  * @property {CSN.Path} [path] CSN path to the current artifact
+ * @property {string}   artifactName Name of the artifact - set in renderArtifact
+ * @property {string}   elementName Name of the element being rendered - set in renderElement
  * @property {{[name: string]: {
       quotedName: string,
       quotedAlias: string