@sap/cds-compiler 6.3.6 → 6.4.6

package/lib/transform/db/flattening.js

@@ -210,7 +210,7 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
       const { links, art, scope } = inspectRef(path);
       const resolvedLinkTypes = resolveLinkTypes(links);
       setProp(parent, '$path', [ ...path ]);
-      const lastRef = ref[ref.length - 1];
+      const lastRef = ref.at(-1);
       const fn = (suspend = false, suspendPos = 0,
                   refFilter = _parent => true) => {
         let refChanged = false;
@@ -226,13 +226,14 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
           // Explicitly set implicit alias for things that are now flattened - but only in columns
           // TODO: Can this be done elegantly during expand phase already?
           if (parent.$implicitAlias) { // an expanded s -> s.a is marked with this - do not add implicit alias "a" there, we want s_a
-            if (parent.ref[parent.ref.length - 1] === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
+            if (parent.ref.at(-1) === parent.as) // for a simple s that was expanded - for s.substructure this would not apply
               delete parent.as;
             delete parent.$implicitAlias;
           }
-          // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a
-          else if (parent.ref[parent.ref.length - 1] !== lastRef &&
-                      (insideColumns(scopedPath) || insideKeys(scopedPath)) &&
+          // To handle explicitly written s.a - add implicit alias a, since after flattening it would otherwise be s_a,
+          // also for 'from' clauses
+          else if (parent.ref.at(-1) !== lastRef &&
+                      (insideColumns(scopedPath) || insideKeys(scopedPath) || isFromRef(scopedPath)) &&
                       !parent.as) {
             parent.as = lastRef;
           }
@@ -276,6 +277,16 @@ function getStructStepsFlattener( csn, options, messageFunctions, resolved, path
     return path.length >= 3 && path[path.length - 2] === 'keys' && typeof path[path.length - 1] === 'number';
   }
 
+  /**
+   * Whether the given path points to a `from` clause.
+   *
+   * @param {CSN.Path} path
+   * @returns {boolean}
+   */
+  function isFromRef(path) {
+    return path.at(-1) === 'from';
+  }
+
   return transformer;
 }
 

package/lib/transform/db/rewriteCalculatedElements.js

@@ -9,7 +9,6 @@ const {
   implicitAs,
 } = require('../../model/csnUtils');
 const { getBranches } = require('./flattening');
-const { getColumnMap } = require('./views');
 const { cloneCsnNonDict } = require('../../model/cloneCsn');
 
 const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '$scope' ] };
@@ -23,11 +22,10 @@ const cloneCsnOptions = { hiddenPropertiesToClone: [ '_art', '_links', '$env', '
  * @param {CSN.Options} options
  * @param {object} csnUtils
  * @param {string} pathDelimiter
- * @param {object} messageFunctions
+ * @param {object} _messageFunctions
  */
-function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter, messageFunctions ) {
+function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter, _messageFunctions ) {
   const { inspectRef, effectiveType } = csnUtils;
-  const { error } = messageFunctions;
 
   const views = [];
   const entities = [];
@@ -119,9 +117,6 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
    * Rewrite calculated-elements-columns in views/projections and replace them
    * with their "root"-expression.
    *
-   * As a first step, we ensure that all views/projections have a .columns (see {@link calculateColumns}) and that
-   * all calculated elements are addressed explicitly and not via a * (see {@link makeAllCalculatedElementsExplicitColumns}).
-   *
    * Then, we check the `art` of each ref for a `.value` and rewrite accordingly.
    * We need to ensure that the scope of the rewritten expressions is still correct!
    * An `id` in the `.value` needs to point to the entity containing the element,
@@ -133,73 +128,64 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
    * @param {CSN.Path} path
    */
   function rewriteInView( SELECT, elements, path ) {
-    const containsExpandInline = hasExpandInline(SELECT);
-    let cleanupCallbacks;
-    if (!SELECT.columns) // needs to happen for all subqueries!
-      cleanupCallbacks = calculateColumns(elements, SELECT);
-    else
-      cleanupCallbacks = makeAllCalculatedElementsExplicitColumns(elements, SELECT, containsExpandInline);
-
-    const name = SELECT.from.args ? undefined : SELECT.from.as || (SELECT.from.ref && implicitAs(SELECT.from.ref));
-
-    if (!containsExpandInline) {
-      applyTransformationsOnNonDictionary({ SELECT }, 'SELECT', {
-        ref: (parent, prop, ref, p, root) => {
-          const {
-            art, env, links, scope,
-          } = getRefInfo(parent, p);
-
-          // calc element publishes association, treat as regular
-          // unmanaged association
-          const calcElementIsAssoc = art?.value && art.target;
-          // TODO: Calculated elements on-write
-          if (art?.value && !art.value.stored && !calcElementIsAssoc) {
-            const alias = parent.as || implicitAs(parent.ref);
-            // TODO: What about other scopes? expand/inline?
-            const value = (scope !== 'ref-target') ? absolutifyPaths(env, art, ref, links, name).value : keepAssocStepsInRef(ref, links, art).value;
-
-            // Is a shallow copy enough?
-            if (art.value.cast)
-              root[p[p.length - 1]] = { xpr: [ value ] };
-            else
-              root[p[p.length - 1]] = { ...value };
+    expandStructSelectItems(SELECT);
+
+    const name = SELECT.from.args
+      ? undefined
+      : SELECT.from.as || (SELECT.from.ref && implicitAs(SELECT.from.ref));
+
+    applyTransformationsOnNonDictionary({ SELECT }, 'SELECT', {
+      ref: transformRef,
+    }, {}, path);
+
+    /**
+     * @param {object} parent
+     * @param {string} prop
+     * @param ref
+     * @param p
+     * @param root
+     */
+    function transformRef(parent, prop, ref, p, root) {
+      const {
+        art, env, links, scope,
+      } = getRefInfo(parent, p);
+
+      // calc element publishes association, treat as regular unmanaged association
+      const calcElementIsAssoc = art?.value && art.target;
+
+      if (!art?.value || art.value.stored || calcElementIsAssoc)
+        return;
+
+      if (scope === 'inline' || scope === 'expand') {
+        // Calculated elements in expand/inline are not supported, yet.
+        // Error is reported in expansion.js
+        return;
+      }
 
-            if (p[p.length - 2] === 'columns')
-              root[p[p.length - 1]].as = alias;
-            else
-              delete root[p[p.length - 1]].as;
+      const alias = parent.as || implicitAs(parent.ref);
 
-            // If the calculated element has a type, use it. But only if the column did not have an explicit type.
-            // Note: We should not check `art.type`, because we only need the type for columns, not filters.
-            if (parent.cast)
-              root[p[p.length - 1]].cast = parent.cast;
-            else if (parent._element?.type)
-              root[p[p.length - 1]].cast = { type: parent._element.type };
+      // TODO: What about other scopes? expand/inline may become relevant again if we allow calc elements in them.
+      const value = (scope !== 'ref-target')
+        ? absolutifyPaths(env, art, ref, links, name).value
+        : keepAssocStepsInRef(ref, links, art).value;
 
-            // TODO: Copy annotations? May become relevant in the future
-          }
-        },
-      }, {}, path);
-    }
+      // TODO: Is a shallow copy enough?
+      root[p.at(-1)] = art.value.cast ? { xpr: [ value ] } : { ...value };
 
-    cleanupCallbacks.forEach(fn => fn());
-  }
+      if (p.at(-2) === 'columns' || p.at(-2) === 'expand')
+        root[p.at(-1)].as = alias;
+      else
+        delete root[p.at(-1)].as;
 
-  /**
-   *
-   * @param {CSN.QuerySelect} SELECT
-   * @returns {boolean}
-   */
-  function hasExpandInline( SELECT ) {
-    if (!SELECT.columns)
-      return false;
+      // If the calculated element has a type, use it. But only if the column did not have an explicit type.
+      // Note: We should not check `art.type`, because we only need the type for columns, not filters.
+      if (parent.cast)
+        root[p.at(-1)].cast = parent.cast;
+      else if (parent._element?.type)
+        root[p.at(-1)].cast = { type: parent._element.type };
 
-    for (const column of SELECT.columns) {
-      if (column.expand || column.inline)
-        return true;
+      // TODO: Copy annotations? May become relevant in the future
     }
-
-    return false;
   }
 
   /**
@@ -329,228 +315,38 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
   }
 
   /**
-   * For a `view V as select from E;` or a `entity P as projection on E;` calculate and
-   * attach the .columns if they contain a calculated element so we can rewrite them in
-   * the later steps.
-   *
-   * @param {CSN.Elements} elements Artifact elements
-   * @param {object} carrier The thing that will "carry" the columns - .SELECT or .projection
-   * @returns {Function[]} Cleanup callbacks that remove `_`-links.
-   */
-  function calculateColumns( elements, carrier ) {
-    carrier.columns = [ '*' ];
-    const cleanupCallbacks = makeAllCalculatedElementsExplicitColumns(elements, carrier, false);
-    if (carrier.columns.length === 1 && carrier.columns[0] === '*')
-      delete carrier.columns;
-    return cleanupCallbacks;
-  }
-
-  /**
-   *
-   * @param {CSN.QuerySelect} SELECT
-   * @returns {object}
-   */
-  function getDirectlyAddressableElements( SELECT ) {
-    const { from } = SELECT;
-    if (from.ref) {
-      return from._art.elements;
-    }
-    else if (from.SELECT) {
-      return from.SELECT.elements;
-    }
-    else if (from.SET) {
-      // args[0] could be SELECT or UNION
-      return getDirectlyAddressableElements({ from: from.SET.args[0] });
-    }
-    else if (from.args) {
-      const mergedElements = Object.create(null);
-      for (const arg of from.args) {
-        if (arg.ref) {
-          for (const elementName in arg._art.elements)
-            mergedElements[elementName] = arg._art.elements[elementName];
-        }
-        else if (arg.SET) {
-          return getDirectlyAddressableElements({ from: arg.SET.args[0] });
-        }
-        else if (arg.SELECT) { // TODO: UNION
-          for (const elementName in arg.SELECT.elements)
-            mergedElements[elementName] = arg.SELECT.elements[elementName];
-        }
-        else if (arg.args) { // TODO: Is it safe to do recursion here?
-          for (const subarg of arg.args) {
-            const elements = getDirectlyAddressableElements({ from: subarg });
-            for (const elementName in elements)
-              mergedElements[elementName] = elements[elementName];
-          }
-        }
-        else {
-          throw new CompilerAssertion(`Unhandled arg type: ${ JSON.stringify(arg, null, 2) }`);
-        }
-      }
-      return mergedElements;
-    }
-    throw new CompilerAssertion(`Unhandled query type:  ${ JSON.stringify(SELECT, null, 2) }`);
-  }
-
-  /**
-   * Ensure that all elements of the query that are calculated elements have an explicit column that we can rewrite.
-   * If a field originally comes in via the *, then we need to add an explicit column for it.
+   * Expands all references to structures to its separate leaf elements, adding columns if needed.
    *
-   * @param {CSN.Elements} elements
-   * @param {CSN.QuerySelect} SELECT
-   * @param {boolean} containsExpandInline
-   * @returns {Function[]} Cleanup callbacks that remove `_`-links.
+   * @param {object} SELECT
    */
-  function makeAllCalculatedElementsExplicitColumns( elements, SELECT, containsExpandInline ) {
-    const cleanupCallbacks = [];
-    const root = getDirectlyAddressableElements(SELECT);
-    const columnMap = getColumnMap( { SELECT }, csnUtils );
-    const hasStar = SELECT.columns.includes('*');
-    const unfoldingMap = {};
-    let starContainsCalculated = false;
-    let containsCalcOnRead = false;
-    for (const name in elements) {
-      const originalRef = columnMap[name] && columnMap[name].ref || [ name ];
-
-      if (columnMap[name] || hasStar) {
-        let element;
-        if (columnMap[name]?.expand || columnMap[name]?.inline)
-          element = elements[name]; // only the direct thing in .elements has the .excluding respected properly!
-        else
-          element = columnMap[name]?._art || columnMap[name]?._element || root[name] || elements[name];
-        const branches = getBranches(element, name, effectiveType, pathDelimiter); // TODO: is our elements[name] really the root[name]?
-        if (hasCalcOnReadLeaf(branches)) {
-          containsCalcOnRead = true;
-          const columns = [];
-          for (const branchName in branches) {
-            const branch = branches[branchName];
-            const leafElement = branch.steps[branch.steps.length - 1];
-            if (columnMap[branchName]) { // Existing column - don't overwrite, we need $env!
-              columns.push(columnMap[branchName]);
-            }
-            else {
-              // TODO: Hm, will we have a $env in the leaf of the thing then?
-              const column = { ref: [ ...originalRef, ...branches[branchName].ref.slice(1) ], as: branchName };
-              setProp(column, '_element', leafElement);
-              cleanupCallbacks.push(() => delete column._element);
-              columns.push(column);
-            }
-          }
-          if (columnMap[name]) {
-            unfoldingMap[name] = [ false, [ ...columns ] ];
-          }
-          else if (hasStar) { // Via * - just append
-            starContainsCalculated = true;
-            unfoldingMap[name] = [ true, [ ...columns ] ];
-          }
-        }
-        else {
-          if (usesCalcOnRead(branches))
-            containsCalcOnRead = true;
-          if (!columnMap[name] && hasStar) { // Via * - just append
-            unfoldingMap[name] = [ true, [ { ref: [ name ] } ] ];
-          }
-          else { // just a random column - keep
-            unfoldingMap[name] = [ false, [ columnMap[name] ] ];
-          }
+  function expandStructSelectItems(SELECT) {
+    for (let i = 0; i < SELECT.columns?.length; i++) {
+      const column = SELECT.columns[i];
+      if (column.expand)
+        continue; // skip expand
+
+      if (column.ref && column._element) {
+        const columnName = column.as || implicitAs(column.ref);
+        const branches = getBranches(column._element, columnName, effectiveType, pathDelimiter);
+        const paths = Object.keys(branches);
+        if (paths.length > 1 || paths[0] !== columnName) {
+          SELECT.columns[i] = Object.entries(branches).map(([ name, branch ]) => {
+            const elem = branch.steps.at(-1);
+            // TODO: Table alias somehow?
+            const ref = [ ...column.ref, ...branch.ref.slice(1) ];
+            const newColumn = { ref, as: name };
+
+            // If the calculated element has a type, use it.
+            if (elem['@Core.Computed'] && elem.type) // very crude - we could walk the branches to see if we are dealing with a real calc element?
+              newColumn.cast = { type: elem.type };
+
+            return newColumn;
+          });
         }
       }
     }
 
-    if (containsExpandInline && containsCalcOnRead) {
-      error('query-unsupported-calc', SELECT.$path, { '#': 'std' });
-    }
-    else if (containsCalcOnRead) {
-      const newColumns = [];
-      if (hasStar && !starContainsCalculated)
-        newColumns.push('*');
-      for (const name in elements) {
-        const [ isViaStar, columns ] = unfoldingMap[name];
-        if (isViaStar && starContainsCalculated || !isViaStar)
-          newColumns.push(...columns);
-      }
-
-      SELECT.columns = newColumns;
-    }
-    return cleanupCallbacks;
-  }
-
-  /**
-   * Returns true if any leaf node is a calculated element on-read.
-   * On-write behaves like regular elements, hence they do not count here.
-   *
-   * @param {object} branches
-   * @returns {boolean}
-   */
-  function hasCalcOnReadLeaf( branches ) {
-    for (const branchName in branches) {
-      const branch = branches[branchName].steps;
-      const leaf = branch[branch.length - 1];
-      if (hasOnReadValue(leaf))
-        return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Returns true if the branch/column uses a calc-on-read,
-   * for example in a filter.
-   *
-   * TODO: Enable calculated elements next to nested projections
-   *
-   * @param {object} branches
-   * @returns {boolean}
-   */
-  function usesCalcOnRead( branches ) {
-    let returnValue = false;
-    for (const branchName in branches) {
-      const column = branches[branchName]?.steps[0]?._column;
-      if (column) {
-        applyTransformationsOnNonDictionary({ column }, 'column', {
-          // eslint-disable-next-line no-loop-func
-          ref: (parent) => {
-            if (hasOnReadValue(parent))
-              returnValue = true;
-          },
-        }, {
-          drillRef: true,
-          // skip subqueries and nested projections
-          // calculated elements and nested projections
-          // only conflict on same level
-          skipStandard: [ 'SELECT', 'expand', 'inline' ],
-        });
-      }
-    }
-
-    return returnValue;
-  }
-
-  /**
-   * A leaf can reference a column which in turn references a real element - that might have a .value.
-   * Find such cases.
-   *
-   * @param {object} baseLeaf Leaf to start at
-   * @returns {boolean}
-   */
-  function hasOnReadValue( baseLeaf ) {
-    const visited = new WeakSet();
-    const stack = [ baseLeaf ];
-    while (stack.length > 0) {
-      const leaf = stack.pop();
-      if (!visited.has(leaf)) { // Don't re-process things
-        if (leaf.value && !leaf.value.stored)
-          return true;
-        else if (leaf._art)
-          stack.push(leaf._art);
-        else if (leaf['@Core.Computed'] && leaf._column && leaf._column !== baseLeaf)
-          stack.push(leaf._column);
-      }
-
-      visited.add(leaf);
-    }
-
-    return false;
+    SELECT.columns = SELECT.columns.flat(Infinity);
   }
 
   /**

package/lib/transform/effective/main.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  getUtils, mergeTransformers, applyTransformations,
+  getUtils, mergeTransformers, applyTransformations, forEachDefinition,
 } = require('../../model/csnUtils');
 const transformUtils = require('../transformUtils');
 const effectiveFlattening = require('./flattening');
@@ -19,6 +19,8 @@ const { rewriteCalculatedElementsInViews, processCalculatedElementsInEntities }
 const { cloneFullCsn } = require('../../model/cloneCsn');
 const { featureFlags } = require('../featureFlags');
 const getServiceFilterFunction = require('./service');
+const { traverseQuery } = require('../../model/csnRefs');
+const { expandWildcard } = require('../db/expansion');
 
 /**
  * This is just a PoC for now!
@@ -46,6 +48,11 @@ function effectiveCsn( model, options, messageFunctions ) {
   let { csnUtils } = transformerUtils;
   csnUtils.initAllDefinitions();
 
+  forEachDefinition(csn, (def) => {
+    if (def.query || def.projection)
+      traverseQuery(def.query || def, null, null, query => expandWildcard(query, csnUtils, options));
+  });
+
   // Run validations on CSN - each validator function has access to the message functions and the inspect ref via this
   const cleanup = validate.forRelationalDB(csn, {
     ...messageFunctions, csnUtils, ...csnUtils, csn, options,

package/lib/transform/forOdata.js

@@ -210,7 +210,7 @@ function transform4odataWithCsn(inputModel, options, messageFunctions) {
 
   // needs to be performed after creating foreign keys for the entire model,
   // because of multiple managed associations in refs
-  replaceForeignKeyRefsInExpressionAnnotations(csn, options, messageFunctions, csnUtils, { skipArtifact: isExternalServiceMember });
+  replaceForeignKeyRefsInExpressionAnnotations(csn, csnUtils, { skipArtifact: isExternalServiceMember });
 
   bindCsnReferenceOnly();