@sap/cds-dk 4.9.6 → 6.0.2

package/lib/import/{v4parser.js → odata/v4parser.js}

@@ -3,72 +3,60 @@
  * OData V4 to CSN parser
  */
 
+"use strict";
 
-'use strict';
-let messages = require("./message").getMessages();
-let common = require("./common");
-let versionInfo = require('../../package.json').version;
-let namespace;
-let complexTypes = {};
-let enumTypes = {};
-let typeDefinitions = {};
-let unboundedActions = {};
-let boundedActions = {};
-let unboundedFunctions = {};
-let boundedFunctions = {};
-let errors = [];
-let Multimap = require('../import/utils/MultiMap.js');
-let entitySetToEntityTypeMap = new Multimap();
-let actionImportToActionMap = new Multimap();
-let functionImportToFunctionMap = new Multimap();
-let validEdmDatatypes = ['Edm.DateTimeOffset'];
-let jsonEntityContainerName;
-let entityTypes = [];
-const ignoreObjects = ['$Reference']; // add all the objects that needs to be ignored for parsing.
-const { warn } = require('@sap/cds/bin/utils/term');
+let messages = require("../message").getMessages();
+let common = require("../common");
+let versionInfo = require("../../../package.json").version;
+let Multimap = require("./util/MultiMap");
+const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ignored for parsing.
+const validEdmDatatypes = ["Edm.DateTimeOffset"];
+const { warn } = require("../../util/term");
+const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
 
-const MetadataConverterFactory = require('../import/utils/MetadataConverterFactory');
 const edmxncdsdatatype = {
-    'Edm.String': 'cds.LargeString',
-    'Edm.Boolean': 'cds.Boolean',
-    'Edm.Int16': 'cds.Integer',
-    'Edm.Int32': 'cds.Integer',
-    'Edm.Int64': 'cds.Integer64',
-    'Edm.Decimal': 'cds.DecimalFloat',
-    'Edm.DateTimeOffset': 'cds.DateTime',
-    'Edm.TimeOfDay': 'cds.Time',
-    'Edm.Date': 'cds.Date',
-    'Edm.Binary': 'cds.LargeBinary',
-    'Edm.Guid': 'cds.UUID',
-    'Edm.Byte': 'cds.Integer',
-    'Edm.SByte': 'cds.Integer',
-    'Edm.Double': 'cds.Double',
+    "Edm.String": "cds.LargeString",
+    "Edm.Boolean": "cds.Boolean",
+    "Edm.Int16": "cds.Integer",
+    "Edm.Int32": "cds.Integer",
+    "Edm.Int64": "cds.Integer64",
+    "Edm.Decimal": "cds.Decimal",
+    "Edm.DateTimeOffset": "cds.DateTime",
+    "Edm.TimeOfDay": "cds.Time",
+    "Edm.Date": "cds.Date",
+    "Edm.Binary": "cds.LargeBinary",
+    "Edm.Guid": "cds.UUID",
+    "Edm.Double": "cds.Double",
     // Special handling of data types
-    'Edm.String_m': 'cds.String', // Max length
-    'Edm.Decimal_p': 'cds.Decimal', // Precision, scale
+    "Edm.String_m": "cds.String", // Max length
+    "Edm.Decimal_p": "cds.Decimal", // Precision, scale
     //'Edm.DateTime_f': 'cds.Date', // sap:display-format="Date"
     //'Edm.DateTimeOffset_f': 'cds.Date', // sap:display-format="Date"
-    'Edm.Binary_m': 'cds.Binary', // Max Length
-    'Edm.Byte_m': 'cds.Integer', // Max Length
-    'Edm.Double_p': 'cds.Double', // Precision, scale
+    "Edm.Binary_m": "cds.Binary", // Max Length
+    "Edm.Byte_m": "cds.Integer", // Max Length
+    "Edm.Double_p": "cds.Double", // Precision, scale
     // Special handling with annotations
-	"Edm.Single_a": "cds.Double",
-	"Edm.Stream_a" : "cds.LargeBinary",
-	"Edm.DateTimeOffset_a" : "cds.Timestamp"
+    "Edm.Byte_a": "cds.Integer",
+    "Edm.SByte_a": "cds.Integer",
+    "Edm.Single_a": "cds.Double",
+    "Edm.Stream_a": "cds.LargeBinary",
+    "Edm.DateTimeOffset_a": "cds.Timestamp",
 };
 
-function _initialize() {
-    unboundedActions = {};
-    boundedActions = {};
-    unboundedFunctions = {};
-    boundedFunctions = {};
-    entityTypes = [];
-    namespace = "";
-    complexTypes = {};
-    enumTypes = {};
-    typeDefinitions = {};
-    jsonEntityContainerName = "";
-
+function _initialize(parserContext) {
+    parserContext.unboundedActions = {};
+    parserContext.boundedActions = {};
+    parserContext.unboundedFunctions = {};
+    parserContext.boundedFunctions = {};
+    parserContext.entityTypes = [];
+    parserContext.namespace = "";
+    parserContext.complexTypes = {};
+    parserContext.enumTypes = {};
+    parserContext.typeDefinitions = {};
+    parserContext.jsonEntityContainerName = "";
+    parserContext.entitySetToEntityTypeMap = new Multimap();
+    parserContext.actionImportToActionMap = new Multimap();
+    parserContext.functionImportToFunctionMap = new Multimap();
 }
 
 function _isJson(edmx) {
@@ -89,12 +77,12 @@ function _isValidDataType(propertyType) {
     return false;
 }
 
-function _isValidJSON(jsonObj) {
+function _isValidJSON(jsonObj, parserContext) {
     let tempNamespace = jsonObj.$EntityContainer;
-    namespace = tempNamespace.substring(0, tempNamespace.lastIndexOf('.'));
-    jsonEntityContainerName = tempNamespace.substring(tempNamespace.lastIndexOf('.') + 1);
+    parserContext.namespace = tempNamespace.substring(0, tempNamespace.lastIndexOf('.'));
+    parserContext.jsonEntityContainerName = tempNamespace.substring(tempNamespace.lastIndexOf('.') + 1);
 
-    if (jsonObj.$Version && jsonObj.$EntityContainer && jsonObj[namespace]) {
+    if (jsonObj.$Version && jsonObj.$EntityContainer && jsonObj[parserContext.namespace]) {
         return true;
     }
     else {
@@ -102,40 +90,24 @@ function _isValidJSON(jsonObj) {
     }
 }
 
-function _hasEntityContainer(jsonObj) {
-    if (jsonObj[namespace][jsonEntityContainerName] && jsonObj[namespace][jsonEntityContainerName] instanceof Object) {
+function _hasEntityContainer(jsonObj, parserContext) {
+    if (jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] && 
+        jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] instanceof Object
+    ) {
         return true;
     } else {
         throw new Error(messages.MISSING_ENTITY_CONTAINER);
     }
 }
 
-function _hasEntitySet(jsonObj) {
-    let entitySetCount = 0;
-    let entityContainerData = jsonObj[namespace][jsonEntityContainerName];
-    Object.keys(entityContainerData).forEach(data => {
-        if (ignoreObjects.indexOf(data) === -1 && entityContainerData[data] instanceof Object) {
-            if (entityContainerData[data].$Collection === true) {
-                entitySetCount += 1;
-            }
-        }
-    });
-
-    if (entitySetCount == 0) {
-        throw new Error(messages.MISSING_ENTITY_SETS);
-    }
-    return true;
-}
-
-function _validateJSON(jsonObj) {
+function _validateJSON(jsonObj, parserContext) {
     return (
-        _isValidJSON(jsonObj) &&
-        _hasEntityContainer(jsonObj) &&
-        _hasEntitySet(jsonObj)
+        _isValidJSON(jsonObj, parserContext) &&
+        _hasEntityContainer(jsonObj, parserContext)
     );
 }
 
-function _includeExternalNamespaceAnnotation(source,target){
+function _includeExternalNamespaceAnnotation(source, target) {
     Object.entries(source).forEach(element => {
         if (element[0].startsWith('@')) {
             target[element[0]] = element[1];
@@ -144,11 +116,11 @@ function _includeExternalNamespaceAnnotation(source,target){
 }
 
 function _typeWithCollections(property, type, isCollection) {
-  if (isCollection === true) {
-    property.items = type;
-  } else {
-    Object.assign(property, type);
-  }
+    if (isCollection === true) {
+        property.items = type;
+    } else {
+        Object.assign(property, type);
+    }
 }
 
 function generatePropertyCsn(propertyType, isPrimaryKey) {
@@ -160,7 +132,7 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
         if (propertyType.$Collection)
             throw new Error(messages.COLLECTION_IN_KEY);
     }
-    _includeExternalNamespaceAnnotation(propertyType,property);
+    _includeExternalNamespaceAnnotation(propertyType, property);
     // conditions have to be made
     if (propertyType.$MaxLength) {
         if (propertyType.$Type) {
@@ -169,34 +141,35 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
             typeProperties.type = 'cds.String'; // if type is missing, then it is String type
         }
         typeProperties.length = propertyType.$MaxLength;
-    } else if(_isValidDataType(propertyType.$Type)) {
-        if(propertyType.$Precision && propertyType.$Precision > 0)
-        {
+    } else if (_isValidDataType(propertyType.$Type)) {
+        if (propertyType.$Precision && propertyType.$Precision > 0) {
             typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_a'];
-            typeProperties["@odata.precision"] = propertyType.$Precision;
+            typeProperties["@odata.Precision"] = propertyType.$Precision;
         } else {
             typeProperties.type = edmxncdsdatatype[propertyType.$Type];
-            typeProperties["@odata.precision"] = 0;
+            typeProperties["@odata.Precision"] = 0;
         }
     } else if (propertyType.$Precision && !_isValidDataType(propertyType.$Type)) {
         typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_p'];
-        typeProperties.precision = propertyType.$Precision;
-        if (propertyType.$Scale && propertyType.$Scale == 'variable') {
-            typeProperties.scale = propertyType.$Precision;
-            typeProperties.precision = propertyType.$Precision * 2;
-        } else {
+        if (propertyType.$Scale && !(propertyType.$Scale == 'variable' || propertyType.$Scale == 'floating')) {
             typeProperties.scale = propertyType.$Scale;
+            typeProperties.precision = propertyType.$Precision;
         }
     } else if (edmxncdsdatatype[propertyType.$Type + "_a"]) {
         typeProperties.type = edmxncdsdatatype[propertyType.$Type + "_a"];
     } else if (propertyType.$Type) {
         typeProperties.type = edmxncdsdatatype[propertyType.$Type];
-    } else{
+    } else {
         typeProperties.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
 
     if (edmxncdsdatatype[propertyType.$Type + '_a']) {
-        typeProperties["@odata.type"] = propertyType.$Type;
+        if (edmxncdsdatatype[propertyType.$Type + '_a'] === 'cds.LargeBinary') {
+            typeProperties["@Core.MediaType"] = 'application/octet-stream';
+        }
+        else {
+            typeProperties["@odata.Type"] = propertyType.$Type;
+        }
     }
 
     _typeWithCollections(property, typeProperties, propertyType.$Collection);
@@ -206,23 +179,23 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
 
 function _generateComplexTypePropertyCsn(propertyType) {
     let property = {};
-    let type = {type : propertyType.$Type}
+    let type = { type: propertyType.$Type }
     _typeWithCollections(property, type, propertyType.$Collection);
-    
+
     return property;
 }
 
 function _generateTypeDefinitionPropertyCsn(propertyType) {
     let property = {};
-    let type = {type : propertyType.$Type}
-    
-    _includeExternalNamespaceAnnotation(propertyType,property);
+    let type = { type: propertyType.$Type }
+
+    _includeExternalNamespaceAnnotation(propertyType, property);
     _typeWithCollections(property, type, propertyType.$Collection);
 
     return property;
 }
 
-function _parseAssociationProperty(foreignReference, associationNode, mockServerUc) {
+function _parseAssociationProperty(foreignReference, associationNode, mockServerUc, parserContext) {
     let associationProperty = {};
     let foreignKeys;
     // var foreignReference = associationNode.$Type;
@@ -230,20 +203,20 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     let i;
     let data;
     let ref;
-    associationProperty.type = 'cds.Association';
+    associationProperty.type = (associationNode.$OnDelete === 'Cascade') ? 'cds.Composition' : 'cds.Association';
     // annotation for ON condition
     associationProperty["@cds.ambiguous"] = 'missing on condition?';
     // associationProperty.target = associationNode.$Type;
-    if (mockServerUc && entitySetToEntityTypeMap && entitySetToEntityTypeMap.get(associationNode.$Type)) {
-        if (entitySetToEntityTypeMap.get(associationNode.$Type).length > 1) {
-            for (let j = 0; j < entitySetToEntityTypeMap.get(associationNode.$Type).length; j++) {
-                if (entitySetToEntityTypeMap.get(associationNode.$Type)[j] === foreignReference) {
-                    associationProperty.target = namespace + '.' +
-                        entitySetToEntityTypeMap.get(associationNode.$Type)[j];
+    if (mockServerUc && parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)) {
+        if (parserContext.entitySetToEntityTypeMap.get(associationNode.$Type).length > 1) {
+            for (let j = 0; j < parserContext.entitySetToEntityTypeMap.get(associationNode.$Type).length; j++) {
+                if (parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)[j] === foreignReference) {
+                    associationProperty.target = parserContext.namespace + '.' +
+                    parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)[j];
                 }
             }
         } else {
-            associationProperty.target = namespace + '.' + entitySetToEntityTypeMap.get(associationNode.$Type);
+            associationProperty.target = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(associationNode.$Type);
         }
     } else {
         associationProperty.target = associationNode.$Type;
@@ -277,49 +250,58 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
             }
         }
     }
-	// Convert managed associations and compositions in unmanaged with empty key to avoid
+    // Convert managed associations and compositions in unmanaged with empty key to avoid
     // "generation" of keys, that do not exist in the external service.
     if (common.checkForEmptyKeys(associationProperty, "V4")) {
         associationProperty.keys = [];
     }
-    _includeExternalNamespaceAnnotation(associationNode,associationProperty);
+    _includeExternalNamespaceAnnotation(associationNode, associationProperty);
     return associationProperty;
 }
 
-function _getBaseTypeEntityName(baseType) {
-    const mappedResult = entitySetToEntityTypeMap.get(baseType);
+function _getBaseTypeEntityName(baseType, parserContext) {
+    const mappedResult = parserContext.entitySetToEntityTypeMap.get(baseType);
     // if one entity type has mapping to multiple entity sets, use the first entity set
     if (mappedResult.length > 1) {
-        return namespace + '.' + mappedResult[0];
+        return parserContext.namespace + '.' + mappedResult[0];
     } else {
-        return namespace + '.' + mappedResult;
+        return parserContext.namespace + '.' + mappedResult;
+    }
+}
+
+function _addBlobElement() {
+    return {
+        "blob": {
+            "@Core.MediaType": 'application/octet-stream',
+            "type": "cds.LargeBinary"
+        }
     }
 }
 
-function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc) {
+function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserContext) {
     let entityCsn = {};
     let keySet;
     let curKey;
     let j;
     let propertyType;
     let enumType = {};
-    entityTypes.forEach(element => {
+    parserContext.entityTypes.forEach(element => {
         let key = Object.keys(element)[0];
         let baseType = element[key].$BaseType;
         let isAbstract = element[key].$Abstract;
         if (key) {
             entityCsn[key] = {};
             entityCsn[key].kind = 'entity';
-            if (!ignorePersistenceSkip) {	
-                entityCsn[key]['@cds.persistence.skip'] = true;	
+            if (!ignorePersistenceSkip) {
+                entityCsn[key]['@cds.persistence.skip'] = true;
             }
-            _includeExternalNamespaceAnnotation(element[key],entityCsn[key]);
+            _includeExternalNamespaceAnnotation(element[key], entityCsn[key]);
             // inheritance
             if (baseType) {
                 entityCsn[key].includes = [];
                 // if the baseType has a mapping to an entity set use that
-                if (entitySetToEntityTypeMap && entitySetToEntityTypeMap.get(baseType)) {
-                    baseType = _getBaseTypeEntityName(baseType);
+                if (parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(baseType)) {
+                    baseType = _getBaseTypeEntityName(baseType, parserContext);
                 }
                 entityCsn[key].includes.push(baseType);
             }
@@ -338,43 +320,47 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc) {
                             for (j = 0; j < curKey.length; j++) {
                                 keySet.push(curKey[j]);
                             }
-                        } else if (!element[key][property].$Type || edmxncdsdatatype[element[key][property].$Type] || edmxncdsdatatype[element[key][property].$Type + "_a"]) {
+                        } else if (!element[key][property].$Type || edmxncdsdatatype[element[key][property].$Type] ||
+                            edmxncdsdatatype[element[key][property].$Type + "_a"]
+                        ) {
                             propertyType = element[key][property];
                             if (keySet.includes(property)) {
                                 entityCsn[key].elements[property] = generatePropertyCsn(propertyType, true);
                             } else {
                                 entityCsn[key].elements[property] = generatePropertyCsn(propertyType, false);
                             }
-                        } else if (!element[key][property].$Type || enumTypes[element[key][property].$Type]) {
-                            enumType.$Type = enumTypes[element[key][property].$Type].$UnderlyingType;
+                        } else if (!element[key][property].$Type || parserContext.enumTypes[element[key][property].$Type]) {
+                            enumType.$Type = parserContext.enumTypes[element[key][property].$Type].$UnderlyingType;
                             if (keySet.includes(property)) {
                                 entityCsn[key].elements[property] = generatePropertyCsn(enumType, true);
                             } else {
                                 entityCsn[key].elements[property] = generatePropertyCsn(enumType, false);
                             }
-                        } else if (complexTypes[element[key][property].$Type]) {
+                        } else if (parserContext.complexTypes[element[key][property].$Type]) {
                             propertyType = element[key][property];
                             entityCsn[key].elements[property] = _generateComplexTypePropertyCsn(propertyType);
                         } else if (element[key][property].$Kind === 'NavigationProperty') {
-                            entityCsn[key].elements[property] = _parseAssociationProperty(property,
-                                element[key][property], mockServerUc);
-                        } else if (typeDefinitions[element[key][property].$Type]){
+                            entityCsn[key].elements[property] = _parseAssociationProperty(property, element[key][property], mockServerUc, parserContext);
+                        } else if (parserContext.typeDefinitions[element[key][property].$Type]) {
                             // for TypeDefinitions
                             propertyType = element[key][property];
                             entityCsn[key].elements[property] = _generateTypeDefinitionPropertyCsn(propertyType);
                         } else {
-                            let message = '"' + element[key][property].$Type + '" is not supported (in element:"' + property + '")'; 
+                            let message = '"' + element[key][property].$Type + '" is not supported (in element:"' + property + '")';
                             console.log(warn(message));
                         }
                     }
                 }
             });
+            if (element[key].$HasStream) {
+                entityCsn[key].elements = { ...entityCsn[key].elements, ..._addBlobElement() }
+            }
         }
     });
     return entityCsn;
 }
 
-function _generateEntityType(schemaData, mockServerUc) {
+function _generateEntityType(schemaData, mockServerUc, parserContext) {
     let entity = {};
     let temp;
     Object.keys(schemaData).forEach(entityType => {
@@ -382,64 +368,66 @@ function _generateEntityType(schemaData, mockServerUc) {
         if (schemaData[entityType] instanceof Object) {
             if (schemaData[entityType].$Kind && schemaData[entityType].$Kind === 'EntityType') {
                 if (mockServerUc) {
-                    let entityTypeName = namespace + '.' + entityType;
-                    if (entitySetToEntityTypeMap && entitySetToEntityTypeMap.get(entityTypeName)) {
-                        if (entitySetToEntityTypeMap.get(entityTypeName).length > 1) {
+                    let entityTypeName = parserContext.namespace + '.' + entityType;
+                    if (parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(entityTypeName)) {
+                        if (parserContext.entitySetToEntityTypeMap.get(entityTypeName).length > 1) {
                             let entity1 = {};
-                            for (let i = 0; i < entitySetToEntityTypeMap.get(entityTypeName).length; i++) {
+                            for (let i = 0; i < parserContext.entitySetToEntityTypeMap.get(entityTypeName).length; i++) {
                                 entity1 = {};
-                                let temp1 = namespace + '.' + entitySetToEntityTypeMap.get(entityTypeName)[i];
+                                let temp1 = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(entityTypeName)[i];
                                 entity1[temp1] = schemaData[entityType];
-                                entityTypes.push(entity1);
+                                parserContext.entityTypes.push(entity1);
                             }
                         } else {
-                            temp = namespace + '.' + entitySetToEntityTypeMap.get(entityTypeName);
+                            temp = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(entityTypeName);
                             entity[temp] = schemaData[entityType];
-                            entityTypes.push(entity);
+                            parserContext.entityTypes.push(entity);
                         }
                     } else {
-                        temp = namespace + '.' + entityType;
+                        temp = parserContext.namespace + '.' + entityType;
                         entity[temp] = schemaData[entityType];
-                        entityTypes.push(entity);
+                        parserContext.entityTypes.push(entity);
                     }
                 } else {
-                    temp = namespace + '.' + entityType;
+                    temp = parserContext.namespace + '.' + entityType;
                     entity[temp] = schemaData[entityType];
-                    entityTypes.push(entity);
+                    parserContext.entityTypes.push(entity);
                 }
             }
         }
     });
 }
 
-function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc) {
+function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc, parserContext) {
     // collect entity types
     let schemaData;
     for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
-        _generateEntityType(schemaData, mockServerUc);
+        _generateEntityType(schemaData, mockServerUc, parserContext);
     }
-    return _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc);
+    return _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserContext);
 }
-function _parseEntityContainer(entityCSN, schemaData){
-    Object.entries(schemaData[0][jsonEntityContainerName]).forEach(entry => {
-        if(entityCSN[namespace + '.' + entry[0]])
+
+function _parseEntityContainer(entityCSN, schemaData, parserContext) {
+    Object.entries(schemaData[0][parserContext.jsonEntityContainerName]).forEach(entry => {
+        if (entityCSN[parserContext.namespace + '.' + entry[0]])
             //Captured the annotations at entity set and entity type name level
-            _includeExternalNamespaceAnnotation(entry[1],entityCSN[namespace + '.' + entry[0]]);
-        if(entry[0].startsWith('@')){
+            _includeExternalNamespaceAnnotation(entry[1], entityCSN[parserContext.namespace + '.' + entry[0]]);
+        if (entry[0].startsWith('@')) {
             //Captured the annotations at entity container name level
-            entityCSN[namespace][entry[0]]= entry[1];
+            entityCSN[parserContext.namespace][entry[0]] = entry[1];
         }
     });
     return entityCSN;
 }
-function _generateEnumType(schemaData) {
+
+function _generateEnumType(schemaData, parserContext) {
     let enumTypeDict = {};
     let temp;
     Object.keys(schemaData).forEach(curEnumType => {
         if (schemaData[curEnumType] instanceof Object) {
             if (schemaData[curEnumType].$Kind && schemaData[curEnumType].$Kind === 'EnumType') {
-                temp = namespace + '.' + curEnumType;
+                temp = parserContext.namespace + '.' + curEnumType;
                 enumTypeDict[temp] = schemaData[curEnumType];
             }
         }
@@ -447,22 +435,21 @@ function _generateEnumType(schemaData) {
     return enumTypeDict;
 }
 
-function _collectEnumType(schemaDataList) {
+function _collectEnumType(schemaDataList, parserContext) {
     let schemaData;
     for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
-        enumTypes = _generateEnumType(schemaData);
+        parserContext.enumTypes = _generateEnumType(schemaData, parserContext);
     }
-    return enumTypes;
 }
 
-function _generateTypeDefinition(schemaData) {
+function _generateTypeDefinition(schemaData, parserContext) {
     let typeDefDict = {};
     let temp;
     Object.keys(schemaData).forEach(curTypeDef => {
         if (schemaData[curTypeDef] instanceof Object) {
             if (schemaData[curTypeDef].$Kind && schemaData[curTypeDef].$Kind === 'TypeDefinition') {
-                temp = namespace + '.' + curTypeDef;
+                temp = parserContext.namespace + '.' + curTypeDef;
                 typeDefDict[temp] = schemaData[curTypeDef];
             }
         }
@@ -470,29 +457,32 @@ function _generateTypeDefinition(schemaData) {
     return typeDefDict;
 }
 
-function _collectTypeDefinition(schemaDataList) {
+function _collectTypeDefinition(schemaDataList, parserContext) {
     let schemaData;
     for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
-        typeDefinitions = _generateTypeDefinition(schemaData);
+        parserContext.typeDefinitions = _generateTypeDefinition(schemaData, parserContext);
     }
 }
 
-function _generateBounded(schemaData, flag) {
+function _generateBounded(schemaData, flag, parserContext) {
     let bFunction = {};
     let boundedFunction = [];
     let temp;
     let kindString;
     if (flag == 1) {
-        kindString = 'Function'; 
+        kindString = 'Function';
     }
     else {
         kindString = 'Action';
     }
     Object.keys(schemaData).forEach(curFunction => {
-        if (schemaData[curFunction] instanceof Array && schemaData[curFunction][0].$Kind === kindString && schemaData[curFunction][0].$IsBound === true) {
+        if (schemaData[curFunction] instanceof Array && 
+            schemaData[curFunction][0].$Kind === kindString && 
+            schemaData[curFunction][0].$IsBound === true
+        ) {
             boundedFunction = [];
-            temp = namespace + '.' + curFunction;
+            temp = parserContext.namespace + '.' + curFunction;
             for (let i = 0; i < schemaData[curFunction].length; i++) {
                 boundedFunction.push(schemaData[curFunction][i]);
                 bFunction[temp] = boundedFunction;
@@ -502,37 +492,37 @@ function _generateBounded(schemaData, flag) {
     return bFunction;
 }
 
-function _collectBounded(schemaDataList, flag) {
+function _collectBounded(schemaDataList, flag, parserContext) {
     let schemaData;
     for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
         if (flag == 0) {
-            boundedActions = _generateBounded(schemaData, 0);
+            parserContext.boundedActions = _generateBounded(schemaData, 0, parserContext);
         }
         else {
-            boundedFunctions = _generateBounded(schemaData, 1);
-        }    
+            parserContext.boundedFunctions = _generateBounded(schemaData, 1, parserContext);
+        }
     }
 }
 
-function _getDatatype(datatype) {
+function _getDatatype(datatype, parserContext) {
     let type = undefined;
     if (datatype === undefined) {
         type = "cds.LargeString"; //intentionally used LargeString
-    } else if (entitySetToEntityTypeMap.get(datatype) && entitySetToEntityTypeMap.get(datatype)[0]) {
+    } else if (parserContext.entitySetToEntityTypeMap.get(datatype) && parserContext.entitySetToEntityTypeMap.get(datatype)[0]) {
         //mapping to entity set if type is entity type
-        type = namespace + "." + entitySetToEntityTypeMap.get(datatype)[0];
-    } else if (complexTypes[datatype] || typeDefinitions[datatype] || enumTypes[datatype]) {
+        type = parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(datatype)[0];
+    } else if (parserContext.complexTypes[datatype] || parserContext.typeDefinitions[datatype] || parserContext.enumTypes[datatype]) {
         //if type is complex type, type definition or an enum type
         type = datatype;
     } else {
         //checking if type is an entity set
-        for (const element of entitySetToEntityTypeMap.keys()) {
-            if (namespace + "." + entitySetToEntityTypeMap.get(element) === datatype)
+        for (const element of parserContext.entitySetToEntityTypeMap.keys()) {
+            if (parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(element) === datatype)
                 type = datatype;
         }
-        entityTypes.forEach(entity =>{
-            if(entity[datatype])
+        parserContext.entityTypes.forEach(entity => {
+            if (entity[datatype])
                 type = datatype;
         })
     }
@@ -541,17 +531,17 @@ function _getDatatype(datatype) {
     return type;
 }
 
-function _parseBounded(csnDefs, flag) {
+function _parseBounded(csnDefs, flag, parserContext) {
     let boundedEdmxKind, boundedObj, boundedCsnKind, boundedEntityName, obj, paramName, paramObj, name;
     if (flag == 0) {
         boundedEdmxKind = "Action";
         boundedCsnKind = "action";
-        boundedObj = boundedActions;
+        boundedObj = parserContext.boundedActions;
     }
     else {
         boundedEdmxKind = "Function";
         boundedCsnKind = "function";
-        boundedObj = boundedFunctions;
+        boundedObj = parserContext.boundedFunctions;
     }
     if (Object.keys(boundedObj).length > 0) {
         Object.keys(boundedObj).forEach(b => {
@@ -561,13 +551,13 @@ function _parseBounded(csnDefs, flag) {
                     obj = boundedObj[b];
                     boundedEntityName = obj[j].$Parameter[0].$Type;
                     if (csnDefs[boundedEntityName] === undefined) {
-                        boundedEntityName = namespace + "." + entitySetToEntityTypeMap.get(boundedEntityName)[0];
+                        boundedEntityName = parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(boundedEntityName)[0];
                     }
                     if (csnDefs[boundedEntityName]) {
                         if (csnDefs[boundedEntityName].actions === undefined)
                             csnDefs[boundedEntityName].actions = {};
                         csnDefs[boundedEntityName].actions[name] = {};
-                        _includeExternalNamespaceAnnotation(obj[0],csnDefs[boundedEntityName].actions[name]);
+                        _includeExternalNamespaceAnnotation(obj[0], csnDefs[boundedEntityName].actions[name]);
                         csnDefs[boundedEntityName].actions[name].kind = boundedCsnKind;
                         // add params
                         if (obj[j].$Parameter && obj[j].$Parameter.length >= 2) {
@@ -586,16 +576,15 @@ function _parseBounded(csnDefs, flag) {
                                 paramName = obj[j].$Parameter[i].$Name;
                                 let paramType = {};
                                 let annotations = {};
-                                _includeExternalNamespaceAnnotation(paramObj,annotations);
+                                _includeExternalNamespaceAnnotation(paramObj, annotations);
                                 //check if the parameter type is pre-defined, undefined or custom defined
                                 if (edmxncdsdatatype[paramObj.$Type] || edmxncdsdatatype[paramObj.$Type + "_a"])
                                     paramType = generatePropertyCsn(paramObj, false);
                                 else {
-                                    let type = _getDatatype(paramObj.$Type);
-                                    if(type) paramType["type"] = type;
+                                    let type = _getDatatype(paramObj.$Type, parserContext);
+                                    if (type) paramType["type"] = type;
                                 }
-                                if(Object.keys(paramType).length > 0) 
-                                {
+                                if (Object.keys(paramType).length > 0) {
                                     if (paramType.type || paramType.items.type) {
                                         // check if parameter type is a collection
                                         if (paramObj.$Collection && !paramType.items) {
@@ -603,15 +592,15 @@ function _parseBounded(csnDefs, flag) {
                                             csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
                                         } else
                                             csnDefs[boundedEntityName].actions[name].params[paramName] = paramType;
-                                    } 
+                                    }
                                 }
                                 else {
-                                    let message = '"' + paramObj.$Type + '" is not supported (in element:"' + name + '")'; 
+                                    let message = '"' + paramObj.$Type + '" is not supported (in element:"' + name + '")';
                                     console.log(warn(message));
                                 }
-                                if(csnDefs[boundedEntityName].actions[name].params[paramName])
+                                if (csnDefs[boundedEntityName].actions[name].params[paramName])
                                     Object.assign(csnDefs[boundedEntityName].actions[name].params[paramName], annotations);
-                            }                             
+                            }
                         }
                     }
                     //if parameters has no entries
@@ -626,11 +615,11 @@ function _parseBounded(csnDefs, flag) {
                         if (edmxncdsdatatype[obj[j].$ReturnType.$Type] || edmxncdsdatatype[obj[j].$ReturnType.$Type + "_a"])
                             returnType = generatePropertyCsn(obj[j].$ReturnType, false);
                         else {
-                            let type = _getDatatype(obj[j].$ReturnType.$Type);
-                            _includeExternalNamespaceAnnotation(obj[j].$ReturnType,annotations);
-                            if(type) returnType["type"] = type ;
+                            let type = _getDatatype(obj[j].$ReturnType.$Type, parserContext);
+                            _includeExternalNamespaceAnnotation(obj[j].$ReturnType, annotations);
+                            if (type) returnType["type"] = type;
                         }
-                        if(Object.keys(returnType).length > 0){
+                        if (Object.keys(returnType).length > 0) {
                             if (returnType.type || returnType.items.type) {
                                 csnDefs[boundedEntityName].actions[name].returns = {};
                                 // check if return type is a collection
@@ -638,12 +627,12 @@ function _parseBounded(csnDefs, flag) {
                                     csnDefs[boundedEntityName].actions[name].returns.items = returnType;
                                 else
                                     csnDefs[boundedEntityName].actions[name].returns = returnType;
-                            } 
-                        }   else {
-                            let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)'; 
+                            }
+                        } else {
+                            let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)';
                             console.log(warn(message));
                         }
-                        if(csnDefs[boundedEntityName].actions[name].returns)
+                        if (csnDefs[boundedEntityName].actions[name].returns)
                             Object.assign(csnDefs[boundedEntityName].actions[name].returns, annotations)
                     }
                 }
@@ -652,13 +641,13 @@ function _parseBounded(csnDefs, flag) {
     }
 }
 
-function _generateComplexType(schemaData) {
+function _generateComplexType(schemaData, parserContext) {
     let complexTypeDict = {};
     let temp;
     Object.keys(schemaData).forEach(curComplexType => {
         if (schemaData[curComplexType] instanceof Object) {
             if (schemaData[curComplexType].$Kind && schemaData[curComplexType].$Kind === 'ComplexType') {
-                temp = namespace + '.' + curComplexType;
+                temp = parserContext.namespace + '.' + curComplexType;
                 complexTypeDict[temp] = schemaData[curComplexType];
             }
         }
@@ -666,22 +655,22 @@ function _generateComplexType(schemaData) {
     return complexTypeDict;
 }
 
-function _collectComplexType(schemaDataList) {
+function _collectComplexType(schemaDataList, parserContext) {
     // collect complex types
     let schemaData;
     for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
-        complexTypes = _generateComplexType(schemaData);
+        parserContext.complexTypes = _generateComplexType(schemaData, parserContext);
     }
-    return complexTypes;
+    return parserContext.complexTypes;
 }
 
-function _generateCSNForComplexType(schemaData) {
+function _generateCSNForComplexType(schemaData, parserContext) {
     let complexCsn = {};
     let cTypes;
     let propertyType;
     let baseType;
-    cTypes = _collectComplexType(schemaData);
+    cTypes = _collectComplexType(schemaData, parserContext);
     Object.keys(cTypes).forEach(element => {
         complexCsn[element] = {};
         complexCsn[element].kind = 'type';
@@ -694,10 +683,13 @@ function _generateCSNForComplexType(schemaData) {
         }
         Object.keys(cTypes[element]).forEach(property => { // cTypes[element][property].$Type.startsWith('Edm.')
             if (cTypes[element][property] instanceof Object) {
-                if (!cTypes[element][property].$Type || edmxncdsdatatype[cTypes[element][property].$Type] || edmxncdsdatatype[cTypes[element][property].$Type + "_a"]) {
+                if (!cTypes[element][property].$Type || 
+                    edmxncdsdatatype[cTypes[element][property].$Type] || 
+                    edmxncdsdatatype[cTypes[element][property].$Type + "_a"]
+                ) {
                     propertyType = cTypes[element][property];
                     complexCsn[element].elements[property] = generatePropertyCsn(propertyType, false);
-                } else if (complexTypes[cTypes[element][property].$Type]) {
+                } else if (parserContext.complexTypes[cTypes[element][property].$Type]) {
                     propertyType = cTypes[element][property];
                     complexCsn[element].elements[property] = _generateComplexTypePropertyCsn(propertyType);
                 } else {
@@ -712,59 +704,61 @@ function _generateCSNForComplexType(schemaData) {
     return complexCsn;
 }
 
-function _parseTypeDefinition() {
+function _parseTypeDefinition(parserContext) {
     let typeDef = {};
     let propertyType;
-    Object.keys(typeDefinitions).forEach(element => {
+    Object.keys(parserContext.typeDefinitions).forEach(element => {
         typeDef[element] = {};
         typeDef[element].kind = 'type';
-        if (!typeDefinitions[element].$Type || edmxncdsdatatype[typeDefinitions[element].$Type]) {
-            propertyType = typeDefinitions[element];
+        if (!parserContext.typeDefinitions[element].$Type || 
+            edmxncdsdatatype[parserContext.typeDefinitions[element].$Type]
+        ) {
+            propertyType = parserContext.typeDefinitions[element];
             typeDef[element] = Object.assign(typeDef[element], generatePropertyCsn(propertyType, false));
         }
     });
     return typeDef;
 }
 
-function _parseUnbounded(schemaData, flag) {
+function _parseUnbounded(schemaData, flag, parserContext) {
     let unboundedObj = {}, unbounded, unboundedCsnKind;
     let importToMap = new Multimap();
     if (flag == 0) {
-        unbounded = unboundedActions;
-        importToMap = actionImportToActionMap;
+        unbounded = parserContext.unboundedActions;
+        importToMap = parserContext.actionImportToActionMap;
         unboundedCsnKind = "action";
     }
     else {
-        unbounded = unboundedFunctions;
-        importToMap = functionImportToFunctionMap;
+        unbounded = parserContext.unboundedFunctions;
+        importToMap = parserContext.functionImportToFunctionMap;
         unboundedCsnKind = "function";
     }
     if (Object.keys(unbounded).length > 0) {
         Object.keys(unbounded).forEach(ub => {
             let obj = {};
             let objType = {}, objData = {}, temp = {};
-            if (importToMap && importToMap.get(ub)) { 
+            if (importToMap && importToMap.get(ub)) {
                 temp = ub.split(".").pop();
-                objType = namespace + "." + temp;
+                objType = parserContext.namespace + "." + temp;
                 objData = schemaData[0][temp][0];
                 obj[objType] = {};
                 obj[objType].kind = unboundedCsnKind;
-                _includeExternalNamespaceAnnotation(objData,obj[objType]);
+                _includeExternalNamespaceAnnotation(objData, obj[objType]);
                 // add params
                 if (objData.$Parameter && objData.$Parameter.length > 0) {
-                    obj[objType].params = {};   
+                    obj[objType].params = {};
                     for (let i = 0; i < objData.$Parameter.length; i++) {
                         let paramType = {};
                         let annotations = {};
                         _includeExternalNamespaceAnnotation(objData.$Parameter[i], annotations);
                         // check if the parameter type is pre-defined, undefined or custom defined
                         if (edmxncdsdatatype[objData.$Parameter[i].$Type] || edmxncdsdatatype[objData.$Parameter[i].$Type + "_a"]) {
-                            paramType = generatePropertyCsn(objData.$Parameter[i],false)
+                            paramType = generatePropertyCsn(objData.$Parameter[i], false)
                         } else {
-                            let type = _getDatatype(objData.$Parameter[i].$Type);
-                            if(type) paramType["type"] = type;
+                            let type = _getDatatype(objData.$Parameter[i].$Type, parserContext);
+                            if (type) paramType["type"] = type;
                         }
-                        if(Object.keys(paramType).length > 0){
+                        if (Object.keys(paramType).length > 0) {
                             if (paramType.type || paramType.items.type) {
                                 // check if parameter type is a collection
                                 if (objData.$Parameter[i].$Collection && !paramType.items) {
@@ -772,12 +766,12 @@ function _parseUnbounded(schemaData, flag) {
                                     obj[objType].params[objData.$Parameter[i].$Name].items = paramType;
                                 } else
                                     obj[objType].params[objData.$Parameter[i].$Name] = paramType;
-                            } 
-                        }else {
-                            let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")'; 
+                            }
+                        } else {
+                            let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")';
                             console.log(warn(message));
                         }
-                        if(obj[objType].params[objData.$Parameter[i].$Name])
+                        if (obj[objType].params[objData.$Parameter[i].$Name])
                             Object.assign(obj[objType].params[objData.$Parameter[i].$Name], annotations)
                     }
                 }
@@ -793,11 +787,11 @@ function _parseUnbounded(schemaData, flag) {
                     if (edmxncdsdatatype[objData.$ReturnType.$Type] || edmxncdsdatatype[objData.$ReturnType.$Type + "_a"]) {
                         returnValue = generatePropertyCsn(objData.$ReturnType, false);
                     } else {
-                        let type = _getDatatype(objData.$ReturnType.$Type);
-                        _includeExternalNamespaceAnnotation(objData.$ReturnType,annotations);
-                        if(type) returnValue["type"] = type;
+                        let type = _getDatatype(objData.$ReturnType.$Type, parserContext);
+                        _includeExternalNamespaceAnnotation(objData.$ReturnType, annotations);
+                        if (type) returnValue["type"] = type;
                     }
-                    if(Object.keys(returnValue).length > 0){
+                    if (Object.keys(returnValue).length > 0) {
                         if (returnValue.type || returnValue.items.type) {
                             obj[objType].returns = {};
                             // check if return type is a collection
@@ -807,12 +801,12 @@ function _parseUnbounded(schemaData, flag) {
                             } else
                                 obj[objType].returns = returnValue;
                         }
-                    } 
+                    }
                     else {
-                        let message = '"' + objData.$ReturnType.$Type + '" is not supported (in return type of' + temp + ')'; 
+                        let message = '"' + objData.$ReturnType.$Type + '" is not supported (in return type of' + temp + ')';
                         console.log(warn(message));
                     }
-                    if(obj[objType].returns)
+                    if (obj[objType].returns)
                         Object.assign(obj[objType].returns, annotations);
                 }
             }
@@ -822,7 +816,7 @@ function _parseUnbounded(schemaData, flag) {
     return unboundedObj;
 }
 
-function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
+function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserContext) {
     let csn = {};
     let schemaData = [];
     csn.meta = {};
@@ -840,7 +834,7 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
     });
 
     if (mockServerUc) {
-        let entitySetData = edmxAsJson[namespace];
+        let entitySetData = edmxAsJson[parserContext.namespace];
         let entityContainer;
         Object.keys(entitySetData).forEach(data => {
             if (ignoreObjects.indexOf(data) === -1 && entitySetData[data] instanceof Object) {
@@ -852,42 +846,42 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
         Object.keys(entityContainer).forEach(data => {
             if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
                 entityContainer[data].$Type && entityContainer[data].$Collection) {
-                entitySetToEntityTypeMap.set(entityContainer[data].$Type, data);
+                parserContext.entitySetToEntityTypeMap.set(entityContainer[data].$Type, data);
             } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
                 entityContainer[data].$Action) {
-                actionImportToActionMap.set(entityContainer[data].$Action, data);
-                unboundedActions[entityContainer[data].$Action] = entitySetData[data];
+                parserContext.actionImportToActionMap.set(entityContainer[data].$Action, data);
+                parserContext.unboundedActions[entityContainer[data].$Action] = entitySetData[data];
             } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
                 entityContainer[data].$Function) {
-                functionImportToFunctionMap.set(entityContainer[data].$Function, data);
-                unboundedFunctions[entityContainer[data].$Function] = entitySetData[data];
+                parserContext.functionImportToFunctionMap.set(entityContainer[data].$Function, data);
+                parserContext.unboundedFunctions[entityContainer[data].$Function] = entitySetData[data];
             }
         });
     }
 
-    csn.definitions[namespace] = {};
-    csn.definitions[namespace].kind = 'service';
-    csn.definitions[namespace]['@cds.external'] = true;
+    csn.definitions[parserContext.namespace] = {};
+    csn.definitions[parserContext.namespace].kind = 'service';
+    csn.definitions[parserContext.namespace]['@cds.external'] = true;
 
-    _collectEnumType(schemaData);
-    _collectTypeDefinition(schemaData);
-    _collectBounded(schemaData, 0);
-    _collectBounded(schemaData, 1);
+    _collectEnumType(schemaData, parserContext);
+    _collectTypeDefinition(schemaData, parserContext);
+    _collectBounded(schemaData, 0, parserContext);
+    _collectBounded(schemaData, 1, parserContext);
 
     // Step 1: get all complex types.
-    csn.definitions = Object.assign(_generateCSNForComplexType(schemaData), csn.definitions);
+    csn.definitions = Object.assign(_generateCSNForComplexType(schemaData, parserContext), csn.definitions);
     // Step 2: get all type definition
-    csn.definitions = Object.assign(_parseTypeDefinition(), csn.definitions); 
+    csn.definitions = Object.assign(_parseTypeDefinition(parserContext), csn.definitions);
     // Step 3: get all entity type
-    csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc), csn.definitions);
+    csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc, parserContext), csn.definitions);
     // Step 4: get all unbounded action & function
-    csn.definitions = Object.assign(_parseUnbounded(schemaData, 0), csn.definitions);
-    csn.definitions = Object.assign(_parseUnbounded(schemaData , 1), csn.definitions);
+    csn.definitions = Object.assign(_parseUnbounded(schemaData, 0, parserContext), csn.definitions);
+    csn.definitions = Object.assign(_parseUnbounded(schemaData, 1, parserContext), csn.definitions);
     // Step 5: add entity container properties
-    csn.definitions = Object.assign(_parseEntityContainer(csn.definitions,schemaData),csn.definitions);
+    csn.definitions = Object.assign(_parseEntityContainer(csn.definitions, schemaData, parserContext, parserContext), csn.definitions);
     // Step 6: get all bounded action & function
-    _parseBounded(csn.definitions, 0);
-    _parseBounded(csn.definitions, 1);
+    _parseBounded(csn.definitions, 0, parserContext);
+    _parseBounded(csn.definitions, 1, parserContext);
     // Step 7: get all annotations
     _generateDocumentation(schemaData, csn.definitions);
 
@@ -898,52 +892,52 @@ function _replaceSpecialCharacters(text) {
     return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').replace(/"/g, "&quot;").trim();
 }
 
-function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString){
-   if(path){
-        if(targetString === "@Core.Description" && annotation[1]["@Core.Description"]){
-            if(path.doc === undefined)
+function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString) {
+    if (path) {
+        if (targetString === "@Core.Description" && annotation[1]["@Core.Description"]) {
+            if (path.doc === undefined)
                 path.doc = _replaceSpecialCharacters(annotation[1]["@Core.Description"]);
             else
                 path.doc += _replaceSpecialCharacters(annotation[1]["@Core.Description"]);
         }
-        else if(targetString === "@Core.LongDescription" && annotation[1]["@Core.LongDescription"]){
-            _generateLongDescription(annotation,path,no_of_terms);
+        else if (targetString === "@Core.LongDescription" && annotation[1]["@Core.LongDescription"]) {
+            _generateLongDescription(annotation, path, no_of_terms);
         }
     }
 }
-function _checkAnnotationTarget(annotation, cdsDefs , str, no_of_terms){
+function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms) {
     if (annotation[0].indexOf('/') === -1 && annotation[0].indexOf('(') === -1) {
         if (annotation[0].endsWith(".EntityContainer")) {
             let path = annotation[0].split(".")[0];
-            
-            _checkAnnotatationTerm(annotation,cdsDefs[path],no_of_terms,str);  
+
+            _checkAnnotatationTerm(annotation, cdsDefs[path], no_of_terms, str);
         }
         if (cdsDefs[annotation[0]]) {
-            _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms , str);
+            _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str);
         }
-    } else if(annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)){
+    } else if (annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)) {
         let path = annotation[0].split('/');
-        if(cdsDefs[path[0]]){
-             _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["elements"][path[1]], no_of_terms, str);
-        }   
-    } else{
+        if (cdsDefs[path[0]]) {
+            _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["elements"][path[1]], no_of_terms, str);
+        }
+    } else {
         let path = annotation[0].split('(');
-        if(cdsDefs[path[0]]== undefined){
+        if (cdsDefs[path[0]] == undefined) {
             let temp = path[1].split(')');
             let path1 = temp[0].split(',');
             let path2 = path[0].split('.');
-            if(cdsDefs[path1[0]]){
-                _checkAnnotatationTerm(annotation,cdsDefs[path1[0]]["actions"][path2[1]],no_of_terms,str);
+            if (cdsDefs[path1[0]]) {
+                _checkAnnotatationTerm(annotation, cdsDefs[path1[0]]["actions"][path2[1]], no_of_terms, str);
             }
-        } else{
-            if(path[1].indexOf('/') === -1){ 
-            _checkAnnotatationTerm(annotation,cdsDefs[path[0]],no_of_terms,str);   
-            } else{
+        } else {
+            if (path[1].indexOf('/') === -1) {
+                _checkAnnotatationTerm(annotation, cdsDefs[path[0]], no_of_terms, str);
+            } else {
                 let path1 = path[1].split('/');
-                if(cdsDefs[path[0]] && cdsDefs[path[0]]["params"]){
-                    _checkAnnotatationTerm(annotation,cdsDefs[path[0]]["params"][path1[1]],no_of_terms,str);
+                if (cdsDefs[path[0]] && cdsDefs[path[0]]["params"]) {
+                    _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["params"][path1[1]], no_of_terms, str);
                 }
-            }    
+            }
         }
     }
 }
@@ -956,79 +950,74 @@ function _generateDocumentation(schemaData, cdsDefs) {
             if (annotation[1].hasOwnProperty('@Core.Description')) {
 
                 no_of_terms = true;
-                _checkAnnotationTarget(annotation,cdsDefs,"@Core.Description",no_of_terms);
+                _checkAnnotationTarget(annotation, cdsDefs, "@Core.Description", no_of_terms);
             }
             // eslint-disable-next-line no-prototype-builtins
             if (annotation[1].hasOwnProperty('@Core.LongDescription')) {
-                _checkAnnotationTarget(annotation,cdsDefs,"@Core.LongDescription",no_of_terms);
+                _checkAnnotationTarget(annotation, cdsDefs, "@Core.LongDescription", no_of_terms);
 
-                            }
+            }
         });
     }
 }
 
-function _generateLongDescription(annotation,path,no_of_terms){
-    if(path){
-        path.doc = no_of_terms ? (path.doc += "\n\n") : (path.doc ? (path.doc+="") : (path.doc=""));
+function _generateLongDescription(annotation, path, no_of_terms) {
+    if (path) {
+        path.doc = no_of_terms ? (path.doc += "\n\n") : (path.doc ? (path.doc += "") : (path.doc = ""));
         path.doc += _replaceSpecialCharacters(annotation[1]["@Core.LongDescription"]);
-        return(path.doc);
+        return (path.doc);
     }
 }
 
 
-function _generateEDMX2JSON(edmx, name_space) { 
-    return new Promise(function getJson(resolve, reject) { 
-        try { 
+function _generateEDMX2JSON(edmx, name_space, parserContext) {
+    return new Promise(function getJson(resolve, reject) {
+        try {
             const inputBuffer = edmx;
             // create converter
             const v4Conv = MetadataConverterFactory.createEdmxV40XmlToV40Json(name_space);
-            v4Conv.execute(inputBuffer, (error, json, missingReferencedDocuments) => { 
+            v4Conv.execute(inputBuffer, (error, json, missingReferencedDocuments) => {
                 if (missingReferencedDocuments.length > 0) {
                     console.log(missingReferencedDocuments); // eslint-disable-line no-console
                 }
-                if (_validateJSON(json)) {
+                if (_validateJSON(json, parserContext)) {
                     resolve(json);
                 }
             });
-        } catch (err) { 
+        } catch (err) {
             reject(err);
         }
     });
 }
 
-function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
+async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
     let csn;
     let edmjConverted;
     let name_space = []
-    _initialize();
-    if(context.include_all_namespaces === true)
-    {
+    
+    const parserContext = {};
+    _initialize(parserContext);
+
+    if (context.include_all_namespaces === true)
         name_space.push(true);
-    }
-    else{
+    else
         name_space = context.namespaces;
-    }
+    
     if (_isJson(edmx)) {
         return new Promise(function getCsn(resolve, reject) {
             try {
                 edmjConverted = JSON.parse(edmx);
-                if (_validateJSON(edmjConverted)) {
-                    csn = _generateCSN(edmjConverted, ignorePersistenceSkip, mockServerUc);
-                    if (csn) {
-                        resolve(csn);
-                    } else {
-                        reject(errors);
-                    }
+                if (_validateJSON(edmjConverted, parserContext)) {
+                    csn = _generateCSN(edmjConverted, ignorePersistenceSkip, mockServerUc, parserContext);
+                    if (csn) resolve(csn);
                 }
             } catch (err) {
                 reject(err);
             }
         });
     }
-    return _generateEDMX2JSON(edmx,name_space).then(function getCsn(edmj) {
-        // now parsing logic
-        return _generateCSN(edmj, ignorePersistenceSkip, mockServerUc);
-    });
+    const edmj = await _generateEDMX2JSON(edmx, name_space, parserContext);
+    return _generateCSN(edmj, ignorePersistenceSkip, mockServerUc, parserContext);
 }
 
 module.exports = {