@sap/cds-compiler 3.1.2 → 3.3.2

package/lib/render/manageConstraints.js

@@ -8,7 +8,7 @@ const {
 const { forEach } = require('../utils/objectUtils');
 const { makeMessageFunction } = require('../base/messages');
 const { optionProcessor } = require('../optionProcessor');
-const { transformForHanaWithCsn } = require('../transform/forHanaNew');
+const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 
 const {
   renderReferentialConstraint, getIdentifierUtils,
@@ -38,7 +38,7 @@ function alterConstraintsWithCsn(csn, options) {
   options.assertIntegrityType = 'DB';
 
   const transformedOptions = _transformSqlOptions(csn, options);
-  const forSqlCsn = transformForHanaWithCsn(csn, transformedOptions, 'to.sql');
+  const forSqlCsn = transformForRelationalDBWithCsn(csn, transformedOptions, 'to.sql');
 
   if (violations && src && src !== 'sql')
     error(null, null, `Option “--violations“ can't be combined with source style “${src}“`);

package/lib/render/toCdl.js

@@ -20,7 +20,6 @@ const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
  * Returned object has the following properties:
  *  - `model`: CSN model rendered as CDL (string).
  *  - `namespace`: Namespace statement + `using from './model.cds'.
- *  - `unappliedExtensions`: Annotations / Extensions from the `csn.extensions` array.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} [options]
@@ -45,17 +44,14 @@ function csnToCdl(csn, options) {
 
   if (csn.vocabularies)
     cdlResult.model += renderVocabularies(csn.vocabularies);
+  if (csn.extensions)
+    cdlResult.model += renderExtensions(csn.extensions, createEnv());
 
   if (csn.namespace) {
     cdlResult.namespace = `namespace ${renderArtifactName(csn.namespace)};\n`;
     cdlResult.namespace += 'using from \'./model.cds\';';
   }
 
-  // If there are extensions, such as 'extend' and 'annotate' statements, render them separately.
-  // Used for e.g. parseCdl-style CSN or Universal CSN.
-  if (csn.extensions)
-    cdlResult.unappliedExtensions = renderExtensions(csn.extensions, createEnv());
-
   timetrace.stop();
   return cdlResult;
 
@@ -109,7 +105,9 @@ function csnToCdl(csn, options) {
    * @return {string}
    */
   function renderExtensions(extensions, env) {
-    return extensions.map(ext => renderExtension(ext, env)).join('\n');
+    if (!env.path)
+      env = envNewPath(env, [ 'extensions' ]);
+    return extensions.map((ext, index) => renderExtension(ext, envAddPath(env, [ index ]))).join('\n');
   }
 
   /**
@@ -471,27 +469,6 @@ function csnToCdl(csn, options) {
     return `${result};\n`;
   }
 
-  /**
-   * Render a query's actions and functions (if any) separately as extend-statements, so that actions
-   * work not only for projections but also for views, which have no syntax (yet) to directly specify
-   * actions and functions inline.
-   * Return the resulting 'extend' statement or '' if no actions or functions
-   * FIXME: Simplify once we have such a syntax
-   *
-   * @param {string} artifactName
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderQueryActionsAndFunctions(artifactName, art, env) {
-    let result = renderActionsAndFunctions(art, env);
-    // Even if we have seen actions/functions, they might all have been ignored
-    if (result !== '')
-      result = `${env.indent}extend entity ${artifactName} with${result};`;
-
-    return result;
-  }
-
   /**
    * Render annotations that were extended to a query element of a view or projection (they only
    * appear in the view's 'elements', not in their 'columns' for client CSN, because the element
@@ -507,8 +484,8 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderQueryElementAnnotations(artifactName, art, env) {
-    const annotate = collectAnnotationsOfElements(art, { artifactName, path: env.path });
+  function renderQueryElementAndEnumAnnotations(artifactName, art, env) {
+    const annotate = collectAnnotationsOfElementsAndEnum(art, { artifactName, path: env.path });
     if (annotate)
       return renderExtensions([ annotate ], env);
     return '';
@@ -518,17 +495,20 @@ function csnToCdl(csn, options) {
    * Create an "annotate" statement as a CSN extension for all annotations of (sub-)elements.
    * If no annotation was found, we return `null`.
    *
-   * @param {CSN.Artifact} artWithElements
+   * @param {CSN.Artifact} artifact
    * @param {CdlRenderEnvironment} env
    * @return {CSN.Extension|null}
    */
-  function collectAnnotationsOfElements(artWithElements, env) {
-    // Array of structures, which may be annotated as well.
-    if (!artWithElements.elements && artWithElements.items) {
+  function collectAnnotationsOfElementsAndEnum(artifact, env) {
+    // Array, which may be annotated as well.
+    if (artifact.items) {
       env = envAddPath(env, [ 'items' ]);
-      artWithElements = artWithElements.items;
+      artifact = artifact.items;
     }
 
+    if (!artifact.elements && !artifact.enum)
+      return null;
+
     const annotate = { annotate: env.path[1] };
 
     // Based on the current path, create a correctly nested structure
@@ -551,22 +531,26 @@ function csnToCdl(csn, options) {
         // ignore others, e.g. 'items'
       }
     }
-    return collectAnnos(obj, artWithElements) ? annotate : null;
+    return collectAnnos(obj, artifact) ? annotate : null;
 
     /**
      * Recursive function to collect annotations. `annotateObj` will get an `elements`
-     * object with annotations only if there are annotations on `art`'s (sub-)elements.
+     * object with annotations only if there are annotations on `art`'s (sub-)elements or
+     * enums.  Returned object will use "elements" even for enums, since that is
+     * expected in extensions.
      *
      * @return {boolean} True, if there were annotations, false otherwise.
      */
     function collectAnnos(annotateObj, art) {
-      if (!art.elements)
+      if (!art.elements && !art.enum)
         return false;
 
+      const dictKey = art.elements ? 'elements' : 'enum';
+      // Use "elements" for both enums and elements. This is allowed in extensions.
       const collected = { elements: Object.create(null) };
       let hasAnnotation = false;
 
-      forEach(art.elements, (elemName, element) => {
+      forEach(art[dictKey], (elemName, element) => {
         if (!collected.elements[elemName])
           collected.elements[elemName] = { };
 
@@ -848,14 +832,15 @@ function csnToCdl(csn, options) {
   function renderView(artifactName, art, env) {
     const syntax = (art.projection) ? 'projection' : 'entity';
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}${art.abstract ? 'abstract ' : ''}${syntax === 'projection' ? 'entity' : syntax} ${renderArtifactName(artifactName)}`;
+    result += `${env.indent}entity ${renderArtifactName(artifactName)}`;
     if (art.params)
       result += renderParameters(art, env);
     result += ' as ';
     result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
+    if (art.actions) // Views/Projections also allow actions. Just the VIEW keyword variant did not.
+      result += renderActionsAndFunctions(art, env);
     result += ';\n';
-    result += renderQueryElementAnnotations(artifactName, art, env);
-    result += renderQueryActionsAndFunctions(artifactName, art, env);
+    result += renderQueryElementAndEnumAnnotations(artifactName, art, env);
     return result;
   }
 
@@ -1205,10 +1190,12 @@ function csnToCdl(csn, options) {
 
     // If we have a type and elements, we may have sub-structure annotates that would
     // get lost if we only render the type name.
+    // We only extract annotations of enums, if "typeRefOnly" is true.  Otherwise, since
+    // the full enum is rendered below, we would have unnecessary annotations.
     // TODO: Can we annotate elements of targetAspect?
     //       If so, move this block before the composition rendering.
-    if (!noAnnoCollect && (artifact.elements || artifact.items?.elements)) {
-      const annotate = collectAnnotationsOfElements(artifact, env);
+    if (!noAnnoCollect && (!artifact.enum || typeRefOnly)) {
+      const annotate = collectAnnotationsOfElementsAndEnum(artifact, env);
       if (annotate)
         subelementAnnotates.push(annotate);
     }

package/lib/render/toHdbcds.js

@@ -7,8 +7,9 @@ const {
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const {
-  renderFunc, getExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts, cdsToSqlTypes,
+  renderFunc, getExpressionRenderer, getRealName, addContextMarkers, addIntermediateContexts,
   hasHanaComment, getHanaComment, funcWithoutParen, getSqlSnippets,
+  cdsToSqlTypes, cdsToHdbcdsTypes,
 } = require('./utils/common');
 const {
   renderReferentialConstraint,
@@ -195,7 +196,7 @@ function toHdbcdsSource(csn, options) {
     switch (art.kind) {
       case 'entity':
         // FIXME: For HANA CDS, we need to replace $self at the beginning of paths in association ON-condition
-        // by the full name of the artifact we are rendering (should actually be done by forHana, but that is
+        // by the full name of the artifact we are rendering (should actually be done by forRelationalDB, but that is
         // somewhat difficult because this kind of absolute path is quite unusual). In order not to have to pass
         // the current artifact name down through the stack to renderExpr, we just put it into the env.
         env.currentArtifactName = artifactName;
@@ -763,7 +764,7 @@ function toHdbcdsSource(csn, options) {
       result += key + renderExpr(col, env, true);
       let alias = col.as || col.func;
       // HANA requires an alias for 'key' columns just for syntactical reasons
-      // FIXME: This will not complain for non-refs (but that should be checked in forHana)
+      // FIXME: This will not complain for non-refs (but that should be checked in forRelationalDB)
       // Explicit or implicit alias?
       // Shouldn't we simply generate an alias all the time?
       if ((key || col.cast) && !alias)
@@ -1147,7 +1148,8 @@ function toHdbcdsSource(csn, options) {
     if (elm.type === 'cds.Decimal' && elm.scale === undefined && elm.precision === undefined)
       return 'DecimalFloat';
 
-    return elm.type.replace(/^cds\./, '') + renderTypeParameters(elm);
+    const type = cdsToHdbcdsTypes[elm.type] || elm.type;
+    return type.replace(/^cds\./, '') + renderTypeParameters(elm);
   }
 
   /**
@@ -1160,7 +1162,7 @@ function toHdbcdsSource(csn, options) {
   function renderPathStep(s, idx, ref, env, inline) {
     // Simple id or absolute name
     if (typeof s === 'string') {
-      // HANA-specific extra magic (should actually be in forHana)
+      // HANA-specific extra magic (should actually be in forRelationalDB)
       // In HANA, we replace leading $self by the absolute name of the current artifact
       // (see FIXME at renderArtifact)
       if (idx === 0 && s === $SELF) {

package/lib/render/toRename.js

@@ -6,7 +6,7 @@ const { checkCSNVersion } = require('../json/csnVersion');
 const { getUtils, forEachDefinition } = require('../model/csnUtils');
 const { optionProcessor } = require('../optionProcessor');
 const { isBetaEnabled } = require('../base/model');
-const { transformForHanaWithCsn } = require('../transform/forHanaNew');
+const { transformForRelationalDBWithCsn } = require('../transform/forRelationalDB');
 
 
 /**
@@ -44,9 +44,9 @@ function toRename(inputCsn, options) {
   if (!isBetaEnabled(options, 'toRename'))
     error(null, null, 'Generation of SQL rename statements is not supported yet (only in beta mode)');
 
-  // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forHana)
-  const csn = transformForHanaWithCsn(inputCsn, options, 'to.rename');
-  // forHanaCsn looses empty contexts and services, add them again so that toRename can calculate the namespaces
+  // FIXME: Currently, 'toRename' implies transformation for HANA (transferring the options to forRelationalDB)
+  const csn = transformForRelationalDBWithCsn(inputCsn, options, 'to.rename');
+  // forRelationalDB looses empty contexts and services, add them again so that toRename can calculate the namespaces
   forEachDefinition(csn, (artifact, artifactName) => {
     if ((artifact.kind === 'context' || artifact.kind === 'service') && csn.definitions[artifactName] === undefined)
       csn.definitions[artifactName] = artifact;

package/lib/render/toSql.js

@@ -325,7 +325,7 @@ function toSqlDdl(csn, options) {
   }
 
   // add `ALTER TABLE ADD CONSTRAINT` statements per default for `to.sql` w/ dialect `hana`
-  if (!options.constraintsInCreateTable && options.src === 'sql' && options.sqlDialect === 'hana') {
+  if (!options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres')) {
     const alterStmts = manageConstraints(csn, options);
 
     for ( const constraintName of Object.keys(alterStmts))
@@ -352,7 +352,7 @@ function toSqlDdl(csn, options) {
    * @param {object} env Render environment
    */
   function renderArtifactInto(artifactName, art, resultObj, env) {
-    // Ignore whole artifacts if forHana says so
+    // Ignore whole artifacts if forRelationalDB says so
     if (art.abstract || hasValidSkipOrExists(art))
       return;
 
@@ -605,8 +605,8 @@ function toSqlDdl(csn, options) {
     if (primaryKeys !== '')
       result += `,\n${childEnv.indent}${primaryKeys}`;
 
-    // for `to.sql` w/ dialect `hana` the constraints will be part of the
-    const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && options.sqlDialect === 'hana';
+    // for `to.sql` w/ dialect `hana` the constraints will be part of the alter statement
+    const constraintsAsAlter = !options.constraintsInCreateTable && options.src === 'sql' && (options.sqlDialect === 'hana' || options.sqlDialect === 'postgres');
     if ( !constraintsAsAlter && art.$tableConstraints && art.$tableConstraints.referential) {
       const renderReferentialConstraintsAsHdbconstraint = options.src === 'hdi';
       const referentialConstraints = {};
@@ -1507,7 +1507,7 @@ function toSqlDdl(csn, options) {
           case 'hana':
             return 'CURRENT_TIMESTAMP';
           case 'postgres':
-            return 'current_timestamp';
+            return '(current_timestamp at time zone \'UTC\')';
           default:
             return quoteSqlId(x.ref[0]);
         }
@@ -1534,12 +1534,16 @@ function toSqlDdl(csn, options) {
       if (x.ref[1] === 'id') {
         if (options.sqlDialect === 'hana')
           return 'SESSION_CONTEXT(\'APPLICATIONUSER\')';
+        else if (options.sqlDialect === 'postgres')
+          return 'current_setting(\'CAP.APPLICATIONUSER\')';
         warning(null, null, 'The "$user" variable is not supported. Use option "variableReplacements" to specify a value for "$user.id"');
         return '\'$user.id\'';
       }
       else if (x.ref[1] === 'locale') {
         if (options.sqlDialect === 'hana')
           return 'SESSION_CONTEXT(\'LOCALE\')';
+        else if (options.sqlDialect === 'postgres')
+          return 'current_setting(\'CAP.LOCALE\')';
         return '\'en\''; // default language
       }
       // Basically: Second path step was invalid, do nothing - should not happen.
@@ -1567,6 +1571,7 @@ function toSqlDdl(csn, options) {
           case 'hana':
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-FROM\'))';
           case 'postgres':
+            return '(to_timestamp(current_setting(\'CAP.VALID_FROM\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
           case 'plain':
             return 'current_timestamp';
           default:
@@ -1584,6 +1589,7 @@ function toSqlDdl(csn, options) {
           case 'hana':
             return 'TO_TIMESTAMP(SESSION_CONTEXT(\'VALID-TO\'))';
           case 'postgres':
+            return '(to_timestamp(current_setting(\'CAP.VALID_TO\'), \'YYYY-MM-DD HH24:MI:SS.FF6\') at time zone \'UTC\')';
           case 'plain':
             return 'current_timestamp';
           default:

package/lib/render/utils/common.js

@@ -242,6 +242,10 @@ const cdsToSqlTypes = {
     'cds.DecimalFloat': 'DECIMAL',
     'cds.Integer64': 'BIGINT',
     'cds.Integer': 'INTEGER',
+    'cds.Int64': 'BIGINT',
+    'cds.Int32': 'INTEGER',
+    'cds.Int16': 'SMALLINT',
+    'cds.UInt8': 'TINYINT',
     'cds.hana.SMALLINT': 'SMALLINT',
     'cds.hana.TINYINT': 'TINYINT', // not a Standard SQL type
     'cds.Double': 'DOUBLE',
@@ -280,19 +284,25 @@ const cdsToSqlTypes = {
     'cds.hana.SMALLDECIMAL': 'DECIMAL',
   },
   postgres: {
-    // TODO: Type mapping for binary types is not correct, yet.
-    // We can't use text types for binary on PostgreSQL due to NUL!
+    // See <https://www.postgresql.org/docs/current/datatype.html>
     'cds.String': 'VARCHAR',
-    'cds.LargeString': 'text',
-    'cds.hana.CLOB': 'text',
-    'cds.LargeBinary': 'bytea',
-    'cds.Binary': 'bytea',
-    'cds.hana.BINARY': 'bytea',
-    'cds.Double': 'double precision',
-    'cds.hana.TINYINT': 'INTEGER',
+    'cds.LargeString': 'TEXT',
+    'cds.LargeBinary': 'BYTEA',
+    'cds.Binary': 'BYTEA',
+    'cds.Double': 'FLOAT8',
+    'cds.UInt8': 'INTEGER', // Not equivalent
   },
 };
 
+// Type mapping from cds type names to HDBCDS type names:
+// Only those types, that need mapping, are listed.
+const cdsToHdbcdsTypes = {
+  'cds.UInt8': 'cds.hana.TINYINT',
+  'cds.Int16': 'cds.hana.SMALLINT',
+  'cds.Int32': 'cds.Integer',
+  'cds.Int64': 'cds.Integer64',
+};
+
 /**
  * Get the element matching the column
  *
@@ -521,6 +531,7 @@ module.exports = {
   addIntermediateContexts,
   addContextMarkers,
   cdsToSqlTypes,
+  cdsToHdbcdsTypes,
   hasHanaComment,
   getHanaComment,
   findElement,

package/lib/render/utils/sql.js

@@ -43,8 +43,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
                                 options.src === 'hdi' ||
                                 (options.manageConstraints && options.manageConstraints.src === 'hdi');
 
-  const { sqlMapping } = options;
-  const forSqlite = options.sqlDialect === 'sqlite';
+  const { sqlMapping, sqlDialect } = options;
   let result = '';
   result += `${indent}CONSTRAINT ${quoteId(constraint.identifier)}\n`;
   if (renderAsHdbconstraint)
@@ -55,7 +54,7 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     const onDeleteRemark = constraint.onDeleteRemark ? ` -- ${constraint.onDeleteRemark}` : '';
 
     // omit 'RESTRICT' action for ON UPDATE / ON DELETE, because it interferes with deferred constraint check
-    if (forSqlite) {
+    if (sqlDialect === 'sqlite') {
       if (constraint.onDelete === 'CASCADE' )
         result += `${indent}ON DELETE ${constraint.onDelete}${onDeleteRemark}\n`;
     }
@@ -65,13 +64,14 @@ function renderReferentialConstraint(constraint, indent, toUpperCase, csn, optio
     }
   }
   // constraint enforcement / validation must be switched off using sqlite pragma statement
+  // constraint enforcement / validation not supported by postgres
   // Does not include HDBCDS.
-  if (options.toSql && !forSqlite) {
+  if (options.toSql && sqlDialect !== 'sqlite' && sqlDialect !== 'postgres') {
     result += `${indent}${!constraint.validated ? 'NOT ' : ''}VALIDATED\n`;
     result += `${indent}${!constraint.enforced ? 'NOT ' : ''}ENFORCED\n`;
   }
   // for sqlite, the DEFERRABLE keyword is required
-  result += `${indent}${forSqlite ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
+  result += `${indent}${sqlDialect === 'sqlite' ? 'DEFERRABLE ' : ''}INITIALLY DEFERRED`;
   return result;
 }
 

package/lib/transform/db/applyTransformations.js

@@ -35,10 +35,16 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
   };
 
   const csnPath = [ ...path ];
-  if (prop === 'definitions')
+  if (prop === 'definitions') {
     definitions( parent, 'definitions', parent.definitions );
-  else
+  }
+  else if (options.directDict) {
+    for (const name of Object.getOwnPropertyNames( parent ))
+      standard( parent, name, parent[name] );
+  }
+  else {
     standard(parent, prop, parent[prop]);
+  }
   return parent;
 
   /**
@@ -84,7 +90,7 @@ function applyTransformationsInternal(parent, prop, customTransformers, artifact
    * @param {object} dict The value of node[_prop]
    */
   function dictionary( node, _prop, dict ) {
-    // Allow skipping dicts like actions in forHanaNew
+    // Allow skipping dicts like actions in forRelationalDB
     if (options.skipDict && options.skipDict[_prop] || dict === null || dict === undefined) // with universal CSN, dicts might be null
       return;
     csnPath.push( _prop );
@@ -194,9 +200,31 @@ function applyTransformationsOnNonDictionary(parent, prop, customTransformers =
   return applyTransformationsInternal(parent, prop, customTransformers, [], options, path)[prop];
 }
 
+/**
+ * Instead of looping through the whole model, start at a given thing (like .elements),
+ * as long as it is a dictionary.
+ *
+ * Each transformer gets:
+ * - the parent having the property
+ * - the name of the property
+ * - the value of the property
+ * - the path to the property
+ *
+ *
+ * @param {object} dictionary Dictionary to enrich in-place
+ * @param {object} customTransformers Map of prop to transform and function to apply
+ * @param {applyTransformationsOptions} [options={}]
+ * @param {CSN.Path} path Path pointing to parent
+ * @returns {object} dictionary with transformations applied
+ */
+function applyTransformationsOnDictionary(dictionary, customTransformers = {}, options = {}, path = []) {
+  return applyTransformationsInternal(dictionary, null, customTransformers, [], { directDict: true, ...options }, path);
+}
+
 module.exports = {
   applyTransformations,
   applyTransformationsOnNonDictionary,
+  applyTransformationsOnDictionary,
 };
 
 
@@ -209,4 +237,5 @@ module.exports = {
  * @property {object} [skipStandard] stop drill-down on certain "standard" props
  * @property {object} [skipDict] stop drill-down on certain "dictionary" props
  * @property {boolean} [skipIgnore=true] Whether to skip _ignore elements or not
+ * @property {boolean} [directDict=false] Implicitly set via applyTransformationsOnDictionary
  */

package/lib/transform/db/expansion.js

@@ -7,7 +7,7 @@ const {
   walkCsnPath,
 } = require('../../model/csnUtils');
 const { csnRefs, implicitAs } = require('../../model/csnRefs');
-const { setProp, isBetaEnabled } = require('../../base/model');
+const { setProp } = require('../../base/model');
 const { forEach } = require('../../utils/objectUtils');
 
 /**
@@ -26,12 +26,11 @@ const { forEach } = require('../../utils/objectUtils');
 function expandStructureReferences(csn, options, pathDelimiter, { error, info, throwWithAnyError }, iterateOptions = {}) {
   const csnUtils = getUtils(csn);
   const {
-    isStructured, get$combined, getFinalBaseTypeWithProps, getServiceName,
+    isStructured, get$combined, getFinalBaseTypeWithProps,
   } = csnUtils;
   let { effectiveType, inspectRef } = csnUtils;
 
-  if (isBetaEnabled(options, 'nestedProjections'))
-    rewriteExpandInline();
+  rewriteExpandInline();
 
 
   applyTransformations(csn, {
@@ -83,8 +82,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
           */
           if (rewritten.toMany.length > 0 && !options.toOdata) {
             markAsToDummyfy(artifact, path[1]);
-            if (getServiceName(path[1]) === null)
-              error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME), which is outside any service');
+            error( null, [ 'definitions', path[1] ], { name: path[1] }, 'Unexpected .expand with to-many association in entity $(NAME)');
           }
           else {
             parent.columns = rewritten.columns;
@@ -347,14 +345,18 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
         }
         else if (current.xpr || current.args) {
           // We need to re-write refs in the .xpr/.args so they stay resolvable - we need to prepend the currentRef
-          rewriteXprArgs(current, currentRef);
+          rewriteExpressionArrays(current, currentRef);
           expanded.push(Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } ));
         }
+        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) } ));
+        }
         else if (current.val !== undefined || current.func !== undefined) {
           expanded.push(Object.assign(current, { as: currentAlias.join(pathDelimiter) }));
         }
-        else {
-          expanded.push({ ref: currentRef, as: currentAlias.join(pathDelimiter) });
+        else { // preserve stuff like .cast for redirection
+          expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
         }
       }
 
@@ -367,37 +369,79 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      * @param {object} parent Thing that has an .xpr/.args
      * @param {string[]} ref Ref so far
      */
-    function rewriteXprArgs(parent, ref) {
+    function rewriteExpressionArrays(parent, ref) {
       const stack = [ [ parent, ref ] ];
       while (stack.length > 0) {
         const [ current, currentRef ] = stack.pop();
-        if (current.xpr) {
-          for (let i = 0; i < current.xpr.length; i++) {
-            const part = current.xpr[i];
-            if (part.ref) {
-              part.ref = currentRef.concat(part.ref);
-              // part.as = currentAlias.concat(part.as || part.ref[ref.length - 1]).join(pathDelimiter);
-              current.xpr[i] = part;
-              stack.push([ part, part.ref ]);
-            }
-            else {
-              stack.push([ part, currentRef ]);
-            }
-          }
+        if (current.xpr)
+          rewriteSingleExpressionArray(current.xpr, currentRef, stack);
+        if (current.args)
+          rewriteSingleExpressionArray(current.args, currentRef, stack);
+      }
+    }
+
+    /**
+     * With a .cast.on  or .on in a .expand/.inline, we need to change the references,
+     * since we change the overall scope of things (by "heaving" them up into "normal refs").
+     *
+     * So anything that does not have a $self/$projection infron get's the so-far-traveled alias,
+     * since after the transformation it will basically be in "top-level".
+     *
+     * @param {object} parent
+     * @param {Array} ref The so-far effective name (basically the will-be alias), as an array to treat like a ref
+     */
+    function rewriteOn(parent, ref) {
+      const stack = [ [ parent, ref ] ];
+      while (stack.length > 0) {
+        const [ current, currentRef ] = stack.pop();
+        if (current.on)
+          rewriteOnCondition(current.on, currentRef, stack);
+        if (current.cast?.on)
+          rewriteOnCondition(current.cast.on, currentRef, stack);
+      }
+    }
+
+    /**
+     * Actually rewrite the given oncondition. Once we find something to rewrite,
+     * we preprend the currentRef.
+     *
+     * All stuff is pushed to the stack.
+     *
+     * @param {Array} on
+     * @param {Array} currentRef
+     * @param {Array} stack
+     */
+    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') {
+          part.ref = currentRef[0] ? [ currentRef[0], ...part.ref ] : part.ref;
+          on[i] = part;
+          stack.push([ part, part.ref ]);
         }
-        if (current.args) {
-          for (let i = 0; i < current.args.length; i++) {
-            const part = current.args[i];
-            if (part.ref) {
-              part.ref = currentRef.concat(part.ref);
-              // part.as = currentAlias.concat(part.as || part.ref[ref.length - 1]).join(pathDelimiter);
-              current.args[i] = part;
-              stack.push([ part, part.ref ]);
-            }
-            else {
-              stack.push([ part, currentRef ]);
-            }
-          }
+        else {
+          stack.push([ part, currentRef ]);
+        }
+      }
+    }
+
+    /**
+     * Rewrite the given expressionArray, prefixing currentRef to all refs
+     *
+     * @param {Array} expressionArray
+     * @param {Array} currentRef
+     * @param {Array} stack
+     */
+    function rewriteSingleExpressionArray(expressionArray, currentRef, stack) {
+      for (let i = 0; i < expressionArray.length; i++) {
+        const part = expressionArray[i];
+        if (part.ref) {
+          part.ref = currentRef.concat(part.ref);
+          expressionArray[i] = part;
+          stack.push([ part, part.ref ]);
+        }
+        else {
+          stack.push([ part, currentRef ]);
         }
       }
     }
@@ -409,7 +453,7 @@ function expandStructureReferences(csn, options, pathDelimiter, { error, info, t
      */
     function findAnEntity() {
       for (const name in csn.definitions) {
-        if (Object.hasOwnProperty.call(csn.definitions, name) && csn.definitions[name].kind === 'entity' && !csn.definitions[name].query)
+        if (Object.prototype.hasOwnProperty.call(csn.definitions, name) && csn.definitions[name].kind === 'entity' && !csn.definitions[name].query)
           return name;
       }
       return null;