@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/gen/Dictionary.json

@@ -808,7 +808,6 @@
       "Type": "Core.Tag"
     },
     "Common.IsTimezone": {
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"
@@ -1035,7 +1034,6 @@
       "Type": "Edm.DateTimeOffset"
     },
     "Common.Timezone": {
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"

package/lib/model/csnRefs.js

@@ -250,10 +250,9 @@ function csnRefs( csn, universalReady ) {
   // const { definitions } = csn;
   const cache = new WeakMap();
   setCache( BUILTIN_TYPE, '_origin', null );
-  if (universalReady === 'init-all') {
-    for (const name of Object.keys( csn.definitions || {}))
-      initDefinition( name );
-  }
+  if (universalReady === 'init-all')
+    initAllDefinitions();
+
   // Functions which set the new `baseEnv`:
   resolveRef.expandInline = function resolveExpandInline( ref, ...args ) {
     return cached( ref, '_env', () => navigationEnv( resolveRef( ref, ...args ).art ) );
@@ -278,6 +277,7 @@ function csnRefs( csn, universalReady ) {
     getColumnName: col => getCache( col, '$as' ),
     $getQueries: def => getCache( def, '$queries' ), // unstable API
     initDefinition,
+    initAllDefinitions,
     dropDefinitionCache,
     targetAspect,
     msgLocations,
@@ -489,6 +489,11 @@ function csnRefs( csn, universalReady ) {
     return query && cache.get( query.projection || query );
   }
 
+  function initAllDefinitions() {
+    for (const name of Object.keys( csn.definitions || {}))
+      initDefinition( name );
+  }
+
   function initDefinition( main ) {
     const name = typeof main === 'string' && main;
     if (name) {

package/lib/model/csnUtils.js

@@ -64,6 +64,7 @@ function getUtils( model, universalReady ) {
     addStringAnnotationTo,
     getServiceName,
     getFinalTypeInfo,
+    resolvePath,
     get$combined,
     getQueryPrimarySource,
     ..._csnRefs,
@@ -448,6 +449,71 @@ function getUtils( model, universalReady ) {
       return target;
     }
   }
+
+
+  /**
+   * Resolve the type of an artifact
+   * If art is undefined, stop
+   * If art has elements or items.elements, stop
+   * If art has a type and the type is scalar, stop
+   * If art has a named type or a type ref, resolve it
+   */
+  function resolveType( art ) {
+    while (art &&
+      !((art.items && art.items.elements) || art.elements) &&
+      (art.type &&
+        ((!art.type.ref && !isBuiltinType(art.type)) || art.type.ref))) {
+      if (art.type.ref)
+        art = resolvePath(art.type);
+      else
+        art = model.definitions[art.type];
+    }
+    return art;
+  }
+
+  /**
+   * Path resolution, attach artifact to each path step, if found,
+   * Dereference types and follow associations.
+   *
+   * @param {any} path ref object
+   * @param {any} art start environment
+   * @returns {any} path with resolved artifacts or artifact
+   * (if called with simple ref paths)
+   */
+  function resolvePath( path, art = undefined ) {
+    let notFound = false;
+    for (let i = 0; i < path.ref.length && !notFound; i++) {
+      const ps = path.ref[i];
+      const id = ps.id || ps;
+      if (art) {
+        if (art.target)
+          art = model.definitions[art.target].elements[id];
+        else if (art.items && art.items.elements || art.elements)
+          art = (art.items && art.items.elements || art.elements)[id];
+
+        else
+          art = undefined;
+      }
+      else {
+        art = model.definitions[id];
+      }
+      art = resolveType(art);
+
+      // if path step has id, store art
+      if (ps.id && art)
+        ps._art = art;
+      notFound = !art;
+    }
+    // if resolve was called on constraint path, path has id.
+    // Store art and return path, if called recursively for model ref paths,
+    // return artifact only
+    if (path.ref[0].id) {
+      if (art)
+        path._art = art;
+      return path;
+    }
+    return art;
+  }
 }
 
 
@@ -1248,7 +1314,6 @@ function walkCsnPath( csn, path ) {
   for (const segment of path)
     obj = obj[segment];
 
-
   return obj;
 }
 
@@ -1356,7 +1421,7 @@ function functionList( functions, thisArg ) {
  * @returns {boolean}
  */
 function isDollarSelfOrProjectionOperand( arg ) {
-  return arg.ref && arg.ref.length === 1 &&
+  return arg.ref?.length === 1 &&
     (arg.ref[0] === '$self' || arg.ref[0] === '$projection');
 }
 

package/lib/optionProcessor.js

@@ -265,7 +265,7 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-vocabularies <list>')
   .option('    --odata-no-creator')
   .option('    --draft-messages')
-  .option('    --add-annotation-AddressViaNavigationPath')
+  .option('    --draft-user-description')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', { valid: [ 'flat', 'structured' ] })
   .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
@@ -301,8 +301,7 @@ optionProcessor.command('O, toOdata')
                                    { prefix: { alias, ns, uri }, ... }
        --odata-no-creator          Omit creator identification in API
        --draft-messages            Add draft messages as part of the draft creation
-       --add-annotation-AddressViaNavigationPath Add annotation "@Common.AddressViaNavigationPath" to the services
-                                                 containing draft enabled entitties
+       --draft-user-description    Add user description fields to the DraftAdministrativeData entity
        -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores

package/lib/parsers/AstBuildingParser.js

@@ -49,7 +49,6 @@ const PRECEDENCE_OF_EQUAL = 10;
 class AstBuildingParser extends BaseParser {
   leanConditions = {
     afterBrace: true,
-    atRightParen: true,
     fail: true,
   };
 
@@ -203,6 +202,10 @@ class AstBuildingParser extends BaseParser {
   }
 
   addTokenToSet_( set, tokenName, val, collectKeywordsOnly ) {
+    if (!this.dynamic_.call) {
+      super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
+      return;
+    }
     const token = parserTokens[tokenName];
     // TODO: use lower-case in specialFunctions
     const realTokens = token && this.dynamic_.generic?.[token];
@@ -215,7 +218,7 @@ class AstBuildingParser extends BaseParser {
       // Works, since `DeleteStarFromSet` comes after `*` (length-sorted):
       delete set['*'];
     }
-    else {
+    else if (!token) {
       super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
     }
   }
@@ -489,10 +492,6 @@ class AstBuildingParser extends BaseParser {
     // token is not on a new line?
   }
 
-  atRightParen() {
-    return this.l() !== ')';
-  }
-
   /**
    * For annotations at the beginning of columns outside parentheses
    */

package/lib/render/toCdl.js

@@ -796,10 +796,15 @@ class CsnToCdl {
     }
 
     // Top-level annotations of the artifact
-    let result = this.renderAnnotationAssignmentsAndDocComment(ext, env);
+    const topLevelAnnotations = this.renderAnnotationAssignmentsAndDocComment(ext, env.withIncreasedIndent());
+
     // Note: Not renderDefinitionReference, because we don't care if there
     //       are annotations to unknown things. That's allowed!
-    result += `${ env.indent }annotate ${ this.renderArtifactName(ext.annotate, env) }`;
+    let result = `${ env.indent }annotate ${ this.renderArtifactName(ext.annotate, env) }`;
+
+    if (topLevelAnnotations)
+      result += ` with\n${ topLevelAnnotations }`;
+
 
     if (ext.params)
       result += this.renderAnnotateParamsInParentheses(ext, env);
@@ -1368,7 +1373,7 @@ class CsnToCdl {
   }
 
   /**
-   * Render the given columns.
+   * Render the given columns / select items.
    *
    * @param {CSN.Extension | CSN.QuerySelect} art
    * @param {object} elements
@@ -1459,6 +1464,7 @@ class CsnToCdl {
 
     const isAnonymousExpand = (obj.expand && !obj.ref);
 
+
     // s as alias { * }
     if (obj.as && !isAnonymousExpand)
       result += this.renderAlias(obj.as, env);
@@ -1483,7 +1489,7 @@ class CsnToCdl {
     const childEnv = env.withIncreasedIndent();
     const expandInline = obj.expand || obj.inline;
     result += expandInline //
-      .map(elm => this.renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + this.renderInlineExpand(elm, childEnv))
+      .map(elm => this.renderViewColumn(elm, childEnv))
       .join(',\n');
     result += `\n${ env.indent }}`;
 

package/lib/render/utils/common.js

@@ -305,10 +305,12 @@ const cdsToSqlTypes = {
   h2: {
     'cds.Binary': 'VARBINARY', // same as for plain
     'cds.LargeBinary': 'BINARY LARGE OBJECT', // BLOB would require a length!
-    'cds.DecimalFloat': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
+    // 'cds.Decimal': 'DECFLOAT', // Decimal and Decimal(p) is mapped to cds.DecimalFloat
+    'cds.DecimalFloat': 'DECFLOAT',
     'cds.DateTime': 'TIMESTAMP(0)',
     'cds.Timestamp': 'TIMESTAMP(7)',
     'cds.Map': 'JSON',
+    'cds.UInt8': 'SMALLINT', // See #13870; not equivalent, but smallint can hold >byte
   },
   postgres: {
     // See <https://www.postgresql.org/docs/current/datatype.html>
@@ -317,7 +319,7 @@ const cdsToSqlTypes = {
     'cds.LargeBinary': 'BYTEA',
     'cds.Binary': 'BYTEA',
     'cds.Double': 'FLOAT8',
-    'cds.UInt8': 'INTEGER', // Not equivalent
+    'cds.UInt8': 'SMALLINT', // See #13870; not equivalent, but smallint can hold >byte
     'cds.Vector': 'VARCHAR', // Not supported; see #11725
     'cds.Map': 'JSONB',
   },

package/lib/transform/db/assertUnique.js

@@ -20,7 +20,8 @@ const { pathName } = require('../../compiler/utils');
  * @returns {Function} forEachDefinition callback
  */
 function processAssertUnique( csn, options, messageFunctions ) {
-  const { resolvePath, flattenPath } = getTransformers(csn, options, messageFunctions);
+  const { csnUtils, flattenPath } = getTransformers(csn, options, messageFunctions);
+  const { resolvePath } = csnUtils;
   const { error, info } = messageFunctions;
 
   return handleAssertUnique;

package/lib/transform/db/associations.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  transformAnnotationExpression,
   applyTransformationsOnNonDictionary,
   applyTransformations,
   implicitAs,
@@ -106,18 +107,40 @@ function attachOnConditions( csn, csnUtils, pathDelimiter, iterateOptions = {},
 
 /**
  * @param {CSN.Model} csn
+ * @param {CSN.Options} options
  * @param {object} csnUtils
  * @param {string} pathDelimiter
  * @param {boolean} [processOnInQueries=false] Wether to process on-conditions in queries (joins and mixins)
  * @returns {(artifact: CSN.Artifact, artifactName: string) => void} Callback for forEachDefinition
  */
-function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries = false ) {
+function getFKAccessFinalizer( csn, options, csnUtils, pathDelimiter, processOnInQueries = false ) {
   const {
     inspectRef,
   } = csnUtils;
 
   return handleManagedAssocSteps;
 
+  /**
+   *
+   * @param {object} obj Object with annotations.
+   * @param {object} transformer Annotation expression transformers.
+   * @param {CSN.Path} path CSN path for locations.
+   */
+  function processRefsInAnnotations(obj, transformer, path) {
+    Object.keys(obj)
+      .filter(pn => pn.startsWith('@') && obj[pn])
+      .forEach((anno) => {
+      // TODO: Ensure we only do processing here for annotations that have refs, to save time
+        const annoBefore = JSON.stringify(obj[anno]);
+        transformAnnotationExpression(obj, anno, transformer, path);
+        if (obj[anno].ref)
+          transformer.ref(obj[anno], 'ref', obj[anno].ref, path.concat(anno));
+        const annoAfter = JSON.stringify(obj[anno]);
+        if (annoBefore !== annoAfter)
+          obj[anno]['='] = true;
+      });
+  }
+
   /**
    * Loop over all elements and for all unmanaged associations translate
    * <assoc base>.<managed assoc>.<fk> to <assoc base>.<managed assoc>_<fk>
@@ -133,6 +156,11 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
   function handleManagedAssocSteps( artifact, artifactName ) {
     const transformer = getTransformer();
     const inColumnsTransformer = getTransformer(true);
+
+    if (options.transformation === 'effective')
+      processRefsInAnnotations(artifact, transformer, [ 'definitions', artifactName ]);
+
+
     for (const elemName in artifact.elements) {
       const elem = artifact.elements[elemName];
       // The association is an unmanaged one
@@ -140,6 +168,10 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
         applyTransformationsOnNonDictionary(elem, 'on', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
       else if (elem.value?.stored)
         applyTransformationsOnNonDictionary(elem, 'value', transformer, {}, [ 'definitions', artifactName, 'elements', elemName ]);
+
+      // TODO: Is this enough? I suppose that these annotations can be in places that are not an element.
+      if (options.transformation === 'effective')
+        processRefsInAnnotations(elem, transformer, [ 'definitions', artifactName, 'elements', elemName ]);
     }
 
     if (artifact.query || artifact.projection) {
@@ -165,6 +197,10 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
         };
         queryTransformers.on = transform;
       }
+
+      if (options.transformation === 'effective' || options.transformation === 'odata')
+        queryTransformers.xpr = transform;
+
       applyTransformationsOnNonDictionary(artifact, artifact.query ? 'query' : 'projection', queryTransformers, { drillRef: true }, [ 'definitions', artifactName ]);
     }
 

package/lib/transform/db/assocsToQueries/transformExists.js

@@ -26,30 +26,29 @@ const { getHelpers } = require('./utils');
  *   + Is it part of the source side: <path> is turned into <query source>.<path> - a leading $self is stripped-off
  *   + Is it something else: Don't touch it, leave as is
  *
- * Given that `assoc` from above has the on-condition assoc.id = id, we would generate the following:
+ * Given that `assoc` from above has the on-condition `assoc.id = id`, we would generate the following:
  * - F.id = E.id
  *
- * The final subselect looks like (select 1 as dummy from E where F.id = E.id and filter = 100).
+ * The final subselect looks like `(select 1 as dummy from E where F.id = E.id and filter = 100)`.
  *
  * For a $self backlink:
  * - For $self = <assoc>.<another-assoc>, we do the following for each foreign key of <another-assoc>
  *   + <assoc>.<another-assoc>.<fk> -> <assoc.target>.<another-assoc>.<fk>
- *   + Afterwards, we get the corresponding key from the source side: <query-source>.<fk>
+ *   + Afterward, we get the corresponding key from the source side: <query-source>.<fk>
  *   + And turn this into a comparison: <assoc.target>.<another-assoc>.<fk> = <query-source>.<fk>
  *
  * So for the sample above, given an on-condition like $self = assoc.backToE, we would generate:
  * - F.backToE.id = E.id
  *
- * The final subselect looks like (select 1 as dummy from E where F.backToE.id = E.id and filter = 100).
+ * The final subselect looks like `(select 1 as dummy from E where F.backToE.id = E.id and filter = 100)`.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param {Function} error
- * @param {Function} inspectRef
- * @param {Function} initDefinition
- * @param {Function} dropDefinitionCache
+ * @param {object} messageFunctions
+ * @param {object} csnUtils
  */
-function handleExists( csn, options, error, inspectRef, initDefinition, dropDefinitionCache ) {
+function handleExists( csn, options, messageFunctions, csnUtils ) {
+  const { error } = messageFunctions;
   const {
     getBase,
     firstLinkIsEntityOrQuerySource,
@@ -57,17 +56,12 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     translateManagedAssocToWhere,
     getQuerySources,
     translateUnmanagedAssocToWhere,
-  } = getHelpers(csn, inspectRef, error);
+  } = getHelpers(csn, csnUtils.inspectRef, error);
+
   const generatedExists = new WeakMap();
   forEachDefinition(csn, (artifact, artifactName) => {
-    // drop cache: Otherwise, the projection/query hack below won't work, because csnRefs
-    // thinks that the artifact was already initialized (including all queries).
-    dropDefinitionCache(artifact);
-    if (artifact.projection) // do the same hack we do for the other stuff...
-      artifact.query = { SELECT: artifact.projection };
-
-    if (artifact.query) {
-      forAllQueries(artifact.query, function handleExistsQuery(query, path) {
+    if (artifact.query || artifact.projection) {
+      forAllQueries(artifact.query || { SELECT: artifact.projection }, function handleExistsQuery(query, path) {
         if (!generatedExists.has(query)) {
           const toProcess = []; // Collect all expressions we need to process here
           if (query.SELECT?.where?.length > 1)
@@ -90,8 +84,8 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           while (toProcess.length > 0) {
             const [ queryPath, exprPath ] = toProcess.pop();
             // Re-init caches for this artifact
-            dropDefinitionCache(artifact);
-            initDefinition(artifact);
+            csnUtils.dropDefinitionCache(artifact);
+            csnUtils.initDefinition(artifact);
             // leftovers can happen with nested exists - we then need to drill down into the created SELECT
             // to check for further exists
             const { result, leftovers } = processExists(queryPath, exprPath);
@@ -100,16 +94,10 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
             toProcess.push(...leftovers); // any leftovers - schedule for further processing
           }
           // Make sure we leave csnRefs usable
-          dropDefinitionCache(artifact);
-          initDefinition(artifact);
+          csnUtils.dropDefinitionCache(artifact);
+          csnUtils.initDefinition(artifact);
         }
-      }, [ 'definitions', artifactName, 'query' ]);
-    }
-
-    if (artifact.projection) { // undo our hack
-      artifact.projection = artifact.query.SELECT;
-
-      delete artifact.query;
+      }, [ 'definitions', artifactName, artifact.projection ? 'projection' : 'query' ]);
     }
   });
 
@@ -168,7 +156,7 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
       }
     }
     const stack = [ [ null, startAssoc, startRest, startIndex ] ];
-    const { links } = inspectRef(path);
+    const { links } = csnUtils.inspectRef(path);
     while (stack.length > 0) {
       // previous: to nest "up" if the previous assoc did not originally have a filter
       // assoc: the assoc path step
@@ -258,8 +246,9 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
     const newExpr = [];
     const query = walkCsnPath(csn, queryPath);
     const expr = walkCsnPath(csn, exprPath);
-    const queryBase = query.SELECT.from.ref ? (query.SELECT.from.as || query.SELECT.from.ref) : null;
-    const sources = getQuerySources(query.SELECT);
+    const select = query.projection ?? query.SELECT;
+    const queryBase = select?.from?.ref ? (select.from.as || select.from.ref) : null;
+    const sources = getQuerySources(select);
 
     for (let i = 0; i < expr.length; i++) {
       if (i < expr.length - 1 && expr[i] === 'exists' && expr[i + 1].ref) {

package/lib/transform/db/assocsToQueries/utils.js

@@ -430,7 +430,7 @@ function getHelpers( csn, inspectRef, error ) {
   }
 
   /**
-   * Use cacjed _links and _art or calculate via inspectRef
+   * Use cached _links and _art or calculate via inspectRef
    * @param {object} obj
    * @param {CSN.Path} objPath
    * @returns {object}

package/lib/transform/db/cdsPersistence.js

@@ -125,7 +125,7 @@ function getPersistenceTableProcessor( csn, options, messageFunctions ) {
 
       recurseElements(artifact, [ 'definitions', artifactName ], (member, path) => {
         // All elements must have a type for this to work
-        if (!member.$ignore && !member.kind && !member.type) {
+        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

@@ -38,18 +38,16 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     columns: (parent, name, columns, path) => {
       const artifact = csn.definitions[path[1]];
       csnUtils.initDefinition(artifact); // potentially not initialized, yet
-      if (!artifact['@cds.persistence.table']) {
-        const root = csnUtils.get$combined({ SELECT: parent });
-        // TODO: replace with the correct options.transformation?
-        // Do not expand the * in OData for a moment, not to introduce changes
-        // while the OData CSN is still official
-        const isComplexQuery = parent.from.join !== undefined;
-        if (!options.toOdata)
-          parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
-        // FIXME(v6): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
-        // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
-        parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
-      }
+      const root = csnUtils.get$combined({ SELECT: parent });
+      // TODO: replace with the correct options.transformation?
+      // Do not expand the * in OData for a moment, not to introduce changes
+      // while the OData CSN is still official
+      const isComplexQuery = parent.from.join !== undefined;
+      if (!options.toOdata)
+        parent.columns = replaceStar(root, columns, parent.excluding, isComplexQuery);
+      // FIXME(v6): Remove argument "isComplexOrNestedQuery"; we use path.length > 4 to check
+      // if we're inside the outermost "columns". If so, always prepend a table alias. See #11662
+      parent.columns = expand(parent.columns, path.concat('columns'), true, isComplexQuery || path.length > 4);
     },
     groupBy: (parent, name, groupBy, path) => {
       parent.groupBy = expand(groupBy, path.concat('groupBy'));
@@ -86,24 +84,22 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         // (which is the thing inside SET/SELECT)
         // We can directly use SELECT here, as only projections and SELECT can have .columns
         const root = csnUtils.get$combined({ SELECT: parent });
-        if (!artifact['@cds.persistence.table']) {
-          // Make root look like normal .elements - we never cared about conflict afaik anyway
-          Object.keys(root).forEach((key) => {
-            root[key] = root[key][0].element;
+        // Make root look like normal .elements - we never cared about conflict afaik anyway
+        Object.keys(root).forEach((key) => {
+          root[key] = root[key][0].element;
+        });
+        const rewritten = rewrite(root, parent.columns, parent.excluding);
+        /*
+          * Do not remove unexpandable many columns in OData
+        */
+        if (rewritten.toMany.length > 0 && !options.toOdata) {
+          markAsToDummify(artifact, path[1]);
+          rewritten.toMany.forEach(({ art }) => {
+            error( null, art.$path || [ 'definitions', path[1] ], { name: `${ art.$env || path[1] }:${ art.ref.map(r => r.id || r) }` }, 'Unexpected .expand with to-many association $(NAME)');
           });
-          const rewritten = rewrite(root, parent.columns, parent.excluding);
-          /*
-           * Do not remove unexpandable many columns in OData
-          */
-          if (rewritten.toMany.length > 0 && !options.toOdata) {
-            markAsToDummify(artifact, path[1]);
-            rewritten.toMany.forEach(({ art }) => {
-              error( null, art.$path || [ 'definitions', path[1] ], { name: `${ art.$env || path[1] }:${ art.ref.map(r => r.id || r) }` }, 'Unexpected .expand with to-many association $(NAME)');
-            });
-          }
-          else {
-            parent.columns = rewritten.columns;
-          }
+        }
+        else {
+          parent.columns = rewritten.columns;
         }
       },
     });
@@ -280,11 +276,13 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
       const allToMany = [];
       const newThing = [];
       const containsExpandInline = columns.some(col => col.expand || col.inline);
-      if (containsExpandInline) // Replace stars - needs to happen before resolving .expand/.inline since the .expand/.inline first path step affects the root *
-        columns = replaceStar(root, columns, excluding);
-      else
+      if (!containsExpandInline)
         return { columns, toMany: [] };
 
+      // Replace stars - needs to happen before resolving .expand/.inline since the
+      // .expand/.inline first path step affects the root *
+      columns = replaceStar(root, columns, excluding);
+
       for (const col of columns) {
         if (col.expand || col.inline) {
           const { expanded, toManys } = expandInline(root, col, col.ref || [], col.expand ? [ dbName(col) ] : []);
@@ -364,7 +362,10 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         }
         else if (current.on || current.cast?.on) {
           rewriteOn(current, [ currentAlias.slice(0, -1).join(pathDelimiter) ]);
-          expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
+          const expandedCol = Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } );
+          if (currentRef.length)
+            expandedCol.ref = currentRef;
+          expanded.push(expandedCol);
         }
         else if (current.val !== undefined || current.func !== undefined) {
           expanded.push(Object.assign(current, { as: currentAlias.join(pathDelimiter) }));
@@ -440,7 +441,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     function rewriteOnCondition( on, currentRef, stack ) {
       for (let i = 0; i < on.length; i++) {
         const part = on[i];
-        if (part.ref && part.ref[0] !== '$self' && part.ref[0] !== '$projection') {
+        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self' && part.$scope !== '$projection') {
           part.ref = currentRef[0] ? [ currentRef[0], ...part.ref ] : part.ref;
           on[i] = part;
           stack.push([ part, part.ref ]);
@@ -461,7 +462,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
     function rewriteSingleExpressionArray( expressionArray, currentRef, stack ) {
       for (let i = 0; i < expressionArray.length; i++) {
         const part = expressionArray[i];
-        if (part.ref) {
+        if (part.ref && part.$scope !== '$magic' && part.$scope !== '$self') {
           part.ref = currentRef.concat(part.ref);
           expressionArray[i] = part;
           stack.push([ part, part.ref ]);
@@ -657,7 +658,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
         obj.ref = [ root.$env, ...obj.ref ];
 
       if (iterateOptions.keepKeysOrigin) {
-        setProp(obj, '$originalKeyRef', { ref: root.ref, as: root.as });
+        setProp(obj, '$originalKeyRef', root);
         setProp(obj, '$path', root.$path);
       }