@sap/cds-compiler 4.5.0 → 4.6.2

package/lib/compiler/tweak-assocs.js

@@ -378,6 +378,10 @@ function tweakAssocs( model ) {
   }
 
   function rewriteKeys( elem, assoc ) {
+    addConditionFromAssocPublishing( elem, assoc, null );
+    if (elem.on)
+      return; // foreign keys were transformed into ON-condition
+
     // TODO: split this function: create foreign keys without `targetElement`
     // already in Phase 2: redirectImplicitly()
     // console.log(message( null, elem.location, elem, {art:assoc,target:assoc.target},
@@ -399,8 +403,6 @@ function tweakAssocs( model ) {
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
-
-    addConditionFromAssocPublishing( elem, assoc );
   }
 
   // TODO: there is no need to rewrite the on condition of non-leading queries,
@@ -423,27 +425,24 @@ function tweakAssocs( model ) {
     const nav = (elem._main?.query && elem.value)
       ? pathNavigation( elem.value ) // redirected source elem or mixin
       : { navigation: assoc };       // redirected user-provided
-    const cond = copyExpr( assoc.on,
+    elem.on = copyExpr( assoc.on,
       // replace location in ON except if from mixin element
-                           nav.tableAlias && elem.name.location );
-    elem.on = cond;
-    addConditionFromAssocPublishing( elem, assoc );
-    // `cond` still points to the original condition; does not include possible assoc filter
+                        nav.tableAlias && elem.name.location );
     elem.on.$inferred = 'copy';
 
     const { navigation } = nav;
     if (!navigation) // TODO: what about $projection.assoc as myAssoc ?
       return;                 // should not happen: $projection, $magic, or ref to const
+
     // Currently, having an unmanaged association inside a struct is not
     // supported by this function:
     if (navigation !== assoc && navigation._origin !== assoc) { // TODO: re-check
       // For "assoc1.assoc2" and "struct.elem1.assoc2"
       if (elem._redirected !== null) // null = already reported
         error( 'rewrite-not-supported', [ elem.target.location, elem ] );
-      return;
     }
-    if (!nav.tableAlias || nav.tableAlias.path) {
-      traverseExpr( cond, 'rewrite-on', elem,
+    else if (!nav.tableAlias || nav.tableAlias.path) {
+      traverseExpr( elem.on, 'rewrite-on', elem,
                     expr => rewriteExpr( expr, elem, nav.tableAlias ) );
     }
     else {
@@ -451,6 +450,12 @@ function tweakAssocs( model ) {
       error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
     }
+
+    // filter was copied in original element already
+    // TODO: not correct for e.g. composition-of-inline-aspect (#12223)
+    if (elem.$inferred !== 'include')
+      addConditionFromAssocPublishing( elem, assoc, nav );
+
     elem.on.$inferred = 'rewrite';
   }
 
@@ -462,70 +467,67 @@ function tweakAssocs( model ) {
    *
    * The added condition (filter) is already rewritten relative to `elem`.
    */
-  function addConditionFromAssocPublishing( elem, assoc ) {
+  function addConditionFromAssocPublishing( elem, assoc, nav ) {
     const publishAssoc = (elem._main?.query || elem.$syntax === 'calc') &&
       elem.value?.path?.length > 0;
     if (!publishAssoc)
       return;
 
+    nav ??= (elem._main?.query && elem.value)
+      ? pathNavigation( elem.value ) // redirected source elem or mixin
+      : { navigation: assoc };       // redirected user-provided
+
     const { location } = elem.name;
-    let isRestricted = false;
     const lastStep = elem.value.path[elem.value.path.length - 1];
-    if (!lastStep)
+    if (!lastStep || !lastStep.where)
       return;
 
     if (lastStep.cardinality) {
-      isRestricted = true;
-      if (!elem.cardinality)
-        elem.cardinality = { ...assoc.cardinality } || { location };
+      elem.cardinality ??= { ...assoc.cardinality };
+      elem.cardinality.location = location;
       for (const card of [ 'sourceMin', 'targetMin', 'targetMax' ]) {
         if (lastStep.cardinality[card])
           elem.cardinality[card] = copyExpr( lastStep.cardinality[card], location );
       }
     }
 
-    if (lastStep.where) {
-      // If there are foreign keys, transform them into an ON-condition first.
-      if (assoc.foreignKeys) {
-        const cond = foreignKeysToOnCondition( elem );
-        if (cond) {
-          elem.on = cond;
-          elem.foreignKeys = undefined;
-        }
-      }
-
-      if (elem.on) {
-        isRestricted = true;
-        elem.on = {
-          op: { val: 'and', location },
-          args: [
-            // TODO: Get rid of $parens
-            { ...elem.on, $parens: [ assoc.location ] },
-            filterToCondition( lastStep, elem ),
-          ],
-          location,
-          $inferred: 'copy',
-        };
-      }
-      if (isRestricted) {
-        elem.$filtered = {
-          val: true,
-          literal: 'boolean',
-          location,
-          $inferred: '$generated',
-        };
+    // If there are foreign keys, transform them into an ON-condition first.
+    if (assoc.foreignKeys) {
+      const cond = foreignKeysToOnCondition( elem, assoc, nav );
+      if (cond) {
+        elem.on = cond;
+        elem.foreignKeys = undefined;
       }
     }
+
+    elem.on = {
+      op: { val: 'and', location },
+      args: [
+        // TODO: Get rid of $parens
+        { ...elem.on, $parens: [ assoc.location ] },
+        filterToCondition( lastStep, elem, nav ),
+      ],
+      location,
+      $inferred: 'copy',
+    };
+
+    elem.$filtered = {
+      val: true,
+      literal: 'boolean',
+      location,
+      $inferred: '$generated',
+    };
   }
 
   /**
-   * Transform a filter on `assoc` into an ON-condition.
-   * Paths inside the filter are rewritten relative to `elem`.
+   * Transform a filter on `assocPathStep` into an ON-condition.
+   * Paths inside the filter are rewritten relative to `assoc`, so they can be redirected
+   * using `rewriteExpr()` later on. `$self` paths remain unchanged.
    */
-  function filterToCondition( assoc, elem ) {
-    const cond = copyExpr( assoc.where );
+  function filterToCondition( assocPathStep, elem, nav ) {
+    const cond = copyExpr( assocPathStep.where );
     // TODO: Get rid of $parens
-    cond.$parens = [ assoc.location ];
+    cond.$parens = [ assocPathStep.location ];
     traverseExpr( cond, 'rewrite-filter', elem, (expr) => {
       if (!expr.path || expr.path.length === 0)
         return;
@@ -539,15 +541,17 @@ function tweakAssocs( model ) {
       }
       else if (!root.builtin && root.kind !== 'builtin') {
         expr.path.unshift({
-          id: elem.name.id,
+          id: assocPathStep.id,
           location: elem.name.location,
         });
-        setLink( expr.path[0], '_artifact', elem );
-        // _navigation link not necessary because this condition is not rewritten
-        // inside the same view (would otherwise be needed for mixins).
-
-        if (elem.name.id.charAt(0) === '$')
-          prependSelfToPath( expr.path, elem );
+        setLink( expr.path[0], '_artifact', assocPathStep._artifact );
+        if (assocPathStep._navigation?.kind === 'mixin') {
+          // _navigation link necessary because condition is rewritten
+          // inside the same view (needed for mixins).
+          setLink( expr.path[0], '_navigation', assocPathStep._navigation );
+        }
+        // up to here, filter is relative to original association
+        rewriteExpr( expr, elem, nav?.tableAlias );
       }
     } );
 
@@ -556,15 +560,12 @@ function tweakAssocs( model ) {
   }
 
   // Caller must ensure ON-condition correctness via rewriteExpr()!
-  function foreignKeysToOnCondition( elem ) {
-    const nav = elem.$syntax === 'calc'
-      ? calcPathNavigation( elem.value )
-      : pathNavigation( elem.value );
+  function foreignKeysToOnCondition( elem, assoc, nav ) {
     if (model.options.testMode && !nav.tableAlias && !elem._pathHead && elem.$syntax !== 'calc')
       throw new CompilerAssertion('rewriting keys to cond: no tableAlias but not inline/calc');
 
     if ((!nav.tableAlias && elem.$syntax !== 'calc') || elem._parent?.kind === 'element' ||
-       (nav && nav.item !== elem.value.path[elem.value.path.length - 1])) {
+       (nav && nav.item && nav.item !== elem.value.path[elem.value.path.length - 1])) {
       // - no nav.tableAlias for mixins or inside inline; mixins can't have managed assocs, though.
       // - _parent is element for expand
       // - nav.item is different for multi-path steps e.g. `sub.assoc`, which is not supported, yet
@@ -574,45 +575,40 @@ function tweakAssocs( model ) {
     }
 
     let cond = [];
-    forEachInOrder( elem, 'foreignKeys', function keyToCond( fKey ) {
+    forEachInOrder( assoc, 'foreignKeys', function keyToCond( fKey ) {
       // Format:      lhs = rhs
       //         assoc.id = assoc_id
-      // lhs and rhs look the same, but have different ids and _artifact links.
-      // rhs is rewritten further down to ensure that the foreign key is projected.
+      // lhs and rhs look the same but are rewritten differently. We must ensure that
+      // the rhs is rewritten to a projected element (or it must remain the assoc's
+      // foreign key in case of calc elements).
       const lhs = {
         path: [
-          { id: elem.name.id, location: elem.name.location },
+          { id: assoc.name.id, location: elem.name.location },
           ...copyExpr( fKey.targetElement.path ),
         ],
         location: elem.name.location,
       };
-      setLink( lhs.path[0], '_artifact', elem ); // different to rhs!
-      setLink( lhs, '_artifact', lhs.path[lhs.path.length - 1] );
+      setLink( lhs.path[0], '_artifact', assoc );
+      setLink( lhs, '_artifact', lhs.path[lhs.path.length - 1]._artifact );
 
-      if (elem.name.id.charAt(0) === '$')
-        prependSelfToPath( lhs.path, elem );
+      rewritePath( lhs, lhs.path[0], assoc, elem, elem.value.location ); // different to rhs!
 
-      const elemOrigin = getOrigin( elem );
       const rhs = {
         path: [
           // use origin's name; elem could have alias
-          { id: elemOrigin.name.id, location: elemOrigin.name.location },
+          { id: assoc.name.id, location: elem.name.location },
           ...copyExpr( fKey.targetElement.path ),
         ],
         location: elem.name.location,
       };
-      setLink( rhs.path[0], '_artifact', elemOrigin ); // different to lhs!
-      setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1] );
+      setLink( rhs.path[0], '_artifact', assoc );
+      setLink( rhs, '_artifact', rhs.path[rhs.path.length - 1]._artifact );
 
-      if (elem.$syntax !== 'calc') {
-        // Can't use rewriteExpr as that would use `assoc[…]` itself as well.
+      if (elem.$syntax !== 'calc') { // different to lhs!
         const projectedFk = firstProjectionForPath( rhs.path, nav.tableAlias, elem );
         rewritePath( rhs, projectedFk.item, elem, projectedFk.elem, elem.value.location );
       }
-      else {
-        // TODO: calc elements: Do we need to rewrite? Shouldn't all elements exist, since
-        //       the calc element is right next to all others?
-      }
+
       const fkCond = {
         op: { val: 'ixpr', location: elem.name.location },
         args: [
@@ -699,15 +695,10 @@ function tweakAssocs( model ) {
         return;     // just $self
       // corresponding elem in including structure or…
       let elem = (assoc._main.items || assoc._main).elements[item.id];
-      if (elem !== assoc && assoc.$syntax === 'calc') {
-        // … special case for calc elements where "elem" points to the referenced
-        // (possibly included) association. For _included_ calc elements of the form,
-        // `calc = assoc[…]` it holds: `elem === assoc`
-        // TODO: expr could be the transformed fkey->ON-condition, where this statement is not true
-        //      And for the reference to the _foreign key_, we must _not_ rewrite it.
-        const calcRoot = assoc.value.path[0]?._navigation;
-        if (assoc.value.path[calcRoot?.kind === '$self' ? 1 : 0]?._artifact === elem)
-          elem = assoc;
+      if (assoc.$syntax === 'calc' && assoc._origin === elem) {
+        // … calc element where "elem" points to the referenced (possibly included)
+        // sibling element (association).
+        elem = assoc;
       }
       if (!elem)
         return; // See #11755
@@ -785,9 +776,9 @@ function tweakAssocs( model ) {
 
   function prependSelfToPath( path, elem ) {
     const root = { id: '$self', location: path[0].location };
-    path.unshift( root );
     setLink( root, '_navigation', elem._parent.$tableAliases.$self );
     setArtifactLink( root, elem._parent );
+    path.unshift( root );
   }
 
   function rewriteItem( elem, item, name, assoc, forKeys ) {
@@ -931,20 +922,4 @@ function pathNavigation( ref ) {
   return { navigation: root.elements[item.id], item, tableAlias: root };
 }
 
-// TODO: Maybe unify with pathNavigation?
-function calcPathNavigation( ref ) {
-  if (!ref._artifact)
-    return {};
-  let item = ref.path && ref.path[0];
-  const root = item && item._artifact;
-  if (!root)
-    return {};
-  if (root.kind === 'element')
-    return { navigation: root, item, tableAlias: root._parent };
-  item = ref.path[1];
-  if (root.kind === '$self')
-    return { item, tableAlias: root };
-  return { navigation: root.elements[item.id], item, tableAlias: root };
-}
-
 module.exports = tweakAssocs;

package/lib/compiler/utils.js

@@ -29,7 +29,8 @@ function pushLink( obj, prop, value ) {
 // for annotations:
 
 function annotationVal( anno ) {
-  return anno && (anno.val === undefined || anno.val); // XSN TODO: set val for anno short form
+  // XSN TODO: set val but no location for anno short form
+  return anno && (anno.val === undefined || anno.val);
 }
 function annotationIsFalse( anno ) {                   // falsy, but not null (unset)
   return anno && (anno.val === false || anno.val === 0 || anno.val === '');

package/lib/edm/annotations/edmJson.js

@@ -7,9 +7,8 @@ const {
   EdmTypeFacetNames,
   EdmPrimitiveTypeMap,
 } = require('../EdmPrimitiveTypeDefinitions.js');
-const { isBuiltinType } = require('../../model/csnUtils');
+const { isBuiltinType, isAnnotationExpression } = require('../../model/csnUtils');
 const { transformExpression } = require('../../transform/db/applyTransformations.js');
-const { xprInAnnoProperties } = require('../../compiler/builtins');
 
 /**
  * Translate a given token stream expression into an edmJson representation
@@ -80,7 +79,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   // Error transformer
   const notADynExpr = (parent, op, xpr, csnPath, parentparent, parentprop, txt) => {
     error('odata-anno-xpr', location, {
-      anno, op: txt ??= op, '#': 'notadynexpr',
+      anno, op: txt ?? op, '#': 'notadynexpr',
     });
     delete parent[op];
   };
@@ -108,13 +107,13 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   // list is a $Collection => []
   transform.list = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     parentparent[parentprop] = xpr.filter(a => a);
-    transformExpression(parentparent, transform);
+    transformExpression(parentparent, parentprop, transform);
   };
   // XPR
   transform.xpr = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     // eliminate 'xpr' node by pulling up xpr node to its parent
     parentparent[parentprop] = xpr;
-    transformExpression(parentparent, transform);
+    transformExpression(parentparent, parentprop, transform);
   };
   //----------------------------------
   // CASE
@@ -145,9 +144,11 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       curIf.$If.push(caseExpr[i]);
     parent.$If = edmIf.$If;
     delete parent.case;
-    transformExpression(parent, transform);
+    transformExpression(parent, undefined, transform);
+  };
+  transform.$If = (_parent, _prop, expr) => {
+    transformExpression(expr, undefined, transform);
   };
-  transform.$If = noOp;
   //----------------------------------
   // Cast => $Cast
   transform.cast = (parent, prop, castExpr, csnPath, parentparent, parentprop) => {
@@ -185,7 +186,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
 
 
     parentparent[parentprop] = castFunc;
-    transformExpression(parentparent, transform);
+    transformExpression(parentparent, parentprop, transform);
   };
   //----------------------------------
   const evalArgs = (argDef, args, propName) => {
@@ -221,7 +222,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ exact }, xpr, prop);
     parent[opStr] = xpr;
     delete parent[prop];
-    transformExpression(parent, transform);
+    transformExpression(parent, undefined, transform);
   };
   //----------------------------------
   // LOGICAL
@@ -250,12 +251,12 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     evalArgs({ min: 1 }, xpr[1].list, prop);
     parent.$In = [ xpr[0], ...xpr[1].list ];
     delete parent[prop];
-    transformExpression(parent, transform);
+    transformExpression(parent, undefined, transform);
   };
   transform.$In = noOp;
   transform.between = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     evalArgs({ exact: 2 }, xpr.slice(1), prop);
-    transformExpression(xpr, transform);
+    transformExpression(xpr, undefined, transform);
     delete parent[prop];
     parentparent[parentprop]
     = {
@@ -267,7 +268,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
   };
   transform['||'] = (parent, prop, xpr, csnPath, parentparent, parentprop) => {
     evalArgs({ exact: 2 }, xpr, prop);
-    transformExpression(xpr, transform);
+    transformExpression(xpr, undefined, transform);
     delete parent[prop];
     parentparent[parentprop].$Apply = [ { $Function: 'odata.concat' }, ...xpr ];
   };
@@ -280,7 +281,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     else {
       delete parent[prop];
       parentparent[parentprop] = xpr;
-      transformExpression(parentparent, transform);
+      transformExpression(parentparent, parentprop, transform);
     }
   };
   transform.$Add = noOp;
@@ -591,7 +592,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       delete parent.args;
     };
 
-    const exactArgs = (tgt = parent, x = xpr, count) => {
+    const exactArgs = (tgt = parent, x = xpr, count = undefined) => {
       standard(tgt, x);
       evalArgs({ exact: count }, tgt[x], xpr);
     };
@@ -695,7 +696,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
       // $Record ???
       $Collection: () => {
         standard(parentparent, parentprop);
-        transformExpression(parentparent, transform);
+        transformExpression(parentparent, parentprop, transform);
       },
       $Path: () => {
         oneArg(parent, xpr);
@@ -705,7 +706,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
             anno, op: `${xpr}(…)`, meta: 'string', '#': 'wrongval_meta',
           });
         }
-        transformExpression(parentparent, transform);
+        transformExpression(parentparent, parentprop, transform);
       },
       $Null: () => {
         parent[xpr] = true;
@@ -725,7 +726,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
         funcDef.forEach(f => f());
       else
         funcDef();
-      transformExpression(parent, transform);
+      transformExpression(parent, undefined, transform);
     }
     else {
       const funcName = xpr.startsWith('odata.') ? xpr : `odata.${xpr}`;
@@ -741,7 +742,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
           parentparent[parentprop].$Apply = [ { $Function: funcName }, ...(parent.args || []) ];
           delete parentparent[parentprop].func;
           delete parentparent[parentprop].args;
-          transformExpression(parentparent, transform);
+          transformExpression(parentparent, parentprop, transform);
         }
       }
       else {
@@ -753,14 +754,14 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
     delete parent[prop];
   };
 
-  return transformExpression({ annoVal }, {
+  return transformExpression(carrier, anno, {
     '=': (parent, prop, xpr, csnPath, parentparent, parentprop) => {
-      if (parent?.['='] !== undefined && xprInAnnoProperties.some(xProp => parent[xProp] !== undefined)) {
+      if (isAnnotationExpression(parent)) {
         delete parent['='];
-        parentparent[parentprop] = transformExpression({ $edmJson: parseExpr( parent, { array: false }) }, transform);
+        parentparent[parentprop] = transformExpression({ $edmJson: parseExpr( parent, { array: false }) }, undefined, transform);
       }
     },
-  }).annoVal;
+  });
 }
 
 // Not everything that can occur in OData annotations can be expressed with

package/lib/edm/annotations/genericTranslation.js

@@ -305,7 +305,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     if (isBetaEnabled(options, 'odataAnnotationExpressions')) {
       knownAnnos.forEach((knownAnno) => {
         if (knownAnno.search(/\.\$edmJson\./g) < 0)
-          carrier[knownAnno] = xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
+          xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
       });
     }
 
@@ -676,7 +676,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
 
         // anno is the full <Annotation Term=...>
         const anno = handleTerm(fullTermName, prefixTree[voc][term], msg);
-        if (anno !== undefined) {
+        if (!anno?.$isInvalid) {
           // addAnnotationFunc needs AppliesTo message from dictionary to decide where to put the anno
           const termName = fullTermName.replace(/#(\w+)$/g, ''); // remove qualifier
           const dictTerm = getDictTerm(termName, msg); // message for unknown term was already issued in handleTerm
@@ -835,6 +835,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       }
       else if ( Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
         // object consists only of properties starting with "@", no $value
+        setProp(oTarget, '$isInvalid', true);
         message('odata-anno-value', msg.location,
                 { anno: msg.anno(), str: 'base', '#': 'nested' } );
       }
@@ -1147,8 +1148,17 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       actualTypeName = obj.$Type;
       if (!getDictType(actualTypeName)) {
         // this type doesn't exist
-        message('odata-anno-type', msg.location,
-                { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
+        if (typeof actualTypeName !== 'string') {
+          actualTypeName = JSON.stringify(obj.$Type);
+          message('odata-anno-type', msg.location,
+                  {
+                    anno: msg.anno(), code: '$Type', rawvalue: actualTypeName, '#': 'literal',
+                  });
+        }
+        else {
+          message('odata-anno-type', msg.location,
+                  { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
+        }
         // explicitly mentioned type, render in XML and JSON
         newRecord.setXml({ Type: actualTypeName });
         // unknown dictionary type: can't fully qualify it

package/lib/edm/csn2edm.js

@@ -14,7 +14,6 @@ const {
   cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType, getUtils,
 } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { makeMessageFunction } = require('../base/messages');
 const {
   EdmTypeFacetMap,
   EdmTypeFacetNames,
@@ -23,21 +22,34 @@ const {
 const { getEdm } = require('./edm.js');
 
 /*
-OData V2 spec 06/01/2017 PDF version is available from here:
+OData V2 spec 06/01/2017 PDF version is available here:
 https://msdn.microsoft.com/en-us/library/dd541474.aspx
 */
 
-function csn2edm( _csn, serviceName, _options ) {
-  return csn2edmAll(_csn, _options, [ serviceName ])[serviceName];
+/**
+ * @param {CSN.Model} _csn
+ * @param {string} serviceName
+ * @param {CSN.Options} _options
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @return {any}
+ */
+function csn2edm( _csn, serviceName, _options, messageFunctions ) {
+  return csn2edmAll(_csn, _options, [ serviceName ], messageFunctions)[serviceName];
 }
 
-function csn2edmAll( _csn, _options, serviceNames = undefined ) {
+/**
+ * @param {CSN.Model} _csn
+ * @param {CSN.Options} _options
+ * @param {string[]|undefined} serviceNames
+ * @param {object} messageFunctions Message functions such as `error()`, `info()`, …
+ * @return {any}
+ */
+function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
   // get us a fresh model copy that we can work with
   const csn = cloneCsnNonDict(_csn, _options);
   const special$self = !csn?.definitions?.$self && '$self';
+  messageFunctions.setModel(csn);
 
-  // use original options for messages; cloned CSN for semantic location
-  const messageFunctions = makeMessageFunction(csn, _options, 'to.edmx');
   const {
     info, warning, error, message, throwWithError,
   } = messageFunctions;
@@ -630,15 +642,17 @@ function csn2edmAll( _csn, _options, serviceNames = undefined ) {
             else if (isEdmPropertyRendered(elementCsn, options)) {
             // CDXCORE-CDXCORE-173
             // V2: filter  @Core.MediaType
-              if ( options.isV2() && elementCsn['@Core.MediaType']) {
+              if (options.isV2() && elementCsn['@Core.MediaType']) {
                 hasStream = elementCsn['@Core.MediaType'];
-                delete elementCsn['@Core.MediaType'];
+                elementCsn['@cds.api.ignore'] = true;
                 // CDXCORE-CDXCORE-177:
                 // V2: don't render element but add attribute 'm:HasStream="true' to EntityType
-                // V4: render property type 'Edm.Stream'
                 streamProps.push(elementName);
               }
               else {
+                // V4: render property type 'Edm.Stream' but don't add '@Core.IsURL'
+                if ( elementCsn['@Core.MediaType'])
+                  delete elementCsn['@Core.IsURL'];
                 collectUsedType(elementCsn);
                 props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
               }

package/lib/edm/edmInboundChecks.js

@@ -71,10 +71,9 @@ function inboundQualificationChecks( csn, options, messageFunctions,
         type = elt;
       }
 
-      if (type.type === 'cds.UUID') {
+      if (type.type === 'cds.UUID' && elt['@odata.foreignKey4'] == null) {
         if (path[1] === defName)
           assignAnnotation(elt, anno, true);
-
         else if (elt[anno] == null)
           warning('odata-key-uuid-default-anno', path, { type: type.type, anno, id: `${defName}:${eltPath.join('.')}` });
       }