@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/edm/edmPreprocessor.js

@@ -1,26 +1,18 @@
 'use strict';
 /* eslint max-statements-per-line:off */
 const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
-const { forEachDefinition, forEachGeneric, forEachMemberRecursively,
-  isEdmPropertyRendered, getUtils, cloneCsnNonDict, isBuiltinType } = require('../model/csnUtils');
+const { 
+  forEachDefinition, forEachGeneric, forEachMemberRecursively,
+  isEdmPropertyRendered, getUtils, cloneCsnNonDict, cloneCsnDictionary,
+  isBuiltinType, applyTransformationsOnNonDictionary 
+} = require('../model/csnUtils');
 const edmUtils = require('./edmUtils.js');
+const edmAnnoPreproc = require('./edmAnnoPreprocessor.js');
+const { inboundQualificationChecks } = require('./edmInboundChecks.js');
 const typesExposure = require('../transform/odata/typesExposure');
 const expandCSNToFinalBaseType = require('../transform/odata/toFinalBaseType');
 
-const {
-  intersect,
-  validateOptions,
-  foreach,
-  forAll,
-  isAssociationOrComposition,
-  isComposition,
-  isStructuredArtifact,
-  isParameterizedEntity,
-  resolveOnConditionAndPrepareConstraints,
-  finalizeReferentialConstraints,
-  isEntity,
-  getSchemaPrefix,
-} = require('./edmUtils.js');
+const NavResAnno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
 
 /**
  *  edmPreprocessor warms up the model so that it can be converted into an EDM document and
@@ -34,9 +26,9 @@ const {
  */
 function initializeModel(csn, _options, messageFunctions, requestedServiceNames=undefined)
 {
-  const { info, warning, error, message, throwWithAnyError } = messageFunctions;
+  const { info, warning, error, message } = messageFunctions;
 
-  let csnUtils = getUtils(csn);
+  const csnUtils = getUtils(csn);
 
   // proxies are merged into the final model after all proxy elements are collected
   const proxyCache = [];
@@ -47,13 +39,17 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
 
   // make sure options are complete
-  let options = validateOptions(_options);
+  let options = edmUtils.validateOptions(_options);
 
   const [ serviceRoots,
     serviceRootNames,
     fallBackSchemaName,
     whatsMyServiceRootName ] = getAnOverviewOnTheServices(csn);
 
+  if(serviceRootNames.length === 0) {
+    return [serviceRoots, Object.create(null), reqDefs, whatsMyServiceRootName, fallBackSchemaName, options];
+  }
+
   if(requestedServiceNames === undefined)
     requestedServiceNames = options.serviceNames;
   if(requestedServiceNames === undefined) {
@@ -64,12 +60,9 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     return requestedServiceNames.includes(whatsMyServiceRootName(n));
   }
 
-  if(serviceRootNames.length === 0) {
-    return [serviceRoots, Object.create(null), reqDefs, whatsMyServiceRootName, fallBackSchemaName, options];
-  }
-
   // Structural CSN inbound QA checks
-  inboundQualificationChecks();
+  inboundQualificationChecks(csn, options, messageFunctions,
+    serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName);
   // not needed at the moment
   // resolveForeignKeyRefs();
 
@@ -85,7 +78,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
   /*
     Final base type expansion is required here when:
-    1) The input CSN was already transformed for V4 but shall be rendered in V2 and the 
+    1) The input CSN was already transformed for V4 but shall be rendered in V2 and the
        edmx generator is called directly (bypassing OData transformation)
     2) The input CSN was already transformed for V4 and persisted (all non-enumerables are
        stripped of)
@@ -119,20 +112,16 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   }
 
   if(schemaNames.length) {
-    // First attach names to all definitions (and actions/params) in the model
-    // elements are done in initializeStruct
-    // Set myServiceName for later reference and indication of a service member
-    // First attach names to all definitions in the model and fill reqDefs
-    // Link association targets and spray @odata.contained over untagged compositions
     forEachDefinition(csn, [
       attachNameProperty,
       (def, defName) => {
         const mySchemaName = whatsMySchemaName(defName);
         mySchemaName && setProp(def, '$mySchemaName', mySchemaName);
-        if(isMyServiceRequested(defName))
+        if(isMyServiceRequested(defName) && def.kind !== 'aspect')
           reqDefs.definitions[defName] = def;
       },
-      linkAssociationTarget ]);
+      linkAssociationTarget
+    ]);
     // initialize requested services
     const skip = { skipArtifact: (_def, defName) => !isMyServiceRequested(defName) };
     forEachDefinition({ definitions: serviceRoots }, initService, skip);
@@ -147,23 +136,32 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // Mute V4 elements depending on constraint preparation
     if(options.isV4())
       forEachDefinition(reqDefs, ignoreProperties);
-    // calculate constraints based on ignoreProperties and prepareConstraints
+    // calculate constraints based on ignoreProperties and initConstraints
     forEachDefinition(reqDefs, finalizeConstraints);
     // convert exposed types into cross schema references if required
     // must be run before proxy exposure to avoid potential reference collisions
     convertExposedTypesOfOtherServicesIntoCrossReferences();
-    // create association target proxies
+    // create association target proxies (v4)
     // Decide if an entity set needs to be constructed or not
-    forEachDefinition(reqDefs, [ exposeTargetsAsProxiesOrSchemaRefs, determineEntitySet ]);
+    forEachDefinition(reqDefs, [
+      exposeTargetsAsProxiesOrSchemaRefs,
+      determineEntitySet
+    ]);
     // finalize proxy creation
     mergeProxiesIntoModel();
 
+    // Calculate NavPropBinding Target paths
+    // Rewrite @Capabilities for containment mode
     if(options.isV4())
-      forEachDefinition(reqDefs, initEdmNavPropBindingTargets);
+      forEachDefinition(reqDefs, [
+        initEdmNavPropBindingTargets,
+        rewriteContainmentAnnotations,
+        annotateOptionalActFuncParams
+      ]);
 
     // Things that can be done in one pass
     // Create edmKeyRefPaths
-    // Create NavigationPropertyBindings, requires determineEntitySet
+    // Create V4 NavigationPropertyBindings, requires determineEntitySet & initEdmNavPropBindingTargets
     // Map /** doc comments */ to @CoreDescription
     forEachDefinition(reqDefs, [
       initEdmKeyRefPaths,
@@ -171,7 +169,14 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       initEdmTypesAndDescription
     ]);
   }
-  return [serviceRoots, schemas, reqDefs, whatsMyServiceRootName, fallBackSchemaName, options];
+  return [
+    serviceRoots,
+    schemas,
+    reqDefs,
+    whatsMyServiceRootName,
+    fallBackSchemaName,
+    options
+  ];
 
   //////////////////////////////////////////////////////////////////////
   //
@@ -241,7 +246,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         const rootDef = getRootDef(defName);
         // if this definition has a root def and the root def is not the service/schema name
         // => service C { type D.E }, replace the prefix dots with underscores
-        if(rootDef && defName !== rootDef && rootDef !== getSchemaPrefix(defName)) {
+        if(rootDef && defName !== rootDef && rootDef !== edmUtils.getSchemaPrefix(defName)) {
           let newDefName = rootDef + '.' + defName.replace(rootDef + '.', '').replace(/\./g, '_');
           // store renamed types in correlation maps for later renaming
           if(def.kind === 'entity')
@@ -305,9 +310,9 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     forEachDefinition(csn, (def, defName) => {
       if(def.kind !== 'service') {
         const myServiceRoot = whatsMyServiceRootName(defName);
-        const mySchemaPrefix = getSchemaPrefix(defName);
+        const mySchemaPrefix = edmUtils.getSchemaPrefix(defName);
         if(myServiceRoot && options.isV4() &&
-        /*(options.toOdata.odataProxies || options.toOdata.odataXServiceRefs) && options.isStructFormat && */
+        /*(options.odataProxies || options.odataXServiceRefs) && options.isStructFormat && */
         defName !== myServiceRoot && myServiceRoot !== mySchemaPrefix) {
           const service = { kind: 'service', name: mySchemaPrefix };
           serviceRoots[mySchemaPrefix] = service;
@@ -319,50 +324,48 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   }
 
   function attachNameProperty(def, defName) {
-    assignProp (def, 'name', defName);
+    edmUtils.assignProp (def, 'name', defName);
     // Attach name to bound actions, functions and parameters
     forEachGeneric(def, 'actions', (a, n) => {
-      assignProp(a, 'name', n);
+      edmUtils.assignProp(a, 'name', n);
       forEachGeneric(a, 'params', (p, n) => {
-        assignProp(p, 'name', n);
+        edmUtils.assignProp(p, 'name', n);
       });
     });
     // Attach name unbound action parameters
     forEachGeneric(def, 'params', (p,n) => {
-      assignProp(p, 'name', n);
+      edmUtils.assignProp(p, 'name', n);
     });
   }
 
   // initialize the service itself
   function initService(serviceRoot) {
-    setSAPSpecificV2AnnotationsToEntityContainer(options, serviceRoot);
+    edmAnnoPreproc.setSAPSpecificV2AnnotationsToEntityContainer(options, serviceRoot);
   }
 
   // link association target to association and add @odata.contained to compositions in V4
   function linkAssociationTarget(struct) {
     forEachMemberRecursively(struct, (element, name, prop, subpath) => {
-      if(isAssociationOrComposition(element) && !element._ignore) {
-        if(!element._target) {
-          let target = csn.definitions[element.target];
-          if(target) {
-            setProp(element, '_target', target);
+      if(element.target && !element._target) {
+        let target = csn.definitions[element.target];
+        if(target) {
+          setProp(element, '_target', target);
           // If target has parameters, xref assoc at target for redirection
-            if(isParameterizedEntity(target)) {
-              if(!target.$sources) {
-                setProp(target, '$sources', Object.create(null));
-              }
-              target.$sources[struct.name + '.' + name] = element;
+          if(edmUtils.isParameterizedEntity(target)) {
+            if(!target.$sources) {
+              setProp(target, '$sources', Object.create(null));
             }
+            target.$sources[struct.name + '.' + name] = element;
           }
-          else {
-            error(null, subpath, { target: element.target }, "Target $(TARGET) can't be found in the model");
-          }
+        }
+        else {
+          error(null, subpath, { target: element.target }, "Target $(TARGET) can't be found in the model");
         }
       }
       // in V4 tag all compositions to be containments
       if(options.odataContainment &&
          options.isV4() &&
-         isComposition(element) &&
+         edmUtils.isComposition(element) &&
          element['@odata.contained'] === undefined) {
         element['@odata.contained'] = true;
       }
@@ -372,7 +375,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   // Perform checks and add attributes for "contained" sub-entities:
   // - A container is recognized by having an association/composition annotated with '@odata.contained'.
   // - All targets of such associations ("containees") are marked with a property
-  //   '_containerEntity: []', having as value an array of container names (i.e. of entities
+  //   '$containerNames: []', having as value an array of container names (i.e. of entities
   //   that have a '@odata.contained' association pointing to the containee). Note that this
   //   may be multiple entities, possibly including the container itself.
   // - All associations in the containee pointing back to the container are marked with
@@ -382,35 +385,41 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   //   non-containment rendering. If containment rendering is active, the containee has no
   //   entity set. Instead try to rewrite the annotation in such a way that it is effective
   //   on the containment navigation property.
+  // $containeeAssoications stores the containees (children/outbound edges)
+  // $containerNames stores the containers (parents/inbound edges)
+
   function initContainments(container) {
     if(container.kind === 'entity') {
+      if(!container.$containeeAssociations)
+        setProp(container, '$containeeAssociations', []);
       forEachMemberRecursively(container, initContainments,
-        [], true, { elementsOnly: true });
+        [], true, { pathWithoutProp: true, elementsOnly: true });
     }
 
-    function initContainments(elt, eltName) {
-      if(isAssociationOrComposition(elt) && elt['@odata.contained'] && !elt._ignore) {
+    function initContainments(elt, _memberName, _prop, path) {
+      if(elt.target && elt['@odata.contained'] && !elt._ignore) {
+        // store all containment associations, required to create the containment paths later on
+        container.$containeeAssociations.push( { assoc: elt, path });
         // Let the containee know its container
         // (array because the contanee may contained more then once)
         let containee = elt._target;
-        if (!containee._containerEntity)
-          setProp(containee, '_containerEntity', []);
+        if (!containee.$containerNames)
+          setProp(containee, '$containerNames', []);
         // add container only once per containee
-        if (!containee._containerEntity.includes(container.name))
-          containee._containerEntity.push(container.name);
+        if (!containee.$containerNames.includes(container.name))
+          containee.$containerNames.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);
+          [ 'definitions', containee.name ], true, { elementsOnly: true });
       }
-      else {
+      else if(elt.type && !elt.elements) {
           // try to find elements to drill down further
-        while(elt && !(isBuiltinType(elt.type) || elt.elements)) {
+        while(elt && !isBuiltinType(elt.type) && !elt.elements) {
           elt = csn.definitions[elt.type];
         }
         if(elt && elt.elements) {
           forEachMemberRecursively(elt, initContainments,
-            [], true, { elementsOnly: true });
+            path, true, { pathWithoutProp: true, elementsOnly: true });
         }
       }
     }
@@ -441,13 +450,12 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   // Containment processing must take place before because it might be that this
   // artifact with parameters is already contained. In such a case the existing
   // containment chain must be propagated and reused. This requires that the
-  // containment data structures must be manually added here and rewriteContainmentAnnotations()
-  // must be called.
+  // containment data structures must be manually added here.
   // As a param entity is a potential proxy candidate, this split must be performed on
   // all definitions
   function initParameterizedEntityOrView(entityCsn, entityName) {
 
-    if(!isParameterizedEntity(entityCsn))
+    if(!edmUtils.isParameterizedEntity(entityCsn))
       return;
 
     // Naming rules for aggregated views with parameters
@@ -464,7 +472,6 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // this code can be extended for aggregated views
     const typeEntityName = entityName + 'Type';
     const typeEntitySetName = entityName + 'Set';
-    const parameterToTypeAssocName = 'Set';
     const typeToParameterAssocName = 'Parameters';
     let hasBacklink = true;
 
@@ -510,7 +517,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   <EntitySet Name="ZRHA_TEST_CDSSet" EntityType="ZRHA_TEST_CDS_CDS.ZRHA_TEST_CDSType" sap:creatable="false" sap:updatable="false"
              sap:deletable="false" sap:addressable="false" sap:content-version="1"/>
 */
-    assignProp(entityCsn, '_SetAttributes',
+    edmUtils.assignProp(entityCsn, '_SetAttributes',
       {'@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.addressable': false });
 
     // redirect inbound associations/compositions to the parameter entity
@@ -520,7 +527,6 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       entityCsn.$sources[n]._target = parameterCsn;
       entityCsn.$sources[n].target = parameterCsn.name;
     });
-    rewriteContainmentAnnotations(parameterCsn, entityCsn, parameterToTypeAssocName);
   }
 
   function createParameterEntity(entityCsn, entityName, isProxy) {
@@ -537,7 +543,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     if(!isProxy)
       setProp(parameterCsn, '$entitySetName', entityName);
     if(entityCsn.$location){
-      assignProp(parameterCsn, '$location', entityCsn.$location);
+      edmUtils.assignProp(parameterCsn, '$location', entityCsn.$location);
     }
 
     /*
@@ -545,21 +551,12 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
                  sap:deletable="false" sap:pageable="false" sap:content-version="1"/>
     */
 
-    assignProp(parameterCsn, '_SetAttributes',
+    edmUtils.assignProp(parameterCsn, '_SetAttributes',
       {'@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.pageable': false });
 
     setProp(parameterCsn, '$isParamEntity', true);
     setProp(parameterCsn, '$mySchemaName', entityCsn.$mySchemaName);
 
-    // propagate containment information, if containment is recursive, use parameterCsn.name as _containerEntity
-    if(entityCsn._containerEntity) {
-      setProp(parameterCsn, '_containerEntity', []);
-      for(const c of entityCsn._containerEntity) {
-        parameterCsn._containerEntity.push((c === entityCsn.name) ? parameterCsn.name : c);
-      }
-    }
-    entityCsn._containerEntity = [ parameterCsn ];
-
     forEachGeneric(entityCsn, 'params', (p,n) => {
       let elt = cloneCsnNonDict(p, options);
       elt.name = n;
@@ -574,9 +571,9 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         and so they are in CAP (all view parameters become primary keys which are not null).
       */
       if(options.isV2())
-        assignAnnotation(elt, '@sap.parameter', 'mandatory');
+        edmUtils.assignAnnotation(elt, '@sap.parameter', 'mandatory');
       else
-        assignAnnotation(elt, '@Common.FieldControl', { '#': 'Mandatory' });
+        edmUtils.assignAnnotation(elt, '@Common.FieldControl', { '#': 'Mandatory' });
       parameterCsn.elements[n] = elt;
     });
     linkAssociationTarget(parameterCsn);
@@ -594,7 +591,26 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       setProp(parameterCsn.elements[parameterToTypeAssocName], '$path',
         [ 'definitions', parameterEntityName, 'elements', parameterToTypeAssocName ] );
     }
-        // rewrite $path
+
+    // initialize containment
+    // propagate containment information, if containment is recursive, use parameterCsn.name as $containerNames
+    if(entityCsn.$containerNames) {
+      if(!parameterCsn.$containerNames)
+        setProp(parameterCsn, '$containerNames', []);
+      for(const c of entityCsn.$containerNames) {
+        parameterCsn.$containerNames.push((c === entityCsn.name) ? parameterCsn.name : c);
+      }
+    }
+    entityCsn.$containerNames = [ parameterCsn ];
+
+    if(!parameterCsn.$containeeAssociations)
+      setProp(parameterCsn, '$containeeAssociations', [ ]);
+    parameterCsn.$containeeAssociations.push(
+      { assoc: parameterCsn.elements[parameterToTypeAssocName],
+        path: [ parameterToTypeAssocName ]
+      });
+
+    // rewrite $path
     setProp(parameterCsn, '$path', [ 'definitions', parameterEntityName ]);
 
     // proxies are registered in model separately
@@ -638,14 +654,14 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
     // Don't operate on any structured types other than type and entity
     // such as events and aspects
-    if(!isStructuredArtifact(def))
+    if(!edmUtils.isStructuredArtifact(def))
       return;
 
     let keys = Object.create(null);
     let validFrom = [], validKey = [];
 
     // Iterate all struct elements
-    forEachMemberRecursively(def.items || def, (element, elementName, prop, _path = [], construct) => {
+    forEachMemberRecursively(def.items || def, (element, elementName, prop, _path, construct) => {
       if(prop !== 'elements')
         return;
 
@@ -660,37 +676,39 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       }
       //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) => {
+      const fk = elements[element['@odata.foreignKey4']];
+      for(const attrName in fk) {
+        const attr = fk[attrName];
         if(attrName[0] === '@') {
           element[attrName] = attr;
         }
-      });
+      }
       // and eventually remove some afterwards:)
       if(options.isV2())
-        setSAPSpecificV2AnnotationsToAssociation(element);
+        edmAnnoPreproc.setSAPSpecificV2AnnotationsToAssociation(element);
 
       // initialize an association
-      if(isAssociationOrComposition(element)) {
+      if(element.target) {
         // in case this is a forward assoc, store the backlink partners here, _selfReferences.length > 1 => error
-        assignProp(element, '_selfReferences', []);
-        assignProp(element._target, '$proxies', []);
+        edmUtils.assignProp(element, '_selfReferences', []);
+        edmUtils.assignProp(element._target, '$proxies', []);
         // $abspath is used as partner path
-        assignProp(element, '$abspath', $path2path(element.$path));
+        edmUtils.assignProp(element, '$abspath', $path2path(element.$path));
       }
 
       // Collect keys
       if (element.key) {
         keys[elementName] = element;
       }
-      applyAppSpecificLateCsnTransformationOnElement(options, element, def, error);
+      edmAnnoPreproc.applyAppSpecificLateCsnTransformationOnElement(options, element, def, error);
     }, [], true, { elementsOnly: true });
 
-    if(!isDeprecatedEnabled(options, 'v1KeysForTemporal')) {
+    if(!isDeprecatedEnabled(options, '_v1KeysForTemporal')) {
       // if artifact has a cds.valid.key mention it as @Core.AlternateKey
       if(validKey.length) {
         let altKeys = [{ Key: [] }];
         validKey.forEach(vk => altKeys[0].Key.push( { Name: vk.name, Alias: vk.name } ) );
-        assignAnnotation(def, '@Core.AlternateKeys', altKeys);
+        edmUtils.assignAnnotation(def, '@Core.AlternateKeys', altKeys);
       }
     }
     else {
@@ -699,14 +717,14 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       // @Core.AlternateKeys: [{ Key: [ { Name: 'slID', Alias: 'slID' }, { Name: 'validFrom', Alias: 'validFrom'} ] }]
       if(validKey.length) {
         let altKeys = [{ Key: [] }];
-        forAll(keys, (k, kn) => {
+        Object.entries(([kn, k]) => {
           altKeys[0].Key.push( { Name: kn, Alias: kn } );
           delete k.key;
         });
         validFrom.forEach(e => {
           altKeys[0].Key.push( { Name: e.name, Alias: e.name } );
         });
-        assignAnnotation(def, '@Core.AlternateKeys', altKeys);
+        edmUtils.assignAnnotation(def, '@Core.AlternateKeys', altKeys);
         keys = Object.create(null);
         validKey.forEach(e => {
           e.key = true;
@@ -722,27 +740,27 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     }
 
     // prepare the structure itself
-    if(isEntity(def)) {
-      assignProp(def, '_SetAttributes', Object.create(null));
-      assignProp(def, '$keys', keys);
-      applyAppSpecificLateCsnTransformationOnStructure(options, def, error);
-      setSAPSpecificV2AnnotationsToEntitySet(options, def);
+    if(def.kind === 'entity') {
+      edmUtils.assignProp(def, '_SetAttributes', Object.create(null));
+      edmUtils.assignProp(def, '$keys', keys);
+      edmAnnoPreproc.applyAppSpecificLateCsnTransformationOnStructure(options, def, error);
+      edmAnnoPreproc.setSAPSpecificV2AnnotationsToEntitySet(options, def);
     }
   }
 
   // Prepare the associations for the subsequent steps
   function initConstraints(def) {
-    if(!isStructuredArtifact(def))
+    if(!edmUtils.isStructuredArtifact(def))
       return;
 
     forEachMemberRecursively(def.items || def, initConstraintsOnAssoc, [], true, { elementsOnly: true });
   }
   function initConstraintsOnAssoc(element) {
-    if (isAssociationOrComposition(element) && !element._ignore && !element._constraints) {
+    if (element.target && !element._constraints) {
         // setup the constraints object
       setProp(element, '_constraints', { constraints: Object.create(null), selfs: [], _origins: [], termCount: 0 });
         // and crack the ON condition
-      resolveOnConditionAndPrepareConstraints(csn, element, messageFunctions);
+      edmUtils.resolveOnConditionAndPrepareConstraints(csn, element, messageFunctions);
     }
   }
 
@@ -759,7 +777,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     4) All of this can be revoked with options.renderForeignKeys.
   */
   function ignoreProperties(struct) {
-    if(!isStructuredArtifact(struct))
+    if(!edmUtils.isStructuredArtifact(struct))
       return;
 
     forEachMemberRecursively(struct.items || struct, (element) => {
@@ -783,19 +801,19 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
             */
           if((!isContainerAssoc && !isEdmPropertyRendered(element, options)) ||
                (isContainerAssoc && !options.renderForeignKeys))
-            assignAnnotation(element, '@cds.api.ignore', true);
+            edmUtils.assignAnnotation(element, '@cds.api.ignore', true);
           // Only in containment:
           // If this element is a foreign key and if it is rendered, remove it from the key ref vector
           else if(options.odataContainment && isContainerAssoc && options.renderForeignKeys) {
             delete struct.$keys[element.name];
           }
         }
-        // deprecated unmanagedUpInComponent:
+        // deprecated._unmanagedUpInComponent:
         // Only in containment:
         // Ignore this (foreign key) elment if renderForeignKeys is false
         if(options.odataContainment && element['@odata.containment.ignore']) {
           if(!options.renderForeignKeys)
-            assignAnnotation(element, '@cds.api.ignore', true);
+            edmUtils.assignAnnotation(element, '@cds.api.ignore', true);
           else
             // If foreign keys shall be rendered, remove it from key ref vector
             delete struct.$keys[element.name];
@@ -805,7 +823,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       else if(element['@odata.containment.ignore'] && options.odataContainment && !options.renderForeignKeys) {
           // if this is an explicitly containment ignore tagged association,
           // ignore it if option odataContainment is true and no foreign keys should be rendered
-        assignAnnotation(element, '@odata.navigable', false);
+        edmUtils.assignAnnotation(element, '@odata.navigable', false);
       }
     }, [], true, { elementsOnly: true });
   }
@@ -816,14 +834,14 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     in edmUtils
   */
   function finalizeConstraints(def) {
-    if(!isStructuredArtifact(def))
+    if(!edmUtils.isStructuredArtifact(def))
       return;
 
     forEachMemberRecursively(def.items || def, finalizeConstraintsOnAssoc, [], true, { elementsOnly: true });
   }
   function finalizeConstraintsOnAssoc(element) {
-    if (isAssociationOrComposition(element) && !element._ignore && element._constraints) {
-      finalizeReferentialConstraints(csn, element, options, info);
+    if (element.target && !element._ignore && element._constraints) {
+      edmUtils.finalizeReferentialConstraints(csn, element, options, info);
 
       if(element._constraints._partnerCsn && element.cardinality && element.cardinality.max) {
           // if this is a partnership and this assoc has a set target cardinality, assign it as source cardinality to the partner
@@ -855,7 +873,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     sub artifacts exposed by the initial type exposure
   */
   function convertExposedTypesOfOtherServicesIntoCrossReferences() {
-    if(options.toOdata.odataXServiceRefs && options.isV4()) {
+    if(options.odataXServiceRefs && options.isV4()) {
       serviceRootNames.forEach(srn => {
         schemaNames.forEach(fqSchemaName => {
           if(fqSchemaName.startsWith(srn + '.')) {
@@ -912,7 +930,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // if this artifact is a service member check its associations
     if(globalSchemaPrefix) {
       forEachGeneric(struct.items || struct, 'elements', element => {
-        if(!isAssociationOrComposition(element) || element._ignore || element['@odata.navigable'] === false)
+        if(!element.target || element['@odata.navigable'] === false)
           return;
         /*
          * Consider everything @cds.autoexpose: falsy to be a proxy candidate for now
@@ -920,7 +938,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         /*
         if(element._target['@cds.autoexpose'] === false) {
           // :TODO: Also _ignore foreign keys to association?
-          foreach(struct.elements,
+          edmUtils.foreach(struct.elements,
             e =>
               e['@odata.foreignKey4'] === element.name,
             e => e._ignore = true);
@@ -948,23 +966,27 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
         const targetSchemaName = element._target.$mySchemaName;
         if(isProxyRequired(element)) {
-          if(options.isV4() &&
-             (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs) &&
-             // must be a managed association with keys OR an unambiguous backlink
-             element.keys || 
-             (element.on && element._constraints.selfs.length === 1 && element._constraints.termCount === 1)
-            ) {
+          if(options.isV4() && (options.odataProxies || options.odataXServiceRefs)) {
+            // must be a managed association with keys OR an unambiguous backlink to become a proxy
+            let assocOK = element.keys ||
+             (element.on && element._constraints.selfs.length === 1 && element._constraints.termCount === 1);
             // reuse proxy if available
             let proxy = getProxyForTargetOf(element);
             if(!proxy) {
-              if(targetSchemaName && options.toOdata.odataXServiceRefs) {
+              if(targetSchemaName && options.odataXServiceRefs) {
                 proxy = createSchemaRefFor(targetSchemaName);
               }
-              else if(options.toOdata.odataProxies) {
+              // create a proxy for a 'good' association only
+              else if(options.odataProxies && assocOK) {
                 proxy = createProxyFor(element, targetSchemaName);
               }
               proxy = registerProxy(proxy, element);
-            }
+            } else if(!assocOK) {
+              // if there is already a proxy (generated by a 'good' association)
+              // and this association is not a good one, don't expose this association.
+              muteNavProp(element, 'oncond');
+              return;
+            }            
             if(proxy) {
             // if a proxy was either already created or could be created and
             // if it's a 'real' proxy, link the _target to it and remove constraints
@@ -982,24 +1004,22 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
               }
             }
             else {
-              // no proxy: no navigation
-              assignAnnotation(element, '@odata.navigable', false);
-              noNavPropMsg(element);
+              muteNavProp(element, assocOK ? 'std' : 'oncond');
+              return;
             }
           }
-          // ok schema names are different, now check if external wants to link back into its service schema
           else {
-            assignAnnotation(element, '@odata.navigable', false);
-            noNavPropMsg(element);
+            muteNavProp(element);
             return;
           }
         }
       });
     }
 
-    function noNavPropMsg(elt) {
+    function muteNavProp(elt, msg='std') {
+      edmUtils.assignAnnotation(elt, '@odata.navigable', false);
       warning('odata-navigation', ['definitions', struct.name, 'elements', elt.name],
-            { target: elt._target.name, service: globalSchemaPrefix });
+            { target: elt._target.name, service: globalSchemaPrefix, '#': msg });
     }
 
     function createSchemaRefFor(targetSchemaName) {
@@ -1015,16 +1035,16 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       // If target is outside any service expose it in service of source entity
       // The proxySchemaName is not prepended with the service schema name to allow to share the proxy
       // if it is required in multiple services. The service schema name is prepended upon registration
-      const proxySchemaName = targetSchemaName || getSchemaPrefix(assoc._target.name);
+      const proxySchemaName = targetSchemaName || edmUtils.getSchemaPrefix(assoc._target.name);
 
       // if the target is a parameter entity, it's easy just create the parameter stub
-      const isParamProxy = isParameterizedEntity(assoc._target);
+      const isParamProxy = edmUtils.isParameterizedEntity(assoc._target);
 
       // 1) construct the proxy definition
       // proxyDefinitionName: strip the serviceName and replace '.' with '_'
       let defName =
         `${assoc._target.name.replace(proxySchemaName + '.', '').replace(/\./g, '_')}`;
-      
+
       // fullName: Prepend serviceName and if in same service add '_proxy'
       const proxy = isParamProxy
         ? createParameterEntity(assoc._target,  proxySchemaName + '.' + defName, true)
@@ -1041,7 +1061,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       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] === '@')
+        if(k[0] === '@' && k !== '@open')
           proxy[k] = v;
       });
 
@@ -1068,13 +1088,13 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // copy over the primary keys of the target and trigger the type exposure
     // if the element already exists we assume it was fully exposed
     function populateProxyElements(assoc, proxy, elements) {
-      forAll(elements, e => {
+      Object.values(elements).forEach(e => {
         if (isEdmPropertyRendered(e, options)) {
           let newElt = proxy.elements[e.name];
           if(!newElt) {
             if(csnUtils.isAssocOrComposition(e.type)) {
               if(!e.on && e.keys) {
-                if(options.toOdata.odataNoTransitiveProxies)
+                if(options.odataNoTransitiveProxies)
                   newElt = convertManagedAssocIntoStruct(e);
                 else
                   newElt = createProxyOrSchemaRefForManagedAssoc(e);
@@ -1122,7 +1142,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       // to notNull until the first named type is exposed.
       function exposeStructTypeForProxyOf(proxy, node, artificialName,
                                           typeSchemaName=fallBackSchemaName,
-                                          isKey, forceToNotNull) {
+                                          isKey = false, forceToNotNull = false) {
 
         if(node.type && isBuiltinType(node.type))
           return;
@@ -1146,7 +1166,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
             let typeId = artificialName; // the artificialName has no namespace, it's the element
             if(node.type) {
                 // same as for proxies, use schema or namespace, 'root' is last resort
-              typeSchemaName = typeDef.$mySchemaName || getSchemaPrefix(node.type);
+              typeSchemaName = typeDef.$mySchemaName || edmUtils.getSchemaPrefix(node.type);
               typeId = node.type.replace(typeSchemaName + '.', '').replace(/\./g, '_');
                 // strip the service root of that type (if any)
               const myServiceRootName = whatsMyServiceRootName(typeSchemaName);
@@ -1154,7 +1174,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
                 typeSchemaName = typeSchemaName.replace(myServiceRootName + '.', '');
             }
 
-            if(isStructuredArtifact(typeDef)) {
+            if(edmUtils.isStructuredArtifact(typeDef)) {
                 // pull forceNotNull to false for named types and non-key nodes
                 // only toplevel nodes (elements) can be key
               forceToNotNull = !!(forceToNotNull && isKey && node.elements && !node.type);
@@ -1213,6 +1233,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           };
           setProp(type, '$mySchemaName', typeSchemaName);
           setProp(type, '$exposedBy', 'proxyExposure');
+          if(typeDef['@open'] !== undefined)
+            type['@open'] = typeDef['@open'];
 
           typeDef.elements && Object.entries(typeDef.elements).forEach( ([elemName, elem]) => {
             if(!elem.target) {
@@ -1275,10 +1297,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           proxy = getProxyForTargetOf(e);
           if(!proxy) {
             // option odataXServiceRefs has precedence over odataProxies
-            if(e._target.$mySchemaName && options.toOdata.odataXServiceRefs) {
+            if(e._target.$mySchemaName && options.odataXServiceRefs) {
               proxy = createSchemaRefFor(e._target.$mySchemaName);
             }
-            else if(options.toOdata.odataProxies) {
+            else if(options.odataProxies) {
               proxy = createProxyFor(e, e._target.$mySchemaName);
               if(!e._target.$isParamEntity)
                 populateProxyElements(e, proxy, getForeignKeyDefinitions(e));
@@ -1289,7 +1311,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         if(proxy === undefined) {
           proxy = e._target;
           // no proxy: no navigation
-          assignAnnotation(newElt, '@odata.navigable', false);
+          edmUtils.assignAnnotation(newElt, '@odata.navigable', false);
         }
         // either the proxy has exposed the type or
         // the assoc doesn't need to be exposed, so don't
@@ -1355,7 +1377,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
 
       if(!element._target.$cachedProxy)
-        assignProp(element._target, '$cachedProxy', Object.create(null));
+        edmUtils.assignProp(element._target, '$cachedProxy', Object.create(null));
       if(getProxyForTargetOf(element)) {
         info(null, ['definitions', struct.name, 'elements', element.name],
           { name: fqProxyName }, 'Proxy EDM entity type $(NAME) has already been registered');
@@ -1371,10 +1393,12 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
   function mergeProxiesIntoModel() {
     proxyCache.forEach(proxy => {
+
       const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
       const fqSchemaName = proxy.$globalSchemaPrefix + '.' + proxy.$mySchemaName;
 
       if(proxy.kind === 'entity') {
+        finalizeProxyContainments(proxy);
         // collect all schemas even for newly exposed types
         // (that may reside in another subcontext schema), but only once
         const schemaSet = new Set();
@@ -1384,7 +1408,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         // don't forget to prepend the global namespace prefix
         // schemas are ordered in csn2edm.js for each service
         Object.keys(proxy.$exposedTypes).forEach(t =>
-          schemaSet.add(proxy.$globalSchemaPrefix + '.' + getSchemaPrefix(t)));
+          schemaSet.add(proxy.$globalSchemaPrefix + '.' + edmUtils.getSchemaPrefix(t)));
         schemaSet.forEach(schemaName => {
           if(!schemas[schemaName]) {
             schemas[schemaName] = { kind: 'schema', name: schemaName };
@@ -1405,6 +1429,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
               setProp(v, '$path', ['definitions', fqtn]);
             }
           });
+
           // default location is not always correct in case proxy has been created by a nested assoc
           // as foreign key targeting another proxy association
           let loc = ['definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name];
@@ -1432,6 +1457,26 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     });
       // sort the global schemaNames array
     schemaNames.sort((a,b) => b.length-a.length);
+
+    function finalizeProxyContainments(proxy) {
+      // initialise containments after all exposed types are collected
+      // AND remove unfullfillable NavRestrictions
+      initContainments(proxy);
+      const assocPaths = proxy.$containeeAssociations.map(entry => entry.path.join('.'));
+      const newNpr = [];
+      const npr = proxy[NavResAnno];
+      npr && npr.forEach(np => {
+        const npath = np.NavigationProperty && np.NavigationProperty['='];
+        if(npath && assocPaths.includes(npath))
+          newNpr.push(np);
+      });
+      if(newNpr.length) {
+        proxy[NavResAnno] = newNpr;
+      }
+      else {
+        delete proxy[NavResAnno]
+      }
+    }
   }
 
   /*
@@ -1451,7 +1496,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     if(def.$keys) {
       setProp(def, '$edmKeyPaths', []);
       // for all key elements that shouldn't be ignored produce the paths
-      foreach(def.$keys, k => !k._ignore && !(k._isToContainer && k._selfReferences.length), (k, kn) => {
+      edmUtils.foreach(def.$keys, k => !(k._isToContainer && k._selfReferences.length), (k, kn) => {
         if(isEdmPropertyRendered(k, options) &&
          !(options.isV2() && k['@Core.MediaType'])) {
           if(options.isV4() && options.isStructFormat) {
@@ -1556,7 +1601,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
         // 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)) {
+        if(options.isV4() && type && !type.target && isBuiltinType(type.type)) {
           const edmType = edmUtils.mapCdsToEdmType(type);
           const legalEdmTypes = {
             'Edm.Boolean':1, 'Edm.Byte':1, 'Edm.Date':1, 'Edm.DateTimeOffset':1, 'Edm.Decimal':1, 'Edm.Duration':1,
@@ -1609,7 +1654,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       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 && !elt.$visited) {
           if(!elt._target.$edmTgtPaths)
             setProp(elt._target, '$edmTgtPaths', []);
           // drill into target only if
@@ -1621,10 +1666,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
              !elt._isToContainer &&
              curDef !== elt._target) {
             // follow elements in the target but avoid cycles
-            setProp(elt, '$touched', true);
+            setProp(elt, '$visited', true);
             elt._target.$edmTgtPaths.push(newPrefix);
             Object.values(elt._target.elements).forEach(e => produceTargetPath(newPrefix, e, elt._target));
-            delete elt.$touched;
+            delete elt.$visited;
           }
         }
         else {
@@ -1654,7 +1699,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       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 && !elt.$visited) {
           // 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)
@@ -1664,9 +1709,9 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
              !elt._isToContainer &&
              curDef !== elt._target) {
             // follow elements in the target but avoid cycles
-            setProp(elt, '$touched', true);
+            setProp(elt, '$visited', true);
             Object.values(elt._target.elements).forEach(e => npbs = npbs.concat(produceNavigationPath(e, elt._target)));
-            delete elt.$touched;
+            delete elt.$visited;
           }
           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
@@ -1718,7 +1763,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // 1) must not be a proxy and not a containee in V4
     // No annos are rendered for non-existing EntitySet targets.
     if(def.$hasEntitySet === undefined) {
-      const hasEntitySet = isEntity(def) && !(options.isV4() && edmUtils.isContainee(def)) && !def.$proxy;
+      const hasEntitySet = def.kind === 'entity' && !(options.isV4() && edmUtils.isContainee(def)) && !def.$proxy;
       setProp(def, '$hasEntitySet', hasEntitySet);
     }
   }
@@ -1727,7 +1772,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // 1. let all doc props become @Core.Descriptions
     // 2. mark a member that will become a collection
     // 3. assign the edm primitive type to elements, to be used in the rendering later
-    assignAnnotation(def, '@Core.Description', def.doc);
+    edmUtils.assignAnnotation(def, '@Core.Description', def.doc);
     markCollection(def);
     mapCdsToEdmProp(def);
     if (def.returns)  {
@@ -1735,7 +1780,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       mapCdsToEdmProp(def.returns);
     }
     forEachMemberRecursively(def,member => {
-      assignAnnotation(member, '@Core.Description', member.doc);
+      edmUtils.assignAnnotation(member, '@Core.Description', member.doc);
       markCollection(member);
       mapCdsToEdmProp(member);
       ComputedDefaultValue(member);
@@ -1748,98 +1793,143 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     function markCollection(obj) {
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
       if (items) {
-        assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : true);
-        assignProp(obj, '_isCollection', true);
+        edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : true);
+        edmUtils.assignProp(obj, '_isCollection', true);
       }
     }
   }
 
+  // If containment in V4 is active, annotations that would be assigned to the containees
+  // entity set are not renderable anymore. In such a case try to reassign the annotations to
+  // the containment navigation property.
+  // Today only Capabilities.*Restrictions are known to be remapped as there exists a CDS
+  // short cut annotation @readonly that gets expanded and can be safely remapped.
+  function rewriteContainmentAnnotations(rootContainer) {
 
-  //////////////////////////////////////////////////////////////////////
-  //
-  // Checks section starts here
-  //
+    // meaningless for non-entities and proxies
+    if(rootContainer.kind !== 'entity' || rootContainer.$proxy)
+      return;
 
-// eslint-disable-next-line no-unused-vars
-  function resolveForeignKeyRefs() {
-    forEachDefinition(csn, (def, defName) => {
-      let currPath = ['definitions', defName ];
-      forEachMemberRecursively(def, (construct, _constructName, _prop, path) => {
-        if(construct.target && construct.keys) {
-          construct.keys.forEach((fk, i) => {
-            setProp(fk, '_artifact', csnUtils.inspectRef([...path, 'keys', i]).art);
-          });
-        }
-      }, currPath, true, { elementsOnly: true });
-    });
-  }
+    const isRecursiveContainment = 
+      !!(rootContainer.$containerNames && rootContainer.$containeeAssociations && 
+      rootContainer.$containerNames.length === 1 &&
+      rootContainer.$containeeAssociations.some(entry => rootContainer.$containerNames.includes(entry.assoc.target)));
 
+    // Root nodes are not contained
+    const isRootNode = 
+      !!(!rootContainer.$containerNames ||
+          rootContainer.$containerNames && rootContainer.$containerNames.length === 0);
 
-  function inboundQualificationChecks() {
-    forEachDefinition(csn, [ attach$path, checkChainedArray ]);
-    checkNestedContextsAndServices();
-    throwWithAnyError();
+    if(!isRecursiveContainment && !isRootNode)
+      return;
 
-    // attach $path to all
-    function attach$path(def, defName) {
-      setProp(def, '$path', [ 'definitions', defName ]);
-      forEachMemberRecursively(def,
-        (member, _memberName, _prop, path) => {
-          setProp(member, '$path', path);
-        }, [ 'definitions', defName ]);
-    }
+    const rootRestrictions = [];
+    addContainmentAnnotationsRecursively([], rootContainer);
+    if(rootRestrictions.length)
+      rootContainer[NavResAnno] = rootRestrictions;
+    
+    function addContainmentAnnotationsRecursively(prefix, container) {
+      if(container.$containeeAssociations) {
+        // copy or create container restrictions, don't modify original
+        const localRestrictions = container[NavResAnno] ?
+        cloneCsnDictionary(container[NavResAnno], options) : []
+      
+        setProp(container, '$visited', true);
+        container.$containeeAssociations.forEach(entry => {
+          const { assoc, path } = entry;
+          const containee = assoc._target;
+
+          if(isMyServiceRequested(containee.name) || containee.$proxy) {
+            const localAssocPath = path.join('.');
+            const props = Object.entries(containee);
+            ['@Capabilities.DeleteRestrictions',
+              '@Capabilities.InsertRestrictions',
+              '@Capabilities.UpdateRestrictions',
+              '@Capabilities.ReadRestrictions'].forEach(c => 
+                edmUtils.mergeIntoNavPropRestrictions(c, localAssocPath, props, localRestrictions));
+
+
+            if(!containee.$visited) {
+              addContainmentAnnotationsRecursively(prefix.concat(path), containee);
+            }
+          }
+        });
 
-    function checkChainedArray(def, defName) {
-      if (!isMyServiceRequested(defName))
-        return;
-      let currPath = ['definitions', defName];
-      checkIfItemsOfItems(def, undefined, undefined, currPath);
-      forEachMemberRecursively(def, checkIfItemsOfItems, currPath);
-
-      function checkIfItemsOfItems(construct, _constructName, _prop, path) {
-        const constructType = csnUtils.effectiveType(construct);
-        if (constructType.items) {
-          if (constructType.items.items) {
-            message('chained-array-of', path);
-            return;
+        // 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;
+      }
+    }
+  }
 
-          const itemsType = csnUtils.effectiveType(constructType.items);
-          if (itemsType.items)
-            message('chained-array-of', path);
-        }
+  /*
+    V4 Only:
+    An action/function parameter is optional if
+    1) it is explicitly annotated to be optional
+    2) it has a default value (including null), regardless of it's nullability
+    3) it has NO default value but is nullable (the implicit default value is null)
+
+    If a mandatory parameter (not null no default value) appears after an optional
+    parameter, a warning is raised, Core.OptionalParameter requires that all optional
+    parameters appear rightmost.
+  */
+  function annotateOptionalActFuncParams(def, defName) {
+    if(!isBetaEnabled(options, 'optionalActionFunctionParameters'))
+      return;
+    // return if there is nothing to do
+    const loc = [ 'definitions', defName ]
+    if(def.kind === 'function' || def.kind === 'action')
+      iterateParams(def, loc.concat('params'));
+    if(def.actions) {
+      for(const an in def.actions) {
+        const a = def.actions[an];
+        iterateParams(a, loc.concat(['actions', an, 'params' ]));
       }
     }
 
-    function checkNestedContextsAndServices() {
-      !isBetaEnabled(options, 'nestedServices') && serviceRootNames.forEach(sn => {
-        const parent = whatsMyServiceRootName(sn, false);
-        if(parent && requestedServiceNames.includes(parent) && parent !== sn) {
-          message( 'service-nested-service', [ 'definitions', sn ], { art: parent },
-               'A service can\'t be nested within a service $(ART)' );
+    function iterateParams(def, loc) {
+      let lastOptPos = 0;
+      let i = 0;
+      for(const pn in def.params) {
+        const p = def.params[pn];
+        // user assigned annotation, don't touch it
+        if(Object.keys(p).some(a => a.startsWith('@Core.OptionalParameter') && p[a] !== null)) {
+          lastOptPos = i;
         }
-      });
-
-      Object.entries(csn.definitions).forEach(([fqName, art]) => {
-        if(art.kind === 'context') {
-          const parent = whatsMyServiceRootName(fqName);
-          if(requestedServiceNames.includes(parent)) {
-            message( 'service-nested-context', [ 'definitions', fqName ], { art: parent },
-               'A context can\'t be nested within a service $(ART)' );
-          }
+        // default value automatically makes param optional
+        else if(p.default) {
+          if(p.default.val)
+            edmUtils.assignAnnotation(p, '@Core.OptionalParameter.DefaultValue', p.default.val);
+          else
+            edmUtils.assignAnnotation(p, '@Core.OptionalParameter.$Type', '');
+          lastOptPos = i;
         }
-      });
+        // if no default is available, nullable makes param optional
+        else if(!p.notNull) {
+          edmUtils.assignAnnotation(p, '@Core.OptionalParameter.$Type', '');
+          lastOptPos = i;
+        }
+        // check if mandatory param follows optional param
+        else if(lastOptPos < i) {
+          warning('odata-parameter-order', loc.concat(pn));
+        }
+        i++;
+      }
     }
   }
 
-  //
-  // Checks Secition ends here
-  //
-  //////////////////////////////////////////////////////////////////////
-
-
-
-
   //////////////////////////////////////////////////////////////////////
   //
   // Helper section starts here
@@ -1884,96 +1974,18 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     }
   }
 
-
-  // If containment in V4 is active, annotations that would be assigned to the containees
-  // entity set are not renderable anymore. In such a case try to reassign the annotations to
-  // the containment navigation property.
-  // Today only Capabilities.*Restrictions are known to be remapped as there exists a CDS
-  // short cut annotation @readonly that gets expanded and can be safely remapped.
-  function rewriteContainmentAnnotations(container, containee, assocName) {
-    // rectify Restrictions to NavigationRestrictions
-    if(options.isV4()) {
-      let navPropEntry;
-      let hasEntry = false;
-      let newEntry = false;
-      const anno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
-      let resProps = container[anno];
-      // merge into existing anno, if available
-      if(resProps) {
-        navPropEntry = resProps.find(p => p.NavigationProperty && p.NavigationProperty['='] === assocName);
-        hasEntry = !!navPropEntry;
-      }
-      if(!navPropEntry) {
-        navPropEntry =  { NavigationProperty: { '=': assocName } };
-      }
-
-      const props = Object.entries(containee);
-
-      const merge = (prefix) => {
-        const prop = prefix.split('.')[1];
-        // don't overwrite existing restrictions
-        if(!navPropEntry[prop]) {
-          // Filter properties with prefix and reduce them into a new dictionary
-          const o = props.filter(p => p[0].startsWith(prefix+'.')).reduce((a,c) => {
-            a[c[0].replace(prefix+'.', '')] = c[1];
-            return a;
-          }, { });
-          // if dictionary has entries, add them to navPropEnty
-          if(Object.keys(o).length) {
-            // ReadRestrictions may have sub type ReadByKeyRestrictions { Description, LongDescription }
-            // chop annotations into dictionaries
-            if(prefix === '@Capabilities.ReadRestrictions' && 
-               Object.keys(o).some(k => k.startsWith('ReadByKeyRestrictions.'))) {
-              const no = {};
-              Object.entries(o).forEach(([k,v]) => {
-                const [head, ...tail] = k.split('.');
-                if(head === 'ReadByKeyRestrictions' && tail.length) {
-                  if(!no['ReadByKeyRestrictions'])
-                    no['ReadByKeyRestrictions'] = {};
-                  // Don't try to add entry into non object
-                  if(typeof no['ReadByKeyRestrictions'] === 'object')
-                    no['ReadByKeyRestrictions'][tail.join('.')] = v;
-                }
-                else {
-                  no[k] = v;
-                }
-              });
-              navPropEntry[prop] = no;
-            }
-            else {
-              navPropEntry[prop] = o;
-            }
-            newEntry = true;
-          }
-        }
-      }
-      merge('@Capabilities.DeleteRestrictions');
-      merge('@Capabilities.InsertRestrictions');
-      merge('@Capabilities.UpdateRestrictions');
-      merge('@Capabilities.ReadRestrictions');
-
-      if(newEntry) {
-        if(!hasEntry) {
-          if(!resProps)
-            resProps = container[anno] = [ ];
-          resProps.push(navPropEntry);
-        }
-      }
-    }
-  }
-
   function mapCdsToEdmProp(obj) {
-    if (obj.type && isBuiltinType(obj.type) && !isAssociationOrComposition(obj) && !obj.targetAspect) {
-      let edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.toOdata.version === 'v2', obj['@Core.MediaType']);
-      assignProp(obj, '_edmType', edmType);
+    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)))) {
-      let edmType = edmUtils.mapCdsToEdmType(obj.items, messageFunctions, _options.toOdata.version === 'v2', obj['@Core.MediaType'], obj.$path);
-      assignProp(obj, '_edmType', edmType);
+      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))) {
-      let edmType = edmUtils.mapCdsToEdmType(obj.items.items, messageFunctions, _options.toOdata.version === 'v2', obj['@Core.MediaType']);
-      assignProp(obj, '_edmType', edmType);
+      let edmType = edmUtils.mapCdsToEdmType(obj.items.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
+      edmUtils.assignProp(obj, '_edmType', edmType);
     }
   }
 
@@ -1991,375 +2003,12 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       }
       // it is a computed value if it is not a simple value or an annotation
       if(!((def.val !== undefined && !noTailExpr) || def['#'])) {
-        assignAnnotation(member, '@Core.ComputedDefaultValue', true);
-      }
-    }
-  }
-}
-
-
-
-
-/*
- * Late application specific transformations
- *  At present there are two transformation targets: Structure and Element
- *  These transformations are available today:
- *
- *  Analytical Scenario:
- *    If a structure is annotated with @Aggregation.ApplySupported.PropertyRestrictions
- *    then a number of annotation rewrites are done to this structure and to the
- *    elements of this structure
- *    Also the key properties of all structure elements are removed and a new
- *    artificial key element 'key _ID : String' is inserted at first position of
- *    the elements dictionary
- *
- * PDM (Personal Data Management)
- *    Planned but not yet implemented annotation rewriting (pending to finalization)
- * /
-
-/* eslint max-statements-per-line:off */
-
-function mapAnnotationAssignment(artifact, parent, mappingDictionary)
-{
-  let props = intersect(Object.keys(mappingDictionary), Object.keys(artifact));
-  // now start the substitution
-  props.forEach(prop => {
-    let [ mapping, value, remove_original ] = mappingDictionary[prop];
-    if(mapping instanceof Function)
-    {
-      mapping(artifact, parent, prop);
-    }
-    else
-    {
-      assignAnnotation(artifact, mapping, value || artifact[prop]['='] || artifact[prop]);
-    }
-
-    if(remove_original)
-      delete artifact[prop];
-  });
-}
-
-function applyAppSpecificLateCsnTransformationOnElement(options, element, struct, error)
-{
-  if(options.isV2())
-  {
-    if(struct['@Aggregation.ApplySupported.PropertyRestrictions'])
-    {
-      mapAnnotationAssignment(element, struct, AnalyticalAnnotations());
-    }
-    mapAnnotationAssignment(element, struct, PDMSemantics());
-  }
-
-  // etag requires Core.OptimisticConcurrency to be set in V4 (cap/issues#2641)
-  // Oliver Heinrich mentions in the issue that the Okra runtime must be set to a
-  // concurrent runtime mode by the caller, if the annotation is added this late,
-  // it doesn't appear in the forOData processed CSN, meaning that the
-  // runtime cannot set that okra flag (alternatively the runtime has to search
-  // for @[odata|cds].etag annotations...
-  if(options.isV4())
-  {
-    if(element['@odata.etag'] == true || element['@cds.etag'] == true) {
-      // don't put element name into collection as per advice from Ralf Handl, as
-      // no runtime is interested in the property itself, it is sufficient to mark
-      // the entity set.
-      assignAnnotation(struct, '@Core.OptimisticConcurrency',
-        (struct['@Core.OptimisticConcurrency'] || [])/*.push(element.name)*/);
-    }
-  }
-
-  // nested functions begin
-  function PDMSemantics()
-  {
-    /*
-    let dict = Object.create(null);
-
-    dict['@PDM.xxx1'] = [ '@sap.pdm-semantics' ];
-    dict['@PDM.xxx2'] = [ '@sap.pdm-propery' ];
-    dict['@PDM.xxx3'] = [ '@sap.pdm-display-sq-no' ];
-    dict['@PDM.xxx4'] = [ '@sap.pdm-record-identifier' ];
-    dict['@PDM.xxx5'] = [ '@sap.pdm-field-group' ];
-    dict['@PDM.xxx6'] = [ '@sap.pdm-mask-find-pattern' ];
-    dict['@PDM.xxx7'] = [ '@sap.pdm-mask-replacement-pattern' ];
-    dict['@PDM.xxx8'] = [ '@sap.deletable' ];
-    dict['@PDM.xxx8'] = [ '@sap.updatable' ];
-
-    // respect flattened annotation $value
-    Object.keys(dict).forEach(k => dict[k+'.$value'] = dict[k]);
-    */
-    return Object.create(null);
-  }
-
-  function AnalyticalAnnotations()
-  {
-    function mapCommonAttributes(element, struct, prop)
-    {
-      let CommonAttributes = element[prop];
-      if(!Array.isArray(CommonAttributes)) {
-        error(null, ['definitions', struct.name, 'elements', element.name],
-          { anno: '@Common.attribute', code: JSON.stringify(CommonAttributes) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
-        return;
+        edmUtils.assignAnnotation(member, '@Core.ComputedDefaultValue', true);
       }
-
-      let targets = intersect(CommonAttributes, Object.keys(struct.elements));
-      targets.forEach(tgt => {
-        assignAnnotation(struct.elements[tgt], '@sap.attribute-for', element.name);
-      });
     }
-
-    function mapContextDefiningProperties(element, struct, prop)
-    {
-      let ContextDefiningProperties = element[prop];
-      if(!Array.isArray(ContextDefiningProperties)) {
-        error(null, ['definitions', struct.name, 'elements', element.name],
-          { anno: '@Aggregation.ContextDefiningProperties', code: JSON.stringify(ContextDefiningProperties) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
-        return;
-      }
-      if(ContextDefiningProperties.length > 0)
-        assignAnnotation(element, '@sap.super-ordinate', ContextDefiningProperties[ContextDefiningProperties.length-1]);
-    }
-
-    let dict = Object.create(null);
-    //analytics term definition unknown, lower case
-    dict['@Analytics.Measure'] = [ '@sap.aggregation-role', 'measure' ];
-    dict['@Analytics.Dimension'] = [ '@sap.aggregation-role', 'dimension' ];
-    dict['@Semantics.currencyCode'] = [ '@sap.semantics', 'currency-code', true ];
-    dict['@Semantics.unitOfMeasure'] = [ '@sap.semantics', 'unit-of-measure', true ];
-
-    dict['@Measures.ISOCurrency'] = [ '@sap.unit' ];
-    dict['@Measures.Unit'] = [ '@sap.unit' ];
-
-    dict['@Common.Label'] = [ '@sap.label' ];
-    dict['@Common.Text'] = [ '@sap.text' ];
-    dict['@Aggregation.ContextDefiningProperties'] = [ mapContextDefiningProperties ];
-    dict['@Common.Attributes'] = [ mapCommonAttributes ];
-
-    // respect flattened annotation $value
-    Object.entries(dict).forEach(([k, v]) => dict[k+'.$value'] = v);
-    return dict;
-  }
-}
-
-function applyAppSpecificLateCsnTransformationOnStructure(options, struct, error)
-{
-  if(options.isV2())
-  {
-    if(struct['@Aggregation.ApplySupported.PropertyRestrictions'])
-    {
-      transformAnalyticalModel(struct);
-      mapAnnotationAssignment(struct, undefined, AnalyticalAnnotations());
-    }
-  }
-
-  // nested functions begin
-  function transformAnalyticalModel(struct)
-  {
-    let keyName = 'ID__';
-    if(struct == undefined || struct.elements == undefined || struct.elements[keyName] != undefined)
-      return;
-
-    // remove key prop from elements, add new key to elements
-    let elements = Object.create(null);
-    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.items || struct, 'elements', (e,n) =>
-    {
-      if(e.key) delete e.key;
-      elements[n] = e;
-    });
-    struct.elements = elements;
-  }
-
-  function AnalyticalAnnotations()
-  {
-    function mapFilterRestrictions(struct, parent, prop)
-    {
-      let stringDict = Object.create(null);
-      stringDict['SingleValue'] = 'single-value';
-      stringDict['MultiValue'] = 'multi-value';
-      stringDict['SingleRange'] = 'interval';
-
-      let filterRestrictions = struct[prop];
-      if(!Array.isArray(filterRestrictions)) {
-        error(null, ['definitions', struct.name ],
-          { anno: '@Capabilities.FilterRestrictions.FilterExpressionRestrictions',
-            code: JSON.stringify(filterRestrictions) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
-        return;
-      }
-      filterRestrictions.forEach(v => {
-        let e = struct.elements[v.Property];
-        if(e)
-          assignAnnotation(e, '@sap.filter-restriction', stringDict[v.AllowedExpressions]);
-      });
-    }
-
-    function mapRequiredProperties(struct, parent, prop)
-    {
-      let requiredProperties = struct[prop];
-      if(!Array.isArray(requiredProperties)) {
-        error(null, ['definitions', struct.name],
-          { anno: '@Capabilities.FilterRestrictions.RequiredProperties',
-            code: JSON.stringify(requiredProperties) },
-          `Expect array value for $(ANNOTATION): $(CODE)`);
-        return;
-      }
-
-      let props = intersect(Object.keys(struct.elements), requiredProperties)
-      props.forEach(p => {
-        assignAnnotation(struct.elements[p], '@sap.required-in-filter', true);
-      });
-    }
-
-    function mapRequiresFilter(struct, parent, prop)
-    {
-      let requiresFilter = struct[prop];
-      if(requiresFilter)
-        assignAnnotation(struct._SetAttributes, '@sap.requires-filter', requiresFilter);
-    }
-
-      // Entity Props
-    let dict = Object.create(null);
-    dict['@Aggregation.ApplySupported.PropertyRestrictions'] = [ '@sap.semantics', 'aggregate' ];
-    dict['@Common.Label'] = [ '@sap.label' ];
-    dict['@Capabilities.FilterRestrictions.RequiresFilter'] = [ mapRequiresFilter ];
-    dict['@Capabilities.FilterRestrictions.RequiredProperties'] = [ mapRequiredProperties ];
-    dict['@Capabilities.FilterRestrictions.FilterExpressionRestrictions'] = [ mapFilterRestrictions ];
-
-    // respect flattened annotation $value
-    Object.keys(dict).forEach(k => dict[k+'.$value'] = dict[k]);
-
-    return dict;
-  }
-}
-
-function setSAPSpecificV2AnnotationsToEntityContainer(options, carrier) {
-  if(!options.isV2())
-    return;
-  // documented in https://wiki.scn.sap.com/wiki/display/EmTech/SAP+Annotations+for+OData+Version+2.0#SAPAnnotationsforODataVersion2.0-Elementedm:EntityContainer
-  const SetAttributes = {
-    // EntityContainer only
-    '@sap.supported.formats' : addToSetAttr,
-    '@sap.use.batch': addToSetAttr,
-    '@sap.message.scope.supported': addToSetAttr,
-  };
-
-  Object.entries(carrier).forEach(([p, v]) => {
-    (SetAttributes[p] || function() { /* no-op */ })(carrier, p, v);
-  });
-
-  function addToSetAttr(carrier, propName, propValue, removeFromType=true) {
-    assignProp(carrier, '_SetAttributes', Object.create(null));
-    assignAnnotation(carrier._SetAttributes, propName, propValue);
-    if(removeFromType) {
-      delete carrier[propName];
-    }
-  }
-}
-
-function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
-  if(!options.isV2())
-    return;
-  // documented in https://wiki.scn.sap.com/wiki/display/EmTech/SAP+Annotations+for+OData+Version+2.0#SAPAnnotationsforODataVersion2.0-Elementedm:EntitySet
-  const SetAttributes = {
-    // EntitySet, EntityType
-    '@sap.label' : (s,pn, pv) => { addToSetAttr(s, pn, pv, false); },
-    '@sap.semantics': checkSemantics,
-    // EntitySet only
-    '@sap.creatable' : addToSetAttr,
-    '@sap.updatable' : addToSetAttr,
-    '@sap.deletable': addToSetAttr,
-    '@sap.updatable.path': addToSetAttr,
-    '@sap.deletable.path': addToSetAttr,
-    '@sap.searchable' : addToSetAttr,
-    '@sap.pagable': addToSetAttr,
-    '@sap.topable': addToSetAttr,
-    '@sap.countable': addToSetAttr,
-    '@sap.addressable': addToSetAttr,
-    '@sap.requires.filter': addToSetAttr,
-    '@sap.change.tracking': addToSetAttr,
-    '@sap.maxpagesize': addToSetAttr,
-    '@sap.delta.link.validity': addToSetAttr,
-  };
-
-  Object.entries(carrier).forEach(([p, v]) => {
-    (SetAttributes[p] || function() { /* no-op */ })(carrier, p, v);
-  });
-
-  function addToSetAttr(carrier, propName, propValue, removeFromType=true) {
-    assignProp(carrier, '_SetAttributes', Object.create(null));
-    assignAnnotation(carrier._SetAttributes, propName, propValue);
-    if(removeFromType) {
-      delete carrier[propName];
-    }
-  }
-
-  function checkSemantics(struct, propName, propValue) {
-    if(propValue === 'timeseries' || propValue === 'aggregate') {
-      // aggregate is forwarded to Set and must remain on Type
-      addToSetAttr(struct, propName, propValue, propValue !== 'aggregate');
-    }
-  }
-}
-
-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' : (c, pn, pv) => { addToAssociationSet(c, pn, pv, false); },
-    // Not applicable to NavProp, applicable to foreign keys, add to AssociationSet
-    '@sap.updatable' : addToAssociationSet,
-    // Not applicable to NavProp, not applicable to foreign key, add to AssociationSet
-    '@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,
-    '@sap.filterable': removeFromForeignKey,
-  };
-
-  Object.entries(carrier).forEach(([p, v]) => {
-    (SetAttributes[p] || function() {/* no-op */})(carrier, p, v);
-  });
-
-  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(carrier, propName) {
-    if(carrier['@odata.foreignKey4'] && carrier[propName] !== undefined) {
-      delete carrier[propName];
-    }
-  }
-}
-
-// Assign but not overwrite annotation
-function assignAnnotation(node, name, value) {
-  if(value !== undefined &&
-      name !== undefined && name[0] === '@' &&
-      (node[name] === undefined ||
-      node[name] && node[name] === null)) {
-    node[name] = value;
-  }
-}
-
-// Set non enumerable property if it doesn't exist yet
-function assignProp(obj, prop, value) {
-  if(obj[prop] === undefined) {
-    setProp(obj, prop, value);
   }
 }
 
 module.exports = {
   initializeModel,
-  assignAnnotation
 }