@sap/cds-compiler 6.3.4 → 6.4.2

package/lib/model/csnUtils.js

@@ -87,6 +87,8 @@ function getUtils( model, universalReady ) {
    * - merge all queries in case of joins
    * - follow subqueries
    *
+   * NOTE: Use `csnRefs.queryForElements()` instead! See e.g. expandWildcard()
+   *
    * @param {CSN.Query} query Query to check
    * @param {boolean} [isSubquery]
    * @returns {object} Map of sources
@@ -176,12 +178,13 @@ function getUtils( model, universalReady ) {
    */
   function mergeElementsIntoMap( existingMap, elements, $location, parent, errorParent ) {
     for (const elementName in elements) {
-      const element = elements[elementName];
-      if (!existingMap[elementName])
-        existingMap[elementName] = [];
-
+      existingMap[elementName] ??= [];
       existingMap[elementName].push({
-        element, name: elementName, source: $location, parent, errorParent,
+        element: elements[elementName],
+        name: elementName,
+        source: $location,
+        parent,
+        errorParent,
       });
     }
 
@@ -668,8 +671,7 @@ function forAllQueries( query, queryCallback, path ) {
     const expr = query[prop];
     if (expr && typeof expr === 'object') {
       if (Array.isArray(expr)) {
-        for (let i = 0; i < expr.length; i++)
-          forAllQueries(expr[i], queryCallback, [ ...path, prop, i ]);
+        traverseStructurizedExpression(expr, [ ...path, prop ]);
       }
       else {
         for (const argName of Object.keys( expr ))
@@ -677,6 +679,23 @@ function forAllQueries( query, queryCallback, path ) {
       }
     }
   }
+
+  /**
+   * Traverse the possibly structured xpr. A structured expression may contain arrays inside arrays
+   * to show precedence of operators.
+   *
+   * @param {any} xpr
+   * @param {CSN.Path} csnPath
+   */
+  function traverseStructurizedExpression( xpr, csnPath ) {
+    if (Array.isArray(xpr)) {
+      for (let i = 0; i < xpr.length; i++)
+        traverseStructurizedExpression(xpr[i], [ ...csnPath, i ]);
+    }
+    else {
+      forAllQueries(xpr, queryCallback, csnPath);
+    }
+  }
 }
 
 /**

package/lib/model/enrichCsn.js

@@ -61,6 +61,7 @@ function enrichCsn( csn, options = {} ) {
     target: simpleRef,
     includes: simpleRef,
     $origin,
+    $calc: standard,
     // TODO: excluding
     '@': assignment,
     $: () => { /* ignore properties like $location for performance */ },

package/lib/parsers/AstBuildingParser.js

@@ -8,6 +8,13 @@ const { functionsWithoutParentheses } = require('./identifiers');
 
 const { pathName } = require('../compiler/utils');
 const { quotedLiteralPatterns, specialFunctions } = require('../compiler/builtins');
+
+const { parseMultiLineStringLiteral } = require('../language/multiLineStringParser');
+const { normalizeNewLine, normalizeNumberString } = require('../language/textUtils');
+const { parseDocComment } = require('../language/docCommentParser');
+
+const $location = Symbol.for('cds.$location');
+
 const parserTokens = { // TODO: precompile into specialFunction
   __proto__: null,
   GenericIntro: 'intro',
@@ -15,11 +22,23 @@ const parserTokens = { // TODO: precompile into specialFunction
   GenericSeparator: 'separator',
 };
 
-const { parseMultiLineStringLiteral } = require('../language/multiLineStringParser');
-const { normalizeNewLine, normalizeNumberString } = require('../language/textUtils');
-const { parseDocComment } = require('../language/docCommentParser');
-
-const $location = Symbol.for('cds.$location');
+// if the expectedArray contains all the following tokens, we replace them by `Value`
+const valueTokens = {
+  Id: true,
+  Number: true,
+  QuotedLiteral: true,
+  String: true,
+  ':': true,
+  '#': true,
+  '+': true,
+  '-': true,
+  cast: true,                   // is special function
+  false: true,
+  new: true,                    // is too seldomly really useful
+  null: true,
+  true: true,
+};
+const valueTokensLength = Object.values( valueTokens ).length;
 
 const extensionDicts = {
   elements: true, enum: true, params: true, returns: true,
@@ -82,30 +101,38 @@ class AstBuildingParser extends BaseParser {
     return this.$messageFunctions.info( id, location?.location || location, args, text );
   }
 
-  expectingArray() {
+  expectingArray( raw = false ) {
     const savedState = this.s;
     this.s = this.errorState;
     let array = this.expectingArray_();
     this.s = savedState;
-    // compatibility: replace true+false by Boolean - TODO: delete
-    if (array.includes( 'true' ))
-      array = [ 'Boolean', ...array.filter( n => n !== 'true' && n !== 'false' ) ];
+    // Avoid clutter in messages: replace all value tokens by ‹Value› if all are there:
+    const reduced = raw ? array : array.filter( tok => valueTokens[tok] !== true );
+    if (reduced.length + valueTokensLength === array.length)
+      array = [ 'Value', ...reduced ];
     return array.map( tok => this.antlrName( tok ) )
       .sort( (a, b) => (tokenPrecedence(a) < tokenPrecedence(b) ? -1 : 1) );
   }
 
-  reportUnexpectedToken_() {
-    const token = this.la();
-    const args = { offending: this.antlrName( token ), expecting: this.expectingArray() };
+  reportUnexpectedToken_( msgKind ) {
+    const token = (msgKind === 'reuse') ? this.lb() : this.la();
+    const args = {
+      offending: this.antlrName( token ),
+      expecting: (msgKind === 'reuse' ? undefined : this.expectingArray()),
+    };
     const errorMethod = this.conditionTokenIdx === this.tokenIdx &&
           this[`${ this.conditionName }Error`];
     let err = errorMethod && errorMethod.call( this, args, token );
     // TODO: should we set the msg variant always?  (→ no nestedExpandError necessary)
     if (errorMethod && !err)
       args['#'] ??= this.conditionName;
+    if (!errorMethod && msgKind === 'reuse') {
+      err = this.error( 'syntax-missing-input', token, { keyword: token.keyword },
+                        'Missing input before keyword $(KEYWORD)' );
+    }
     err ||= this.error( 'syntax-unexpected-token', token, args );
     // No 'unwanted' variant, no 'syntax-missing-token'
-    err.expectedTokens = args.expecting;
+    err.expectedTokens = this.expectingArray( true );
   }
 
   reportReservedWord_() {
@@ -224,29 +251,39 @@ class AstBuildingParser extends BaseParser {
   }
 
   inSelectItem( arg ) {         // <prepare=…>
-    this.dynamic_.inSelectItem = arg ||
-      (this.tokens[this.tokenIdx - 2].type === '.' ? 'inline' : 'expand');
+    if (!Object.hasOwn(this.dynamic_, 'inSelectItem')) {
+      // This copies the entries from the lower prototype into the current dynamic_ object.
+      this.dynamic_.inSelectItem ??= [];
+      this.dynamic_.inSelectItem = [ ...this.dynamic_.inSelectItem ];
+    }
+    this.dynamic_.inSelectItem.push(arg ||
+      (this.tokens[this.tokenIdx - 2].type === '.' ? 'inline' : 'expand'));
   }
 
   /**
-   * `virtual` and `key` cannot be used inside expand/inline
+   * `virtual` cannot be used inside expand/inline.
+   * `key` can only be used in inlines, but not expands.
    * (also inside sub queries in those, which will be rejected later anyway)
    */
   modifierRestriction() {
-    const { inSelectItem } = this.dynamic_;
-    // TODO: really reject for top-level "inline"?
-    return inSelectItem === 'expand' || inSelectItem === 'inline';
+    const top = this.dynamic_.inSelectItem?.at(-1);
+    const insideExpand = this.dynamic_.inSelectItem?.includes('expand');
+    const next = this.tokens[this.tokenIdx]?.keyword;
+    return insideExpand || (next !== 'key' && top === 'inline');
   }
   modifierRestrictionError( args, offending ) {
-    return this.error( 'syntax-unexpected-modifier', offending, args,
-                       // TODO: we would have text variant for expand or inline,
-                       // but we probably allow `key` in nested top-level inline
-                       'Unexpected $(OFFENDING) in nested expand/inline, expecting $(EXPECTING)' );
+    return this.error( 'syntax-unexpected-modifier', offending, {
+      '#': offending.keyword || 'std', ...args,
+    }, {
+      // TODO: we would have text variant for expand or inline
+      std: 'Unexpected $(OFFENDING) in nested expand/inline, expecting $(EXPECTING)',
+      key: 'Unexpected $(OFFENDING) in nested expand, expecting $(EXPECTING)',
+    } );
   }
 
   isDotForPath() {              // see also inSelectItem
     // TODO: also consider whether we are in the <prefer>ed `valuePath` branch
-    if (this.dynamic_.inSelectItem == null)
+    if (this.dynamic_.inSelectItem == null || this.dynamic_.inSelectItem.length === 0)
       return false;
     // TODO: it would be best to set this.dynamic_.inSelectItem to null in filters
     // (as <prepare>)
@@ -643,9 +680,15 @@ class AstBuildingParser extends BaseParser {
     if (!art)
       return art;
     art.location ??= this.startLocation();
-    if (this.s == null)         // do not set end location if error
-      return art;
-    const { location } = this.lb();
+    let last = this.lb();
+    if (this.s == null) {
+      let { tokenIdx } = this;
+      if (tokenIdx === this.stack.at(-1).tokenIdx)
+        return art;
+      while (!last.parsedAs)
+        last = this.tokens[--tokenIdx];
+    }
+    const { location } = last;
     art.location.endLine = location.endLine;
     art.location.endCol = location.endCol;
     return art;
@@ -1526,6 +1569,8 @@ class AstBuildingParser extends BaseParser {
 }
 
 AstBuildingParser.prototype.queryOnLeftSloppyAlias.afterError = true;
+AstBuildingParser.prototype.isNamedArg.afterError = true;
+// TODO: can we somehow _add_ '=>' and ':' to expected set if next token fails ?
 
 function addOneForDefinition( count, ext ) {
   return (ext.kind === 'extend') ? count : count + 1;

package/lib/render/toCdl.js

@@ -2255,9 +2255,10 @@ class CsnToCdl {
       filter = `${ where } ${ filter }`;
     }
 
+    const hasFilter = filter.length > 0; // filter may be empty after trimming
     filter = filter.trim();
 
-    if (cardinality || filter) {
+    if (cardinality || hasFilter) {
       if (filter.endsWith(']')) // for cases such as [… ![id] ]
         result += `[ ${ cardinality }${ filter } ]`;
       else

package/lib/render/toHdbcds.js

@@ -4,7 +4,7 @@ const {
   getLastPartOf, getLastPartOfRef,
   hasValidSkipOrExists, getNormalizedQuery,
   getRootArtifactName, getResultingName, getNamespace, forEachMember, getVariableReplacement,
-  pathName, hasPersistenceSkipAnnotation,
+  pathName, hasPersistenceSkipAnnotation, implicitAs,
 } = require('../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../base/builtins');
 const keywords = require('../base/keywords');
@@ -735,7 +735,7 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
    * @returns {string} Rendered column
    */
   function renderViewColumn( col, elements, env ) {
-    const leaf = col.as || col.ref && col.ref[col.ref.length - 1] || col.func;
+    const leaf = col.as || col.ref?.[col.ref.length - 1] || col.func;
     const element = elements[leaf];
 
     // Render 'null as <alias>' only for database and if element is virtual
@@ -746,7 +746,6 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
     }
     return renderNonVirtualColumn();
 
-
     function renderNonVirtualColumn() {
       let result = env.indent;
       // only if column is virtual, keyword virtual was present in the source text
@@ -756,6 +755,10 @@ function toHdbcdsSource( csn, options, messageFunctions ) {
       if (col.key && env.skipKeys)
         error(null, env.path, { keyword: 'key', $reviewed: true }, 'Unexpected $(KEYWORD) in subquery');
 
+      // Since magic variables are replaced, we may need to create an alias if there isn't one.
+      if (!col.as && col.ref?.[0] && isMagicVariable(pathId(col.ref?.[0])))
+        col.as = implicitAs(col.ref);
+
       const key = (!env.skipKeys && (col.key || element?.key) ? 'key ' : '');
       result += key + renderExpr(withoutCast(col), env);
       let alias = col.as || (!col.args && col.func); // func: e.g. CURRENT_TIMESTAMP

package/lib/render/toSql.js

@@ -6,6 +6,7 @@ const {
   hasValidSkipOrExists, getNormalizedQuery,
   forEachDefinition, getResultingName,
   getVariableReplacement, pathName,
+  implicitAs,
 } = require('../model/csnUtils');
 const { isBuiltinType, isMagicVariable } = require('../base/builtins');
 const { forEach, forEachValue, forEachKey } = require('../utils/objectUtils');
@@ -1178,6 +1179,10 @@ function toSqlDdl( csn, options, messageFunctions ) {
         result += `${ env.indent }NULL AS ${ quoteSqlId(col.as || leaf) }`;
     }
     else {
+      // Since magic variables are replaced, we may need to create an alias if there isn't one.
+      if (!col.as && col.ref?.[0] && isMagicVariable(pathId(col.ref?.[0])))
+        col.as = implicitAs(col.ref);
+
       result = env.indent + renderExpr(withoutCast(col), env);
       if (col.as)
         result += ` AS ${ quoteSqlId(col.as) }`;

package/lib/transform/db/applyTransformations.js

@@ -30,7 +30,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
   if (!options.skipStandard)
     options.skipStandard = { $tableConstraints: true };
   else if (options.skipStandard.$tableConstraints === undefined)
-    options.skipStandard = { ...options.skipStandard, ...{ $tableConstraints: true } };
+    options.skipStandard = { ...options.skipStandard, $tableConstraints: true };
 
   const transformers = {
     elements: dictionary,

package/lib/transform/db/assertUnique.js

@@ -67,7 +67,10 @@ function processAssertUnique( csn, options, messageFunctions ) {
         pathObjects = pathObjects.filter(p => p._art);
         // 7) Flatten correct paths, check and clean again
         let flattenedPathObjects = [];
-        pathObjects.forEach(p => flattenedPathObjects.push(...flattenPath(p, true)));
+        pathObjects.forEach(p => flattenedPathObjects.push(...flattenPath(p, true).map((f) => {
+          delete f.comparisonRef;
+          return f;
+        })));
         flattenedPathObjects.forEach(p => check(p, propName));
         flattenedPathObjects = flattenedPathObjects.filter(p => p._art);
         // 8) Duplicate path check on final flattened paths to detect structural overlaps

package/lib/transform/db/cdsPersistence.js

@@ -6,7 +6,7 @@ const {
   isPersistedOnDatabase,
   hasPersistenceSkipAnnotation,
 } = require('../../model/csnUtils');
-const transformUtils = require('../transformUtils');
+const { recurseElements } = require('../transformUtils');
 
 /**
  * Return a callback function for forEachDefinition that marks artifacts that are abstract or @cds.persistence.exists/skip
@@ -105,9 +105,6 @@ function getAssocToSkippedIgnorer( csn, options, messageFunctions, csnUtils ) {
  */
 function getPersistenceTableProcessor( csn, options, messageFunctions ) {
   const { error } = messageFunctions;
-  const {
-    recurseElements,
-  } = transformUtils.getTransformers(csn, options, messageFunctions, '_');
 
   return handleQueryish;
 
@@ -117,20 +114,22 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
    * @param {string} artifactName
    */
   function handleQueryish( artifact, artifactName ) {
-    const stripQueryish = artifact.query && artifact['@cds.persistence.table'];
-
-    if (stripQueryish) {
-      artifact.kind = 'entity';
-      delete artifact.query;
-
-      recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
-        // All elements must have a type for this to work
-        if (!member.$ignore && !member.kind && !member.type && !member.elements) { // .items? Probably resolved at this point
-          error(null, path, { anno: '@cds.persistence.table' },
-                'Expecting element to have a type if view is annotated with $(ANNO)');
-        }
-      });
-    }
+    const stripQueryish = (artifact.query || artifact.projection) && artifact['@cds.persistence.table'];
+
+    if (!stripQueryish)
+      return;
+
+    artifact.kind = 'entity';
+    delete artifact.query;
+    delete artifact.projection;
+
+    recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
+      // All elements must have a type for this to work
+      if (!member.$ignore && !member.kind && !member.type && !member.elements) { // .items? Probably resolved at this point
+        error(null, path, { anno: '@cds.persistence.table' },
+              'Expecting element to have a type if view is annotated with $(ANNO)');
+      }
+    });
   }
 }
 

package/lib/transform/db/expansion.js

@@ -5,12 +5,14 @@ const {
   setDependencies,
   walkCsnPath,
   getUtils,
+  forEachDefinition,
 } = require('../../model/csnUtils');
 const { implicitAs, columnAlias, pathId } = require('../../model/csnRefs');
 const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 const { killNonrequiredAnno } = require('./killAnnotations');
 const { featureFlags } = require('../featureFlags');
+const { applyTransformationsOnNonDictionary } = require('./applyTransformations');
 
 /**
  * For keys, columns, groupBy and orderBy, expand structured things.
@@ -28,6 +30,8 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
 
   if (options.transformation === 'odata' || csn.meta?.[featureFlags]?.$expandInline)
     rewriteExpandInline();
+  if (options.transformation === 'odata' || csn.meta?.[featureFlags]?.$calculatedElements)
+    rewriteRefsInCalcSubElements();
 
   throwWithAnyError();
 
@@ -66,6 +70,59 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
 
   applyTransformations(csn, transformers, [], iterateOptions);
 
+  /**
+   * Rewrite references in calculated elements that are in sub-elements.
+   * We do so, do absolutify any references.
+   *
+   * TODO: This should not be necessary if `value` of calculated elements were to be
+   *        rewritten during flattening, i.e. if we would keep track of parent elements
+   *        and prepend the parent-hierarchy to all references in the calc element.
+   */
+  function rewriteRefsInCalcSubElements() {
+    forEachDefinition(csn, (def, _defName) => {
+      if (def.kind === 'entity' && !def.query && !def.projection)
+        rewriteInElements(def.elements, []);
+    });
+
+    /**
+     * Rewrite the paths in calc elements.
+     * @param {object} elements
+     * @param {string[]} parents
+     */
+    function rewriteInElements(elements, parents ) {
+      for (const elemName in elements) {
+        const element = elements[elemName];
+        if (element.elements)
+          rewriteInElements(element.elements, parents.concat(elemName));
+        else
+          rewriteInElement(elemName, elements[elemName], parents);
+      }
+    }
+
+    /**
+     *
+     * @param {string} elemName
+     * @param {object} element
+     * @param {string[]} parents
+     */
+    function rewriteInElement(elemName, element, parents) {
+      if (!element.value)
+        return;
+      if (parents.length === 0)
+        return; // don't rewrite in top-level elements
+
+      applyTransformationsOnNonDictionary(element, 'value', {
+        ref: (path, _name) => {
+          if (path.$scope === 'parent') {
+            path.ref.unshift('$self', ...parents);
+            setProp(path, '$scope', '$self');
+            delete path._links;
+          }
+        },
+      });
+    }
+  }
+
   /**
    * Turn .expand/.inline into normal refs. @cds.persistence.skip .expand with to-many (and all transitive views).
    * For such skipped things, error for usage of assoc pointing to them and ignore publishing of assoc pointing to them.
@@ -90,8 +147,8 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         });
         const rewritten = rewrite(root, parent.columns, parent.excluding);
         /*
-          * Do not remove unexpandable many columns in OData
-        */
+         * Do not remove unexpandable many columns in OData
+         */
         if (rewritten.toMany.length > 0 && !options.toOdata) {
           markAsToDummify(artifact, path[1]);
           rewritten.toMany.forEach(({ art }) => {
@@ -719,7 +776,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
    * @param {object} base The raw set of things a * can expand to
    * @param {Array} subs Things - the .expand/.inline or .columns
    * @param {string[]} [excluding=[]]
-   * @param {boolean} [isComplexQuery=false] Wether the query is a single source select or something more complex
+   * @param {boolean} [isComplexQuery=false] Whether the query is a single source select or something more complex
    * @returns {Array} If there was a star, expand it and handle shadowing/excluding, else just return subs
    */
   function replaceStar( base, subs, excluding = [], isComplexQuery = false ) {
@@ -777,6 +834,125 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
   }
 }
 
+
+/**
+ * Expands the asterisks '*' a.k.a. wildcard in a query.
+ * Does not expand it inside expands/inline, though.
+ *
+ * @param {object} query
+ * @param {object} csnUtils
+ * @param {object} options
+ */
+function expandWildcard( query, csnUtils, options ) {
+  if (!query.SELECT && !query.projection)
+    return; // e.g. query source node inside `from`
+
+  const SELECT = query.SELECT ?? query.projection;
+  SELECT.columns ??= [ '*' ]; // no columns -> implicit wildcard
+
+  const wildcardIndex = SELECT.columns.indexOf('*');
+  if (wildcardIndex === -1)
+    return;
+
+  const allElements = wildcardElements(query, csnUtils);
+  const columns = Object.keys(allElements).map( (elementName) => {
+    const elem = allElements[elementName];
+    if (elem.replacedByColumn) {
+      SELECT.columns.splice(SELECT.columns.indexOf(elem.replacedByColumn), 1);
+      return elem.replacedByColumn;
+    }
+
+    const column = { ref: [ elementName ] };
+    if (elem.alias) {
+      // Special case for `for.effective` to reduce diffs and unnecessary table aliases.
+      const requiresAlias = options.transformation !== 'effective' ||
+        elementName === elem.alias ||
+        elementName.charAt(0) === '$' ||
+        (!query.projection && !query.SELECT?.from?.ref);
+
+      if (requiresAlias)
+        column.ref.unshift(elem.alias); // use table alias if available and required
+    }
+    return column;
+  });
+
+  SELECT.columns.splice(SELECT.columns.indexOf('*'), 1, ...columns);
+  // since we've expanded '*', the excluding clause has no effect anymore
+  delete SELECT.excluding;
+}
+
+
+/**
+ * Get all elements that are expanded by '*'.
+ * Respects the query's 'excluding' clause and 'masked' elements.
+ * Elements that are replaced by columns have a `replacedByColumn` property.
+ *
+ * @param {object} query Query with SELECT/projection.
+ * @param {object} csnUtils
+ * @returns {object} All elements which '*' expands to.
+ */
+function wildcardElements( query, csnUtils ) {
+  const combined = aliasesToCombined(csnUtils.queryForElements(query));
+  const SELECT = query.SELECT ?? query.projection;
+  for (const excluded of SELECT.excluding ?? [])
+    delete combined[excluded];
+
+  // Handle deprecated 'masked' keyword.
+  for (const name in combined) {
+    combined[name] = combined[name].filter(sourceElement => !sourceElement.element?.masked);
+    if (combined[name].length === 0)
+      delete combined[name];
+    else
+      combined[name] = combined[name][0]; // flatten
+  }
+
+  let seenStar = false;
+  for (const col of SELECT.columns) {
+    if (col === '*') {
+      seenStar = true;
+      continue;
+    }
+    if (col.inline) {
+      // 'inline' does not result in an element, hence skip it.  We can do so, because for
+      // something like `*, toSelf.{ id }`, '*' would still expand 'id' which results in
+      // a 'duplicate' error.  It wouldn't happen for `*, toSelf.id`.
+      continue;
+    }
+    const alias = col.as || col.ref && implicitAs(col.ref);
+    if (alias && combined[alias]) {
+      if (seenStar)
+        combined[alias] = { replacedByColumn: col };
+      else
+        delete combined[alias];
+    }
+  }
+
+  return combined;
+}
+
+/**
+ * Transforms the result of `csnRefs.queryElements()` into a dictionary like form
+ * for further processing by `wildcardElements`.
+ *
+ * @param {object} queryElements Result of `csnRefs.queryElements()`
+ * @returns {object}
+ */
+function aliasesToCombined(queryElements) {
+  const combined = Object.create(null);
+  for (const alias in queryElements.$aliases) {
+    const elements = queryElements.$aliases[alias]?.elements;
+    for (const elementName in elements) {
+      combined[elementName] ??= [];
+      const entry = { name: elementName, element: elements[elementName] };
+      if (alias.charAt(0) !== '$') // don't set alias for e.g. '$_select_N' internal aliases
+        entry.alias = alias;
+      combined[elementName].push(entry);
+    }
+  }
+  return combined;
+}
+
 module.exports = {
   expandStructureReferences,
+  expandWildcard,
 };

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;
 }