@sap/cds-compiler 2.7.0 → 2.10.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);
@@ -142,14 +140,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 +339,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 +446,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 +463,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 +569,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] },
@@ -578,10 +605,12 @@ function initializeModel(csn, _options)
 
         //forward annotations from managed association element to its foreign keys
         if(element.keys && options.isFlatFormat) {
+          const elements = construct.items && construct.items.elements || construct.elements;
           for(let fk of element.keys) {
             forAll(element, (attr, attrName) => {
-              if(attrName[0] === '@' && fk.$generatedFieldName)
-                def.elements[fk.$generatedFieldName][attrName] = attr;
+              if(attrName[0] === '@' && fk.$generatedFieldName && elements && elements[fk.$generatedFieldName]) {
+                elements[fk.$generatedFieldName][attrName] = attr;
+              }
             });
           }
         }
@@ -594,7 +623,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 +675,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 +698,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 +746,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 +758,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 +785,7 @@ function initializeModel(csn, _options)
           }
         }
       }
-    });
+    }, [], true, { elementsOnly: true });
   }
 
   /*
@@ -816,7 +848,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 +906,7 @@ function initializeModel(csn, _options)
               }
               else {
                 // fake the target to be proxy
-                element._target.$externalRef = true;
+                setProp(element._target, '$externalRef', true);
               }
             }
             else {
@@ -923,7 +955,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 +1101,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 +1133,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 +1223,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 +1240,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 +1253,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 +1270,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 +1324,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 +1341,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 +1349,19 @@ 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.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 || 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;