@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/edm/edmPreprocessor.js

@@ -1,9 +1,8 @@
 'use strict';
 /* eslint max-statements-per-line:off */
 const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
-const { forEachDefinition, forEachGeneric, forEachMember, forEachMemberRecursively,
+const { forEachDefinition, forEachGeneric, forEachMemberRecursively,
   isEdmPropertyRendered, getUtils, cloneCsn, isBuiltinType } = require('../model/csnUtils');
-const { makeMessageFunction } = require('../base/messages');
 const edmUtils = require('./edmUtils.js');
 const typesExposure = require('../transform/odata/typesExposure');
 const expandCSNToFinalBaseType = require('../transform/odata/toFinalBaseType');
@@ -35,12 +34,11 @@ const {
  * @param {CSN.Model} csn
  * @param {object}    _options
  */
-function initializeModel(csn, _options)
+function initializeModel(csn, _options, messageFunctions)
 {
   if (!_options)
     throw Error('Please debug me: initializeModel must be invoked with options');
 
-  const messageFunctions = makeMessageFunction(csn, _options);
   const { info, warning, error, throwWithError } = messageFunctions;
 
   const csnUtils = getUtils(csn);
@@ -56,7 +54,7 @@ function initializeModel(csn, _options)
   let options = validateOptions(_options);
 
   // Fetch service definitions
-  const serviceRoots = Object.keys(csn.definitions).reduce((serviceRoots, artName) => {
+  const serviceRoots = Object.keys(csn.definitions || {}).reduce((serviceRoots, artName) => {
     const art = csn.definitions[artName];
     if(art.kind === 'service') {
       serviceRoots[artName] = Object.assign(art, { name: artName });
@@ -69,6 +67,9 @@ function initializeModel(csn, _options)
   function whatsMyServiceRootName(n, self=true) {
     return serviceRootNames.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') || (n === sn && self) ? sn : rc, undefined);
   }
+  if(serviceRootNames.length === 0) {
+    return [serviceRoots, Object.create(null), whatsMyServiceRootName, options];
+  }
 
   // Structural CSN inbound QA checks
   inboundQualificationChecks();
@@ -142,14 +143,18 @@ function initializeModel(csn, _options)
     // must be run before proxy exposure to avoid potential reference collisions
     convertExposedTypesOfOtherServicesIntoCrossReferences();
     // create association target proxies
-    forEachDefinition(csn, exposeTargetsAsProxiesOrSchemaRefs);
+    // Decide if an entity set needs to be constructed or not
+    forEachDefinition(csn, [ exposeTargetsAsProxiesOrSchemaRefs, determineEntitySet ]);
+    if(options.isV4())
+      forEachDefinition(csn, initializeEdmNavPropBindingTargets);
 
     // Things that can be done in one pass
     // Create edmKeyRefPaths
-    // Decide if an entity set needs to be constructed or not
+    // Create NavigationPropertyBindings, requires determineEntitySet
     // Map /** doc comments */ to @CoreDescription
     // Artifact identifier spec compliance check (should be run last)
-    forEachDefinition(csn, [ initializeEdmKeyRefPaths, determineEntitySet, initializeEdmTypesAndDescription, checkArtifactIdentifierAndBoundActions ]);
+    forEachDefinition(csn, [ initializeEdmKeyRefPaths, initializeEdmNavPropBindingPaths,
+      initializeEdmTypesAndDescription, checkArtifactIdentifierAndBoundActions ]);
   }
   return [serviceRoots, schemas, whatsMyServiceRootName, options];
 
@@ -337,33 +342,57 @@ function initializeModel(csn, _options)
   //   entity set. Instead try to rewrite the annotation in such a way that it is effective
   //   on the containment navigation property.
   function initializeContainments(container) {
-    forEachMemberRecursively(container, (element, elementName) => {
-      if(isAssociationOrComposition(element) && !element._ignore) {
-        if(element['@odata.contained']) {
+    if(['entity', 'view'].includes(container.kind)) {
+      forEachMemberRecursively(container, initContainments,
+        [], true, { elementsOnly: true });
+    }
+
+    function initContainments(elt, eltName) {
+      if(isAssociationOrComposition(elt) && elt['@odata.contained'] && !elt._ignore) {
         // Let the containee know its container
         // (array because the contanee may contained more then once)
-          let containee = element._target;
-          if (!containee._containerEntity) {
-            setProp(containee, '_containerEntity', []);
-          }
+        let containee = elt._target;
+        if (!containee._containerEntity)
+          setProp(containee, '_containerEntity', []);
         // add container only once per containee
-          if (!containee._containerEntity.includes(container.name)) {
-            containee._containerEntity.push(container.name);
-          // Mark associations in the containee pointing to the container (i.e. to this entity)
-            containee.elements && Object.values(containee.elements).forEach( containeeElement => {
-              if (containeeElement._target && containeeElement._target.name) {
-              // If this is an association that points to a container (but is not by itself contained,
-              // which would indicate the top role in a hierarchy) mark it with '_isToContainer'
-                if (containeeElement._target.name == container.name && !containeeElement['@odata.contained']) {
-                  setProp(containeeElement, '_isToContainer', true);
-                }
-              }
-            });
-          }
-          rewriteContainmentAnnotations(container, containee, elementName);
+        if (!containee._containerEntity.includes(container.name))
+          containee._containerEntity.push(container.name);
+        // Mark associations in the containee pointing to the container (i.e. to this entity)
+        forEachMemberRecursively(containee, markToContainer,
+          [], true, { elementsOnly: true });
+        rewriteContainmentAnnotations(container, containee, eltName);
+      }
+      else {
+          // try to find elements to drill down further
+        while(elt && !(isBuiltinType(elt.type) || elt.elements)) {
+          elt = csn.definitions[elt.type];
+        }
+        if(elt && elt.elements) {
+          forEachMemberRecursively(elt, initContainments,
+            [], true, { elementsOnly: true });
         }
       }
-    });
+    }
+
+    function markToContainer(elt) {
+      if(elt._target && elt._target.name) {
+        // If this is an association that points to the container (but is not by itself contained,
+        // which would indicate the top role in a hierarchy) mark it with '_isToContainer'
+        if(elt._target.name === container.name && !elt['odata.contained']) {
+          setProp(elt, '_isToContainer', true);
+        }
+      }
+      else {
+        // try to find elements to drill down further
+        while(elt && !(isBuiltinType(elt.type) || elt.elements)) {
+          elt = csn.definitions[elt.type];
+        }
+        if(elt && elt.elements) {
+          forEachMemberRecursively(elt, markToContainer,
+            [], true, { elementsOnly: true });
+        }
+      }
+    }
   }
 
   // Split an entity with parameters into two entity types with their entity sets,
@@ -420,7 +449,6 @@ function initializeModel(csn, _options)
     assignProp(parameterCsn, '_SetAttributes',
       {'@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.pageable': false });
 
-    assignProp(parameterCsn, '$keys', Object.create(null));
     setProp(parameterCsn, '$isParamEntity', true);
     setProp(parameterCsn, '$mySchemaName', entityCsn.$mySchemaName);
 
@@ -438,9 +466,10 @@ function initializeModel(csn, _options)
       elt.name = n;
       delete elt.kind;
       elt.key = true; // params become primary key in parameter entity
-      parameterCsn.$keys[n] = parameterCsn.elements[n] = elt;
+      parameterCsn.elements[n] = elt;
     });
-
+    linkAssociationTarget(parameterCsn);
+    initializeContainments(parameterCsn);
     // add assoc to result set, FIXME: is the cardinality correct?
     parameterCsn.elements[parameterToOriginalAssocName] = {
       '@odata.contained': true,
@@ -543,16 +572,17 @@ function initializeModel(csn, _options)
     let keys = Object.create(null);
     let validFrom = [], validKey = [];
 
-    let structParent = def.items || def;
-
     // Iterate all struct elements
-    forEachGeneric(structParent, 'elements', (element, elementName) => {
-      initElement(element, elementName, def);
+    forEachMemberRecursively(def.items || def, (element, elementName, prop, path = [], construct) => {
+      if(!['elements'].includes(prop))
+        return;
+
+      initElement(element, elementName, construct);
 
       if(!['event', 'aspect'].includes(def.kind)) {
         if(element._parent && element._parent.$mySchemaName) {
           if(!isODataSimpleIdentifier(elementName)) {
-            signalIllegalIdentifier(elementName, ['definitions', def.name, 'elements', elementName]);
+            signalIllegalIdentifier(elementName, ['definitions', def.name].concat(path));
           } else if (options.isV2() && /^(_|[0-9])/.test(elementName) && ['view', 'entity'].includes(element._parent.kind)) {
             // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
             error(null, ['definitions', def.name, 'elements', elementName], { prop: elementName[0] },
@@ -567,6 +597,16 @@ function initializeModel(csn, _options)
       if(element['@cds.valid.from']) {
         validFrom.push(element);
       }
+      //forward annotations from managed association element to its foreign keys
+      const elements = construct.items && construct.items.elements || construct.elements;
+      forAll(elements[element['@odata.foreignKey4']], (attr, attrName) => {
+        if(attrName[0] === '@') {
+          element[attrName] = attr;
+        }
+      });
+      // and eventually remove some afterwards:)
+      if(options.isV2())
+        setSAPSpecificV2AnnotationsToAssociation(element);
 
       // initialize an association
       if(isAssociationOrComposition(element)) {
@@ -575,18 +615,6 @@ function initializeModel(csn, _options)
         assignProp(element._target, '$proxies', []);
         // $abspath is used as partner path
         assignProp(element, '$abspath', $path2path(element.$path));
-
-        //forward annotations from managed association element to its foreign keys
-        if(element.keys && options.isFlatFormat) {
-          for(let fk of element.keys) {
-            forAll(element, (attr, attrName) => {
-              if(attrName[0] === '@' && fk.$generatedFieldName)
-                def.elements[fk.$generatedFieldName][attrName] = attr;
-            });
-          }
-        }
-        // and afterwards eventually remove some :)
-        setSAPSpecificV2AnnotationsToAssociation(options, element, def);
       }
 
       // Collect keys
@@ -594,7 +622,7 @@ function initializeModel(csn, _options)
         keys[elementName] = element;
       }
       applyAppSpecificLateCsnTransformationOnElement(options, element, def, error);
-    });
+    }, [], true, { elementsOnly: true });
 
     if(!isDeprecatedEnabled(options, 'v1KeysForTemporal')) {
       // if artifact has a cds.valid.key mention it as @Core.AlternateKey
@@ -646,14 +674,14 @@ function initializeModel(csn, _options)
     if(!isStructuredArtifact(struct))
       return;
 
-    forEachMember(struct, element => {
+    forEachMemberRecursively(struct.items || struct, (element) => {
       if (isAssociationOrComposition(element) && !element._ignore) {
         // setup the constraints object
         setProp(element, '_constraints', { constraints: Object.create(null), selfs: [], _origins: [], termCount: 0 });
         // and crack the ON condition
         resolveOnConditionAndPrepareConstraints(csn, element, messageFunctions);
       }
-    });
+    }, [], true, { elementsOnly: true });
   }
 
   /*
@@ -669,13 +697,16 @@ function initializeModel(csn, _options)
     4) All of this can be revoked with options.renderForeignKeys.
   */
   function ignoreProperties(struct) {
-    forEachGeneric(struct, 'elements', (element) => {
+    if(!isStructuredArtifact(struct))
+      return;
+
+    forEachMemberRecursively(struct.items || struct, (element) => {
       if(!element.target) {
         if(element['@odata.foreignKey4']) {
           let isContainerAssoc = false;
-          let elements = struct.elements;
+          let elements = (struct.items || struct).elements;
           let assoc = undefined;
-          let paths = element['@odata.foreignKey4'].split('.')
+          const paths = element['@odata.foreignKey4'].split('.')
           for(let p of paths) {
             assoc = elements[p];
             if(assoc) // could be that the @odata.foreignKey4 was propagated...
@@ -714,7 +745,7 @@ function initializeModel(csn, _options)
           // ignore it if option odataContainment is true and no foreign keys should be rendered
         assignAnnotation(element, '@odata.navigable', false);
       }
-    });
+    }, [], true, { elementsOnly: true });
   }
 
   /*
@@ -726,7 +757,7 @@ function initializeModel(csn, _options)
     if(!isStructuredArtifact(struct))
       return;
 
-    forEachMember(struct, element => {
+    forEachMemberRecursively(struct.items || struct, (element) => {
       if (isAssociationOrComposition(element) && !element._ignore) {
         finalizeReferentialConstraints(csn, element, options, info);
 
@@ -753,7 +784,7 @@ function initializeModel(csn, _options)
           }
         }
       }
-    });
+    }, [], true, { elementsOnly: true });
   }
 
   /*
@@ -816,7 +847,7 @@ function initializeModel(csn, _options)
     const globalSchemaPrefix = whatsMyServiceRootName(struct.$mySchemaName);
     // if this artifact is a service member check its associations
     if(globalSchemaPrefix) {
-      forEachGeneric(struct, 'elements', element => {
+      forEachGeneric(struct.items || struct, 'elements', element => {
         if(!isAssociationOrComposition(element) || element._ignore || element['@odata.navigable'] === false)
           return;
         /*
@@ -874,7 +905,7 @@ function initializeModel(csn, _options)
               }
               else {
                 // fake the target to be proxy
-                element._target.$externalRef = true;
+                setProp(element._target, '$externalRef', true);
               }
             }
             else {
@@ -923,7 +954,6 @@ function initializeModel(csn, _options)
       setProp(proxy, '$keys', Object.create(null));
       setProp(proxy, '$hasEntitySet', false);
       setProp(proxy, '$exposedTypes', Object.create(null));
-
       // copy all annotations of the target to the proxy
       Object.entries(assoc._target).forEach(([k, v]) => {
         if(k[0] === '@')
@@ -1070,10 +1100,12 @@ function initializeModel(csn, _options)
             if(!elem.target) {
               type.elements[elemName] = Object.create(null);
               Object.keys(elem).forEach(prop => type.elements[elemName][prop] = elem[prop])
+              type.elements[elemName].notNull = true;
             }
             else {
               type.elements[elemName] = createProxyOrSchemaRefForManagedAssoc(elem);
             }
+            setProp(type.elements[elemName], 'name', elem.name);
           });
           return type;
         }
@@ -1100,6 +1132,7 @@ function initializeModel(csn, _options)
           // art is in the target side, clone it and remove key property
           let cloneArt = cloneCsn(art, options);
           setProp(cloneArt, 'name', art.name);
+          cloneArt.notNull = true;
           delete cloneArt.key;
           newElt.elements[art.name] = cloneArt;
         });
@@ -1189,14 +1222,14 @@ function initializeModel(csn, _options)
     function registerProxy(proxy, element) {
       if(proxy === undefined)
         return undefined;
-      const proxyName = globalSchemaPrefix + '.' + proxy.name;
-      const schemaName = globalSchemaPrefix + '.' + proxy.$mySchemaName;
+      const fqProxyName = globalSchemaPrefix + '.' + proxy.name;
+      const fqSchemaName = globalSchemaPrefix + '.' + proxy.$mySchemaName;
 
       if(!element._target.$cachedProxy)
         assignProp(element._target, '$cachedProxy', Object.create(null));
       if(getProxyForTargetOf(element)) {
         info(null, ['definitions', struct.name, 'elements', element.name],
-          { name: proxyName }, 'Proxy EDM entity type $(NAME) has already been registered');
+          { name: fqProxyName }, 'Proxy EDM entity type $(NAME) has already been registered');
       }
       else
         element._target.$cachedProxy[globalSchemaPrefix] = proxy;
@@ -1206,7 +1239,7 @@ function initializeModel(csn, _options)
         // (that may reside in another subcontext schema), but only once
         const schemaSet = new Set();
         // start with the schema name for the proxy
-        schemaSet.add(schemaName);
+        schemaSet.add(fqSchemaName);
         // followed by all namespaces that are potentially exposed by the exposed types
         // don't forget to prepend the global namespace prefix
         // schemas are ordered in csn2edm.js for each service
@@ -1219,12 +1252,16 @@ function initializeModel(csn, _options)
           }
         });
         /** @type {object} */
-        const alreadyRegistered = csn.definitions[proxyName]
+        const alreadyRegistered = csn.definitions[fqProxyName]
         if(!alreadyRegistered) {
-          csn.definitions[proxyName] = proxy;
+          csn.definitions[fqProxyName] = proxy;
+          setProp(proxy, '$path', ['definitions', fqProxyName]);
           Object.entries(proxy.$exposedTypes).forEach(([tn, v]) => {
-            if(csn.definitions[globalSchemaPrefix + '.' + tn] === undefined)
-              csn.definitions[globalSchemaPrefix + '.' + tn] = v;
+            const fqtn = globalSchemaPrefix + '.' + tn;
+            if(csn.definitions[fqtn] === undefined) {
+              csn.definitions[fqtn] = v;
+              setProp(v, '$path', ['definitions', fqtn]);
+            }
           });
           info(null, ['definitions', element._parent.name, 'elements', element.name],
             { name: proxy.name }, 'Created proxy EDM entity type $(NAME)');
@@ -1232,16 +1269,16 @@ function initializeModel(csn, _options)
         else if(alreadyRegistered && !alreadyRegistered.$proxy &&
           !['entity', 'view'].includes(alreadyRegistered.kind)) {
           warning(null, ['definitions', element._parent.name, 'elements', element.name],
-            { name: proxyName, kind: alreadyRegistered.kind },
+            { name: fqProxyName, kind: alreadyRegistered.kind },
             'No proxy EDM entity type created due to name collision with $(NAME) of kind $(KIND)');
           return undefined;
         }
       }
       else {
         // it's a service reference, just add that reference proxy
-        if(!schemas[schemaName]) {
-          schemas[schemaName] = proxy;
-          schemaNames.push(schemaName);
+        if(!schemas[fqSchemaName]) {
+          schemas[fqSchemaName] = proxy;
+          schemaNames.push(fqSchemaName);
           info(null, ['definitions', struct.name, 'elements', element.name],
             { name: proxy.name }, 'Created EDM namespace reference $(NAME)');
         }
@@ -1286,11 +1323,8 @@ function initializeModel(csn, _options)
           else if(!k.target) {
             struct.$edmKeyPaths.push([kn]);
           }
-          // complain about nullable keys in toplevel
-          if(k.notNull === false) {
-            const pathToElement = ['definitions', struct.name, 'elements', k.name];
-            signalErrorForNullableKey(pathToElement);
-          }
+          // check toplevel key for spec violations
+          checkKeySpecViolations(k, ['definitions', struct.name, 'elements', k.name]);
         }
       });
     }
@@ -1306,7 +1340,7 @@ function initializeModel(csn, _options)
       If element is of scalar type, return it as an array.
     */
     function produceKeyRefPaths(eltCsn, prefix) {
-      let keyPaths = [];
+      const keyPaths = [];
       if(!isEdmPropertyRendered(eltCsn, options)) {
         // let annos = Object.keys(eltCsn).filter(a=>a[0]==='@').join(', ');
         // warning(null, ['definitions', struct.name, 'elements', eltCsn.name ],
@@ -1314,15 +1348,20 @@ function initializeModel(csn, _options)
         return keyPaths;
       }
       // OData requires all elements along the path to be nullable: false (that is either key or notNull)
-      let elements = eltCsn.elements || getFinalTypeDef(eltCsn.items && eltCsn.items.type || eltCsn.type).elements;
+
+      const finalType = getFinalTypeDef(eltCsn.items && eltCsn.items.type || eltCsn.type);
+      const elements = eltCsn.elements || eltCsn.items && eltCsn.items.elements || 
+      (finalType && (finalType.elements || finalType.items && finalType.items.elements));
       if(elements) {
         Object.entries(elements).forEach(([eltName, elt]) => {
-          keyPaths.push(...produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName));
-          if(elt.notNull === false && !isBuiltinType(elt)) {
-            const odataKeyPath = `${prefix}/${eltName}`;
+          const newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName);
+          if(newRefs.length) {
+            keyPaths.push(...newRefs);
+            // check path step key for spec violations
+            const pathSegment = `${prefix}/${eltName}`;
             // we want to point to the element in the entity which is the first path step
-            const pathToMaliciousKey = struct.$path.concat(['elements']).concat(odataKeyPath.split('/')[0]);
-            signalErrorForNullableKey(pathToMaliciousKey, odataKeyPath);
+            const location = struct.$path.concat(['elements']).concat(pathSegment.split('/')[0]);
+            checkKeySpecViolations(elt, location, pathSegment);
           }
         });
       }
@@ -1353,17 +1392,169 @@ function initializeModel(csn, _options)
       return keyPaths;
     }
 
-    function signalErrorForNullableKey(pathToElement, keyElement) {
-      error(null, pathToElement,
-        {name: keyElement, '#': keyElement ? 'std' : 'scalar'},
-        {
-          std: 'Key element $(NAME) must not be nullable',
-          scalar: 'Key element must not be nullable'
+    function checkKeySpecViolations(elt, location, pathSegment) {
+      // Nullability
+      if((!elt.key && (elt.notNull === undefined || elt.notNull === false)) ||
+           elt.key && (elt.notNull !== undefined && elt.notNull === false)) {
+        error('odata-spec-violation-key-null', location,
+          {name: pathSegment, '#': pathSegment ? 'std' : 'scalar'});
+      }
+      // many
+      let type = elt.items || elt.type && !isBuiltinType(elt.type) && getFinalTypeDef(elt.type).items;
+      if(type) {
+        error('odata-spec-violation-key-array', location,
+          {name: pathSegment, '#': pathSegment ? 'std' : 'scalar'});
+      }
+      // type
+      if(!elt.elements) {
+        if(!type)
+          type = isBuiltinType(elt.type) ? elt : csn.definitions[elt.type];
+
+        // check for legal scalar types, proxy exposed structured types are not resolvable in CSN
+        // V2 allows any Edm.PrimitiveType (even Double and Binary), V4 is more specific:
+        if(options.isV4() && type && !isAssociationOrComposition(type) && isBuiltinType(type.type)) {
+          const edmType = edmUtils.mapCdsToEdmType(type);
+          const legalEdmTypes = [
+            'Edm.Boolean', 'Edm.Byte', 'Edm.Date', 'Edm.DateTimeOffset', 'Edm.Decimal', 'Edm.Duration', 
+            'Edm.Guid', 'Edm.Int16', 'Edm.Int32', 'Edm.Int64', 'Edm.SByte', 'Edm.String', 'Edm.TimeOfDay' ];
+          if(!legalEdmTypes.includes(edmType)) {
+            warning('odata-spec-violation-key-type', location,
+          {name: pathSegment, type: type.type, id: edmType, '#': pathSegment ? 'std' : 'scalar'});
+          }
         }
-        );
+      }
     }
   }
 
+  /*
+    Calculate all reachable entity set paths for a given navigation start point
+
+    Rule: First non-containment association terminates Path, if association is
+    containment enabling assoc, Target is own Struct/ plus the path down to the
+    n-2nd path segment (which is the path to the n-1st implicit entity set).
+
+    Example:
+    entity Header {
+      items: composition of many {
+        toF: association to F;
+        subitems: composition of many {
+          toG: association to G;
+          subitems: composition of many {
+            toG: association to G;
+          };
+        }
+      }
+    }
+    Must produce:
+    Path="items/up_" Target="Header"/>
+    Path="items/toF" Target="F"/>
+    Path="items/subitems/up_" Target="Header/items"/>
+    Path="items/subitems/toG" Target="G"/>
+    Path="items/subitems/subitems/up_" Target="Header/items/subitems"/>
+    Path="items/subitems/subitems/toG" Target="G"/>
+  */
+  function initializeEdmNavPropBindingTargets(struct) {
+    if(options.isV4() && struct.$mySchemaName && struct.$hasEntitySet) {
+      forEachGeneric(struct.items || struct, 'elements', (element) => {
+        produceTargetPath([edmUtils.getBaseName(struct.name)], element, struct);
+      });
+    }
+
+    function produceTargetPath(prefix, elt, curDef) {
+      const newPrefix = [...prefix, elt.name];
+      if(isEdmPropertyRendered(elt, options)) {
+        // Assoc can never be a derived TypeDefinition, no need to
+        // unroll derived type chains for assocs
+        if(isAssociationOrComposition(elt) && !elt.$touched) {
+          if(!elt._target.$edmTgtPaths)
+            setProp(elt._target, '$edmTgtPaths', []);
+          if(!elt._target.$hasEntitySet && !elt._isToContainer && curDef !== elt._target) {
+            // follow elements in the target but avoid cycles
+            setProp(elt, '$touched', true);
+            elt._target.$edmTgtPaths.push(newPrefix);
+            Object.values(elt._target.elements).forEach(e => produceTargetPath(newPrefix, e, elt._target));
+            delete elt.$touched;
+          }
+        }
+        else {
+          // try to find elements to drill down further
+          while(elt && !(isBuiltinType(elt.type) || elt.elements)) {
+            elt = csn.definitions[elt.type];
+          }
+          elt && elt.elements && Object.values(elt.elements).forEach(e => produceTargetPath(newPrefix, e, curDef));
+        }
+      }
+    }
+  }
+
+  function initializeEdmNavPropBindingPaths(struct) {
+    if(options.isV4() && struct.$mySchemaName && struct.$hasEntitySet) {
+      let npbs = [];
+      forEachGeneric(struct.items || struct, 'elements', (element) => {
+        npbs = npbs.concat(produceNavigationPath(element, struct));
+      });
+      setProp(struct, '$edmNPBs', npbs);
+    }
+
+    // collect all paths originating from this element that end up in an entity set
+    function produceNavigationPath(elt, curDef) {
+      let npbs = [];
+      const prefix = elt.name;
+      if(isEdmPropertyRendered(elt, options)) {
+        // Assoc can never be a derived TypeDefinition, no need to
+        // unroll derived type chains for assocs
+        if(isAssociationOrComposition(elt) && !elt.$touched) {
+          // drill into target only if
+          // 1) target has no entity set and this assoc is not going to the container
+          // 2) current definition and target are the same (cycle)
+          if(!elt._target.$hasEntitySet && !elt._isToContainer && curDef !== elt._target) {
+            // follow elements in the target but avoid cycles
+            setProp(elt, '$touched', true);
+            Object.values(elt._target.elements).forEach(e => npbs = npbs.concat(produceNavigationPath(e, elt._target)));
+            delete elt.$touched;
+          }
+          else if(!(options.odataContainment && options.isV4() && elt['@odata.contained'])) {
+            // end point reached but must not be an external reference nor a proxy nor a composition itself
+            // last assoc step must not be to-n and target a singleton
+            let p = undefined;
+            if (!elt._target.$externalRef && 
+              !(edmUtils.isToMany(elt) && edmUtils.isSingleton(elt._target, options.isV4()))) {
+              if(elt._target.$edmTgtPaths && elt._target.$edmTgtPaths.length) {
+                p = elt._target.$edmTgtPaths.find(p => p[0] === edmUtils.getBaseName(struct.name)) || elt._target.$edmTgtPaths[0];
+              }
+              else if(elt._target.$hasEntitySet) {
+                const baseName = edmUtils.getBaseName(elt._target.$entitySetName || elt._target.name);
+                // if own struct and target have a set they either are in the same $mySchemaName or not
+                // if target is in another schema, target the full qualified entity set
+                p = (elt._target.$mySchemaName === struct.$mySchemaName) ? 
+                  [ baseName ] : [elt._target.$mySchemaName + '.EntityContainer', baseName];
+              }
+              if(p) {
+                // if own struct and target have a set they either are in the same $mySchemaName or not
+                // if target is in another schema, target the full qualified entity set
+                const npb = {
+                  Path: elt.name,
+                  Target: p.join('/')
+                };
+                npbs.push( npb );
+              }
+            }
+            // Do not prepend prefix here!
+            return npbs;
+          }
+        }
+        else {
+          // try to find elements to drill down further
+          while(elt && !(isBuiltinType(elt.type) || elt.elements)) {
+            elt = csn.definitions[elt.type];
+          }
+          elt && elt.elements && Object.values(elt.elements).forEach(e => npbs = npbs.concat(produceNavigationPath(e, curDef)));
+        }
+      }
+      npbs.forEach(p => p.Path = prefix + '/' + p.Path );
+      return npbs;
+    }
+  }
 
   function determineEntitySet(struct) {
     // if this is an entity or a view, determine if an entity set is required or not
@@ -1827,7 +2018,7 @@ function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error
     let key =  { name: keyName, key : true, type : 'cds.String', '@sap.sortable':false, '@sap.filterable':false, '@UI.Hidden': true };
     elements[keyName] = key;
     setProp(struct, '$keys',{ [keyName] : key } );
-    forEachGeneric(struct, 'elements', (e,n) =>
+    forEachGeneric(struct.items || struct, 'elements', (e,n) =>
     {
       if(e.key) delete e.key;
       elements[n] = e;
@@ -1967,19 +2158,17 @@ function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
   }
 }
 
-function setSAPSpecificV2AnnotationsToAssociation(options, carrier, struct) {
-  if(!options.isV2())
-    return;
+function setSAPSpecificV2AnnotationsToAssociation(carrier) {
   // documented in https://wiki.scn.sap.com/wiki/display/EmTech/SAP+Annotations+for+OData+Version+2.0
   const SetAttributes = {
     // Applicable to NavProp and foreign keys, add to AssociationSet
-    '@sap.creatable' : (struct, c,pn, pv) => { addToSetAttr(struct, c, pn, pv, false); },
+    '@sap.creatable' : (c, pn, pv) => { addToAssociationSet(c, pn, pv, false); },
     // Not applicable to NavProp, applicable to foreign keys, add to AssociationSet
-    '@sap.updatable' : addToSetAttr,
+    '@sap.updatable' : addToAssociationSet,
     // Not applicable to NavProp, not applicable to foreign key, add to AssociationSet
-    '@sap.deletable': (struct, c, pn, pv) => {
-      addToSetAttr(struct, c, pn, pv);
-      removeFromForeignKey(struct, c, pn);
+    '@sap.deletable': (c, pn, pv) => {
+      addToAssociationSet(c, pn, pv);
+      removeFromForeignKey(c, pn);
     },
     // applicable to NavProp, not applicable to foreign keys, not applicable to AssociationSet
     '@sap.creatable.path': removeFromForeignKey,
@@ -1987,24 +2176,22 @@ function setSAPSpecificV2AnnotationsToAssociation(options, carrier, struct) {
   };
 
   Object.entries(carrier).forEach(([p, v]) => {
-    (SetAttributes[p] || function() {/* no-op */})(struct, carrier, p, v);
+    (SetAttributes[p] || function() {/* no-op */})(carrier, p, v);
   });
 
-  function addToSetAttr(struct, carrier, propName, propValue, removeFromType=true) {
-    assignProp(carrier, '_SetAttributes', Object.create(null));
-    assignAnnotation(carrier._SetAttributes, propName, propValue);
-    if(removeFromType) {
-      delete carrier[propName];
+  function addToAssociationSet(carrier, propName, propValue, removeFromType=true) {
+    if(isAssociationOrComposition(carrier)) {
+      assignProp(carrier, '_SetAttributes', Object.create(null));
+      assignAnnotation(carrier._SetAttributes, propName, propValue);
+      if(removeFromType) {
+        delete carrier[propName];
+      }
     }
   }
 
-  function removeFromForeignKey(struct, carrier, propName) {
-    if(carrier.target && carrier.keys) {
-      struct.elements && Object.values(struct.elements).forEach(e => {
-        if(e['@odata.foreignKey4'] === carrier.name) {
-          delete e[propName];
-        }
-      });
+  function removeFromForeignKey(carrier, propName) {
+    if(carrier['@odata.foreignKey4'] && carrier[propName] !== undefined) {
+      delete carrier[propName];
     }
   }
 }