@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/compiler/tweak-assocs.js

@@ -5,7 +5,6 @@
 const {
   forEachGeneric,
   forEachInOrder,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
@@ -39,16 +38,17 @@ function tweakAssocs( model ) {
     checkOnCondition,
     effectiveType,
     getOrigin,
+    extendForeignKeys,
+    createRemainingAnnotateStatements,
+    mergeSpecifiedForeignKeys,
   } = model.$functions;
 
   Object.assign(model.$functions, {
     firstProjectionForPath,
   });
 
-  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
-
   // Phase 5: rewrite associations
-  model._entities.forEach( rewriteArtifact );
+  model._entities.forEach( rewriteArtifact ); // _entities contains all definitions, sorted.
   // Think hard whether an on condition rewrite can lead to a new cyclic
   // dependency.  If so, we need other messages anyway.  TODO: probably dox
   // another cyclic check with testMode.js
@@ -59,6 +59,11 @@ function tweakAssocs( model ) {
     if (art.kind === 'select')
       forEachQueryExpr( art, checkExpr );
   } );
+
+
+  // create “super” ANNOTATE statements for annotations on unknown artifacts:
+  createRemainingAnnotateStatements();
+
   return;
 
 
@@ -71,7 +76,6 @@ function tweakAssocs( model ) {
     // return;
     if (!art.query) {
       rewriteAssociation( art );
-      forEachGeneric( art, 'elements', rewriteAssociation );
     }
     else {
       traverseQueryExtra( art, ( query ) => {
@@ -81,9 +85,11 @@ function tweakAssocs( model ) {
     if (art._service)
       forEachGeneric( art, 'elements', complainAboutTargetOutsideService );
 
-    traverseQueryPost( art.query, false, ( query ) => {
-      forEachGeneric( query, 'elements', rewriteAssociationCheck );
-    } );
+    if (art.query) {
+      traverseQueryPost(art.query, false, (query) => {
+        forEachGeneric( query, 'elements', rewriteAssociationCheck );
+      });
+    }
   }
 
   // function rewriteView( view ) {
@@ -111,9 +117,7 @@ function tweakAssocs( model ) {
       info( 'assoc-target-not-in-service', loc,
             { target, '#': (elem._main.query ? 'select' : 'define') }, {
               std: 'Target $(TARGET) of association is outside any service', // not used
-              // eslint-disable-next-line max-len
               define: 'Target $(TARGET) of explicitly defined association is outside any service',
-              // eslint-disable-next-line max-len
               select: 'Target $(TARGET) of explicitly selected association is outside any service',
             } );
     }
@@ -129,7 +133,7 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociationCheck( element ) {
-    const elem = element.items || element; // TODO v5: nested items
+    const elem = element.items || element; // TODO v6: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociationCheck );
     if (!elem.target)
@@ -236,13 +240,24 @@ function tweakAssocs( model ) {
   }
 
   function rewriteAssociation( element ) {
-    let elem = element.items || element; // TODO v5: nested items
+    doRewriteAssociation( element );
+    if (element.target) {
+      extendForeignKeys( element );
+      if (element.foreignKeys$)
+        mergeSpecifiedForeignKeys( element );
+    }
+  }
+
+  // only to be used by rewriteAssociation()
+  function doRewriteAssociation( element ) {
+    let elem = element.items || element; // TODO v6: nested items
     if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
     if (elem.targetAspect?.elements)
       forEachGeneric( elem.targetAspect, 'elements', rewriteAssociation );
     if (!originTarget( elem ))
       return;
+
     // console.log(message( null, elem.location, elem,
     // {art:assoc,target,ftype:JSON.stringify(ftype)}, 'Info','RA').toString())
 
@@ -300,6 +315,7 @@ function tweakAssocs( model ) {
     }
   }
 
+  /** Returns the element's origin's target artifact. */
   function originTarget( elem ) {
     const assoc = !elem.expand && getOrigin( elem );
     const ftype = assoc && effectiveType( assoc );
@@ -378,6 +394,9 @@ function tweakAssocs( model ) {
       traverseExpr( elem.on, 'rewrite-on', elem,
                     expr => rewriteExpr( expr, elem, nav.tableAlias ) );
     }
+    else if (elem._pathHead) {
+      error( 'rewrite-not-supported', [ elem.target.location, elem ] );
+    }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
       error( null, [ elem.value.location, elem ], {},
@@ -456,15 +475,6 @@ function tweakAssocs( model ) {
     };
     setArtifactLink( elem.type, assocType._artifact );
 
-    if (!isV5preview) { // TODO(v5): Remove, only use $enclosed
-      elem.$filtered = {
-        val: true,
-        literal: 'boolean',
-        location,
-        $inferred: '$generated',
-      };
-    }
-
     const isComp = (getUnderlyingBuiltinType( assoc )?.name?.id === 'cds.Composition');
     if (isComp) {
       elem.$enclosed = {

package/lib/compiler/utils.js

@@ -125,7 +125,8 @@ function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDepreca
       // TODO throughout the compiler: do not set art.‹prop›.$inferred if art.$inferred
       if (kind)
         member.kind = kind;
-      else if (origin.key && !tmpDeprecated) // TODO(v5/v6): remove tmpDeprecated
+      else if (origin.key && !tmpDeprecated)
+        // TODO(v6): remove tmpDeprecated once `noKeyPropagationWithExpansions` is removed
         member.key = Object.assign( { $inferred: 'expanded' }, origin.key );
       if (kind && origin.masked)  // TODO: remove!
         member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );

package/lib/compiler/xsn-model.js

@@ -27,6 +27,10 @@ class XsnSource {
   artifacts = Object.create( null );
   vocabularies = Object.create( null );
   extensions = [];
+  $frontend;
+  constructor( frontend ) {
+    this.$frontend = frontend;
+  }
 }
 
 class XsnArtifact {

package/lib/edm/annotations/genericTranslation.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const { isEdmPropertyRendered, transformExpression } = require('../../model/csnUtils');
-const { isBuiltinType } = require('../../base/builtins');
+const { isBuiltinType, isMagicVariable } = require('../../base/builtins');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
@@ -60,6 +60,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     if (defName.startsWith(`${serviceName}.`))
       assignParameterAnnotations(def);
   });
+
   // Crawl over the csn and trigger the annotation translation for all kinds
   //   of annotated things.
   // Note: only works for single service
@@ -103,6 +104,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     const scopeCheck = {
       ref: (elemref, prop, xpr, path) => {
         if (scopeCheck.scope === 'param' &&
+          !isMagicVariable(xpr[0]) &&
           (!elemref.param ||
            (xpr[0].id || xpr[0]) === '$self' && !def.elements.$self)) {
           error('odata-anno-xpr-ref', path, { anno: scopeCheck.anno, elemref, '#': 'notaparam' });
@@ -221,13 +223,16 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
 
   function handleDefinition( defName, def, location ) {
     // definition bound annotations
-    handleAnnotations(defName, def, location);
+    handleAnnotations(defName, def, { location });
     // definition bound element annotations
     if (def.$elementsAnnoProxies) {
       Object.entries(def.$elementsAnnoProxies).forEach(([ elemPath, element ]) => {
         const edmTargetName = `${defName}/${elemPath}`;
-        handleAnnotations(edmTargetName, element, element.$path,
-                          [ ...location, '$elementsAnnoProxies', elemPath ]);
+        handleAnnotations(edmTargetName, element,
+                          {
+                            location: element.$path,
+                            csnPath: [ ...location, '$elementsAnnoProxies', elemPath ],
+                          });
       });
     }
     // element bound annotations
@@ -235,7 +240,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       Object.entries(def.elements).forEach(([ elemName, element ]) => {
         const edmTargetName = `${defName}/${elemName}`;
         const eLocation = [ ...location, 'elements', elemName ];
-        handleAnnotations(edmTargetName, element, eLocation);
+        handleAnnotations(edmTargetName, element, { location: eLocation });
       });
     }
     // bound actions
@@ -274,6 +279,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   //     entityNameIfBound : qualified name of entity if bound action/function
   function handleAction( cActionName, cAction, entityNameIfBound, location ) {
     let actionName = cActionName;
+
     if (isV2()) { // Replace up to last dot with <serviceName>.EntityContainer
       const lastDotIndex = actionName.lastIndexOf('.');
       if (lastDotIndex > -1)
@@ -283,55 +289,70 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       actionName += relParList();
     }
 
-    handleAnnotations(actionName, cAction, location);
+    handleAnnotations(actionName, cAction, { location, cAction });
 
     if (cAction.params) {
       if (cAction.$paramsAnnoProxies) {
         Object.entries(cAction.$paramsAnnoProxies).forEach(([ paramPath, param ]) => {
-          const edmTargetName = `${actionName}/${paramPath}`;
-          handleAnnotations(edmTargetName, param, param.$path,
-                            [ ...location, '$paramsAnnoProxies', paramPath ]);
+          // skip explicit binding parameter in V2
+          if (!(options.isV2() && param.type === '$self' && paramPath === cAction.$bindingParam?.name)) {
+            const edmTargetName = `${actionName}/${paramPath}`;
+            handleAnnotations(edmTargetName, param,
+                              {
+                                location: param.$path,
+                                csnPath: [ ...location, '$paramsAnnoProxies', paramPath ],
+                                cAction,
+                              });
+          }
         });
       }
+      // explicit binding parameter is removed from params in V2 during
+      // createActionV2(), no need to check ;)
       Object.entries(cAction.params).forEach(([ n, p ]) => {
         const edmTargetName = `${actionName}/${n}`;
         handleAnnotations(edmTargetName, p,
-                          [ ...location, 'params', n ]);
+                          {
+                            action: true,
+                            location: [ ...location, 'params', n ],
+                            cAction,
+                          });
       });
     }
     if (cAction.returns) {
       if (cAction.$returnsAnnoProxies) {
         Object.entries(cAction.$returnsAnnoProxies).forEach(([ returnsPath, returns ]) => {
           const edmTargetName = `${actionName}/${returnsPath}`;
-          handleAnnotations(edmTargetName, returns, returns.$path,
-                            [ ...location, '$returnsAnnoProxies', returnsPath ]);
+          handleAnnotations(edmTargetName, returns,
+                            {
+                              location: returns.$path,
+                              csnPath: [ ...location, '$returnsAnnoProxies', returnsPath ],
+                              cAction,
+                            });
         });
       }
       const edmTargetName = `${actionName}/$ReturnType`;
       setProp(cAction.returns, '$appliesToReturnType', true);
       handleAnnotations(edmTargetName, cAction.returns,
-                        [ ...location, 'returns' ]);
+                        {
+                          location: [ ...location, 'returns' ],
+                          cAction,
+                        });
       delete cAction.returns.$appliesToReturnType;
     }
 
     function relParList() {
-    // we rely on the order of params in the csn being the correct one
+      // we rely on the order of params in the csn being the correct one
       const params = [];
       if (entityNameIfBound) {
         // If this is an action and has an explicit binding parameter add it here
-        if (cAction.$bindingParam && cAction.kind === 'action') {
+        if (cAction.$bindingParam && cAction.kind === 'action' ||
+            cAction.$bindingParam?.viaAnno) {
           params.push(
             cAction.$bindingParam.items
               ? `Collection(${entityNameIfBound})`
               : entityNameIfBound
           );
         }
-        // If action/function has no explicit binding parameter add it here
-        else if (!cAction.$bindingParam) {
-          params.push(cAction['@cds.odata.bindingparameter.collection']
-            ? `Collection(${entityNameIfBound})`
-            : entityNameIfBound);
-        }
       }
       // In case this is a function the explicit binding parameter is part of
       // the functions params dictionary. Only for functions all parameters must
@@ -349,12 +370,12 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           return edmUtils.mapCdsToEdmType(p, messageFunctions, false /* is only called for v4 */);
         }
         else if (options.whatsMySchemaName) {
-          const schemaName = options.whatsMySchemaName(p.type);
+          const schemaName = options.whatsMySchemaName(p._edmType || p.type);
           // strip the service namespace of from a parameter type
           if (schemaName && schemaName !== options.serviceName)
-            return p.type.replace(`${options.serviceName}.`, '');
+            return (p._edmType || p.type).replace(`${options.serviceName}.`, '');
         }
-        return p.type;
+        return p._edmType || p.type;
       }
     }
   }
@@ -364,7 +385,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   //   edmTargetName : string, name of the target in edm
   //   carrier: object, the annotated cds thing, contains all the annotations
   //                    as properties with names starting with @
-  function handleAnnotations( edmTargetName, carrier, location, csnPathResolutionLocation = location ) {
+  //   ctx: locations and other information that is required to write the
+  //        annotations
+  function handleAnnotations( edmTargetName, carrier, ctx ) {
     // collect the names of the carrier's annotation properties
     // keep only those annotations that - start with a known vocabulary name
     //                                  - have a value other than null
@@ -378,6 +401,8 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       (isV2() && (edmUtils.isDerivedType(carrier))))
       return;
 
+    if (ctx.location == null)
+      throw Error('location required');
 
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
@@ -397,15 +422,15 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
         transformExpression(carrier, knownAnno, {
           ref: (elemref, prop, xpr, csnPath) => {
             if (options.isV2() && elemref.$bparam) {
-              error('odata-anno-xpr-ref', location, {
-                elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2',
+              error('odata-anno-xpr-ref', ctx.location, {
+                elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2_expl',
               });
               return;
             }
             const { links, scope } = reqDefsUtils.inspectRef(csnPath);
             let i = scope === '$self' ? 1 : 0;
             if (scope === '$magic') {
-              error('odata-anno-xpr-ref', location, {
+              error('odata-anno-xpr-ref', ctx.location, {
                 elemref, anno: knownAnno, '#': 'magic',
               });
               return;
@@ -413,7 +438,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
             let stop = false;
             for (; i < links.length && !stop; i++) {
               if (!isEdmPropertyRendered(links[i].art, csnPath)) {
-                error('odata-anno-xpr-ref', location, {
+                error('odata-anno-xpr-ref', ctx.location, {
                   count: i + 1, elemref, anno: knownAnno, '#': 'notrendered',
                 });
                 stop = true;
@@ -422,16 +447,27 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
                 const proxy = links[i].art?._target;
                 const eltName = links[i + 1].art?.name;
                 if (!proxy.elements[eltName]) {
-                  error('odata-anno-xpr-ref', location, {
+                  error('odata-anno-xpr-ref', ctx.location, {
                     count: i + 2, elemref, anno: knownAnno, '#': 'notrendered',
                   });
                   stop = true;
                 }
               }
             }
+            if (!stop && ctx.cAction?.$isBound && scope === '$self') {
+              if (options.isV2()) {
+                error('odata-anno-xpr-ref', ctx.location, {
+                  elemref, anno: knownAnno, version: '2.0', '#': 'bparam_v2_impl',
+                });
+              }
+              else {
+                xpr[0] = ctx.cAction.$bindingParam.name;
+                elemref.param = true;
+              }
+            }
           },
-        }, csnPathResolutionLocation);
-        xpr2edmJson(carrier, knownAnno, location, options, messageFunctions);
+        }, ctx.csnPath || ctx.location);
+        xpr2edmJson(carrier, knownAnno, ctx.location, options, messageFunctions);
       }
     });
 
@@ -458,7 +494,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     const alternativeAnnotations = [];
 
     // now create annotation objects for all the annotations of carrier
-    handleAnno2(addAnnotation, prefixTree, location);
+    handleAnno2(addAnnotation, prefixTree, ctx.location);
 
     // Produce Edm.Annotations and attach collected Edm.Annotation(s) to the
     // envelope (or directly to the Schema)
@@ -507,7 +543,6 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     }
 
     function initCarrierControlVars() {
-    // eslint-disable-next-line no-unused-vars
       let testToStandardEdmTargetP = () => true; // if true, assign to standard Edm Target
       let stdEdmTargetNameP = edmTargetName;
       let alternativeEdmTargetNameP = null;
@@ -783,7 +818,6 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
           // 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
-          // eslint-disable-next-line sonarjs/no-collapsible-if
           if (!addAnnotationFunc(anno, dictTerm && dictTerm.AppliesTo)) {
             if (dictTerm && dictTerm.AppliesTo) {
               message('odata-anno-def', location,

package/lib/edm/csn2edm.js

@@ -732,11 +732,13 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           if (type === special$self) {
             bpName = entries[0][0];
             setProp(actionCsn, '$bindingParam', firstParam);
+            // preserve the original type (as it is the key to reqDefs.defintions)
+            // for annotation path resolution (eg. for $draft.IsActiveEntity)
             if (bpType) {
               if (firstParam.items?.type)
-                firstParam.items.type = bpType;
+                setProp(firstParam.items, '_edmType', bpType);
               if (firstParam.type)
-                firstParam.type = bpType;
+                setProp(firstParam, '_edmType', bpType);
             }
             if (!edmUtils.isODataSimpleIdentifier(bpName))
               message('odata-spec-violation-id', [ ...location, 'params', bpName ], { id: bpName });
@@ -775,11 +777,20 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         if (entityCsn) {
           actionNode.setEdmAttribute('IsBound', true);
           if (!actionCsn.$bindingParam) {
+            const bpDef = {
+              name: bpName,
+              viaAnno: true,
+            };
             // Binding Parameter: 'in' at first position in sequence, this is decisive!
-            if (actionCsn['@cds.odata.bindingparameter.collection'])
+            if (actionCsn['@cds.odata.bindingparameter.collection']) {
               actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection: true/* , Nullable: false */ } ));
-            else
+              bpDef.items = { type: bpType };
+            }
+            else {
               actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType } ));
+              bpDef.type = bpType;
+            }
+            setProp(actionCsn, '$bindingParam', bpDef);
           }
         }
         else if (EntityContainer) { // unbound => produce Action/FunctionImport
@@ -891,6 +902,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             if (i === 0 && type === special$self) {
             // skip and remove the first parameter if it is a $self binding parameter to
             // omit annotation rendering later on
+              setProp(actionCsn, '$bindingParam', parameterCsn);
               delete actionCsn.params[parameterName];
             }
             else {

package/lib/edm/edm.js

@@ -625,7 +625,8 @@ function getEdm( options, messageFunctions ) {
               edmUtils.addTypeFacets(this, this._scalarType);
           }
           else {
-            this._edmAttributes[typeName] = typecsn.type;
+            // it's either _edmType or type (_edmType only used for explicit binding param)
+            this._edmAttributes[typeName] = typecsn._edmType || typecsn.type;
           }
         }
         // CDXCORE-245:
@@ -882,12 +883,20 @@ function getEdm( options, messageFunctions ) {
   class ReturnType extends PropertyBase {
     constructor(version, csn) {
       super(version, {}, csn);
+      // CSDL 12.8: If the return type is a collection of entity types,
+      // the Nullable attribute has no meaning and MUST NOT be specified.
+      if (csn.$NoNullableProperty)
+        delete this._edmAttributes.Nullable;
     }
 
     // we need Name but NO $kind, can't use standard to JSON()
     toJSON() {
       const json = Object.create(null);
       this.toJSONattributes(json);
+      // CSDL 12.8: If the return type is a collection of entity types,
+      // the Nullable attribute has no meaning and MUST NOT be specified.
+      if (this._csn.$NoNullableProperty)
+        delete json.$Nullable;
       return json;
     }
   }
@@ -897,7 +906,6 @@ function getEdm( options, messageFunctions ) {
       super(version, attributes, csn);
       // TIPHANACDS-4180
       if (this.v2) {
-        // eslint-disable-next-line sonarjs/no-redundant-boolean
         if (csn['@odata.etag'] || csn['@cds.etag'])
           this._edmAttributes.ConcurrencyMode = 'Fixed';
 
@@ -1037,7 +1045,6 @@ function getEdm( options, messageFunctions ) {
           See csn2edm.createEntityTypeAndSet() for details
           2) ContainsTarget stems from the @odata.contained annotation
         */
-        // eslint-disable-next-line sonarjs/no-redundant-boolean
         if (csn['@odata.contained'] || csn.containsTarget)
           this._edmAttributes.ContainsTarget = true;
 

package/lib/edm/edmAnnoPreprocessor.js

@@ -59,7 +59,6 @@ function applyAppSpecificLateCsnTransformationOnElement( options, element, struc
   // runtime cannot set that okra flag (alternatively the runtime has to search
   // for @[odata|cds].etag annotations...
   if (options.isV4() && (element['@odata.etag'] || element['@cds.etag'])) {
-    // eslint-disable-next-line sonarjs/no-redundant-boolean
     // don't put element name into collection as per advice from Ralf Handl, as
     // no runtime is interested in the property itself, it is sufficient to mark
     // the entity set.
@@ -243,7 +242,7 @@ function setSAPSpecificV2AnnotationsToEntitySet( options, carrier ) {
     '@sap.updatable.path': addToSetAttr,
     '@sap.deletable.path': addToSetAttr,
     '@sap.searchable': addToSetAttr,
-    '@sap.pagable': addToSetAttr,
+    '@sap.pageable': addToSetAttr,
     '@sap.topable': addToSetAttr,
     '@sap.countable': addToSetAttr,
     '@sap.addressable': addToSetAttr,

package/lib/edm/edmPreprocessor.js

@@ -100,7 +100,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     as a step in the OData transformer with the goal to have a protocol agnostic OData CSN.
   */
   if (csn.meta && csn.meta.options && csn.meta.options.odataVersion === 'v4' && options.isV2()) {
-    // eslint-disable-next-line global-require
     const { toFinalBaseType } = require('../transform/transformUtils').getTransformers(csn, options, messageFunctions);
     expandCSNToFinalBaseType(csn, { toFinalBaseType }, csnUtils, serviceRootNames, options);
   }
@@ -704,11 +703,6 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
         validFrom.push(element);
 
       // forward annotations from managed association element to its foreign keys
-      // TODO: Try to eliminate this code by rearranging
-      // forOdata::addCommonValueListviaAssociation(member, memberName)
-      // such that the VL annotations are distributed to the associations *before*
-      // FK creation.
-      // The FK creation already propagates the annotations from the association
       const elements = construct.items?.elements || construct.elements;
       const assoc = elements[element['@odata.foreignKey4']];
       if (assoc) {
@@ -1892,7 +1886,7 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
     mapCdsToEdmProp(def);
     annotateAllowedValues(def, defLocation);
     if (def.returns) {
-      markCollection(def.returns);
+      markCollection(def.returns, true);
       mapCdsToEdmProp(def.returns);
       annotateAllowedValues(def.returns, [ ...defLocation, 'returns' ]);
     }
@@ -1905,17 +1899,21 @@ function initializeModel( csn, _options, messageFunctions, requestedServiceNames
       rewriteAnnotationExpressions(member);
       if (member.returns) {
         edmUtils.assignAnnotation(member.returns, '@Core.Description', member.returns.doc);
-        markCollection(member.returns);
+        markCollection(member.returns, true);
         mapCdsToEdmProp(member.returns);
         annotateAllowedValues(member.returns, [ ...location, 'returns' ]);
         rewriteAnnotationExpressions(member.returns);
       }
     }, defLocation);
     // mark members that need to be rendered as collections
-    function markCollection( obj ) {
+    function markCollection( obj, isReturns ) {
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
       if (items) {
-        edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : true);
+        edmUtils.assignProp(obj, '$NoNullableProperty',
+                            isReturns && items.type &&
+                            !isBuiltinType(items.type) &&
+                            csn.definitions[items.type]?.kind === 'entity');
+        edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : false);
         edmUtils.assignProp(obj, '$isCollection', true);
       }
     }