@sap/cds-compiler 3.1.0 → 3.3.2

package/lib/compiler/shared.js

@@ -534,16 +534,21 @@ function fns( model ) {
   // if the artifact does not exist.  Return a "fresh" artifact for
   // non-existing external using references if `unchecked` is truthy.
   function getPathRoot( path, spec, user, env, extDict, msgArt ) {
-    if (!spec.envFn && user._pathHead) {
-      // TODO: not necessarily for explicit ON condition in expand
+    const head = path[0];
+    if (!head || !head.id || !env)
+      return undefined;         // parse error
+    if (!spec.envFn && user._pathHead && head.id.charAt(0) !== '$') {
+      if (spec.rootEnv === 'elements') { // ON condition in expand/inline
+        let root = user._pathHead;
+        while (root.kind === '$inline')
+          root = root._parent;
+        return root;
+      }
       VolatileFns.environment( user._pathHead ); // make sure _origin is set
       return user._pathHead._origin;
       // const { _origin } = user._pathHead;
       // return (_origin && _origin.kind === '$tableAlias') ? _origin._origin : _origin;
     }
-    const head = path[0];
-    if (!head || !head.id || !env)
-      return undefined;         // parse error
     // if (head.id === 'k') {console.log(Object.keys(user));throw Error(JSON.stringify(user.name))}
     // if head._artifact is set or is null then it was already computed once
     if ('_artifact' in head)
@@ -576,7 +581,7 @@ function fns( model ) {
             message( 'ref-obsolete-parameters', [ head.location, user ],
                      { code: `$parameters.${ path[1].id }`, newcode: `:${ path[1].id }` },
                      'Obsolete $(CODE) - replace by $(NEWCODE)' );
-            // TODO: replace it in to-csn correspondingly
+            // TODO: replace it in to-csn correspondingly  !!!
             return setArtifactLink( head, r );
           }
         }
@@ -685,6 +690,9 @@ function fns( model ) {
   // search environment (for the first path item) is `arg`.  For messages about
   // missing artifacts (as opposed to elements), provide the `head` (first
   // element item in the path)
+  // TODO - think about setting _navigation for all $navElement – the
+  // "ref: ['tabAlias']: inline: […]" handling might be easier
+  // (no _pathHead consultation for key prop and renaming support)
   function getPathItem( path, spec, user, artItemsCount, headArt ) {
     // let art = (headArt && headArt.kind === '$tableAlias') ? headArt._origin : headArt;
     let art = headArt;
@@ -889,6 +897,8 @@ function fns( model ) {
   // (TODO: really here?, probably split main artifacts vs returns)
   // see also lateExtensions() where similar messages are reported
   function checkAnnotate( construct, art ) {
+    // TODO: Handle extend statements properly: Different message for empty extend?
+
     // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
     // they can still be applied. Namespace annotations are extracted in to-csn.js
     // In parseCdl mode USINGs and other unknown references are generated as

package/lib/compiler/tweak-assocs.js

@@ -98,6 +98,7 @@ function tweakAssocs( model ) {
             } );
     }
     else {
+      // ID published! Used in stakeholder project; if renamed, add to oldMessageIds
       info( 'assoc-outside-service', [ elem.target.location, elem ],
             { target },
             'Association target $(TARGET) is outside any service' );
@@ -283,11 +284,12 @@ function tweakAssocs( model ) {
       // managed association as sub element not supported yet
       error( null, [ elem.location, elem ], {},
         // eslint-disable-next-line max-len
-             'Rewriting the ON condition of unmanaged association in sub element is not supported' );
+             'Rewriting the ON-condition of unmanaged association in sub element is not supported' );
       return;
     }
-    const nav = (elem._main && elem._main.query) ? pathNavigation( elem.value )
-      : { navigation: assoc };
+    const nav = (elem._main && elem._main.query && elem.value)
+      ? pathNavigation( elem.value ) // redirected source elem or mixin
+      : { navigation: assoc };       // redirected user-provided
     const cond = copyExpr( assoc.on,
       // replace location in ON except if from mixin element
                            nav.tableAlias && elem.name.location );
@@ -305,7 +307,7 @@ function tweakAssocs( model ) {
       // For "assoc1.assoc2" and "structelem1.assoc2"
       if (elem._redirected !== null) { // null = already reported
         error( 'rewrite-not-supported', [ elem.target.location, elem ], {},
-               'The ON condition is not rewritten here - provide an explicit ON condition' );
+               'The ON-condition is not rewritten here - provide an explicit ON-condition' );
       }
       return;
     }
@@ -314,7 +316,7 @@ function tweakAssocs( model ) {
     }
     else {
       // TODO: support that, now that the ON condition is rewritten in the right order
-      error( null, [ elem.value.location, elem ],
+      error( null, [ elem.value.location, elem ], {},
              'Selecting unmanaged associations from a sub query is not supported' );
     }
     cond.$inferred = 'rewrite';
@@ -325,7 +327,6 @@ function tweakAssocs( model ) {
     // 'assoc' in query or including entity from ON cond of mixin element /
     // element in included structure / element in source ref/d by table alias.
 
-    // TODO: re-check args in references, forbid parameter use for the moment
     // TODO: complain about $self (unclear semantics)
     // console.log( info(null, [assoc.name.location, assoc],
     //       { art: expr._artifact, names: expr.path.map(i=>i.id) }, 'A').toString(), expr.path)
@@ -341,13 +342,25 @@ function tweakAssocs( model ) {
       //                   { names: expr.path.map(i=>i.id), art: root }, 'TA').toString())
       if (!root || root._main !== source)
         return;                 // not $self or source element
+      if (expr.scope === 'param' || root.kind === '$parameters')
+        return;                 // are not allowed anyway - there was an error before
       const item = expr.path[root.kind === '$self' ? 1 : 0];
       // console.log('YE', assoc.name, item, root.name, expr.path)
-      rewritePath( expr, item, assoc,
-                   navProjection( item && tableAlias.elements[item.id], assoc ),
-                   assoc.value.location );
+      const elem = navProjection( item && tableAlias.elements[item.id], assoc );
+      rewritePath( expr, item, assoc, elem, assoc.value.location );
     }
     else if (assoc._main.query) { // from ON cond of mixin element in query
+      const root = expr.path[0]._navigation || expr.path[0]._artifact;
+      if (expr.scope === 'param' || root?.kind === '$parameters') {
+        if (assoc.$errorReported !== 'assoc-unexpected-scope') {
+          error( 'assoc-unexpected-scope', [ assoc.value.location, assoc ],
+                 { id: assoc.value._artifact.name.id },
+                 // eslint-disable-next-line max-len
+                 'Association $(ID) can\'t be projected because its ON-condition refers to a parameter' );
+          assoc.$errorReported = 'assoc-unexpected-scope';
+        }
+        return;
+      }
       const nav = pathNavigation( expr );
       if (nav.navigation || nav.tableAlias) { // rewrite src elem, mixin, $self[.elem]
         rewritePath( expr, nav.item, assoc,
@@ -372,9 +385,9 @@ function tweakAssocs( model ) {
                  { art: art && effectiveType( art ) },
                  {
                    // eslint-disable-next-line max-len
-                   std: 'This element is not originally referred to in the ON condition of association $(ART)',
+                   std: 'This element is not originally referred to in the ON-condition of association $(ART)',
                    // eslint-disable-next-line max-len
-                   element: 'This element is not originally referred to in the ON condition of association $(MEMBER) of $(ART)',
+                   element: 'This element is not originally referred to in the ON-condition of association $(MEMBER) of $(ART)',
                  } );
       }
       rewritePath( expr, item, assoc, (Array.isArray(elem) ? false : elem), null );
@@ -473,7 +486,7 @@ function tweakAssocs( model ) {
     // TODO: better (extra message), TODO: do it
     error( 'query-undefined-element', [ item.location, assoc ], { id: name || item.id },
            // eslint-disable-next-line max-len
-           'Element $(ID) has not been found in the elements of the query; please use REDIRECTED TO with an explicit ON condition' );
+           'Element $(ID) has not been found in the elements of the query; please use REDIRECTED TO with an explicit ON-condition' );
     return (elem) ? false : null;
   }
 }

package/lib/compiler/utils.js

@@ -33,7 +33,7 @@ function annotationIsFalse( anno ) {                   // falsy, but not null (u
 }
 function annotationHasEllipsis( anno ) {
   const { val } = anno || {};
-  return Array.isArray( val ) && val.some( v => v.literal === 'token' && v.val === '...' );
+  return Array.isArray( val ) && val.find( v => v.literal === 'token' && v.val === '...' );
 }
 
 /**
@@ -87,7 +87,7 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
     setMemberParent( elem, name, parent, prop ); // TODO: redef in template
   setLink( elem, '_origin', origin );
   // TODO: should we use silent dependencies also for other things, like
-  // included elements?  (Currently for $inferred: 'expand-element' only)
+  // included elements?  (Currently for $inferred: 'expanded' only)
   if (silentDep)
     dependsOnSilent( elem, origin );
   else

package/lib/edm/annotations/genericTranslation.js

@@ -401,8 +401,6 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       params.push(action['@cds.odata.bindingparameter.collection'] ? 'Collection(' + bindingParam + ')' : bindingParam);
     }
     if (action.kind === 'function') {
-      let mapType = (p) => (isBuiltinType(p.type)) ?
-        edmUtils.mapCdsToEdmType(p, messageFunctions, false /*is only called for v4*/) : p.type;
       if(action.params) {
         action.params && Object.values(action.params).forEach(p => {
           let isArrayType = !p.type && p.items && p.items.type;
@@ -411,6 +409,18 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       }
     }
     return '(' + params.join(',') + ')';
+
+    function mapType(p) {
+      if(isBuiltinType(p.type))
+        return edmUtils.mapCdsToEdmType(p, messageFunctions, false /*is only called for v4*/)
+      else if(options.whatsMySchemaName) {
+        const schemaName = options.whatsMySchemaName(p.type);
+        // strip the service namespace of from a parameter type
+        if(schemaName && schemaName !== options.serviceName)
+          return p.type.replace(options.serviceName + '.', '');
+      }
+      return p.type;
+    }
   }
 
 
@@ -689,7 +699,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         }
         if (innerAnnotation) {
         // A voc annotation has two steps (Namespace+Name),
-        // any furter steps need to be rendered separately
+        // any further steps need to be rendered separately
           const innerAnnoSteps = innerAnnotation.split('.');
           const tailSteps = innerAnnoSteps.splice(2, innerAnnoSteps.length-2);
         // prepend annotation prefix (path) to tail steps
@@ -1293,7 +1303,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   function handleEdmJson(obj, context, exprDef=undefined) {
 
     let edmNode = undefined;
-    if(obj === undefined)
+    if(obj === undefined || obj === null)
       return edmNode;
 
     const dynExprs = edmUtils.intersect(dynamicExpressionNames, Object.keys(obj));
@@ -1304,7 +1314,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     }
 
     if (dynExprs.length === 0) {
-      if (typeof obj === 'object' && obj !== null && !Array.isArray(obj) && Object.keys(obj).length === 1) {
+      if (typeof obj === 'object' && !Array.isArray(obj) && Object.keys(obj).length === 1) {
         const k = Object.keys(obj)[0];
         const val = obj[k];
         edmNode = new Edm.ValueThing(v, k[0] === '$' ? k.slice(1) : k, val );

package/lib/edm/csn2edm.js

@@ -305,9 +305,9 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       const reservedNames = ['Edm', 'odata', 'System', 'Transient'];
       const loc = ['definitions', schema.name];
       if(reservedNames.includes(schema.name))
-        warning('odata-spec-violation-namespace', loc, { names: reservedNames });
+        message('odata-spec-violation-namespace', loc, { names: reservedNames });
       if (schema.name.length > 511)
-        warning('odata-spec-violation-namespace', loc, { '#': 'length' });
+        message('odata-spec-violation-namespace', loc, { '#': 'length' });
       else {
         schema.name.split('.').forEach(id => {
           if (!edmUtils.isODataSimpleIdentifier(id))
@@ -413,10 +413,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           const pLoc = [...loc, 'elements', p._edmAttributes.Name];
           edmTypeCompatibilityCheck(p, pLoc);
           if(p._edmAttributes.Name === EntityTypeName)
-            warning('odata-spec-violation-property-name', pLoc, { kind: entityCsn.kind });
+            message('odata-spec-violation-property-name', pLoc, { kind: entityCsn.kind });
 
           if(options.isV2() && p._isCollection && !p._csn.target)
-            warning('odata-spec-violation-array', pLoc, { version: '2.0' });
+            message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
           if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
@@ -626,10 +626,10 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             !param._type.startsWith('Edm.') &&
             csn.definitions[param._type] &&
             !edmUtils.isStructuredType(csn.definitions[param._type]))
-            warning('odata-spec-violation-param', pLoc, { version: '2.0' });
+            message('odata-spec-violation-param', pLoc, { version: '2.0' });
 
           if(param._isCollection)
-            warning('odata-spec-violation-array', pLoc, { version: '2.0' });
+            message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
           functionImport.append(param);
         });
@@ -645,7 +645,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           let type = returns.type;
           if (type) {
             if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
-              warning('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
+              message('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
             }
             else if(isBuiltinType(type)) {
               type = edmUtils.mapCdsToEdmType(returns, messageFunctions, true);
@@ -764,17 +764,17 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           const pLoc = [ ...loc, ...(structuredTypeCsn.items ? ['items', 'elements'] : [ 'elements' ]), p._edmAttributes.Name ];
           edmTypeCompatibilityCheck(p, pLoc);
           if(p._edmAttributes.Name === complexType._edmAttributes.Name)
-            warning('odata-spec-violation-property-name', pLoc, { kind: structuredTypeCsn.kind });
+            message('odata-spec-violation-property-name', pLoc, { kind: structuredTypeCsn.kind });
 
           if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
 
           if(options.isV2()) {
             if(p._isCollection && !p._csn.target)
-              warning('odata-spec-violation-array', pLoc, { version: '2.0' });
+              message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
             if(p._csn.target)
-              warning('odata-spec-violation-assoc', pLoc, { version: '2.0' });
+              message('odata-spec-violation-assoc', pLoc, { version: '2.0' });
           }
         });
 

package/lib/edm/edm.js

@@ -10,7 +10,7 @@ const { isBetaEnabled } = require('../base/model.js');
 const EdmTypeFacetMap = {
   'MaxLength': { v2: true, v4: true, remove: true, optional: true },
   'Precision': { v2: true, v4: true, remove: true, optional: true },
-  'Scale': { v2: true, v4: true, remove: true, optional: true },
+  'Scale': { v2: true, v4: true, remove: true, optional: true, extra: 'sap:variable-scale' },
   'SRID': { v4: true, remove: true, optional: true },
   //'FixedLength': { v2: true },
   //'Collation': { v2: true },
@@ -116,6 +116,8 @@ function getEdm(options, messageFunctions) {
     removeEdmAttribute(name) {
       if (name in this._edmAttributes)
         delete this._edmAttributes[name];
+      if (name in this._xmlOnlyAttributes)
+        delete this._xmlOnlyAttributes[name];
     }
 
     /**
@@ -695,14 +697,20 @@ function getEdm(options, messageFunctions) {
               // produce an unrecoverable error.
               if(td && (td.v2 === this.v2 || td.v4 === this.v4)) {
                 this.setEdmAttribute(typeName, odataType);
-                EdmTypeFacetNames.forEach(facet => {
-                  if(EdmTypeFacetMap[facet].remove)
-                    this.removeEdmAttribute(facet);
-                  if(td[facet] !== undefined && 
-                      (EdmTypeFacetMap[facet].v2 === this.v2 || 
-                      EdmTypeFacetMap[facet].v4 === this.v4)
-                    ) {
-                    this.setEdmAttribute(facet, csn['@odata.'+facet]);
+                EdmTypeFacetNames.forEach(facetName => {
+                  const facet = EdmTypeFacetMap[facetName];
+                  if(facet.remove) {
+                    this.removeEdmAttribute(facetName);
+                    this.removeEdmAttribute(facet.extra);
+                  }
+                  if(td[facetName] !== undefined &&
+                      (facet.v2 === this.v2 ||
+                      facet.v4 === this.v4))
+                  {
+                    if(this.v2 && facetName === 'Scale' && csn['@odata.'+facetName] === 'variable')
+                      this.setXml({ [facet.extra]: true });
+                    else
+                      this.setEdmAttribute(facetName, csn['@odata.'+facetName]);
                   }
                 });
               }

package/lib/edm/edmPreprocessor.js

@@ -1,10 +1,10 @@
 'use strict';
 /* eslint max-statements-per-line:off */
 const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
-const { 
+const {
   forEachDefinition, forEachGeneric, forEachMemberRecursively,
-  isEdmPropertyRendered, getUtils, cloneCsnNonDict, cloneCsnDictionary,
-  isBuiltinType, applyTransformationsOnNonDictionary 
+  isEdmPropertyRendered, getUtils, cloneCsnNonDict,
+  isBuiltinType, applyTransformations, cloneAnnotationValue
 } = require('../model/csnUtils');
 const edmUtils = require('./edmUtils.js');
 const edmAnnoPreproc = require('./edmAnnoPreprocessor.js');
@@ -14,6 +14,12 @@ const expandCSNToFinalBaseType = require('../transform/odata/toFinalBaseType');
 
 const NavResAnno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
 
+// Capabilities that can be pulled up to NavigationRestrictions
+const capabilities = Object.keys(require('../gen/Dictionary.json').
+  types['Capabilities.NavigationPropertyRestriction'].Properties).
+  filter(c => !['NavigationProperty', 'Navigability'].includes(c)).
+  map(c => `@Capabilities.`+c);
+
 /**
  *  edmPreprocessor warms up the model so that it can be converted into an EDM document and
  *  contains all late & application specific model transformations
@@ -203,7 +209,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // TODO: work on service basis (this requires post exposure renaming)
     let fallBackSchemaName = 'root';
     let i = 1;
-    while (Object.keys(defs).some(artName => {
+    const defNames = Object.keys(defs);
+    while (defNames.some(artName => {
       const p = artName.split('.');
       return p.length === 2 && p[0] === fallBackSchemaName;
     })) {
@@ -417,9 +424,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         while(elt && !isBuiltinType(elt.type) && !elt.elements) {
           elt = csn.definitions[elt.type];
         }
-        if(elt && elt.elements) {
+        if(elt && elt.elements && !elt.$visited) {
+          setProp(elt, '$visited', true);
           forEachMemberRecursively(elt, initContainments,
             path, true, { pathWithoutProp: true, elementsOnly: true });
+          delete elt.$visited;
         }
       }
     }
@@ -437,9 +446,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         while(elt && !(isBuiltinType(elt.type) || elt.elements)) {
           elt = csn.definitions[elt.type];
         }
-        if(elt && elt.elements) {
+        if(elt && elt.elements && !elt.$visited) {
+          setProp(elt, '$visited', true);
           forEachMemberRecursively(elt, markToContainer,
             [], true, { elementsOnly: true });
+          delete elt.$visited;
         }
       }
     }
@@ -1492,7 +1503,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         and do not render associations (this will include the foreign keys of
         the _isToContainer association).
   */
-  function initEdmKeyRefPaths(def) {
+  function initEdmKeyRefPaths(def, defName) {
     if(def.$keys) {
       setProp(def, '$edmKeyPaths', []);
       // for all key elements that shouldn't be ignored produce the paths
@@ -1503,7 +1514,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
             // This is structured OData ONLY
             // if the foreign keys are explicitly requested, ignore associations and use the flat foreign keys instead
             if(!options.renderForeignKeys || (options.renderForeignKeys && !k.target))
-              def.$edmKeyPaths.push(...produceKeyRefPaths(k, kn));
+              def.$edmKeyPaths.push(...produceKeyRefPaths(k, kn, [ 'definitions', defName, 'elements', kn ]));
           }
         // In v2/v4 flat, associations are never rendered
           else if(!k.target) {
@@ -1525,7 +1536,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         navprops to be key ref.
       If element is of scalar type, return it as an array.
     */
-    function produceKeyRefPaths(eltCsn, prefix) {
+    function produceKeyRefPaths(eltCsn, prefix, path) {
       const keyPaths = [];
       // we want to point to the element in the entity which is the first path step
       const location = def.$path.concat(['elements']).concat(prefix.split('/')[0]);
@@ -1537,18 +1548,25 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       }
       // OData requires all elements along the path to be nullable: false (that is either key or notNull)
 
-      const finalType = csnUtils.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));
+      const finalType = csnUtils.getFinalTypeDef(eltCsn.items?.type || eltCsn.type);
+      const elements = eltCsn.elements || eltCsn.items?.elements ||
+                     finalType?.elements || finalType?.items?.elements;
       if(elements) {
         Object.entries(elements).forEach(([eltName, elt]) => {
-          const newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName);
-          if(newRefs.length) {
-            keyPaths.push(...newRefs);
+          if(!elt.$visited) {
+            setProp(elt, '$visited', true);
+            const newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName, path);
+            if(newRefs.length) {
+              keyPaths.push(...newRefs);
             // check path step key for spec violations
-            const pathSegment = `${prefix}/${eltName}`;
-            checkKeySpecViolations(elt, location, pathSegment);
+              const pathSegment = `${prefix}/${eltName}`;
+              checkKeySpecViolations(elt, location, pathSegment);
+            }
+            delete elt.$visited;
+          } else {
+            error('odata-key-recursive', path, { name: prefix });
           }
+
         });
       }
       /* If element is a managed association (can't be anything else),
@@ -1572,7 +1590,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
               art = art._type || csnUtils.getCsnDef(art.type);
             }
           }
-          keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter)));
+          keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter), path));
         });
       }
       else {
@@ -1677,7 +1695,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           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));
+          if(elt && elt.elements && !elt.$visited) {
+            setProp(elt, '$visited', true);
+            Object.values(elt.elements).forEach(e => produceTargetPath(newPrefix, e, curDef));
+            delete elt.$visited;
+          }
         }
       }
     }
@@ -1750,7 +1772,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           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)));
+          if(elt && elt.elements && !elt.$visited) {
+            setProp(elt, '$visited', true);
+            Object.values(elt.elements).forEach(e => npbs = npbs.concat(produceNavigationPath(e, curDef)));
+            delete elt.$visited;
+          }
         }
       }
       npbs.forEach(p => p.Path = prefix + '/' + p.Path );
@@ -1832,22 +1858,49 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       if(container.$containeeAssociations) {
         // copy or create container restrictions, don't modify original
         const localRestrictions = container[NavResAnno] ?
-        cloneCsnDictionary(container[NavResAnno], options) : []
-      
+          cloneAnnotationValue(container[NavResAnno]) : []
+
+        // prefix the existing navigation property restritictions on the container
+        if(prefix.length) {
+          localRestrictions.forEach(npe => {
+            if(npe.NavigationProperty &&
+               npe.NavigationProperty['='] &&
+               typeof npe.NavigationProperty['='] === 'string') {
+              applyTransformations({ definitions: { npe }}, {
+                "=": (parent, prop, value) => {
+                  parent[prop] = prefix.concat(value).join('.');
+                }
+              });
+            }
+          });
+        }
+
         setProp(container, '$visited', true);
+        // collect capabilities from containees
         container.$containeeAssociations.forEach(entry => {
           const { assoc, path } = entry;
           const containee = assoc._target;
 
           if(isMyServiceRequested(containee.name) || containee.$proxy) {
             const localAssocPath = path.join('.');
+            let navPropEntry;
+            const hasEntry = !!(navPropEntry = localRestrictions.find(p =>
+                p.NavigationProperty && p.NavigationProperty['='] === prefix.concat(localAssocPath).join('.')));
+
+            if(!hasEntry) {
+              navPropEntry =  { NavigationProperty: { '=': prefix.concat(localAssocPath).join('.') } };
+            }
+
             const props = Object.entries(containee);
-            ['@Capabilities.DeleteRestrictions',
-              '@Capabilities.InsertRestrictions',
-              '@Capabilities.UpdateRestrictions',
-              '@Capabilities.ReadRestrictions'].forEach(c => 
-                edmUtils.mergeIntoNavPropRestrictions(c, localAssocPath, props, localRestrictions));
+            let newEntry = false;
+            capabilities.forEach(c => {
+              if(edmUtils.mergeIntoNavPropEntry(c, navPropEntry, prefix.concat(path), props))
+                newEntry = true;
+            });
 
+            if(newEntry && !hasEntry) {
+              localRestrictions.push(navPropEntry);
+            }
 
             if(!containee.$visited) {
               addContainmentAnnotationsRecursively(prefix.concat(path), containee);
@@ -1855,19 +1908,6 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           }
         });
 
-        // prefix all paths in the navPropEntry with the NavigationPropertyPath
-        localRestrictions.forEach((p, i) => {
-          if(p.NavigationProperty && p.NavigationProperty['='] && typeof p.NavigationProperty['='] === 'string') {
-            const lp = [ ...prefix, p.NavigationProperty['=']].join('.');
-            applyTransformationsOnNonDictionary(localRestrictions, i, {
-              "=": (parent, prop, value) => {
-                parent[prop] = [lp, value].join('.');
-              }
-            });
-            // reset NavigationPropertyPath
-            p.NavigationProperty['='] = lp;
-          }
-        });
         rootRestrictions.unshift(...localRestrictions);
         delete container.$visited;
       }
@@ -1978,12 +2018,12 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     if (obj.type && isBuiltinType(obj.type) && !obj.target && !obj.targetAspect) {
       let edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
       edmUtils.assignProp(obj, '_edmType', edmType);
-    } else if (obj._isCollection && (obj.items && isBuiltinType(csnUtils.getFinalTypeDef(obj.items.type)))) {
+    } else if (obj._isCollection && (obj.items && isBuiltinType(csnUtils.getFinalBaseTypeWithProps(obj.items.type)?.type))) {
       let edmType = edmUtils.mapCdsToEdmType(obj.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType'], obj.$path);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }
     // This is the special case when we have array of array, but will not be supported in the future
-    else if (obj._isCollection && obj.items && obj.items.type && obj.items.items && isBuiltinType(csnUtils.getFinalTypeDef(obj.items.items.type))) {
+    else if (obj._isCollection && obj.items && obj.items.type && obj.items.items && isBuiltinType(csnUtils.getFinalBaseTypeWithProps(obj.items.items.type)?.type)) {
       let edmType = edmUtils.mapCdsToEdmType(obj.items.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }