@sap/cds-compiler 3.0.0 → 3.1.2

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, applyTransformations
+} = 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,7 +39,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
 
   // make sure options are complete
-  let options = validateOptions(_options);
+  let options = edmUtils.validateOptions(_options);
 
   const [ serviceRoots,
     serviceRootNames,
@@ -69,7 +61,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   }
 
   // Structural CSN inbound QA checks
-  inboundQualificationChecks();
+  inboundQualificationChecks(csn, options, messageFunctions,
+    serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName);
   // not needed at the moment
   // resolveForeignKeyRefs();
 
@@ -124,10 +117,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       (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);
@@ -142,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,
@@ -166,7 +169,14 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       initEdmTypesAndDescription
     ]);
   }
-  return [serviceRoots, schemas, reqDefs, whatsMyServiceRootName, fallBackSchemaName, options];
+  return [
+    serviceRoots,
+    schemas,
+    reqDefs,
+    whatsMyServiceRootName,
+    fallBackSchemaName,
+    options
+  ];
 
   //////////////////////////////////////////////////////////////////////
   //
@@ -236,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')
@@ -300,7 +310,7 @@ 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.odataProxies || options.odataXServiceRefs) && options.isStructFormat && */
         defName !== myServiceRoot && myServiceRoot !== mySchemaPrefix) {
@@ -314,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)) {
-        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));
             }
-          }
-          else {
-            error(null, subpath, { target: element.target }, "Target $(TARGET) can't be found in the model");
+            target.$sources[struct.name + '.' + name] = element;
           }
         }
+        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;
       }
@@ -367,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
@@ -377,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 });
         }
       }
     }
@@ -436,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
@@ -459,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;
 
@@ -505,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
@@ -515,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) {
@@ -532,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);
     }
 
     /*
@@ -540,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;
@@ -569,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);
@@ -589,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
@@ -633,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;
 
@@ -655,29 +676,31 @@ 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')) {
@@ -685,7 +708,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       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 {
@@ -694,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;
@@ -717,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._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);
     }
   }
 
@@ -754,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) => {
@@ -778,7 +801,7 @@ 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) {
@@ -790,7 +813,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         // 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];
@@ -800,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 });
   }
@@ -811,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
@@ -907,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['@odata.navigable'] === false)
+        if(!element.target || element['@odata.navigable'] === false)
           return;
         /*
          * Consider everything @cds.autoexpose: falsy to be a proxy candidate for now
@@ -915,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);
@@ -943,23 +966,27 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
         const targetSchemaName = element._target.$mySchemaName;
         if(isProxyRequired(element)) {
-          if(options.isV4() &&
-             (options.odataProxies || options.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.odataXServiceRefs) {
                 proxy = createSchemaRefFor(targetSchemaName);
               }
-              else if(options.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
@@ -977,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) {
@@ -1010,10 +1035,10 @@ 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 '_'
@@ -1036,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;
       });
 
@@ -1063,7 +1088,7 @@ 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) {
@@ -1117,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;
@@ -1141,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);
@@ -1149,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);
@@ -1208,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) {
@@ -1284,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
@@ -1350,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');
@@ -1366,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();
@@ -1379,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 };
@@ -1400,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];
@@ -1427,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]
+      }
+    }
   }
 
   /*
@@ -1446,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._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) {
@@ -1551,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,
@@ -1604,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
@@ -1616,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 {
@@ -1649,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)
@@ -1659,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
@@ -1713,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);
     }
   }
@@ -1722,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)  {
@@ -1730,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);
@@ -1743,98 +1793,160 @@ 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);
+    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);
+
+    if(!isRecursiveContainment && !isRootNode)
+      return;
+
+    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) : []
+
+        // 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('.');
+                }
+              });
+            }
           });
         }
-      }, currPath, true, { elementsOnly: true });
-    });
-  }
 
+        setProp(container, '$visited', true);
+        // collect capabilities from containees
+        container.$containeeAssociations.forEach(entry => {
+          const { assoc, path } = entry;
+          const containee = assoc._target;
 
-  function inboundQualificationChecks() {
-    forEachDefinition(csn, [ attach$path, checkChainedArray ]);
-    checkNestedContextsAndServices();
-    throwWithAnyError();
+          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('.')));
 
-    // 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 ]);
-    }
+            if(!hasEntry) {
+              navPropEntry =  { NavigationProperty: { '=': prefix.concat(localAssocPath).join('.') } };
+            }
 
-    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;
+            const props = Object.entries(containee);
+            let newEntry = false;
+            ['@Capabilities.DeleteRestrictions',
+              '@Capabilities.InsertRestrictions',
+              '@Capabilities.UpdateRestrictions',
+              '@Capabilities.ReadRestrictions'].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);
+            }
           }
+        });
 
-          const itemsType = csnUtils.effectiveType(constructType.items);
-          if (itemsType.items)
-            message('chained-array-of', path);
-        }
+        rootRestrictions.unshift(...localRestrictions);
+        delete container.$visited;
       }
     }
+  }
 
-    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)' );
-        }
-      });
+  /*
+    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' ]));
+      }
+    }
 
-      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)' );
-          }
+    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;
         }
-      });
+        // 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
@@ -1879,96 +1991,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) {
+    if (obj.type && isBuiltinType(obj.type) && !obj.target && !obj.targetAspect) {
       let edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
-      assignProp(obj, '_edmType', edmType);
+      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.odataVersion === 'v2', obj['@Core.MediaType'], obj.$path);
-      assignProp(obj, '_edmType', edmType);
+      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.odataVersion === 'v2', obj['@Core.MediaType']);
-      assignProp(obj, '_edmType', edmType);
+      edmUtils.assignProp(obj, '_edmType', edmType);
     }
   }
 
@@ -1986,375 +2020,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);
+        edmUtils.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;
-      }
-
-      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
 }