@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/render/toCdl.js

@@ -8,11 +8,13 @@ const {
   isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
-const { renderFunc, processExprArray } = 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`;
   }
 
@@ -727,27 +754,25 @@ function toCdsSourceCsn(csn, options) {
    *
    * @param {object} col
    * @param {CdlRenderEnvironment} env
+   * @param {CSN.Element} element Element corresponding to the column. Generated by the compiler.
    */
-  function renderViewColumn(col, env) {
+  function renderViewColumn(col, env, element) {
     // Annotations and column
-    let result = renderDocComment(col, env) + renderAnnotationAssignments(col, env);
+    let result = renderDocComment(col.doc ? col : element, env) + renderAnnotationAssignments(col, env);
     result += env.indent;
+
     // only if column is virtual, keyword virtual was present in the source text
     if (col.virtual)
       result += 'virtual ';
 
-    const key = (!env.skipKeys && col.key ? 'key ' : '');
-    result += key + renderExpr(col, env, true);
+    const key = col.key ? 'key ' : '';
+    // 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
@@ -762,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;
     }
   }
 
@@ -791,8 +861,11 @@ function toCdsSourceCsn(csn, options) {
    * @returns {String}
    */
   function renderDocComment(obj, env) {
-    if (!(obj && obj.doc))
+    if (!obj || obj && obj.doc === undefined)
       return '';
+    else if (obj && obj.doc === null) // empty doc comment needs to be rendered
+      return `\n${env.indent}/** */\n`;
+
     return `\n${env.indent}/**\n${obj.doc.split('\n').map(line => `${env.indent} * ${line}`).join('\n')}\n${env.indent} */\n`;
   }
 
@@ -818,7 +891,7 @@ function toCdsSourceCsn(csn, options) {
       result += ' as ';
     }
     env._artifact = art;
-    result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ]);
+    result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
     result += ';\n';
     result += renderQueryElementAnnotations(artifactName, art, env);
     result += renderQueryActionsAndFunctions(artifactName, art, env);
@@ -837,18 +910,17 @@ function toCdsSourceCsn(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @param {CSN.Path} [path=[]]
    */
-  function renderQuery(query, isLeadingQuery, syntax, env, path = []) {
+  function renderQuery(query, isLeadingQuery, syntax, env, path = [], elements = query.elements || Object.create(null)) {
     let result = renderDocComment(query, env);
-    env.skipKeys = !isLeadingQuery;
     // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
       // First arg may be leading query
-      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, 'view', env, path.concat([ 'SET', 'args', 0 ]))}`;
+      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, 'view', env, path.concat([ 'SET', 'args', 0 ]), elements)}`;
       // FIXME: Clarify if set operators can be n-ary (assuming binary here)
       if (query.SET.op) {
         // Loop over all other arguments, i.e. for A UNION B UNION C UNION D ...
         for (let i = 1; i < query.SET.args.length; i++)
-          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, 'view', env, path.concat([ 'SET', 'args', i ]))}`;
+          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, 'view', env, path.concat([ 'SET', 'args', i ]), elements)}`;
       }
       result += ')';
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
@@ -890,7 +962,7 @@ function toCdsSourceCsn(csn, options) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += `${select.columns.map(col => renderViewColumn(col, childEnv))
+      result += `${select.columns.map(col => renderViewColumn(col, childEnv, findElement(elements, col)))
         .filter(s => s !== '')
         .join(',\n')}\n`;
       result += `${env.indent}}`;
@@ -1011,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;
@@ -1080,7 +1155,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderTypeReference(elm, env, noEnum = false) {
-    let result = renderDocComment(elm, env);
+    let result = '';
 
     // Array type: Render items instead
     if (elm.items && !elm.type) {
@@ -1088,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;
     }
 
@@ -1205,10 +1284,11 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderEnum(enumPart, env) {
-    let result = `${renderDocComment(enumPart, env)} enum {\n`;
+    let result = ' enum {\n';
     const childEnv = increaseIndent(env);
     for (const name in enumPart) {
       const enumConst = enumPart[name];
+      result += renderDocComment(enumConst, childEnv);
       result += renderAnnotationAssignments(enumConst, childEnv);
       result += childEnv.indent + quoteIdIfRequired(name);
       if (enumConst.val !== undefined)
@@ -1270,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)
@@ -1406,6 +1486,7 @@ function toCdsSourceCsn(csn, options) {
           // Filter, possibly with cardinality
           result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
         }
+
         return result;
       }
 
@@ -1814,6 +1895,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