@sap/cds-dk 4.9.7 → 6.0.3

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

@@ -4,26 +4,10 @@
 
 "use strict";
 
-let serviceNamespace;
-let allEntities = [];
-let allEntitiesMC = [];
-let allEntitySetMap = {};
-let allEntitySetMapMC = {};
-let allEntitySetNamespaces = {};
-let allFunctionImports = [];
-let allFunctionImportsMap = {};
-let allAssociations = {};
-let allAssociationSets = {};
-let allComplexTypes = {};
-let allComplexTypeDocs = {};
-let allComplexTypeNamespaces = {};
-let allInheritedComplexTypes = {};
-let allowedNamespaces = [];
-let allowAllNamespaces = false;
-let messages = require("./message").getMessages();
-let common = require("./common");
-let versionInfo = require('../../package.json').version;
-const { warn } = require('@sap/cds/bin/utils/term');
+let messages = require("../message").getMessages();
+let common = require("../common");
+let versionInfo = require('../../../package.json').version;
+const { warn } = require('../../util/term');
 
 let edmxncdsdatatype = {
 	"Edm.String": "cds.LargeString",
@@ -31,14 +15,12 @@ let edmxncdsdatatype = {
 	"Edm.Int16": "cds.Integer",
 	"Edm.Int32": "cds.Integer",
 	"Edm.Int64": "cds.Integer64",
-	"Edm.Decimal": "cds.DecimalFloat",
-	"Edm.DateTime": "cds.DateTime", 
+	"Edm.Decimal": "cds.Decimal",
+	"Edm.DateTime": "cds.DateTime",
 	"Edm.DateTimeOffset": "cds.DateTime",
 	"Edm.Time": "cds.Time",
 	"Edm.Binary": "cds.LargeBinary",
 	"Edm.Guid": "cds.UUID",
-	"Edm.Byte": "cds.Integer",
-	"Edm.SByte": "cds.Integer",
 	"Edm.Double": "cds.Double",
 	// Special handling of data types
 	"Edm.String_m": "cds.String", // Max length
@@ -49,38 +31,40 @@ let edmxncdsdatatype = {
 	"Edm.Byte_m": "cds.Integer", // Max Length
 	"Edm.Double_p": "cds.Double", // Precision, scale
 	// Special handling with annotations
+	"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", //precision > 0
-	"Edm.DateTime_a" : "cds.Timestamp" //precision > 0
+	"Edm.Stream_a": "cds.LargeBinary",
+	"Edm.DateTimeOffset_a": "cds.Timestamp", //precision > 0
+	"Edm.DateTime_a": "cds.Timestamp" //precision > 0
 };
 
-function _initialize() {
-	allEntities.length = 0;
-	allEntitiesMC.length = 0;
-	allEntitySetMap = {};
-	allEntitySetMapMC = {};
-	allFunctionImports.length = 0;
-	allFunctionImportsMap = {};
-	allAssociations = {};
-	allAssociationSets = {};
-	allComplexTypes = {};
-	allComplexTypeDocs = {};
-	allComplexTypeNamespaces = {};
-	allInheritedComplexTypes = {};
-	allowedNamespaces = [];
-	allowAllNamespaces = false;
+function _initialize(parserContext) {
+	parserContext.serviceNamespace = "";
+	parserContext.allEntities = [];
+	parserContext.allEntitiesMC = [];
+	parserContext.allEntitySetMap = {};
+	parserContext.allEntitySetMapMC = {};
+	parserContext.allEntitySetNamespaces = {};
+	parserContext.allFunctionImports = [];
+	parserContext.allFunctionImportsMap = {};
+	parserContext.allAssociations = {};
+	parserContext.allAssociationSets = {};
+	parserContext.allComplexTypes = {};
+	parserContext.allComplexTypeDocs = {};
+	parserContext.allComplexTypeNamespaces = {};
+	parserContext.allInheritedComplexTypes = {};
+	parserContext.allowedNamespaces = [];
+	parserContext.allowAllNamespaces = false;
 }
 
 // Function to extract allowed namespace attributes from given set of attributes
-function namespaceAttributeFilter(attributes) {
-	let namespaceAttributes = allowAllNamespaces
+function namespaceAttributeFilter(attributes, parserContext) {
+	let namespaceAttributes = parserContext.allowAllNamespaces
 		? Object.keys(attributes).filter((attr) => attr.includes(':'))
-		: Object.keys(attributes).filter(
-				(attr) =>
-					attr.includes(':') &&
-					allowedNamespaces.includes(attr.split(':')[0]));
-			
+		: Object.keys(attributes).filter((attr) => 
+			attr.includes(':') && parserContext.allowedNamespaces.includes(attr.split(':')[0]));
+
 
 	namespaceAttributes = namespaceAttributes.map(attribute => {
 		const index = attribute.indexOf(':');
@@ -92,6 +76,7 @@ function namespaceAttributeFilter(attributes) {
 		let formattedAttribute = {};
 		formattedAttribute[`${namespace}.${name}`] = _replaceSpecialCharacters(attributes[attribute]);
 		return formattedAttribute;
+
 	});
 
 	return namespaceAttributes;
@@ -102,13 +87,16 @@ function _generateNamespaceAttributes(attributes, isBefore) {
 	let csn = "";
 	attributes.forEach((attr) => {
 		let key = Object.keys(attr)[0];
-		if (isBefore) csn = csn + ',\n';
-		csn = csn + `"@${key}":"${attr[key]}"`;
-		if (!isBefore) csn = csn + ',\n';
+		if (key !== 'm.HasStream') {
+			if (isBefore) csn = csn + ',\n';
+			csn = csn + `"@${key}":"${attr[key]}"`;
+			if (!isBefore) csn = csn + ',\n';
+		}
 	});
 
 	return csn;
 }
+
 function _isValidEDMX(jsonObj) {
 	let isValid = false;
 	let edmx;
@@ -130,22 +118,13 @@ function _isValidEDMX(jsonObj) {
 }
 
 function _hasEntityContainer(jsonObj) {
-	let isEntityContainerPresent = !!jsonObj["edmx:Edmx"]["edmx:DataServices"]
-		.Schema.EntityContainer;
+	let isEntityContainerPresent = !!jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityContainer;
 	if (!isEntityContainerPresent) {
 		throw new Error(messages.MISSING_ENTITY_CONTAINER);
 	}
 	return isEntityContainerPresent;
 }
 
-function _hasEntitySet(jsonObj) {
-    let isEntitySetPresent = !!jsonObj['edmx:Edmx']['edmx:DataServices'].Schema.EntityContainer.EntitySet;
-    if (!isEntitySetPresent) {
-        throw new Error(messages.MISSING_ENTITY_SETS);
-    }
-    return isEntitySetPresent;
-}
-
 function _isValidEDMXProvided(jsonObj) {
 	let isValid = false;
 	if (_isValidEDMX(jsonObj)) {
@@ -159,8 +138,7 @@ function _isValidEDMXProvided(jsonObj) {
 function _validateEDMX(jsonObj) {
 	return (
 		_isValidEDMXProvided(jsonObj) &&
-		_hasEntityContainer(jsonObj) &&
-		_hasEntitySet(jsonObj)
+		_hasEntityContainer(jsonObj)
 	);
 }
 
@@ -184,54 +162,51 @@ function _getServiceNameSpace(jsonObj) {
 	return null;
 }
 
-function _extractAssociationSet(associationSet) {
+function _extractAssociationSet(associationSet, parserContext) {
 	let associations = {};
 	Object.keys(associationSet).forEach((key) => {
 		if (key === "_attributes") {
 			associations.Name = associationSet[key].Name;
 			associations.End = associationSet.End;
-			// allAssociationSets[associationSet[key]['Association']] = associationSet['End'];
-			allAssociationSets[associationSet[key].Association] = associations;
+			parserContext.allAssociationSets[associationSet[key].Association] = associations;
 		}
 	});
 }
 
-function _extractAllAssociationSets(associationSets) {
-	let i;
+function _extractAllAssociationSets(associationSets, parserContext) {
 	if (associationSets.length) {
 		// Has many association sets in metadata
-		for (i = 0; i < associationSets.length; i++) {
-			_extractAssociationSet(associationSets[i]);
+		for (let i = 0; i < associationSets.length; i++) {
+			_extractAssociationSet(associationSets[i], parserContext);
 		}
 	} else {
 		// Has only one association set in metadata
-		_extractAssociationSet(associationSets);
+		_extractAssociationSet(associationSets, parserContext);
 	}
 }
 
-function _extractAssociation(association) {
+function _extractAssociation(association, parserContext) {
 	Object.keys(association).forEach((key) => {
 		if (key === "_attributes") {
-			allAssociations[association[key].Name] = association;
+			parserContext.allAssociations[association[key].Name] = association;
 		}
 	});
 }
 
-function _extractAllAssociations(associations) {
-	let i;
+function _extractAllAssociations(associations, parserContext) {
 	if (associations.length) {
 		// Has many associations in metadata
-		for (i = 0; i < associations.length; i++) {
-			_extractAssociation(associations[i]);
+		for (let i = 0; i < associations.length; i++) {
+			_extractAssociation(associations[i], parserContext);
 		}
 	} else {
 		// Has only one association in metadata
-		_extractAssociation(associations);
+		_extractAssociation(associations, parserContext);
 	}
 }
 
 function _extractEntityFromNamespace(entityName) {
-	if (!entityName)	
+	if (!entityName)
 		return;
 	let entityId = "";
 	let pos = entityName.lastIndexOf(".");
@@ -242,71 +217,55 @@ function _extractEntityFromNamespace(entityName) {
 	return entityId;
 }
 
-function _extractEntityFromEntitySet(entitySet) {
+function _extractEntityFromEntitySet(entitySet, parserContext) {
 	let entityName;
 	Object.keys(entitySet).forEach((key) => {
 		if (key === "_attributes") {
-			allEntitySetMap[entitySet[key].Name] = entitySet[key].EntityType;
-			if (allEntitySetMapMC[entitySet[key].EntityType] === undefined)
-				allEntitySetMapMC[entitySet[key].EntityType] = [];
-			allEntitySetMapMC[entitySet[key].EntityType].push(entitySet[key].Name);
+			parserContext.allEntitySetMap[entitySet[key].Name] = entitySet[key].EntityType;
+			if (parserContext.allEntitySetMapMC[entitySet[key].EntityType] === undefined)
+				parserContext.allEntitySetMapMC[entitySet[key].EntityType] = [];
+			parserContext.allEntitySetMapMC[entitySet[key].EntityType].push(entitySet[key].Name);
 			entityName = _extractEntityFromNamespace(entitySet[key].EntityType);
-			let namespaces = namespaceAttributeFilter(entitySet[key]);
-			if(namespaces.length)
-				allEntitySetNamespaces[entitySet[key].Name] = namespaces;
-			allEntities.push(entityName);
-			allEntitiesMC.push(entitySet[key].Name);
+			let namespaces = namespaceAttributeFilter(entitySet[key], parserContext);
+			if (namespaces.length)
+				parserContext.allEntitySetNamespaces[entitySet[key].Name] = namespaces;
+			parserContext.allEntities.push(entityName);
+			parserContext.allEntitiesMC.push(entitySet[key].Name);
 		}
 	});
 }
 
-function _extractAllEntityFromEntitySets(entitySets) {
-	let i;
+function _extractAllEntityFromEntitySets(entitySets, parserContext) {
 	if (entitySets.length) {
 		// Has many entity sets in metadata
-		for (i = 0; i < entitySets.length; i++) {
-			_extractEntityFromEntitySet(entitySets[i]);
+		for (let i = 0; i < entitySets.length; i++) {
+			_extractEntityFromEntitySet(entitySets[i], parserContext);
 		}
 	} else {
 		// Has only one entity sets in metadata
-		_extractEntityFromEntitySet(entitySets);
-	}
-}
-
-function _extractNameFromFunctionImport(entityName) {
-	let entityId = "";
-	let pos = entityName.lastIndexOf("_");
-	if (pos < 0) {
-		return entityName;
+		_extractEntityFromEntitySet(entitySets, parserContext);
 	}
-	entityId = entityName.substring(pos + 1);
-	return entityId;
 }
 
-function _getFunctionAttributes(functionImport, serviceNamespaceParam)
-{
+function _getFunctionAttributes(functionImport, serviceNamespaceParam) {
 	let funcAttributes = [];
-	if(functionImport["_attributes"])
-	{
-		funcAttributes.push(serviceNamespaceParam + _extractNameFromFunctionImport(functionImport["_attributes"].Name));
+	if (functionImport["_attributes"]) {
+		funcAttributes.push(serviceNamespaceParam + functionImport["_attributes"].Name);
 		funcAttributes.push(functionImport["_attributes"]["m:HttpMethod"]);
-		if(functionImport["_attributes"].ReturnType)
-		{
+		if (functionImport["_attributes"].ReturnType) {
 			funcAttributes.push(functionImport["_attributes"].ReturnType);
 		} else {
 			funcAttributes.push(-1);
 		}
 	}
 
-	if(functionImport["Parameter"])
-	{
+	if (functionImport["Parameter"]) {
 		funcAttributes.push(functionImport["Parameter"]);
 	} else {
 		funcAttributes.push(-1);
 	}
 
-	if(functionImport["Documentation"])
-	{
+	if (functionImport["Documentation"]) {
 		funcAttributes.push(_parseDocumentationTag(functionImport["Documentation"]));
 	} else {
 		funcAttributes.push(-1);
@@ -315,47 +274,45 @@ function _getFunctionAttributes(functionImport, serviceNamespaceParam)
 	return funcAttributes;
 }
 
-function _extractFunctionImport(functionImport, serviceNamespaceParam)
-{
+function _extractFunctionImport(functionImport, parserContext) {
 	//extracting the bounded and unbounded function import
 	let boundedFunctionImports = [];
 	let entityName;
 	Object.keys(functionImport).forEach((key) => {
-		if(key === "_attributes") {
-			if(functionImport[key]["sap:action-for"])
-			{
+		if (key === "_attributes") {
+			if (functionImport[key]["sap:action-for"]) {
 				//storing bounded function imports 
 				entityName = _extractEntityFromNamespace(functionImport[key]["sap:action-for"]);
-				boundedFunctionImports = (allFunctionImportsMap[entityName]) ? allFunctionImportsMap[entityName] : [];
-				boundedFunctionImports.push(_getFunctionAttributes(functionImport,""));
-				allFunctionImportsMap[entityName] = boundedFunctionImports;
+				boundedFunctionImports = (parserContext.allFunctionImportsMap[entityName])
+					? parserContext.allFunctionImportsMap[entityName] : [];
+				boundedFunctionImports.push(_getFunctionAttributes(functionImport, ""));
+				parserContext.allFunctionImportsMap[entityName] = boundedFunctionImports;
 			}
-			else
-			{
+			else {
 				//storing unbounded function imports
-				allFunctionImports.push(_getFunctionAttributes(functionImport,serviceNamespaceParam + "."));
+				parserContext.allFunctionImports.push(
+					_getFunctionAttributes(functionImport, parserContext.serviceNamespace + ".")
+				);
 			}
 		}
 	});
 }
 
 //extracting the function imports from the metadata
-function _extractAllFunctionImports(functionImports, serviceNamespaceParam)
-{
-	let i;
+function _extractAllFunctionImports(functionImports, parserContext) {
 	if (functionImports.length) {
 		//Has many function imports in metadata
-		for (i = 0; i < functionImports.length; i++) {
-			_extractFunctionImport(functionImports[i], serviceNamespaceParam);
+		for (let i = 0; i < functionImports.length; i++) {
+			_extractFunctionImport(functionImports[i], parserContext);
 		}
 	} else {
 		//Has only one function import in metadata
-		_extractFunctionImport(functionImports, serviceNamespaceParam);
+		_extractFunctionImport(functionImports, parserContext);
 	}
 }
 
 function _replaceSpecialCharacters(text) {
-    return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\\n").replace(/\s+/g, ' ').replace(/"/g, "&quot;").trim();
+	return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\\n").replace(/\s+/g, ' ').replace(/"/g, "&quot;").trim();
 }
 
 // to parse the documentation tag
@@ -363,7 +320,7 @@ function _parseDocumentationTag(documentedContent) {
 	let documentation = "";
 	if (documentedContent.Summary && documentedContent.Summary._text) {
 		documentation = _replaceSpecialCharacters(documentedContent.Summary._text);
-	}	
+	}
 	if (documentedContent.LongDescription && documentedContent.LongDescription._text) {
 		if (documentedContent.Summary)
 			documentation += "\\n\\n";
@@ -372,42 +329,40 @@ function _parseDocumentationTag(documentedContent) {
 	return documentation;
 }
 
-function _extractComplexType(complexType, serviceNamespaceParam) {
+function _extractComplexType(complexType, parserContext) {
 	let complexTypeKey = "";
 	let baseType = "";
 	let properties;
 	let namespaceAttributes = {};
 	Object.keys(complexType).forEach((key) => {
 		if (key === "_attributes") {
-			complexTypeKey =
-				serviceNamespaceParam + "." + complexType[key].Name;
-			namespaceAttributes = namespaceAttributeFilter(complexType[key]);
+			complexTypeKey = parserContext.serviceNamespace + "." + complexType[key].Name;
+			namespaceAttributes = namespaceAttributeFilter(complexType[key], parserContext);
 			baseType = complexType[key].BaseType;
 		} else if (key === "Property") {
 			properties = complexType.Property;
 		} else if (key === "Documentation") {
-			allComplexTypeDocs[complexTypeKey] = _parseDocumentationTag(complexType.Documentation);
+			parserContext.allComplexTypeDocs[complexTypeKey] = _parseDocumentationTag(complexType.Documentation);
 		}
 	});
-	allComplexTypes[complexTypeKey] = properties;
+	parserContext.allComplexTypes[complexTypeKey] = properties;
 	if (complexTypeKey && baseType) {
-		allInheritedComplexTypes[complexTypeKey] = baseType;
+		parserContext.allInheritedComplexTypes[complexTypeKey] = baseType;
 	}
 	if (namespaceAttributes.length) {
-		allComplexTypeNamespaces[complexTypeKey] = namespaceAttributes;
+		parserContext.allComplexTypeNamespaces[complexTypeKey] = namespaceAttributes;
 	}
 }
 
-function _extractAllComplexTypes(complexTypes, serviceNamespaceParam) {
-	let i;
+function _extractAllComplexTypes(complexTypes, parserContext) {
 	if (complexTypes.length) {
 		// Has many complex types in metadata
-		for (i = 0; i < complexTypes.length; i++) {
-			_extractComplexType(complexTypes[i], serviceNamespaceParam);
+		for (let i = 0; i < complexTypes.length; i++) {
+			_extractComplexType(complexTypes[i], parserContext);
 		}
 	} else {
 		// Has only one association in metadata
-		_extractComplexType(complexTypes, serviceNamespaceParam);
+		_extractComplexType(complexTypes, parserContext);
 	}
 }
 
@@ -420,13 +375,13 @@ function _getServiceEntityProperty(
 	displayFormat,
 	isKey,
 	documentation,
-	allowedNamespaceAttributes = -1
+	allowedNamespaceAttributes = -1,
+	parserContext
 ) {
 	let isCollection = -1;
 	//preprocessing of datatype in case it is a collection
-	if(dataType.substring(0,10) === 'Collection')
-	{
-		dataType = dataType.substring(11,dataType.length-1);
+	if (dataType.substring(0, 10) === 'Collection') {
+		dataType = dataType.substring(11, dataType.length - 1);
 		isCollection = 1;
 	}
 
@@ -437,7 +392,7 @@ function _getServiceEntityProperty(
 
 	let cdsDataType = null;
 	let hasInvalidPrecision = false;
-	let propertyJson='';
+	let propertyJson = '';
 	if (length && length > 0) {
 		cdsDataType = edmxncdsdatatype[dataType + "_m"];
 	} else if (precision && precision > 0) {
@@ -459,27 +414,26 @@ function _getServiceEntityProperty(
 		cdsDataType = edmxncdsdatatype[dataType + "_a"];
 	}
 	// Lookup from complex type properties
-	if (!cdsDataType && allComplexTypes[dataType]) {
+	if (!cdsDataType && parserContext.allComplexTypes[dataType]) {
 		cdsDataType = dataType;
 	}
 
 	// Lookup from inherited complex type properties
-	if (!cdsDataType && allInheritedComplexTypes[dataType]) {
+	if (!cdsDataType && parserContext.allInheritedComplexTypes[dataType]) {
 		cdsDataType = dataType;
 	}
 
 	//Possibility of entity type or entity set as the data type
-	if (!cdsDataType && allEntitySetMapMC[dataType]) {
-		cdsDataType = serviceNamespace + "." + allEntitySetMapMC[dataType][0];
-	} else if(!cdsDataType && allEntitySetMap[_extractEntityFromNamespace(dataType)]) {
+	if (!cdsDataType && parserContext.allEntitySetMapMC[dataType]) {
+		cdsDataType = parserContext.serviceNamespace + "." + parserContext.allEntitySetMapMC[dataType][0];
+	} else if (!cdsDataType && parserContext.allEntitySetMap[_extractEntityFromNamespace(dataType)]) {
 		cdsDataType = dataType;
 	}
 
 	//if the cdsDataType is undefined/ not supported
-	if(cdsDataType === undefined)
-	{
-		let message = '"' + dataType + '" is not supported'; 
-		if(propertyName)
+	if (cdsDataType === undefined) {
+		let message = '"' + dataType + '" is not supported';
+		if (propertyName)
 			message += ' (in element:"' + propertyName + '")';
 		else
 			message += ' (in return type)'
@@ -487,22 +441,23 @@ function _getServiceEntityProperty(
 		return "";
 	}
 
-	if(propertyName)
+	if (propertyName)
 		propertyJson = '"' + propertyName + '": {\n';
 
 	if (isKey) {
 		propertyJson = propertyJson + '"key": true,\n';
 	}
-	if(isCollection === 1)
-	{
+	if (isCollection === 1) {
 		propertyJson = propertyJson + '"items": { \n'
 	}
 	propertyJson = propertyJson + '"type":"' + cdsDataType + '"';
 
 	//if annotations to be added
-	if(edmxncdsdatatype[dataType + "_a"] && cdsDataType != "cds.Date")
-	{
-		propertyJson = propertyJson + ',\n"@odata.type": "' + dataType + '"'; 
+	if (edmxncdsdatatype[dataType + "_a"] && cdsDataType != "cds.Date") {
+		if (dataType === 'Edm.Stream') 
+			propertyJson = propertyJson + ',\n"@Core.MediaType": "application/octet-stream"';
+		else 
+			propertyJson = propertyJson + ',\n"@odata.Type": "' + dataType + '"';
 	}
 
 	if (length && length > 0) {
@@ -515,19 +470,17 @@ function _getServiceEntityProperty(
 			propertyJson = propertyJson + ',\n"scale":' + 0;
 		}
 	}
-	
+
 	//adding precision in case of DateTime datatypes
-	if((dataType === "Edm.DateTimeOffset" || dataType === "Edm.DateTime") && cdsDataType != "cds.Date")
-	{
-		if(!precision || precision === -1) precision = 0;
-		propertyJson = propertyJson + ',\n"@odata.precision": ' + precision;
+	if ((dataType === "Edm.DateTimeOffset" || dataType === "Edm.DateTime") && cdsDataType != "cds.Date") {
+		if (!precision || precision === -1) precision = 0;
+		propertyJson = propertyJson + ',\n"@odata.Precision": ' + precision;
 	}
 
-	if(isCollection === 1)
-	{
+	if (isCollection === 1) {
 		propertyJson = propertyJson + '\n}'
 	}
-	if(documentation != -1 && documentation){
+	if (documentation != -1 && documentation) {
 		propertyJson = propertyJson + ',\n"doc":"' + documentation + '"';
 	}
 
@@ -535,33 +488,33 @@ function _getServiceEntityProperty(
 		propertyJson += _generateNamespaceAttributes(allowedNamespaceAttributes, true);
 	}
 
-	if(propertyName)
+	if (propertyName)
 		propertyJson = propertyJson + "\n}";
 	return propertyJson;
 }
 
-function _getServiceComplexType(complexTypeKey, complexType) {
+function _getServiceComplexType(complexTypeKey, complexType, parserContext) {
 	let complexTypeCSN = '"' + complexTypeKey + '": {\n';
 	let complexTypeProperty;
 	let i;
 	complexTypeCSN = complexTypeCSN + '"kind": "type",\n';
-	if(allComplexTypeNamespaces[complexTypeKey]) {
-		complexTypeCSN += _generateNamespaceAttributes(allComplexTypeNamespaces[complexTypeKey], false);
+	if (parserContext.allComplexTypeNamespaces[complexTypeKey]) {
+		complexTypeCSN += _generateNamespaceAttributes(parserContext.allComplexTypeNamespaces[complexTypeKey], false);
 	}
-	if (allComplexTypeDocs[complexTypeKey])
-		complexTypeCSN = complexTypeCSN + '"doc":' + `"${allComplexTypeDocs[complexTypeKey]}",` + "\n";
+	if (parserContext.allComplexTypeDocs[complexTypeKey])
+		complexTypeCSN = complexTypeCSN + '"doc":' + `"${parserContext.allComplexTypeDocs[complexTypeKey]}",` + "\n";
 	complexTypeCSN = complexTypeCSN + '"elements": {\n';
 	if (complexType) {
 		if (complexType.length) {
 			// More than one complex types
 			for (i = 0; i < complexType.length; i++) {
 				complexTypeProperty = complexType[i]._attributes;
-				if(complexType[i].Documentation)
+				if (complexType[i].Documentation)
 					complexTypeProperty.doc = _parseDocumentationTag(complexType[i].Documentation);
-				let namespaceAttributes = namespaceAttributeFilter(complexTypeProperty)	
+				let namespaceAttributes = namespaceAttributeFilter(complexTypeProperty, parserContext);
 				const complexTypePropertyNamespace = namespaceAttributes.length ? namespaceAttributes : -1
-					
-				let complexProperty =
+
+				let complexProperty = 
 					_getServiceEntityProperty(
 						complexTypeProperty.Name,
 						complexTypeProperty.Type,
@@ -571,7 +524,8 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 						complexTypeProperty["sap:display-format"],
 						false,
 						complexTypeProperty.doc,
-						complexTypePropertyNamespace
+						complexTypePropertyNamespace,
+						parserContext
 					);
 				complexTypeCSN = complexTypeCSN + complexProperty;
 				if (i !== complexType.length - 1 && complexProperty != "") {
@@ -583,14 +537,13 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 		} else {
 			// Only one complex type
 			complexTypeProperty = complexType._attributes;
-			if(complexType.Documentation)
+			if (complexType.Documentation)
 				complexTypeProperty.doc = _parseDocumentationTag(complexType.Documentation);
 
-			let namespaceAttributes = namespaceAttributeFilter(complexTypeProperty);
+			let namespaceAttributes = namespaceAttributeFilter(complexTypeProperty, parserContext);
 			const complexTypePropertyNamespace = namespaceAttributes.length ? namespaceAttributes : -1;
-			
-			complexTypeCSN =
-				complexTypeCSN +
+
+			complexTypeCSN = complexTypeCSN +
 				_getServiceEntityProperty(
 					complexTypeProperty.Name,
 					complexTypeProperty.Type,
@@ -600,7 +553,8 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 					complexTypeProperty["sap:display-format"],
 					false,
 					complexTypeProperty.doc,
-					complexTypePropertyNamespace
+					complexTypePropertyNamespace,
+					parserContext
 				);
 		}
 
@@ -609,30 +563,24 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 		}
 	}
 	complexTypeCSN = complexTypeCSN + "}\n";
-	if (allInheritedComplexTypes[complexTypeKey]) {
+	if (parserContext.allInheritedComplexTypes[complexTypeKey]) {
 		complexTypeCSN = complexTypeCSN + ",\n";
-		complexTypeCSN =
-			complexTypeCSN +
-			'"includes": ["' +
-			allInheritedComplexTypes[complexTypeKey] +
-			'"]\n';
+		complexTypeCSN = complexTypeCSN + 
+			'"includes": ["' + parserContext.allInheritedComplexTypes[complexTypeKey] + '"]\n';
 	}
 	complexTypeCSN = complexTypeCSN + "}\n";
 	return complexTypeCSN;
 }
 
-function _getServiceComplexTypes() {
+function _getServiceComplexTypes(parserContext) {
 	let complexTypeCSN = "";
-	let complexTypesKeys = Object.keys(allComplexTypes);
-	let i;
+	let complexTypesKeys = Object.keys(parserContext.allComplexTypes);
 	let complexTypeKey;
 	let complexType;
-	for (i = 0; i < complexTypesKeys.length; i++) {
+	for (let i = 0; i < complexTypesKeys.length; i++) {
 		complexTypeKey = complexTypesKeys[i];
-		complexType = allComplexTypes[complexTypesKeys[i]];
-		complexTypeCSN =
-			complexTypeCSN +
-			_getServiceComplexType(complexTypeKey, complexType);
+		complexType = parserContext.allComplexTypes[complexTypesKeys[i]];
+		complexTypeCSN = complexTypeCSN + _getServiceComplexType(complexTypeKey, complexType, parserContext);
 		if (i !== complexTypesKeys.length - 1) {
 			complexTypeCSN = complexTypeCSN + ",\n";
 		} else {
@@ -642,47 +590,49 @@ function _getServiceComplexTypes() {
 	return complexTypeCSN;
 }
 
-function _parseParameter(parameter)
-{
+function _parseParameter(parameter, parserContext) {
 	let csn = "";
 	let doc;
-	if(parameter.Documentation)
+	if (parameter.Documentation)
 		doc = _parseDocumentationTag(parameter.Documentation);
 
-	let namespaceAttributes = namespaceAttributeFilter(parameter._attributes);
+	let namespaceAttributes = namespaceAttributeFilter(parameter._attributes, parserContext);
 	const parameterNamespaceAttributes = namespaceAttributes.length ? namespaceAttributes : -1;
 
-	csn = csn + _getServiceEntityProperty(parameter["_attributes"].Name,
-				parameter["_attributes"].Type,
-				parameter["_attributes"].MaxLength,
-				parameter["_attributes"].Precision,
-				parameter["_attributes"].Scale,
-				parameter["_attributes"]["sap:display-format"],
-				false,
-				doc,
-				parameterNamespaceAttributes);
+	csn = csn + 
+		_getServiceEntityProperty(
+			parameter["_attributes"].Name,
+			parameter["_attributes"].Type,
+			parameter["_attributes"].MaxLength,
+			parameter["_attributes"].Precision,
+			parameter["_attributes"].Scale,
+			parameter["_attributes"]["sap:display-format"],
+			false,
+			doc,
+			parameterNamespaceAttributes,
+			parserContext
+		);
 	return csn;
 }
 
-function _checkParameterKey(parameter, entityKeysList){
-	if ( entityKeysList && (Object.values(entityKeysList).indexOf(parameter._attributes.Name) > -1)){
+function _checkParameterKey(parameter, entityKeysList) {
+	if (entityKeysList && (Object.values(entityKeysList).indexOf(parameter._attributes.Name) > -1)) {
 		return true;
 	}
-	return false;	
+	return false;
 }
 
-function  _parseParametersFunctionImport(parameters, isBounded, entityKeysList) {
+function _parseParametersFunctionImport(parameters, entityKeysList, parserContext) {
 	let csn = "";
 	let parameterCsn = "";
-	let i = 0;
-	if(parameters.length)
-	{
-		for (i; i < parameters.length; i++) {
+
+	if (parameters.length) {
+		for (let i = 0; i < parameters.length; i++) {
 			// check if the parameter is a key of the entity type or not
 			// If yes then that paramater is ignored in CSN 
 			let isKey = _checkParameterKey(parameters[i], entityKeysList);
 			if (isKey == false) {
-				parameterCsn = _parseParameter(parameters[i]);
+				parameterCsn = _parseParameter(parameters[i], parserContext);
 				csn = csn + parameterCsn;
 				if (i !== parameters.length - 1 && parameterCsn != "") {
 					csn = csn + ",\n";
@@ -694,40 +644,36 @@ function  _parseParametersFunctionImport(parameters, isBounded, entityKeysList)
 	} else {
 		let isKey = _checkParameterKey(parameters);
 		if (isKey === false) {
-			csn = csn + _parseParameter(parameters);
+			csn = csn + _parseParameter(parameters, parserContext);
 		}
 	}
 
 	if (csn && (csn.endsWith(",\n") || csn.endsWith(",\n\n"))) {
-		csn= csn.substring(0, csn.lastIndexOf(",\n")) + "\n";
+		csn = csn.substring(0, csn.lastIndexOf(",\n")) + "\n";
 	}
 	return csn;
 }
 
-function _getFunctionImport(functionImport,isBounded,entityKeysList) {
+function _getFunctionImport(functionImport, isBounded, entityKeysList, parserContext) {
 	let noValue;
 	let csn = "";
 	csn = csn + '"' + functionImport[0] + '": { \n';
 	csn = csn + '"kind": "';
-	if(functionImport[1] === "GET")
-	{
+	if (functionImport[1] === "GET") {
 		csn = csn + "function";
-	} else if(functionImport[1] === "POST")
-	{
+	} else if (functionImport[1] === "POST") {
 		csn = csn + "action";
 	} else {
-		let message = functionImport[0].substring(functionImport[0].lastIndexOf(".") + 1) + " has kind " + functionImport[1] + " which is not supported.";
+		let message = functionImport[0].substring(functionImport[0].lastIndexOf(".") + 1) + " has kind " + 
+			functionImport[1] + " which is not supported.";
 		console.log(warn(message));
 		return "";
 	}
 	csn = csn + '"';
-	if(functionImport[3] !== -1)
-	{
-		if(isBounded === 0 || (isBounded === 1 && functionImport[3] instanceof Array ))
-		{
-			let parametersCsn = _parseParametersFunctionImport(functionImport[3],isBounded,entityKeysList);
-			if(parametersCsn != "")
-			{
+	if (functionImport[3] !== -1) {
+		if (isBounded === 0 || (isBounded === 1 && functionImport[3] instanceof Array)) {
+			let parametersCsn = _parseParametersFunctionImport(functionImport[3], entityKeysList, parserContext);
+			if (parametersCsn != "") {
 				csn = csn + ", \n";
 				csn = csn + '"params": { \n';
 				csn = csn + parametersCsn;
@@ -735,11 +681,10 @@ function _getFunctionImport(functionImport,isBounded,entityKeysList) {
 			}
 		}
 	}
-	if(functionImport[2] !== -1)
-	{
-		let returnCsn = _getServiceEntityProperty(noValue,functionImport[2],noValue,noValue,noValue,noValue,noValue,noValue);
-		if(returnCsn != "")
-		{
+	if (functionImport[2] !== -1) {
+		let returnCsn = _getServiceEntityProperty(noValue, functionImport[2], noValue, noValue, noValue, 
+			noValue, noValue, noValue, -1, parserContext);
+		if (returnCsn != "") {
 			csn = csn + ", \n";
 			csn = csn + '"returns": { \n';
 			//return type
@@ -747,8 +692,7 @@ function _getFunctionImport(functionImport,isBounded,entityKeysList) {
 			csn = csn + '\n }';
 		}
 	}
-	if(functionImport[4] !== -1 && functionImport[4])
-	{
+	if (functionImport[4] !== -1 && functionImport[4]) {
 		csn = csn + ',\n "doc": "' + _replaceSpecialCharacters(functionImport[4]) + '"';
 	}
 
@@ -756,15 +700,14 @@ function _getFunctionImport(functionImport,isBounded,entityKeysList) {
 	return csn;
 }
 
-function _getAllFunctionImports(functionImports,isBounded,entityKeysList) {
+function _getAllFunctionImports(functionImports, isBounded, entityKeysList, parserContext) {
 	let functionImportsCSN = "";
 	let i;
 	let functionImportCSN = "";
-	for(i=0; i<functionImports.length;i++)
-	{
-		functionImportCSN = _getFunctionImport(functionImports[i],isBounded, entityKeysList);
+	for (i = 0; i < functionImports.length; i++) {
+		functionImportCSN = _getFunctionImport(functionImports[i], isBounded, entityKeysList, parserContext);
 		functionImportsCSN = functionImportsCSN + functionImportCSN;
-		if(i!== functionImports.length - 1 && functionImportCSN !== "" ) {
+		if (i !== functionImports.length - 1 && functionImportCSN !== "") {
 			functionImportsCSN = functionImportsCSN + ",\n";
 		} else {
 			functionImportsCSN = functionImportsCSN + "\n";
@@ -773,7 +716,7 @@ function _getAllFunctionImports(functionImports,isBounded,entityKeysList) {
 
 	//if last function import is omitted, remove the extra characters
 	if (functionImportsCSN && (functionImportsCSN.endsWith(",\n") || functionImportsCSN.endsWith(",\n\n"))) {
-		functionImportsCSN= functionImportsCSN.substring(0, functionImportsCSN.lastIndexOf(",\n")) + "\n";
+		functionImportsCSN = functionImportsCSN.substring(0, functionImportsCSN.lastIndexOf(",\n")) + "\n";
 	}
 	return functionImportsCSN;
 }
@@ -782,13 +725,13 @@ function _getEntityName(entity) {
 	return entity._attributes.Name;
 }
 
-function _parseEntityAttributes(attributes) {
+function _parseEntityAttributes(attributes, parserContext) {
 	let entityAttributes = {};
 	// Extract only needed entity attributes
 	entityAttributes.Name = attributes.Name;
 	entityAttributes.BaseType = attributes.BaseType;
 	entityAttributes.Abstract = attributes.Abstract;
-	entityAttributes.allowedNamespaceAttributes = namespaceAttributeFilter(attributes);
+	entityAttributes.allowedNamespaceAttributes = namespaceAttributeFilter(attributes, parserContext);
 
 	return entityAttributes;
 }
@@ -809,10 +752,10 @@ function _parseEntityKeys(keys) {
 	return retKeys;
 }
 
-function _getPropertyAttributes(propAttributes) {
+function _getPropertyAttributes(propAttributes, parserContext) {
 	let propOthers = [];
 
-	let namespaceAttributes = namespaceAttributeFilter(propAttributes)
+	let namespaceAttributes = namespaceAttributeFilter(propAttributes, parserContext)
 
 	propOthers.push(propAttributes.Type);
 	if (propAttributes.MaxLength) {
@@ -838,9 +781,9 @@ function _getPropertyAttributes(propAttributes) {
 		propOthers.push(-1);
 	}
 
-	if(propAttributes.doc){
+	if (propAttributes.doc) {
 		propOthers.push(propAttributes.doc.replace(/"/g, '&quot;'));
-	}else{
+	} else {
 		propOthers.push(-1);
 	}
 
@@ -853,26 +796,26 @@ function _getPropertyAttributes(propAttributes) {
 	return propOthers;
 }
 
-function _parseEntityProperty(properties) {
+function _parseEntityProperty(properties, parserContext) {
 	let propAttributes;
 	let retProperties = {};
-	let i;
+
 	if (properties.length) {
 		// Has more than one entities
-		for (i = 0; i < properties.length; i++) {
+		for (let i = 0; i < properties.length; i++) {
 			propAttributes = properties[i]._attributes;
 			// if the property contains documentatin tag
-			if(properties[i] && properties[i].Documentation)	
+			if (properties[i] && properties[i].Documentation)
 				propAttributes.doc = _parseDocumentationTag(properties[i].Documentation);
-			retProperties[propAttributes.Name] = _getPropertyAttributes(propAttributes);
+			retProperties[propAttributes.Name] = _getPropertyAttributes(propAttributes, parserContext);
 		}
 	} else {
 		// Has only one entity
 		propAttributes = properties._attributes;
 		// if the property contains documentatin tag
-		if(properties && properties.Documentation)
+		if (properties && properties.Documentation)
 			propAttributes.doc = _parseDocumentationTag(properties.Documentation);
-		retProperties[propAttributes.Name] = _getPropertyAttributes(propAttributes);
+		retProperties[propAttributes.Name] = _getPropertyAttributes(propAttributes, parserContext);
 	}
 	return retProperties;
 }
@@ -880,13 +823,13 @@ function _parseEntityProperty(properties) {
 function _parseNavigationProperty(navigationProperties) {
 	let retNavProperties = {};
 	let navPropAttributes;
-	let i;
+
 	if (navigationProperties.length) {
 		// Has more than one navigation property
-		for (i = 0; i < navigationProperties.length; i++) {
+		for (let i = 0; i < navigationProperties.length; i++) {
 			navPropAttributes = navigationProperties[i]._attributes;
 			// if the property contains documentatin tag
-			if(navigationProperties[i] && navigationProperties[i].Documentation)
+			if (navigationProperties[i] && navigationProperties[i].Documentation)
 				navPropAttributes.doc = _parseDocumentationTag(navigationProperties[i].Documentation);
 			retNavProperties[navPropAttributes.Name] = navPropAttributes;
 		}
@@ -894,18 +837,18 @@ function _parseNavigationProperty(navigationProperties) {
 		// Has only one navigation property
 		navPropAttributes = navigationProperties._attributes;
 		// if the property contains documentatin tag
-		if(navigationProperties && navigationProperties.Documentation)
+		if (navigationProperties && navigationProperties.Documentation)
 			navPropAttributes.doc = _parseDocumentationTag(navigationProperties.Documentation);
 		retNavProperties[navPropAttributes.Name] = navPropAttributes;
 	}
 	return retNavProperties;
 }
 
-function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap) {
+function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap, parserContext) {
 	let csnEntity = "";
 	let propAttributes;
-	let i;
-	for (i = 0; i < entityKeysList.length; i++) {
+
+	for (let i = 0; i < entityKeysList.length; i++) {
 		propAttributes = entityPropertiesMap[entityKeysList[i]];
 		let keyCsn =
 			_getServiceEntityProperty(
@@ -917,7 +860,8 @@ function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap) {
 				propAttributes[4],
 				true,
 				propAttributes[5],
-				propAttributes[6]
+				propAttributes[6],
+				parserContext
 			);
 		csnEntity = csnEntity + keyCsn;
 		if (i !== entityKeysList.length - 1 && keyCsn != "") {
@@ -925,15 +869,14 @@ function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap) {
 		}
 	}
 	if (csnEntity && (csnEntity.endsWith(",\n") || csnEntity.endsWith(",\n\n"))) {
-		csnEntity= csnEntity.substring(0, csnEntity.lastIndexOf(",\n")) + "\n";
+		csnEntity = csnEntity.substring(0, csnEntity.lastIndexOf(",\n")) + "\n";
 	}
 	return csnEntity;
 }
 
-function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
+function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap, parserContext) {
 	let csnEntity = "";
 	let entityProperties = Object.keys(entityPropertiesMap);
-	let i;
 	let property;
 	let propAttributes;
 	if (entityKeysList.length > 0) {
@@ -943,7 +886,7 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
 			csnEntity = csnEntity + "\n";
 		}
 	}
-	for (i = 0; i < entityProperties.length; i++) {
+	for (let i = 0; i < entityProperties.length; i++) {
 		property = entityProperties[i];
 		// Include Property which are not part of keys
 		if (entityKeysList.indexOf(property) === -1) {
@@ -958,7 +901,8 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
 					propAttributes[4],
 					false,
 					propAttributes[5],
-					propAttributes[6]
+					propAttributes[6],
+					parserContext
 				);
 			csnEntity = csnEntity + propertyString;
 			if (i !== entityProperties.length - 1 && propertyString != "") {
@@ -970,35 +914,29 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
 	}
 	// Last property can be an key; eliminate additional delimiter.
 	// Last property can have undefined datatype and be ignored too
-	//doubt
 	if (csnEntity && (csnEntity.endsWith(",\n") || csnEntity.endsWith(",\n\n"))) {
 		csnEntity = csnEntity.substring(0, csnEntity.lastIndexOf(",\n")) + "\n";
 	}
 	return csnEntity;
 }
 
-function _getAssociatedEntity(associationEnds, toRole, mockServerUc) {
+function _getAssociatedEntity(associationEnds, toRole, mockServerUc, parserContext) {
 	let entityName;
 	let entitySetName;
 	Object.keys(associationEnds).forEach((i) => {
 		if (toRole === associationEnds[i]._attributes.Role) {
 			entitySetName = associationEnds[i]._attributes.EntitySet;
 			if (mockServerUc) {
-				entityName = serviceNamespace + "." + entitySetName;
+				entityName = parserContext.serviceNamespace + "." + entitySetName;
 			} else {
-				entityName = allEntitySetMap[entitySetName];
+				entityName = parserContext.allEntitySetMap[entitySetName];
 			}
 		}
 	});
 	return entityName;
 }
 
-function _getCSNMultiplicity(
-	associationEnds,
-	toRole,
-	entityName,
-	mockServerUc
-) {
+function _getCSNMultiplicity(associationEnds, toRole, entityName, mockServerUc, parserContext) {
 	let csn = "";
 	let multiplicity;
 	let attributes;
@@ -1007,8 +945,7 @@ function _getCSNMultiplicity(
 		if (!stop) {
 			attributes = associationEnds[i]._attributes;
 			if (mockServerUc) {
-				let entityNameWithOutNS =
-					allEntitySetMap[_extractEntityFromNamespace(entityName)];
+				let entityNameWithOutNS = parserContext.allEntitySetMap[_extractEntityFromNamespace(entityName)];
 				if (
 					toRole === attributes.Role &&
 					entityNameWithOutNS === attributes.Type
@@ -1058,11 +995,7 @@ function _getCSNRefrenentialCondition(navPropName, from, to) {
 	return csn;
 }
 
-function _getCSNMultipleRefrenentialConditions(
-	refConstraints,
-	navPropName,
-	role
-) {
+function _getCSNMultipleRefrenentialConditions(refConstraints, navPropName, role) {
 	let csn = "";
 	csn = csn + '"on": [\n';
 	Object.keys(refConstraints).forEach((i) => {
@@ -1146,8 +1079,7 @@ function _getCSNRefrenentialConstraints(associations, navPropName, toRole) {
 	});
 	if (refConstraints.length > 0) {
 		// Multiple referential constraints within Association
-		csn =
-			csn +
+		csn = csn +
 			_getCSNMultipleRefrenentialConditions(
 				refConstraints,
 				navPropName,
@@ -1155,8 +1087,7 @@ function _getCSNRefrenentialConstraints(associations, navPropName, toRole) {
 			);
 	} else {
 		// Single referential constraint within Association
-		csn =
-			csn +
+		csn = csn +
 			_getCSNRefrenentialConditions(
 				refConstraints,
 				navPropName,
@@ -1171,7 +1102,8 @@ function _getCSNAssociatedRefrenentialConstraints(
 	toRole,
 	entityName,
 	navPropName,
-	mockServerUc
+	mockServerUc,
+	parserContext
 ) {
 	let csn = "";
 	let multiplicity;
@@ -1184,7 +1116,8 @@ function _getCSNAssociatedRefrenentialConstraints(
 		associations.End,
 		toRole,
 		entityName,
-		mockServerUc
+		mockServerUc,
+		parserContext
 	);
 	if (multiplicity) {
 		csn = csn + ",\n" + multiplicity;
@@ -1205,20 +1138,23 @@ function _getCSNAssociatedEntitySet(
 	relationshipName,
 	toRole,
 	navPropName,
-	mockServerUc
+	mockServerUc,
+	parserContext
 ) {
-	let associationSet = allAssociationSets[relationshipName];
-	if(associationSet === undefined) {
+	let associationSet = parserContext.allAssociationSets[relationshipName];
+	if (associationSet === undefined) {
+		console.log(relationshipName + " " + parserContext.serviceNamespace);
 		throw new Error(messages.MISSING_ASSOCIATION_SETS);
 	}
 	let associationName = associationSet.Name;
 	let entityName = _getAssociatedEntity(
 		associationSet.End,
 		toRole,
-		mockServerUc
+		mockServerUc,
+		parserContext
 	);
 	let differentAssociationNames;
-	if (!allAssociations[associationName]) {
+	if (!parserContext.allAssociations[associationName]) {
 		let array = relationshipName.split(".");
 		if (
 			array != "undefined" &&
@@ -1226,40 +1162,62 @@ function _getCSNAssociatedEntitySet(
 			array.length != null &&
 			array.length > 0
 		) {
-			differentAssociationNames =
-				allAssociations[array[array.length - 1]];
+			differentAssociationNames = parserContext.allAssociations[array[array.length - 1]];
 		}
 	} else {
-		differentAssociationNames = allAssociations[associationName];
+		differentAssociationNames = parserContext.allAssociations[associationName];
 	}
 	return _getCSNAssociatedRefrenentialConstraints(
 		differentAssociationNames,
 		toRole,
 		entityName,
 		navPropName,
-		mockServerUc
+		mockServerUc,
+		parserContext
 	);
 }
 
-function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc) {
+function _findAssociationType(relationshipName, fromRole, parserContext) {
+	const associationName = relationshipName.replace(parserContext.serviceNamespace + '.', '');
+	const associationEnds = parserContext.allAssociations[associationName].End;
+	let associationType;
+
+	for (let i = 0; i < associationEnds.length; i++) {
+		let potentialComposition = false;
+		Object.keys(associationEnds[i]).forEach((key) => {
+			if (key === "_attributes" && associationEnds[i][key].Role === fromRole)
+				potentialComposition = true;
+			if (key === "OnDelete"
+				&& associationEnds[i][key]._attributes.Action === "Cascade"
+				&& potentialComposition
+			) {
+				associationType = "composition";
+			}
+		});
+	}
+
+	return '"type": "cds.' + (associationType === "composition" ? 'Composition"' : 'Association"') + ',\n';
+}
+
+function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc, parserContext) {
 	let csn = "";
 	let navPropName;
 	let relationshipName;
 	let navPropDoc;
-	let allowedNamespaceAttributes = namespaceAttributeFilter(navPropAttributes);
-	// var fromRole;
+	let allowedNamespaceAttributes = namespaceAttributeFilter(navPropAttributes, parserContext);
+	let fromRole;
 	let toRole;
 	if (!navPropAttributes) {
 		return csn;
 	}
 	navPropName = navPropAttributes.Name;
 	relationshipName = navPropAttributes.Relationship;
-	// fromRole = navPropAttributes.FromRole;
+	fromRole = navPropAttributes.FromRole;
 	toRole = navPropAttributes.ToRole;
 	navPropDoc = navPropAttributes.doc;
 
 	csn = csn + '"' + navPropName + '": {\n';
-	if(allowedNamespaceAttributes.length) {
+	if (allowedNamespaceAttributes.length) {
 		csn += _generateNamespaceAttributes(allowedNamespaceAttributes, false);
 	}
 	// annotation for on conditions
@@ -1267,16 +1225,17 @@ function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc) {
 	// if documentation exists for navigation property
 	if (navPropDoc)
 		csn = csn + '"doc":' + ` "${navPropDoc}",\n`;
-	csn = csn + '"type": "cds.Association",\n';
+	csn = csn + _findAssociationType(relationshipName, fromRole, parserContext);
 	csn = csn +
 		_getCSNAssociatedEntitySet(
 			relationshipName,
 			toRole,
 			navPropName,
-			mockServerUc
+			mockServerUc,
+			parserContext
 		);
 	// Convert managed associations and compositions in unmanaged with empty key to avoid
-    // "generation" of keys, that do not exist in the external service.
+	// "generation" of keys, that do not exist in the external service.
 	if (common.checkForEmptyKeys(csn, "V2")) {
 		csn = csn + ',\n"keys": []\n';
 	}
@@ -1288,10 +1247,10 @@ function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc) {
 function _generateCSNEntityNavigationProperties(
 	entityNavigationPropertiesMap,
 	hasProperties,
-	mockServerUc
+	mockServerUc,
+	parserContext
 ) {
 	let csn = "";
-	let i;
 	let entityNavProperties;
 	let navProperty;
 	let navPropAttributes;
@@ -1304,14 +1263,14 @@ function _generateCSNEntityNavigationProperties(
 		// Has navigation properties
 		csn = ",\n";
 	}
-	for (i = 0; i < entityNavProperties.length; i++) {
+	for (let i = 0; i < entityNavProperties.length; i++) {
 		navProperty = entityNavProperties[i];
 		navPropAttributes = entityNavigationPropertiesMap[navProperty];
-		csn =
-			csn +
+		csn = csn +
 			_getServiceEntityNavigationProperty(
 				navPropAttributes,
-				mockServerUc
+				mockServerUc,
+				parserContext
 			);
 		if (i < entityNavProperties.length - 1) {
 			csn = csn + ",\n";
@@ -1320,18 +1279,17 @@ function _generateCSNEntityNavigationProperties(
 	return csn;
 }
 
-function _getBaseTypeEntityName(entityName, serviceNamespaceParam) {
+function _getBaseTypeEntityName(entityName, parserContext) {
 	let baseTypeName;
 	// if one entity type has mapping to multiple entity sets, use the first entity set
-	if (allEntitySetMapMC[entityName]) {
-		baseTypeName = serviceNamespaceParam + "." + allEntitySetMapMC[entityName][0];
+	if (parserContext.allEntitySetMapMC[entityName]) {
+		baseTypeName = parserContext.serviceNamespace + "." + parserContext.allEntitySetMapMC[entityName][0];
 		return baseTypeName;
 	}
 	return entityName;
 }
 
 function _constructServiceEntity(
-	serviceNamespaceParam,
 	entityName,
 	entityKeysList,
 	entityPropertiesMap,
@@ -1339,18 +1297,19 @@ function _constructServiceEntity(
 	entityAttributes,
 	ignorePersistenceSkip,
 	mockServerUc,
-	documentation
+	documentation,
+	parserContext
 ) {
 	let filteredNamespaces = {};
 	let namespaces = [];
-	let serviceEntityName = serviceNamespaceParam + "." + entityName;
+	let serviceEntityName = parserContext.serviceNamespace + "." + entityName;
 	let csnEntity = '"' + serviceEntityName + '": {\n';
 	let csnKeys;
 	let csnProperties;
 	let hasProperties;
 	csnEntity = csnEntity + '"kind": "entity",\n';
-	if (ignorePersistenceSkip === false) {	
-		csnEntity = csnEntity + '"@cds.persistence.skip": true,\n';	
+	if (ignorePersistenceSkip === false) {
+		csnEntity = csnEntity + '"@cds.persistence.skip": true,\n';
 	}
 	if (entityAttributes.Abstract && entityAttributes.Abstract.toUpperCase() === "TRUE") {
 		csnEntity = csnEntity + '"abstract": true,\n';
@@ -1358,14 +1317,14 @@ function _constructServiceEntity(
 
 	/* Merging the namespace list from entity set and entity type
 	And in case of same label, entity set's value will have precedence */
-	if(allEntitySetNamespaces[entityName]){
-		allEntitySetNamespaces[entityName].forEach((item) => {
+	if (parserContext.allEntitySetNamespaces[entityName]) {
+		parserContext.allEntitySetNamespaces[entityName].forEach((item) => {
 			filteredNamespaces[Object.keys(item)[0]] = Object.values(item)[0];
 		});
 	}
-	if(entityAttributes.allowedNamespaceAttributes.length){
+	if (entityAttributes.allowedNamespaceAttributes.length) {
 		entityAttributes.allowedNamespaceAttributes.forEach((item) => {
-			if(!filteredNamespaces[Object.keys(item)[0]]){
+			if (!filteredNamespaces[Object.keys(item)[0]]) {
 				filteredNamespaces[Object.keys(item)[0]] = Object.values(item)[0];
 			}
 		});
@@ -1373,12 +1332,12 @@ function _constructServiceEntity(
 	Object.keys(filteredNamespaces).forEach((item) => {
 		let obj = {};
 		obj[item] = filteredNamespaces[item];
-		namespaces.push(obj)
+		namespaces.push(obj);
 	});
 
-	if(namespaces)
+	if (namespaces)
 		csnEntity += _generateNamespaceAttributes(namespaces, false);
-	
+
 	// if documentation exists for the entity
 	if (documentation) {
 		csnEntity = csnEntity + `"doc": "${documentation}",` + '\n';
@@ -1386,19 +1345,16 @@ function _constructServiceEntity(
 	csnEntity = csnEntity + '"elements": {\n';
 
 	// Key Entity attributes
-	csnKeys = _generateCSNEntityKeys(entityKeysList, entityPropertiesMap);
+	csnKeys = _generateCSNEntityKeys(entityKeysList, entityPropertiesMap, parserContext);
 
 	// Non key Entity attributes
-	csnProperties = _generateCSNEntityProperties(
-		entityKeysList,
-		entityPropertiesMap
-	);
+	csnProperties = _generateCSNEntityProperties(entityKeysList, entityPropertiesMap, parserContext);
 	csnProperties = csnKeys + csnProperties;
 	//to remove additional ',\n' in case key datatype is undefined
 	if (csnProperties && csnProperties.startsWith(",\n")) {
 		csnProperties = csnProperties.substring(csnProperties.indexOf(",\n") + 2);
 	}
-	
+
 	csnEntity = csnEntity + csnProperties;
 
 	// No keys and No properties found
@@ -1407,45 +1363,50 @@ function _constructServiceEntity(
 		hasProperties = false;
 	}
 	// Entity navigation properties
-	csnEntity =
-		csnEntity +
+	csnEntity = csnEntity +
 		_generateCSNEntityNavigationProperties(
 			entityNavigationPropertiesMap,
 			hasProperties,
-			mockServerUc
+			mockServerUc,
+			parserContext
 		);
 	csnEntity = csnEntity + "}\n";
 
 	if (entityAttributes.BaseType) {
-		let baseTypeName = _getBaseTypeEntityName(entityAttributes.BaseType, serviceNamespaceParam);
+		let baseTypeName = _getBaseTypeEntityName(entityAttributes.BaseType, parserContext);
 		csnEntity = csnEntity + ",\n";
 		csnEntity = csnEntity + '"includes": ["' + baseTypeName + '"]\n';
 	}
 
 	//if the function import is bounded to entitySet 
-	if (allFunctionImportsMap[entityName])
-	{
+	if (parserContext.allFunctionImportsMap[entityName]) {	
 		csnEntity = csnEntity + ', \n "actions": {\n';
-		csnEntity = csnEntity + _getAllFunctionImports(allFunctionImportsMap[entityName],1,entityKeysList);
+		csnEntity = csnEntity + 
+			_getAllFunctionImports(parserContext.allFunctionImportsMap[entityName],
+				1, entityKeysList, parserContext
+			);
 		csnEntity = csnEntity + "}";
 	}
-	else if (allFunctionImportsMap[_extractEntityFromNamespace(allEntitySetMap[entityName])]) //if the function import is bounded to entityType
-	{
+	// if the function import is bounded to entityType
+	else if (parserContext.allFunctionImportsMap[_extractEntityFromNamespace(parserContext.allEntitySetMap[entityName])]) {
 		csnEntity = csnEntity + ', \n "actions": {\n';
-		csnEntity = csnEntity + _getAllFunctionImports(allFunctionImportsMap[_extractEntityFromNamespace(allEntitySetMap[entityName])],1,entityKeysList);
+		csnEntity = csnEntity +
+			_getAllFunctionImports(
+				parserContext.allFunctionImportsMap[_extractEntityFromNamespace(parserContext.allEntitySetMap[entityName])],
+				1, entityKeysList, parserContext
+			);
 		csnEntity = csnEntity + "}";
 	}
 
 	return csnEntity;
 }
 
-function _parseServiceEntity(
-	serviceNamespaceParam,
-	entityName,
-	entity,
-	ignorePersistenceSkip,
-	mockServerUc
-) {
+function _addBlobElement(properties) {
+	const blobElement = ['Edm.Stream', -1, -1, -1, -1, -1, -1];
+	properties['blob'] = blobElement;
+}
+
+function _parseServiceEntity(entityName, entity, ignorePersistenceSkip, mockServerUc, parserContext) {
 	let entityAttributes;
 	let entityKeysList;
 	let entityPropertiesMap;
@@ -1453,11 +1414,11 @@ function _parseServiceEntity(
 	let documentation;
 	Object.keys(entity).forEach((key) => {
 		if (key === "_attributes") {
-			entityAttributes = _parseEntityAttributes(entity[key]);
+			entityAttributes = _parseEntityAttributes(entity[key], parserContext);
 		} else if (key.toUpperCase() === "Key".toUpperCase()) {
 			entityKeysList = _parseEntityKeys(entity[key]);
 		} else if (key.toUpperCase() === "Property".toUpperCase()) {
-			entityPropertiesMap = _parseEntityProperty(entity[key]);
+			entityPropertiesMap = _parseEntityProperty(entity[key], parserContext);
 		} else if (key.toUpperCase() === "NavigationProperty".toUpperCase()) {
 			entityNavigationPropertiesMap = _parseNavigationProperty(entity[key]);
 		} else if (key.toUpperCase() === "Documentation".toUpperCase()) {
@@ -1478,12 +1439,13 @@ function _parseServiceEntity(
 	}
 	// If inherited entity found
 	if (entityAttributes.BaseType) {
-		allEntities.push(
-			_extractEntityFromNamespace(entityAttributes.BaseType)
-		);
+		parserContext.allEntities.push(_extractEntityFromNamespace(entityAttributes.BaseType));
 	}
+	// adding blob element if entity has m:HasStream as true
+	const checkProperty = entityAttributes["allowedNamespaceAttributes"].filter(e => e["m.HasStream"] === 'true');
+	if (checkProperty.length === 1) _addBlobElement(entityPropertiesMap);
+	
 	return _constructServiceEntity(
-		serviceNamespaceParam,
 		entityName,
 		entityKeysList,
 		entityPropertiesMap,
@@ -1491,18 +1453,19 @@ function _parseServiceEntity(
 		entityAttributes,
 		ignorePersistenceSkip,
 		mockServerUc,
-		documentation
+		documentation,
+		parserContext
 	);
 }
 
-function _getEntitesWithNamesFromEntitySets(serviceNamespaceParam, entityJson, mockServerUc) {
+function _getEntitesWithNamesFromEntitySets(entityJson, mockServerUc, parserContext) {
 	const getEntityName = mockServerUc
-		? (entity) => allEntitySetMapMC[serviceNamespaceParam + "." + _getEntityName(entity)]
+		? (entity) => parserContext.allEntitySetMapMC[parserContext.serviceNamespace + "." + _getEntityName(entity)]
 		: (entity) => [_getEntityName(entity)];
 
 	const isNameInEntitySet = mockServerUc
-		? (name) => allEntitiesMC.indexOf(name) >= 0
-		: (name) => allEntities.indexOf(name) >= 0;
+		? (name) => parserContext.allEntitiesMC.indexOf(name) >= 0
+		: (name) => parserContext.allEntities.indexOf(name) >= 0;
 
 	const getEntitySetNames = entityWithName => {
 		if (!entityWithName.name) return false;
@@ -1521,60 +1484,50 @@ function _getEntitesWithNamesFromEntitySets(serviceNamespaceParam, entityJson, m
 		.filter((entityWithName) => getEntitySetNames(entityWithName));
 }
 
-function _getEntitesWithNamesFromEntityTypes(serviceNamespaceParam, entityJson) {
+function _getEntitesWithNamesFromEntityTypes(entityJson, parserContext) {
 	let entities = [];
 	// we are not making any decision here on the basis of mockserverUc variable as of now
 	for (let i = 0; i < entityJson.length; i++) {
 		let entity = _getEntityName(entityJson[i]);
 		// if entity doesn't have any mapping with entity set,
 		// then collect those entityType
-		if (!allEntitySetMapMC[serviceNamespaceParam + "." + entity]) {
-			entities.push( { 
-				entity: entityJson[i], 
-				name: [entity] 
-			} );
+		if (!parserContext.allEntitySetMapMC[parserContext.serviceNamespace + "." + entity]) {
+			entities.push({
+				entity: entityJson[i],
+				name: [entity]
+			});
 		}
 	}
 
 	return entities;
 }
 
-function _parsingServiceEntities(
-	entitiesWithNames,
-	serviceNamespaceParam,
-	ignorePersistenceSkip,
-	mockServerUc
-){
-	return  entitiesWithNames.map((entityWithName) => 
-				entityWithName.name.map((entityName) =>
-					_parseServiceEntity(
-						serviceNamespaceParam,
-						entityName,
-						entityWithName.entity,
-						ignorePersistenceSkip,
-						mockServerUc
-					)
-				).join("},") + "}"
-			);
+function _parsingServiceEntities(entitiesWithNames, ignorePersistenceSkip, mockServerUc, parserContext) {
+	return entitiesWithNames.map((entityWithName) =>
+		entityWithName.name.map((entityName) =>
+			_parseServiceEntity(
+				entityName,
+				entityWithName.entity,
+				ignorePersistenceSkip,
+				mockServerUc,
+				parserContext
+			)
+		).join("},") + "}"
+	);
 }
 
-function _getServiceEntitites(
-	serviceNamespaceParam,
-	entityJson = [],
-	ignorePersistenceSkip,
-	mockServerUc
-) {
+function _getServiceEntitites(entityJson = [], ignorePersistenceSkip, mockServerUc, parserContext) {
 	const entities = Array.isArray(entityJson) ? entityJson : [entityJson];
 	let entitiesWithNames = []; // [0]-> entity set, [1]-> entity type
 	let parsedEntities = []; // [0]-> entity set, [1]-> entity type
 
-	entitiesWithNames[0] = _getEntitesWithNamesFromEntitySets(serviceNamespaceParam, entities, mockServerUc);
-	entitiesWithNames[1] = _getEntitesWithNamesFromEntityTypes(serviceNamespaceParam, entities);
+	entitiesWithNames[0] = _getEntitesWithNamesFromEntitySets(entities, mockServerUc, parserContext);
+	entitiesWithNames[1] = _getEntitesWithNamesFromEntityTypes(entities, parserContext);
 
 	for (let i = 0; i < 2; i++) {
 		if (entitiesWithNames[i].length) {
 			parsedEntities[i] = _parsingServiceEntities(entitiesWithNames[i],
-				serviceNamespaceParam, ignorePersistenceSkip, mockServerUc);
+				ignorePersistenceSkip, mockServerUc, parserContext);
 		}
 	}
 	// if entities from entity set and entity type both are parsed
@@ -1588,91 +1541,76 @@ function _getServiceEntitites(
 	return "";
 }
 
-function _generateEDMXJSON2CSN(
-	jsonObj,
-	serviceNamespaceParam,
-	ignorePersistenceSkip,
-	mockServerUc
-) {
+function _generateEDMXJSON2CSN(jsonObj, ignorePersistenceSkip, mockServerUc, parserContext) {
 	const csn = {};
 	csn.meta = {};
-    csn.meta.creator = 'cds-dk ' + versionInfo;
+	csn.meta.creator = 'cds-dk ' + versionInfo;
 	csn.$version = '2.0';
 	csn.definitions = {};
 
 	// Extract association sets
-	let associationSets =
-		jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityContainer
-			.AssociationSet;
+	let associationSets = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityContainer.AssociationSet;
 	if (associationSets) {
-		_extractAllAssociationSets(associationSets);
+		_extractAllAssociationSets(associationSets, parserContext);
 	}
 	// Extract associations
-	const associations =
-		jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.Association;
+	const associations = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.Association;
 	if (associations) {
-		_extractAllAssociations(associations);
+		_extractAllAssociations(associations, parserContext);
 	}
 	// Extract entities from EntitySets
-	const entitySets =
-		jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityContainer
-			.EntitySet;
+	const entitySets = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityContainer.EntitySet;
 	if (entitySets) {
-		_extractAllEntityFromEntitySets(entitySets);
+		_extractAllEntityFromEntitySets(entitySets, parserContext);
 	}
 	// Extract function imports
-	const functionImports = 
-		jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityContainer
-			.FunctionImport;
-	if(functionImports) {
-		_extractAllFunctionImports(functionImports, serviceNamespaceParam);
+	const functionImports = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityContainer.FunctionImport;
+	if (functionImports) {
+		_extractAllFunctionImports(functionImports, parserContext);
 	}
 	// Extract complex types
-	const complexTypes =
-		jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.ComplexType;
+	const complexTypes = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.ComplexType;
 	if (complexTypes) {
-		_extractAllComplexTypes(complexTypes, serviceNamespaceParam);
+		_extractAllComplexTypes(complexTypes, parserContext);
 	}
 
 	// Construct CSN entity based on EDMX entity
-	const entityJson =
-		jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityType;
+	const entityJson = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityType;
 	const definitions = [];
 
 	if (mockServerUc) {
-		let def  = '"' + serviceNamespaceParam + '": {"kind": "service"' + ',\n' + '"@cds.external": true';
+		let def = '"' + parserContext.serviceNamespace + '": {"kind": "service"' + ',\n' + '"@cds.external": true';
 		let serviceDoc = jsonObj["edmx:Edmx"]["edmx:DataServices"]["Schema"].EntityContainer.Documentation;
-		let namespaceAttributes = namespaceAttributeFilter(jsonObj["edmx:Edmx"]["edmx:DataServices"]["Schema"].EntityContainer["_attributes"]);
+		let namespaceAttributes = namespaceAttributeFilter(
+				jsonObj["edmx:Edmx"]["edmx:DataServices"]["Schema"].EntityContainer["_attributes"], parserContext
+			);
 		// if documentation exists for service
 		if (serviceDoc) {
 			let doc = _parseDocumentationTag(serviceDoc);
 			if (doc) def += ',\n' + `"doc": "${doc}"`;
 		}
-		if(namespaceAttributes.length)
-			def += _generateNamespaceAttributes(namespaceAttributes,true);
+		if (namespaceAttributes.length)
+			def += _generateNamespaceAttributes(namespaceAttributes, true);
 		def += "}";
 		definitions.push(def);
 	}
 
 	// If complex type exists
 	if (complexTypes) {
-		definitions.push(_getServiceComplexTypes());
+		definitions.push(_getServiceComplexTypes(parserContext));
 	}
 
-	//if there are unbounded function imports
-	if(Object.keys(allFunctionImports).length > 0)
-	{
-		definitions.push(_getAllFunctionImports(allFunctionImports,0,0)); //passing 0 for unbounded actions/functions and 0 for entityKeysList 
+	// if there are unbounded function imports
+	if (Object.keys(parserContext.allFunctionImports).length > 0) {
+		// passing 0 for unbounded actions/functions and 0 for entityKeysList 
+		definitions.push(
+			_getAllFunctionImports(parserContext.allFunctionImports, 0, 0, parserContext)
+		);
 	}
 
 	if (entityJson) {
 		definitions.push(
-			_getServiceEntitites(
-				serviceNamespaceParam,
-				entityJson,
-				ignorePersistenceSkip,
-				mockServerUc
-			)
+			_getServiceEntitites(entityJson, ignorePersistenceSkip, mockServerUc, parserContext)
 		);
 	}
 
@@ -1684,35 +1622,34 @@ function _generateEDMXJSON2CSN(
 	}
 }
 
-function getEdmxv2CSN(
-	edmx2jsonModel,
-	ignorePersistenceSkip,
-	mockServerUc,
-	context
-) {
+function getEdmxv2CSN(edmx2jsonModel, ignorePersistenceSkip, mockServerUc, context) {
 	let csnDataModel;
 	let isValid;
-	_initialize();
+
+	const parserContext = {};
+	_initialize(parserContext);
+	
 	if (!context.include_all_namespaces && context.namespaces.length) {
-		allowedNamespaces = allowedNamespaces.concat(context.namespaces)
+		parserContext.allowedNamespaces = parserContext.allowedNamespaces.concat(context.namespaces)
+	}
+	else if (context.include_all_namespaces) {
+		parserContext.allowAllNamespaces = true;
 	}
-	else if(context.include_all_namespaces) {
-		allowAllNamespaces = true;
-	} 
 
 	isValid = _validateEDMX(edmx2jsonModel);
 	if (isValid) {
-		serviceNamespace = _getServiceNameSpace(edmx2jsonModel);
+		parserContext.serviceNamespace = _getServiceNameSpace(edmx2jsonModel);
 		let namespaceAlias = edmx2jsonModel["edmx:Edmx"]["edmx:DataServices"].Schema._attributes.Alias;
 		// replace the namespace alias value with original namespace value
 		if (namespaceAlias) {
-			edmx2jsonModel = common.replaceAliasValue(JSON.stringify(edmx2jsonModel), serviceNamespace, namespaceAlias);
+			edmx2jsonModel = common.replaceAliasValue(JSON.stringify(edmx2jsonModel), 
+			parserContext.serviceNamespace, namespaceAlias);
 		}
 		csnDataModel = _generateEDMXJSON2CSN(
 			edmx2jsonModel,
-			serviceNamespace,
 			ignorePersistenceSkip,
-			mockServerUc
+			mockServerUc,
+			parserContext
 		);
 	}
 	return csnDataModel;