@sap/cds-compiler 4.3.2 → 4.4.2

package/lib/transform/effective/associations.js

@@ -3,7 +3,7 @@
 const { setProp } = require('../../base/model');
 const flattening = require('../db/flattening');
 const {
-  applyTransformations, forEachDefinition, forEachMemberRecursively, implicitAs, cloneCsnNonDict,
+  applyTransformations, forEachDefinition, forEachMemberRecursively, implicitAs, cloneCsnNonDict, forEachMember, applyTransformationsOnNonDictionary,
 } = require('../../model/csnUtils');
 const associations = require('../db/associations');
 const backlinks = require('../db/backlinks');
@@ -33,31 +33,62 @@ function turnAssociationsIntoUnmanaged( csn, options, csnUtils, { error, warning
     }, [ 'definitions', artifactName ]);
   });
   // Flatten out the fks and create the corresponding elements
-  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', true, csnUtils, { allowArtifact: a => a.kind === 'entity' });
+  flattening.handleManagedAssociationsAndCreateForeignKeys(csn, options, error, warning, '_', true, csnUtils, { allowArtifact: () => true, skipDict: {} });
 
   // Add the foreign keys also to the columns if the association itself was explicitly selected
   // TODO: Extend the expansion to also expand managed to their foreign
   // TODO: Remember where in .elements we had associations and do it then?
   applyTransformations(csn, {
-    columns: (parent, prop, columns) => {
-      const newColumns = [];
-      for (const col of columns) {
-        newColumns.push(col);
-        const element = csnUtils.getElement(col);
-        if (element && element.keys)
-          element.keys.forEach(fk => addForeignKeyToColumns(fk, newColumns, col, options));
-      }
-      parent.columns = newColumns;
-    },
-  }, [], { allowArtifact: artifact => artifact.kind === 'entity' });
+    columns: expandManagedToFksInArray(),
+    groupBy: expandManagedToFksInArray(true),
+    orderBy: expandManagedToFksInArray(true),
+  }, [], { allowArtifact: artifact => artifact.query !== undefined || artifact.projection !== undefined });
 
-  forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_'));
+  forEachDefinition(csn, associations.getFKAccessFinalizer(csn, csnUtils, '_', true));
+  applyTransformations(csn, {
+    elements: (_parent, prop, elements, path) => {
+      forEachMember(_parent, (element, elementName, _prop, elPath) => {
+        if (element.on) {
+          applyTransformationsOnNonDictionary(element, 'on', {
+            ref: (parent, __prop, ref) => {
+              if (ref[0] === '$self' && ref.length > 1 && !ref[1].startsWith('$')) // TODO: Is this safe?
+                parent.ref = ref.slice(1);
+            },
+          }, {}, elPath);
+        }
+      }, path);
+    },
+  });
   // Calculate the on-conditions from the .keys -
-  associations.attachOnConditions(csn, csnUtils, '_');
+  associations.attachOnConditions(csn, csnUtils, '_', { allowArtifact: () => true }, options);
 
   return csn;
+
+  /**
+   * Expand managed associations in an array and insert them in-place
+   *
+   * If requested, leave out the assocs themselves
+   *
+   * @param {boolean} [killAssoc=false]
+   * @returns {Function} applyTransformationsCallback
+   */
+  function expandManagedToFksInArray( killAssoc = false ) {
+    return function expand(parent, prop, array, path) {
+      const newColumns = [];
+      for (let i = 0; i < array.length; i++) {
+        const col = array[i];
+        const element = csnUtils.getElement(col) || col.ref && csnUtils.inspectRef(path.concat(prop, i)).art;
+        if (!killAssoc || !element?.keys)
+          newColumns.push(col);
+        if (element?.keys)
+          element.keys.forEach(fk => addForeignKeyToColumns(fk, newColumns, col, options));
+      }
+      parent[prop] = newColumns;
+    };
+  }
 }
 
+
 /**
  * FKs need to be added to the .columns
  * @todo stolen from lib/transform/db/views.js

package/lib/transform/effective/main.js

@@ -34,6 +34,8 @@ function effectiveCsn( model, options ) {
 
   const csn = cloneCsnNonDict(model, options);
 
+  delete csn.vocabularies; // must not be set for effective CSN
+
   const { expandStructsInExpression } = transformUtils.getTransformers(csn, options, '_');
   queries.projectionToSELECTAndAddColumns(csn);
 
@@ -58,11 +60,11 @@ function effectiveCsn( model, options ) {
 
   messageFunctions.throwWithAnyError();
 
-  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils);
-
   // Expand a structured thing in: keys, columns, order by, group by
   expansion.expandStructureReferences(csn, options, '_', messageFunctions, csnUtils);
 
+  const resolveTypesInActionsAfterFlattening = types.resolve(csn, csnUtils);
+
   csnUtils = getUtils(csn, 'init-all');
 
   // Remove properties attached by validator - they do not "grow" as the model grows.
@@ -73,6 +75,9 @@ function effectiveCsn( model, options ) {
 
   resolveTypesInActionsAfterFlattening();
 
+  // ensure getElement works on flattened struct_assoc columns
+  csnUtils = getUtils(csn, 'init-all');
+
   processCalculatedElementsInEntities(csn);
   associations.managedToUnmanaged(csn, options, csnUtils, messageFunctions);
   associations.transformBacklinks(csn, options, csnUtils, messageFunctions);

package/lib/transform/effective/misc.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  forEachDefinition, forEachMemberRecursively, getArtifactDatabaseNameOf, getElementDatabaseNameOf, forEachMember,
+  forEachDefinition, forEachMemberRecursively, getArtifactDatabaseNameOf, getElementDatabaseNameOf, applyTransformations,
 } = require('../../model/csnUtils');
 /**
  * Attach @cds.persistence.name to all artifacts and "things".
@@ -14,16 +14,21 @@ function attachPersistenceName( csn, options, csnUtils ) {
   const { addStringAnnotationTo } = csnUtils;
 
   forEachDefinition(csn, (artifact, artifactName) => {
-    if (artifact.kind === 'entity') {
-      addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
+    addStringAnnotationTo('@cds.persistence.name', getArtifactDatabaseNameOf(artifactName, options.sqlMapping, csn, options.sqlDialect), artifact);
 
-      forEachMemberRecursively(artifact, (member, memberName) => addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member), [ 'definitions', artifactName ]);
-    }
+    forEachMemberRecursively(artifact, (member, memberName) => addStringAnnotationTo('@cds.persistence.name', getElementDatabaseNameOf(memberName, options.sqlMapping, options.sqlDialect), member), [ 'definitions', artifactName ]);
   });
 }
 
-const artifactPropertiesToRemove = [ 'includes' ];
-const memberPropertiesToRemove = [ 'localized', 'enum', 'keys' ];
+/**
+ * Delete the given prop from parent.
+ *
+ * @param {object} parent
+ * @param {string|number} prop
+ */
+function killProp( parent, prop ) {
+  delete parent[prop];
+}
 
 /**
  * Remove definitions from the CSN:
@@ -36,26 +41,40 @@ const memberPropertiesToRemove = [ 'localized', 'enum', 'keys' ];
  * @param {CSN.Model} csn
  * @todo Callback-like architecture and merge with persistence name?
  */
-function removeDefinitionsAndProperties( csn ) {
-  forEachDefinition(csn, (artifact, artifactName) => {
-    if (artifact.kind === 'aspect' || artifact.kind === 'type') {
-      delete csn.definitions[artifactName];
-    }
-    else {
-      if (artifact['@cds.persistence.skip'] === 'if-unused')
+function _removeDefinitionsAndProperties( csn ) {
+  const killers = {
+    $ignore: (a, b, c, path, parentParent) => {
+      const tail = path[path.length - 1];
+      delete parentParent[tail];
+    },
+    kind: (artifact, a, b, path) => {
+      if (artifact.kind === 'aspect' || artifact.kind === 'type')
+        delete csn.definitions[path[1]];
+
+      else if (artifact['@cds.persistence.skip'] === 'if-unused')
         artifact['@cds.persistence.skip'] = false;
-      for (const prop of artifactPropertiesToRemove)
-        delete artifact[prop];
-
-      forEachMember(artifact, (member) => {
-        for (const prop of memberPropertiesToRemove)
-          delete member[prop];
-      });
-    }
-  });
+    },
+    // Still used in flattenStructuredElements - in db/flattening.js
+    _flatElementNameWithDots: killProp,
+    // Set when setting default string/binary length - used in copyTypeProperties and fixBorkedElementsOfLocalized
+    // to not copy the .length property if it was only set via default
+    $default: killProp,
+    // Set when we turn UUID into String, checked during generateDraftForHana
+    $renamed: killProp,
+    // Set when we remove .key from temporal things, used in localized.js
+    $key: killProp,
+    includes: killProp,
+    localized: killProp,
+    enum: killProp,
+    keys: killProp,
+    excluding: killProp, // * is resolved, so has no effect anymore
+  };
+
+  applyTransformations(csn, killers, [], { skipIgnore: false });
 }
 
+
 module.exports = {
   attachPersistenceName,
-  removeDefinitionsAndProperties,
+  removeDefinitionsAndProperties: _removeDefinitionsAndProperties,
 };

package/lib/transform/effective/queries.js

@@ -11,28 +11,26 @@ const { forEachDefinition, applyTransformationsOnNonDictionary } = require('../.
 function projectionToSELECTAndAddColumns( csn ) {
   const redoProjections = [];
   forEachDefinition(csn, (artifact) => {
-    if (artifact.kind === 'entity') {
-      if (artifact.projection) {
-        if (!artifact.projection.columns)
-          artifact.projection.columns = [ '*' ];
-        artifact.query = { SELECT: artifact.projection };
-        delete artifact.projection;
-        redoProjections.push(() => {
-          if (artifact.query) {
-            artifact.projection = artifact.query.SELECT;
-            delete artifact.query;
-            if (artifact.$syntax === 'projection')
-              delete artifact.$syntax;
-          }
-        });
-      }
-      else if (artifact.query) {
-        applyTransformationsOnNonDictionary(artifact, 'query', {
-          SELECT: (parent, prop, SELECT) => {
-            SELECT.columns ??= [ '*' ];
-          },
-        });
-      }
+    if (artifact.projection) {
+      if (!artifact.projection.columns)
+        artifact.projection.columns = [ '*' ];
+      artifact.query = { SELECT: artifact.projection };
+      delete artifact.projection;
+      redoProjections.push(() => {
+        if (artifact.query) {
+          artifact.projection = artifact.query.SELECT;
+          delete artifact.query;
+          if (artifact.$syntax === 'projection')
+            delete artifact.$syntax;
+        }
+      });
+    }
+    else if (artifact.query) {
+      applyTransformationsOnNonDictionary(artifact, 'query', {
+        SELECT: (parent, prop, SELECT) => {
+          SELECT.columns ??= [ '*' ];
+        },
+      });
     }
   });
 

package/lib/transform/effective/types.js

@@ -3,6 +3,7 @@
 const {
   cloneCsnNonDict, applyTransformations, applyTransformationsOnNonDictionary, cloneCsnDictionary, applyTransformationsOnDictionary,
 } = require('../../model/csnUtils');
+const { forEachKey } = require('../../utils/objectUtils');
 
 /**
  * Resolve all references to structured types in entities to the underlying elements.
@@ -33,7 +34,7 @@ function resolveTypes( csn, csnUtils ) {
       later.push({ [artifactName]: artifact });
     else if (artifact.actions)
       later.push(artifact.actions);
-  } ], { skipDict: { actions: true } });
+  } ], { skipDict: { actions: true }, processAnnotations: true });
 
   return function resolveTypesInActions() {
     later.forEach(action => applyTransformationsOnDictionary(action, { type: parent => resolveType(parent) }));
@@ -64,7 +65,10 @@ function resolveTypes( csn, csnUtils ) {
       delete parent.type;
     }
     else if (final?.type) {
-      parent.type = final.type;
+      forEachKey(final, (key) => { // copy `type` + properties (default, etc.)
+        if (parent[key] === undefined || key === 'type')
+          parent[key] = final[key];
+      });
     }
 
     // Drill down - there might be other type references

package/lib/transform/forOdata.js

@@ -98,7 +98,9 @@ function transform4odataWithCsn(inputModel, options) {
     inspectRef,
     artifactRef,
     effectiveType,
-    getFinalTypeInfo
+    getFinalTypeInfo,
+    dropDefinitionCache,
+    initDefinition,
   } = csnUtils;
 
   // are we working with structured OData or not
@@ -147,6 +149,8 @@ function transform4odataWithCsn(inputModel, options) {
       // TODO: handle artifact.projection instead of artifact.query correctly in future V2
       if (def.kind === 'entity' && def.projection) {
         def.query = { SELECT: def.projection };
+        dropDefinitionCache(def);
+        initDefinition(def);
       }
     }],
     { skipArtifact: isExternalServiceMember }
@@ -161,12 +165,17 @@ function transform4odataWithCsn(inputModel, options) {
   // rendering which may has to publish external definitions
   expandToFinalBaseType(csn, transformers, csnUtils, services, options);
 
+  // - Generate artificial draft fields on a structured CSN if requested, flattening and struct
+  //   expansion do their magic including foreign key generation and annotation propagation.
+  generateDrafts(csn, options, services);
+
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
   // If errors are detected, throwWithAnyError() will return from further processing
   expandStructsInExpression(csn, { skipArtifact: isExternalServiceMember, drillRef: true });
 
+  
   if (!structuredOData) {
     expansion.expandStructureReferences(csn, options, '_', { error, info, throwWithAnyError }, csnUtils, { skipArtifact: isExternalServiceMember });
     const resolved = new WeakMap();
@@ -211,7 +220,6 @@ function transform4odataWithCsn(inputModel, options) {
   forEachDefinition(csn, [ setDefaultTypeFacets, processOnCond ], { skipArtifact: isExternalServiceMember });
 
   // Now all artificially generated things are in place
-  // - Generate artificial draft fields if requested
   // TODO: should be done by the compiler - Check associations for valid foreign keys
   // TODO: check if needed at all: Remove '$projection' from paths in the element's ON-condition
   // - Check associations for:
@@ -219,7 +227,6 @@ function transform4odataWithCsn(inputModel, options) {
   //        - structured types must not contain associations for OData V2
   // - Element must not be an 'array of' for OData V2 TODO: move to the validator
   // - Perform checks for exposed non-abstract entities and views - check media type and key-ness
-  generateDrafts(csn, options, services)
 
   // Deal with all kind of annotations manipulations here
   const skipPersNameKinds = {'service':1, 'context':1, 'namespace':1, 'annotation':1, 'action':1, 'function':1};

package/lib/transform/localized.js

@@ -648,7 +648,7 @@ function _addLocalizationViews(csn, options, config) {
       filter: (name) => name.startsWith('localized.'),
       notFound(name, index) {
         if (!ignoreUnknownExtensions) {
-          messageFunctions.message('anno-undefined-art', [ 'extensions', index ],
+          messageFunctions.message('ext-undefined-def', [ 'extensions', index ],
                                    { art: name });
         }
       },

package/lib/transform/parseExpr.js

@@ -34,12 +34,13 @@
  *
  * @param {any} xpr A JSON object.
  * @param {Object} state Object
- *  anno: Don't eliminate arrays with single entry in statetations (TODO?) as they are collections
+ *  anno: Don't eliminate arrays with single entry in expressions (TODO?) as they are collections
  *  array: Bias AST representation.
  *  nary: return n-ary or binary tree
  */
 
-function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
+function parseExpr(xpr, state = { array: true, nary: false }) {
+  state.anno = 0;
   // Notes:
   //  - Variables `s` and `e` are used as index variables into `xpr`s for start and end.
   //  - xpr's are our CSN expressions, see <https://cap.cloud.sap/docs/cds/cxn>
@@ -47,7 +48,28 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   return parseExprInt(xpr, state);
 
   function parseExprInt(xpr, state) {
-    return conditionOR(...CaseWhen(xpr), state);
+    return conditionOR(...CaseWhen(Cast(xpr, state)), state);
+  }
+
+  function Cast(xpr, state) {
+    if(xpr != null && !state.array) {
+      if(Array.isArray(xpr))
+        return xpr.map(x => Cast(x, state));
+      if(typeof xpr === 'object') {
+        const castKeys = Object.keys(xpr).filter(k => k !== 'cast');
+        if(xpr.cast != null && castKeys.length === 1) {
+          return { 'cast': [ xpr.cast, { [castKeys[0]]: xpr[castKeys[0]] } ] };
+        }
+        else {
+          for(let n in xpr) {
+            // xpr could be an array with polluted prototype
+            if (Object.hasOwnProperty.call(xpr, n))
+              xpr[n] = Cast(xpr[n], state)
+          }
+        }
+      }
+    }
+    return xpr;
   }
 
   function CaseWhen(xpr) {
@@ -95,11 +117,11 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
 
       while(xpr[whenPos] !== 'when' && whenPos < endPos) whenPos++;
       if(xpr[whenPos] === 'when' && whenPos - (casePos+1) >= 1) {
-        const arg = xpr.slice(casePos+1, whenPos)
+        const caseExpr = xpr.slice(casePos+1, whenPos)
         if(state.array)
-          caseTree.push(arg);
+          caseTree.push(caseExpr);
         else
-            caseTree.case.push(arg);
+          caseTree.case.push(caseExpr.length === 1 ? caseExpr[0] : caseExpr);
       }
 
       while(xpr[whenPos] === 'when') {
@@ -112,11 +134,11 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
         let thenPos = whenPos+1;
         while(xpr[thenPos] !== 'then' && thenPos < endPos) thenPos++;
         if(xpr[thenPos] === 'then') {
-          const when = xpr.slice(whenPos+1, thenPos);
+          const whenExpr = xpr.slice(whenPos+1, thenPos);
           if(state.array)
-            caseTree.push(when);
+            caseTree.push(whenExpr);
           else
-            when.when.push(when.length === 1 ? when[0] : when);
+            when.when.push(whenExpr.length === 1 ? whenExpr[0] : whenExpr);
         }
 
         whenPos = thenPos+1;
@@ -188,17 +210,19 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   function compareTerm(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
       let i = s;
+      let not = false;
+      let between;
       while(i < e && xpr[i] !== 'between') i++;
       const b = i < e ? i : -1;
       while(i < e && xpr[i] !== 'and') i++;
       const a = i < e ? i : -1;
       if(b >= 0) {
         let token = [ 'between' ];
-        const not = (xpr[b-1] === 'not');
+        not = (xpr[b-1] === 'not');
         if(not)
           token.splice(0,0, 'not');
         const expr = expression(xpr, s, not ? b-1 : b, state);
-        const between = state.array
+        between = state.array
           ? [ expr, ...token ]
           : { 'between': [ expr ] };
         if(a >= 0) {
@@ -217,6 +241,9 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
           else
             between.between.push(unspec);
         }
+        if(not && !state.array) {
+          between = { 'not': between }
+        }
         return between;
       }
     }
@@ -263,7 +290,10 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   function unary(xpr, s, e, state) {
     if(Array.isArray(xpr)) {
       if(xpr[s] === '+' || xpr[s] === '-' || (!state.array && xpr[s] === 'new')) {
-        return [ xpr[s], unary(xpr, s+1, e, state) ];
+        if(state.array)
+          return [ xpr[s], unary(xpr, s+1, e, state) ];
+        else
+          return { [xpr[s]]: unary(xpr, s+1, e, state) };
       }
     }
     return terminal(xpr, s, e, state);
@@ -277,7 +307,7 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
       'xpr', 'on', 'where', 'orderBy', 'groupBy', 'having' ];
 
     if(Array.isArray(xpr) && xpr.length > 0) {
-      if(e-s <= 1 && state.anno === 0)
+      if(e-s <= 1 && state.anno === 0  && typeof xpr[e-1] !== 'string')
         return parseExprInt(xpr[e-1], state);
       else
         return xpr.slice(s, e).map(ix => parseExprInt(ix, state));
@@ -311,28 +341,50 @@ function parseExpr(xpr, state = { anno: 0, array: true, nary: false }) {
   }
 
   function binaryExpr(xpr, token, next, s, e, state) {
-    const expr = [];
+    const naryExpr = [];
+    let not = false;
     if (Array.isArray(xpr)) {
       let [tl, p] = findToken(s, e);
       if (p >= 0) {
         let lhs = next(xpr, s, p, state);
-        expr.push(lhs);
+        naryExpr.push(lhs);
         let op = xpr.slice(p, p+tl);
         s = p+tl;
         [tl, p] = findToken(s, e);
         while(p >= 0) {
           let rhs = next(xpr, s, p, state);
-          expr.push(...op, rhs);
-          lhs = state.array ? [ lhs, ...op, rhs ] : { [op.join('')]: [lhs, rhs] };
+          naryExpr.push(...op, rhs);
+          if(state.array)
+            lhs = [ lhs, ...op, rhs ];
+          else {
+            not = op.length > 1 && op[0] === 'not';
+            if(not)
+              op = op.slice(1);
+            lhs = (not
+                ? { 'not': { [op.join('')]: [lhs, rhs] } }
+                : { [op.join('')]: [lhs, rhs] });
+          }
           op = xpr.slice(p, p+tl);
           s = p+tl;
           [tl, p] = findToken(s, e);
         }
-        expr.push(...op, next(xpr, s, e, state));
+
+        let rhs = next(xpr, s, e, state);
+        if(Array.isArray(rhs) && rhs.length === 0)
+          rhs = undefined;
+        naryExpr.push(...op, rhs);
+
         if (state.array)
-          return (state.nary ? expr : [ lhs, ...op, next(xpr, s, e, state) ])
-        else
-          return { [op.join('')]: [lhs, next(xpr, s, e, state)] };
+          return (state.nary ? naryExpr : [ lhs, ...op, rhs ])
+        else {
+          not = op.length > 1 && op[0] === 'not';
+          if(not)
+            op = op.slice(1);
+          return (not
+            ? { 'not': { [op.join('')]: [ lhs, rhs ] } }
+            : { [op.join('')]: [ lhs, rhs ] });
+
+        }
       }
     }
     return next(xpr, s, e, state);

package/lib/transform/translateAssocsToJoins.js

@@ -17,7 +17,9 @@ function translateAssocsToJoinsCSN(csn, options){
   // Do not re-complain about localized
   const compileOptions = { ...options, $skipNameCheck: true };
   delete compileOptions.csnFlavor;
-  // console.log('CSN passed by A2J to compiler:',JSON.stringify(csn,null,2))
+
+  //require('fs').writeFileSync('./csninput_a2j.json', JSON.stringify(csn, null,2))
+  //console.log('CSN passed by A2J to compiler:',JSON.stringify(csn,null,2))
   const model = recompileX(csn, compileOptions);
   timetrace.stop('A2J: Recompiling model');
   timetrace.start('A2J: Translating associations to joins');
@@ -48,7 +50,9 @@ function translateAssocsToJoinsCSN(csn, options){
   // If A2J reports error - end! Continuing with a broken CSN makes no sense
   makeMessageFunction(model, options).throwWithAnyError();
   // FIXME: Move this somewhere more appropriate
-  return compactModel(model, compileOptions);
+  const newCsn = compactModel(model, compileOptions);
+  //require('fs').writeFileSync('./csnoutput_a2j.json', JSON.stringify(newCsn, null,2))
+  return newCsn;
 }
 
 function translateAssocsToJoins(model, inputOptions = {})
@@ -444,7 +448,7 @@ function translateAssocsToJoins(model, inputOptions = {})
             {
               // Filter conditions are unique for each JOIN, they don't need to be copied
               let filter = childQat._filter;
-              rewritePathsInExpression(filter, function(pathNode) {
+              rewritePathsInFilterExpression(filter, function(pathNode) {
                 return [ /* tableAlias=> */ constructTableAliasPathStep(childQat.$QA),
                         /* filterPath=> */ pathNode.path ]; // eslint-disable-line indent-legacy
               }, env);
@@ -490,7 +494,7 @@ function translateAssocsToJoins(model, inputOptions = {})
     {
       // Filter conditions are unique for each JOIN, they don't need to be copied
       let filter = assocQAT._filter;
-      rewritePathsInExpression(filter, function(pathNode) {
+      rewritePathsInFilterExpression(filter, function(pathNode) {
         return [ tgtTableAlias, pathNode.path ];
       }, env);
 
@@ -809,8 +813,6 @@ function translateAssocsToJoins(model, inputOptions = {})
         if(rhs.mixin)
         {
           if (hasDollarSelfPrefix) {
-            hasDollarSelfPrefix = true;
-
             /* Do the $projection resolution ONLY in own query not for referenced forward ON condition
             view YP as select from Y mixin ( toXP: association to XP on $projection.yid = toXP.xid; } into { yid };
             view XP as select from X mixin { toYP: association to YP on $self = toYP.toXP; } into { xid, toYP.elt };
@@ -1065,9 +1067,9 @@ function translateAssocsToJoins(model, inputOptions = {})
     tableAlias = [ aliasName, _artifact, _navigation ]
     path = [ { id: ..., _artifact: ... (unused) } ]
   */
-  function rewritePathsInExpression(node, getTableAliasAndPathSteps, env)
+  function rewritePathsInFilterExpression(node, getTableAliasAndPathSteps, env)
   {
-    let innerEnv = {
+    const innerEnv = {
       lead: env.lead,
       location: env.location,
       position: env.position,
@@ -1076,9 +1078,15 @@ function translateAssocsToJoins(model, inputOptions = {})
       callback: [
         function(pathNode) {
           if(checkPathDictionary(pathNode, env)) {
-            let [ tableAlias, path ] = getTableAliasAndPathSteps(pathNode);
-            let pathStr = path.map(ps => ps.id).join(pathDelimiter);
-            replaceNodeContent(pathNode, constructPathNode([ tableAlias, { id: pathStr, _artifact: pathNode._artifact } ]));
+            const head = pathNode.path[0];
+            if(head._navigation?.kind === '$self') {
+              substituteDollarSelf(pathNode);
+            }
+            else {
+              const [ tableAlias, path ] = getTableAliasAndPathSteps(pathNode);
+              const pathStr = path.map(ps => ps.id).join(pathDelimiter);
+              replaceNodeContent(pathNode, constructPathNode([ tableAlias, { id: pathStr, _artifact: pathNode._artifact } ]));
+            }
           }
         } ]
     };
@@ -1317,8 +1325,8 @@ function translateAssocsToJoins(model, inputOptions = {})
     // we need to unambiguously identify the target side with the full assoc prefix.
     // If the path is on the target side, strip the prefix of and treat src/tgt
     // paths uniformly.
-    path = (env.assocStack && env.assocStack.stripAssocPrefix(path) || path);
-    let lead = env.art || env.lead;
+    path = (env.assocStack?.stripAssocPrefix(path) || path);
+    const lead = env.art || env.lead;
     path.forEach((ps) => {
       /* checks for all path steps */
       if(ps.args) {
@@ -1715,6 +1723,7 @@ function constructPathNode(pathSteps, alias, rewritten=true)
           o[k] = p[k];
       });
       setProp(o, '_artifact', p._artifact );
+      setProp(o, '_navigation', p._navigation );
       return o; })
   };
 
@@ -1760,8 +1769,6 @@ function walkQuery(query, env)
       walk(query.having, env);
       env.location = 'OrderBy';
       walk(query.orderBy, env);
-      // outer orderBy's of anonymous union
-      walk(query.$orderBy, env);
       if(query.limit) {
         env.location = 'Limit';
         walk(query.limit.rows, env);

package/lib/utils/term.js

@@ -14,8 +14,8 @@
 
 'use strict';
 
-const stderrHasColor = process.stderr.isTTY;
-const stdoutHasColor = process.stdout.isTTY;
+const stderrHasColor = process.stderr?.isTTY;
+const stdoutHasColor = process.stdout?.isTTY;
 
 // Note: We require both stderr and stdout to be TTYs, as we don't
 //       know (in our exported functions) where the text will end up.