@sap/cds-compiler 4.1.2 → 4.2.4

package/lib/edm/edm.js

@@ -1,4 +1,4 @@
-'use strict'
+'use strict';
 
 const edmUtils = require('./edmUtils.js');
 const { isBuiltinType } = require('../model/csnUtils.js');
@@ -7,25 +7,37 @@ const { forEach } = require('../utils/objectUtils');
 // facet definitions, optional could either be true or array of edm types
 // remove indicates wether or not the canonic facet shall be removed when applying @odata.Type
 const EdmTypeFacetMap = {
-  'MaxLength': { v2: true, v4: true, remove: true, optional: true },
-  'Precision': { v2: true, v4: true, remove: true, optional: true },
-  'Scale': { v2: true, v4: true, remove: true, optional: true, extra: 'sap:variable-scale' },
-  'SRID': { v4: true, remove: true, optional: true },
-  //'FixedLength': { v2: true },
-  //'Collation': { v2: true },
-  //'Unicode': { v2: true, v4: true },
+  MaxLength: {
+    v2: true, v4: true, remove: true, optional: true,
+  },
+  Precision: {
+    v2: true, v4: true, remove: true, optional: true,
+  },
+  Scale: {
+    v2: true, v4: true, remove: true, optional: true, extra: 'sap:variable-scale',
+  },
+  SRID: { v4: true, remove: true, optional: true },
+  // 'FixedLength': { v2: true },
+  // 'Collation': { v2: true },
+  // 'Unicode': { v2: true, v4: true },
 };
 const EdmTypeFacetNames = Object.keys(EdmTypeFacetMap);
 
 // Merged primitive type map with descriptions taken from V4 spec and filled up with V2 spec
 const EdmPrimitiveTypeMap = {
-  'Edm.Binary': { v2: true, v4: true, MaxLength: true, FixedLength: true, desc: 'Binary data' },
+  'Edm.Binary': {
+    v2: true, v4: true, MaxLength: true, FixedLength: true, desc: 'Binary data',
+  },
   'Edm.Boolean': { v2: true, v4: true, desc: 'Binary-valued logic' },
   'Edm.Byte': { v2: true, v4: true, desc: 'Unsigned 8-bit integer' },
   'Edm.Date': { v4: true, desc: 'Date without a time-zone offset' },
   'Edm.DateTime': { v2: true, Precision: true, desc: 'Date and time with values ranging from 12:00:00 midnight, January 1, 1753 A.D. through 11:59:59 P.M, December 31, 9999 A.D.' },
-  'Edm.DateTimeOffset': { v2: true, v4: true, Precision: true, desc: 'Date and time with a time-zone offset, no leap seconds' },
-  'Edm.Decimal': { v2: true, v4: true, Precision: true, Scale: true, desc: 'Numeric values with decimal representation' },
+  'Edm.DateTimeOffset': {
+    v2: true, v4: true, Precision: true, desc: 'Date and time with a time-zone offset, no leap seconds',
+  },
+  'Edm.Decimal': {
+    v2: true, v4: true, Precision: true, Scale: true, desc: 'Numeric values with decimal representation',
+  },
   'Edm.Double': { v2: true, v4: true, desc: 'IEEE 754 binary64 floating-point number (15-17 decimal digits)' },
   'Edm.Duration': { v4: true, Precision: true, desc: 'Signed duration in days, hours, minutes, and (sub)seconds' },
   'Edm.Guid': { v2: true, v4: true, desc: '16-byte (128-bit) unique identifier' },
@@ -35,7 +47,9 @@ const EdmPrimitiveTypeMap = {
   'Edm.SByte': { v2: true, v4: true, desc: 'Signed 8-bit integer' },
   'Edm.Single': { v2: true, v4: true, desc: 'IEEE 754 binary32 floating-point number (6-9 decimal digits)' },
   'Edm.Stream': { v4: true, MaxLength: true, desc: 'Binary data stream' },
-  'Edm.String': { v2: true, v4: true, MaxLength: true, FixedLength: true, Collation: true, Unicode: true, desc: 'Sequence of characters' },
+  'Edm.String': {
+    v2: true, v4: true, MaxLength: true, FixedLength: true, Collation: true, Unicode: true, desc: 'Sequence of characters',
+  },
   'Edm.Time': { v2: true, Precision: true, desc: 'time of day with values ranging from 0:00:00.x to 23:59:59.y, where x and y depend upon the precision' },
   'Edm.TimeOfDay': { v4: true, Precision: true, desc: 'Clock time 00:00-23:59:59.999999999999' },
   'Edm.Geography': { v4: true, SRID: true, desc: 'Abstract base type for all Geography types' },
@@ -55,25 +69,23 @@ const EdmPrimitiveTypeMap = {
   'Edm.GeometryMultiPolygon': { v4: true, SRID: true, desc: 'Collection of polygons in a flat-earth coordinate system' },
   'Edm.GeometryCollection': { v4: true, SRID: true, desc: 'Collection of arbitrary Geometry values' },
   'Edm.PrimitiveType': { v4: true, desc: 'Abstract meta type' },
-  //'Edm.Untyped': { v4: true, desc: 'Abstract void type' },
+  // 'Edm.Untyped': { v4: true, desc: 'Abstract void type' },
 };
 
-function getEdm(options, messageFunctions) {
-  const { error } = messageFunctions || { error: ()=>true, warning: ()=>true };
-  class Node
-  {
+function getEdm( options, messageFunctions ) {
+  const { error } = messageFunctions || { error: () => true, warning: () => true };
+  class Node {
     /**
-     * @param {boolean[]} v Versions in the form of [<v2>, <v4>].
+     * @param {boolean[]} version Versions in the form of [<v2>, <v4>].
      * @param {object} attributes
      * @param {CSN.Model} csn
      */
-    constructor(v, attributes = Object.create(null), csn=undefined)
-    {
-      if(!attributes || typeof attributes !== 'object')
+    constructor(version, attributes = Object.create(null), csn = undefined) {
+      if (!attributes || typeof attributes !== 'object')
         error(null, 'Please debug me: attributes must be a dictionary');
-      if(!Array.isArray(v))
-        error(null, 'Please debug me: v is either undefined or not an array: ' + v);
-      if(v.filter(v => v).length !== 1)
+      if (!Array.isArray(version))
+        error(null, `Please debug me: v is either undefined or not an array: ${version}`);
+      if (version.filter(v => v).length !== 1)
         error(null, 'Please debug me: exactly one version must be set');
 
       // Common attributes of JSON and XML.
@@ -85,17 +97,21 @@ function getEdm(options, messageFunctions) {
 
       this._children = [];
       this._ignoreChildren = false;
-      this._v = v;
+      this._v = version;
 
-      if(this.v2)
+      if (this.v2)
         this.setSapVocabularyAsAttributes(csn);
     }
 
-    get v2() { return this._v[0] }
-    get v4() { return this._v[1] }
+    get v2() {
+      return this._v[0];
+    }
+    get v4() {
+      return this._v[1];
+    }
 
     get kind() {
-      return this.constructor.name
+      return this.constructor.name;
     }
 
     /**
@@ -104,7 +120,7 @@ function getEdm(options, messageFunctions) {
      * @param {any} value
      */
     setEdmAttribute(key, value) {
-      if(key !== undefined && key !== null && value !== undefined && value !== null)
+      if (key !== undefined && key !== null && value !== undefined && value !== null)
         this._edmAttributes[key] = value;
     }
 
@@ -124,8 +140,7 @@ function getEdm(options, messageFunctions) {
      * @param {object} attributes
      * @return {any}
      */
-    setXml(attributes)
-    {
+    setXml(attributes) {
       return Object.assign(this._xmlOnlyAttributes, attributes);
     }
 
@@ -136,176 +151,188 @@ function getEdm(options, messageFunctions) {
      * @param {object} attributes
      * @return {any}
      */
-    setJSON(attributes)
-    {
+    setJSON(attributes) {
       return Object.assign(this._jsonOnlyAttributes, attributes);
     }
 
-    prepend(...children)
-    {
+    prepend(...children) {
       this._children.splice(0, 0, ...children.filter(c => c));
       return this;
     }
 
-    append(...children)
-    {
+    append(...children) {
       // remove undefined entries
       this._children.push(...children.filter(c => c));
-      return this
+      return this;
     }
 
     // virtual
-    toJSON()
-    {
+    toJSON() {
       const json = Object.create(null);
       // $kind Property MAY be omitted in JSON for performance reasons
-      if(!(this.kind in Node.noJsonKinds))
-        json['$Kind'] = this.kind;
+      if (!(this.kind in Node.noJsonKinds))
+        json.$Kind = this.kind;
 
       this.toJSONattributes(json);
       this.toJSONchildren(json);
-      return json
+      return json;
     }
 
     // virtual
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       forEach(this._edmAttributes, (p, v) => {
         if (p !== 'Name')
-          json[p[0] === '@' ? p : '$' + p] = v;
+          json[p[0] === '@' ? p : `$${p}`] = v;
       });
       return json;
     }
 
     // virtual
-    toJSONchildren(json)
-    {
+    toJSONchildren(json) {
       // any child with a Name should be added by its name into the JSON object
       // all others must overload toJSONchildren()
-      this._children.filter(c => c._edmAttributes.Name).forEach(c => json[c._edmAttributes.Name] = c.toJSON());
+      this._children.filter(c => c._edmAttributes.Name).forEach((c) => {
+        json[c._edmAttributes.Name] = c.toJSON();
+      });
     }
 
     // virtual
-    toXML(indent = '', what='all')
-    {
-      let kind = this.kind;
-      let head = indent + '<' + kind;
+    toXML(indent = '', what = 'all') {
+      const { kind } = this;
+      let head = `${indent}<${kind}`;
 
-      if(kind==='Parameter' && this._edmAttributes.Collection) {
+      if (kind === 'Parameter' && this._edmAttributes.Collection) {
         delete this._edmAttributes.Collection;
-        this._edmAttributes.Type=`Collection(${this._edmAttributes.Type})`;
+        this._edmAttributes.Type = `Collection(${this._edmAttributes.Type})`;
       }
 
       head += this.toXMLattributes();
 
-      let inner = this.innerXML(indent + '  ', what)
-      if (inner.length < 1) {
-        head += '/>'
-      }
-      else if (inner.length < 77 && inner.indexOf('<') < 0) {
-        head += '>' + inner.slice(indent.length + 1, -1) + '</' + kind + '>'
-      } else {
-        head += '>\n' + inner + indent + '</' + kind + '>'
-      }
+      const inner = this.innerXML(`${indent}  `, what);
+      if (inner.length < 1)
+        head += '/>';
+
+      else if (inner.length < 77 && inner.indexOf('<') < 0)
+        head += `>${inner.slice(indent.length + 1, -1)}</${kind}>`;
+
+      else
+        head += `>\n${inner}${indent}</${kind}>`;
+
       return head;
     }
 
     // virtual
-    toXMLattributes()
-    {
+    toXMLattributes() {
       let tmpStr = '';
       forEach(this._edmAttributes, (p, v) => {
         if (v !== undefined && typeof v !== 'object')
-          tmpStr += ' ' + p + '="' + edmUtils.escapeStringForAttributeValue(v) + '"'
+          tmpStr += ` ${p}="${edmUtils.escapeStringForAttributeValue(v)}"`;
       });
       forEach(this._xmlOnlyAttributes, (p, v) => {
         if (v !== undefined && typeof v !== 'object')
-          tmpStr += ' ' + p + '="' + edmUtils.escapeStringForAttributeValue(v) + '"'
+          tmpStr += ` ${p}="${edmUtils.escapeStringForAttributeValue(v)}"`;
       });
       return tmpStr;
     }
 
     // virtual
-    innerXML(indent, what='all')
-    {
+    innerXML(indent, what = 'all') {
       let xml = '';
 
-      this._children.forEach(e =>
-        xml += e.toXML(indent, what) + '\n');
+      this._children.forEach((e) => {
+        xml += `${e.toXML(indent, what)}\n`;
+      });
       return xml;
     }
 
     // virtual
-    setSapVocabularyAsAttributes(csn, useSetAttributes=false)
-    {
-      if(csn)
-      {
+    setSapVocabularyAsAttributes(csn, useSetAttributes = false) {
+      if (csn) {
         const attr = (useSetAttributes ? csn._SetAttributes : csn);
-        attr && Object.entries(attr).forEach(([p, v]) => {
-          if (p.match(/^@sap./))
-            this.setXml( { ['sap:' + p.slice(5).replace(/\./g, '-')] : v } );
-        });
+        if (attr) {
+          Object.entries(attr).forEach(([ p, v ]) => {
+            if (p.match(/^@sap./))
+              this.setXml( { [`sap:${p.slice(5).replace(/\./g, '-')}`]: v } );
+          });
+        }
       }
     }
   }
 
   // $kind Property MAY be omitted in JSON for performance reasons
-  Node.noJsonKinds = {'Property':1, 'EntitySet':1, 'ActionImport':1, 'FunctionImport':1, 'Singleton':1, 'Schema':1};
-
-  class Reference extends Node
-  {
-    constructor(v, details)
-    {
-      super(v, details);
-      if(this.v2)
+  Node.noJsonKinds = {
+    Property: 1, EntitySet: 1, ActionImport: 1, FunctionImport: 1, Singleton: 1, Schema: 1,
+  };
+
+  class Reference extends Node {
+    constructor(version, details) {
+      super(version, details);
+      if (this.v2)
         this._edmAttributes['xmlns:edmx'] = 'http://docs.oasis-open.org/odata/ns/edmx';
     }
 
-    get kind() { return 'edmx:Reference' }
+    get kind() {
+      return 'edmx:Reference';
+    }
 
-    toJSON()
-    {
-      let json = Object.create(null);
-      let includes = [];
+    toJSON() {
+      const json = Object.create(null);
+      const includes = [];
 
       this._children.forEach(c => includes.push(c.toJSON()));
-      if(includes.length > 0)
-        json['$Include'] = includes;
+      if (includes.length > 0)
+        json.$Include = includes;
       return json;
     }
   }
 
-  class Include extends Node
-  {
-    get kind() { return 'edmx:Include' }
-    toJSON()
-    {
-      let json = Object.create(null);
+  class Include extends Node {
+    get kind() {
+      return 'edmx:Include';
+    }
+    toJSON() {
+      const json = Object.create(null);
       return this.toJSONattributes(json);
     }
   }
 
-  class Schema extends Node
-  {
-    constructor(v, ns, alias=undefined, serviceCsn=null, annotations=[], withEntityContainer=true)
-    {
+  class EntityContainer extends Node {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn);
+      this._registry = Object.create(null);
+    }
+    // use the _SetAttributes
+    setSapVocabularyAsAttributes(csn) {
+      super.setSapVocabularyAsAttributes(csn, true);
+    }
+
+    register(entry) {
+      if (!this._registry[entry._edmAttributes.Name])
+        this._registry[entry._edmAttributes.Name] = [ entry ];
+      else
+        this._registry[entry._edmAttributes.Name].push(entry);
+      this.append(entry);
+    }
+  }
+
+  class Schema extends Node {
+    constructor(version, ns, alias = undefined, serviceCsn = null, annotations = [], withEntityContainer = true) {
       const props = { Namespace: ns };
-      if(alias !== undefined)
+      if (alias !== undefined)
         props.Alias = alias;
-      super(v, props);
+      super(version, props);
       this._annotations = annotations;
       this._actions = Object.create(null);
       this.setXml( { xmlns: (this.v2) ? 'http://schemas.microsoft.com/ado/2008/09/edm' : 'http://docs.oasis-open.org/odata/ns/edm' } );
 
-      if(this.v2 && serviceCsn)
+      if (this.v2 && serviceCsn)
         this.setSapVocabularyAsAttributes(serviceCsn);
 
-      if(withEntityContainer)
-      {
-        let ecprops = { Name: 'EntityContainer' };
-        let ec = new EntityContainer(v, ecprops, serviceCsn );
-        if(this.v2)
-          ec.setXml( { 'm:IsDefaultEntityContainer':  true } );
+      if (withEntityContainer) {
+        const ecprops = { Name: 'EntityContainer' };
+        const ec = new EntityContainer(version, ecprops, serviceCsn );
+        if (this.v2)
+          ec.setXml( { 'm:IsDefaultEntityContainer': true } );
         // append for rendering, ok ec has Name
         this.append(ec);
         // set as attribute for later access...
@@ -314,107 +341,110 @@ function getEdm(options, messageFunctions) {
     }
 
     // hold actions and functions in V4
-    addAction(action)
-    {
-      if(this._actions[action._edmAttributes.Name])
+    addAction(action) {
+      if (this._actions[action._edmAttributes.Name])
         this._actions[action._edmAttributes.Name].push(action);
       else
-        this._actions[action._edmAttributes.Name] = [action];
+        this._actions[action._edmAttributes.Name] = [ action ];
     }
 
-    setAnnotations(annotations)
-    {
-      if(Array.isArray(annotations) && annotations.length > 0)
+    setAnnotations(annotations) {
+      if (Array.isArray(annotations) && annotations.length > 0)
         this._annotations.push(...annotations);
     }
 
-    innerXML(indent, what)
-    {
+    innerXML(indent, what) {
       let xml = '';
-      if(what==='metadata' || what==='all')
-      {
+      if (what === 'metadata' || what === 'all') {
         xml += super.innerXML(indent);
-        this._actions && Object.values(this._actions).forEach(actionArray => {
-          actionArray.forEach(action => {
-            xml += action.toXML(indent, what) + '\n'; });
-        });
-      }
-      if(what==='annotations' || what==='all')
-      {
-        if(this._annotations.length > 0) {
-          this._annotations.filter(a => a._edmAttributes.Term).forEach(a => xml += a.toXML(indent) + '\n');
-          this._annotations.filter(a => a._edmAttributes.Target).forEach(a => xml += a.toXML(indent) + '\n');
+        if (this._actions) {
+          Object.values(this._actions).forEach((actionArray) => {
+            actionArray.forEach((action) => {
+              xml += `${action.toXML(indent, what)}\n`;
+            });
+          });
         }
       }
+      if ((what === 'annotations' || what === 'all') && this._annotations.length > 0) {
+        this._annotations.filter(a => a._edmAttributes.Term).forEach((a) => {
+          xml += `${a.toXML(indent)}\n`;
+        });
+        this._annotations.filter(a => a._edmAttributes.Target).forEach((a) => {
+          xml += `${a.toXML(indent)}\n`;
+        });
+      }
       return xml;
     }
 
     // no $Namespace
-    toJSONattributes(json)
-    {
-      this._edmAttributes && Object.entries(this._edmAttributes).forEach(([p, v]) => {
-        if (p !== 'Name' && p !== 'Namespace')
-          json[p[0] === '@' ? p : '$' + p] = v;
-      });
+    toJSONattributes(json) {
+      if (this._edmAttributes) {
+        Object.entries(this._edmAttributes).forEach(([ p, v ]) => {
+          if (p !== 'Name' && p !== 'Namespace')
+            json[p[0] === '@' ? p : `$${p}`] = v;
+        });
+      }
     }
 
-    toJSONchildren(json)
-    {
+    toJSONchildren(json) {
       // 'edmx:DataServices' should not appear in JSON
       super.toJSONchildren(json);
-      if(this._annotations.length > 0) {
-        this._annotations.filter(a => a._edmAttributes.Term).forEach(a => {
-          Object.entries(a.toJSON()).forEach(([n, v]) => {
+      if (this._annotations.length > 0) {
+        this._annotations.filter(a => a._edmAttributes.Term).forEach((a) => {
+          Object.entries(a.toJSON()).forEach(([ n, v ]) => {
             json[n] = v;
           });
         });
-        let json_Annotations = Object.create(null);
-        this._annotations.filter(a => a._edmAttributes.Target).forEach(a => json_Annotations[a._edmAttributes.Target] = a.toJSON());
-        if(Object.keys(json_Annotations).length)
-          json['$Annotations'] = json_Annotations;
+        const jsonAnnotations = Object.create(null);
+        this._annotations.filter(a => a._edmAttributes.Target).forEach((a) => {
+          jsonAnnotations[a._edmAttributes.Target] = a.toJSON();
+        });
+        if (Object.keys(jsonAnnotations).length)
+          json.$Annotations = jsonAnnotations;
       }
-      this._actions && Object.entries(this._actions).forEach(([actionName, actionArray]) => {
-        json[actionName] = [];
-        actionArray.forEach(action => {
-          json[actionName].push(action.toJSON());
+      if (this._actions) {
+        Object.entries(this._actions).forEach(([ actionName, actionArray ]) => {
+          json[actionName] = [];
+          actionArray.forEach((action) => {
+            json[actionName].push(action.toJSON());
+          });
         });
-      });
+      }
 
       return json;
     }
-
   }
 
-  class DataServices extends Node
-  {
-    constructor(v)
-    {
+  class DataServices extends Node {
+    constructor(v) {
       super(v);
       this._schemas = Object.create(null);
 
-      if(this.v2)
-        this.setXml( { 'm:DataServiceVersion': '2.0' } )
+      if (this.v2)
+        this.setXml( { 'm:DataServiceVersion': '2.0' } );
     }
 
-    get kind() { return 'edmx:DataServices'; }
+    get kind() {
+      return 'edmx:DataServices';
+    }
 
-    registerSchema(fqName, schema)
-    {
-      if(!this._schemas[fqName]) {
+    registerSchema(fqName, schema) {
+      if (!this._schemas[fqName]) {
         this._schemas[fqName] = schema;
         super.append(schema);
       }
     }
 
-    toJSONchildren(json)
-    {
+    toJSONchildren(json) {
       // 'edmx:DataServices' should not appear in JSON
-      this._children.forEach(s => json[s._edmAttributes.Namespace] = s.toJSON());
+      this._children.forEach((s) => {
+        json[s._edmAttributes.Namespace] = s.toJSON();
+      });
       return json;
     }
   }
 
-    /* <edmx:Edmx> must contain exactly one <edmx:DataServices> with 1..n <edm:Schema> elements
+  /* <edmx:Edmx> must contain exactly one <edmx:DataServices> with 1..n <edm:Schema> elements
                   may contain 0..n <edmx:Reference> elements
 
       For Odata 1.0..3.0 EDMX is an independent container with its own version 1.0.
@@ -424,60 +454,58 @@ function getEdm(options, messageFunctions) {
       OData version
     */
 
-  class Edm extends Node
-  {
-    constructor(v, service)
-    {
-      super(v, { Version : (v[1]) ? '4.0' : '1.0' });
+  class Edm extends Node {
+    constructor(version, service) {
+      super(version, { Version: (version[1]) ? '4.0' : '1.0' });
       this._service = service;
       this._defaultRefs = [];
 
       const xmlProps = Object.create(null);
-      if(this.v4)
-      {
+      if (this.v4) {
         xmlProps['xmlns:edmx'] = 'http://docs.oasis-open.org/odata/ns/edmx';
-        xmlProps['xmlns:m']    =  undefined;
-        xmlProps['xmlns:sap']  =  undefined;
+        xmlProps['xmlns:m'] = undefined;
+        xmlProps['xmlns:sap'] = undefined;
       }
-      else
-      {
+      else {
         xmlProps['xmlns:edmx'] = 'http://schemas.microsoft.com/ado/2007/06/edmx';
-        xmlProps['xmlns:m']    = 'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata';
-        xmlProps['xmlns:sap']  = 'http://www.sap.com/Protocols/SAPData';
+        xmlProps['xmlns:m'] = 'http://schemas.microsoft.com/ado/2007/08/dataservices/metadata';
+        xmlProps['xmlns:sap'] = 'http://www.sap.com/Protocols/SAPData';
       }
       this.setXml(xmlProps);
     }
 
-    get kind() { return 'edmx:Edmx' }
+    get kind() {
+      return 'edmx:Edmx';
+    }
 
-    getAnnotations(schemaIndex=0)
-    {
-      if(this._service && this._service._children[schemaIndex])
+    getAnnotations(schemaIndex = 0) {
+      if (this._service && this._service._children[schemaIndex])
         return this._service._children[schemaIndex]._annotations;
-      else
-        return undefined;
+      return undefined;
     }
 
-    setAnnotations(annotations, schemaIndex=0)
-    {
-      if(this._service && this._service._children[schemaIndex])
+    setAnnotations(annotations, schemaIndex = 0) {
+      if (this._service && this._service._children[schemaIndex])
         this._service._children[schemaIndex]._annotations = annotations;
     }
 
-    toJSON()
-    {
-      let schema = this._service._children[0];
+    toJSON() {
+      const schema = this._service._children[0];
 
-      let json = Object.create(null);
-      json['$Version'] = this._edmAttributes.Version;
-      json['$EntityContainer'] = schema._edmAttributes.Namespace + '.' + schema._ec._edmAttributes.Name;
+      const json = Object.create(null);
+      json.$Version = this._edmAttributes.Version;
+      json.$EntityContainer = `${schema._edmAttributes.Namespace}.${schema._ec._edmAttributes.Name}`;
 
-      let reference_json = Object.create(null);
-      this._defaultRefs.forEach(r => reference_json[r._edmAttributes.Uri] = r.toJSON());
-      this._children.forEach(r => reference_json[r._edmAttributes.Uri] = r.toJSON());
+      const referenceJson = Object.create(null);
+      this._defaultRefs.forEach((r) => {
+        referenceJson[r._edmAttributes.Uri] = r.toJSON();
+      });
+      this._children.forEach((r) => {
+        referenceJson[r._edmAttributes.Uri] = r.toJSON();
+      });
 
-      if(Object.keys(reference_json).length)
-        json['$Reference'] = reference_json;
+      if (Object.keys(referenceJson).length)
+        json.$Reference = referenceJson;
 
       this._service.toJSONattributes(json);
       this._service.toJSONchildren(json);
@@ -485,106 +513,88 @@ function getEdm(options, messageFunctions) {
     }
 
     // all(default), metadata, annotations
-    toXML(what='all')
-    {
-      return '<?xml version="1.0" encoding="utf-8"?>\n' + super.toXML('', what);
+    toXML(what = 'all') {
+      return `<?xml version="1.0" encoding="utf-8"?>\n${super.toXML('', what)}`;
     }
 
-    innerXML(indent, what)
-    {
+    innerXML(indent, what) {
       let xml = '';
 
-      if(this.v4 || (this.v2 && (what === 'all' || what === 'annotations')))
-        this._defaultRefs.forEach(r => xml += r.toXML(indent) + '\n');
-      this._children.forEach(e => xml += e.toXML(indent) + '\n');
-      xml += this._service.toXML(indent, what) + '\n';
+      if (this.v4 || (this.v2 && (what === 'all' || what === 'annotations'))) {
+        this._defaultRefs.forEach((r) => {
+          xml += `${r.toXML(indent)}\n`;
+        });
+      }
+      this._children.forEach((e) => {
+        xml += `${e.toXML(indent)}\n`;
+      });
+      xml += `${this._service.toXML(indent, what)}\n`;
       return xml;
     }
   }
 
-  class EntityContainer extends Node
-  {
-    constructor(v, attributes, csn) {
-      super(v, attributes, csn);
-      this._registry = Object.create(null);
-    }
-    // use the _SetAttributes
-    setSapVocabularyAsAttributes(csn)
-    {
-      super.setSapVocabularyAsAttributes(csn, true);
-    }
-
-    register(entry) {
-      if(!this._registry[entry._edmAttributes.Name])
-        this._registry[entry._edmAttributes.Name] = [entry];
-      else
-        this._registry[entry._edmAttributes.Name].push(entry);
-      this.append(entry);
-    }
-  }
-
-
-  class Singleton extends Node
-  {
-    toJSONattributes(json)
-    {
+  class Singleton extends Node {
+    toJSONattributes(json) {
       forEach(this._edmAttributes, (p, v) => {
         if (p !== 'Name') {
-          if(p === 'EntityType') // it's $Type in json
-            json['$Type'] = v;
+          if (p === 'EntityType') // it's $Type in json
+            json.$Type = v;
           else
-            json[p[0] === '@' ? p : '$' + p] = v;
+            json[p[0] === '@' ? p : `$${p}`] = v;
         }
       });
       return json;
     }
 
-    toJSONchildren(json)
-    {
-      let json_navPropBinding = Object.create(null);
-      this._children.forEach(npb => json_navPropBinding[npb._edmAttributes.Path] = npb._edmAttributes.Target);
-      if(Object.keys(json_navPropBinding).length > 0)
-        json['$NavigationPropertyBinding'] = json_navPropBinding;
+    toJSONchildren(json) {
+      const jsonNavPropBinding = Object.create(null);
+      this._children.forEach((npb) => {
+        jsonNavPropBinding[npb._edmAttributes.Path] = npb._edmAttributes.Target;
+      });
+      if (Object.keys(jsonNavPropBinding).length > 0)
+        json.$NavigationPropertyBinding = jsonNavPropBinding;
 
       return json;
     }
 
     getDuplicateMessage() {
-      return `EntityType "${this._edmAttributes.EntityType}"`
+      return `EntityType "${this._edmAttributes.EntityType}"`;
     }
   }
 
-  class EntitySet extends Singleton
-  {
+  class EntitySet extends Singleton {
     // use the _SetAttributes
-    setSapVocabularyAsAttributes(csn)
-    {
+    setSapVocabularyAsAttributes(csn) {
       super.setSapVocabularyAsAttributes(csn, true);
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       //  OASIS ODATA-1231 $Collection=true
-      json['$Collection']=true;
+      json.$Collection = true;
       return super.toJSONattributes(json);
     }
   }
 
-  class Key extends Node
-  {
+  class PropertyRef extends Node {
+    constructor(version, Name, Alias) {
+      super(version, (Alias) ? { Name, Alias } : { Name });
+    }
+
+    toJSON() {
+      return this._edmAttributes.Alias ? { [this._edmAttributes.Alias]: this._edmAttributes.Name } : this._edmAttributes.Name;
+    }
+  }
+
+  class Key extends Node {
     // keys is an array of [name] or [name, alias]
-    constructor(v, keys)
-    {
-      super(v);
+    constructor(version, keys) {
+      super(version);
       if (keys && keys.length > 0)
-      {
-        keys.forEach(k => this.append(new PropertyRef(v, ...k)));
-      }
+        keys.forEach(k => this.append(new PropertyRef(version, ...k)));
     }
 
-    toJSON()
-    {
-      let json = [];
+    toJSON() {
+      const json = [];
       this._children.forEach(c => json.push(c.toJSON()));
       return json;
     }
@@ -598,40 +608,36 @@ function getEdm(options, messageFunctions) {
   to the FunctionImport. See comment in class FunctionImport.
   */
 
-  class ActionFunctionBase extends Node
-  {
-    constructor(v, details)
-    {
-      super(v, details);
+  class ActionFunctionBase extends Node {
+    constructor(version, details) {
+      super(version, details);
       this._returnType = undefined;
     }
 
-    innerXML(indent)
-    {
+    innerXML(indent) {
       let xml = super.innerXML(indent);
-      if(this._returnType !== undefined)
-        xml += this._returnType.toXML(indent) + '\n';
-      return xml
-    }
-
-    toJSONchildren(json)
-    {
-      let json_parameters = [];
-      this._children.forEach(p => json_parameters.push(p.toJSON()));
-      if(json_parameters.length > 0)
-        json['$Parameter'] = json_parameters;
-      if(this._returnType)
-      {
-        json['$ReturnType'] = this._returnType.toJSON();
-      }
+      if (this._returnType !== undefined)
+        xml += `${this._returnType.toXML(indent)}\n`;
+      return xml;
+    }
+
+    toJSONchildren(json) {
+      const jsonParameters = [];
+      this._children.forEach(p => jsonParameters.push(p.toJSON()));
+      if (jsonParameters.length > 0)
+        json.$Parameter = jsonParameters;
+      if (this._returnType)
+        json.$ReturnType = this._returnType.toJSON();
+
       return json;
     }
   }
   // FunctionDefinition should be named 'Function', but this would
   // collide with a method 'Function' of the Istanbul/NYC tool
-  class FunctionDefinition extends ActionFunctionBase
-  {
-    get kind()  { return 'Function'; }
+  class FunctionDefinition extends ActionFunctionBase {
+    get kind() {
+      return 'Function';
+    }
   }
   class Action extends ActionFunctionBase {}
 
@@ -642,46 +648,43 @@ function getEdm(options, messageFunctions) {
   */
   class FunctionImport extends Node {
     getDuplicateMessage() {
-      return `Function "${this._edmAttributes.Name}"`
+      return `Function "${this._edmAttributes.Name}"`;
     }
-  } //ActionFunctionBase {}
+  } // ActionFunctionBase {}
   class ActionImport extends Node {
     getDuplicateMessage() {
-      return `Action "${this._edmAttributes.Name}"`
+      return `Action "${this._edmAttributes.Name}"`;
     }
   }
 
-  class TypeBase extends Node
-  {
-    constructor(v, attributes, csn, typeName='Type')
-    {
+  class TypeBase extends Node {
+    constructor(version, attributes, csn, typeName = 'Type') {
       // ??? Is CSN still required? NavProp?
-      super(v, attributes, csn);
+      super(version, attributes, csn);
       this._typeName = typeName;
       this._scalarType = undefined;
-      if(this._edmAttributes[typeName] === undefined)
-      {
-        let typecsn = csn.type ? csn : (csn.items && csn.items.type ? csn.items : csn);
+      if (this._edmAttributes[typeName] === undefined) {
+        const typecsn = csn.type ? csn : (csn.items && csn.items.type ? csn.items : csn);
         // Complex/EntityType are derived from TypeBase
         // but have no type attribute in their CSN
-        if(typecsn.type) { // this thing has a type
+        if (typecsn.type) { // this thing has a type
           // check whether this is a scalar type (or array of scalar type) or a named type
-          if(typecsn.items && typecsn.items.type &&
-            isBuiltinType(typecsn.items.type)) {
+          if (typecsn.items && typecsn.items.type &&
+            isBuiltinType(typecsn.items.type))
             this._scalarType = typecsn.items;
-          }
-          else if(isBuiltinType(typecsn.type)) {
+
+          else if (isBuiltinType(typecsn.type))
             this._scalarType = typecsn;
-          }
-          if(this._scalarType) {
+
+          if (this._scalarType) {
             this._edmAttributes[typeName] = csn._edmType;
             // CDXCORE-CDXCORE-173 ignore type facets for Edm.Stream
             // cds-compiler/issues/7835: Only set length for Binary as long as it is
             // unclear how many bytes a string character represents.
             // We can't calculate an unambiguous byte stream length for DB dependent
             // multi-byte characters.
-            if(!(this._edmAttributes[typeName] === 'Edm.Stream' &&
-               !( /*scalarType.type === 'cds.String' ||*/ this._scalarType.type === 'cds.Binary')))
+            if (!(this._edmAttributes[typeName] === 'Edm.Stream' &&
+               !( /* scalarType.type === 'cds.String' || */ this._scalarType.type === 'cds.Binary')))
               edmUtils.addTypeFacets(this, this._scalarType);
           }
           else {
@@ -693,30 +696,29 @@ function getEdm(options, messageFunctions) {
         // optionally add @odata { MaxLength, Precision, Scale, SRID }
         // but only in combination with @odata.Type
         // Allow to override type only on scalar and undefined types
-        if((this._scalarType || typecsn.type == null) && !csn.elements) {
+        if ((this._scalarType || typecsn.type == null) && !csn.elements) {
           const odataType = csn['@odata.Type'];
-          if(odataType) {
+          if (odataType) {
             const td = EdmPrimitiveTypeMap[odataType];
             // If type is known, it must be available in the current version
             // Reason: EDMX Importer may set `@odata.Type: 'Edm.DateTime'` on imported V2 services
             // Not filtering out this incompatible type here in case of a V4 rendering would
             // produce an unrecoverable error.
-            if(td && (td.v2 === this.v2 || td.v4 === this.v4)) {
+            if (td && (td.v2 === this.v2 || td.v4 === this.v4)) {
               this.setEdmAttribute(typeName, odataType);
-              EdmTypeFacetNames.forEach(facetName => {
+              EdmTypeFacetNames.forEach((facetName) => {
                 const facet = EdmTypeFacetMap[facetName];
-                if(facet.remove) {
+                if (facet.remove) {
                   this.removeEdmAttribute(facetName);
                   this.removeEdmAttribute(facet.extra);
                 }
-                if(td[facetName] !== undefined &&
+                if (td[facetName] !== undefined &&
                       (facet.v2 === this.v2 ||
-                      facet.v4 === this.v4))
-                  {
-                  if(this.v2 && facetName === 'Scale' && csn['@odata.'+facetName] === 'variable')
+                      facet.v4 === this.v4)) {
+                  if (this.v2 && facetName === 'Scale' && csn[`@odata.${facetName}`] === 'variable')
                     this.setXml({ [facet.extra]: true });
                   else
-                      this.setEdmAttribute(facetName, csn['@odata.'+facetName]);
+                    this.setEdmAttribute(facetName, csn[`@odata.${facetName}`]);
                 }
               });
             }
@@ -727,278 +729,245 @@ function getEdm(options, messageFunctions) {
       // Set the collection property if this is either an element, parameter or a term def
       this._isCollection = (csn.kind === undefined || csn.kind === 'annotation') ? csn._isCollection : false;
 
-      if(options.whatsMySchemaName && this._edmAttributes[typeName]) {
-        let schemaName = options.whatsMySchemaName(this._edmAttributes[typeName]);
-        if(schemaName && schemaName !== options.serviceName) {
-          this._edmAttributes[typeName] = this._edmAttributes[typeName].replace(options.serviceName + '.', '');
-        }
+      if (options.whatsMySchemaName && this._edmAttributes[typeName]) {
+        const schemaName = options.whatsMySchemaName(this._edmAttributes[typeName]);
+        if (schemaName && schemaName !== options.serviceName)
+          this._edmAttributes[typeName] = this._edmAttributes[typeName].replace(`${options.serviceName}.`, '');
       }
 
       // store undecorated type for JSON
       this._type = this._edmAttributes[typeName];
       // decorate for XML (not for Complex/EntityType)
-      if(this._isCollection && this._edmAttributes[typeName])
-        this._edmAttributes[typeName] = `Collection(${this._edmAttributes[typeName]})`
+      if (this._isCollection && this._edmAttributes[typeName])
+        this._edmAttributes[typeName] = `Collection(${this._edmAttributes[typeName]})`;
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       // $Type Edm.String, $Nullable=false MAY be omitted
       // @ property and parameter for performance reasons
-      if(this._type !== 'Edm.String' && this._type)   // Edm.String is default)
-        json['$'+this._typeName] = this._type;
+      if (this._type !== 'Edm.String' && this._type)   // Edm.String is default)
+        json[`$${this._typeName}`] = this._type;
 
-      this._edmAttributes && Object.entries(this._edmAttributes).forEach(([p, v]) => {
-        if (p !== 'Name' && p !== this._typeName
+      if (this._edmAttributes) {
+        Object.entries(this._edmAttributes).forEach(([ p, v ]) => {
+          if (p !== 'Name' && p !== this._typeName &&
           // remove this line if Nullable=true becomes default
-          && !(p === 'Nullable' && !v))
-        {
-          json[p[0] === '@' ? p : '$' + p] = v;
-        }
-      });
+          !(p === 'Nullable' && !v))
+            json[p[0] === '@' ? p : `$${p}`] = v;
+        });
+      }
 
-      if(this._isCollection)
-        json['$Collection'] = this._isCollection;
+      if (this._isCollection)
+        json.$Collection = this._isCollection;
 
       return json;
-
     }
   }
 
   class ComplexType extends TypeBase {
-    constructor(v, details, csn) {
-      super(v, details, csn);
-      if(this.v4 && !!csn['@open']) {
-        this._edmAttributes['OpenType'] = true;
-      }
+    constructor(version, details, csn) {
+      super(version, details, csn);
+      if (this.v4 && !!csn['@open'])
+        this._edmAttributes.OpenType = true;
     }
   }
-  class EntityType extends ComplexType
-  {
-    constructor(v, details, properties, csn)
-    {
-      super(v, details, csn);
+  class EntityType extends ComplexType {
+    constructor(version, details, properties, csn) {
+      super(version, details, csn);
       this.append(...properties);
       const aliasXref = Object.create(null);
 
-      csn.$edmKeyPaths.forEach(p => {
-        const [alias, ...tail] = p[0].split('/').reverse();
+      csn.$edmKeyPaths.forEach((p) => {
+        const [ alias, ...tail ] = p[0].split('/').reverse();
 
-        if(aliasXref[alias] === undefined)
+        if (aliasXref[alias] === undefined)
           aliasXref[alias] = 0;
         else
           aliasXref[alias]++;
         // if it's a path, push the alias
-        if(tail.length > 0)
+        if (tail.length > 0)
           p.push(alias);
       });
-      csn.$edmKeyPaths.slice().reverse().forEach(p => {
+      csn.$edmKeyPaths.slice().reverse().forEach((p) => {
         let alias = p[1];
-        if(alias)
-        {
+        if (alias) {
           const c = aliasXref[alias]--;
           // Limit Key length to 32 characters
-          if(c > 0) {
-            if(alias.length > 28) {
-              alias = alias.substr(0, 13)+ '__' +alias.substr(alias.length-13, alias.length);
-            }
-            alias = alias+'_'+c.toString().padStart(3, '0');
+          if (c > 0) {
+            if (alias.length > 28)
+              alias = `${alias.substr(0, 13)}__${alias.substr(alias.length - 13, alias.length)}`;
+
+            alias = `${alias}_${c.toString().padStart(3, '0')}`;
           }
-          else if(alias.length > 32) {
-            alias = alias.substr(0, 15)+ '__' +alias.substr(alias.length-15, alias.length);
+          else if (alias.length > 32) {
+            alias = `${alias.substr(0, 15)}__${alias.substr(alias.length - 15, alias.length)}`;
           }
           p[1] = alias;
         }
       });
 
-      if(csn.$edmKeyPaths && csn.$edmKeyPaths.length)
-        this._keys = new Key(v, csn.$edmKeyPaths);
+      if (csn.$edmKeyPaths && csn.$edmKeyPaths.length)
+        this._keys = new Key(version, csn.$edmKeyPaths);
       else
         this._keys = undefined;
 
-      if(options.odataOpenapiHints) {
-        if(csn['@cds.autoexpose'])
+      if (options.odataOpenapiHints) {
+        if (csn['@cds.autoexpose'])
           this.setJSON({ '@cds.autoexpose': true });
-        if(csn['@cds.autoexposed'])
+        if (csn['@cds.autoexposed'])
           this.setJSON({ '@cds.autoexposed': true });
       }
     }
 
-    innerXML(indent)
-    {
+    innerXML(indent) {
       let xml = '';
-      if(this._keys)
-        xml += this._keys.toXML(indent) + '\n';
+      if (this._keys)
+        xml += `${this._keys.toXML(indent)}\n`;
       return xml + super.innerXML(indent);
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       super.toJSONattributes(json);
-      this._jsonOnlyAttributes && Object.entries(this._jsonOnlyAttributes).forEach(([p, v]) => {
-        json[p[0] === '@' ? p : '$' + p] = v;
-      });
-      if(this._keys)
-      {
-        json['$Key'] = this._keys.toJSON();
+      if (this._jsonOnlyAttributes) {
+        Object.entries(this._jsonOnlyAttributes).forEach(([ p, v ]) => {
+          json[p[0] === '@' ? p : `$${p}`] = v;
+        });
       }
+      if (this._keys)
+        json.$Key = this._keys.toJSON();
+
       return json;
     }
   }
 
-  class Term extends TypeBase
-    {
-    constructor(v, attributes, csn)
-      {
-      super(v, attributes, csn);
+  class Term extends TypeBase {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn);
       const appliesTo = csn['@odata.term.AppliesTo'];
-      if(appliesTo) {
-        this.setEdmAttribute('AppliesTo', Array.isArray(appliesTo) ? appliesTo.map(v=>v['=']||v).join(' ') : appliesTo['='] || appliesTo);
-      }
-    }
+      if (appliesTo)
+        this.setEdmAttribute('AppliesTo', Array.isArray(appliesTo) ? appliesTo.map(v => v['='] || v).join(' ') : appliesTo['='] || appliesTo);
     }
+  }
 
-  class TypeDefinition extends TypeBase
-  {
-    constructor(v, attributes, csn)
-    {
-      super(v, attributes, csn, 'UnderlyingType');
+  class TypeDefinition extends TypeBase {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn, 'UnderlyingType');
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       super.toJSONattributes(json);
-      json['$UnderlyingType'] = this._type;
+      json.$UnderlyingType = this._type;
       return json;
     }
   }
 
-  class EnumType extends TypeDefinition
-  {
-    constructor(v, attributes, csn)
-    {
-      super(v, attributes, csn);
+  class Member extends Node {
+    toJSONattributes(json) {
+      json[this._edmAttributes.Name] = this._edmAttributes.Value;
+      return json;
+    }
+  }
+
+  class EnumType extends TypeDefinition {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn);
 
       // array of enum not yet allowed
-      const enumValues = /*(csn.items && csn.items.enum) ||*/ csn.enum;
-      enumValues && Object.entries(enumValues).forEach(([en, e]) =>  {
-        this.append(new Member(v, { Name: en, Value: e.val } ));
-      });
+      const enumValues = /* (csn.items && csn.items.enum) || */ csn.enum;
+      if (enumValues) {
+        Object.entries(enumValues).forEach(([ en, e ]) => {
+          this.append(new Member(version, { Name: en, Value: e.val } ));
+        });
+      }
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       super.toJSONattributes(json);
       return json;
     }
 
-    toJSONchildren(json)
-    {
+    toJSONchildren(json) {
       this._children.forEach(c => c.toJSONattributes(json));
       return json;
     }
   }
 
-  class Member extends Node
-  {
-    toJSONattributes(json)
-    {
-      json[this._edmAttributes.Name] = this._edmAttributes.Value;
-      return json;
-    }
-  }
-
-  class PropertyBase extends TypeBase
-  {
-    constructor(v, attributes, csn)
-    {
-      super(v, attributes, csn);
+  class PropertyBase extends TypeBase {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn);
       this._csn = csn;
-      if(this.v2)
-      {
-        let typecsn = csn.items || csn;
+      if (this.v2) {
+        const typecsn = csn.items || csn;
 
         // see edmUtils.mapsCdsToEdmType => add sap:display-format annotation
         // only if Edm.DateTime is the result of a cast from Edm.Date
         // but not if Edm.DateTime is the result of a regular cds type mapping
-        if(this._edmAttributes.Type === 'Edm.DateTime'
-        && (typecsn.type !== 'cds.DateTime' && typecsn.type !== 'cds.Timestamp'))
-          this.setXml( { 'sap:display-format' : 'Date' } );
-
+        if (this._edmAttributes.Type === 'Edm.DateTime' &&
+        (typecsn.type !== 'cds.DateTime' && typecsn.type !== 'cds.Timestamp'))
+          this.setXml( { 'sap:display-format': 'Date' } );
       }
       this.setNullable();
     }
 
-    setNullable()
-    {
+    setNullable() {
       // From the Spec: In OData 4.01 responses a collection-valued property MUST specify a value for the Nullable attribute.
-      if(this._isCollection) {
+      if (this._isCollection)
         this._edmAttributes.Nullable = !this.isNotNullable();
-      }
+
       // Nullable=true is default, mention Nullable=false only in XML
       // Nullable=false is default for EDM JSON representation 4.01
       // When a key explicitly (!) has 'notNull = false', it stays nullable
-      else if(this.isNotNullable())
-      {
+      else if (this.isNotNullable())
         this._edmAttributes.Nullable = false;
-      }
     }
 
-    isNotNullable(csn=undefined) {
-      let nodeCsn = csn || this._csn;
+    isNotNullable(csn = undefined) {
+      const nodeCsn = csn || this._csn;
       // Nullable=true is default, mention Nullable=false only in XML
       // Nullable=false is default for EDM JSON representation 4.01
       // When a key explicitly (!) has 'notNull = false', it stays nullable
-      return (nodeCsn._NotNullCollection !== undefined ? nodeCsn._NotNullCollection :
-        (nodeCsn.key && nodeCsn.notNull !== false) || nodeCsn.notNull === true);
+      return (nodeCsn._NotNullCollection !== undefined ? nodeCsn._NotNullCollection
+        : (nodeCsn.key && nodeCsn.notNull !== false) || nodeCsn.notNull === true);
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       super.toJSONattributes(json);
       // mention all nullable elements explicitly, remove if Nullable=true becomes default
-      if(this._edmAttributes.Nullable === undefined || this._edmAttributes.Nullable === true)
-      {
-        json['$Nullable'] = true;
-      }
+      if (this._edmAttributes.Nullable === undefined || this._edmAttributes.Nullable === true)
+        json.$Nullable = true;
+
       return json;
     }
   }
 
   /* ReturnType is only used in v4, mapCdsToEdmType can be safely
   called with V2=false */
-  class ReturnType extends PropertyBase
-  {
-    constructor(v, csn)
-    {
-      super(v, {}, csn);
+  class ReturnType extends PropertyBase {
+    constructor(version, csn) {
+      super(version, {}, csn);
     }
 
     // we need Name but NO $kind, can't use standard to JSON()
-    toJSON()
-    {
-      let json = Object.create(null);
+    toJSON() {
+      const json = Object.create(null);
       this.toJSONattributes(json);
       return json;
     }
   }
 
-  class Property extends PropertyBase
-  {
-    constructor(v, attributes, csn)
-    {
-      super(v, attributes, csn);
+  class Property extends PropertyBase {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn);
       // TIPHANACDS-4180
-      if(this.v2)
-      {
+      if (this.v2) {
         // eslint-disable-next-line sonarjs/no-redundant-boolean
-        if(csn['@odata.etag'] == true || csn['@cds.etag'] == true)
-          this._edmAttributes.ConcurrencyMode='Fixed'
+        if (csn['@odata.etag'] || csn['@cds.etag'])
+          this._edmAttributes.ConcurrencyMode = 'Fixed';
 
         // translate the following @sap annos as xml attributes to the Property
         forEach(csn, (p, v) => {
           if (p in Property.SAP_Annotation_Attributes)
-            this.setXml( { ['sap:' + p.slice(5).replace(/\./g, '-')] : v });
+            this.setXml( { [`sap:${p.slice(5).replace(/\./g, '-')}`]: v });
         });
       }
 
@@ -1006,15 +975,14 @@ function getEdm(options, messageFunctions) {
       // This is a poor man's expr renderer, assuming that edmPreprocessor has
       // added a @Core.ComputedDefaultValue for complex defaults
       if (csn.default && !csn['@Core.ComputedDefaultValue']) {
-
         const def = csn.default;
         // if def has a value, it's a simple value
         let defVal = def.val;
         // if it's a simple value with signs, produce a string representation
-        if(csn.default.xpr) {
-          defVal = csn.default.xpr.map(i => {
-            if(i.val !== undefined) {
-              if(csn.type === 'cds.Boolean')
+        if (csn.default.xpr) {
+          defVal = csn.default.xpr.map((i) => {
+            if (i.val !== undefined) {
+              if (csn.type === 'cds.Boolean')
                 return i.val ? 'true' : 'false';
               return i.val;
             }
@@ -1022,13 +990,12 @@ function getEdm(options, messageFunctions) {
           }).join('');
         }
         // complex values should be marked with @Core.ComputedDefaultValue already in the edmPreprocessor
-        if(defVal !== undefined) {
+        if (this.v4 && defVal !== undefined) {
           /* No Default Value rendering in V2 (or only with future flag).
             Reason: Fiori UI5 expects 'Default' under extension namespace 'sap:'
             Additionally: The attribute is named 'Default' in V2 and 'DefaultValue' in V4
           */
-          if(this.v4)
-            this._edmAttributes[`Default${this.v4 ? 'Value' : ''}`] = defVal;
+          this._edmAttributes[`Default${this.v4 ? 'Value' : ''}`] = defVal;
         }
       }
     }
@@ -1040,72 +1007,72 @@ function getEdm(options, messageFunctions) {
   // the annotations in this array shall become exposed as Property attributes in
   // the V2 metadata.xml
   Property.SAP_Annotation_Attributes = {
-    '@sap.hierarchy.node.for':1,                  // ->   sap:hierarchy-node-for
-    '@sap.hierarchy.parent.node.for':1,           // ->   sap:hierarchy-parent-node-for
-    '@sap.hierarchy.level.for':1,                 // ->   sap:hierarchy-level-for
-    '@sap.hierarchy.drill.state.for':1,           // ->   sap:hierarchy-drill-state-for
-    '@sap.hierarchy.node.descendant.count.for':1, // ->   sap:hierarchy-node-descendant-count-for
-    '@sap.parameter':1
+    '@sap.hierarchy.node.for': 1,                  // ->   sap:hierarchy-node-for
+    '@sap.hierarchy.parent.node.for': 1,           // ->   sap:hierarchy-parent-node-for
+    '@sap.hierarchy.level.for': 1,                 // ->   sap:hierarchy-level-for
+    '@sap.hierarchy.drill.state.for': 1,           // ->   sap:hierarchy-drill-state-for
+    '@sap.hierarchy.node.descendant.count.for': 1, // ->   sap:hierarchy-node-descendant-count-for
+    '@sap.parameter': 1,
   };
 
-  class PropertyRef extends Node
-  {
-    constructor(v, Name, Alias) {
-      super(v, (Alias) ? { Name, Alias } : { Name });
-    }
-
-    toJSON() {
-      return this._edmAttributes.Alias ? { [this._edmAttributes.Alias]:this._edmAttributes.Name } : this._edmAttributes.Name;
-    }
-  }
-
-  class Parameter extends PropertyBase
-  {
-    constructor(v, attributes, csn={}, mode=null)
-    {
-      super(v, attributes, csn);
+  class Parameter extends PropertyBase {
+    constructor(version, attributes, csn = {}, mode = null) {
+      super(version, attributes, csn);
 
-      if(mode != null)
+      if (mode != null)
         this._edmAttributes.Mode = mode;
 
       // 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
-      if(this.v2 && this._edmAttributes.Nullable === undefined)
-        this.setXml({Nullable: true});
+      if (this.v2 && this._edmAttributes.Nullable === undefined)
+        this.setXml({ Nullable: true });
     }
 
-    toJSON()
-    {
+    toJSON() {
       // we need Name but NO $kind, can't use standard to JSON()
-      let json = Object.create(null);
-      json['$Name'] = this._edmAttributes.Name;
+      const json = Object.create(null);
+      json.$Name = this._edmAttributes.Name;
       return this.toJSONattributes(json);
     }
   }
 
   class NavigationPropertyBinding extends Node {}
 
-  class NavigationProperty extends Property
-  {
-    constructor(v, attributes, csn)
-    {
-      super(v, attributes, csn);
+  class OnDelete extends Node {}
+
+  class ReferentialConstraint extends Node {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn);
+      this._d = null;
+      this._p = null;
+    }
+
+    innerXML(indent) {
+      if (this._d && this._p)
+        return `${this._p.toXML(indent)}\n${this._d.toXML(indent)}\n`;
+
+      return super.innerXML(indent);
+    }
+  }
+
+  class NavigationProperty extends Property {
+    constructor(version, attributes, csn) {
+      super(version, attributes, csn);
 
-      let [src, tgt] = edmUtils.determineMultiplicity(csn._constraints._partnerCsn || csn);
-      csn._constraints._multiplicity = csn._constraints._partnerCsn ? [tgt, src] : [src, tgt];
+      const [ src, tgt ] = edmUtils.determineMultiplicity(csn._constraints._partnerCsn || csn);
+      csn._constraints._multiplicity = csn._constraints._partnerCsn ? [ tgt, src ] : [ src, tgt ];
       this._type = attributes.Type;
       this._isCollection = this.isToMany();
       this._targetCsn = csn._target;
 
-      if (this.v4)
-      {
-        if(options.isStructFormat && this._csn.key)
+      if (this.v4) {
+        if (options.isStructFormat && this._csn.key)
           this._edmAttributes.Nullable = false;
 
         // either csn has multiplicity or we have to use the multiplicity of the backlink
-        if(this._isCollection) {
-          this._edmAttributes.Type = `Collection(${attributes.Type})`
+        if (this._isCollection) {
+          this._edmAttributes.Type = `Collection(${attributes.Type})`;
           // attribute Nullable is not allowed in combination with Collection (see Spec)
           // Even if min cardinality is > 0, remove Nullable, because the implicit OData contract
           // is that a navigation property must either return an empty collection or all collection
@@ -1113,15 +1080,15 @@ function getEdm(options, messageFunctions) {
           delete this._edmAttributes.Nullable;
         }
         // we have exactly one selfReference or the default partner
-        let partner =
-          !csn.$noPartner ?
-            csn._selfReferences.length === 1
+        const partner
+          = !csn.$noPartner
+            ? csn._selfReferences.length === 1
               ? csn._selfReferences[0]
               : csn._constraints._partnerCsn
             : undefined;
-        if(partner && partner['@odata.navigable'] !== false && this._csn._edmParentCsn.kind !== 'type') {
+        if (partner && partner['@odata.navigable'] !== false && this._csn._edmParentCsn.kind !== 'type') {
           // $abspath[0] is main entity
-          this._edmAttributes.Partner = partner.$abspath.slice(1).join(options.pathDelimiter);
+          this._edmAttributes.Partner = partner.$abspath.slice(1).join('/');
         }
 
         /*
@@ -1134,20 +1101,19 @@ function getEdm(options, messageFunctions) {
           2) ContainsTarget stems from the @odata.contained annotation
         */
         // eslint-disable-next-line sonarjs/no-redundant-boolean
-        if(csn['@odata.contained'] == true || csn.containsTarget) {
+        if (csn['@odata.contained'] || csn.containsTarget)
           this._edmAttributes.ContainsTarget = true;
-        }
-        if(this._edmAttributes.ContainsTarget === undefined && csn.type === 'cds.Composition') {
+
+        if (this._edmAttributes.ContainsTarget === undefined && csn.type === 'cds.Composition') {
           // Delete is redundant in containment
           // TODO: to be specified via @sap.on.delete
-          this.append(new OnDelete(v, { Action: 'Cascade' } ) );
+          this.append(new OnDelete(version, { Action: 'Cascade' } ) );
         }
-
       }
 
       if (this.v2 && this.isNotNullable()) {
-          // in V2 not null must be expressed with target cardinality of 1 or more,
-          // store Nullable=false and evaluate in determineMultiplicity()
+        // in V2 not null must be expressed with target cardinality of 1 or more,
+        // store Nullable=false and evaluate in determineMultiplicity()
         delete this._edmAttributes.Nullable;
       }
       // A nav prop has no default value
@@ -1163,8 +1129,8 @@ function getEdm(options, messageFunctions) {
       return this._csn._isToContainer || this._csn['@odata.contained'];
     }
 
-    isNotNullable(csn=undefined) {
-      let nodeCsn = csn || this._csn;
+    isNotNullable(csn = undefined) {
+      const nodeCsn = csn || this._csn;
       // Set Nullable=false only if 'NOT NULL' was specified in the model
       // Do not derive Nullable=false from key attribute.
       // OR if an association has cardinality.min > 0
@@ -1182,101 +1148,79 @@ function getEdm(options, messageFunctions) {
       return (this._isCollection || this._csn._constraints._multiplicity[1] === '*');
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       // use the original type, not the decorated one
       super.toJSONattributes(json);
-      json['$Type'] = this._type;
+      json.$Type = this._type;
 
       // attribute Nullable is not allowed in combination with Collection (see Spec)
-      if(json['$Collection'])
-        delete json['$Nullable'];
+      if (json.$Collection)
+        delete json.$Nullable;
       return json;
     }
 
-    toJSONchildren(json)
-    {
-      let json_constraints = Object.create(null);
-      this._children.forEach(c => {
-        switch(c.kind) {
+    toJSONchildren(json) {
+      const jsonConstraints = Object.create(null);
+      this._children.forEach((c) => {
+        switch (c.kind) {
           case 'ReferentialConstraint':
             // collect ref constraints in dictionary
-            json_constraints[c._edmAttributes.Property] = c._edmAttributes.ReferencedProperty;
+            jsonConstraints[c._edmAttributes.Property] = c._edmAttributes.ReferencedProperty;
             break;
           case 'OnDelete':
-            json['$OnDelete'] = c._edmAttributes.Action;
+            json.$OnDelete = c._edmAttributes.Action;
             break;
           default:
-            error(null, 'Please debug me: Unhandled NavProp child: ' + c.kind);
-
+            error(null, `Please debug me: Unhandled NavProp child: ${c.kind}`);
         }
       });
       // TODO Annotations
-      if(Object.keys(json_constraints).length > 0)
-        json['$ReferentialConstraint'] = json_constraints;
+      if (Object.keys(jsonConstraints).length > 0)
+        json.$ReferentialConstraint = jsonConstraints;
       return json;
     }
 
     // V4 referential constraints!
-    addReferentialConstraintNodes()
-    {
+    addReferentialConstraintNodes() {
       // flip the constrains if this is a $self partner
-      let _constraints = this._csn._constraints;
-      let [i,j] = [0,1];
-      if(this._csn._constraints._partnerCsn) {
+      let { _constraints } = this._csn;
+      let [ i, j ] = [ 0, 1 ];
+      if (this._csn._constraints._partnerCsn) {
         _constraints = this._csn._constraints._partnerCsn._constraints;
-        [i,j] = [1,0];
+        [ i, j ] = [ 1, 0 ];
       }
-      _constraints.constraints && Object.values(_constraints.constraints).forEach(c =>
-        this.append(new ReferentialConstraint(this._v,
-          { Property: c[i].join(options.pathDelimiter), ReferencedProperty: c[j].join(options.pathDelimiter) } ) )
-      );
-    }
-  }
-
-  class ReferentialConstraint extends Node
-  {
-    constructor(v, attributes, csn) {
-      super(v, attributes, csn);
-      this._d = null;
-      this._p = null;
-    }
-
-    innerXML(indent)
-    {
-      if(this._d && this._p)
-      {
-        return this._p.toXML(indent) + '\n' + this._d.toXML(indent) + '\n';
+      if (_constraints.constraints) {
+        Object.values(_constraints.constraints)
+          .forEach(c => this.append(
+            new ReferentialConstraint(this._v,
+                                      {
+                                        Property: c[i].join(options.pathDelimiter),
+                                        ReferencedProperty: c[j].join(options.pathDelimiter),
+                                      } )
+          ));
       }
-      else
-        return super.innerXML(indent);
     }
   }
 
-  class OnDelete extends Node {}
-
   // Annotations below
-  class AnnotationBase extends Node
-  {
+  class AnnotationBase extends Node {
     // No Kind: AnnotationBase is base class for Thing and ValueThing with dynamic kinds,
     // this requires an explicit constructor as the kinds cannot be blacklisted in
     // Node.toJSON()
-    toJSON()
-    {
-      let json = Object.create(null);
+    toJSON() {
+      const json = Object.create(null);
       this.toJSONattributes(json);
       this.toJSONchildren(json);
-      return json
+      return json;
     }
 
-    getConstantExpressionValue()
-    {
+    getConstantExpressionValue() {
       // short form: key: value
-      const inlineConstExpr =
-        [ 'Edm.Binary', 'Edm.Boolean', 'Edm.Byte', 'Edm.Date', 'Edm.DateTimeOffset', 'Edm.Decimal', 'Edm.Double', 'Edm.Duration', 'Edm.Guid',
-          'Edm.Int16', 'Edm.Int32', 'Edm.Int64', 'Edm.SByte','Edm.Single', 'Edm.Stream', 'Edm.String', 'Edm.TimeOfDay',
+      const inlineConstExpr
+        = [ 'Edm.Binary', 'Edm.Boolean', 'Edm.Byte', 'Edm.Date', 'Edm.DateTimeOffset', 'Edm.Decimal', 'Edm.Double', 'Edm.Duration', 'Edm.Guid',
+          'Edm.Int16', 'Edm.Int32', 'Edm.Int64', 'Edm.SByte', 'Edm.Single', 'Edm.Stream', 'Edm.String', 'Edm.TimeOfDay',
           // Edm.Geo* according to https://issues.oasis-open.org/browse/ODATA-1323
-/*          'Edm.Geography', 'Edm.GeographyPoint', 'Edm.GeographyLineString', 'Edm.GeographyPolygon', 'Edm.GeographyMultiPoint',
+          /*          'Edm.Geography', 'Edm.GeographyPoint', 'Edm.GeographyLineString', 'Edm.GeographyPolygon', 'Edm.GeographyMultiPoint',
           'Edm.GeographyMultiLineString', 'Edm.GeographyMultiPolygon', 'Edm.GeographyCollection', 'Edm.Geometry', 'Edm.GeometryPoint',
           'Edm.GeometryLineString', 'Edm.GeometryPolygon', 'Edm.GeometryMultiPoint', 'Edm.GeometryMultiLineString', 'Edm.GeometryMultiPolygon',
           'Edm.GeometryCollection',
@@ -1284,72 +1228,60 @@ function getEdm(options, messageFunctions) {
           /* UI.xml: defines Annotations with generic type 'Edm.PrimitiveType' */
           'Edm.PrimitiveType', 'Edm.Untyped', 'Bool',
           // Official JSON V4.01 Spec defines these paths as constant inline expression:
-          'AnnotationPath', 'ModelElementPath', 'NavigationPropertyPath', 'PropertyPath',
-        ];
+          'AnnotationPath', 'ModelElementPath', 'NavigationPropertyPath', 'PropertyPath' ];
 
       const dict = this._jsonOnlyAttributes;
       const inline = edmUtils.intersect(Object.keys(dict), inlineConstExpr);
-      if(inline.length === 1)
-      {
-        let v = dict[inline[0]];
-        switch(inline[0])
-        {
-          /* short notation for Edm.Boolean, Edm.String and Edm.Float, see internal project:
-             edmx2csn-npm/edm-converters/blob/835d92a1aa6b0be25c56cef85e260c9188187429/lib/edmxV40ToJsonV40/README.md
-          */
-          case 'Edm.Boolean':
-            v = (v=='true'?true:(v=='false'?false:v));
-            // eslint-no-fallthrough
-          default:
-            return v;
-        }
-      }
-      else
-      {
-        // if this is not a constant expression shortcut, render key/value pair verbatim
-        // without filtering non-spec-compliant constExpr
-        let json = Object.create(null);
-        Object.entries(dict).forEach(([k,v]) => {
-          json['$'+k] = v;
-        });
-        return json;
+      if (inline.length === 1) {
+        const v = dict[inline[0]];
+        /* short notation for Edm.Boolean, Edm.String and Edm.Float, see internal project:
+           edmx2csn-npm/edm-converters/blob/835d92a1aa6b0be25c56cef85e260c9188187429/lib/edmxV40ToJsonV40/README.md
+        */
+        if (inline[0] === 'Edm.Boolean')
+          return (v === 'true' ? true : (v === 'false' ? false : v));
+        return v;
       }
+
+      // if this is not a constant expression shortcut, render key/value pair verbatim
+      // without filtering non-spec-compliant constExpr
+      const json = Object.create(null);
+      Object.entries(dict).forEach(([ k, v ]) => {
+        json[`$${k}`] = v;
+      });
+      return json;
     }
 
-    mergeJSONAnnotations(prefix='') {
+    mergeJSONAnnotations(prefix = '') {
       return this._children.filter(c => c.kind === 'Annotation').reduce((o, a) => {
-        Object.entries(a.toJSON()).forEach(([n, v]) => {
-          o[prefix+n] = v;
+        Object.entries(a.toJSON()).forEach(([ n, v ]) => {
+          o[prefix + n] = v;
         });
-        return o; },
-        Object.create(null));
+        return o;
+      },
+                                                                        Object.create(null));
     }
   }
 
-  class Annotations extends AnnotationBase
-  {
-    constructor(v, target)
-    {
-      super(v, { Target: target });
-      this.setXml( { xmlns : this.v2 ? 'http://docs.oasis-open.org/odata/ns/edm' : undefined } );
+  class Annotations extends AnnotationBase {
+    constructor(version, target) {
+      super(version, { Target: target });
+      this.setXml( { xmlns: this.v2 ? 'http://docs.oasis-open.org/odata/ns/edm' : undefined } );
     }
 
-    toJSONattributes(json)
-    {
+    toJSONattributes(json) {
       forEach(this._edmAttributes, (p, v) => {
         if (p !== 'Target')
-          json[p[0] === '@' ? p : '$' + p] = v;
+          json[p[0] === '@' ? p : `$${p}`] = v;
       });
       return json;
     }
 
-    toJSONchildren(json)
-    {
-      this._children.forEach(a => {
-        Object.entries(a.toJSON()).forEach(([n, v]) => {
+    toJSONchildren(json) {
+      this._children.forEach((a) => {
+        Object.entries(a.toJSON()).forEach(([ n, v ]) => {
           json[n] = v;
         });
-      })
+      });
     }
   }
 
@@ -1365,18 +1297,15 @@ function getEdm(options, messageFunctions) {
   // the constant expression value is the same for both XML and JSON. But
   // since it was discovered, that in JSON the EnumMember type must be
   // transported this is no longer the case....
-  class Annotation extends AnnotationBase
-  {
-    constructor(v, termName)
-    {
-      super(v, { Term: termName } );
+  class Annotation extends AnnotationBase {
+    constructor(version, termName) {
+      super(version, { Term: termName } );
     }
 
-    toJSON()
-    {
+    toJSON() {
       const json = super.mergeJSONAnnotations(this.getJsonFQTermName());
       const e = this._children.filter(c => c.kind !== 'Annotation');
-      if(e.length === 0 || this._ignoreChildren) // must be a constant expression
+      if (e.length === 0 || this._ignoreChildren) // must be a constant expression
         json[this.getJsonFQTermName()] = this.getConstantExpressionValue();
       else
         // annotation must have exactly one child (=record or collection)
@@ -1385,44 +1314,38 @@ function getEdm(options, messageFunctions) {
     }
 
     getJsonFQTermName() {
-      return '@' + this._edmAttributes.Term + (this._edmAttributes.Qualifier ? '#' + this._edmAttributes.Qualifier : '');
+      return `@${this._edmAttributes.Term}${this._edmAttributes.Qualifier ? `#${this._edmAttributes.Qualifier}` : ''}`;
     }
   }
 
-  class Collection extends AnnotationBase
-  {
-    toJSON()
-    {
+  class Collection extends AnnotationBase {
+    toJSON() {
       // EDM JSON doesn't mention annotations on collections
       return this._children.map(a => a.toJSON());
     }
   }
 
-  class Record extends AnnotationBase
-  {
-    toJSONattributes(json)
-    {
-      if(this._jsonOnlyAttributes.Type)
+  class Record extends AnnotationBase {
+    toJSONattributes(json) {
+      if (this._jsonOnlyAttributes.Type)
         json['@type'] = this._jsonOnlyAttributes.Type;
-      let keys = Object.keys(this._edmAttributes).filter(k => k !== 'Type');
-      for(const key of keys)
-        json['$'+key] = this._edmAttributes[key];
+      const keys = Object.keys(this._edmAttributes).filter(k => k !== 'Type');
+      for (const key of keys)
+        json[`$${key}`] = this._edmAttributes[key];
     }
 
-    toJSONchildren(json)
-    {
-      this._children.forEach(c => {
-        switch(c.kind)
-        {
+    toJSONchildren(json) {
+      this._children.forEach((c) => {
+        switch (c.kind) {
           case 'Annotation': {
-            Object.entries(c.toJSON()).forEach(([n, v]) => {
+            Object.entries(c.toJSON()).forEach(([ n, v ]) => {
               json[n] = v;
             });
             break;
           }
           case 'PropertyValue': {
             // plus property annotations as [a.Property]@anno: val
-            Object.entries(c.mergeJSONannotations()).forEach(([n, a]) => {
+            Object.entries(c.mergeJSONannotations()).forEach(([ n, a ]) => {
               json[n] = a;
             });
             // render property as const expr (or subnode)
@@ -1430,89 +1353,73 @@ function getEdm(options, messageFunctions) {
             break;
           }
           default:
-            error(null, 'Pease debug me: Unhandled Record child: ' + c.kind);
+            error(null, `Pease debug me: Unhandled Record child: ${c.kind}`);
         }
       });
     }
   }
 
-  class PropertyValue extends AnnotationBase
-  {
-    constructor(v, property)
-    {
-      super(v);
+  class PropertyValue extends AnnotationBase {
+    constructor(version, property) {
+      super(version);
       this._edmAttributes.Property = property;
     }
 
-    toJSON()
-    {
-      const c = this._children.filter(c => c.kind !== 'Annotation')
-      if(c.length === 0 || this._ignoreChildren)
+    toJSON() {
+      const children = this._children.filter(child => child.kind !== 'Annotation');
+      if (children.length === 0 || this._ignoreChildren)
         return this.getConstantExpressionValue();
-      else
-      {
-        return c[0].toJSON();
-      }
+
+      return children[0].toJSON();
     }
     mergeJSONannotations() {
       return super.mergeJSONAnnotations(this._edmAttributes.Property);
     }
   }
 
-  class Thing extends AnnotationBase
-  {
-    constructor(v, kind, details)
-    {
-      super(v, details);
+  class Thing extends AnnotationBase {
+    constructor(version, kind, details) {
+      super(version, details);
       this._kind = kind;
     }
 
-    get kind() { return this._kind; }
+    get kind() {
+      return this._kind;
+    }
   }
 
-  class ValueThing extends Thing
-  {
-    constructor(v, kind, value)
-    {
-      super(v, kind, undefined);
+  class ValueThing extends Thing {
+    constructor(version, kind, value) {
+      super(version, kind, undefined);
       this._value = value;
     }
 
-    toXML(indent='')
-    {
-      let kind = this.kind;
-      let xml = indent + '<' + kind + this.toXMLattributes();
-      xml +=  (this._value !== undefined ? '>' + edmUtils.escapeStringForText(this._value) + '</' + kind + '>' : '/>');
+    toXML(indent = '') {
+      const { kind } = this;
+      let xml = `${indent}<${kind}${this.toXMLattributes()}`;
+      xml += (this._value !== undefined ? `>${edmUtils.escapeStringForText(this._value)}</${kind}>` : '/>');
       return xml;
     }
 
-    toJSON()
-    {
-      if(this._children.length === 0 || this._ignoreChildren) // must be a constant expression
+    toJSON() {
+      if (this._children.length === 0 || this._ignoreChildren) // must be a constant expression
         return this.getConstantExpressionValue();
-      else
-        // annotation must have exactly one child (=record or collection)
-        return this._children[0].toJSON();
+      return this._children[0].toJSON();
     }
   }
 
   // Binary/Unary dynamic expression
   class Expr extends Thing {
-    constructor(v, kind, details) {
-      super(v, kind, details);
-    }
-
-    toJSON()
-    {
+    toJSON() {
       // toJSON: depending on number of children unary or n-ary expr
       const json = this.mergeJSONAnnotations();
-      const e = this._children.filter(c=>c.kind !== 'Annotation');
-      if(e.length === 1) {
-        json['$'+this.kind] = e[0].toJSON();
-      }
-      else {
-        json['$'+this.kind] = e.map(c => c.toJSON());
-      }
+      const e = this._children.filter(c => c.kind !== 'Annotation');
+      if (e.length === 1)
+        json[`$${this.kind}`] = e[0].toJSON();
+
+      else
+        json[`$${this.kind}`] = e.map(c => c.toJSON());
+
       return json;
     }
   }
@@ -1523,14 +1430,14 @@ function getEdm(options, messageFunctions) {
     }
     toJSON() {
       const json = this.mergeJSONAnnotations();
-      json['$'+this.kind] = null;
+      json[`$${this.kind}`] = null;
       return json;
     }
   }
   class Apply extends AnnotationBase {
     toJSON() {
       const json = this.mergeJSONAnnotations();
-      json['$'+this.kind] = this._children.filter(c=>c.kind !== 'Annotation').map(c => c.toJSON());
+      json[`$${this.kind}`] = this._children.filter(c => c.kind !== 'Annotation').map(c => c.toJSON());
       this.toJSONattributes(json);
       return json;
     }
@@ -1538,24 +1445,25 @@ function getEdm(options, messageFunctions) {
   class Cast extends AnnotationBase {
     toXMLattributes() {
       // TODO: Why json?
-      if(this._jsonOnlyAttributes['Collection'])
-        return ` Type="Collection(${this._edmAttributes.Type})"`
-      else
-        return ` Type="${this._edmAttributes.Type}"`
+      if (this._jsonOnlyAttributes.Collection)
+        return ` Type="Collection(${this._edmAttributes.Type})"`;
+      return ` Type="${this._edmAttributes.Type}"`;
     }
     toJSON() {
       const json = this.mergeJSONAnnotations();
       // first expression only, if any
-      const c = this._children.filter(c=>c.kind !== 'Annotation');
-      json['$'+this.kind] = c.length ? c[0].toJSON() : {};
+      const children = this._children.filter(child => child.kind !== 'Annotation');
+      json[`$${this.kind}`] = children.length ? children[0].toJSON() : {};
       this.toJSONattributes(json);
       return json;
     }
     toJSONattributes(json) {
       super.toJSONattributes(json);
-      this._jsonOnlyAttributes && Object.entries(this._jsonOnlyAttributes).forEach(([p, v]) => {
-        json[p[0] === '@' ? p : '$' + p] = v;
-      });
+      if (this._jsonOnlyAttributes) {
+        Object.entries(this._jsonOnlyAttributes).forEach(([ p, v ]) => {
+          json[p[0] === '@' ? p : `$${p}`] = v;
+        });
+      }
       return json;
     }
   }
@@ -1564,7 +1472,7 @@ function getEdm(options, messageFunctions) {
   class If extends AnnotationBase {
     toJSON() {
       const json = this.mergeJSONAnnotations();
-      json['$'+this.kind] = this._children.filter(c=>c.kind !== 'Annotation').map(c => c.toJSON());
+      json[`$${this.kind}`] = this._children.filter(c => c.kind !== 'Annotation').map(c => c.toJSON());
       return json;
     }
   }
@@ -1572,97 +1480,94 @@ function getEdm(options, messageFunctions) {
     toJSON() {
       const json = this.mergeJSONAnnotations();
       // first expression only, if any
-      const c = this._children.filter(c=>c.kind !== 'Annotation');
-      json['$'+this.kind] = c.length ? c[0].toJSON() : '';
+      const children = this._children.filter(child => child.kind !== 'Annotation');
+      json[`$${this.kind}`] = children.length ? children[0].toJSON() : '';
       this.toJSONattributes(json);
       return json;
     }
 
-    toJSONattributes(json) // including Name
-    {
+    toJSONattributes(json) { // including Name
       forEach(this._edmAttributes, (p, v) => {
-        json[p[0] === '@' ? p : '$' + p] = v;
+        json[p[0] === '@' ? p : `$${p}`] = v;
       });
       return json;
     }
   }
   // LabeledElementReference is a
   class LabeledElementReference extends ValueThing {
-    constructor(v, val) {
-      super(v, 'LabeledElementReference', val);
+    constructor(version, val) {
+      super(version, 'LabeledElementReference', val);
     }
   }
   class UrlRef extends AnnotationBase {
     toJSON() {
       const json = this.mergeJSONAnnotations();
       // first expression only, if any
-      const c = this._children.filter(c=>c.kind !== 'Annotation');
-      json['$'+this.kind] = c.length ? c[0].toJSON() : {};
+      const children = this._children.filter(child => child.kind !== 'Annotation');
+      json[`$${this.kind}`] = children.length ? children[0].toJSON() : {};
       return json;
     }
   }
 
   // V2 specials
   class End extends Node {}
-  class Association extends Node
-  {
-    constructor(v, details, navProp, fromRole, toRole, multiplicity)
-    {
-      super(v, details);
+  class Association extends Node {
+    constructor(version, details, navProp, fromRole, toRole, multiplicity) {
+      super(version, details);
       this._end = [
-        new End(v, { Role: fromRole[0], Type: fromRole[1], Multiplicity: multiplicity[0] } ),
-        new End(v, { Role: toRole[0], Type: toRole[1], Multiplicity: multiplicity[1] } )
+        new End(version, { Role: fromRole[0], Type: fromRole[1], Multiplicity: multiplicity[0] } ),
+        new End(version, { Role: toRole[0], Type: toRole[1], Multiplicity: multiplicity[1] } ),
       ];
 
       // set Delete:Cascade on composition end
-      if(navProp._csn.type === 'cds.Composition')
-        this._end[0].append(new OnDelete(v, { Action: 'Cascade' }));
+      if (navProp._csn.type === 'cds.Composition')
+        this._end[0].append(new OnDelete(version, { Action: 'Cascade' }));
 
-      if(navProp._csn._selfReferences && navProp._csn._selfReferences.length &&
+      if (navProp._csn._selfReferences && navProp._csn._selfReferences.length &&
          navProp._csn._selfReferences[0].type === 'cds.Composition')
-        this._end[1].append(new OnDelete(v, { Action: 'Cascade' }));
+        this._end[1].append(new OnDelete(version, { Action: 'Cascade' }));
     }
 
-    innerXML(indent)
-    {
+    innerXML(indent) {
       let xml = '';
-      this._end.forEach(e => xml += e.toXML(indent) + '\n');
+      this._end.forEach((e) => {
+        xml += `${e.toXML(indent)}\n`;
+      });
       xml += super.innerXML(indent);
       return xml;
     }
   }
 
-  class AssociationSet extends Node
-  {
-    constructor(v, details, fromRole, toRole, fromEntitySet, toEntitySet)
-    {
-      super(v, details);
+  class AssociationSet extends Node {
+    constructor(version, details, fromRole, toRole, fromEntitySet, toEntitySet) {
+      super(version, details);
       this.append(
-          new End(v, { Role: fromRole, EntitySet: fromEntitySet } ),
-          new End(v, { Role: toRole,   EntitySet: toEntitySet } )
-        );
+        new End(version, { Role: fromRole, EntitySet: fromEntitySet } ),
+        new End(version, { Role: toRole, EntitySet: toEntitySet } )
+      );
     }
     getDuplicateMessage() {
-      return `Association "${this._edmAttributes.Association}"`
+      return `Association "${this._edmAttributes.Association}"`;
     }
-}
+  }
 
   class Dependent extends Node {}
   class Principal extends Node {}
 
-  ReferentialConstraint.createV2 =
-    function(v, from, to, c)
-    {
-      let node = new ReferentialConstraint(v, {});
+  ReferentialConstraint.createV2
+    = (v, from, to, c) => {
+      const node = new ReferentialConstraint(v, {});
       node._d = new Dependent(v, { Role: from } );
       node._p = new Principal(v, { Role: to } );
 
-      c && Object.values(c).forEach(cv => {
-        node._d.append(new PropertyRef(v, cv[0].join(options.pathDelimiter)));
-        node._p.append(new PropertyRef(v, cv[1].join(options.pathDelimiter)));
-      });
+      if (c) {
+        Object.values(c).forEach((cv) => {
+          node._d.append(new PropertyRef(v, cv[0].join(options.pathDelimiter)));
+          node._p.append(new PropertyRef(v, cv[1].join(options.pathDelimiter)));
+        });
+      }
       return node;
-    }
+    };
 
   return {
     Edm,
@@ -1680,7 +1585,7 @@ function getEdm(options, messageFunctions) {
     ComplexType,
     EntityType,
     Key,
-    //ActionFunctionBase,
+    // ActionFunctionBase,
     FunctionDefinition,
     Action,
     FunctionImport,
@@ -1717,9 +1622,10 @@ function getEdm(options, messageFunctions) {
     Association,
     AssociationSet,
     Dependent,
-    Principal
-  }
-
+    Principal,
+  };
 } // instance function
 
-module.exports = { EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap, getEdm };
+module.exports = {
+  EdmTypeFacetMap, EdmTypeFacetNames, EdmPrimitiveTypeMap, getEdm,
+};