@sap/cds-compiler 4.1.2 → 4.2.2

package/lib/edm/edmPreprocessor.js

@@ -1,4 +1,5 @@
 'use strict';
+
 /* eslint max-statements-per-line:off */
 const { setProp, isDeprecatedEnabled, isBetaEnabled } = require('../base/model');
 const {
@@ -15,10 +16,10 @@ const expandCSNToFinalBaseType = require('../transform/odata/toFinalBaseType');
 const NavResAnno = '@Capabilities.NavigationRestrictions.RestrictedProperties';
 
 // Capabilities that can be pulled up to NavigationRestrictions
-const capabilities = Object.keys(require('../gen/Dictionary.json').
-  types['Capabilities.NavigationPropertyRestriction'].Properties).
-  filter(c => !['NavigationProperty', 'Navigability'].includes(c)).
-  map(c => '@Capabilities.'+c);
+const capabilities = Object.keys(require('../gen/Dictionary.json')
+  .types['Capabilities.NavigationPropertyRestriction'].Properties)
+  .filter(c => ![ 'NavigationProperty', 'Navigability' ].includes(c))
+  .map(c => `@Capabilities.${c}`);
 
 /**
  *  edmPreprocessor warms up the model so that it can be converted into an EDM document and
@@ -30,9 +31,10 @@ const capabilities = Object.keys(require('../gen/Dictionary.json').
  * @param {CSN.Model} csn
  * @param {object}    _options
  */
-function initializeModel(csn, _options, messageFunctions, requestedServiceNames=undefined)
-{
-  const { info, warning, error, message } = messageFunctions;
+function initializeModel( csn, _options, messageFunctions, requestedServiceNames = undefined ) {
+  const {
+    info, warning, error, message,
+  } = messageFunctions;
   const special$self = !csn?.definitions?.$self && '$self';
   const csnUtils = getUtils(csn);
 
@@ -45,36 +47,36 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
 
   // make sure options are complete
-  let options = edmUtils.validateOptions(_options);
+  const options = edmUtils.validateOptions(_options);
 
   const [ serviceRoots,
     serviceRootNames,
     fallBackSchemaName,
-    whatsMyServiceRootName ] = getAnOverviewOnTheServices(csn);
+    whatsMyServiceRootName ] = getAnOverviewOnTheServices();
+
+  if (serviceRootNames.length === 0)
+    return [ serviceRoots, Object.create(null), reqDefs, whatsMyServiceRootName, fallBackSchemaName, options ];
 
-  if(serviceRootNames.length === 0) {
-    return [serviceRoots, Object.create(null), reqDefs, whatsMyServiceRootName, fallBackSchemaName, options];
-  }
 
-  if(requestedServiceNames === undefined)
+  if (requestedServiceNames === undefined)
     requestedServiceNames = options.serviceNames;
-  if(requestedServiceNames === undefined) {
+  if (requestedServiceNames === undefined)
     requestedServiceNames = serviceRootNames;
-  }
 
-  function isMyServiceRequested(n) {
+
+  function isMyServiceRequested( n ) {
     return requestedServiceNames.includes(whatsMyServiceRootName(n));
   }
 
   // Structural CSN inbound QA checks
   inboundQualificationChecks(csn, options, messageFunctions,
-    serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils);
+                             serviceRootNames, requestedServiceNames, isMyServiceRequested, whatsMyServiceRootName, csnUtils);
   // not needed at the moment
   // resolveForeignKeyRefs();
 
-  if(isBetaEnabled(options, undefined)) {
+  if (isBetaEnabled(options, undefined))
     splitDottedDefinitionsIntoSeparateServices();
-  }
+
   else
     /*
       Replace dots with underscores for all definitions below a context
@@ -94,7 +96,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     as a step in the OData transformer with the goal to have a protocol agnostic OData CSN.
   */
   if (csn.meta && csn.meta.options && csn.meta.options.odataVersion === 'v4' && options.isV2()) {
-    const { toFinalBaseType }= require('../transform/transformUtils').getTransformers(csn, options);
+    // eslint-disable-next-line global-require
+    const { toFinalBaseType } = require('../transform/transformUtils').getTransformers(csn, options);
     expandCSNToFinalBaseType(csn, { toFinalBaseType }, csnUtils, serviceRootNames, options);
   }
 
@@ -102,31 +105,33 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     Enrich the CSN by de-anonymizing and exposing types that are required to make the service self contained.
   */
   const schemas = typesExposure(csn, whatsMyServiceRootName, requestedServiceNames,
-    fallBackSchemaName, options, csnUtils, { error });
+                                fallBackSchemaName, options, csnUtils, { error });
 
   // Get an overview about all schemas (including the services)
-  const schemaNames = [...serviceRootNames];
+  const schemaNames = [ ...serviceRootNames ];
   schemaNames.push(...Object.keys(schemas));
   // sort schemas in reverse order to allow longest match in whatsMySchemaName function
-  schemaNames.sort((a,b) => b.length-a.length);
-  function whatsMySchemaName(n) {
-    return schemaNames.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') ? sn : rc, undefined);
+  schemaNames.sort((a, b) => b.length - a.length);
+  function whatsMySchemaName( n ) {
+    return schemaNames.reduce((rc, sn) => (!rc && n && n.startsWith(`${sn}.`) ? sn : rc), undefined);
   }
 
-  if(schemaNames.length) {
+  if (schemaNames.length) {
     forEachDefinition(csn, [
       attachNameProperty,
       (def, defName) => {
         const mySchemaName = whatsMySchemaName(defName);
-        mySchemaName && setProp(def, '$mySchemaName', mySchemaName);
-        if(isMyServiceRequested(defName) && def.kind !== 'aspect')
+        if (mySchemaName)
+          setProp(def, '$mySchemaName', mySchemaName);
+        if (isMyServiceRequested(defName) && def.kind !== 'aspect')
           reqDefs.definitions[defName] = def;
       },
-      linkAssociationTarget
+      linkAssociationTarget,
     ]);
     forEachGeneric(csn, 'vocabularies', (term, termName) => {
       const mySchemaName = whatsMySchemaName(termName);
-      mySchemaName && setProp(term, '$mySchemaName', mySchemaName);
+      if (mySchemaName)
+        setProp(term, '$mySchemaName', mySchemaName);
     });
     // initialize requested services
     const skip = { skipArtifact: (_def, defName) => !isMyServiceRequested(defName) };
@@ -140,7 +145,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // Initialize associations after _parent linking
     forEachDefinition(reqDefs, initConstraints);
     // Mute V4 elements depending on constraint preparation
-    if(options.isV4())
+    if (options.isV4())
       forEachDefinition(reqDefs, ignoreProperties);
     // calculate constraints based on ignoreProperties and initConstraints
     forEachDefinition(reqDefs, finalizeConstraints);
@@ -151,19 +156,20 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // Decide if an entity set needs to be constructed or not
     forEachDefinition(reqDefs, [
       exposeTargetsAsProxiesOrSchemaRefs,
-      determineEntitySet
+      determineEntitySet,
     ]);
     // finalize proxy creation
     mergeProxiesIntoModel();
 
     // Calculate NavPropBinding Target paths
     // Rewrite @Capabilities for containment mode
-    if(options.isV4())
+    if (options.isV4()) {
       forEachDefinition(reqDefs, [
         initEdmNavPropBindingTargets,
         pullupCapabilitiesAnnotations,
-        annotateOptionalActFuncParams
+        annotateOptionalActFuncParams,
       ]);
+    }
 
     // Things that can be done in one pass
     // Create edmKeyRefPaths
@@ -172,7 +178,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     forEachDefinition(reqDefs, [
       initEdmKeyRefPaths,
       initEdmNavPropBindingPaths,
-      finalize
+      finalize,
     ]);
   }
   return [
@@ -181,47 +187,47 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     reqDefs,
     whatsMyServiceRootName,
     fallBackSchemaName,
-    options
+    options,
   ];
 
-  //////////////////////////////////////////////////////////////////////
+  // ////////////////////////////////////////////////////////////////////
   //
   // Service initialization starts here
   //
 
-  function getAnOverviewOnTheServices(csn) {
+  function getAnOverviewOnTheServices( ) {
     const defs = csn.definitions || {};
-    const serviceRoots = Object.create(null);
-    for(const defName in defs) {
+    const sroots = Object.create(null);
+    for (const defName in defs) {
       const def = defs[defName];
-      if(def && def.kind === 'service')
-        serviceRoots[defName] = Object.assign(def, { name: defName });
+      if (def && def.kind === 'service')
+        sroots[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);
+    const srootNames = Object.keys(sroots).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 fbSchemaName = 'root';
     let i = 1;
     const defNames = Object.keys(defs);
-    while (defNames.some(artName => {
+    // eslint-disable-next-line no-loop-func
+    while (defNames.some((artName) => {
       const p = artName.split('.');
-      return p.length === 2 && p[0] === fallBackSchemaName;
-    })) {
-      fallBackSchemaName = 'root' + i++;
-    }
+      return p.length === 2 && p[0] === fbSchemaName;
+    }))
+      fbSchemaName = `root${i++}`;
+
 
     return [
-      serviceRoots,
-      serviceRootNames,
-      fallBackSchemaName,
-      whatsMyServiceRootName ];
+      sroots,
+      srootNames,
+      fbSchemaName,
+      // whatsMyServiceRootName
+      ( n, self = true ) => srootNames.reduce((rc, sn) => (!rc && n && n.startsWith(`${sn}.`) || (n === sn && self) ? sn : rc), undefined),
+    ];
   }
 
   /*
@@ -231,11 +237,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     All type refs and assoc targets must also be adjusted to refer to the new names.
   */
   function renameDottedDefinitionsInsideServiceOrContext() {
-
     // 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};
+    function getRootDef( name ) {
+      const scopeKinds = { service: 1, context: 1 };
       let pos = name.lastIndexOf('.');
       name = pos < 0 ? undefined : name.substring(0, pos);
       while (name && !((csn.definitions[name] && csn.definitions[name].kind) in scopeKinds)) {
@@ -247,24 +252,26 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
     const dotEntityNameMap = Object.create(null);
     const dotTypeNameMap = Object.create(null);
-    const kinds = {'entity':1, 'type':1, 'action':1, 'function':1};
+    const kinds = {
+      entity: 1, type: 1, action: 1, function: 1,
+    };
     forEachDefinition(csn, (def, defName) => {
-      if(def.kind in kinds) {
+      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 !== edmUtils.getSchemaPrefix(defName)) {
-          let newDefName = rootDef + '.' + defName.replace(rootDef + '.', '').replace(/\./g, '_');
+        if (rootDef && defName !== rootDef && rootDef !== edmUtils.getSchemaPrefix(defName)) {
+          const newDefName = `${rootDef}.${defName.replace(`${rootDef}.`, '').replace(/\./g, '_')}`;
           // store renamed types in correlation maps for later renaming
-          if(def.kind === 'entity')
+          if (def.kind === 'entity')
             dotEntityNameMap[defName] = newDefName;
-          if(def.kind === 'type')
+          if (def.kind === 'type')
             dotTypeNameMap[defName] = newDefName;
           // rename in csn.definitions
           const art = csn.definitions[newDefName];
-          if(art !== undefined) {
+          if (art !== undefined) {
             error(null, [ 'definitions', defName ], { name: newDefName },
-            'Artifact name containing dots can\'t be mapped to an OData compliant name because it conflicts with existing definition $(NAME)');
+                  'Artifact name containing dots can\'t be mapped to an OData compliant name because it conflicts with existing definition $(NAME)');
           }
           else {
             csn.definitions[newDefName] = def;
@@ -276,32 +283,34 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     });
     // rename type refs to new type names
     const rewrite = (def) => {
-      const applyOnNode = (node) => {
-        node = node.items || node;
-        if(node.type && dotTypeNameMap[node.type]) {
-          node.type = dotTypeNameMap[node.type];
-        }
-        if(node.target && dotEntityNameMap[node.target]) {
-          node.target = dotEntityNameMap[node.target];
-        }
-        if(node.$path && dotEntityNameMap[node.$path[1]]) {
-          node.$path[1] = dotEntityNameMap[node.$path[1]]
-        }
-        rewriteReferencesInActions(node);
-      }
-
       const rewriteReferencesInActions = (act) => {
-        act.params && Object.values(act.params).forEach(param => {
-          param = param.items || param;
-          if(param.type && (dotEntityNameMap[param.type] || dotTypeNameMap[param.type]))
-            param.type = dotEntityNameMap[param.type] || dotTypeNameMap[param.type];
-        });
-        if(act.returns){
+        if (act.params) {
+          Object.values(act.params).forEach((param) => {
+            param = param.items || param;
+            if (param.type && (dotEntityNameMap[param.type] || dotTypeNameMap[param.type]))
+              param.type = dotEntityNameMap[param.type] || dotTypeNameMap[param.type];
+          });
+        }
+        if (act.returns) {
           const returnsObj = act.returns.items || act.returns;
           if (returnsObj.type && dotEntityNameMap[returnsObj.type] || dotTypeNameMap[returnsObj.type])
             returnsObj.type = dotEntityNameMap[returnsObj.type] || dotTypeNameMap[returnsObj.type];
         }
-      }
+      };
+
+      const applyOnNode = (node) => {
+        node = node.items || node;
+        if (node.type && dotTypeNameMap[node.type])
+          node.type = dotTypeNameMap[node.type];
+
+        if (node.target && dotEntityNameMap[node.target])
+          node.target = dotEntityNameMap[node.target];
+
+        if (node.$path && dotEntityNameMap[node.$path[1]])
+          node.$path[1] = dotEntityNameMap[node.$path[1]];
+
+        rewriteReferencesInActions(node);
+      };
 
       forEachMemberRecursively(def, applyOnNode);
       applyOnNode(def);
@@ -321,11 +330,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   */
   function splitDottedDefinitionsIntoSeparateServices() {
     forEachDefinition(csn, (def, defName) => {
-      if(def.kind !== 'service') {
+      if (def.kind !== 'service') {
         const myServiceRoot = whatsMyServiceRootName(defName);
         const mySchemaPrefix = edmUtils.getSchemaPrefix(defName);
-        if(myServiceRoot && options.isV4() &&
-        /*(options.odataProxies || options.odataXServiceRefs) && options.isStructFormat && */
+        if (myServiceRoot && options.isV4() &&
+        /* (options.odataProxies || options.odataXServiceRefs) && options.isStructFormat && */
         defName !== myServiceRoot && myServiceRoot !== mySchemaPrefix) {
           const service = { kind: 'service', name: mySchemaPrefix };
           serviceRoots[mySchemaPrefix] = service;
@@ -333,42 +342,42 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         }
       }
     });
-    serviceRootNames.sort((a,b) => b.length-a.length);
+    serviceRootNames.sort((a, b) => b.length - a.length);
   }
 
-  function attachNameProperty(def, defName) {
-    edmUtils.assignProp (def, 'name', defName);
+  function attachNameProperty( def, defName ) {
+    edmUtils.assignProp(def, 'name', defName);
     // Attach name to bound actions, functions and parameters
-    forEachGeneric(def, 'actions', (a, n) => {
-      edmUtils.assignProp(a, 'name', n);
-      forEachGeneric(a, 'params', (p, n) => {
-        edmUtils.assignProp(p, 'name', n);
+    forEachGeneric(def, 'actions', (a, an) => {
+      edmUtils.assignProp(a, 'name', an);
+      forEachGeneric(a, 'params', (p, pn) => {
+        edmUtils.assignProp(p, 'name', pn);
       });
     });
     // Attach name unbound action parameters
-    forEachGeneric(def, 'params', (p,n) => {
-      edmUtils.assignProp(p, 'name', n);
+    forEachGeneric(def, 'params', (p, pn) => {
+      edmUtils.assignProp(p, 'name', pn);
     });
   }
 
   // initialize the service itself
-  function initService(serviceRoot) {
+  function initService( serviceRoot ) {
     edmAnnoPreproc.setSAPSpecificV2AnnotationsToEntityContainer(options, serviceRoot);
   }
 
   // link association target to association and add @odata.contained to compositions in V4
-  function linkAssociationTarget(struct) {
+  function linkAssociationTarget( struct ) {
     forEachMemberRecursively(struct, (element, name, prop, subpath) => {
-      if(element.target && !element._target) {
-        let target = csn.definitions[element.target];
-        if(target) {
+      if (element.target && !element._target) {
+        const target = csn.definitions[element.target];
+        if (target) {
           setProp(element, '_target', target);
           // If target has parameters, xref assoc at target for redirection
-          if(edmUtils.isParameterizedEntity(target)) {
-            if(!target.$sources) {
+          if (edmUtils.isParameterizedEntity(target)) {
+            if (!target.$sources)
               setProp(target, '$sources', Object.create(null));
-            }
-            target.$sources[struct.name + '.' + name] = element;
+
+            target.$sources[`${struct.name}.${name}`] = element;
           }
         }
         else {
@@ -376,12 +385,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         }
       }
       // in V4 tag all compositions to be containments
-      if(options.odataContainment &&
+      if (options.odataContainment &&
          options.isV4() &&
          csnUtils.isComposition(element) &&
-         element['@odata.contained'] === undefined) {
+         element['@odata.contained'] === undefined)
         element['@odata.contained'] = true;
-      }
     });
   }
 
@@ -401,21 +409,21 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   // $containeeAssociations stores the containees (children/outbound edges)
   // $containerNames stores the containers (parents/inbound edges)
 
-  function initContainments(container) {
-    if(container.kind === 'entity') {
-      if(!container.$containeeAssociations)
+  function initContainments( container ) {
+    if (container.kind === 'entity') {
+      if (!container.$containeeAssociations)
         setProp(container, '$containeeAssociations', []);
-      forEachMemberRecursively(container, initContainments,
-        [], true, { pathWithoutProp: true, elementsOnly: true });
+      forEachMemberRecursively(container, eachAssoc,
+                               [], true, { pathWithoutProp: true, elementsOnly: true });
     }
 
-    function initContainments(elt, _memberName, _prop, path) {
-      if(elt.target && elt['@odata.contained']) {
+    function eachAssoc( elt, _memberName, _prop, path ) {
+      if (elt.target && elt['@odata.contained']) {
         // 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;
+        const containee = elt._target;
         if (!containee.$containerNames)
           setProp(containee, '$containerNames', []);
         // add container only once per containee
@@ -423,39 +431,38 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           containee.$containerNames.push(container.name);
         // Mark associations in the containee pointing to the container (i.e. to this entity)
         forEachMemberRecursively(containee, markToContainer,
-          [ 'definitions', containee.name ], true, { elementsOnly: true });
+                                 [ 'definitions', containee.name ], true, { elementsOnly: true });
       }
-      else if(elt.type && !elt.elements) {
+      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 && !elt.$visited) {
+
+        if (elt && elt.elements && !elt.$visited) {
           setProp(elt, '$visited', true);
-          forEachMemberRecursively(elt, initContainments,
-            path, true, { pathWithoutProp: true, elementsOnly: true });
+          forEachMemberRecursively(elt, eachAssoc,
+                                   path, true, { pathWithoutProp: true, elementsOnly: true });
           delete elt.$visited;
         }
       }
     }
 
-    function markToContainer(elt) {
-      if(elt._target && elt._target.name) {
+    function markToContainer( elt ) {
+      if (elt._target && elt._target.name) {
         // If this is an association that points to the container (but is not by itself contained,
         // which would indicate the top role in a hierarchy) mark it with '_isToContainer'
-        if(elt._target.name === container.name && !elt['odata.contained']) {
+        if (elt._target.name === container.name && !elt['odata.contained'])
           setProp(elt, '_isToContainer', true);
-        }
       }
       else {
         // try to find elements to drill down further
-        while(elt && !(isBuiltinType(elt.type) || elt.elements)) {
+        while (elt && !(isBuiltinType(elt.type) || elt.elements))
           elt = csn.definitions[elt.type];
-        }
-        if(elt && elt.elements && !elt.$visited) {
+
+        if (elt && elt.elements && !elt.$visited) {
           setProp(elt, '$visited', true);
           forEachMemberRecursively(elt, markToContainer,
-            [], true, { elementsOnly: true });
+                                   [], true, { elementsOnly: true });
           delete elt.$visited;
         }
       }
@@ -470,9 +477,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   // 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(!edmUtils.isParameterizedEntity(entityCsn))
+  function initParameterizedEntityOrView( entityCsn, entityName ) {
+    if (!edmUtils.isParameterizedEntity(entityCsn))
       return;
 
     // Naming rules for aggregated views with parameters
@@ -487,10 +493,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     //             Backlink Navigation Property "Parameters" to <ViewName>Parameters
 
     // this code can be extended for aggregated views
-    const typeEntityName = entityName + 'Type';
-    const typeEntitySetName = entityName + 'Set';
+    const typeEntityName = `${entityName}Type`;
+    const typeEntitySetName = `${entityName}Set`;
     const typeToParameterAssocName = 'Parameters';
-    let hasBacklink = true;
+    const hasBacklink = true;
 
 
     // create the Parameter Definition
@@ -498,8 +504,9 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     setProp(parameterCsn, '_origin', entityCsn);
     // 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 });
+    if (csn.definitions[typeEntityName]) {
+      error('odata-definition-exists', [ 'definitions', entityName ], { '#': 'std', name: typeEntityName });
+    }
     else {
       csn.definitions[typeEntityName] = entityCsn;
       reqDefs.definitions[typeEntityName] = entityCsn;
@@ -509,36 +516,38 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     }
     setProp(entityCsn, '$entitySetName', typeEntitySetName);
     // add backlink association
-    if(hasBacklink) {
+    if (hasBacklink) {
       entityCsn.elements[typeToParameterAssocName] = {
         name: typeToParameterAssocName,
         target: parameterCsn.name,
         type: 'cds.Association',
-        on: [ { ref: [ 'Parameters', 'Set' ] }, '=', { ref: [ '$self' ] } ]
+        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 ] );
+              [ 'definitions', typeEntityName, 'elements', typeToParameterAssocName ] );
 
       // rewrite $path
-      if(entityCsn.$path)
+      if (entityCsn.$path)
         entityCsn.$path[1] = typeEntityName;
       forEachMemberRecursively(entityCsn, (member) => {
-        if(member.$path)
+        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"/>
 */
     edmUtils.assignProp(entityCsn, '_SetAttributes',
-      {'@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.addressable': false });
+                        {
+                          '@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 => {
+    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;
@@ -546,8 +555,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     });
   }
 
-  function createParameterEntity(entityCsn, entityName, isProxy) {
-    const parameterEntityName = entityName + 'Parameters';
+  function createParameterEntity( entityCsn, entityName, isProxy ) {
+    const parameterEntityName = `${entityName}Parameters`;
     const parameterToTypeAssocName = 'Set';
 
     // Construct the parameter entity
@@ -557,11 +566,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       elements: Object.create(null),
       '@sap.semantics': 'parameters',
     };
-    if(!isProxy)
+    if (!isProxy)
       setProp(parameterCsn, '$entitySetName', entityName);
-    if(entityCsn.$location){
+    if (entityCsn.$location)
       edmUtils.assignProp(parameterCsn, '$location', entityCsn.$location);
-    }
+
 
     /*
       <EntitySet Name="ZRHA_TEST_CDS" EntityType="ZRHA_TEST_CDS_CDS.ZRHA_TEST_CDSParameters" sap:creatable="false" sap:updatable="false"
@@ -569,13 +578,15 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     */
 
     edmUtils.assignProp(parameterCsn, '_SetAttributes',
-      {'@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.pageable': false });
+                        {
+                          '@sap.creatable': false, '@sap.updatable': false, '@sap.deletable': false, '@sap.pageable': false,
+                        });
 
     setProp(parameterCsn, '$isParamEntity', true);
     setProp(parameterCsn, '$mySchemaName', entityCsn.$mySchemaName);
 
-    forEachGeneric(entityCsn, 'params', (p,n) => {
-      let elt = cloneCsnNonDict(p, options);
+    forEachGeneric(entityCsn, 'params', (p, n) => {
+      const elt = cloneCsnNonDict(p, options);
       elt.name = n;
       delete elt.kind;
       setProp(elt, '$path', [ 'definitions', parameterEntityName, 'elements', n ]);
@@ -587,7 +598,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         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())
+      if (options.isV2())
         edmUtils.assignAnnotation(elt, '@sap.parameter', 'mandatory');
       else
         edmUtils.assignAnnotation(elt, '@Common.FieldControl', { '#': 'Mandatory' });
@@ -596,50 +607,52 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     linkAssociationTarget(parameterCsn);
     initContainments(parameterCsn);
     // add assoc to result set, FIXME: is the cardinality correct?
-    if(!isProxy) {
+    if (!isProxy) {
       parameterCsn.elements[parameterToTypeAssocName] = {
         '@odata.contained': true,
         name: parameterToTypeAssocName,
         target: entityCsn.name,
         type: 'cds.Association',
-        cardinality: { src: 1, min: 0, max: '*' }
+        cardinality: { src: 1, min: 0, max: '*' },
       };
       setProp(parameterCsn.elements[parameterToTypeAssocName], '_target', entityCsn);
       setProp(parameterCsn.elements[parameterToTypeAssocName], '$path',
-        [ 'definitions', parameterEntityName, 'elements', parameterToTypeAssocName ] );
+              [ 'definitions', parameterEntityName, 'elements', parameterToTypeAssocName ] );
     }
 
-    [ '@odata.singleton', '@odata.singleton.nullable' ].forEach(a => {
-      if(entityCsn[a] != null)
+    [ '@odata.singleton', '@odata.singleton.nullable' ].forEach((a) => {
+      if (entityCsn[a] != null)
         parameterCsn[a] = entityCsn[a];
       delete entityCsn[a];
     });
 
     // initialize containment
     // propagate containment information, if containment is recursive, use parameterCsn.name as $containerNames
-    if(entityCsn.$containerNames) {
-      if(!parameterCsn.$containerNames)
+    if (entityCsn.$containerNames) {
+      if (!parameterCsn.$containerNames)
         setProp(parameterCsn, '$containerNames', []);
-      for(const c of entityCsn.$containerNames) {
+      for (const c of entityCsn.$containerNames)
         parameterCsn.$containerNames.push((c === entityCsn.name) ? parameterCsn.name : c);
-      }
     }
     entityCsn.$containerNames = [ parameterCsn ];
 
-    if(!parameterCsn.$containeeAssociations)
+    if (!parameterCsn.$containeeAssociations)
       setProp(parameterCsn, '$containeeAssociations', [ ]);
     parameterCsn.$containeeAssociations.push(
-      { assoc: parameterCsn.elements[parameterToTypeAssocName],
-        path: [ parameterToTypeAssocName ]
-      });
+      {
+        assoc: parameterCsn.elements[parameterToTypeAssocName],
+        path: [ parameterToTypeAssocName ],
+      }
+    );
 
     // rewrite $path
     setProp(parameterCsn, '$path', [ 'definitions', parameterEntityName ]);
 
     // proxies are registered in model separately
-    if(!isProxy) {
-      if(csn.definitions[parameterCsn.name])
+    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;
@@ -648,13 +661,13 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     return parameterCsn;
   }
 
-  function initElement(element, name, struct) {
-    setProp(element, 'name', name)
+  function initElement( element, name, struct ) {
+    setProp(element, 'name', name);
     setProp(element, '_parent', struct);
   }
 
   // convert $path to path starting at main artifact
-  function $path2path(p) {
+  function $path2path( p ) {
     const path = [];
     /** @type {any} */
     let env = csn;
@@ -663,9 +676,13 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       env = env[ps];
       if (env && env.constructor === Object) {
         path.push(ps);
-        if(env.items)
+        // jump over many items but not if this is an element
+        if (env.items) {
           env = env.items;
-        if(env.type && !isBuiltinType(env.type) && !env.elements)
+          if (p[i + 1] === 'items')
+            i++;
+        }
+        if (env.type && !isBuiltinType(env.type) && !env.elements)
           env = csn.definitions[env.type];
       }
     }
@@ -673,45 +690,49 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   }
 
   // Initialize a structured artifact
-  function initStructure(def) {
-
+  function initStructure( def ) {
     // Don't operate on any structured types other than type and entity
     // such as events and aspects
-    if(!edmUtils.isStructuredArtifact(def))
+    if (!edmUtils.isStructuredArtifact(def))
       return;
 
     let keys = Object.create(null);
-    let validFrom = [], validKey = [];
+    const validFrom = []; const
+      validKey = [];
 
     // Iterate all struct elements
     forEachMemberRecursively(def.items || def, (element, elementName, prop, _path, construct) => {
-      if(prop !== 'elements')
+      if (prop !== 'elements')
         return;
 
       initElement(element, elementName, construct);
 
       // collect temporal information
-      if(element['@cds.valid.key']) {
+      if (element['@cds.valid.key'])
         validKey.push(element);
-      }
-      if(element['@cds.valid.from']) {
+
+      if (element['@cds.valid.from'])
         validFrom.push(element);
-      }
-      //forward annotations from managed association element to its foreign keys
+
+      // forward annotations from managed association element to its foreign keys
+      // TODO: Try to eliminate this code by rearranging
+      // forOdata::addCommonValueListviaAssociation(member, memberName)
+      // such that the VL annotations are distributed to the associations *before*
+      // FK creation.
+      // The FK creation already propagates the annotations from the association
       const elements = construct.items && construct.items.elements || construct.elements;
       const fk = elements[element['@odata.foreignKey4']];
-      for(const attrName in fk) {
+      for (const attrName in fk) {
         const attr = fk[attrName];
-        if(attrName[0] === '@') {
-          element[attrName] = attr;
-        }
+        if (attrName[0] === '@')
+          edmUtils.assignAnnotation(element, attrName, attr);
       }
       // and eventually remove some afterwards
-      if(options.isV2())
+      if (options.isV2())
         edmAnnoPreproc.setSAPSpecificV2AnnotationsToAssociation(element);
 
       // initialize an association
-      if(element.target) {
+      if (element.target) {
         // in case this is a forward assoc, store the backlink partners here, _selfReferences.length > 1 => error
         edmUtils.assignProp(element, '_selfReferences', []);
         edmUtils.assignProp(element._target, '$proxies', []);
@@ -720,50 +741,48 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       }
 
       // Collect keys
-      if (element.key) {
+      if (element.key)
         keys[elementName] = element;
-      }
+
       edmAnnoPreproc.applyAppSpecificLateCsnTransformationOnElement(options, element, def, error);
     }, [], true, { elementsOnly: true });
 
-    if(!isDeprecatedEnabled(options, '_v1KeysForTemporal')) {
+    if (!isDeprecatedEnabled(options, '_v1KeysForTemporal')) {
       // if artifact has a cds.valid.key mention it as @Core.AlternateKey
-      if(validKey.length) {
-        let altKeys = [{ Key: [] }];
+      if (validKey.length) {
+        const altKeys = [ { Key: [] } ];
         validKey.forEach(vk => altKeys[0].Key.push( { Name: vk.name, Alias: vk.name } ) );
         edmUtils.assignAnnotation(def, '@Core.AlternateKeys', altKeys);
       }
     }
-    else {
+    else if (validKey.length) {
       // if artifact has a cds.valid.key make this the only primary key and
       // add all @cds.valid.from + original primary keys as alternate keys
       // @Core.AlternateKeys: [{ Key: [ { Name: 'slID', Alias: 'slID' }, { Name: 'validFrom', Alias: 'validFrom'} ] }]
-      if(validKey.length) {
-        let altKeys = [{ Key: [] }];
-        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 } );
-        });
-        edmUtils.assignAnnotation(def, '@Core.AlternateKeys', altKeys);
-        keys = Object.create(null);
-        validKey.forEach(e => {
-          e.key = true;
-          keys[e.name] = e;
-        });
-      }
-      else {
-        validFrom.forEach(e => {
-          e.key = true;
-          keys[e.name] = e;
-        });
-      }
+      const altKeys = [ { Key: [] } ];
+      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 } );
+      });
+      edmUtils.assignAnnotation(def, '@Core.AlternateKeys', altKeys);
+      keys = Object.create(null);
+      validKey.forEach((e) => {
+        e.key = true;
+        keys[e.name] = e;
+      });
+    }
+    else {
+      validFrom.forEach((e) => {
+        e.key = true;
+        keys[e.name] = e;
+      });
     }
 
     // prepare the structure itself
-    if(def.kind === 'entity') {
+    if (def.kind === 'entity') {
       edmUtils.assignProp(def, '_SetAttributes', Object.create(null));
       edmUtils.assignProp(def, '$keys', keys);
       edmAnnoPreproc.applyAppSpecificLateCsnTransformationOnStructure(options, def, error);
@@ -772,17 +791,19 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   }
 
   // Prepare the associations for the subsequent steps
-  function initConstraints(def) {
-    if(!edmUtils.isStructuredArtifact(def))
+  function initConstraints( def ) {
+    if (!edmUtils.isStructuredArtifact(def))
       return;
 
     forEachMemberRecursively(def.items || def, initConstraintsOnAssoc, [], true, { elementsOnly: true });
   }
-  function initConstraintsOnAssoc(element) {
+  function initConstraintsOnAssoc( element ) {
     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
+      // setup the constraints object
+      setProp(element, '_constraints', {
+        constraints: Object.create(null), selfs: [], _origins: [], termCount: 0,
+      });
+      // and crack the ON condition
       edmUtils.resolveOnConditionAndPrepareConstraints(csn, element, messageFunctions);
     }
   }
@@ -799,53 +820,52 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
        active, assign @cds.api.ignore or @odata.navigable: false
     4) All of this can be revoked with options.renderForeignKeys.
   */
-  function ignoreProperties(struct) {
-    if(!edmUtils.isStructuredArtifact(struct))
+  function ignoreProperties( struct ) {
+    if (!edmUtils.isStructuredArtifact(struct))
       return;
 
     forEachMemberRecursively(struct.items || struct, (element) => {
-      if(!element.target) {
-        if(element['@odata.foreignKey4']) {
+      if (!element.target) {
+        if (element['@odata.foreignKey4']) {
           let isContainerAssoc = false;
-          let elements = (struct.items || struct).elements;
-          let assoc = undefined;
-          const paths = element['@odata.foreignKey4'].split('.')
-          for(let p of paths) {
+          let { elements } = struct.items || struct;
+          let assoc;
+          const paths = element['@odata.foreignKey4'].split('.');
+          for (const p of paths) {
             assoc = elements[p];
-            if(assoc) // could be that the @odata.foreignKey4 was propagated...
+            if (assoc) // could be that the @odata.foreignKey4 was propagated...
               elements = assoc.elements;
           }
 
-          if(assoc)
+          if (assoc)
             isContainerAssoc = !!(assoc._isToContainer && assoc._selfReferences.length || assoc['@odata.contained']);
             /*
               If this foreign key is NOT a container fk, let isEdmPropertyRendered() decide
               Else, if fk is container fk, omit it if it wasn't requested in structured mode
             */
-          if((!isContainerAssoc && !isEdmPropertyRendered(element, options)) ||
+          if ((!isContainerAssoc && !isEdmPropertyRendered(element, options)) ||
                (isContainerAssoc && !options.renderForeignKeys))
             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 (if available)
-          else if(options.odataContainment &&
+          else if (options.odataContainment &&
                   isContainerAssoc &&
                   options.renderForeignKeys &&
-                  struct.$keys) {
+                  struct.$keys)
             delete struct.$keys[element.name];
-          }
         }
         // Only in containment:
         // Ignore this (foreign key) element if renderForeignKeys is false
-        if(options.odataContainment && element['@odata.containment.ignore']) {
-          if(!options.renderForeignKeys)
+        if (options.odataContainment && element['@odata.containment.ignore']) {
+          if (!options.renderForeignKeys)
             edmUtils.assignAnnotation(element, '@cds.api.ignore', true);
-          else if(struct.$keys)
+          else if (struct.$keys)
             // If foreign keys shall be rendered, remove it from key ref vector (if available)
             delete struct.$keys[element.name];
         }
       }
-        // it's an association
-      else if(element['@odata.containment.ignore'] && options.odataContainment && !options.renderForeignKeys) {
+      // it's an association
+      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
         edmUtils.assignAnnotation(element, '@odata.navigable', false);
@@ -858,43 +878,44 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     It may be that now a number of properties are not rendered and cannot act as constraints (see isConstraintCandidate())
     in edmUtils
   */
-  function finalizeConstraints(def) {
-    if(!edmUtils.isStructuredArtifact(def))
+  function finalizeConstraints( def ) {
+    if (!edmUtils.isStructuredArtifact(def))
       return;
 
     forEachMemberRecursively(def.items || def, finalizeConstraintsOnAssoc, [], true, { elementsOnly: true });
   }
-  function finalizeConstraintsOnAssoc(element) {
+  function finalizeConstraintsOnAssoc( element ) {
     if (element.target && element._constraints) {
       edmUtils.finalizeReferentialConstraints(csn, element, options, info);
 
-      if(element._constraints?._partnerCsn) {
+      if (element._constraints?._partnerCsn) {
         // 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) {
+          if (element._constraints._partnerCsn.cardinality.src) {
+            // eslint-disable-next-line eqeqeq
             const srcMult = (element._constraints._partnerCsn.cardinality.src == 1) ? '0..1' : '*';
-            const newMult =
-              (element.cardinality?.min == 1 && element.cardinality?.max == 1)
+            const newMult
+              = (element.cardinality?.min == 1 && element.cardinality?.max == 1) // eslint-disable-line eqeqeq
+
                 ? '1'
                 : (element.cardinality?.max === '*' || element.cardinality?.max > 1)
                   ? '*'
                   : '0..1';
-            if(srcMult !== newMult) {
+            if (srcMult !== newMult)
               warning(null, element.$path, `Explicit source cardinality "${srcMult}" of "${element._constraints._partnerCsn._parent.name}/${element._constraints._partnerCsn.name}" conflicts with target cardinality "${newMult}"`);
-            }
           }
           else {
             // .. but only if the original assoc hasn't set src yet
             element._constraints._partnerCsn.cardinality.src = element.cardinality?.max ? element.cardinality.max : 1;
-            if(element.cardinality?.min !== undefined && element._constraints._partnerCsn.cardinality?.srcmin === undefined)
+            if (element.cardinality?.min !== undefined && element._constraints._partnerCsn.cardinality?.srcmin === undefined)
               element._constraints._partnerCsn.cardinality.srcmin = element.cardinality.min;
           }
         }
         else {
           element._constraints._partnerCsn.cardinality = { src: element.cardinality?.max ? element.cardinality.max : 1 };
-          if(element.cardinality?.min !== undefined)
+          if (element.cardinality?.min !== undefined)
             element._constraints._partnerCsn.cardinality.srcmin = element.cardinality.min;
         }
       }
@@ -907,20 +928,20 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     sub artifacts exposed by the initial type exposure
   */
   function convertExposedTypesOfOtherServicesIntoCrossReferences() {
-    if(options.odataXServiceRefs && options.isV4()) {
-      serviceRootNames.forEach(srn => {
-        schemaNames.forEach(fqSchemaName => {
-          if(fqSchemaName.startsWith(srn + '.')) {
-            const targetSchemaName = fqSchemaName.replace(srn + '.', '');
-            if(serviceRootNames.includes(targetSchemaName)) {
+    if (options.odataXServiceRefs && options.isV4()) {
+      serviceRootNames.forEach((srn) => {
+        schemaNames.forEach((fqSchemaName) => {
+          if (fqSchemaName.startsWith(`${srn}.`)) {
+            const targetSchemaName = fqSchemaName.replace(`${srn}.`, '');
+            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)) {
+              Object.keys(csn.definitions).forEach((dn) => {
+                if (dn.startsWith(fqSchemaName)) {
                   delete csn.definitions[dn];
                   delete reqDefs.definitions[dn];
                 }
               });
-              if(!schemas[fqSchemaName])
+              if (!schemas[fqSchemaName])
                 schemaNames.push(fqSchemaName);
               schemas[fqSchemaName] = edmUtils.createSchemaRef(serviceRoots, targetSchemaName);
             }
@@ -928,7 +949,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         });
       });
     }
-    schemaNames.sort((a,b)=>b.length-a.length);
+    schemaNames.sort((a, b) => b.length - a.length);
   }
 
   /*
@@ -953,8 +974,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       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(struct.kind === 'context' || struct.kind === 'service' || struct.$proxy)
+  function exposeTargetsAsProxiesOrSchemaRefs( struct ) {
+    if (struct.kind === 'context' || struct.kind === 'service' || struct.$proxy)
       return;
 
     // globalSchemaPrefix is the prefix for all proxy registrations and must not change
@@ -962,9 +983,9 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     // definitions which are directly below the root service ($mySchemaName is the root)
     const globalSchemaPrefix = whatsMyServiceRootName(struct.$mySchemaName);
     // if this artifact is a service member check its associations
-    if(globalSchemaPrefix) {
-      forEachGeneric(struct.items || struct, 'elements', element => {
-        if(!edmUtils.isNavigable(element))
+    if (globalSchemaPrefix) {
+      forEachGeneric(struct.items || struct, 'elements', (element) => {
+        if (!edmUtils.isNavigable(element))
           return;
         /*
          * Consider everything @cds.autoexpose: falsy to be a proxy candidate for now
@@ -999,36 +1020,37 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         // 1 | 1 | Cross service references and proxies are generated
 
         const targetSchemaName = element._target.$mySchemaName;
-        if(isProxyRequired(element)) {
-          if(options.isV4() && (options.odataProxies || options.odataXServiceRefs)) {
+        if (isProxyRequired(element)) {
+          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 ||
+            const 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) {
+            if (!proxy) {
+              if (targetSchemaName && options.odataXServiceRefs)
                 proxy = createSchemaRefFor(targetSchemaName);
-              }
+
               // create a proxy for a 'good' association only
-              else if(options.odataProxies && assocOK) {
+              else if (options.odataProxies && assocOK)
                 proxy = createProxyFor(element, targetSchemaName);
-              }
+
               proxy = registerProxy(proxy, element);
-            } else if(!assocOK) {
+            }
+            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 (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
             // 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)
+              if (proxy.kind === 'entity') {
+                if (!proxy.$isParamEntity)
                   populateProxyElements(element, proxy, getForeignKeyDefinitions(element));
                 element._target = proxy;
               }
@@ -1050,22 +1072,22 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       });
     }
 
-    function muteNavProp(elt, msg='std') {
+    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, '#': msg });
+      warning('odata-navigation', [ 'definitions', struct.name, 'elements', elt.name ],
+              { target: elt._target.name, service: globalSchemaPrefix, '#': msg });
     }
 
-    function createSchemaRefFor(targetSchemaName) {
-      let ref = csn.definitions[globalSchemaPrefix + '.' + targetSchemaName];
-      if(!ref) {
+    function createSchemaRefFor( targetSchemaName ) {
+      let ref = csn.definitions[`${globalSchemaPrefix}.${targetSchemaName}`];
+      if (!ref)
         ref = edmUtils.createSchemaRef(serviceRoots, targetSchemaName);
-      }
+
 
       return ref;
     }
 
-    function createProxyFor(assoc, targetSchemaName) {
+    function createProxyFor( assoc, targetSchemaName ) {
       // 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
@@ -1076,13 +1098,13 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
       // 1) construct the proxy definition
       // proxyDefinitionName: strip the serviceName and replace '.' with '_'
-      let defName =
-        `${assoc._target.name.replace(proxySchemaName + '.', '').replace(/\./g, '_')}`;
+      const 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) };
+        ? 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' : '');
@@ -1094,77 +1116,78 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       setProp(proxy, '$hasEntitySet', false);
       setProp(proxy, '$exposedTypes', Object.create(null));
       // copy all annotations of the target to the proxy
-      Object.entries(assoc._target).forEach(([k, v]) => {
-        if(k[0] === '@' && k !== '@open')
+      Object.entries(assoc._target).forEach(([ k, v ]) => {
+        if (k[0] === '@' && k !== '@open')
           proxy[k] = v;
       });
 
       // 2) create the elements and $keys
-      if(isParamProxy) {
+      if (isParamProxy) {
         // Reset param proxy elements to expose element tree
-        const elements = proxy.elements;
+        const { elements } = proxy;
         proxy.elements = Object.create(null);
         populateProxyElements(assoc, proxy, elements);
       }
-      else
+      else {
         populateProxyElements(assoc, proxy, assoc._target.$keys);
+      }
       return proxy;
-
     }
 
     // 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) {
+    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) {
-      Object.values(elements).forEach(e => {
+    function populateProxyElements( assoc, proxy, elements ) {
+      Object.values(elements).forEach((e) => {
         if (isEdmPropertyRendered(e, options)) {
           let newElt = proxy.elements[e.name];
-          if(!newElt) {
-            if(csnUtils.isAssocOrComposition(e)) {
-              if(!e.on && e.keys) {
-                if(options.odataNoTransitiveProxies)
+          if (!newElt) {
+            if (csnUtils.isAssocOrComposition(e)) {
+              if (!e.on && e.keys) {
+                if (options.odataNoTransitiveProxies)
                   newElt = convertManagedAssocIntoStruct(e);
                 else
                   newElt = createProxyOrSchemaRefForManagedAssoc(e);
               }
               else {
-                info(null, ['definitions', struct.name, 'elements', assoc.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)');
+                info(null, [ 'definitions', struct.name, 'elements', assoc.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 = Object.create(null);
-              Object.keys(e).forEach(prop => newElt[prop] = e[prop])
+              Object.keys(e).forEach((prop) => {
+                newElt[prop] = e[prop];
+              });
             }
-            if(newElt) {
+            if (newElt) {
               initElement(newElt, e.name, proxy);
               proxy.elements[newElt.name] = newElt;
 
-              if(csnUtils.isStructured(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, proxy.$proxyShortName + '_' + newElt.name,
-                                          proxy.$mySchemaName, newElt.key, !!(newElt.key && newElt.elements));
+                exposeStructTypeForProxyOf(newElt, `${proxy.$proxyShortName}_${newElt.name}`,
+                                           proxy.$mySchemaName, newElt.key, !!(newElt.key && newElt.elements));
               }
-              if(newElt.key)
+              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
+        return dict;
       }, Object.create(null));
 
       // If 'node' exists and has a structured type that is not exposed in 'service', (because the type is
@@ -1174,11 +1197,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       // 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 = false, forceToNotNull = false) {
-
-        if(node.type && isBuiltinType(node.type))
+      function exposeStructTypeForProxyOf( node, artificialName,
+                                           typeSchemaName = fallBackSchemaName,
+                                           isKey = false, forceToNotNull = false ) {
+        if (node.type && isBuiltinType(node.type))
           return;
 
         // Always expose types referred to by a proxy, never reuse an eventually existing type
@@ -1191,43 +1213,46 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           // 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 type has been exposed in a schema use this type
+          if (typeDef.$proxyTypes && typeDef.$proxyTypes[globalSchemaPrefix]) {
+            // if type has been exposed in a schema use this type
             typeClone = typeDef.$proxyTypes[globalSchemaPrefix];
           }
           else {
-              // Set the correct name
+            // Set the correct name
             let typeId = artificialName; // the artificialName has no namespace, it's the element
-            if(node.type) {
+            if (node.type) {
               // same as for proxies, use schema or namespace, 'root' is last resort
               typeSchemaName = typeDef.$mySchemaName || edmUtils.getSchemaPrefix(node.type);
-              typeId = node.type.replace(typeSchemaName + '.', '').replace(/\./g, '_');
+              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 + '.', '');
+              if (myServiceRootName)
+                typeSchemaName = typeSchemaName.replace(`${myServiceRootName}.`, '');
             }
 
-            if(edmUtils.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);
 
-              typeClone = cloneStructTypeForProxy(typeSchemaName, `${typeSchemaName}.${typeId}`, typeDef);
-              if(typeClone) {
+              typeClone = cloneStructTypeForProxy(`${typeSchemaName}.${typeId}`);
+              if (typeClone) {
                 // Recurse into elements of 'type' (if any)
-                typeClone.elements && Object.entries(typeClone.elements).forEach(([elemName, elem]) => {
+                if (typeClone.elements) {
+                  Object.entries(typeClone.elements).forEach(([ elemName, elem ]) => {
                   // if this is a foreign key element, 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'] ||
-                      (elem['@odata.foreignKey4'] && !typeClone.elements[elem['@odata.foreignKey4']].$exposed))
-                    exposeStructTypeForProxyOf(proxy, elem, `${typeId}_${elemName}`,
-                        typeSchemaName, isKey, forceToNotNull);
-                });
-                if(!typeDef.$proxyTypes)
+                    // TODO: expose types of assoc.keys and don't rely on exposed foreign keys
+                    if (!elem['@odata.foreignKey4'] ||
+                      (elem['@odata.foreignKey4'] && !typeClone.elements[elem['@odata.foreignKey4']].$exposed)) {
+                      exposeStructTypeForProxyOf(elem, `${typeId}_${elemName}`,
+                                                 typeSchemaName, isKey, forceToNotNull);
+                    }
+                  });
+                }
+                if (!typeDef.$proxyTypes)
                   typeDef.$proxyTypes = Object.create(null);
                 typeDef.$proxyTypes[globalSchemaPrefix] = typeClone;
               }
@@ -1236,7 +1261,7 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
               // 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
@@ -1253,12 +1278,12 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
             // 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)
+            if (typeClone.elements)
               node.elements = typeClone.elements;
           }
         }
 
-        function cloneStructTypeForProxy(typeSchemaName, name, typeDef) {
+        function cloneStructTypeForProxy( name ) {
           // Create type with empty elements
           const type = {
             kind: 'type',
@@ -1267,56 +1292,60 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           };
           setProp(type, '$mySchemaName', typeSchemaName);
           setProp(type, '$exposedBy', 'proxyExposure');
-          if(typeDef['@open'] !== undefined)
+          if (typeDef['@open'] !== undefined)
             type['@open'] = typeDef['@open'];
 
-          typeDef.elements && Object.entries(typeDef.elements).forEach( ([elemName, elem]) => {
-            if(!elem.target) {
-              type.elements[elemName] = Object.create(null);
-              Object.keys(elem).forEach(prop => type.elements[elemName][prop] = elem[prop])
-            }
-            else if(elem.keys && !elem.on) {
+          if (typeDef.elements) {
+            Object.entries(typeDef.elements).forEach( ([ elemName, elem ]) => {
+              if (!elem.target) {
+                type.elements[elemName] = Object.create(null);
+                Object.keys(elem).forEach((prop) => {
+                  type.elements[elemName][prop] = elem[prop];
+                });
+              }
+              else if (elem.keys && !elem.on) {
               // a primary key can never be an unmanaged association
-              type.elements[elemName] = createProxyOrSchemaRefForManagedAssoc(elem);
-            }
-            if(forceToNotNull) {
-              const newElt = type.elements[elemName];
-              if(newElt.target) {
-                if (newElt.cardinality === undefined)
-                  newElt.cardinality = {};
-                newElt.cardinality.min = 1;
+                type.elements[elemName] = createProxyOrSchemaRefForManagedAssoc(elem);
               }
-              // if odata-spec-violation-key-null is checking on min>1, this can be an else
-              newElt.notNull = true;
-            }
-            setProp(type.elements[elemName], 'name', elem.name);
-          });
+              if (forceToNotNull) {
+                const newElt = type.elements[elemName];
+                if (newElt.target) {
+                  if (newElt.cardinality === undefined)
+                    newElt.cardinality = {};
+                  newElt.cardinality.min = 1;
+                }
+                // if odata-spec-violation-key-null is checking on min>1, this can be an else
+                newElt.notNull = true;
+              }
+              setProp(type.elements[elemName], 'name', elem.name);
+            });
+          }
           return type;
         }
       }
 
       // Convert a managed association into a structured type and
       // eliminate nested foreign key associations
-      function convertManagedAssocIntoStruct(e) {
-        let newElt = cloneCsnNonDict(e, options);
+      function convertManagedAssocIntoStruct( e ) {
+        const newElt = cloneCsnNonDict(e, options);
         newElt.elements = Object.create(null);
-                // remove all unwanted garbage
+        // remove all unwanted garbage
         delete newElt.keys;
         delete newElt.target;
         delete newElt.type;
         // if this association has no keys or if it is a redirected parameterized entity,
         // use the primary keys of the target
-        let keys = (!e._target.$isParamEntity && e.keys) ||
-          Object.keys(e._target.$keys).map(k => { return { ref: [k] } });
-        keys.forEach(k => {
+        const keys = (!e._target.$isParamEntity && e.keys) ||
+          Object.keys(e._target.$keys).map(k => ({ ref: [ k ] }));
+        keys.forEach((k) => {
           let art = e._target || csnUtils.getCsnDef(e.target);
-          for(let ps of k.ref) {
+          for (const ps of k.ref)
             art = art.elements[ps];
-          }
+
           // art is in the target side, clone it and remove key property
-          let cloneArt = cloneCsnNonDict(art, options);
+          const cloneArt = cloneCsnNonDict(art, options);
           setProp(cloneArt, 'name', art.name);
-          if(e.key)
+          if (e.key)
             cloneArt.notNull = true;
           delete cloneArt.key;
           newElt.elements[art.name] = cloneArt;
@@ -1330,28 +1359,27 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       //    the proxy that is just being created targets back into
       //    its own serice
       // 2) or if no proxy for this source schema has been created yet
-      function createProxyOrSchemaRefForManagedAssoc(e) {
-
-        let proxy = e._target;
-        let newElt = cloneCsnNonDict(e, options);
+      function createProxyOrSchemaRefForManagedAssoc( e ) {
+        let newProxy = e._target;
+        const newElt = cloneCsnNonDict(e, options);
 
-        if(isProxyRequired(e)) {
-          proxy = getProxyForTargetOf(e);
-          if(!proxy) {
+        if (isProxyRequired(e)) {
+          newProxy = getProxyForTargetOf(e);
+          if (!newProxy) {
             // option odataXServiceRefs has precedence over odataProxies
-            if(e._target.$mySchemaName && options.odataXServiceRefs) {
-              proxy = createSchemaRefFor(e._target.$mySchemaName);
+            if (e._target.$mySchemaName && options.odataXServiceRefs) {
+              newProxy = createSchemaRefFor(e._target.$mySchemaName);
             }
-            else if(options.odataProxies) {
-              proxy = createProxyFor(e, e._target.$mySchemaName);
-              if(!e._target.$isParamEntity)
-                populateProxyElements(e, proxy, getForeignKeyDefinitions(e));
+            else if (options.odataProxies) {
+              newProxy = createProxyFor(e, e._target.$mySchemaName);
+              if (!e._target.$isParamEntity)
+                populateProxyElements(e, newProxy, getForeignKeyDefinitions(e));
             }
-            proxy = registerProxy(proxy, e);
+            newProxy = registerProxy(newProxy, e);
           }
         }
-        if(proxy === undefined) {
-          proxy = e._target;
+        if (!newProxy) {
+          newProxy = e._target;
           // no proxy: no navigation
           edmUtils.assignAnnotation(newElt, '@odata.navigable', false);
         }
@@ -1367,9 +1395,9 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         finalizeConstraintsOnAssoc(e);
         setProp(newElt, '_constraints', e._constraints);
         setProp(newElt, '_selfReferences', []);
-        if(proxy.kind === 'entity') {
-          newElt.target = proxy.name;
-          setProp(newElt, '_target', proxy);
+        if (newProxy.kind === 'entity') {
+          newElt.target = newProxy.name;
+          setProp(newElt, '_target', newProxy);
         }
         return newElt;
       }
@@ -1395,34 +1423,34 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
       the same service name 'S', which implies that they are always exposed
       in the same Edm => no proxy required.
     */
-    function isProxyRequired(element) {
+    function isProxyRequired( element ) {
       const targetSchemaName = element._target.$mySchemaName;
       // longest match for service name
-      return (!element._target.$proxy && globalSchemaPrefix !== targetSchemaName) ?
-        ((targetSchemaName &&
-          globalSchemaPrefix === whatsMyServiceRootName(targetSchemaName)) ? false : true) : false;
+      return (!element._target.$proxy && globalSchemaPrefix !== targetSchemaName)
+        ? (!((targetSchemaName &&
+          globalSchemaPrefix === whatsMyServiceRootName(targetSchemaName)))) : false;
     }
 
     // read a proxy from the elements target
-    function getProxyForTargetOf(element) {
+    function getProxyForTargetOf( element ) {
       return element._target.$cachedProxy && element._target.$cachedProxy[globalSchemaPrefix];
     }
 
     // register the proxy at the elements target
-    function registerProxy(proxy, element) {
-      if(proxy === undefined)
+    function registerProxy( proxy, element ) {
+      if (proxy === undefined)
         return undefined;
 
       setProp(proxy, '$globalSchemaPrefix', globalSchemaPrefix);
       setProp(proxy, '$origin', element);
 
-      const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
+      const fqProxyName = `${proxy.$globalSchemaPrefix}.${proxy.name}`;
 
-      if(!element._target.$cachedProxy)
+      if (!element._target.$cachedProxy)
         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');
+      if (getProxyForTargetOf(element)) {
+        info(null, [ 'definitions', struct.name, 'elements', element.name ],
+             { name: fqProxyName }, 'Proxy EDM entity type $(NAME) has already been registered');
       }
       else {
         determineEntitySet(proxy);
@@ -1434,12 +1462,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   }
 
   function mergeProxiesIntoModel() {
-    proxyCache.forEach(proxy => {
+    proxyCache.forEach((proxy) => {
+      const fqProxyName = `${proxy.$globalSchemaPrefix}.${proxy.name}`;
+      const fqSchemaName = `${proxy.$globalSchemaPrefix}.${proxy.$mySchemaName}`;
 
-      const fqProxyName = proxy.$globalSchemaPrefix + '.' + proxy.name;
-      const fqSchemaName = proxy.$globalSchemaPrefix + '.' + proxy.$mySchemaName;
-
-      if(proxy.kind === 'entity') {
+      if (proxy.kind === 'entity') {
         finalizeProxyContainments(proxy);
         // collect all schemas even for newly exposed types
         // (that may reside in another subcontext schema), but only once
@@ -1449,73 +1476,71 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         // followed by all namespaces that are potentially exposed by the exposed types
         // don't forget to prepend the global namespace prefix
         // schemas are ordered in csn2edm.js for each service
-        Object.keys(proxy.$exposedTypes).forEach(t =>
-          schemaSet.add(proxy.$globalSchemaPrefix + '.' + edmUtils.getSchemaPrefix(t)));
-        schemaSet.forEach(schemaName => {
-          if(!schemas[schemaName]) {
+        Object.keys(proxy.$exposedTypes).forEach(t => schemaSet.add(`${proxy.$globalSchemaPrefix}.${edmUtils.getSchemaPrefix(t)}`));
+        schemaSet.forEach((schemaName) => {
+          if (!schemas[schemaName]) {
             schemas[schemaName] = { kind: 'schema', name: schemaName };
             schemaNames.push(schemaName);
           }
         });
         const alreadyRegistered = csn.definitions[fqProxyName];
-        if(!alreadyRegistered) {
+        if (!alreadyRegistered) {
           csn.definitions[fqProxyName] = proxy;
           reqDefs.definitions[fqProxyName] = proxy;
-          setProp(proxy, '$path', ['definitions', fqProxyName]);
-          Object.entries(proxy.$exposedTypes).forEach(([tn, v]) => {
-            const fqtn = proxy.$globalSchemaPrefix + '.' + tn;
-            if(csn.definitions[fqtn] === undefined) {
+          setProp(proxy, '$path', [ 'definitions', fqProxyName ]);
+          Object.entries(proxy.$exposedTypes).forEach(([ tn, v ]) => {
+            const fqtn = `${proxy.$globalSchemaPrefix}.${tn}`;
+            if (csn.definitions[fqtn] === undefined) {
               csn.definitions[fqtn] = v;
               reqDefs.definitions[fqtn] = v;
-              setProp(v, '$path', ['definitions', fqtn]);
+              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];
-          if(proxy.$origin._parent.$path)
-            loc = [...proxy.$origin._parent.$path, 'elements', proxy.$origin.name]
+          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)');
+               { name: proxy.name }, 'Created proxy EDM entity type $(NAME)');
         }
-        else if(alreadyRegistered && !alreadyRegistered.$proxy &&
+        else if (alreadyRegistered && !alreadyRegistered.$proxy &&
           alreadyRegistered.kind !== 'entity') {
-          warning('odata-definition-exists', ['definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name],
-            { '#': 'proxy', name: fqProxyName, kind: alreadyRegistered.kind });
+          warning('odata-definition-exists', [ 'definitions', proxy.$origin._parent.name, 'elements', proxy.$origin.name ],
+                  { '#': 'proxy', name: fqProxyName, kind: alreadyRegistered.kind });
         }
       }
-      else {
+      else if (!schemas[fqSchemaName]) {
         // it's a service reference, just add that reference proxy
-        if(!schemas[fqSchemaName]) {
-          schemas[fqSchemaName] = proxy;
-          schemaNames.push(fqSchemaName);
-          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....
+        schemas[fqSchemaName] = proxy;
+        schemaNames.push(fqSchemaName);
+        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....
     });
-    schemaNames.sort((a,b) => b.length-a.length);
+    schemaNames.sort((a, b) => b.length - a.length);
 
-    function finalizeProxyContainments(proxy) {
+    function finalizeProxyContainments( proxy ) {
       // initialise containments after all exposed types are collected
       // AND remove unfulfillable 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]
+      if (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];
     }
   }
 
@@ -1532,25 +1557,25 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         and do not render associations (this will include the foreign keys of
         the _isToContainer association).
   */
-  function initEdmKeyRefPaths(def, defName) {
-    if(def.$keys) {
+  function initEdmKeyRefPaths( def, defName ) {
+    if (def.$keys) {
       setProp(def, '$edmKeyPaths', []);
       // for all key elements that shouldn't be ignored produce the paths
       edmUtils.foreach(def.$keys, k => !(k._isToContainer && k._selfReferences.length), (k, kn) => {
-        if(isEdmPropertyRendered(k, options) &&
+        if (isEdmPropertyRendered(k, options) &&
          !(options.isV2() && k['@Core.MediaType'])) {
-          if(options.isV4() && options.isStructFormat) {
+          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 || (options.renderForeignKeys && !k.target))
+            if (!options.renderForeignKeys || (options.renderForeignKeys && !k.target))
               def.$edmKeyPaths.push(...produceKeyRefPaths(k, kn, [ 'definitions', defName, 'elements', kn ]));
           }
           // In v2/v4 flat, associations are never rendered
-          else if(!k.target) {
-            def.$edmKeyPaths.push([kn]);
+          else if (!k.target) {
+            def.$edmKeyPaths.push([ kn ]);
           }
           // check toplevel key for spec violations
-          checkKeySpecViolations(k, ['definitions', defName, 'elements', k.name]);
+          checkKeySpecViolations(k, [ 'definitions', defName, 'elements', k.name ]);
         }
       });
     }
@@ -1565,11 +1590,11 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         navprops to be key ref.
       If element is of scalar type, return it as an array.
     */
-    function produceKeyRefPaths(eltCsn, prefix, path) {
+    function produceKeyRefPaths( eltCsn, prefix, path ) {
       const keyPaths = [];
       // we want to point to the element in the entity which is the first path step
-      const location = def.$path.concat(['elements']).concat(prefix.split('/')[0]);
-      if(!isEdmPropertyRendered(eltCsn, options)) {
+      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 ],
         //    `${struct.name}: OData V4 primary key path: "${prefix}" is unexposed by one of these annotations "${annos}"` );
@@ -1583,25 +1608,25 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         elements = finalType?.elements || finalType?.items?.elements;
       }
       if (elements) {
-        Object.entries(elements).forEach(([eltName, elt]) => {
-          if(!elt.$visited) {
+        Object.entries(elements).forEach(([ eltName, elt ]) => {
+          if (!elt.$visited) {
             setProp(elt, '$visited', true);
             let newRefs = [];
             // if the foreign keys are explicitly requested, ignore associations and use the flat foreign key instead
             // ignore nested unmanaged associations
-            if((!options.renderForeignKeys || (options.renderForeignKeys && !elt.target)) && !(elt.target && elt.on))
+            if ((!options.renderForeignKeys || (options.renderForeignKeys && !elt.target)) && !(elt.target && elt.on))
               newRefs = produceKeyRefPaths(elt, prefix + options.pathDelimiter + eltName, path);
-            if(newRefs.length) {
+            if (newRefs.length) {
               keyPaths.push(...newRefs);
-            // check path step key for spec violations
+              // check path step key for spec violations
               const pathSegment = `${prefix}/${eltName}`;
               checkKeySpecViolations(elt, location, pathSegment);
             }
             delete elt.$visited;
-          } else {
+          }
+          else {
             error('odata-key-recursive', path, { name: prefix });
           }
-
         });
       }
       /* If element is a managed association (can't be anything else),
@@ -1609,38 +1634,37 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
          This also implies that the association itself is never added into the
          list of primary key refs
       */
-      else if(eltCsn.target && !eltCsn.on) {
+      else if (eltCsn.target && !eltCsn.on) {
         // if this association has no keys or if it is a redirected parameterized entity,
         // 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 => {
+        const keys = (!eltCsn._target.$isParamEntity && eltCsn.keys) ||
+          Object.keys(eltCsn._target.$keys).map(k => ({ ref: [ k ] }));
+        let pathSegment = prefix;
+        keys.forEach((k) => {
           let art = eltCsn._target || csnUtils.getCsnDef(eltCsn.target);
-          for(let ps of k.ref) {
+          for (const ps of k.ref) {
             art = art.elements[ps];
-            pathSegment += '/' + art.name
+            pathSegment += `/${art.name}`;
             checkKeySpecViolations(art, location, pathSegment);
-            if(art.type && !isBuiltinType(art.type)) {
+            if (art.type && !isBuiltinType(art.type))
               art = art._type || csnUtils.getCsnDef(art.type);
-            }
           }
           keyPaths.push(...produceKeyRefPaths(art, prefix + options.pathDelimiter + k.ref.join(options.pathDelimiter), path));
         });
       }
       else {
-        keyPaths.push([prefix]);
+        keyPaths.push([ prefix ]);
       }
       return keyPaths;
     }
 
-    function checkKeySpecViolations(elt, location, pathSegment) {
+    function checkKeySpecViolations( elt, location, pathSegment ) {
       // Nullability
       const eltDef = elt.items || elt;
-      if((!elt.key && (eltDef.notNull === undefined || eltDef.notNull === false)) ||
+      if ((!elt.key && (eltDef.notNull === undefined || eltDef.notNull === false)) ||
            elt.key && (eltDef.notNull !== undefined && eltDef.notNull === false)) {
         message('odata-spec-violation-key-null', location,
-          {name: pathSegment ? pathSegment : elt.name, '#': !pathSegment ? 'std' : 'scalar'});
+                { name: pathSegment || elt.name, '#': !pathSegment ? 'std' : 'scalar' });
       }
       // many is either directly on elements or on the type
       // due to added proxy types it might be that the type can't be found in definitions
@@ -1649,32 +1673,46 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         !isBuiltinType(elt.type) &&
         csn.definitions[elt.type] &&
         csnUtils.getFinalTypeInfo(elt.type).items);
-      if(type ||
+      if (type ||
         (options.odataFormat !== 'flat' && !options.odataForeignKeys) &&
          elt.cardinality?.max && elt.cardinality.max !== 1) {
         // many primary key can be induced by a many parameter of a view
         message('odata-spec-violation-key-array', location,
-          {
-            name: pathSegment ? pathSegment : elt.name,
-            value: cardinality2str(elt),
-            '#': elt.target ? 'assoc' : 'std'
-          });
+                {
+                  name: pathSegment || elt.name,
+                  value: cardinality2str(elt),
+                  '#': elt.target ? 'assoc' : 'std',
+                });
       }
       // type
-      if(!elt.elements) {
-        if(!type)
+      if (!elt.elements) {
+        if (!type)
           type = isBuiltinType(elt.type) ? elt : csn.definitions[elt.type];
 
         // check for legal scalar types, proxy exposed structured types are not resolvable in CSN
         // V2 allows any Edm.PrimitiveType (even Double and Binary), V4 is more specific:
-        if(options.isV4() && type && !type.target && 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,
-            '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)) {
+            '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'});
+                    {
+                      name: pathSegment, type: type.type, id: edmType, '#': pathSegment ? 'std' : 'scalar',
+                    });
           }
         }
       }
@@ -1708,26 +1746,26 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     Path="items/subitems/subitems/up_" Target="Header/items/subitems"/>
     Path="items/subitems/subitems/toG" Target="G"/>
   */
-  function initEdmNavPropBindingTargets(def) {
-    if(def.$hasEntitySet) {
+  function initEdmNavPropBindingTargets( def ) {
+    if (def.$hasEntitySet) {
       forEachGeneric(def.items || def, 'elements', (element) => {
-        produceTargetPath([edmUtils.getBaseName(def.name)], element, def);
+        produceTargetPath([ edmUtils.getBaseName(def.name) ], element, def);
       });
     }
 
-    function produceTargetPath(prefix, elt, curDef) {
-      const newPrefix = [...prefix, elt.name];
-      if(isEdmPropertyRendered(elt, options)) {
+    function produceTargetPath( prefix, elt, curDef ) {
+      const newPrefix = [ ...prefix, elt.name ];
+      if (isEdmPropertyRendered(elt, options)) {
         // Assoc can never be a derived TypeDefinition, no need to
         // unroll derived type chains for assocs
-        if(elt.target && !elt.$visited) {
-          if(!elt._target.$edmTgtPaths)
+        if (elt.target && !elt.$visited) {
+          if (!elt._target.$edmTgtPaths)
             setProp(elt._target, '$edmTgtPaths', []);
           // 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)
           // 3) it's no external reference
-          if(!elt.$externalRef &&
+          if (!elt.$externalRef &&
              !elt._target.$hasEntitySet &&
              !elt._isToContainer &&
              curDef !== elt._target) {
@@ -1740,10 +1778,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         }
         else {
           // 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 && !elt.$visited) {
+
+          if (elt && elt.elements && !elt.$visited) {
             setProp(elt, '$visited', true);
             Object.values(elt.elements).forEach(e => produceTargetPath(newPrefix, e, curDef));
             delete elt.$visited;
@@ -1753,8 +1791,8 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     }
   }
 
-  function initEdmNavPropBindingPaths(def) {
-    if(options.isV4() &&def.$hasEntitySet) {
+  function initEdmNavPropBindingPaths( def ) {
+    if (options.isV4() && def.$hasEntitySet) {
       let npbs = [];
       forEachGeneric(def.items || def, 'elements', (element) => {
         npbs = npbs.concat(produceNavigationPath(element, def));
@@ -1763,50 +1801,52 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     }
 
     // collect all paths originating from this element that end up in an entity set
-    function produceNavigationPath(elt, curDef) {
+    function produceNavigationPath( elt, curDef ) {
       let npbs = [];
       const prefix = elt.name;
-      if(isEdmPropertyRendered(elt, options)) {
+      if (isEdmPropertyRendered(elt, options)) {
         // Assoc can never be a derived TypeDefinition, no need to
         // unroll derived type chains for assocs
-        if(elt.target && !elt.$visited) {
+        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)
           // 3) it's no external reference
-          if(!elt.$externalRef &&
+          if (!elt.$externalRef &&
              !elt._target.$hasEntitySet &&
              !elt._isToContainer &&
              curDef !== elt._target) {
             // follow elements in the target but avoid cycles
             setProp(elt, '$visited', true);
-            Object.values(elt._target.elements).forEach(e => npbs = npbs.concat(produceNavigationPath(e, elt._target)));
+            Object.values(elt._target.elements).forEach((e) => {
+              npbs = npbs.concat(produceNavigationPath(e, elt._target));
+            });
             delete elt.$visited;
           }
-          else if(!(options.odataContainment && options.isV4() && elt['@odata.contained'])) {
+          else if (!(options.odataContainment && options.isV4() && elt['@odata.contained'])) {
             // end point reached but must not be an external reference nor a proxy nor a composition itself
             // last assoc step must not be to-n and target a singleton
-            let p = undefined;
+            let path;
             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(def.name)) || elt._target.$edmTgtPaths[0];
+              if (elt._target.$edmTgtPaths && elt._target.$edmTgtPaths.length) {
+                path = elt._target.$edmTgtPaths.find(p => p[0] === edmUtils.getBaseName(def.name)) || elt._target.$edmTgtPaths[0];
               }
-              else if(elt._target.$hasEntitySet) {
+              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 === def.$mySchemaName) ?
-                  [ baseName ] : [elt._target.$mySchemaName + '.EntityContainer', baseName];
+                path = (elt._target.$mySchemaName === def.$mySchemaName)
+                  ? [ baseName ] : [ `${elt._target.$mySchemaName}.EntityContainer`, baseName ];
               }
-              if(p) {
+              if (path) {
                 // if own struct and target have a set they either are in the same $mySchemaName or not
                 // if target is in another schema, target the full qualified entity set
                 const npb = {
                   Path: elt.name,
-                  Target: p.join('/')
+                  Target: path.join('/'),
                 };
                 npbs.push( npb );
               }
@@ -1817,61 +1857,65 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
         }
         else {
           // 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 && !elt.$visited) {
+
+          if (elt && elt.elements && !elt.$visited) {
             setProp(elt, '$visited', true);
-            Object.values(elt.elements).forEach(e => npbs = npbs.concat(produceNavigationPath(e, curDef)));
+            Object.values(elt.elements).forEach((e) => {
+              npbs = npbs.concat(produceNavigationPath(e, curDef));
+            });
             delete elt.$visited;
           }
         }
       }
-      npbs.forEach(p => p.Path = prefix + '/' + p.Path );
+      npbs.forEach((p) => {
+        p.Path = `${prefix}/${p.Path}`;
+      });
       return npbs;
     }
   }
 
-  function determineEntitySet(def) {
+  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(def.$hasEntitySet === undefined) {
+    if (def.$hasEntitySet === undefined) {
       const hasEntitySet = def.kind === 'entity' && !(options.isV4() && edmUtils.isContainee(def)) && !def.$proxy;
       setProp(def, '$hasEntitySet', hasEntitySet);
     }
   }
 
-  function finalize(def, defName) {
+  function finalize( def, defName ) {
     // 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
     // 4. assign @Validation.AllowedValues to enums
-    const path = ['definitions', defName];
+    const defLocation = [ 'definitions', defName ];
     edmUtils.assignAnnotation(def, '@Core.Description', def.doc);
     markCollection(def);
     mapCdsToEdmProp(def);
-    annotateAllowedValues(def, path);
-    if (def.returns)  {
+    annotateAllowedValues(def, defLocation);
+    if (def.returns) {
       markCollection(def.returns);
       mapCdsToEdmProp(def.returns);
-      annotateAllowedValues(def.returns, [...path, 'returns']);
+      annotateAllowedValues(def.returns, [ ...defLocation, 'returns' ]);
     }
-    forEachMemberRecursively(def, (member, _memberName, _prop, path) => {
+    forEachMemberRecursively(def, (member, _memberName, _prop, location) => {
       edmUtils.assignAnnotation(member, '@Core.Description', member.doc);
       markCollection(member);
       mapCdsToEdmProp(member);
-      annotateAllowedValues(member, path);
+      annotateAllowedValues(member, location);
       ComputedDefaultValue(member);
       if (member.returns) {
         edmUtils.assignAnnotation(member.returns, '@Core.Description', member.returns.doc);
         markCollection(member.returns);
         mapCdsToEdmProp(member.returns);
-        annotateAllowedValues(member.returns, [...path, 'returns']);
+        annotateAllowedValues(member.returns, [ ...location, 'returns' ]);
       }
-    }, path);
+    }, defLocation);
     // mark members that need to be rendered as collections
-    function markCollection(obj) {
+    function markCollection( obj ) {
       const items = obj.items || csn.definitions[obj.type] && csn.definitions[obj.type].items;
       if (items) {
         edmUtils.assignProp(obj, '_NotNullCollection', items.notNull !== undefined ? items.notNull : true);
@@ -1886,48 +1930,46 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     - has no value but the base type is cds.String, use the
       symbol as value
     */
-    function annotateAllowedValues(node, path) {
+    function annotateAllowedValues( node, location ) {
       let typeDef = node;
-      if(!node.enum && node.type && !isBuiltinType(node.type))
+      if (!node.enum && node.type && !isBuiltinType(node.type))
         typeDef = csn.definitions[node.type];
-      if(typeDef?.enum) {
+      if (typeDef?.enum) {
         const enumValue = [];
-        for(const enumSymbol in typeDef.enum) {
+        for (const enumSymbol in typeDef.enum) {
           const result = { '@Core.SymbolicName': enumSymbol };
           let enumSymbolDef = typeDef.enum[enumSymbol];
-          while(enumSymbolDef && !enumSymbolDef.$visited && enumSymbolDef['#']) {
+          while (enumSymbolDef && !enumSymbolDef.$visited && enumSymbolDef['#']) {
             setProp(enumSymbolDef, '$visited', true);
             enumSymbolDef = typeDef.enum[enumSymbolDef['#']];
           }
           // reset visited
-          for(const es in typeDef.enum)
+          for (const es in typeDef.enum)
             delete typeDef.enum[es].$visited;
 
-          if(enumSymbolDef) {
-            if(enumSymbolDef.val !== undefined) {
+          if (enumSymbolDef) {
+            if (enumSymbolDef.val !== undefined) {
               // 'null' value is represented spec conform as empty record in AllowedValues collection
               result.Value = enumSymbolDef.val;
               enumValue.push(result);
             }
-            else {
-              if(typeDef.type === 'cds.String') {
+            else if (typeDef.type === 'cds.String') {
               // the symbol is used as value for type 'cds.String'
-                result.Value = enumSymbol;
-                enumValue.push(result);
-              }
-              else if(node.kind !== 'annotation') {
-                // omit the entry and warn
-                warning('odata-enum-missing-value', path,
-                  { name: enumSymbol, anno: '@Validation.AllowedValues', type: typeDef.type },
-                  'Expected enum element $(NAME) of type $(TYPE) to have a value, not added to $(ANNO)');
-              }
+              result.Value = enumSymbol;
+              enumValue.push(result);
+            }
+            else if (node.kind !== 'annotation') {
+              // omit the entry and warn
+              warning('odata-enum-missing-value', location,
+                      { name: enumSymbol, anno: '@Validation.AllowedValues', type: typeDef.type },
+                      'Expected enum element $(NAME) of type $(TYPE) to have a value, not added to $(ANNO)');
             }
           }
           else { // enumSymbolDef not found
             // omit the entry and warn
-            warning('odata-enum-missing-value', path,
-              { name: enumSymbol, anno: '@Validation.AllowedValues', type: typeDef.type },
-              'Expected enum element $(NAME) of type $(TYPE) to have a value, not added to $(ANNO)');
+            warning('odata-enum-missing-value', location,
+                    { name: enumSymbol, anno: '@Validation.AllowedValues', type: typeDef.type },
+                    'Expected enum element $(NAME) of type $(TYPE) to have a value, not added to $(ANNO)');
           }
 
           // Can't rely that @description has already been renamed to @Core.Description
@@ -1937,11 +1979,10 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
           if (desc)
             result['@Core.Description'] = desc;
         }
-        if(enumValue.length > 0)
+        if (enumValue.length > 0)
           edmUtils.assignAnnotation(node, '@Validation.AllowedValues', enumValue);
       }
     }
-
   }
 
   // If containment in V4 is active, annotations that would be assigned to the containees
@@ -1949,48 +1990,47 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
   // 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 pullupCapabilitiesAnnotations(rootContainer) {
-
-    if(!options.odataCapabilitiesPullup)
+  function pullupCapabilitiesAnnotations( rootContainer ) {
+    if (!options.odataCapabilitiesPullup)
       return;
     // @Capabilities is applicable to EntitySet/Collection only
-    if(!rootContainer.$hasEntitySet)
+    if (!rootContainer.$hasEntitySet)
       return;
 
-    const isRecursiveContainment =
-      !!(rootContainer.$containerNames && rootContainer.$containeeAssociations &&
+    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 ||
+    const isRootNode
+      = !!(!rootContainer.$containerNames ||
           rootContainer.$containerNames && rootContainer.$containerNames.length === 0);
 
-    if(!isRecursiveContainment && !isRootNode)
+    if (!isRecursiveContainment && !isRootNode)
       return;
 
     const rootRestrictions = [];
     addContainmentAnnotationsRecursively([], rootContainer);
-    if(rootRestrictions.length)
+    if (rootRestrictions.length)
       rootContainer[NavResAnno] = rootRestrictions;
 
-    function addContainmentAnnotationsRecursively(prefix, container) {
-      if(container.$containeeAssociations) {
+    function addContainmentAnnotationsRecursively( prefix, container ) {
+      if (container.$containeeAssociations) {
         // copy or create container restrictions, don't modify original
-        const localRestrictions = container[NavResAnno] ?
-          cloneAnnotationValue(container[NavResAnno]) : []
+        const localRestrictions = container[NavResAnno]
+          ? cloneAnnotationValue(container[NavResAnno]) : [];
 
         // prefix the existing navigation property restrictions on the container
-        if(prefix.length) {
-          localRestrictions.forEach(npe => {
-            if(npe.NavigationProperty &&
+        if (prefix.length) {
+          localRestrictions.forEach((npe) => {
+            if (npe.NavigationProperty &&
                npe.NavigationProperty['='] &&
                typeof npe.NavigationProperty['='] === 'string') {
-              applyTransformations({ definitions: { npe }}, {
+              applyTransformations({ definitions: { npe } }, {
                 '=': (parent, prop, value) => {
                   parent[prop] = prefix.concat(value).join('.');
-                }
+                },
               });
             }
           });
@@ -1998,34 +2038,32 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
 
         setProp(container, '$visited', true);
         // collect capabilities from containees
-        container.$containeeAssociations.forEach(entry => {
+        container.$containeeAssociations.forEach((entry) => {
           const { assoc, path } = entry;
           const containee = assoc._target;
 
-          if(edmUtils.isNavigable(assoc) && isMyServiceRequested(containee.name) || containee.$proxy) {
+          if (edmUtils.isNavigable(assoc) && isMyServiceRequested(containee.name) || containee.$proxy) {
             const localAssocPath = path.join('.');
-            let navPropEntry= localRestrictions.find(p =>
-                p.NavigationProperty && p.NavigationProperty['='] === prefix.concat(localAssocPath).join('.'));
+            let navPropEntry = localRestrictions.find(p => p.NavigationProperty && p.NavigationProperty['='] === prefix.concat(localAssocPath).join('.'));
             const hasEntry = !!navPropEntry;
 
-            if(!hasEntry) {
-              navPropEntry =  { NavigationProperty: { '=': prefix.concat(localAssocPath).join('.') } };
-            }
+            if (!hasEntry)
+              navPropEntry = { NavigationProperty: { '=': prefix.concat(localAssocPath).join('.') } };
+
 
             const props = Object.entries(containee);
             let newEntry = false;
-            capabilities.forEach(c => {
-              if(edmUtils.mergeIntoNavPropEntry(c, navPropEntry, prefix.concat(path), props))
+            capabilities.forEach((c) => {
+              if (edmUtils.mergeIntoNavPropEntry(c, navPropEntry, prefix.concat(path), props))
                 newEntry = true;
             });
 
-            if(newEntry && !hasEntry) {
+            if (newEntry && !hasEntry)
               localRestrictions.push(navPropEntry);
-            }
 
-            if(!containee.$visited) {
+
+            if (!containee.$visited)
               addContainmentAnnotationsRecursively(prefix.concat(path), containee);
-            }
           }
         });
 
@@ -2046,95 +2084,97 @@ function initializeModel(csn, _options, messageFunctions, requestedServiceNames=
     parameter, a warning is raised, Core.OptionalParameter requires that all optional
     parameters appear rightmost.
   */
-  function annotateOptionalActFuncParams(def, defName) {
-    if(!isBetaEnabled(options, 'optionalActionFunctionParameters'))
+  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')
+    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) {
+    if (def.actions) {
+      for (const an in def.actions) {
         const a = def.actions[an];
-        iterateParams(a, loc.concat(['actions', an, 'params' ]));
+        iterateParams(a, loc.concat([ 'actions', an, 'params' ]));
       }
     }
 
-    function iterateParams(def, loc) {
+    function iterateParams( action, location ) {
       let optPns = [];
-      def.params && Object.values(def.params).forEach(p => {
+      if (action.params) {
+        Object.values(action.params).forEach((p) => {
         // user assigned annotation, don't touch it
-        if(Object.keys(p).some(a => a.startsWith('@Core.OptionalParameter') && p[a] !== null)) {
-          optPns.push(p);
-        }
-        // default value automatically makes param optional
-        else if(p.default) {
-          if(p.default.val)
-            edmUtils.assignAnnotation(p, '@Core.OptionalParameter.DefaultValue', p.default.val);
-          else
+          if (Object.keys(p).some(a => a.startsWith('@Core.OptionalParameter') && p[a] !== null)) {
+            optPns.push(p);
+          }
+          // 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', '');
+            optPns.push(p);
+          }
+          // if no default is available, nullable makes param optional
+          else if (!p.notNull) {
             edmUtils.assignAnnotation(p, '@Core.OptionalParameter.$Type', '');
-          optPns.push(p);
-        }
-        // if no default is available, nullable makes param optional
-        else if(!p.notNull) {
-          edmUtils.assignAnnotation(p, '@Core.OptionalParameter.$Type', '');
-          optPns.push(p);
-
-        }
-        else {
+            optPns.push(p);
+          }
+          else {
           // this is a mandatory parameter, warn about all previously collected optional parameters
-          optPns.forEach(p => {
-            const type = p.items?.type || p.type;
-            if(type !== special$self)
-              warning('odata-parameter-order', loc.concat(p.name));
-          });
-          optPns = [];
-        }
-      });
+            optPns.forEach((op) => {
+              const type = op.items?.type || op.type;
+              if (type !== special$self)
+                warning('odata-parameter-order', location.concat(op.name));
+            });
+            optPns = [];
+          }
+        });
+      }
     }
   }
 
-  //////////////////////////////////////////////////////////////////////
+  // ////////////////////////////////////////////////////////////////////
   //
   // Helper section starts here
   //
 
 
-  function mapCdsToEdmProp(obj) {
+  function mapCdsToEdmProp( obj ) {
     if (obj.type && isBuiltinType(obj.type) && !obj.target && !obj.targetAspect) {
-      let edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
+      const edmType = edmUtils.mapCdsToEdmType(obj, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
       edmUtils.assignProp(obj, '_edmType', edmType);
-    } else if (obj._isCollection && (obj.items && isBuiltinType(csnUtils.getFinalTypeInfo(obj.items.type)?.type))) {
-      let edmType = edmUtils.mapCdsToEdmType(obj.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType'], obj.$path);
+    }
+    else if (obj._isCollection && (obj.items && isBuiltinType(csnUtils.getFinalTypeInfo(obj.items.type)?.type))) {
+      const edmType = edmUtils.mapCdsToEdmType(obj.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType'], obj.$path);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }
     // This is the special case when we have array of array, but will not be supported in the future
     else if (obj._isCollection && obj.items && obj.items.type && obj.items.items && isBuiltinType(csnUtils.getFinalTypeInfo(obj.items.items.type)?.type)) {
-      let edmType = edmUtils.mapCdsToEdmType(obj.items.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
+      const edmType = edmUtils.mapCdsToEdmType(obj.items.items, messageFunctions, _options.odataVersion === 'v2', obj['@Core.MediaType']);
       edmUtils.assignProp(obj, '_edmType', edmType);
     }
   }
 
-  function ComputedDefaultValue(member) {
+  function ComputedDefaultValue( member ) {
     if (member.default && !csn['@Core.ComputedDefaultValue']) {
       let def = member.default;
       let noTailExpr = false;
-      if(def.xpr) {
+      if (def.xpr) {
         let i = 0;
         // consume all unary signs
-        while(def.xpr[i] === '-' || def.xpr[i] === '+') i++;
+        while (def.xpr[i] === '-' || def.xpr[i] === '+')
+          i++;
         // noTailExpr is true if there is nothing behind the next token in the stream
-        noTailExpr = i < def.xpr.length-1;
+        noTailExpr = i < def.xpr.length - 1;
         def = def.xpr[i];
       }
       // it is a computed value if it is not a simple value or an annotation
-      if(!((def.val !== undefined && !noTailExpr) || def['#'])) {
+      if (!((def.val !== undefined && !noTailExpr) || def['#']))
         edmUtils.assignAnnotation(member, '@Core.ComputedDefaultValue', true);
-      }
     }
   }
 }
 
 module.exports = {
   initializeModel,
-}
+};