@sap/cds-compiler 4.1.2 → 4.2.4

package/lib/edm/csn2edm.js

@@ -6,32 +6,36 @@
 const NAVPROP_TRENNER = '_';
 const VALUELIST_NAVPROP_PREFIX = '';
 
-const edmUtils = require('./edmUtils.js')
+const edmUtils = require('./edmUtils.js');
 const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp, isBetaEnabled } = require('../base/model');
 const { cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { makeMessageFunction } = require('../base/messages');
-const { EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap, getEdm } = require('./edm.js');
+const {
+  EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap, getEdm,
+} = require('./edm.js');
 
 /*
 OData V2 spec 06/01/2017 PDF version is available from here:
 https://msdn.microsoft.com/en-us/library/dd541474.aspx
 */
 
-function csn2edm(_csn, serviceName, _options) {
-  return csn2edmAll(_csn, _options, [ serviceName ])[ serviceName ];
+function csn2edm( _csn, serviceName, _options ) {
+  return csn2edmAll(_csn, _options, [ serviceName ])[serviceName];
 }
 
-function csn2edmAll(_csn, _options, serviceNames=undefined) {
+function csn2edmAll( _csn, _options, serviceNames = undefined ) {
   // get us a fresh model copy that we can work with
   const csn = cloneCsnNonDict(_csn, _options);
   const special$self = !csn?.definitions?.$self && '$self';
 
   // use original options for messages; cloned CSN for semantic location
   const messageFunctions = makeMessageFunction(csn, _options, 'to.edmx');
-  const { info, warning, error, message, throwWithError } = messageFunctions;
+  const {
+    info, warning, error, message, throwWithError,
+  } = messageFunctions;
   checkCSNVersion(csn, _options);
 
   let rc = Object.create(null);
@@ -40,7 +44,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
   // There is the need to assign the odata options because we would like to determine
   // whether to execute toFinalBaseType in the edmPreprocessor or not
   if (_csn.meta && _csn.meta.transformation === 'odata' && _csn.meta.options) {
-    if (!csn.meta) setProp(csn, 'meta', Object.create(null));
+    if (!csn.meta)
+      setProp(csn, 'meta', Object.create(null));
     setProp(csn.meta, 'options', _csn.meta.options);
   }
 
@@ -50,35 +55,36 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     reqDefs,
     whatsMyServiceRootName,
     fallBackSchemaName,
-    options ] = initializeModel(csn, _options, messageFunctions, serviceNames);
+    options,
+  ] = initializeModel(csn, _options, messageFunctions, serviceNames);
 
   const mergedVocabularies = translate.mergeOdataVocabularies(options, message);
 
   const Edm = getEdm(options, messageFunctions);
 
-  const v = options.v;
-  if(Object.keys(allServices).length === 0) {
+  const { v } = options;
+  if (Object.keys(allServices).length === 0) {
     info(null, null, 'No Services in model');
     return rc;
   }
 
-  if(serviceNames === undefined)
+  if (serviceNames === undefined)
     serviceNames = options.serviceNames;
-  if(serviceNames) {
-    serviceNames.forEach(name => {
-      let serviceCsn = allServices[name];
-      if(serviceCsn == undefined) {
+  if (serviceNames) {
+    serviceNames.forEach((name) => {
+      const serviceCsn = allServices[name];
+      if (!serviceCsn)
         warning(null, null, { name }, 'No service definition with name $(NAME) found in the model');
-      }
-      else {
+
+      else
         rc[name] = createEdm(serviceCsn);
-      }
     });
   }
   else {
     rc = Object.values(allServices).reduce((services, serviceCsn) => {
       services[serviceCsn.name] = createEdm(serviceCsn);
-      return services; }, rc);
+      return services;
+    }, rc);
   }
 
   throwWithError();
@@ -87,16 +93,20 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
   //--------------------------------------------------------------------------------
   // embedded functions
   //--------------------------------------------------------------------------------
-  function createEdm(serviceCsn) {
-
-    function baseName(str, del) { let l = str.lastIndexOf(del);   // eslint-disable-line no-unused-vars
-      return (l >= 0) ? str.slice(l+del.length, str.length) : str; }
+  function createEdm( serviceCsn ) {
+    // eslint-disable-next-line no-unused-vars
+    function baseName( str, del ) {
+      const l = str.lastIndexOf(del);
+      return (l >= 0) ? str.slice(l + del.length, str.length) : str;
+    }
 
     // if we have a real alias take it, otherwise use basename of service
     // let alias = serviceCsn.alias || baseName(baseName(serviceCsn.name, '::'), '.');
     // FIXME: UI5 cannot deal with spec conforming simpleid alias names
 
-    function markRendered(def) { setProp(def, '$isRendered', true); }
+    function markRendered( def ) {
+      setProp(def, '$isRendered', true);
+    }
 
     const service = new Edm.DataServices(v);
     /** @type {object} */
@@ -137,26 +147,24 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       entries.
       -----------------------------------------------*/
     let LeadSchema;
-    const fqSchemaXRef = [serviceCsn.name];
-    const whatsMySchemaName = function(n) {
-      return fqSchemaXRef.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') ? sn : rc, undefined);
-    }
+    const fqSchemaXRef = [ serviceCsn.name ];
+    const whatsMySchemaName = n => fqSchemaXRef.reduce((acc, sn) => (!acc && n && n.startsWith(`${sn}.`) ? sn : acc), undefined);
 
     // tunnel schema xref and servicename in options to edm.Typebase to rectify
     // type references that are eventually also prefixed with the service schema name.
     options.serviceName = serviceCsn.name;
-      // List of all schema names in this service, including the service itself
+    // List of all schema names in this service, including the service itself
     options.whatsMySchemaName = whatsMySchemaName;
     options.whatsMyServiceRootName = whatsMyServiceRootName;
 
     let xServiceRefs = {};
     const UsedTypes = {};
-    function collectUsedType(csn, typeName = (csn.items?.type || csn.type)) {
-      if(typeName) {
-        if(UsedTypes[typeName])
-          UsedTypes[typeName].push(csn)
+    function collectUsedType( def, typeName = (def.items?.type || def.type) ) {
+      if (typeName) {
+        if (UsedTypes[typeName])
+          UsedTypes[typeName].push(def);
         else
-          UsedTypes[typeName] = [ csn ];
+          UsedTypes[typeName] = [ def ];
       }
     }
 
@@ -167,34 +175,34 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         fqName: serviceCsn.name,
         _csn: serviceCsn,
         container: true,
-        definitions: Object.create(null)
-      }
+        definitions: Object.create(null),
+      },
     };
 
-    if(options.isV4()) {
+    if (options.isV4()) {
       // Add additional schema containers as sub contexts to the service
-      Object.entries(allSchemas).forEach(([fqName, art]) => {
-        if(serviceCsn.name === whatsMyServiceRootName(fqName) &&
-          fqName.startsWith(serviceCsn.name + '.')) {
-          if(art.kind === 'reference')
+      Object.entries(allSchemas).forEach(([ fqName, art ]) => {
+        if (serviceCsn.name === whatsMyServiceRootName(fqName) &&
+          fqName.startsWith(`${serviceCsn.name}.`)) {
+          if (art.kind === 'reference')
             fqSchemaXRef.push(fqName);
-          if(art.kind === 'schema') {
+          if (art.kind === 'schema') {
             fqSchemaXRef.push(fqName);
             // Strip the toplevel service schema name (see comment above)
-            const name = fqName.replace(serviceCsn.name + '.', '');
+            const name = fqName.replace(`${serviceCsn.name}.`, '');
             subSchemaDictionary[name] = {
               name,
               fqName,
               _csn: art,
               container: false,
-              definitions: Object.create(null)
+              definitions: Object.create(null),
             };
           }
         }
       }, subSchemaDictionary);
 
       // Sort schema names in reverse order to allow longest match
-      fqSchemaXRef.sort((a,b) => b.length-a.length);
+      fqSchemaXRef.sort((a, b) => b.length - a.length);
 
       // Fill the schemas and references, fqSchemaXRef must be complete
       populateSchemas(subSchemaDictionary);
@@ -202,14 +210,14 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       // Bring the schemas in alphabetical order, service first, root last
       const sortedSchemaNames = Object.keys(subSchemaDictionary).filter(n => n !== fallBackSchemaName && n !== serviceCsn.name).sort();
-      if(subSchemaDictionary[fallBackSchemaName])
+      if (subSchemaDictionary[fallBackSchemaName])
         sortedSchemaNames.push(fallBackSchemaName);
 
       // Finally create the schemas and register them in the service.
       LeadSchema = createSchema(subSchemaDictionary[serviceCsn.name]);
       service.registerSchema(serviceCsn.name, LeadSchema);
 
-      sortedSchemaNames.forEach(name => {
+      sortedSchemaNames.forEach((name) => {
         const schema = subSchemaDictionary[name];
         service.registerSchema(schema.fqName, createSchema(schema));
       });
@@ -223,30 +231,32 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
     /*
       EntityContainer duplicate check
     */
-    service._children.forEach(c => {
-      c._ec && Object.entries(c._ec._registry).forEach((([setName, arr]) => {
-        if(arr.length > 1) {
-          error(null, null, {
-            name: c._edmAttributes.Namespace,
-            id: setName,
-            names: arr.map(a => a.getDuplicateMessage())
-          }, 'Namespace $(NAME): Duplicate entries in EntityContainer with Name=$(ID) for $(NAMES)');
-        }
-      }));
+    service._children.forEach((c) => {
+      if (c._ec) {
+        Object.entries(c._ec._registry).forEach((([ setName, arr ]) => {
+          if (arr.length > 1) {
+            error(null, null, {
+              name: c._edmAttributes.Namespace,
+              id: setName,
+              names: arr.map(a => a.getDuplicateMessage()),
+            }, 'Namespace $(NAME): Duplicate entries in EntityContainer with Name=$(ID) for $(NAMES)');
+          }
+        }));
+      }
     });
     // Create annotations and distribute into Schemas, merge vocabulary cross refs into xServiceRefs
-    addAnnotations(xServiceRefs);
+    addAnnotations2XServiceRefs();
 
     // Finally add cross service references into the EDM and extract the targetSchemaNames
     // for the type cross check
-    Object.values(xServiceRefs).forEach(ref => {
-      let r = new Edm.Reference(v, ref.ref);
-      r.append(new Edm.Include(v, ref.inc))
+    Object.values(xServiceRefs).forEach((ref) => {
+      const r = new Edm.Reference(v, ref.ref);
+      r.append(new Edm.Include(v, ref.inc));
       edm._defaultRefs.push(r);
     });
 
-    for(let typeName in UsedTypes) {
-      if(!isBuiltinType(typeName)) {
+    for (const typeName in UsedTypes) {
+      if (!isBuiltinType(typeName)) {
         let iTypeName = typeName;
         /*
           Report type ref, if the type is
@@ -255,31 +265,30 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             - not a type clash (reported in type exposure),
             - a @cds.external service member but can't be rendered
         */
-        if(!typeName.startsWith(serviceCsn.name + '.'))
-          iTypeName = serviceCsn.name + '.' + typeName;
+        if (!typeName.startsWith(`${serviceCsn.name}.`))
+          iTypeName = `${serviceCsn.name}.${typeName}`;
         const def = reqDefs.definitions[iTypeName];
 
         const usages = UsedTypes[typeName].filter(u => !u.$NameClashReported);
-        if(usages.length > 0 && def && !def.$isRendered && def['@cds.external']) {
+        if (usages.length > 0 && def && !def.$isRendered && def['@cds.external']) {
           message('odata-spec-violation-type', usages[0].$location,
-            {
-              type: typeName,
-              anno: '@cds.external',
-              name: serviceCsn.name,
-              code: def.elements ? 'Edm.ComplexType' : 'Edm.TypeDefinition',
-              version: options.isV4() ? '4.0' : '2.0',
-              '#': 'external'
-            }
-          );
+                  {
+                    type: typeName,
+                    anno: '@cds.external',
+                    name: serviceCsn.name,
+                    code: def.elements ? 'Edm.ComplexType' : 'Edm.TypeDefinition',
+                    version: options.isV4() ? '4.0' : '2.0',
+                    '#': 'external',
+                  });
         }
       }
     }
 
-    return edm
+    return edm;
 
     // Sort definitions into their schema container
-    function populateSchemas(schemas) {
-      Object.entries(reqDefs.definitions).forEach(([fqName, art]) => {
+    function populateSchemas( schemas ) {
+      Object.entries(reqDefs.definitions).forEach(([ fqName, art ]) => {
         // Identify service members by their definition name only, this allows
         // to let the internal object.name have the sub-schema name.
         // With nested services we must do a longest path match and check whether
@@ -292,16 +301,16 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // Add this definition to a (sub) schema, if it is not
         // a container (context, service) and
         // not marked to be ignored as schema member
-        if(mySchemaName &&
+        if (mySchemaName &&
            serviceCsn.name === whatsMyServiceRootName(fqName, false) &&
            art.kind !== 'context' && art.kind !== 'service') {
-
           // Strip the toplevel serviceName from object.name
           // except if the schema name is the service name itself.
           // Proxy names are not prefixed, as they need to be reused.
-          if(mySchemaName !== serviceCsn.name) {
-            fqName = art.name = fqName.replace(serviceCsn.name + '.', '');
-            mySchemaName = mySchemaName.replace(serviceCsn.name + '.', '');
+          if (mySchemaName !== serviceCsn.name) {
+            art.name = fqName.replace(`${serviceCsn.name}.`, '');
+            fqName = art.name;
+            mySchemaName = mySchemaName.replace(`${serviceCsn.name}.`, '');
           }
           schemas[mySchemaName].definitions[fqName] = art;
         }
@@ -332,30 +341,31 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         };
       */
 
-      return Object.entries(allSchemas).reduce((references, [fqName, art]) => {
+      return Object.entries(allSchemas).reduce((references, [ fqName, art ]) => {
         // add references
-        if(art.kind === 'reference' &&
+        if (art.kind === 'reference' &&
            whatsMySchemaName(fqName) &&
-           serviceCsn.name === whatsMyServiceRootName(fqName, false)) {
+           serviceCsn.name === whatsMyServiceRootName(fqName, false))
           references[art.inc.Namespace] = art;
-        }
+
         return references;
       }, {});
     }
 
     // Main schema creator function
-    function createSchema(schema) {
+    function createSchema( schema ) {
       /** @type {object} */
 
       // Same check for alias (if supported by us)
-      const reservedNames = ['Edm', 'odata', 'System', 'Transient'];
-      const loc = ['definitions', schema.name];
-      if(reservedNames.includes(schema.name))
+      const reservedNames = [ 'Edm', 'odata', 'System', 'Transient' ];
+      const loc = [ 'definitions', schema.name ];
+      if (reservedNames.includes(schema.name))
         message('odata-spec-violation-namespace', loc, { names: reservedNames });
-      if (schema.name.length > 511)
+      if (schema.name.length > 511) {
         message('odata-spec-violation-namespace', loc, { '#': 'length' });
+      }
       else {
-        schema.name.split('.').forEach(id => {
+        schema.name.split('.').forEach((id) => {
           if (!edmUtils.isODataSimpleIdentifier(id))
             message('odata-spec-violation-id', loc, { id });
         });
@@ -365,7 +375,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       const Schema = new Edm.Schema(v, schema.name, undefined /* unset alias */, schema._csn, /* annotations */ [], schema.container);
       const EntityContainer = Schema._ec || (LeadSchema && LeadSchema._ec);
       // now namespace and alias are used to create the fullQualified(name)
-      const schemaNamePrefix = schema.name + '.'
+      const schemaNamePrefix = `${schema.name}.`;
       const schemaAliasPrefix = schemaNamePrefix;
       const schemaCsn = schema;
       const navigationProperties = [];
@@ -376,49 +386,48 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
             Entity starts with 'localserviceNameized.' or ends with '_localized'
       */
       edmUtils.foreach(schemaCsn.definitions,
-        a => a.kind === 'entity' && !a.abstract && a.name.startsWith(schemaNamePrefix),
-        [createEntityTypeAndSet, markRendered]
-      );
+                       a => a.kind === 'entity' && !a.abstract && a.name.startsWith(schemaNamePrefix),
+                       [ createEntityTypeAndSet, markRendered ]);
       // create unbound actions/functions
       edmUtils.foreach(schemaCsn.definitions,
-        a => (a.kind === 'action' || a.kind === 'function') && a.name.startsWith(schemaNamePrefix),
-        [(options.isV4()) ? createActionV4 : createActionV2, markRendered]);
+                       a => (a.kind === 'action' || a.kind === 'function') && a.name.startsWith(schemaNamePrefix),
+                       [ (options.isV4()) ? createActionV4 : createActionV2, markRendered ]);
 
-    // create the complex types
+      // create the complex types
       edmUtils.foreach(schemaCsn.definitions,
-      a => edmUtils.isStructuredType(a) && a.name.startsWith(schemaNamePrefix),
-      [createComplexType, markRendered]);
+                       a => edmUtils.isStructuredType(a) && a.name.startsWith(schemaNamePrefix),
+                       [ createComplexType, markRendered ]);
 
-      if(options.isV4())
-      {
+      if (options.isV4()) {
         edmUtils.foreach(schemaCsn.definitions,
-        artifact => edmUtils.isDerivedType(artifact) &&
-        !artifact.target&&
+                         artifact => edmUtils.isDerivedType(artifact) &&
+        !artifact.target &&
         artifact.name.startsWith(schemaNamePrefix),
-          [createTypeDefinitionV4, markRendered]);
+                         [ createTypeDefinitionV4, markRendered ]);
       }
 
-      if(isBetaEnabled(options, 'odataTerms')) {
+      if (isBetaEnabled(options, 'odataTerms')) {
         edmUtils.foreach(schemaCsn.definitions,
-      a => a.kind === 'annotation' && a.name.startsWith(schemaNamePrefix),
-      createTerm);
+                         a => a.kind === 'annotation' && a.name.startsWith(schemaNamePrefix),
+                         createTerm);
       }
 
       // fetch all existing children names in a map
       const NamesInSchemaXRef = Schema._children.reduce((acc, cur) => {
         const name = cur._edmAttributes.Name;
-        if(acc[name] === undefined) {
+        if (acc[name] === undefined)
           acc[name] = [ cur ];
-        } else {
+
+        else
           acc[name].push(cur);
-        }
+
         return acc;
       }, Object.create(null) );
 
-      navigationProperties.forEach(np => {
-        if(options.isV4()) {
+      navigationProperties.forEach((np) => {
+        if (options.isV4()) {
         // V4: No referential constraints for Containment Relationships
-          if((!np.isContainment() || (options.renderForeignKeys)) && !np.isToMany())
+          if ((!np.isContainment() || (options.renderForeignKeys)) && !np.isToMany())
             np.addReferentialConstraintNodes();
         }
         else {
@@ -440,122 +449,126 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         This sentence expresses that an OData SERVICE must contain an entity container, but an EDMX is not required to have a container.
         Therefore it is absolutely legal and necessary to remove an empty container from the IR!
       */
-      if(Schema._ec && Schema._ec._children.length === 0) {
+      if (Schema._ec && Schema._ec._children.length === 0)
         Schema._children.splice(Schema._children.indexOf(Schema._ec), 1);
-      }
 
-      Object.entries(NamesInSchemaXRef).forEach(([name, refs]) => {
-        if(refs.length > 1) {
-          error(null, ['definitions', `${Schema._edmAttributes.Namespace}.${name}`], { name: Schema._edmAttributes.Namespace },
-          'Duplicate name in Schema $(NAME)');
+
+      Object.entries(NamesInSchemaXRef).forEach(([ name, refs ]) => {
+        if (refs.length > 1) {
+          error(null, [ 'definitions', `${Schema._edmAttributes.Namespace}.${name}` ], { name: Schema._edmAttributes.Namespace },
+                'Duplicate name in Schema $(NAME)');
         }
       });
 
       return Schema;
 
-      function createEntityTypeAndSet(entityCsn)
-      {
+      function createEntityTypeAndSet( entityCsn ) {
         const EntityTypeName = entityCsn.name.replace(schemaNamePrefix, '');
         const EntitySetName = edmUtils.getBaseName(entityCsn.$entitySetName || entityCsn.name);
         const isSingleton = edmUtils.isSingleton(entityCsn) && options.isV4();
         const [ properties, hasStream ] = createProperties(entityCsn);
 
-        const loc = ['definitions', entityCsn.name];
+        const location = [ 'definitions', entityCsn.name ];
         const type = `${schema.name}.${EntityTypeName}`;
-        if(properties.length === 0)
-          warning(null, loc, { type }, 'EDM EntityType $(TYPE) has no properties');
-        else if(entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
-          message('odata-spec-violation-no-key', loc);
+        if (properties.length === 0)
+          warning(null, location, { type }, 'EDM EntityType $(TYPE) has no properties');
+        else if (entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
+          message('odata-spec-violation-no-key', location);
 
-        if(!edmUtils.isODataSimpleIdentifier(EntityTypeName))
-          message('odata-spec-violation-id', loc, { id: EntityTypeName });
+        if (!edmUtils.isODataSimpleIdentifier(EntityTypeName))
+          message('odata-spec-violation-id', location, { id: EntityTypeName });
 
-        properties.forEach(p => {
-          const pLoc = [...loc, 'elements', p._edmAttributes.Name];
+        properties.forEach((p) => {
+          const pLoc = [ ...location, 'elements', p._edmAttributes.Name ];
           edmTypeCompatibilityCheck(p, pLoc);
-          if(p._edmAttributes.Name === EntityTypeName)
+          if (p._edmAttributes.Name === EntityTypeName)
             message('odata-spec-violation-property-name', pLoc, { meta: entityCsn.kind });
 
-          if(options.isV2() && p._isCollection && !p._csn.target)
+          if (options.isV2() && p._isCollection && !p._csn.target)
             message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
-          if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
+          if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name)) {
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
+          }
           else if (options.isV2() && /^(_|\d)/.test(p._edmAttributes.Name)) {
             // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
             message('odata-spec-violation-id', pLoc,
-            { prop: p._edmAttributes.Name[0], id: p._edmAttributes.Name, version: '2.0', '#': 'v2firstchar' });
+                    {
+                      prop: p._edmAttributes.Name[0], id: p._edmAttributes.Name, version: '2.0', '#': 'v2firstchar',
+                    });
           }
         });
 
         // construct EntityType attributes
-        const attributes = { Name : EntityTypeName };
+        const attributes = { Name: EntityTypeName };
 
         // CDXCORE-CDXCORE-173
-        if(options.isV2() && hasStream) {
+        if (options.isV2() && hasStream) {
           attributes['m:HasStream'] = true;
           edmUtils.assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
         }
 
         Schema.append(new Edm.EntityType(v, attributes, properties, entityCsn));
 
-        if (EntityContainer && entityCsn.$hasEntitySet)
-        {
+        if (EntityContainer && entityCsn.$hasEntitySet) {
           /** @type {object} */
           let containerEntry;
 
-          if(edmUtils.isSingleton(entityCsn) && options.isV4()) {
+          if (edmUtils.isSingleton(entityCsn) && options.isV4()) {
             containerEntry = new Edm.Singleton(v, { Name: EntitySetName, Type: fullQualified(EntityTypeName) }, entityCsn);
-            if(entityCsn['@odata.singleton.nullable'])
-              containerEntry._edmAttributes.Nullable= true;
+            if (entityCsn['@odata.singleton.nullable'])
+              containerEntry._edmAttributes.Nullable = true;
           }
           else {
             containerEntry = new Edm.EntitySet(v, { Name: EntitySetName, EntityType: fullQualified(EntityTypeName) }, entityCsn);
           }
 
           // V4: Create NavigationPropertyBinding in EntitySet
-          if(options.isV4()) {
-            entityCsn.$edmNPBs.forEach(npb => {
-              containerEntry.append(new Edm.NavigationPropertyBinding(v, npb))
+          if (options.isV4()) {
+            entityCsn.$edmNPBs.forEach((npb) => {
+              containerEntry.append(new Edm.NavigationPropertyBinding(v, npb));
             });
           }
           EntityContainer.register(containerEntry);
         }
 
         // put actions behind entity types in Schema/EntityContainer
-        entityCsn.actions && Object.entries(entityCsn.actions).forEach(([ n, a ]) => {
-          (options.isV4()) ? createActionV4(a, n, entityCsn)
-                          : createActionV2(a, n, entityCsn)
-        });
+        if (entityCsn.actions) {
+          Object.entries(entityCsn.actions).forEach(([ n, a ]) => {
+            if (options.isV4())
+              createActionV4(a, n, entityCsn);
+            else
+              createActionV2(a, n, entityCsn);
+          });
+        }
       }
 
-      function createComplexType(structuredTypeCsn)
-      {
+      function createComplexType( structuredTypeCsn ) {
         // V4 attributes: Name, BaseType, Abstract, OpenType
         const attributes = { Name: structuredTypeCsn.name.replace(schemaNamePrefix, '') };
 
         const complexType = new Edm.ComplexType(v, attributes, structuredTypeCsn);
         const elementsCsn = structuredTypeCsn.items || structuredTypeCsn;
         const properties = createProperties(elementsCsn, structuredTypeCsn)[0];
-        const loc = ['definitions', structuredTypeCsn.name];
+        const location = [ 'definitions', structuredTypeCsn.name ];
 
-        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', loc, { id: attributes.Name });
+        if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', location, { id: attributes.Name });
 
-        properties.forEach(p => {
-          const pLoc = [ ...loc, ...(structuredTypeCsn.items ? ['items', 'elements'] : [ 'elements' ]), p._edmAttributes.Name ];
+        properties.forEach((p) => {
+          const pLoc = [ ...location, ...(structuredTypeCsn.items ? [ 'items', 'elements' ] : [ 'elements' ]), p._edmAttributes.Name ];
           edmTypeCompatibilityCheck(p, pLoc);
-          if(p._edmAttributes.Name === complexType._edmAttributes.Name)
+          if (p._edmAttributes.Name === complexType._edmAttributes.Name)
             message('odata-spec-violation-property-name', pLoc, { meta: structuredTypeCsn.kind });
 
-          if(!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
+          if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
 
-          if(options.isV2()) {
-            if(p._isCollection && !p._csn.target)
+          if (options.isV2()) {
+            if (p._isCollection && !p._csn.target)
               message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
-            if(p._csn.target)
+            if (p._csn.target)
               message('odata-spec-violation-assoc', pLoc, { version: '2.0' });
           }
         });
@@ -573,86 +586,82 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
        *                              array of Edm Properties
        *                              hasStream : value of @Core.MediaType assignment
        */
-      function createProperties(elementsCsn, edmParentCsn=elementsCsn)
-      {
+      function createProperties( elementsCsn, edmParentCsn = elementsCsn ) {
         const props = [];
         let hasStream = false;
         const streamProps = [];
 
-        elementsCsn.elements && Object.entries(elementsCsn.elements).forEach(([elementName, elementCsn]) =>
-        {
-          if(elementCsn._edmParentCsn == undefined)
-            setProp(elementCsn, '_edmParentCsn', edmParentCsn);
+        if (elementsCsn.elements) {
+          Object.entries(elementsCsn.elements).forEach(([ elementName, elementCsn ]) => {
+            if (!elementCsn._edmParentCsn)
+              setProp(elementCsn, '_edmParentCsn', edmParentCsn);
 
-          if(elementCsn.target) {
-              // Foreign keys are part of the generic elementCsn.elements property creation
+            if (elementCsn.target) {
+            // Foreign keys are part of the generic elementCsn.elements property creation
 
               // This is the V4 edmx:NavigationProperty
               // gets rewritten for V2 in addAssociations()
 
               // suppress navprop creation only if @odata.navigable:false is not annotated.
               // (undefined !== false) still evaluates to true
-            if (!elementCsn._target.abstract && elementCsn['@odata.navigable'] !== false)
-              {
-              const navProp = new Edm.NavigationProperty(v, {
-                Name: elementName,
-                Type: elementCsn._target.name
-              }, elementCsn);
-              collectUsedType(elementCsn, elementCsn._target.name);
-              props.push(navProp);
+              if (!elementCsn._target.abstract && elementCsn['@odata.navigable'] !== false) {
+                const navProp = new Edm.NavigationProperty(v, {
+                  Name: elementName,
+                  Type: elementCsn._target.name,
+                }, elementCsn);
+                collectUsedType(elementCsn, elementCsn._target.name);
+                props.push(navProp);
                 // save the navProp in the global array for late constraint building
-              navigationProperties.push(navProp);
+                navigationProperties.push(navProp);
+              }
             }
-          }
             // render ordinary property if element is NOT ...
             // 1) ... annotated @cds.api.ignore
             // 2) ... annotated @odata.foreignKey4 and odataFormat: structured
 
-          else if(isEdmPropertyRendered(elementCsn, options))
-            {
-              // CDXCORE-CDXCORE-173
-              // V2: filter  @Core.MediaType
-            if ( options.isV2() && elementCsn['@Core.MediaType']) {
-              hasStream = elementCsn['@Core.MediaType'];
-              delete elementCsn['@Core.MediaType'];
+            else if (isEdmPropertyRendered(elementCsn, options)) {
+            // CDXCORE-CDXCORE-173
+            // V2: filter  @Core.MediaType
+              if ( options.isV2() && elementCsn['@Core.MediaType']) {
+                hasStream = elementCsn['@Core.MediaType'];
+                delete elementCsn['@Core.MediaType'];
                 // CDXCORE-CDXCORE-177:
                 // V2: don't render element but add attribute 'm:HasStream="true' to EntityType
                 // V4: render property type 'Edm.Stream'
-              streamProps.push(elementName);
-
-            } else {
-              collectUsedType(elementCsn);
-              props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
+                streamProps.push(elementName);
+              }
+              else {
+                collectUsedType(elementCsn);
+                props.push(new Edm.Property(v, { Name: elementName }, elementCsn));
+              }
             }
+          });
+        }
+        if (options.isV2()) {
+          if (streamProps.length > 1) { // TODO: why not mention 2.0 in text?
+            error(null, [ 'definitions', elementsCsn.name ], { names: streamProps, version: '2.0', anno: '@Core.MediaType' },
+                  'Expected only one element to be annotated with $(ANNO) for OData $(VERSION) but found $(NAMES)');
           }
-
-        });
-        if(options.isV2()) {
-          if(streamProps.length > 1) { // TODO: why not mention 2.0 in text?
-            error(null, ['definitions', elementsCsn.name], { names: streamProps, version: '2.0', anno: '@Core.MediaType' },
-                 'Expected only one element to be annotated with $(ANNO) for OData $(VERSION) but found $(NAMES)');
-          }
-          else if(streamProps.length === 1) {
-            info(null, ['definitions', elementsCsn.name], { id: streamProps[0], version: '2.0', anno: '@Core.MediaType' },
-                  'Property $(ID) annotated with $(ANNO) is removed from EDM for OData $(VERSION)');
+          else if (streamProps.length === 1) {
+            info(null, [ 'definitions', elementsCsn.name ], { id: streamProps[0], version: '2.0', anno: '@Core.MediaType' },
+                 'Property $(ID) annotated with $(ANNO) is removed from EDM for OData $(VERSION)');
           }
         }
         return [ props, hasStream ];
       }
 
-      function createTerm(termCsn) {
+      function createTerm( termCsn ) {
         const attributes = { Name: termCsn.name.replace(schemaNamePrefix, '') };
         const term = new Edm.Term(v, attributes, termCsn);
         Schema.append(term);
       }
 
       // V4 <TypeDefintion>
-      function createTypeDefinitionV4(typeCsn)
-      {
+      function createTypeDefinitionV4( typeCsn ) {
         // derived types are already resolved to base types
         const attributes = { Name: typeCsn.name.replace(schemaNamePrefix, '') };
-        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', ['definitions', typeCsn.name], { id: attributes.Name });
+        if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', [ 'definitions', typeCsn.name ], { id: attributes.Name });
 
         const typeDef = new Edm.TypeDefinition(v, attributes, typeCsn );
         edmTypeCompatibilityCheck(typeDef, [ 'definitions', typeCsn.name ]);
@@ -660,25 +669,24 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
       }
 
       // add bound/unbound actions/functions for V4
-      function createActionV4(actionCsn, _name, entityCsn=undefined)
-      {
+      function createActionV4( actionCsn, _name, entityCsn = undefined ) {
         const iAmAnAction = actionCsn.kind === 'action';
         const actionName = edmUtils.getBaseName(actionCsn.name);
-        const attributes = { Name: actionName, IsBound : false };
+        const attributes = { Name: actionName, IsBound: false };
 
-        const loc = entityCsn
-            ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
-            : [ 'definitions', actionCsn.name ];
+        const location = entityCsn
+          ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
+          : [ 'definitions', actionCsn.name ];
 
-        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', loc, { id: attributes.Name });
+        if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', location, { id: attributes.Name });
 
-        if(!iAmAnAction)
+        if (!iAmAnAction)
           attributes.IsComposable = false;
 
         /** @type {object} */
         const actionNode = (iAmAnAction) ? new Edm.Action(v, attributes)
-                                      : new Edm.FunctionDefinition(v, attributes);
+          : new Edm.FunctionDefinition(v, attributes);
 
         const bpType = entityCsn ? fullQualified(entityCsn.name) : undefined;
         /*
@@ -689,97 +697,91 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         */
 
         let bpName = 'in';
-        if(actionCsn.params) {
-          const entries =  Object.entries(actionCsn.params);
+        if (actionCsn.params) {
+          const entries = Object.entries(actionCsn.params);
           const firstParam = entries[0][1];
           const type = firstParam?.items?.type || firstParam?.type;
-          if(type === special$self) {
+          if (type === special$self) {
             bpName = entries[0][0];
             setProp(actionCsn, '$bindingParam', firstParam);
-            if(bpType) {
-              if(firstParam.items?.type)
+            if (bpType) {
+              if (firstParam.items?.type)
                 firstParam.items.type = bpType;
-              if(firstParam.type)
+              if (firstParam.type)
                 firstParam.type = bpType;
             }
-            if(!edmUtils.isODataSimpleIdentifier(bpName))
-              message('odata-spec-violation-id', [ ...loc, 'params', bpName ], { id: bpName });
+            if (!edmUtils.isODataSimpleIdentifier(bpName))
+              message('odata-spec-violation-id', [ ...location, 'params', bpName ], { id: bpName });
           }
         }
 
         // bpName is eventually used later for EntitySetPath
         // No explicit binding parameter, check (user defined) annotation value)
-        if(!actionCsn.$bindingParam) {
+        if (!actionCsn.$bindingParam) {
           const bpNameAnno = actionCsn['@cds.odata.bindingparameter.name'];
-          if(bpNameAnno != null) {
-            if(typeof bpNameAnno === 'string')
+          if (bpNameAnno != null) {
+            if (typeof bpNameAnno === 'string')
               bpName = bpNameAnno;
-            if(typeof bpNameAnno === 'object' && bpNameAnno['='])
+            if (typeof bpNameAnno === 'object' && bpNameAnno['='])
               bpName = bpNameAnno['='];
           }
-          if(!edmUtils.isODataSimpleIdentifier(bpName))
-            message('odata-spec-violation-id', [...loc, '@cds.odata.bindingparameter.name'], { id: bpName });
-          if(actionCsn.params && actionCsn.params[bpName]) {
-            error('duplicate-definition', [...loc, '@cds.odata.bindingparameter.name'], { '#': 'param', name: bpName });
-          }
+          if (!edmUtils.isODataSimpleIdentifier(bpName))
+            message('odata-spec-violation-id', [ ...location, '@cds.odata.bindingparameter.name' ], { id: bpName });
+          if (actionCsn.params && actionCsn.params[bpName])
+            error('duplicate-definition', [ ...location, '@cds.odata.bindingparameter.name' ], { '#': 'param', name: bpName });
         }
-        if(entityCsn != undefined)
-        {
+        if (entityCsn) {
           actionNode.setEdmAttribute('IsBound', true);
-          if(!actionCsn.$bindingParam) {
+          if (!actionCsn.$bindingParam) {
             // Binding Parameter: 'in' at first position in sequence, this is decisive!
-            if(actionCsn['@cds.odata.bindingparameter.collection'])
-              actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection:true/*, Nullable: false*/ } ));
+            if (actionCsn['@cds.odata.bindingparameter.collection'])
+              actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType, Collection: true/* , Nullable: false */ } ));
             else
-            actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType } ));
+              actionNode.append(new Edm.Parameter(v, { Name: bpName, Type: bpType } ));
           }
         }
-        else if(EntityContainer)// unbound => produce Action/FunctionImport
-        {
+        else if (EntityContainer) { // unbound => produce Action/FunctionImport
           /** @type {object} */
           const actionImport = iAmAnAction
-            ? new Edm.ActionImport(v, { Name: actionName, Action : fullQualified(actionName) })
-            : new Edm.FunctionImport(v, { Name: actionName, Function : fullQualified(actionName) });
+            ? new Edm.ActionImport(v, { Name: actionName, Action: fullQualified(actionName) })
+            : new Edm.FunctionImport(v, { Name: actionName, Function: fullQualified(actionName) });
 
           const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
-          if(rt) // add EntitySet attribute only if return type is a non abstract entity
-          {
+          if (rt) { // add EntitySet attribute only if return type is a non abstract entity
             const definition = schemaCsn.definitions[rt];
-            if(definition && definition.kind === 'entity' && !definition.abstract)
-            {
+            if (definition && definition.kind === 'entity' && !definition.abstract)
               actionImport.setEdmAttribute('EntitySet', edmUtils.getBaseName(rt));
-            }
           }
           EntityContainer.register(actionImport);
         }
 
         // Parameter Nodes
-        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn]) => {
-          const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
-          const pLoc = [ ...loc, 'params', p._edmAttributes.Name ];
-          if(!edmUtils.isODataSimpleIdentifier(parameterName))
-            message('odata-spec-violation-id', pLoc, { id: parameterName });
-          collectUsedType(parameterCsn);
-          edmTypeCompatibilityCheck(p, pLoc);
-          actionNode.append(p);
-        });
+        if (actionCsn.params) {
+          Object.entries(actionCsn.params).forEach(([ parameterName, parameterCsn ]) => {
+            const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
+            const pLoc = [ ...location, 'params', p._edmAttributes.Name ];
+            if (!edmUtils.isODataSimpleIdentifier(parameterName))
+              message('odata-spec-violation-id', pLoc, { id: parameterName });
+            collectUsedType(parameterCsn);
+            edmTypeCompatibilityCheck(p, pLoc);
+            actionNode.append(p);
+          });
+        }
 
         // return type if any
-        if(actionCsn.returns) {
+        if (actionCsn.returns) {
           actionNode._returnType = new Edm.ReturnType(v, actionCsn.returns);
           collectUsedType(actionCsn.returns);
-          edmTypeCompatibilityCheck(actionNode._returnType, [ ...loc, 'returns' ]);
+          edmTypeCompatibilityCheck(actionNode._returnType, [ ...location, 'returns' ]);
           // if binding type matches return type add attribute EntitySetPath
-          if(entityCsn != undefined && fullQualified(entityCsn.name) === actionNode._returnType._type) {
+          if (entityCsn && fullQualified(entityCsn.name) === actionNode._returnType._type)
             actionNode.setEdmAttribute('EntitySetPath', bpName);
-          }
         }
         Schema.addAction(actionNode);
       }
 
       // add bound/unbound actions/functions for V2
-      function createActionV2(actionCsn, name, entityCsn=undefined)
-      {
+      function createActionV2( actionCsn, name, entityCsn = undefined ) {
         /** @type {object} */
         const attributes = { Name: name.replace(schemaNamePrefix, '') };
         const functionImport = new Edm.FunctionImport(v, attributes );
@@ -795,117 +797,113 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           in the spec and advised mention it as in V4
         */
 
-        const loc = entityCsn
+        const location = entityCsn
           ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
           : [ 'definitions', actionCsn.name ];
 
-        if(!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', loc, { id: attributes.Name });
+        if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
+          message('odata-spec-violation-id', location, { id: attributes.Name });
 
         const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
-        if(rt) // add EntitySet attribute only if return type is an entity
-        {
+        if (rt) { // add EntitySet attribute only if return type is an entity
           const definition = schemaCsn.definitions[rt];
-          if(definition && definition.kind === 'entity')
-          {
+          if (definition && definition.kind === 'entity')
             functionImport.setEdmAttribute('EntitySet', rt.replace(schemaNamePrefix, ''));
-          }
         }
 
-        if(actionCsn.returns)
+        if (actionCsn.returns)
           functionImport.setEdmAttribute('ReturnType', getReturnType(actionCsn));
 
-        if(actionCsn.kind === 'function')
-          functionImport.setXml( {'m:HttpMethod': 'GET' });
-        else if(actionCsn.kind === 'action')
-          functionImport.setXml( {'m:HttpMethod': 'POST'});
+        if (actionCsn.kind === 'function')
+          functionImport.setXml( { 'm:HttpMethod': 'GET' });
+        else if (actionCsn.kind === 'action')
+          functionImport.setXml( { 'm:HttpMethod': 'POST' });
 
-        if(entityCsn != undefined)
-        {
+        if (entityCsn) {
           // Make bound function names always unique as per Ralf's recommendation
-          functionImport.setXml( {'sap:action-for':  fullQualified(entityCsn.name) } );
-          const name = entityCsn.name.replace(schemaNamePrefix, '') + '_' + functionImport._edmAttributes.Name;
-          functionImport.setEdmAttribute('Name', name);
+          functionImport.setXml( { 'sap:action-for': fullQualified(entityCsn.name) } );
+          const entityName = `${entityCsn.name.replace(schemaNamePrefix, '')}_${functionImport._edmAttributes.Name}`;
+          functionImport.setEdmAttribute('Name', entityName);
 
           // Binding Parameter: Primary Keys at first position in sequence, this is decisive!
           // V2 XML: Nullable=false is set because we reuse the primary key property for the parameter
           edmUtils.foreach(entityCsn.elements,
-            elementCsn => elementCsn.key && !elementCsn.target,
-            (elementCsn, elementName) => {
-              functionImport.append(new Edm.Parameter(v, { Name: elementName }, elementCsn, 'In' ));
-            }
-          );
+                           elementCsn => elementCsn.key && !elementCsn.target,
+                           (elementCsn, elementName) => {
+                             functionImport.append(new Edm.Parameter(v, { Name: elementName }, elementCsn, 'In' ));
+                           });
         }
 
         // is this still required?
-        Object.entries(actionCsn).forEach(([p, v]) => {
-          if (p.match(/^@sap\./))
-            functionImport.setXml( { ['sap:' + p.slice(5).replace(/\./g, '-')] : v });
+        Object.entries(actionCsn).forEach(([ key, val ]) => {
+          if (key.match(/^@sap\./))
+            functionImport.setXml( { [`sap:${key.slice(5).replace(/\./g, '-')}`]: val });
         });
         // then append all other parameters
         // V2 XML: Parameters that are not explicitly marked as Nullable or NotNullable in the CSN must become Nullable=true
         // V2 XML spec does only mention default Nullable=true for Properties not for Parameters so omitting Nullable=true let
         // the client assume that Nullable is false.... Correct Nullable Handling is done inside Parameter constructor
-        actionCsn.params && Object.entries(actionCsn.params).forEach(([parameterName, parameterCsn], i) => {
-          const type = parameterCsn?.items?.type || parameterCsn?.type;
-          if(i === 0 && type === special$self) {
+        if (actionCsn.params) {
+          Object.entries(actionCsn.params).forEach(([ parameterName, parameterCsn ], i) => {
+            const type = parameterCsn?.items?.type || parameterCsn?.type;
+            if (i === 0 && type === special$self) {
             // skip and remove the first parameter if it is a $self binding parameter to
             // omit annotation rendering later on
-            delete actionCsn.params[parameterName];
-          }
-          else {
-            const pLoc = [...loc, 'params', parameterName];
-            const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
-            collectUsedType(parameterCsn);
-            edmTypeCompatibilityCheck(param, pLoc);
-            if(!edmUtils.isODataSimpleIdentifier(parameterName))
-              message('odata-spec-violation-id', pLoc, { id: parameterName });
-
-          // only scalar or structured type in V2 (not entity)
-            if(param._type &&
+              delete actionCsn.params[parameterName];
+            }
+            else {
+              const pLoc = [ ...location, 'params', parameterName ];
+              const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
+              collectUsedType(parameterCsn);
+              edmTypeCompatibilityCheck(param, pLoc);
+              if (!edmUtils.isODataSimpleIdentifier(parameterName))
+                message('odata-spec-violation-id', pLoc, { id: parameterName });
+
+              // only scalar or structured type in V2 (not entity)
+              if (param._type &&
             !param._type.startsWith('Edm.') &&
             csn.definitions[param._type] &&
             !edmUtils.isStructuredType(csn.definitions[param._type]))
-              message('odata-spec-violation-param', pLoc, { version: '2.0' });
+                message('odata-spec-violation-param', pLoc, { version: '2.0' });
 
-            if(param._isCollection)
-              message('odata-spec-violation-array', pLoc, { version: '2.0' });
+              if (param._isCollection)
+                message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
-            functionImport.append(param);
-          }
-        });
+              functionImport.append(param);
+            }
+          });
+        }
 
-        if(EntityContainer)
+        if (EntityContainer)
           EntityContainer.register(functionImport);
 
-        function getReturnType(action)
-        {
+        function getReturnType( action ) {
           // it is safe to assume that either type or items.type are set
-          const returnsLoc = [ ...loc, 'returns'];
+          const returnsLoc = [ ...location, 'returns' ];
           const returns = action.returns.items || action.returns;
           let type = returns['@odata.Type'];
-          if(!type) {
+          if (!type) {
             type = returns.type;
             if (type) {
               collectUsedType(action.returns);
               if (!isBuiltinType(type) && csn.definitions[type].kind !== 'entity' && csn.definitions[type].kind !== 'type') {
                 message('odata-spec-violation-returns', returnsLoc, { kind: action.kind, version: '2.0' });
               }
-              else if(isBuiltinType(type)) {
+              else if (isBuiltinType(type)) {
                 type = edmUtils.mapCdsToEdmType(returns, messageFunctions, true);
-                if(type) {
+                if (type) {
                   const td = EdmPrimitiveTypeMap[type];
-                  if(td && !td.v2) {
+                  if (td && !td.v2) {
                     message('odata-spec-violation-type', returnsLoc,
-                    { type, version: '2.0', '#': 'incompatible' });
+                            { type, version: '2.0', '#': 'incompatible' });
                   }
                 }
                 else {
                   message('odata-spec-violation-type-unknown', returnsLoc, { type });
                 }
               }
-              if(action.returns._isCollection)
-                type = `Collection(${type})`
+              if (action.returns._isCollection)
+                type = `Collection(${type})`;
             }
             else {
               // type is missing
@@ -930,16 +928,15 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         add <End>, <ReferentialConstraint>, <Dependent> and <Principal> sub elements to <Association>
         add <AssociationSet> to the EntityContainer for each <Association>
       */
-      function addAssociationV2(navigationProperty)
-      {
+      function addAssociationV2( navigationProperty ) {
         let constraints = navigationProperty._csn._constraints;
         let parentName = navigationProperty._csn._edmParentCsn.name.replace(schemaNamePrefix, '');
         let plainAssocName = parentName + NAVPROP_TRENNER + navigationProperty._edmAttributes.Name.replace(VALUELIST_NAVPROP_PREFIX, '');
         let assocName = plainAssocName;
         let i = 1;
-        while(NamesInSchemaXRef[assocName] !== undefined) {
-          assocName = plainAssocName + '_' + i++;
-        }
+        while (NamesInSchemaXRef[assocName] !== undefined)
+          assocName = `${plainAssocName}_${i++}`;
+
 
         let fromRole = parentName;
         let toRole = navigationProperty._edmAttributes.Type.replace(schemaAliasPrefix, ''); // <= navprops type should be prefixed with alias
@@ -954,8 +951,8 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
         // from and to roles must be distinguishable (in case of self association entity E { toE: association to E; ... })
 
-        if(fromRole === toRole) {
-          if(constraints._partnerCsn)
+        if (fromRole === toRole) {
+          if (constraints._partnerCsn)
             fromRole += '1';
           else
             toRole += '1';
@@ -980,20 +977,20 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         */
 
         let reuseAssoc = false;
-        let forwardAssocCsn = constraints._partnerCsn;
-        if(forwardAssocCsn)
-        {
+        const forwardAssocCsn = constraints._partnerCsn;
+        if (forwardAssocCsn) {
           // This is a backlink, swap the roles and types, rewrite assocName
           [ fromRole, toRole ] = [ toRole, fromRole ];
           [ fromEntityType, toEntityType ] = [ toEntityType, fromEntityType ];
           [ fromEntitySet, toEntitySet ] = [ toEntitySet, fromEntitySet ];
 
           parentName = forwardAssocCsn._edmParentCsn.name.replace(schemaNamePrefix, '');
-          assocName = plainAssocName = parentName + NAVPROP_TRENNER + forwardAssocCsn.name.replace(VALUELIST_NAVPROP_PREFIX, '');
+          plainAssocName = parentName + NAVPROP_TRENNER + forwardAssocCsn.name.replace(VALUELIST_NAVPROP_PREFIX, '');
+          assocName = plainAssocName;
           i = 1;
-          while(NamesInSchemaXRef[assocName] !== undefined && !(NamesInSchemaXRef[assocName][0] instanceof Edm.Association)) {
-            assocName = plainAssocName + '_' + i++;
-          }
+          while (NamesInSchemaXRef[assocName] !== undefined && !(NamesInSchemaXRef[assocName][0] instanceof Edm.Association))
+            assocName = `${plainAssocName}_${i++}`;
+
 
           navigationProperty.setEdmAttribute('Relationship', fullQualified(assocName));
 
@@ -1002,111 +999,125 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
           constraints._multiplicity = edmUtils.determineMultiplicity(forwardAssocCsn);
         }
 
-        if(reuseAssoc)
+        if (reuseAssoc)
           return;
 
         // Create Association and AssociationSet if this is not a backlink association.
         // Store association at navigation property because in case the Ends must be modified
         // later by the partner (backlink) association
         const edmAssociation = new Edm.Association(v, { Name: assocName }, navigationProperty,
-                                        [ fromRole, fullQualified(fromEntityType) ],
-                                        [ toRole, fullQualified(toEntityType) ],
-                                        constraints._multiplicity );
-        if(NamesInSchemaXRef[assocName] === undefined) {
+                                                   [ fromRole, fullQualified(fromEntityType) ],
+                                                   [ toRole, fullQualified(toEntityType) ],
+                                                   constraints._multiplicity );
+        if (NamesInSchemaXRef[assocName] === undefined)
           NamesInSchemaXRef[assocName] = [ edmAssociation ];
-        }
-        else {
+
+        else
           NamesInSchemaXRef[assocName].push(edmAssociation);
-        }
+
         // Add ReferentialConstraints if any
-        if(!navigationProperty._isCollection && Object.keys(constraints.constraints).length > 0) {
+        if (!navigationProperty._isCollection && Object.keys(constraints.constraints).length > 0) {
           // A managed composition is treated as association
-          if(navigationProperty._csn.type === 'cds.Composition' && navigationProperty._csn.on) {
+          if (navigationProperty._csn.type === 'cds.Composition' && navigationProperty._csn.on) {
             edmAssociation.append(Edm.ReferentialConstraint.createV2(v,
-              toRole, fromRole, constraints.constraints));
+                                                                     toRole, fromRole, constraints.constraints));
           }
           else {
             edmAssociation.append(Edm.ReferentialConstraint.createV2(v,
-              fromRole, toRole, constraints.constraints));
+                                                                     fromRole, toRole, constraints.constraints));
           }
         }
 
         Schema.append(edmAssociation);
-        if(EntityContainer && !navigationProperty._targetCsn.$proxy) {
-          const assocSet =  new Edm.AssociationSet(v, { Name: assocName, Association: fullQualified(assocName) },
-            fromRole, toRole, fromEntitySet, toEntitySet);
-          if(navigationProperty._csn._SetAttributes)
+        if (EntityContainer && !navigationProperty._targetCsn.$proxy) {
+          const assocSet = new Edm.AssociationSet(v, { Name: assocName, Association: fullQualified(assocName) },
+                                                  fromRole, toRole, fromEntitySet, toEntitySet);
+          if (navigationProperty._csn._SetAttributes)
             assocSet.setSapVocabularyAsAttributes(navigationProperty._csn._SetAttributes);
           EntityContainer.register(assocSet);
         }
       }
 
       // produce a full qualified name replacing the namespace with the alias (if provided)
-      function fullQualified(name)
-      {
-        return schemaAliasPrefix + name.replace(schemaNamePrefix, '')
+      function fullQualified( name ) {
+        return schemaAliasPrefix + name.replace(schemaNamePrefix, '');
       }
     }
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
-    function addAnnotations(xServiceRefs) {
-      let { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
+    function addAnnotations2XServiceRefs( ) {
+      const { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema
-      annos.forEach(anno => {
+      annos.forEach((anno) => {
         let targetSchema = whatsMySchemaName(anno._edmAttributes.Target);
         // if no target schema has been found, it's a service annotation that applies to the service schema
-        if(targetSchema === undefined)
+        if (targetSchema === undefined)
           targetSchema = serviceCsn.name;
-        if(targetSchema !== serviceCsn.name) {
-          const newTarget = anno._edmAttributes.Target.replace(serviceCsn.name + '.', '');
+        if (targetSchema !== serviceCsn.name) {
+          const newTarget = anno._edmAttributes.Target.replace(`${serviceCsn.name}.`, '');
           anno.setEdmAttribute('Target', newTarget);
         }
         edm._service._schemas[targetSchema]._annotations.push(anno);
       });
 
       // create service cross reference and merge it into xServiceRefs
-      xrefs.forEach(xr => {
-        if(xr !== serviceCsn.name) {
+      xrefs.forEach((xr) => {
+        if (xr !== serviceCsn.name) {
           const art = edmUtils.createSchemaRef(allServices, xr);
-          if(xServiceRefs[art.inc.Namespace] === undefined)
+          if (xServiceRefs[art.inc.Namespace] === undefined)
             xServiceRefs[art.inc.Namespace] = art;
         }
       });
       // merge vocabulary cross references into xServiceRefs
-      usedVocabularies.forEach(art => xServiceRefs[art.inc.Namespace] = art);
+      usedVocabularies.forEach((art) => {
+        xServiceRefs[art.inc.Namespace] = art;
+      } );
     }
 
-    function edmTypeCompatibilityCheck(p, pLoc) {
+    function edmTypeCompatibilityCheck( p, pLoc ) {
       const edmType = p._type;
-      if(!edmType) {
+      if (!edmType) {
         message('odata-spec-violation-type', pLoc);
       }
-      else if(p._scalarType) {
+      else if (p._scalarType) {
         const td = EdmPrimitiveTypeMap[edmType];
-        if(td) {
+        if (td) {
           // The renderer/type mapper doesn't/shouldn't produce incompatible types and facets.
           // Only the unknown type warning may be triggered by an unknown @odata.Type override.
-          if(td.v2 !== p.v2 && td.v4 !== p.v4)
+          if (td.v2 !== p.v2 && td.v4 !== p.v4) {
             message('odata-spec-violation-type', pLoc,
-            { type: edmType, version: (p.v4 ? '4.0' : '2.0'), '#': 'incompatible' });
-          EdmTypeFacetNames.forEach(name => {
+                    { type: edmType, version: (p.v4 ? '4.0' : '2.0'), '#': 'incompatible' });
+          }
+          EdmTypeFacetNames.forEach((name) => {
             const facet = EdmTypeFacetMap[name];
-            const optional =
-              (facet.optional !== undefined)
+            const optional
+              = (facet.optional !== undefined)
                 ? (Array.isArray(facet.optional)
                   ? facet.optional.includes(edmType)
                   : facet.optional)
-              : false;
+                : false;
 
             // facet is not in attributes
             // facet is member of type definition and mandatory
             // node and facet version match
-            if(!p._edmAttributes[name] && td[name] && !optional && (p.v2 === facet.v2 || p.v4 === facet.v4)) {
+            if (!p._edmAttributes[name] && td[name] && !optional && (p.v2 === facet.v2 || p.v4 === facet.v4)) {
               message('odata-spec-violation-type', pLoc,
-                { type: edmType, name, version: (p.v4 ? '4.0' : '2.0'), '#': 'facet' });
+                      {
+                        type: edmType, name, version: (p.v4 ? '4.0' : '2.0'), '#': 'facet',
+                      });
             }
           });
+          if (edmType === 'Edm.Decimal') {
+            const precision = Number.parseInt(p._edmAttributes.Precision, 10);
+            const scale = Number.parseInt(p._edmAttributes.Scale, 10);
+            if (!Number.isNaN(precision) && !Number.isNaN(scale) && scale > precision) {
+              message('odata-spec-violation-type', pLoc,
+                      {
+                        type: edmType, number: scale, rawvalue: precision, ersion: (p.v4 ? '4.0' : '2.0'), '#': 'scale',
+                      });
+            }
+          }
         }
         else {
           message('odata-spec-violation-type-unknown', pLoc, { type: edmType });