@sap/cds-compiler 2.10.2 → 2.10.4

package/CHANGELOG.md

@@ -7,6 +7,16 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 2.10.4 - 2021-11-05
+
+### Fixed
+
+- to.sql/hdi/hdbcds:
+  + Correctly complain about `exists` in conjunction with non-associations/compositions
+  + Don't resolve types in action returns, as this causes issues with $self-resolution
+
+- to.edm(x): Be robust against transitively untyped keys in stacked view hierarchies
+
 ## Version 2.10.2 - 2021-10-29
 
 ### Fixed
@@ -38,13 +48,9 @@ The compiler behavior concerning `beta` features can change at any time without
   + `exists` can now be followed by more than one association step.
   `exists assoc.anotherassoc.moreassoc` is semantically equivalent to `exists assoc[exists anotherassoc[exists moreassoc]]`
 
-### Removed
-
 ### Changed
 
-- to.odata: Inform when overwriting draft action annotations like @Common.DraftRoot.ActivationAction.
-
-### Fixed
+- to.odata: Inform when overwriting draft action annotations like `@Common.DraftRoot.ActivationAction`.
 
 ## Version 2.9.0 - 2021-10-15
 

package/doc/CHANGELOG_BETA.md

@@ -8,6 +8,12 @@ Note: `beta` fixes, changes and features are listed in this ChangeLog just for i
 The compiler behavior concerning `beta` features can change at any time without notice.
 **Don't use `beta` fixes, changes and features in productive mode.**
 
+## Version 2.10.4
+
+### Fixed `nestedProjections`
+
+- to.sql/hdi/hdbcds: Correctly handle a `*` at the not-first place in the query
+
 ## Version 2.6.0
 
 ### Removed `pretransformedCSN`

package/lib/compiler/resolver.js

@@ -541,7 +541,8 @@ function resolve( model ) {
     if (art.elements || art.kind === '$tableAlias' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
-        struct.kind !== 'type' && struct.kind !== 'element' && !struct._outer)
+        struct.kind !== 'type' && struct.kind !== 'element' && struct.kind !== 'param' &&
+        !struct._outer)
       return false;
     if (struct.elements === 0 || isInParents( art, eType )) {
       art.elements = 0;         // circular
@@ -1586,6 +1587,11 @@ function resolve( model ) {
       }
     }
     if (art && art._annotate) {
+      if (art.kind === 'action' || art.kind === 'function') {
+        expandParameters( art );
+        if (art.returns)
+          effectiveType( art.returns );
+      }
       const aor = art.returns || art;
       const obj = aor.items || aor.targetAspect || aor;
       // Currently(?), effectiveType() does not calculate the effective type of
@@ -1620,6 +1626,42 @@ function resolve( model ) {
         annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
     }
   }
+  function expandParameters( action ) {
+    // see also expandElements()
+    if (!enableExpandElements || !effectiveType( action ))
+      return;
+    const chain = [];
+    // Should we be able to consider params and returns separately?
+    // Probably not, let to-csn omit unchanged params/returns.
+    while (action._origin && !action.params) {
+      chain.push( action );
+      action = action._origin;
+    }
+    chain.reverse();
+    for (const art of chain) {
+      const origin = art._origin;
+      if (!art.params && origin.params) {
+        for (const name in origin.params) {
+          // TODO: we could check _annotate here to decide whether we really
+          // not to create proxies
+          const orig = origin.params[name];
+          linkToOrigin( orig, name, art, 'params', weakLocation( orig.location ), true )
+            .$inferred = 'expand-param';
+        }
+      }
+      if (!art.returns && origin.returns) {
+        // TODO: make linkToOrigin() work for returns, kind/name?
+        const location = weakLocation( origin.returns.location );
+        art.returns = {
+          name: Object.assign( {}, art.name, { id: '', param: '', location } ),
+          kind: 'param',
+          location,
+          $inferred: 'expand-param',
+        };
+        setProp( art.returns, '_origin', origin.returns );
+      }
+    }
+  }
 
   function extensionFor( art ) {
     if (art.kind === 'annotate')

package/lib/edm/edmPreprocessor.js

@@ -1351,7 +1351,8 @@ function initializeModel(csn, _options, messageFunctions)
       // OData requires all elements along the path to be nullable: false (that is either key or notNull)
 
       const finalType = getFinalTypeDef(eltCsn.items && eltCsn.items.type || eltCsn.type);
-      const elements = eltCsn.elements || eltCsn.items && eltCsn.items.elements|| finalType.elements || finalType.items && finalType.items.elements;
+      const elements = eltCsn.elements || eltCsn.items && eltCsn.items.elements || 
+      (finalType && (finalType.elements || finalType.items && finalType.items.elements));
       if(elements) {
         Object.entries(elements).forEach(([eltName, elt]) => {
           const newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName);
@@ -1400,7 +1401,7 @@ function initializeModel(csn, _options, messageFunctions)
           {name: pathSegment, '#': pathSegment ? 'std' : 'scalar'});
       }
       // many
-      let type = elt.items || getFinalTypeDef(elt.type).items;
+      let type = elt.items || elt.type && !isBuiltinType(elt.type) && getFinalTypeDef(elt.type).items;
       if(type) {
         error('odata-spec-violation-key-array', location,
           {name: pathSegment, '#': pathSegment ? 'std' : 'scalar'});

package/lib/model/csnUtils.js

@@ -1107,6 +1107,9 @@ function applyTransformations( csn, customTransformers={}, artifactTransformers=
   }
 
   function dictionary( node, prop, dict ) {
+    // Allow skipping dicts like actions in forHanaNew
+    if(options.skipDict && options.skipDict[prop])
+      return;
     csnPath.push( prop );
     for (let name of Object.getOwnPropertyNames( dict )) {
       standard( dict, name, dict[name] );

package/lib/render/toCdl.js

@@ -715,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)}]`;
@@ -1474,13 +1474,13 @@ 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
@@ -1498,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(', ');

package/lib/render/toHdbcds.js

@@ -630,7 +630,7 @@ function toHdbcdsSource(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)}]`;
@@ -1321,13 +1321,13 @@ function toHdbcdsSource(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 = `${formatIdentifier(s.id)}`;
         if (s.args) {
           // View parameters
-          result += `(${renderArgs(s.args, ':', env)})`;
+          result += `(${renderArgs(s, ':', env)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality
@@ -1344,19 +1344,21 @@ function toHdbcdsSource(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 Seperator between arguments
    * @param {CdlRenderEnvironment} env Environment
    * @returns {string} Rendered arguments
    */
-  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(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${formatIdentifier(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      // if this is a function param which is not a reference to the model, we must not quote it
+      return Object.keys(args).map(key => `${node.func ? key : formatIdentifier(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
 
 
     throw new Error(`Unknown args: ${JSON.stringify(args)}`);

package/lib/render/toSql.js

@@ -385,7 +385,7 @@ function toSqlDdl(csn, options) {
     function reducesTypeSize(def) {
       // HANA does not allow decreasing the value of any of those type parameters.
       return def.old.type === def.new.type &&
-          [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
+        [ 'length', 'precision', 'scale' ].some(param => def.new[param] < def.old[param]);
     }
     function getEltStr(defVariant, eltName) {
       return defVariant.target
@@ -525,12 +525,12 @@ function toSqlDdl(csn, options) {
           referentialConstraints[fileName] = renderReferentialConstraint(referentialConstraint, childEnv.indent, false, csn, options);
         });
       if (renderReferentialConstraintsAsHdbconstraint) {
-        Object.entries(referentialConstraints).forEach( ([ fileName, constraint ]) => {
+        Object.entries(referentialConstraints).forEach(([ fileName, constraint ]) => {
           resultObj.hdbconstraint[fileName] = constraint;
         });
       }
       else {
-        Object.values(referentialConstraints).forEach( (constraint) => {
+        Object.values(referentialConstraints).forEach((constraint) => {
           result += `,\n${constraint}`;
         });
       }
@@ -546,8 +546,7 @@ function toSqlDdl(csn, options) {
           = `UNIQUE INVERTED INDEX ${renderArtifactName(`${artifactName}_${cn}`)} ON ${tableName} (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
       }
       else {
-        result += `,\n${childEnv.indent}CONSTRAINT ${renderArtifactName(`${artifactName}_${cn}`)} UNIQUE (${
-          c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
+        result += `,\n${childEnv.indent}CONSTRAINT ${renderArtifactName(`${artifactName}_${cn}`)} UNIQUE (${c.map(cpath => quoteSqlId(cpath.ref[0])).join(', ')})`;
       }
     }
     result += `${env.indent}\n)`;
@@ -659,8 +658,7 @@ function toSqlDdl(csn, options) {
     if (duplicateChecker)
       duplicateChecker.addElement(quotedElementName, elm.$location, elementName);
 
-    let result = `${env.indent + quotedElementName} ${
-      renderTypeReference(artifactName, elementName, elm)
+    let result = `${env.indent + quotedElementName} ${renderTypeReference(artifactName, elementName, elm)
     }${renderNullability(elm, true)}`;
     if (elm.default)
       result += ` DEFAULT ${renderExpr(elm.default, env)}`;
@@ -956,7 +954,7 @@ function toSqlDdl(csn, options) {
     // An empty actual parameter list is rendered as `()`.
     const ref = csn.definitions[path.ref[0].id] || csn.definitions[path.ref[0]];
     if (ref && ref.params) {
-      result += `(${renderArgs(path.ref[0].args || {}, '=>', env, syntax)})`;
+      result += `(${renderArgs(path.ref[0] || {}, '=>', env, syntax)})`;
     }
     else if ([ 'udf' ].includes(syntax)) {
       // if syntax is user defined function, render empty argument list
@@ -978,21 +976,23 @@ function toSqlDdl(csn, options) {
    * Render function arguments or view parameters (positional if array, named if object/dict),
    * using 'sep' as separator for positional parameters
    *
-   * @param {Array|object} args Arguments to render
+   * @param {object} node with `args` to render
    * @param {string} sep Separator between args
    * @param {object} env Render environment
    * @param {string} syntax Some magic A2J paramter - for calcview parameter rendering
    * @returns {string} Rendered arguments
    * @throws Throws if args is not an array or object.
    */
-  function renderArgs(args, sep, env, syntax) {
+  function renderArgs(node, sep, env, syntax) {
+    const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
       return args.map(arg => renderExpr(arg, env)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      // if this is a function param which is not a reference to the model, we must not quote it
+      return Object.keys(args).map(key => `${node.func ? key : decorateParameter(key, syntax)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
 
 
     throw new Error(`Unknown args: ${JSON.stringify(args)}`);
@@ -1151,12 +1151,11 @@ function toSqlDdl(csn, options) {
     const childEnv = increaseIndent(env);
     result += `SELECT${select.distinct ? ' DISTINCT' : ''}`;
     // FIXME: We probably also need to consider `excluding` here ?
-    result += `\n${
-      (select.columns || [ '*' ])
-        .filter(col => !(select.mixin || Object.create(null))[firstPathStepId(col.ref)]) // No mixin columns
-        .map(col => renderViewColumn(col, childEnv))
-        .filter(s => s !== '')
-        .join(',\n')}\n`;
+    result += `\n${(select.columns || [ '*' ])
+      .filter(col => !(select.mixin || Object.create(null))[firstPathStepId(col.ref)]) // No mixin columns
+      .map(col => renderViewColumn(col, childEnv))
+      .filter(s => s !== '')
+      .join(',\n')}\n`;
     result += `${env.indent}FROM ${renderViewSource(artifactName, select.from, env)}`;
     if (select.where)
       result += `\n${env.indent}WHERE ${renderExpr(select.where, env, true, true)}`;
@@ -1412,23 +1411,23 @@ function toSqlDdl(csn, options) {
         case 'number':
         case 'boolean':
         case 'null':
-        // 17.42, NULL, TRUE
+          // 17.42, NULL, TRUE
           return String(x.val).toUpperCase();
         case 'x':
-        // x'f000'
+          // x'f000'
           return `${x.literal}'${x.val}'`;
         case 'date':
         case 'time':
         case 'timestamp':
           if (options.toSql.dialect === 'sqlite') {
-          // simple string literal '2017-11-02'
+            // simple string literal '2017-11-02'
             return `'${x.val}'`;
           }
           // date'2017-11-02'
           return `${x.literal}'${x.val}'`;
 
         case 'string':
-        // 'foo', with proper escaping
+          // 'foo', with proper escaping
           return `'${x.val.replace(/'/g, '\'\'')}'`;
         case 'object':
           if (x.val === null)
@@ -1593,13 +1592,13 @@ function toSqlDdl(csn, options) {
 
         // Not really a path step but an object-like function call
         if (s.func)
-          return `${s.func}(${renderArgs(s.args, '=>', env, null)})`;
+          return `${s.func}(${renderArgs(s, '=>', env, null)})`;
 
         // Path step, possibly with view parameters and/or filters
         let result = `${quoteSqlId(s.id)}`;
         if (s.args) {
           // View parameters
-          result += `(${renderArgs(s.args, '=>', env, null)})`;
+          result += `(${renderArgs(s, '=>', env, null)})`;
         }
         if (s.where) {
           // Filter, possibly with cardinality

package/lib/render/utils/common.js

@@ -33,7 +33,7 @@ const { implicitAs } = require('../../model/csnRefs');
 function renderFunc( funcName, node, dialect, renderArgs) {
   if (funcWithoutParen( node, dialect ))
     return funcName;
-  return `${funcName}(${renderArgs( node.args )})`;
+  return `${funcName}(${renderArgs( node )})`;
 }
 
 /**

package/lib/transform/db/expansion.js

@@ -552,7 +552,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
       for (const part of Object.keys(base)) {
         if (excluding.indexOf(part) === -1) {
           // The thing is shadowed - ignore names present because of .inline, as those "disappear"
-          if (names[part] && !subs[names[part]].inline) {
+          if (names[part] !== undefined && !subs[names[part]].inline) {
             replaced[part] = true;
             star.push(subs[names[part]]);
           }

package/lib/transform/db/flattening.js

@@ -103,7 +103,7 @@ function resolveTypeReferences(csn, options, resolved, pathDelimiter) {
 
       definitions[artifactName] = dummy;
     }
-  } ]);
+  } ], true, { skipDict: { actions: true } });
 }
 
 /**

package/lib/transform/db/transformExists.js

@@ -249,6 +249,15 @@ function handleExists(csn, options, error) {
         const {
           ref, head, tail,
         } = getFirstAssoc(current, exprPath.concat(i));
+
+        const lastAssoc = getLastAssoc(current, exprPath.concat(i));
+        // toE.toF.id -> we must not end on a non-assoc - this will also be caught downstream by
+        // '“EXISTS” can only be used with associations/compositions, found $(TYPE)'
+        // But the error might not be clear, since it could be because of our rewritten stuff. The later check
+        // checks for exists id -> our rewrite turns toE.toF.id into toE[exists toF[exists id]], leading to the same error
+        if (lastAssoc.tail.length > 0)
+          error(null, current.$path, { id: lastAssoc.tail[0].id ? lastAssoc.tail[0].id : lastAssoc.tail[0], name: lastAssoc.ref.id ? lastAssoc.ref.id : lastAssoc.ref }, 'Unexpected path step $(ID) after association $(NAME) in "EXISTS"');
+
         const newThing = [ ...head, nestFilters(head.length + 1, ref, tail, exprPath.concat([ i ])) ];
         expr[i].ref = newThing;
       }
@@ -278,15 +287,10 @@ function handleExists(csn, options, error) {
         const current = expr[i];
         const isPrefixedWithTableAlias = firstLinkIsEntityOrQuerySource(exprPath.concat(i));
         const base = getBase(queryBase, isPrefixedWithTableAlias, current, exprPath.concat(i));
-        const { root, ref, tail } = getFirstAssoc(current, exprPath.concat(i));
-
-        if (tail.length > 0) {
-          error(null, current.$path, { id: tail[0].id ? tail[0].id : tail[0], name: ref.id ? ref.id : ref }, 'Unexpected path step $(ID) after association $(NAME) in "EXISTS"');
-          continue;
-        }
+        const { root, ref } = getFirstAssoc(current, exprPath.concat(i));
 
         if (!root.target) {
-          error(null, current.$path, { type: root.type }, '“EXISTS” can only be used with associations/compositions, found $(TYPE)');
+          error(null, exprPath.concat(i), { type: root.type }, '“EXISTS” can only be used with associations/compositions, found $(TYPE)');
           return { result: [], leftovers: [] };
         }
 
@@ -477,6 +481,27 @@ function handleExists(csn, options, error) {
     };
   }
 
+  /**
+   * Get the last association from the expression part - similar to getFirstAssoc
+   *
+   * @param {object} xprPart
+   * @param {CSN.Path} path
+   * @returns {{head: Array, root: CSN.Element, ref: string|object, tail: Array}} The last assoc (root), the corresponding ref (ref), anything before the ref (head) and the rest of the ref (tail).
+   */
+  function getLastAssoc(xprPart, path) {
+    const { links, art } = inspectRef(path);
+    for (let i = xprPart.ref.length - 1; i > -1; i--) {
+      if (links[i].art && links[i].art.target) {
+        return {
+          head: (i === 0 ? [] : xprPart.ref.slice(0, i)), root: links[i].art, ref: xprPart.ref[i], tail: xprPart.ref.slice(i + 1),
+        };
+      }
+    }
+    return {
+      head: (xprPart.ref.length === 1 ? [] : xprPart.ref.slice(0, xprPart.ref.length - 1)), root: art, ref: xprPart.ref[xprPart.ref.length - 1], tail: [],
+    };
+  }
+
   /**
    * Check (using inspectRef -> links), wether the first path step is an entity or query source
    *

package/lib/transform/odata/structuralPath.js

@@ -10,7 +10,7 @@ const structuralNodeHandlers = {
   returns: traverseTyped,
   on: traverseArray,
   keys: traverseArray,
-  ref: traverseRef,
+  ref: traverseArray,
   query: traverseTyped,
   SELECT: traverseTyped,
   SET: traverseTyped,
@@ -33,10 +33,6 @@ function structuralPath(csn, path) {
   return traverseDict(csn.definitions, path, 1, ['definitions']);
 }
 
-function traverseRef(obj, path, index, typeStack) {
-  return traverseArray(obj, path, index, typeStack);
-}
-
 function traverseArray(obj, path, index, typeStack) {
   if(!Array.isArray(obj)) return typeStack;
   const name = path[index];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-compiler",
-  "version": "2.10.2",
+  "version": "2.10.4",
   "description": "CDS (Core Data Services) compiler and backends",
   "homepage": "https://cap.cloud.sap/",
   "author": "SAP SE (https://www.sap.com)",