@sap/cds-compiler 5.8.2 → 5.9.0

package/lib/transform/addTenantFields.js

@@ -57,6 +57,8 @@ function addTenantFields( csn, options, messageFunctions ) {
     initDefinition,
     artifactRef,
     effectiveType,
+    queryForElements,
+    $getQueries,
     msgLocations,
   } = csnRefs( csn, true );
 
@@ -100,7 +102,10 @@ function addTenantFields( csn, options, messageFunctions ) {
   // the cache of csnRefs):
   for (const name in definitions) {
     const art = definitions[name];
-    addTenantFieldToArt(art, options);
+    if (addTenantFieldToArt( art, options ) && (art.query || art.projection)) {
+      for (const qcache of $getQueries( art ).slice( 1 ))
+        addTenantFieldToArt( qcache._select, options, true );
+    }
   }
 
   (csn.extensions || []).forEach( ( ext, idx ) => {
@@ -152,25 +157,36 @@ function addTenantFields( csn, options, messageFunctions ) {
 
   // Queries --------------------------------------------------------------------
 
-  function handleQuery( query ) {
-    // TODO: errors are temporary: start with simple projections only = no better
-    // message $location necessary yet - better: set `name` in csnRefs
-    if (!projection || query.ref && handleQuerySource( query ))
+  function handleQuery( query, fromSelect, parentQuery ) {
+    const select = query.SELECT || query.projection;
+    if (select)
+      csnPath[0] = query;
+    if (!projection || query.ref && handleQuerySource( query, fromSelect ))
       return;
 
-    if (query !== projection && !independent) {
-      error( 'tenant-unsupported-query', msgLocations( csnPath ), {},
-             'Can\'t yet have tenant-dependent non-simple query entities' );
-      projection = null;
+    if (query !== projection && !independent &&
+        (fromSelect && !fromSelect.from.ref || !parentQuery?.SET)) {
+      // If a sub query would be supported in ORDER BY or LIMIT, the test above
+      // would not be enough
+      error( 'tenant-unsupported-query', msgLocations( csnPath ),
+             { '#': (fromSelect?.from?.join ? 'join' : 'subquery') },
+             {
+               std: 'Can\'t have tenant-dependent non-simple query entities',
+               join: 'Can\'t use a join in a tenant-dependent entity',
+               subquery: 'Can\'t use a sub query in a tenant-dependent entity',
+             } );
+      projection = null;        // no further error
       return;
     }
 
-    if (!query.projection && !query.SELECT)
+    if (!select)
       return;                   // query.SET or query.join
-    csnPath[0] = query;
     csnPath.push( query.SELECT ? 'SELECT' : 'projection' );
 
-    const select = query.SELECT || query.projection;
+    const qcache = queryForElements( query );
+    if (qcache.$queryNumber > 1)
+      handleElements( qcache );
+
     if (select.mixin)
       checkMixins( select.mixin );
     if (!independent) {
@@ -178,19 +194,12 @@ function addTenantFields( csn, options, messageFunctions ) {
         checkExcluding( select.excluding );
       if (select.columns)
         handleColumns( select.columns );
-      // TODO: when we allow subqueries, we must also check for published in redirected assocs
-      // TODO: for subqueries, we might need to adapt the inferred elements
-      // TODO: where exists ref -
-      // TODO: select and query clauses, especially with aggregation functions
       handleGroupBy( select );
     }
-    else if (query !== projection && select.columns) {
-      checkColumnCasts( select.columns );
-    }
     csnPath.length = 1;
   }
 
-  function handleQuerySource( query ) {
+  function handleQuerySource( query, fromSelect ) {
     if (independent) {
       const art = pathId(query.ref[0]); // yes, the base
       if (csn.definitions[art][annoTenantIndep])
@@ -202,8 +211,8 @@ function addTenantFields( csn, options, messageFunctions ) {
       } );
       return true;
     }
-    if (query !== (projection.SELECT || projection.projection)?.from) // with `join`
-      return false;
+    if (fromSelect && fromSelect.from !== query) // with JOIN
+      return false;                              // issue better error later
     if ((query.as || implicitAs( query.ref )) === tenantName) {
       error( 'tenant-invalid-alias-name', msgLocations( csnPath ),
              { name: tenantName, '#': (query.as ? 'std' : 'implicit') } );
@@ -265,20 +274,6 @@ function addTenantFields( csn, options, messageFunctions ) {
       : { ref: [ tenantName ] } );
   }
 
-  function checkColumnCasts( columns, prop = 'columns' ) {
-    csnPath.push( prop, -1 );
-    for (const col of columns) {
-      ++csnPath[csnPath.length - 1];
-      if (col.cast?.target)
-        handleAssociations( col.cast, null );
-      else if (col.expand)
-        checkColumnCasts( col.expand, 'expand' );
-      else if (col.inline)
-        checkColumnCasts( col.inline, 'inline' );
-    }
-    csnPath.length -= 2;
-  }
-
   // Associations ---------------------------------------------------------------
 
   function handleAssociations( elem, afterRecursion ) {
@@ -419,12 +414,15 @@ function isTenantDepEntity( art ) {
   return art?.kind === 'entity' && !art[annoTenantIndep];
 }
 
-function addTenantFieldToArt( art, options ) {
+function addTenantFieldToArt( art, options, isQuery = false ) {
+  if (!isQuery && !isTenantDepEntity( art ))
+    return false;
   const tenantName = options.tenantDiscriminator === true ? 'tenant' : options.tenantDiscriminator;
-
-  if (isTenantDepEntity( art ))
-    art.elements = { [tenantName]: { ...tenantDef }, ...art.elements };
-    // consider non-enumerable `elements` of subqueries if that is supported
+  const elements = Object.getOwnPropertyDescriptor( art, 'elements' );
+  // `query.elements` is usually non-enumerable
+  elements.value = { [tenantName]: { ...tenantDef }, ...elements.value };
+  Object.defineProperty( art, 'elements', elements );
+  return true;
 }
 
 module.exports = {

package/lib/transform/db/applyTransformations.js

@@ -131,14 +131,14 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
     if (options.skipDict?.[_prop] || dict == null) // with universal CSN, dictionaries might be null
       return;
     csnPath.push( _prop );
-    context[`$in_${_prop}`] = true;
+    context[`$in_${ _prop }`] = true;
     for (const name of Object.getOwnPropertyNames( dict ))
       dictEntry( dict, name, dict[name] );
 
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
-      setProp(node, `$${_prop}`, dict);
+      setProp(node, `$${ _prop }`, dict);
     csnPath.pop();
-    context[`$in_${_prop}`] = undefined;
+    context[`$in_${ _prop }`] = undefined;
   }
 
   /**
@@ -188,7 +188,7 @@ function applyTransformationsInternal( parent, prop, customTransformers, artifac
       }
     }
     if (!Object.prototype.propertyIsEnumerable.call( node, _prop ))
-      setProp(node, `$${_prop}`, dict);
+      setProp(node, `$${ _prop }`, dict);
     csnPath.pop();
   }
 

package/lib/transform/db/assertUnique.js

@@ -322,16 +322,17 @@ function rewriteUniqueConstraints( csn, options, pathDelimiter ) {
 
         // now add the index for HANA CDS
         if (options.transformation === 'hdbcds') {
-          const index = [ 'unique', 'index', { ref: [ uniqueConstraint ] }, 'on', '(' ];
+          const cond = [];
           let i = 0;
           for (const constraint of rewrittenPaths) {
             if (i > 0)
-              index.push(',');
-            index.push(constraint);
+              cond.push(',');
+            cond.push(constraint);
             i++;
           }
-          index.push(')');
-          artifact.technicalConfig.hana.indexes[uniqueConstraint] = index;
+          artifact.technicalConfig.hana.indexes[uniqueConstraint] = [
+            'unique', 'index', { ref: [ uniqueConstraint ] }, 'on', { xpr: cond },
+          ];
         }
       }
       artifact.$tableConstraints.unique = uniqueConstraints;

package/lib/transform/db/associations.js

@@ -62,7 +62,7 @@ function attachOnConditions( csn, csnUtils, pathDelimiter, iterateOptions = {},
             ...foreignKey.ref,
           ],
         };
-        const fkName = `${elemName}${pathDelimiter}${foreignKey.as || implicitAs(foreignKey.ref)}`;
+        const fkName = `${ elemName }${ pathDelimiter }${ foreignKey.as || implicitAs(foreignKey.ref) }`;
         const fKeyArg = {
           ref: [
             ...fkName.startsWith('$') ? [ '$self' ] : [],
@@ -189,14 +189,14 @@ function getFKAccessFinalizer( csn, csnUtils, pathDelimiter, processOnInQueries
                       // Doesn't work when ref-target (filter condition) or similar is used
                       !ref.slice(i).some(refElement => typeof refElement !== 'string')) {
                   const fkRef = ref[i + 1];
-                  const fkName = (!fkAlias ? fkRef : `${fkRef}${pathDelimiter}${fkAlias}`);
+                  const fkName = (!fkAlias ? fkRef : `${ fkRef }${ pathDelimiter }${ fkAlias }`);
                   const fks = link.art.keys.filter(key => key.ref[0] === fkName);
 
                   if (fks.length >= 1) { // after flattening, at most one FK will remain.
                     // `.as` is set for SQL, but not for OData -> fall back to implicit alias
                     fkAlias = fks[0].as || fks[0].ref[fks[0].ref.length - 1];
                     const managedAssocStepName = ref[i];
-                    const newFkName = `${managedAssocStepName}${pathDelimiter}${fkAlias}`;
+                    const newFkName = `${ managedAssocStepName }${ pathDelimiter }${ fkAlias }`;
                     if (isColumns) {
                       refOwner.ref = [ ...ref.slice(0, i), newFkName ];
                       if (!refOwner.as)

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

@@ -283,23 +283,23 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
           }
         }
 
-        // TODO: parentheses around sub expressions are to be represented by inner `xpr`
-        if (extension.length > 3)
-          subselect.SELECT.where.push('('); // add braces around the on-condition part to ensure precedence is kept
-
         // TODO: add tenant comparison here ?
-        subselect.SELECT.where.push(...extension);
-
-        if (extension.length > 3)
-          subselect.SELECT.where.push(')');
+        if (extension.length > 3) {
+          // make on-condition part sub-xpr to ensure precedence is kept
+          subselect.SELECT.where.push({ xpr: extension });
+        }
+        else {
+          subselect.SELECT.where.push(...extension);
+        }
 
         newExpr.push('exists');
-        if (ref && ref.where) {
+        if (ref?.where) {
           const remappedWhere = remapExistingWhere(target, ref.where, exprPath, current);
+          subselect.SELECT.where.push('and');
           if (remappedWhere.length > 3)
-            subselect.SELECT.where.push(...[ 'and', '(', ...remappedWhere, ')' ]);
+            subselect.SELECT.where.push( { xpr: remappedWhere } );
           else
-            subselect.SELECT.where.push(...[ 'and', ...remappedWhere ]);
+            subselect.SELECT.where.push( ...remappedWhere );
         }
 
         newExpr.push(subselect);
@@ -332,10 +332,10 @@ function handleExists( csn, options, error, inspectRef, initDefinition, dropDefi
    * @returns {CSN.Query}
    */
   function getSubselect( target, assocRef, _sources ) {
-    let subselectAlias = `_${assocRef.id ? assocRef.id : assocRef}_exists`;
+    let subselectAlias = `_${ assocRef.id ? assocRef.id : assocRef }_exists`;
 
     while (_sources[subselectAlias])
-      subselectAlias = `_${subselectAlias}`;
+      subselectAlias = `_${ subselectAlias }`;
 
     const subselect = {
       SELECT: {

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

@@ -445,3 +445,11 @@ function getHelpers( csn, inspectRef, error ) {
 
 
 module.exports = { getHelpers };
+
+/**
+ * @typedef {Token[]} TokenStream Array of tokens.
+ */
+
+/**
+ * @typedef {string|object} Token Could be an object or a string - strings are usually operators.
+ */

package/lib/transform/db/backlinks.js

@@ -69,7 +69,8 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
    */
   function processBacklinkAssoc( elem, elemName, art, artName, pathToOn ) {
     // Don't add braces if it is a single expression (ignoring superfluous braces)
-    const multipleExprs = elem.on.filter(x => x !== '(' && x !== ')' ).length > 3;
+    // TODO: This check is too simplistic and probably adds superfluous parentheses.
+    const multipleExprs = elem.on.length > 3;
     elem.on = processExpressionArgs(elem.on, pathToOn);
     const column = csnUtils.getColumn(elem);
     if (column?.cast?.on) // avoid difference between column and element
@@ -92,26 +93,30 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
         // (if so, replace all three tokens with the condition generated from the other side, in parentheses)
           if (isDollarSelfOrProjectionOperand(xprArgs[i]) && isAssociationOperand(xprArgs[i + 2], path.concat([ i + 2 ]), csnUtils.inspectRef)) {
             const assoc = csnUtils.inspectRef(path.concat([ i + 2 ])).art;
-            if (multipleExprs)
-              result.push('(');
             const backlinkName = xprArgs[i + 2].ref[xprArgs[i + 2].ref.length - 1];
-            result.push(...transformDollarSelfComparison(xprArgs[i + 2],
-                                                         assoc,
-                                                         backlinkName,
-                                                         elem, elemName, art, artName, path.concat([ i ])));
+            const comparison = transformDollarSelfComparison(
+              xprArgs[i + 2], assoc, backlinkName,
+              elem, elemName, art, artName, path.concat([ i ])
+            );
+
             if (multipleExprs)
-              result.push(')');
+              result.push({ xpr: comparison });
+            else
+              result.push(...comparison);
+
             i += 3;
             attachBacklinkInformation(backlinkName);
           }
           else if (isDollarSelfOrProjectionOperand(xprArgs[i + 2]) && isAssociationOperand(xprArgs[i], path.concat([ i ]), csnUtils.inspectRef)) {
             const assoc = csnUtils.inspectRef(path.concat([ i ])).art;
-            if (multipleExprs)
-              result.push('(');
             const backlinkName = xprArgs[i].ref[xprArgs[i].ref.length - 1];
-            result.push(...transformDollarSelfComparison(xprArgs[i], assoc, backlinkName, elem, elemName, art, artName, path.concat([ i + 2 ])));
+            const comparison = transformDollarSelfComparison(xprArgs[i], assoc, backlinkName, elem, elemName, art, artName, path.concat([ i + 2 ]));
+
             if (multipleExprs)
-              result.push(')');
+              result.push({ xpr: comparison });
+            else
+              result.push(...comparison);
+
             i += 3;
             attachBacklinkInformation(backlinkName);
           }
@@ -205,7 +210,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
       return transformDollarSelfComparisonWithUnmanagedAssoc(assocOp, assoc, assocName, elemName, art, path);
     }
 
-    throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${JSON.stringify(elem.on)}`);
+    throw new ModelError(`Expected either managed or unmanaged association in $self-comparison: ${ JSON.stringify(elem.on) }`);
   }
 
 
@@ -235,7 +240,7 @@ function getBacklinkTransformer( csnUtils, messageFunctions, options, pathDelimi
       // Depending on naming conventions, the foreign key may two path steps (hdbcds) or be a single path step with a flattened name (plain, quoted)
       // With to.hdbcds in conjunction with hdbcds naming, we need to NOT use the alias - else we get deployment errors
       const keyName = k.as && doA2J ? [ k.as ] : k.ref;
-      const fKeyPath = !doA2J ? [ assocName, ...keyName ] : [ `${assocName}${pathDelimiter}${keyName[0]}` ];
+      const fKeyPath = !doA2J ? [ assocName, ...keyName ] : [ `${ assocName }${ pathDelimiter }${ keyName[0] }` ];
       // FIXME: _artifact to the args ???
       const a = [
         {

package/lib/transform/db/constraints.js

@@ -57,7 +57,7 @@ function createReferentialConstraints( csn, options ) {
           });
         }
         // for `texts` compositions, we may generate foreign key constraints even w/o `up_`
-        else if (elementName === 'texts' && element.target === `${path[path.length - 1]}.texts`) {
+        else if (elementName === 'texts' && element.target === `${ path[path.length - 1] }.texts`) {
           const { on } = element;
           const textsEntity = csn.definitions[element.target];
           // `texts` entities have a key named "locale"
@@ -568,14 +568,14 @@ function createReferentialConstraints( csn, options ) {
       // comments in sqlite files are causing the JDBC driver to throw an error on deployment
       if (options.testMode && onDelete === 'CASCADE') {
         if ($foreignKeyConstraint.upLinkFor?.texts)
-          onDeleteRemark = `Constraint originates from localized composition ”${$foreignKeyConstraint.parentTable}:texts“`;
+          onDeleteRemark = `Constraint originates from localized composition ”${ $foreignKeyConstraint.parentTable }:texts“`;
         else
-          onDeleteRemark = `Up_ link for Composition "${$foreignKeyConstraint.upLinkFor}" implies existential dependency`;
+          onDeleteRemark = `Up_ link for Composition "${ $foreignKeyConstraint.upLinkFor }" implies existential dependency`;
       }
       // constraint identifier usually start with `c__` to avoid name clashes
       let identifier = options.pre2134ReferentialConstraintNames ? '' : 'c__';
-      identifier += `${getResultingName(csn, options.sqlMapping, artifactName)}_${$foreignKeyConstraint.sourceAssociation}`;
-      referentialConstraints[`${getResultingName(csn, 'quoted', artifactName)}_${$foreignKeyConstraint.sourceAssociation}`] = {
+      identifier += `${ getResultingName(csn, options.sqlMapping, artifactName) }_${ $foreignKeyConstraint.sourceAssociation }`;
+      referentialConstraints[`${ getResultingName(csn, 'quoted', artifactName) }_${ $foreignKeyConstraint.sourceAssociation }`] = {
         identifier,
         foreignKey: dependentKey,
         parentKey,
@@ -605,7 +605,7 @@ function assertConstraintIdentifierUniqueness( artifact, artifactName, path, err
     return;
 
   forEachKey(artifact.$tableConstraints.unique, (uniqueConstraintKey) => {
-    const uniqueConstraintIdentifier = `${artifactName}_${uniqueConstraintKey}`; // final unique constraint identifier will be generated in renderer likewise
+    const uniqueConstraintIdentifier = `${ artifactName }_${ uniqueConstraintKey }`; // final unique constraint identifier will be generated in renderer likewise
     if (artifact.$tableConstraints.referential[uniqueConstraintIdentifier]) {
       error(null, path,
             { name: uniqueConstraintIdentifier, art: artifactName },

package/lib/transform/db/expansion.js

@@ -99,7 +99,7 @@ function expandStructureReferences( csn, options, pathDelimiter, messageFunction
           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)');
+              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 {

package/lib/transform/db/flattening.js

@@ -751,7 +751,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
   // we have reached a leaf element, create a foreign key
   else if (finalElement.type == null || isBuiltinType(finalElement.type)) {
     const newFk = Object.create(null);
-    [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${f}`) ].forEach((prop) => {
+    [ 'type', 'length', 'scale', 'precision', 'srid', 'default', '@odata.Type', ...EdmTypeFacetNames.map(f => `@odata.${ f }`) ].forEach((prop) => {
       // copy props from original element to preserve derived types!
       if (element[prop] !== undefined)
         newFk[prop] = element[prop];
@@ -761,7 +761,7 @@ function createForeignKeys( csnUtils, path, element, prefix, csn, options, pathD
 
   fks.forEach((fk) => {
     // prepend current prefix
-    fk[0] = `${prefix}${pathDelimiter}${fk[0]}`;
+    fk[0] = `${ prefix }${ pathDelimiter }${ fk[0] }`;
     // if this is the entry association, decorate the final foreign keys with the association props
     if (lvl === 0) {
       if (options.transformation !== 'effective')

package/lib/transform/db/groupByOrderBy.js

@@ -91,7 +91,7 @@ function replaceAssociationsInGroupByOrderBy( inputQuery, options, inspectRef, e
 function getForeignKeyRefs( assoc ) {
   return assoc.keys.map((fk) => {
     if (!fk.$generatedFieldName)
-      throw new ModelError(`Expecting generated field name for foreign key: ${JSON.stringify(fk)}`);
+      throw new ModelError(`Expecting generated field name for foreign key: ${ JSON.stringify(fk) }`);
 
     return { ref: [ fk.$generatedFieldName ] };
   });

package/lib/transform/db/processSqlServices.js

@@ -101,10 +101,10 @@ function createServiceDummy(artifact, artifactName, csn, { error }) {
   delete dummy['@cds.persistence.exists'];
   delete dummy.$ignore;
 
-  if (csn.definitions[`dummy.${artifactName}`])
-    error(null, [ 'definitions', artifactName ], { name: `dummy.${artifactName}` }, 'Generated artifact name $(NAME) conflicts with existing entity');
+  if (csn.definitions[`dummy.${ artifactName }`])
+    error(null, [ 'definitions', artifactName ], { name: `dummy.${ artifactName }` }, 'Generated artifact name $(NAME) conflicts with existing entity');
   else
-    csn.definitions[`dummy.${artifactName}`] = dummy;
+    csn.definitions[`dummy.${ artifactName }`] = dummy;
 }
 
 module.exports = {

package/lib/transform/db/rewriteCalculatedElements.js

@@ -384,12 +384,12 @@ function rewriteCalculatedElementsInViews( csn, options, csnUtils, pathDelimiter
           }
         }
         else {
-          throw new CompilerAssertion(`Unhandled arg type: ${JSON.stringify(arg, null, 2)}`);
+          throw new CompilerAssertion(`Unhandled arg type: ${ JSON.stringify(arg, null, 2) }`);
         }
       }
       return mergedElements;
     }
-    throw new CompilerAssertion(`Unhandled query type:  ${JSON.stringify(SELECT, null, 2)}`);
+    throw new CompilerAssertion(`Unhandled query type:  ${ JSON.stringify(SELECT, null, 2) }`);
   }
 
   /**

package/lib/transform/db/temporal.js

@@ -73,19 +73,17 @@ function getViewDecorator( csn, messageFunctions, csnUtils, options ) {
             const validFrom = { ref: [ '$valid', 'from' ] };
             const validTo = { ref: [ '$valid', 'to' ] };
 
-            const cond = [ '(', fromPath, '<', validTo, 'and', toPath, '>', validFrom, ')' ];
-
-            if (normalizedQuery.query.SELECT.where) { // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
-              normalizedQuery.query.SELECT.where = [ '(', ...normalizedQuery.query.SELECT.where, ')', 'and', ...cond ];
-            }
-            else {
-              normalizedQuery.query.SELECT.where = cond;
-            }
+            const cond = { xpr: [ fromPath, '<', validTo, 'and', toPath, '>', validFrom ] };
+
+            if (normalizedQuery.query.SELECT.where) // if there is an existing where-clause, extend it by adding 'and (temporal clause)'
+              normalizedQuery.query.SELECT.where = [ { xpr: normalizedQuery.query.SELECT.where }, 'and', cond ];
+            else
+              normalizedQuery.query.SELECT.where = [ cond ];
           }
         }
         else {
           info(null, [ 'definitions', artifactName ],
-               { source: `${from[0].errorParent}.${from[0].name}`, target: `${to[0].errorParent}.${to[0].name}` },
+               { source: `${ from[0].errorParent }.${ from[0].name }`, target: `${ to[0].errorParent }.${ to[0].name }` },
                'No temporal WHERE clause added as $(SOURCE) and $(TARGET) are not of same origin');
         }
       }

package/lib/transform/db/views.js

@@ -145,10 +145,10 @@ function getViewTransformer( csn, options, messageFunctions ) {
       const matchingCombined = $combined[elemName];
       // Internal errors - this should never happen!
       if (matchingCombined.length > 1) { // should already be caught by compiler
-        throw new ModelError(`Ambiguous name - can't be resolved: ${elemName}. Found in: ${matchingCombined.map(o => o.parent)}`);
+        throw new ModelError(`Ambiguous name - can't be resolved: ${ elemName }. Found in: ${ matchingCombined.map(o => o.parent) }`);
       }
       else if (matchingCombined.length === 0) { // no clue how this could happen? Invalid CSN?
-        throw new ModelError(`No matching entry found in UNION of all elements for: ${elemName}`);
+        throw new ModelError(`No matching entry found in UNION of all elements for: ${ elemName }`);
       }
       alias = matchingCombined[0].parent;
     }
@@ -177,7 +177,7 @@ function getViewTransformer( csn, options, messageFunctions ) {
           ref,
         };
         if (assocCol.as) {
-          const columnName = `${assocCol.as}${pathDelimiter}${foreignKey.as}`;
+          const columnName = `${ assocCol.as }${ pathDelimiter }${ foreignKey.as }`;
           result.as = columnName;
         }
 
@@ -229,9 +229,9 @@ function getViewTransformer( csn, options, messageFunctions ) {
 
 
         // Create an unused alias name for the MIXIN - use 3 _ to avoid collision with usings
-        let mixinElemName = `___${mixinName || elemName}`;
+        let mixinElemName = `___${ mixinName || elemName }`;
         while (elements[mixinElemName])
-          mixinElemName = `_${mixinElemName}`;
+          mixinElemName = `_${ mixinElemName }`;
 
         // Copy the association element to the MIXIN clause under its alias name
         // Needs to be a deep copy, as we transform the on-condition
@@ -327,7 +327,7 @@ function getViewTransformer( csn, options, messageFunctions ) {
   function transformViewOrEntity( query, artifact, artName, path ) {
     const ignoreAssociations = options.sqlDialect === 'hana' && options.withHanaAssociations === false;
     csnUtils.initDefinition(artifact);
-    const { elements } = queryOrMain(query, artifact);
+    const { elements } = queryOrMain(query, artifact); // TODO: use queryForElements
     // We use the elements from the leading query/main artifact - adapt the path
     const elementsPath = elements === artifact.elements ? path.slice(0, 2).concat('elements') : path.concat('elements');
     const queryPath = path;

package/lib/transform/draft/odata.js

@@ -188,6 +188,8 @@ function generateDrafts( csn, options, services, messageFunctions ) {
         setAnnotation(artifact, '@Common.SideEffects#alwaysFetchMessages.TargetProperties', ['DraftMessages'] );
       }
       setAnnotation(artifact, '@Common.Messages', { '=': 'DraftMessages', ref: ['DraftMessages'] });
+      const service = csn.definitions[getServiceOfArtifact(artifactName, services)];
+      setAnnotation(service, '@Common.AddressViaNavigationPath', true);
     }
 
     // Iterate elements

package/lib/transform/effective/annotations.js

@@ -172,7 +172,7 @@ function remapODataAnnotations( csn ) {
    */
   function remapAnnotationsOnElement( artifact, element ) {
     if (element.elements && !element.$ignore) // We expect to only be called on flattened CSN - error if we encounter .elements!
-      throw new CompilerAssertion(`Expected a flat model. Found element with subelements: ${JSON.stringify(element)}`);
+      throw new CompilerAssertion(`Expected a flat model. Found element with subelements: ${ JSON.stringify(element) }`);
     for (const prop in element) {
       if (directMappings[prop])
         directMappings[prop](csn, artifact, element, prop);

package/lib/transform/effective/associations.js

@@ -104,7 +104,7 @@ function addForeignKeyToColumns( foreignKey, columns, associationColumn, options
     ref,
   };
   if (associationColumn.as) {
-    const columnName = `${associationColumn.as}_${foreignKey.as || implicitAs(foreignKey.ref)}`;
+    const columnName = `${ associationColumn.as }_${ foreignKey.as || implicitAs(foreignKey.ref) }`;
     result.as = columnName;
   }
 

package/lib/transform/effective/main.js

@@ -34,6 +34,7 @@ const getServiceFilterFunction = require('./service');
  */
 function effectiveCsn( model, options, messageFunctions ) {
   const csn = cloneFullCsn(model, options);
+  delete csn.namespace; // must not be set for effective CSN
   delete csn.vocabularies; // must not be set for effective CSN
   messageFunctions.setModel(csn);
 

package/lib/transform/effective/service.js

@@ -16,13 +16,13 @@ function getServiceFilterFunction(serviceName, collector) {
     if (artifactName === serviceName && artifact.kind === 'service') {
       collector.service = artifact;
     }
-    else if (definitions[serviceName]?.kind === 'service' && artifactName.startsWith(`${serviceName }.`)) {
+    else if (definitions[serviceName]?.kind === 'service' && artifactName.startsWith(`${ serviceName }.`)) {
       collector.containedArtifacts[artifactName] = artifact;
       delete artifact.query;
       delete artifact.projection;
       if (artifact.elements) {
         forEach(artifact.elements, (elementName, element) => {
-          if (element.target && !element.target.startsWith(`${serviceName }.`))
+          if (element.target && !element.target.startsWith(`${ serviceName }.`))
             delete artifact.elements[elementName];
         });
       }