@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/edm/edmPreprocessor.js

@@ -2,7 +2,7 @@
 /* eslint max-statements-per-line:off */
 const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const { forEachDefinition, forEachGeneric, forEachMemberRecursively,
-  isEdmPropertyRendered, getUtils, cloneCsn, isBuiltinType } = require('../model/csnUtils');
+  isEdmPropertyRendered, getUtils, cloneCsnNonDict, isBuiltinType } = require('../model/csnUtils');
 const edmUtils = require('./edmUtils.js');
 const typesExposure = require('../transform/odata/typesExposure');
 const expandCSNToFinalBaseType = require('../transform/odata/toFinalBaseType');
@@ -18,10 +18,8 @@ const {
   isParameterizedEntity,
   resolveOnConditionAndPrepareConstraints,
   finalizeReferentialConstraints,
-  isODataSimpleIdentifier,
   isEntity,
   getSchemaPrefix,
-  isActionOrFunction
 } = require('./edmUtils.js');
 
 /**
@@ -34,45 +32,46 @@ const {
  * @param {CSN.Model} csn
  * @param {object}    _options
  */
-function initializeModel(csn, _options, messageFunctions)
+function initializeModel(csn, _options, messageFunctions, requestedServiceNames=undefined)
 {
-  if (!_options)
-    throw Error('Please debug me: initializeModel must be invoked with options');
+  const { info, warning, error, message, throwWithAnyError } = messageFunctions;
 
-  const { info, warning, error, message, throwWithError } = messageFunctions;
+  let csnUtils = getUtils(csn);
 
-  const csnUtils = getUtils(csn);
-  const {
-      getCsnDef,
-      getFinalTypeDef,
-      isStructured,
-      isAssocOrComposition,
-    } = getUtils(csn);
+  // proxies are merged into the final model after all proxy elements are collected
+  const proxyCache = [];
+  // iterarte only over those definitions that need to be preprocessed
+  // instead of mangling through the whole model each time
+  // preprocess steps removing adding to the model must co-modify this map
+  const reqDefs = { definitions: Object.create(null) };
 
 
   // make sure options are complete
   let options = validateOptions(_options);
 
-  // Fetch service definitions
-  const serviceRoots = Object.keys(csn.definitions || {}).reduce((serviceRoots, artName) => {
-    const art = csn.definitions[artName];
-    if(art.kind === 'service') {
-      serviceRoots[artName] = Object.assign(art, { name: artName });
-    }
-    return serviceRoots;
-  }, Object.create(null) );
+  const [ serviceRoots,
+    serviceRootNames,
+    fallBackSchemaName,
+    whatsMyServiceRootName ] = getAnOverviewOnTheServices(csn);
+
+  if(requestedServiceNames === undefined)
+    requestedServiceNames = options.serviceNames;
+  if(requestedServiceNames === undefined) {
+    requestedServiceNames = serviceRootNames;
+  }
 
-  // first of all we need to know about all 'real' user defined services
-  const serviceRootNames = Object.keys(serviceRoots).sort((a,b)=>b.length-a.length);
-  function whatsMyServiceRootName(n, self=true) {
-    return serviceRootNames.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') || (n === sn && self) ? sn : rc, undefined);
+  function isMyServiceRequested(n) {
+    return requestedServiceNames.includes(whatsMyServiceRootName(n));
   }
+
   if(serviceRootNames.length === 0) {
-    return [serviceRoots, Object.create(null), whatsMyServiceRootName, options];
+    return [serviceRoots, Object.create(null), reqDefs, whatsMyServiceRootName, fallBackSchemaName, options];
   }
 
   // Structural CSN inbound QA checks
   inboundQualificationChecks();
+  // not needed at the moment
+  // resolveForeignKeyRefs();
 
   if(isBetaEnabled(options, undefined)) {
     splitDottedDefinitionsIntoSeparateServices();
@@ -85,10 +84,13 @@ function initializeModel(csn, _options, messageFunctions)
     renameDottedDefinitionsInsideServiceOrContext();
 
   /*
-    In order to cover the scenario when the renderer is called with option V2 directly, there is
-    the need to expand to final base type when the CSN was already transformed, bur for V4.
-    The logic will run also when the CSN was persisted on a file system and the non-enumerable
-    properties are lost. Also, will be execute when called with cdsc.
+    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 
+       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)
+    3) call via cdsc
+
     At the end of the day, this module must be called only here, in the renderer and removed
     as a step in the OData transformer with the goal to have a protocol agnostic OData CSN.
   */
@@ -96,20 +98,18 @@ function initializeModel(csn, _options, messageFunctions)
     const { toFinalBaseType }= require('../transform/transformUtilsNew').getTransformers(csn, options);
     expandCSNToFinalBaseType(csn, { toFinalBaseType }, csnUtils, serviceRootNames, options);
   }
+
   /*
-    Enrich the CSN by de-anonymizing and exposing of required types that are defined outside services.
+    Enrich the CSN by de-anonymizing and exposing types that are required to make the service self contained.
     Type exposure will add additional schema contexts and group the exposed types in these contexts.
     contexts either represent another service (if the type to be exposed resides in that
     service), the namespace (including (sub-)contexts) or as last resort (if the type name
      has no prefix path) a 'root' namespace.
   */
-  const schemas = typesExposure(csn, whatsMyServiceRootName, options, csnUtils, { error });
-
-  // First attach names to all definitions (and actions/params) in the model
-  // elements are done in initializeStruct
-  forEachDefinition(csn, attachNameProperty);
+  const schemas = typesExposure(csn, whatsMyServiceRootName, requestedServiceNames,
+    fallBackSchemaName, options, csnUtils, { error });
 
-  // next, we must get an overview about all schemas (including the services)
+  // Get an overview about all schemas (including the services)
   const schemaNames = [...serviceRootNames];
   schemaNames.push(...Object.keys(schemas));
   // sort schemas in reverse order to allow longest match in whatsMySchemaName function
@@ -119,50 +119,99 @@ function initializeModel(csn, _options, messageFunctions)
   }
 
   if(schemaNames.length) {
-    Object.values(serviceRoots).forEach(initializeService);
+    // 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
+    // First attach names to all definitions in the model and fill reqDefs
     // Link association targets and spray @odata.contained over untagged compositions
-    forEachDefinition(csn, [ (def, defName) => {
-      const mySchemaName = whatsMySchemaName(defName);
-      mySchemaName && setProp(def, '$mySchemaName', mySchemaName) }, linkAssociationTarget ]);
+    forEachDefinition(csn, [
+      attachNameProperty,
+      (def, defName) => {
+        const mySchemaName = whatsMySchemaName(defName);
+        mySchemaName && setProp(def, '$mySchemaName', mySchemaName);
+        if(isMyServiceRequested(defName))
+          reqDefs.definitions[defName] = def;
+      },
+      linkAssociationTarget ]);
+    // initialize requested services
+    const skip = { skipArtifact: (_def, defName) => !isMyServiceRequested(defName) };
+    forEachDefinition({ definitions: serviceRoots }, initService, skip);
     // Create data structures for containments
-    forEachDefinition(csn, initializeContainments);
+    forEachDefinition(reqDefs, initContainments);
     // Initialize entities with parameters (add Parameter entity)
-    forEachDefinition(csn, initializeParameterizedEntityOrView);
+    forEachDefinition(reqDefs, initParameterizedEntityOrView);
     // Initialize structures
-    forEachDefinition(csn, initializeStructure);
+    forEachDefinition(csn, initStructure);
     // Initialize associations after _parent linking
-    forEachDefinition(csn, prepareConstraints);
+    forEachDefinition(reqDefs, initConstraints);
     // Mute V4 elements depending on constraint preparation
     if(options.isV4())
-      forEachDefinition(csn, ignoreProperties);
+      forEachDefinition(reqDefs, ignoreProperties);
     // calculate constraints based on ignoreProperties and prepareConstraints
-    forEachDefinition(csn, finalizeConstraints);
+    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
     // Decide if an entity set needs to be constructed or not
-    forEachDefinition(csn, [ exposeTargetsAsProxiesOrSchemaRefs, determineEntitySet ]);
+    forEachDefinition(reqDefs, [ exposeTargetsAsProxiesOrSchemaRefs, determineEntitySet ]);
+    // finalize proxy creation
+    mergeProxiesIntoModel();
+
     if(options.isV4())
-      forEachDefinition(csn, initializeEdmNavPropBindingTargets);
+      forEachDefinition(reqDefs, initEdmNavPropBindingTargets);
 
     // Things that can be done in one pass
     // Create edmKeyRefPaths
     // Create NavigationPropertyBindings, requires determineEntitySet
     // Map /** doc comments */ to @CoreDescription
-    // Artifact identifier spec compliance check (should be run last)
-    forEachDefinition(csn, [ initializeEdmKeyRefPaths, initializeEdmNavPropBindingPaths,
-      initializeEdmTypesAndDescription, checkArtifactIdentifierAndBoundActions ]);
+    forEachDefinition(reqDefs, [
+      initEdmKeyRefPaths,
+      initEdmNavPropBindingPaths,
+      initEdmTypesAndDescription
+    ]);
   }
-  return [serviceRoots, schemas, whatsMyServiceRootName, options];
+  return [serviceRoots, schemas, reqDefs, whatsMyServiceRootName, fallBackSchemaName, options];
 
   //////////////////////////////////////////////////////////////////////
   //
   // Service initialization starts here
   //
 
+  function getAnOverviewOnTheServices(csn) {
+    const defs = csn.definitions || {};
+    const serviceRoots = Object.create(null);
+    for(const defName in defs) {
+      const def = defs[defName];
+      if(def && def.kind === 'service')
+        serviceRoots[defName] = Object.assign(def, { name: defName });
+    }
+
+    // first of all we need to know about all 'real' user defined services
+    const serviceRootNames = Object.keys(serviceRoots).sort((a,b)=>b.length-a.length);
+
+    function whatsMyServiceRootName(n, self=true) {
+      return serviceRootNames.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') || (n === sn && self) ? sn : rc, undefined);
+    }
+
+    // find a globally unambiguous schema name to collect all top level 'root' types
+    // TODO: work on service basis (this requires post exposure renaming)
+    let fallBackSchemaName = 'root';
+    let i = 1;
+    while (Object.keys(defs).some(artName => {
+      const p = artName.split('.');
+      return p.length === 2 && p[0] === fallBackSchemaName;
+    })) {
+      fallBackSchemaName = 'root' + i++;
+    }
+
+    return [
+      serviceRoots,
+      serviceRootNames,
+      fallBackSchemaName,
+      whatsMyServiceRootName ];
+  }
+
   /*
     Replace dots in sub-service and sub-context definitions with underscores to be
     Odata ID compliant.
@@ -174,9 +223,10 @@ function initializeModel(csn, _options, messageFunctions)
     // Find the first definition above the current definition or undefined otherwise.
     // Definition can either be a context or a service
     function getRootDef(name) {
+      const scopeKinds = {'service':1, 'context':1};
       let pos = name.lastIndexOf('.');
       name = pos < 0 ? undefined : name.substring(0, pos);
-      while (name && !['service', 'context'].includes(csn.definitions[name] && csn.definitions[name].kind)) {
+      while (name && !((csn.definitions[name] && csn.definitions[name].kind) in scopeKinds)) {
         pos = name.lastIndexOf('.');
         name = pos < 0 ? undefined : name.substring(0, pos);
       }
@@ -185,17 +235,18 @@ function initializeModel(csn, _options, messageFunctions)
 
     const dotEntityNameMap = Object.create(null);
     const dotTypeNameMap = Object.create(null);
+    const kinds = {'entity':1, 'type':1, 'action':1, 'function':1};
     forEachDefinition(csn, (def, defName) => {
-      if(['entity', 'view', 'type', 'action', 'function'].includes(def.kind)) {
+      if(def.kind in kinds) {
         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)) {
           let newDefName = rootDef + '.' + defName.replace(rootDef + '.', '').replace(/\./g, '_');
           // store renamed types in correlation maps for later renaming
-          if(['entity', 'view'].includes(def.kind))
+          if(def.kind === 'entity')
             dotEntityNameMap[defName] = newDefName;
-          if(['type'].includes(def.kind))
+          if(def.kind === 'type')
             dotTypeNameMap[defName] = newDefName;
           // rename in csn.definitions
           const art = csn.definitions[newDefName];
@@ -252,7 +303,7 @@ function initializeModel(csn, _options, messageFunctions)
   */
   function splitDottedDefinitionsIntoSeparateServices() {
     forEachDefinition(csn, (def, defName) => {
-      if(![ 'service' ].includes(def.kind)) {
+      if(def.kind !== 'service') {
         const myServiceRoot = whatsMyServiceRootName(defName);
         const mySchemaPrefix = getSchemaPrefix(defName);
         if(myServiceRoot && options.isV4() &&
@@ -283,18 +334,8 @@ function initializeModel(csn, _options, messageFunctions)
   }
 
   // initialize the service itself
-  function initializeService(service) {
-    // check service name
-    if (service.name.length > 511) {
-      error(null, ['definitions', service.name], 'OData namespace must not exceed 511 characters' );
-    }
-    const simpleIdentifiers = service.name.split('.');
-    simpleIdentifiers.forEach((identifier) => {
-      if (!isODataSimpleIdentifier(identifier)) {
-        signalIllegalIdentifier(identifier, ['definitions', service.name]);
-      }
-    });
-    setSAPSpecificV2AnnotationsToEntityContainer(options, service);
+  function initService(serviceRoot) {
+    setSAPSpecificV2AnnotationsToEntityContainer(options, serviceRoot);
   }
 
   // link association target to association and add @odata.contained to compositions in V4
@@ -341,8 +382,8 @@ function initializeModel(csn, _options, messageFunctions)
   //   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.
-  function initializeContainments(container) {
-    if(['entity', 'view'].includes(container.kind)) {
+  function initContainments(container) {
+    if(container.kind === 'entity') {
       forEachMemberRecursively(container, initContainments,
         [], true, { elementsOnly: true });
     }
@@ -404,7 +445,7 @@ function initializeModel(csn, _options, messageFunctions)
   // must be called.
   // As a param entity is a potential proxy candidate, this split must be performed on
   // all definitions
-  function initializeParameterizedEntityOrView(entityCsn, entityName) {
+  function initParameterizedEntityOrView(entityCsn, entityName) {
 
     if(!isParameterizedEntity(entityCsn))
       return;
@@ -421,13 +462,71 @@ function initializeModel(csn, _options, messageFunctions)
     //             Backlink Navigation Property "Parameters" to <ViewName>Parameters
 
     // this code can be extended for aggregated views
-    const parameterEntityName = entityName + 'Parameters';
-    const originalEntityName = entityName + 'Type';
-    const originalEntitySetName = entityName + 'Set';
-    const parameterToOriginalAssocName = 'Set';
-    const backlinkAssocName = 'Parameters';
+    const typeEntityName = entityName + 'Type';
+    const typeEntitySetName = entityName + 'Set';
+    const parameterToTypeAssocName = 'Set';
+    const typeToParameterAssocName = 'Parameters';
     let hasBacklink = true;
 
+
+    // create the Parameter Definition
+    const parameterCsn = createParameterEntity(entityCsn, entityName, false);
+
+    // create the Type Definition
+    // modify the original parameter entity with backlink and new name
+    if(csn.definitions[typeEntityName])
+      error('odata-definition-exists', [ 'definitions', entityName ], {  '#': 'std', name: typeEntityName });
+    else {
+      csn.definitions[typeEntityName] = entityCsn;
+      reqDefs.definitions[typeEntityName] = entityCsn;
+      delete csn.definitions[entityCsn.name];
+      delete reqDefs.definitions[entityCsn.name];
+      entityCsn.name = typeEntityName;
+    }
+    setProp(entityCsn, '$entitySetName', typeEntitySetName);
+    // add backlink association
+    if(hasBacklink) {
+      entityCsn.elements[typeToParameterAssocName] = {
+        name: typeToParameterAssocName,
+        target: parameterCsn.name,
+        type: 'cds.Association',
+        on: [ { ref: [ 'Parameters', 'Set' ] }, '=', { ref: [ '$self' ] } ]
+      };
+      setProp(entityCsn.elements[typeToParameterAssocName], '_selfReferences', []);
+      setProp(entityCsn.elements[typeToParameterAssocName], '_target', parameterCsn);
+      setProp(entityCsn.elements[typeToParameterAssocName], '$path',
+        [ 'definitions', typeEntityName, 'elements', typeToParameterAssocName ] );
+
+      // rewrite $path
+      if(entityCsn.$path)
+        entityCsn.$path[1] = typeEntityName;
+      forEachMemberRecursively(entityCsn, (member) => {
+        if(member.$path)
+          member.$path[1] = typeEntityName;
+      });
+    }
+
+/*
+  <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',
+      {'@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.addressable': false });
+
+    // redirect inbound associations/compositions to the parameter entity
+    Object.keys(entityCsn.$sources || {}).forEach(n => {
+      // preserve the original target for constraint calculation
+      setProp(entityCsn.$sources[n], '_originalTarget', entityCsn.$sources[n]._target);
+      entityCsn.$sources[n]._target = parameterCsn;
+      entityCsn.$sources[n].target = parameterCsn.name;
+    });
+    rewriteContainmentAnnotations(parameterCsn, entityCsn, parameterToTypeAssocName);
+  }
+
+  function createParameterEntity(entityCsn, entityName, isProxy) {
+    const parameterEntityName = entityName + 'Parameters';
+    const parameterToTypeAssocName = 'Set';
+
     // Construct the parameter entity
     const parameterCsn = {
       name: parameterEntityName,
@@ -435,8 +534,8 @@ function initializeModel(csn, _options, messageFunctions)
       elements: Object.create(null),
       '@sap.semantics': 'parameters',
     };
-    setProp(parameterCsn, '$entitySetName', entityName);
-
+    if(!isProxy)
+      setProp(parameterCsn, '$entitySetName', entityName);
     if(entityCsn.$location){
       assignProp(parameterCsn, '$location', entityCsn.$location);
     }
@@ -462,88 +561,54 @@ function initializeModel(csn, _options, messageFunctions)
     entityCsn._containerEntity = [ parameterCsn ];
 
     forEachGeneric(entityCsn, 'params', (p,n) => {
-      let elt = cloneCsn(p, options);
+      let elt = cloneCsnNonDict(p, options);
       elt.name = n;
       delete elt.kind;
+      setProp(elt, '$path', [ 'definitions', parameterEntityName, 'elements', n ]);
       elt.key = true; // params become primary key in parameter entity
+      /*
+        Spec meeting decision 28.02.22:
+        Annotation @sap.parameter allows two values "mandatory"/"optional".
+        Question was how to deal with incompatible "optional".
+        Only "mandatory" is allowed because in RAP all parameters are NOT NULL
+        and so they are in CAP (all view parameters become primary keys which are not null).
+      */
+      if(options.isV2())
+        assignAnnotation(elt, '@sap.parameter', 'mandatory');
+      else
+        assignAnnotation(elt, '@Common.FieldControl', { '#': 'Mandatory' });
       parameterCsn.elements[n] = elt;
     });
     linkAssociationTarget(parameterCsn);
-    initializeContainments(parameterCsn);
-    // add assoc to result set, FIXME: is the cardinality correct?
-    parameterCsn.elements[parameterToOriginalAssocName] = {
-      '@odata.contained': true,
-      name: parameterToOriginalAssocName,
-      target: entityCsn.name,
-      type: 'cds.Association',
-      cardinality: { src: 1, min: 0, max: '*' }
-    };
-    setProp(parameterCsn.elements[parameterToOriginalAssocName], '_target', entityCsn);
-    setProp(parameterCsn.elements[parameterToOriginalAssocName], '$path',
-      [ 'definitions', parameterEntityName, 'elements', parameterToOriginalAssocName ] );
-
-      // rewrite $path
-    setProp(parameterCsn, '$path', [ 'definitions', parameterEntityName ]);
-    forEachMemberRecursively(parameterCsn, (member) => {
-      if(member.$path)
-        member.$path[1] = parameterEntityName;
-    });
-
-    if(csn.definitions[parameterCsn.name])
-      error('odata-definition-exists', [ 'definitions', entityName ], { '#': 'std', name: parameterCsn.name });
-    else
-      csn.definitions[parameterCsn.name] = parameterCsn;
-    // modify the original parameter entity with backlink and new name
-    if(csn.definitions[originalEntityName])
-      error('odata-definition-exists', [ 'definitions', entityName ], {  '#': 'std', name: originalEntityName });
-    else {
-      csn.definitions[originalEntityName] = entityCsn;
-      delete csn.definitions[entityCsn.name];
-      entityCsn.name = originalEntityName;
-    }
-    setProp(entityCsn, '$entitySetName', originalEntitySetName);
-    // add backlink association
-    if(hasBacklink) {
-      entityCsn.elements[backlinkAssocName] = {
-        name: backlinkAssocName,
-        target: parameterCsn.name,
+    initContainments(parameterCsn);
+      // add assoc to result set, FIXME: is the cardinality correct?
+    if(!isProxy) {
+      parameterCsn.elements[parameterToTypeAssocName] = {
+        '@odata.contained': true,
+        name: parameterToTypeAssocName,
+        target: entityCsn.name,
         type: 'cds.Association',
-        on: [ { ref: [ 'Parameters', 'Set' ] }, '=', { ref: [ '$self' ] } ]
+        cardinality: { src: 1, min: 0, max: '*' }
       };
-      setProp(entityCsn.elements[backlinkAssocName], '_selfReferences', []);
-      setProp(entityCsn.elements[backlinkAssocName], '_target', parameterCsn);
-      setProp(entityCsn.elements[backlinkAssocName], '$path',
-        [ 'definitions', originalEntityName, 'elements', backlinkAssocName ] );
-
-      // rewrite $path
-      if(entityCsn.$path)
-        entityCsn.$path[1] = originalEntityName;
-      forEachMemberRecursively(entityCsn, (member) => {
-        if(member.$path)
-          member.$path[1] = originalEntityName;
-      });
+      setProp(parameterCsn.elements[parameterToTypeAssocName], '_target', entityCsn);
+      setProp(parameterCsn.elements[parameterToTypeAssocName], '$path',
+        [ 'definitions', parameterEntityName, 'elements', parameterToTypeAssocName ] );
     }
+        // rewrite $path
+    setProp(parameterCsn, '$path', [ 'definitions', parameterEntityName ]);
 
-/*
-  <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',
-      {'@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.addressable': false });
-
-
-
-    // redirect inbound associations/compositions to the parameter entity
-    Object.keys(entityCsn.$sources || {}).forEach(n => {
-      // preserve the original target for constraint calculation
-      setProp(entityCsn.$sources[n], '_originalTarget', entityCsn.$sources[n]._target);
-      entityCsn.$sources[n]._target = parameterCsn;
-      entityCsn.$sources[n].target = parameterCsn.name;
-    });
-    rewriteContainmentAnnotations(parameterCsn, entityCsn, parameterToOriginalAssocName);
+    // proxies are registered in model separately
+    if(!isProxy) {
+      if(csn.definitions[parameterCsn.name])
+        error('odata-definition-exists', [ 'definitions', entityName ], { '#': 'std', name: parameterCsn.name });
+      else {
+        csn.definitions[parameterCsn.name] = parameterCsn;
+        reqDefs.definitions[parameterCsn.name] = parameterCsn;
+      }
+    }
+    return parameterCsn;
   }
 
-
   function initElement(element, name, struct) {
     setProp(element, 'name', name)
     setProp(element, '_parent', struct);
@@ -569,7 +634,7 @@ function initializeModel(csn, _options, messageFunctions)
   }
 
   // Initialize a structured artifact
-  function initializeStructure(def) {
+  function initStructure(def) {
 
     // Don't operate on any structured types other than type and entity
     // such as events and aspects
@@ -580,24 +645,13 @@ function initializeModel(csn, _options, messageFunctions)
     let validFrom = [], validKey = [];
 
     // Iterate all struct elements
-    forEachMemberRecursively(def.items || def, (element, elementName, prop, path = [], construct) => {
-      if(!['elements'].includes(prop))
+    forEachMemberRecursively(def.items || def, (element, elementName, prop, _path = [], construct) => {
+      if(prop !== 'elements')
         return;
 
       initElement(element, elementName, construct);
 
-      if(!['event', 'aspect'].includes(def.kind)) {
-        if(element._parent && element._parent.$mySchemaName) {
-          if(!isODataSimpleIdentifier(elementName)) {
-            signalIllegalIdentifier(elementName, ['definitions', def.name].concat(path));
-          } else if (options.isV2() && /^(_|[0-9])/.test(elementName) && ['view', 'entity'].includes(element._parent.kind)) {
-            // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
-            error(null, ['definitions', def.name, 'elements', elementName], { prop: elementName[0] },
-            'Element names must not start with $(PROP) for OData V2');
-          }
-        }
-      }
-        // collect temporal information
+      // collect temporal information
       if(element['@cds.valid.key']) {
         validKey.push(element);
       }
@@ -677,18 +731,19 @@ function initializeModel(csn, _options, messageFunctions)
   }
 
   // Prepare the associations for the subsequent steps
-  function prepareConstraints(struct) {
-    if(!isStructuredArtifact(struct))
+  function initConstraints(def) {
+    if(!isStructuredArtifact(def))
       return;
 
-    forEachMemberRecursively(struct.items || struct, (element) => {
-      if (isAssociationOrComposition(element) && !element._ignore) {
+    forEachMemberRecursively(def.items || def, initConstraintsOnAssoc, [], true, { elementsOnly: true });
+  }
+  function initConstraintsOnAssoc(element) {
+    if (isAssociationOrComposition(element) && !element._ignore && !element._constraints) {
         // setup the constraints object
-        setProp(element, '_constraints', { constraints: Object.create(null), selfs: [], _origins: [], termCount: 0 });
+      setProp(element, '_constraints', { constraints: Object.create(null), selfs: [], _origins: [], termCount: 0 });
         // and crack the ON condition
-        resolveOnConditionAndPrepareConstraints(csn, element, messageFunctions);
-      }
-    }, [], true, { elementsOnly: true });
+      resolveOnConditionAndPrepareConstraints(csn, element, messageFunctions);
+    }
   }
 
   /*
@@ -760,38 +815,39 @@ function initializeModel(csn, _options, messageFunctions)
     It may be that now a number of properties are not rendered and cannot act as constraints (see isConstraintCandidate())
     in edmUtils
   */
-  function finalizeConstraints(struct) {
-    if(!isStructuredArtifact(struct))
+  function finalizeConstraints(def) {
+    if(!isStructuredArtifact(def))
       return;
 
-    forEachMemberRecursively(struct.items || struct, (element) => {
-      if (isAssociationOrComposition(element) && !element._ignore) {
-        finalizeReferentialConstraints(csn, element, options, info);
+    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._constraints._partnerCsn && element.cardinality && element.cardinality.max) {
+      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
-          if(element._constraints._partnerCsn.cardinality) {
+        if(element._constraints._partnerCsn.cardinality) {
             // if the forward association has set a src cardinality and it deviates from the backlink target cardinality raise a warning
             // in V2 only, in V4 the source cardinality is rendered implicitly at the Type property
-            if(element._constraints._partnerCsn.cardinality.src) {
-              let srcMult = (element._constraints._partnerCsn.cardinality.src == 1) ? '0..1' : '*';
-              let newMult = (element.cardinality.max > 1) ? '*' : '0..1';
-              if(options.isV2() && srcMult !== newMult) {
+          if(element._constraints._partnerCsn.cardinality.src) {
+            let srcMult = (element._constraints._partnerCsn.cardinality.src == 1) ? '0..1' : '*';
+            let newMult = (element.cardinality.max > 1) ? '*' : '0..1';
+            if(options.isV2() && srcMult !== newMult) {
                 // Association 'E_toF': Multiplicity of Role='E' defined to '*', conflicting with target multiplicity '0..1' from
-                warning(null, null, `Source cardinality "${element._constraints._partnerCsn.cardinality.src}" of "${element._constraints._partnerCsn._parent.name}/${element._constraints._partnerCsn.name}" conflicts with target cardinality "${element.cardinality.max}" of association "${element._parent.name}/${element.name}"`);
-              }
-            }
-            else {
-              // .. but only if the original assoc hasn't set src yet
-              element._constraints._partnerCsn.cardinality.src = element.cardinality.max;
+              warning(null, null, `Source cardinality "${element._constraints._partnerCsn.cardinality.src}" of "${element._constraints._partnerCsn._parent.name}/${element._constraints._partnerCsn.name}" conflicts with target cardinality "${element.cardinality.max}" of association "${element._parent.name}/${element.name}"`);
             }
           }
           else {
-            element._constraints._partnerCsn.cardinality = { src: element.cardinality.max };
+              // .. but only if the original assoc hasn't set src yet
+            element._constraints._partnerCsn.cardinality.src = element.cardinality.max;
           }
         }
+        else {
+          element._constraints._partnerCsn.cardinality = { src: element.cardinality.max };
+        }
       }
-    }, [], true, { elementsOnly: true });
+    }
   }
 
   /*
@@ -807,8 +863,10 @@ function initializeModel(csn, _options, messageFunctions)
             if(serviceRootNames.includes(targetSchemaName)) {
             // remove all definitions starting with < fqSchemaName >. and add a schema reference
               Object.keys(csn.definitions).forEach(dn => {
-                if(dn.startsWith(fqSchemaName)) // this includes the fqSchemaName context
+                if(dn.startsWith(fqSchemaName)) {// this includes the fqSchemaName context
                   delete csn.definitions[dn];
+                  delete reqDefs.definitions[dn];
+                }
               });
               if(!schemas[fqSchemaName])
                 schemaNames.push(fqSchemaName);
@@ -839,13 +897,12 @@ function initializeModel(csn, _options, messageFunctions)
 
       If option odataExtReferences is used, 'root' proxies are still created.
 
-      If an entity type which is a proxy candidate has a managed association as primary key,
-      all dependent entity types are exposed (or referenced) as well to keep the navigation
-      graph in tact. This effectively will expose the transitive primary key closure of all
-      proxies.
+      If the association leading to the proxy candidate refers to associations either directly
+      or indirectly (via structured elements), these dependent entity types are (recursively) exposed
+      (or referenced) as well to keep the navigation graph in tact.
   */
   function exposeTargetsAsProxiesOrSchemaRefs(struct) {
-    if([ 'context', 'service' ].includes(struct.kind) || struct.$proxy)
+    if(struct.kind === 'context' || struct.kind === 'service' || struct.$proxy)
       return;
 
     // globalSchemaPrefix is the prefix for all proxy registrations and must not change
@@ -880,6 +937,7 @@ function initializeModel(csn, _options, messageFunctions)
         // If the target is in another schema, check if both the source and the target share the same service name.
         // If they share the same service name, then it is just a cross schema navigation within the same EDM, no
         // proxy required.
+        // association must be managed and not unmanaged
 
         // odataProxies (P) and odataXServiceRefs (X) are evalutated as follows:
         // P | X | Action
@@ -890,12 +948,17 @@ function initializeModel(csn, _options, messageFunctions)
 
         const targetSchemaName = element._target.$mySchemaName;
         if(isProxyRequired(element)) {
-          if(options.isV4() && (options.toOdata.odataProxies || options.toOdata.odataXServiceRefs)) {
+          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)
+            ) {
             // reuse proxy if available
             let proxy = getProxyForTargetOf(element);
             if(!proxy) {
               if(targetSchemaName && options.toOdata.odataXServiceRefs) {
-                proxy = createSchemaRefFor(element, targetSchemaName);
+                proxy = createSchemaRefFor(targetSchemaName);
               }
               else if(options.toOdata.odataProxies) {
                 proxy = createProxyFor(element, targetSchemaName);
@@ -906,13 +969,16 @@ function initializeModel(csn, _options, messageFunctions)
             // 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
             // otherwise proxy is a schema reference, then do nothing
+              setProp(element, '$noPartner', true);
               element._constraints.constraints = Object.create(null);
               if(proxy.kind === 'entity') {
+                if(!proxy.$isParamEntity)
+                  populateProxyElements(element, proxy, getForeignKeyDefinitions(element));
                 element._target = proxy;
               }
               else {
-                // fake the target to be proxy
-                setProp(element._target, '$externalRef', true);
+                // No navigation property bindings on external references
+                setProp(element, '$externalRef', true);
               }
             }
             else {
@@ -932,11 +998,11 @@ function initializeModel(csn, _options, messageFunctions)
     }
 
     function noNavPropMsg(elt) {
-      warning(null, ['definitions', struct.name, 'elements', elt.name],
-            { target: elt._target.name }, 'No OData navigation property generated, target $(TARGET) is outside any service');
+      warning('odata-navigation', ['definitions', struct.name, 'elements', elt.name],
+            { target: elt._target.name, service: globalSchemaPrefix });
     }
 
-    function createSchemaRefFor(assoc, targetSchemaName) {
+    function createSchemaRefFor(targetSchemaName) {
       let ref = csn.definitions[globalSchemaPrefix + '.' + targetSchemaName];
       if(!ref) {
         ref = createSchemaRef(targetSchemaName);
@@ -951,13 +1017,25 @@ function initializeModel(csn, _options, messageFunctions)
       // if it is required in multiple services. The service schema name is prepended upon registration
       const proxySchemaName = targetSchemaName || getSchemaPrefix(assoc._target.name);
 
-        // 1) construct the proxy definition
-        // proxyShortName: strip the serviceName and replace '.' with '_'
-      const proxyShortName = assoc._target.name.replace(proxySchemaName + '.', '').replace(/\./g, '_');
-        // fullName: Prepend serviceName and if in same service add '_proxy'
-      const fullName = proxySchemaName + '.' + proxyShortName;
-      const proxy = { name: fullName, kind: 'entity', $proxy: true, elements: Object.create(null) };
+      // if the target is a parameter entity, it's easy just create the parameter stub
+      const isParamProxy = 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)
+        : { name: proxySchemaName + '.' + defName, kind: 'entity', elements: Object.create(null) };
+
+      // Final proxyShortName for all further processing
+      const proxyShortName = defName + (isParamProxy ? 'Parameters' : '');
+
+      setProp(proxy, '$proxy', true);
       setProp(proxy, '$mySchemaName', proxySchemaName);
+      setProp(proxy, '$proxyShortName', proxyShortName);
       setProp(proxy, '$keys', Object.create(null));
       setProp(proxy, '$hasEntitySet', false);
       setProp(proxy, '$exposedTypes', Object.create(null));
@@ -968,21 +1046,33 @@ function initializeModel(csn, _options, messageFunctions)
       });
 
       // 2) create the elements and $keys
-      populateProxyElements(proxy, assoc._target.$keys);
-      // 3) sort the exposed types so that they appear lexicographically ordered in the EDM
-      proxy.$exposedTypes = Object.keys(proxy.$exposedTypes).sort().reduce((dict, tn) => {
-        dict[tn] = proxy.$exposedTypes[tn];
-        return dict
-      }, Object.create(null));
-
+      if(isParamProxy) {
+        // Reset param proxy elements to expose element tree
+        const elements = proxy.elements;
+        proxy.elements = Object.create(null);
+        populateProxyElements(assoc, proxy, elements);
+      }
+      else
+        populateProxyElements(assoc, proxy, assoc._target.$keys);
       return proxy;
 
-      // copy over the primary keys of the target and trigger the type exposure
-      function populateProxyElements(proxy, keys) {
-        forAll(keys, e => {
-          if (isEdmPropertyRendered(e, options)) {
-            let newElt = undefined;
-            if(isAssocOrComposition(e.type)) {
+    }
+
+    // Return top level foreign key element definitions. The full top level
+    // element is exposed instead of merging partial trees into the exposed type
+    // def structure.
+    function getForeignKeyDefinitions(e) {
+      return e.keys ? e.keys.map(fk => e._target.elements[fk.ref[0]]) : [];
+    }
+
+    // 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 => {
+        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)
                   newElt = convertManagedAssocIntoStruct(e);
@@ -991,105 +1081,126 @@ function initializeModel(csn, _options, messageFunctions)
               }
               else {
                 info(null, ['definitions', struct.name, 'elements', assoc.name],
-                { name: fullName, target: assoc._target.name },
+                { name: proxy.nname, target: assoc._target.name },
                 'Unmanaged associations are not supported as primary keys for proxy entity type $(NAME) of unexposed association target $(TARGET)');
               }
             }
             else {
-              newElt = cloneCsn(e, options);
+              newElt = Object.create(null);
+              Object.keys(e).forEach(prop => newElt[prop] = e[prop])
             }
             if(newElt) {
               initElement(newElt, e.name, proxy);
-              if(isStructured(newElt)) {
+              proxy.elements[newElt.name] = newElt;
+
+              if(csnUtils.isStructured(newElt)) {
                 // argument proxySchemaName forces an anonymous type definition for newElt into the
-                // proxy schema. If omitted, this exposure defaults to 'root', in case API flavor of the day
-                // changes...
-                exposeStructTypeForProxyOf(proxy, newElt, proxyShortName + '_' + newElt.name, proxySchemaName);
-              // elements of newElt are required for key ref paths
+                // proxy schema. If omitted, this exposure defaults to 'root', in case API flavor
+                // of the day changes...
+                exposeStructTypeForProxyOf(proxy, newElt, proxy.$proxyShortName + '_' + newElt.name,
+                                          proxy.$mySchemaName, newElt.key, !!(newElt.key && newElt.elements));
               }
-              // all elements must become primary key
-              proxy.$keys[e.name] = proxy.elements[newElt.name] = newElt;
+              if(newElt.key)
+                proxy.$keys[newElt.name] = newElt;
             }
           }
-        });
-      }
+        }
+
+      });
+      // 3) sort the exposed types so that they appear lexicographically ordered in the EDM
+      proxy.$exposedTypes = Object.keys(proxy.$exposedTypes).sort().reduce((dict, tn) => {
+        dict[tn] = proxy.$exposedTypes[tn];
+        return dict
+      }, Object.create(null));
 
       // If 'node' exists and has a structured type that is not exposed in 'service', (because the type is
       // anonymous or has a definition outside of 'service'), create an equivalent type in 'service', either
       // using the type's name or (if anonymous) 'artificialName', and make 'node' use that type instead.
       // Complain if there is an error.
-      function exposeStructTypeForProxyOf(proxy, node, artificialName, typeSchemaName='root') {
-        const isNotInProtNS = node.type ? !isBuiltinType(node.type) : true;
-        // Always expose types referred to by a proxy, never reuse an eventually exisiting type
+      // isKey: Indicates top level element is key or not
+      // forceToNotNull: if top level element is key, recursively set all anonymously exposed elements
+      // to notNull until the first named type is exposed.
+      function exposeStructTypeForProxyOf(proxy, node, artificialName,
+                                          typeSchemaName=fallBackSchemaName,
+                                          isKey, forceToNotNull) {
+
+        if(node.type && isBuiltinType(node.type))
+          return;
+
+        // Always expose types referred to by a proxy, never reuse an eventually existing type
         // as the nested elements must all be not nullable
-        if (isNotInProtNS) {
-          let typeDef = node.type ? csn.definitions[node.type] : /* anonymous type */ node;
+          // elements have precedence over type
+        const typeDef = !node.elements && node.type ? csn.definitions[node.type] : node;
 
-          if (typeDef) {
-            let typeClone;
+        if (typeDef) {
+          let typeClone;
             // the type clone must be produced for each service as this type may
             // produce references and/or proxies into multiple services
             // (but only once per service, therefore cache it).
-            if(typeDef.$proxyTypes && typeDef.$proxyTypes[globalSchemaPrefix]) {
+          if(typeDef.$proxyTypes && typeDef.$proxyTypes[globalSchemaPrefix]) {
               // if type has been exposed in a schema use this type
-              typeClone = typeDef.$proxyTypes[globalSchemaPrefix];
-            }
-            else {
+            typeClone = typeDef.$proxyTypes[globalSchemaPrefix];
+          }
+          else {
                 // Set the correct name
-              let typeId = artificialName; // the artificialName has no namespace, it's the element
-              if(node.type) {
+            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);
-                typeId = node.type.replace(typeSchemaName + '.', '').replace(/\./g, '_');
+              typeSchemaName = typeDef.$mySchemaName || getSchemaPrefix(node.type);
+              typeId = node.type.replace(typeSchemaName + '.', '').replace(/\./g, '_');
                 // strip the service root of that type (if any)
-                const myServiceRootName = whatsMyServiceRootName(typeSchemaName);
-                if(myServiceRootName)
-                  typeSchemaName = typeSchemaName.replace(myServiceRootName + '.', '');
-              }
+              const myServiceRootName = whatsMyServiceRootName(typeSchemaName);
+              if(myServiceRootName)
+                typeSchemaName = typeSchemaName.replace(myServiceRootName + '.', '');
+            }
 
-              if(isStructuredArtifact(typeDef)) {
-                typeClone = cloneStructTypeForProxy(typeSchemaName, `${typeSchemaName}.${typeId}`, typeDef);
-                if(typeClone) {
+            if(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);
+
+              typeClone = cloneStructTypeForProxy(typeSchemaName, `${typeSchemaName}.${typeId}`, typeDef);
+              if(typeClone) {
                   // Recurse into elements of 'type' (if any)
-                  typeClone.elements && Object.entries(typeClone.elements).forEach( ([elemName, elem]) => {
-                    // if this is a foreign key elment, we must check wether or not the association
+                typeClone.elements && Object.entries(typeClone.elements).forEach(([elemName, elem]) => {
+                    // if this is a foreign key elment, we must check whether or not the association
                     // has been exposed as proxy. If it has not been exposed, no further structured
                     // types must be exposed as 'Proxy_' types.
 
                     // TODO: expose types of assoc.keys and don't rely on exposed foreign keys
-                    if(!elem['@odata.foreignKey4'] ||
+                  if(!elem['@odata.foreignKey4'] ||
                       (elem['@odata.foreignKey4'] && !typeClone.elements[elem['@odata.foreignKey4']].$exposed))
-                      exposeStructTypeForProxyOf(proxy, elem, `${typeId}_${elemName}`, typeSchemaName);
-                  });
-                  if(!typeDef.$proxyTypes)
-                    typeDef.$proxyTypes = Object.create(null);
-                  typeDef.$proxyTypes[globalSchemaPrefix] = typeClone;
-                }
+                    exposeStructTypeForProxyOf(proxy, elem, `${typeId}_${elemName}`,
+                        typeSchemaName, isKey, forceToNotNull);
+                });
+                if(!typeDef.$proxyTypes)
+                  typeDef.$proxyTypes = Object.create(null);
+                typeDef.$proxyTypes[globalSchemaPrefix] = typeClone;
               }
-              else {
+            }
+            else {
                 // FUTURE: expose scalar type definition as well
-              }
             }
-            if(typeClone) {
+          }
+          if(typeClone) {
               // register the type clone at the proxy
               // Reminder: Each proxy receives a full set of type clones, even if the types are shared
               // (no scattered type clone caching). registerProxy() checks if a clone needs to be added to
               // csn.definitions.
-              proxy.$exposedTypes[typeClone.name] = typeClone;
+            proxy.$exposedTypes[typeClone.name] = typeClone;
 
               // set the node's new type name
-              node.type = typeClone.name;
+            node.type = typeClone.name;
               // the key path generator must use the type clone directly, because it can't resolve
               // the type clone in the CSN (its name is the final name and not the definition name).
-              setProp(node, '_type', typeClone);
+            setProp(node, '_type', typeClone);
               // Hack alert:
               // beta feature 'subElemRedirections' (now the default in v2) adds elements to the node by
               // default, without we must do it to get the primary key tuple calculation correct.
               // Remember: node.type is the service local type name (not prepended by the service name),
               // so it can't be resolved in definitions later on
-              if(typeClone.elements)
-                node.elements = typeClone.elements;
-            }
+            if(typeClone.elements)
+              node.elements = typeClone.elements;
           }
         }
 
@@ -1107,11 +1218,13 @@ function initializeModel(csn, _options, messageFunctions)
             if(!elem.target) {
               type.elements[elemName] = Object.create(null);
               Object.keys(elem).forEach(prop => type.elements[elemName][prop] = elem[prop])
-              type.elements[elemName].notNull = true;
             }
-            else {
+            else if(elem.keys && !elem.on) {
+                // a primary key can never be an unmanaged association
               type.elements[elemName] = createProxyOrSchemaRefForManagedAssoc(elem);
             }
+            if(forceToNotNull)
+              type.elements[elemName].notNull = true;
             setProp(type.elements[elemName], 'name', elem.name);
           });
           return type;
@@ -1121,7 +1234,7 @@ function initializeModel(csn, _options, messageFunctions)
       // Convert a managed association into a structured type and
       // eliminate nested foreign key associations
       function convertManagedAssocIntoStruct(e) {
-        let newElt = cloneCsn(e, options);
+        let newElt = cloneCsnNonDict(e, options);
         newElt.elements = Object.create(null);
                 // remove all unwanted garbage
         delete newElt.keys;
@@ -1132,14 +1245,15 @@ function initializeModel(csn, _options, messageFunctions)
         let keys = (!e._target.$isParamEntity && e.keys) ||
           Object.keys(e._target.$keys).map(k => { return { ref: [k] } });
         keys.forEach(k => {
-          let art = e._target || getCsnDef(e.target);
+          let art = e._target || csnUtils.getCsnDef(e.target);
           for(let ps of k.ref) {
             art = art.elements[ps];
           }
           // art is in the target side, clone it and remove key property
-          let cloneArt = cloneCsn(art, options);
+          let cloneArt = cloneCsnNonDict(art, options);
           setProp(cloneArt, 'name', art.name);
-          cloneArt.notNull = true;
+          if(e.key)
+            cloneArt.notNull = true;
           delete cloneArt.key;
           newElt.elements[art.name] = cloneArt;
         });
@@ -1155,17 +1269,19 @@ function initializeModel(csn, _options, messageFunctions)
       function createProxyOrSchemaRefForManagedAssoc(e) {
 
         let proxy = e._target;
-        let newElt = cloneCsn(e, options);
+        let newElt = cloneCsnNonDict(e, options);
 
         if(isProxyRequired(e)) {
           proxy = getProxyForTargetOf(e);
           if(!proxy) {
             // option odataXServiceRefs has precedence over odataProxies
             if(e._target.$mySchemaName && options.toOdata.odataXServiceRefs) {
-              proxy = createSchemaRefFor(e, e._target.$mySchemaName);
+              proxy = createSchemaRefFor(e._target.$mySchemaName);
             }
             else if(options.toOdata.odataProxies) {
               proxy = createProxyFor(e, e._target.$mySchemaName);
+              if(!e._target.$isParamEntity)
+                populateProxyElements(e, proxy, getForeignKeyDefinitions(e));
             }
             proxy = registerProxy(proxy, e);
           }
@@ -1181,7 +1297,10 @@ function initializeModel(csn, _options, messageFunctions)
         setProp(newElt, '$exposed', true);
         // _target must be set with (original) in case
         // a schema ref has been created
+        setProp(newElt, '$noPartner', true);
         setProp(newElt, '_target', e._target);
+        initConstraintsOnAssoc(e);
+        finalizeConstraintsOnAssoc(e);
         setProp(newElt, '_constraints', e._constraints);
         setProp(newElt, '_selfReferences', []);
         if(proxy.kind === 'entity') {
@@ -1229,8 +1348,11 @@ function initializeModel(csn, _options, messageFunctions)
     function registerProxy(proxy, element) {
       if(proxy === undefined)
         return undefined;
-      const fqProxyName = globalSchemaPrefix + '.' + proxy.name;
-      const fqSchemaName = globalSchemaPrefix + '.' + proxy.$mySchemaName;
+
+      setProp(proxy, '$globalSchemaPrefix', globalSchemaPrefix);
+      setProp(proxy, '$origin', element);
+
+      const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
 
       if(!element._target.$cachedProxy)
         assignProp(element._target, '$cachedProxy', Object.create(null));
@@ -1238,8 +1360,19 @@ function initializeModel(csn, _options, messageFunctions)
         info(null, ['definitions', struct.name, 'elements', element.name],
           { name: fqProxyName }, 'Proxy EDM entity type $(NAME) has already been registered');
       }
-      else
+      else {
+        determineEntitySet(proxy);
+        proxyCache.push(proxy);
         element._target.$cachedProxy[globalSchemaPrefix] = proxy;
+      }
+      return proxy;
+    }
+  }
+
+  function mergeProxiesIntoModel() {
+    proxyCache.forEach(proxy => {
+      const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
+      const fqSchemaName = proxy.$globalSchemaPrefix + '.' + proxy.$mySchemaName;
 
       if(proxy.kind === 'entity') {
         // collect all schemas even for newly exposed types
@@ -1251,7 +1384,7 @@ function initializeModel(csn, _options, messageFunctions)
         // 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(globalSchemaPrefix + '.' + getSchemaPrefix(t)));
+          schemaSet.add(proxy.$globalSchemaPrefix + '.' + getSchemaPrefix(t)));
         schemaSet.forEach(schemaName => {
           if(!schemas[schemaName]) {
             schemas[schemaName] = { kind: 'schema', name: schemaName };
@@ -1259,25 +1392,31 @@ function initializeModel(csn, _options, messageFunctions)
           }
         });
         /** @type {object} */
-        const alreadyRegistered = csn.definitions[fqProxyName]
+        const alreadyRegistered = csn.definitions[fqProxyName];
         if(!alreadyRegistered) {
           csn.definitions[fqProxyName] = proxy;
+          reqDefs.definitions[fqProxyName] = proxy;
           setProp(proxy, '$path', ['definitions', fqProxyName]);
           Object.entries(proxy.$exposedTypes).forEach(([tn, v]) => {
-            const fqtn = globalSchemaPrefix + '.' + tn;
+            const fqtn = proxy.$globalSchemaPrefix + '.' + tn;
             if(csn.definitions[fqtn] === undefined) {
               csn.definitions[fqtn] = v;
+              reqDefs.definitions[fqtn] = v;
               setProp(v, '$path', ['definitions', fqtn]);
             }
           });
-          info(null, ['definitions', element._parent.name, 'elements', element.name],
+          // 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];
+          if(proxy.$origin._parent.$path)
+            loc = [...proxy.$origin._parent.$path, 'elements', proxy.$origin.name]
+          info(null, loc,
             { name: proxy.name }, 'Created proxy EDM entity type $(NAME)');
         }
         else if(alreadyRegistered && !alreadyRegistered.$proxy &&
-          !['entity', 'view'].includes(alreadyRegistered.kind)) {
-          warning('odata-definition-exists', ['definitions', element._parent.name, 'elements', element.name],
+          alreadyRegistered.kind !== 'entity') {
+          warning('odata-definition-exists', ['definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name],
             { '#': 'proxy', name: fqProxyName, kind: alreadyRegistered.kind });
-          return undefined;
         }
       }
       else {
@@ -1285,15 +1424,14 @@ function initializeModel(csn, _options, messageFunctions)
         if(!schemas[fqSchemaName]) {
           schemas[fqSchemaName] = proxy;
           schemaNames.push(fqSchemaName);
-          info(null, ['definitions', struct.name, 'elements', element.name],
+          info(null, ['definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name],
             { name: proxy.name }, 'Created EDM namespace reference $(NAME)');
         }
         // don't error on duplicate schemas, if it's already present then all is good....
       }
+    });
       // sort the global schemaNames array
-      schemaNames.sort((a,b) => b.length-a.length);
-      return proxy;
-    }
+    schemaNames.sort((a,b) => b.length-a.length);
   }
 
   /*
@@ -1309,28 +1447,28 @@ function initializeModel(csn, _options, messageFunctions)
         and do not render associations (this will include the foreign keys of
         the _isToContainer association).
   */
-  function initializeEdmKeyRefPaths(struct) {
-    if(struct.$mySchemaName && struct.$keys) {
-      setProp(struct, '$edmKeyPaths', []);
+  function initEdmKeyRefPaths(def) {
+    if(def.$keys) {
+      setProp(def, '$edmKeyPaths', []);
       // for all key elements that shouldn't be ignored produce the paths
-      foreach(struct.$keys, k => !k._ignore && !(k._isToContainer && k._selfReferences.length), (k, kn) => {
+      foreach(def.$keys, k => !k._ignore && !(k._isToContainer && k._selfReferences.length), (k, kn) => {
         if(isEdmPropertyRendered(k, options) &&
          !(options.isV2() && k['@Core.MediaType'])) {
           if(options.isV4() && options.isStructFormat) {
           // This is structured OData ONLY
           // if the foreign keys are explicitly requested, ignore associations and use the flat foreign keys instead
             if(options.renderForeignKeys && !k.target)
-              struct.$edmKeyPaths.push([kn]);
+              def.$edmKeyPaths.push([kn]);
           // else produce paths (isEdmPropertyRendered() has filtered @odata.foreignKey4 already)
             else if(!options.renderForeignKeys)
-              struct.$edmKeyPaths.push(...produceKeyRefPaths(k, kn));
+              def.$edmKeyPaths.push(...produceKeyRefPaths(k, kn));
           }
         // In v2/v4 flat, associations are never rendered
           else if(!k.target) {
-            struct.$edmKeyPaths.push([kn]);
+            def.$edmKeyPaths.push([kn]);
           }
           // check toplevel key for spec violations
-          checkKeySpecViolations(k, ['definitions', struct.name, 'elements', k.name]);
+          checkKeySpecViolations(k, ['definitions', def.name, 'elements', k.name]);
         }
       });
     }
@@ -1347,6 +1485,8 @@ function initializeModel(csn, _options, messageFunctions)
     */
     function produceKeyRefPaths(eltCsn, prefix) {
       const keyPaths = [];
+      // we want to point to the element in the entity which is the first path step
+      const location = def.$path.concat(['elements']).concat(prefix.split('/')[0]);
       if(!isEdmPropertyRendered(eltCsn, options)) {
         // let annos = Object.keys(eltCsn).filter(a=>a[0]==='@').join(', ');
         // warning(null, ['definitions', struct.name, 'elements', eltCsn.name ],
@@ -1355,7 +1495,7 @@ function initializeModel(csn, _options, messageFunctions)
       }
       // OData requires all elements along the path to be nullable: false (that is either key or notNull)
 
-      const finalType = getFinalTypeDef(eltCsn.items && eltCsn.items.type || eltCsn.type);
+      const finalType = csnUtils.getFinalTypeDef(eltCsn.items && eltCsn.items.type || eltCsn.type);
       const elements = eltCsn.elements || eltCsn.items && eltCsn.items.elements ||
       (finalType && (finalType.elements || finalType.items && finalType.items.elements));
       if(elements) {
@@ -1365,8 +1505,6 @@ function initializeModel(csn, _options, messageFunctions)
             keyPaths.push(...newRefs);
             // check path step key for spec violations
             const pathSegment = `${prefix}/${eltName}`;
-            // we want to point to the element in the entity which is the first path step
-            const location = struct.$path.concat(['elements']).concat(pathSegment.split('/')[0]);
             checkKeySpecViolations(elt, location, pathSegment);
           }
         });
@@ -1381,12 +1519,15 @@ function initializeModel(csn, _options, messageFunctions)
         // use the primary keys of the target
         let keys = (!eltCsn._target.$isParamEntity && eltCsn.keys) ||
           Object.keys(eltCsn._target.$keys).map(k => { return { ref: [k] } });
+        let pathSegment = prefix
         keys.forEach(k => {
-          let art = eltCsn._target || getCsnDef(eltCsn.target);
+          let art = eltCsn._target || csnUtils.getCsnDef(eltCsn.target);
           for(let ps of k.ref) {
             art = art.elements[ps];
+            pathSegment += '/' + art.name
+            checkKeySpecViolations(art, location, pathSegment);
             if(art.type && !isBuiltinType(art.type)) {
-              art = art._type || getCsnDef(art.type);
+              art = art._type || csnUtils.getCsnDef(art.type);
             }
           }
           keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter)));
@@ -1406,7 +1547,7 @@ function initializeModel(csn, _options, messageFunctions)
           {name: pathSegment, '#': pathSegment ? 'std' : 'scalar'});
       }
       // many
-      let type = elt.items || elt.type && !isBuiltinType(elt.type) && getFinalTypeDef(elt.type).items;
+      let type = elt.items || elt.type && !isBuiltinType(elt.type) && csnUtils.getFinalTypeDef(elt.type).items;
       if(type) {
         error('odata-spec-violation-key-array', location,
           {name: pathSegment, '#': pathSegment ? 'std' : 'scalar'});
@@ -1420,10 +1561,10 @@ function initializeModel(csn, _options, messageFunctions)
         // V2 allows any Edm.PrimitiveType (even Double and Binary), V4 is more specific:
         if(options.isV4() && type && !isAssociationOrComposition(type) && isBuiltinType(type.type)) {
           const edmType = edmUtils.mapCdsToEdmType(type);
-          const legalEdmTypes = [
-            'Edm.Boolean', 'Edm.Byte', 'Edm.Date', 'Edm.DateTimeOffset', 'Edm.Decimal', 'Edm.Duration',
-            'Edm.Guid', 'Edm.Int16', 'Edm.Int32', 'Edm.Int64', 'Edm.SByte', 'Edm.String', 'Edm.TimeOfDay' ];
-          if(!legalEdmTypes.includes(edmType)) {
+          const legalEdmTypes = {
+            'Edm.Boolean':1, 'Edm.Byte':1, 'Edm.Date':1, 'Edm.DateTimeOffset':1, 'Edm.Decimal':1, 'Edm.Duration':1,
+            'Edm.Guid':1, 'Edm.Int16':1, 'Edm.Int32':1, 'Edm.Int64':1, 'Edm.SByte':1, 'Edm.String':1, 'Edm.TimeOfDay':1 };
+          if(!(edmType in legalEdmTypes)) {
             warning('odata-spec-violation-key-type', location,
           {name: pathSegment, type: type.type, id: edmType, '#': pathSegment ? 'std' : 'scalar'});
           }
@@ -1459,10 +1600,10 @@ function initializeModel(csn, _options, messageFunctions)
     Path="items/subitems/subitems/up_" Target="Header/items/subitems"/>
     Path="items/subitems/subitems/toG" Target="G"/>
   */
-  function initializeEdmNavPropBindingTargets(struct) {
-    if(options.isV4() && struct.$mySchemaName && struct.$hasEntitySet) {
-      forEachGeneric(struct.items || struct, 'elements', (element) => {
-        produceTargetPath([edmUtils.getBaseName(struct.name)], element, struct);
+  function initEdmNavPropBindingTargets(def) {
+    if(def.$hasEntitySet) {
+      forEachGeneric(def.items || def, 'elements', (element) => {
+        produceTargetPath([edmUtils.getBaseName(def.name)], element, def);
       });
     }
 
@@ -1493,13 +1634,13 @@ function initializeModel(csn, _options, messageFunctions)
     }
   }
 
-  function initializeEdmNavPropBindingPaths(struct) {
-    if(options.isV4() && struct.$mySchemaName && struct.$hasEntitySet) {
+  function initEdmNavPropBindingPaths(def) {
+    if(options.isV4() &&def.$hasEntitySet) {
       let npbs = [];
-      forEachGeneric(struct.items || struct, 'elements', (element) => {
-        npbs = npbs.concat(produceNavigationPath(element, struct));
+      forEachGeneric(def.items || def, 'elements', (element) => {
+        npbs = npbs.concat(produceNavigationPath(element, def));
       });
-      setProp(struct, '$edmNPBs', npbs);
+      setProp(def, '$edmNPBs', npbs);
     }
 
     // collect all paths originating from this element that end up in an entity set
@@ -1513,7 +1654,10 @@ function initializeModel(csn, _options, messageFunctions)
           // drill into target only if
           // 1) target has no entity set and this assoc is not going to the container
           // 2) current definition and target are the same (cycle)
-          if(!elt._target.$hasEntitySet && !elt._isToContainer && curDef !== elt._target) {
+          if(!elt.$externalRef &&
+             !elt._target.$hasEntitySet &&
+             !elt._isToContainer &&
+             curDef !== elt._target) {
             // follow elements in the target but avoid cycles
             setProp(elt, '$touched', true);
             Object.values(elt._target.elements).forEach(e => npbs = npbs.concat(produceNavigationPath(e, elt._target)));
@@ -1523,16 +1667,18 @@ function initializeModel(csn, _options, messageFunctions)
             // end point reached but must not be an external reference nor a proxy nor a composition itself
             // last assoc step must not be to-n and target a singleton
             let p = undefined;
-            if (!elt._target.$externalRef &&
-              !(edmUtils.isToMany(elt) && edmUtils.isSingleton(elt._target) && options.isV4())) {
+            if (!elt.$externalRef &&
+                !(edmUtils.isToMany(elt) &&
+                edmUtils.isSingleton(elt._target) &&
+                options.isV4())) {
               if(elt._target.$edmTgtPaths && elt._target.$edmTgtPaths.length) {
-                p = elt._target.$edmTgtPaths.find(p => p[0] === edmUtils.getBaseName(struct.name)) || elt._target.$edmTgtPaths[0];
+                p = elt._target.$edmTgtPaths.find(p => p[0] === edmUtils.getBaseName(def.name)) || elt._target.$edmTgtPaths[0];
               }
               else if(elt._target.$hasEntitySet) {
                 const baseName = edmUtils.getBaseName(elt._target.$entitySetName || elt._target.name);
                 // if own struct and target have a set they either are in the same $mySchemaName or not
                 // if target is in another schema, target the full qualified entity set
-                p = (elt._target.$mySchemaName === struct.$mySchemaName) ?
+                p = (elt._target.$mySchemaName === def.$mySchemaName) ?
                   [ baseName ] : [elt._target.$mySchemaName + '.EntityContainer', baseName];
               }
               if(p) {
@@ -1562,28 +1708,28 @@ function initializeModel(csn, _options, messageFunctions)
     }
   }
 
-  function determineEntitySet(struct) {
+  function determineEntitySet(def) {
     // if this is an entity or a view, determine if an entity set is required or not
     // 1) must not be a proxy and not a containee in V4
     // No annos are rendered for non-existing EntitySet targets.
-    if(struct.$mySchemaName && struct.$hasEntitySet === undefined) {
-      const hasEntitySet = isEntity(struct) && !(options.isV4() && edmUtils.isContainee(struct)) && !struct.$proxy;
-      setProp(struct, '$hasEntitySet', hasEntitySet);
+    if(def.$hasEntitySet === undefined) {
+      const hasEntitySet = isEntity(def) && !(options.isV4() && edmUtils.isContainee(def)) && !def.$proxy;
+      setProp(def, '$hasEntitySet', hasEntitySet);
     }
   }
 
-  function initializeEdmTypesAndDescription(artifact) {
+  function initEdmTypesAndDescription(def) {
     // 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(artifact, '@Core.Description', artifact.doc);
-    markCollection(artifact);
-    mapCdsToEdmProp(artifact);
-    if (artifact.returns)  {
-      markCollection(artifact.returns);
-      mapCdsToEdmProp(artifact.returns);
-    }
-    forEachMemberRecursively(artifact,member => {
+    assignAnnotation(def, '@Core.Description', def.doc);
+    markCollection(def);
+    mapCdsToEdmProp(def);
+    if (def.returns)  {
+      markCollection(def.returns);
+      mapCdsToEdmProp(def.returns);
+    }
+    forEachMemberRecursively(def,member => {
       assignAnnotation(member, '@Core.Description', member.doc);
       markCollection(member);
       mapCdsToEdmProp(member);
@@ -1593,7 +1739,6 @@ function initializeModel(csn, _options, messageFunctions)
         mapCdsToEdmProp(member.returns);
       }
     });
-
     // mark members that need to be rendered as collections
     function markCollection(obj) {
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
@@ -1610,19 +1755,37 @@ function initializeModel(csn, _options, messageFunctions)
   // Checks section starts here
   //
 
+// 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 });
+    });
+  }
+
+
   function inboundQualificationChecks() {
-    forEachDefinition(csn, [ checkChainedArray ]);
+    forEachDefinition(csn, [ attach$path, checkChainedArray ]);
     checkNestedContextsAndServices();
-    throwWithError();
-
-    // NOTE: This is a copy of ./libs/checks/arrayOfs.js//checkChainedArray
-    //       as long as validators cannot operate on OData processed CSN.
-    // TODO: Remove this code.
-    //       Not possible at the moment, because running this at the beginning of
-    //       the renderer does not work because the enricher can't handle certain
-    //       OData specifics.
+    throwWithAnyError();
+
+    // 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 ]);
+    }
+
     function checkChainedArray(def, defName) {
-      if (!whatsMyServiceRootName(defName))
+      if (!isMyServiceRequested(defName))
         return;
       let currPath = ['definitions', defName];
       checkIfItemsOfItems(def, undefined, undefined, currPath);
@@ -1632,13 +1795,13 @@ function initializeModel(csn, _options, messageFunctions)
         const constructType = csnUtils.effectiveType(construct);
         if (constructType.items) {
           if (constructType.items.items) {
-            error('chained-array-of', path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
+            message('chained-array-of', path);
             return;
           }
 
           const itemsType = csnUtils.effectiveType(constructType.items);
           if (itemsType.items)
-            error('chained-array-of', path, '"Array of"/"many" must not be chained with another "array of"/"many" inside a service');
+            message('chained-array-of', path);
         }
       }
     }
@@ -1646,7 +1809,7 @@ function initializeModel(csn, _options, messageFunctions)
     function checkNestedContextsAndServices() {
       !isBetaEnabled(options, 'nestedServices') && serviceRootNames.forEach(sn => {
         const parent = whatsMyServiceRootName(sn, false);
-        if(parent && parent !== sn) {
+        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)' );
         }
@@ -1655,7 +1818,7 @@ function initializeModel(csn, _options, messageFunctions)
       Object.entries(csn.definitions).forEach(([fqName, art]) => {
         if(art.kind === 'context') {
           const parent = whatsMyServiceRootName(fqName);
-          if(parent) {
+          if(requestedServiceNames.includes(parent)) {
             message( 'service-nested-context', [ 'definitions', fqName ], { art: parent },
                'A context can\'t be nested within a service $(ART)' );
           }
@@ -1664,54 +1827,6 @@ function initializeModel(csn, _options, messageFunctions)
     }
   }
 
-  /**
-   *
-   * @param {String} identifier the illegal identifier
-   * @param {CSN.Path} path
-   */
-  function signalIllegalIdentifier(identifier, path) {
-    error(null, path, { id: identifier },
-      'OData identifier $(ID) must start with a letter or underscore, followed by at most 127 letters, underscores or digits'
-    );
-  }
-
-
-  // { '#': this.csnUtils.isComposition(member.type) ? 'cmp' : 'std' },
-  //                    {
-  //                      std: 'An association can\'t have cardinality "to many" without an ON-condition',
-  //                      cmp: 'A composition can\'t have cardinality "to many" without an ON-condition',
-  //                    }
-
-  // Check the artifact identifier for compliance with the odata specification
-  function checkArtifactIdentifierAndBoundActions(artifact) {
-    if(artifact.$mySchemaName) {
-      const artifactName = artifact.name.replace(`${artifact.$mySchemaName  }.`, '');
-      // if the artifact has bound actions, check the action identifiers and their param identifiers to be OData compliant
-      if(artifact.actions) {
-        Object.keys(artifact.actions).forEach(identifier => checkActionOrFunctionIdentifier(artifact.actions[identifier], identifier))
-      }
-
-      // if the artifact is an unbound function check it's identifer
-      if(isActionOrFunction(artifact)){
-        checkActionOrFunctionIdentifier(artifact, artifactName);
-      } else if(![ 'service', 'context', 'event', 'aspect' ].includes(artifact.kind) && !isODataSimpleIdentifier(artifactName)) {
-        signalIllegalIdentifier(artifactName, ['definitions', artifact.name]);
-      }
-    }
-
-    function checkActionOrFunctionIdentifier(actionOrFunction, actionOrFunctionName) {
-      if(!isODataSimpleIdentifier(actionOrFunctionName)){
-        signalIllegalIdentifier(actionOrFunctionName, actionOrFunction.$path);
-      }
-      if(actionOrFunction.params) {
-        forEachGeneric(actionOrFunction, 'params', (param) => {
-          if(!isODataSimpleIdentifier(param.name)){
-            signalIllegalIdentifier(param.name, param.$path);
-          }
-        });
-      }
-    }
-  }
   //
   // Checks Secition ends here
   //
@@ -1737,12 +1852,13 @@ function initializeModel(csn, _options, messageFunctions)
     //   serviceRef.push('');
     if(serviceRef[serviceRef.length-1] !== '$metadata')
       serviceRef.push('$metadata');
-    return { kind: 'reference',
+    let sc = { kind: 'reference',
       name: targetSchemaName,
       ref: { Uri: serviceRef.join('/') },
-      inc: { Namespace: targetSchemaName },
-      $mySchemaName: targetSchemaName,
+      inc: { Namespace: targetSchemaName }
     };
+    setProp(sc, '$mySchemaName', targetSchemaName);
+    return sc;
 
     /**
      * Resolve a service endpoint path to mount it to as follows...
@@ -1799,7 +1915,29 @@ function initializeModel(csn, _options, messageFunctions)
           }, { });
           // if dictionary has entries, add them to navPropEnty
           if(Object.keys(o).length) {
-            navPropEntry[prop] = o;
+            // 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;
           }
         }
@@ -1823,19 +1961,15 @@ function initializeModel(csn, _options, messageFunctions)
     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);
-    } else if (obj._isCollection && (obj.items && isBuiltinType(getFinalTypeDef(obj.items.type)))) {
-      let edmType = edmUtils.mapCdsToEdmType(obj.items, messageFunctions, _options.toOdata.version === 'v2', obj['@Core.MediaType']);
+    } 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);
     }
     // 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(getFinalTypeDef(obj.items.items.type))) {
+    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);
     }
-
-    // check against the value of the @odata.Type annotation
-    if (obj['@odata.Type'] && !['Edm.Int16', 'Edm.Int32', 'Edm.Int64', 'Edm.String'].includes(obj['@odata.Type']))
-      info(null, obj.$location, { type: obj['@odata.Type'] }, "@odata.Type: $(TYPE) is ignored, only Edm.String and Edm.Int[16,32,64] are allowed");
   }
 
   function ComputedDefaultValue(member) {
@@ -2158,7 +2292,7 @@ function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
   }
 
   function checkSemantics(struct, propName, propValue) {
-    if(['timeseries', 'aggregate'].includes(propValue)) {
+    if(propValue === 'timeseries' || propValue === 'aggregate') {
       // aggregate is forwarded to Set and must remain on Type
       addToSetAttr(struct, propName, propValue, propValue !== 'aggregate');
     }
@@ -2222,4 +2356,5 @@ function assignProp(obj, prop, value) {
 
 module.exports = {
   initializeModel,
+  assignAnnotation
 }