@sap/cds-dk 4.5.2 → 4.6.2

package/lib/import/common.js

@@ -30,6 +30,14 @@ function checkForEmptyKeys(element, oDataVersion) {
     }    
 }
 
+//to replace the alias value with original schema namespace value
+function replaceAliasValue(schemaContent, schemaNamespaceValue, aliasValue){
+    const re = RegExp(`([("/])${aliasValue}([/").])`, 'g');
+    const val = `$1${schemaNamespaceValue}$2`;
+    schemaContent = schemaContent.replace(re, val);
+    return JSON.parse(schemaContent);
+}
+
 async function _getODataVersion(edmx) {
     let oDataVersion;
     let jsonObj;
@@ -115,5 +123,6 @@ module.exports = {
     getVersion,
     getSuffix,
     supportedFormats,
-    checkForEmptyKeys
+    checkForEmptyKeys,
+    replaceAliasValue
 };

package/lib/import/importapi.js

@@ -1,5 +1,7 @@
 const edm2csn = require('.');
-
+let context={};
+context.oDataInfo = {};
+context.namespaces = [];
 /**
 * This is the import API function to generate CSN from XML/EDMX files.
 * @param {string} filepath
@@ -10,11 +12,10 @@ const edm2csn = require('.');
 * - other import options not supported
 * @returns {object} CSN
 */
-const oDataInfo={};
 module.exports = async function cds_import(filepath, options = {keepNamespace : false}) //namespace will be taken as false in case it is not mentioned
 {
         filepath = await edm2csn.isValidInputFile(filepath);
         let edmx= await edm2csn.getMetadataFromFile(filepath);
-        let csn = await edm2csn.edmx2csn(edmx, !options.keepNamespace && filepath, false, oDataInfo);
+        let csn = await edm2csn.edmx2csn(edmx, !options.keepNamespace && filepath, context);
         return csn;
 }

package/lib/import/index.js

@@ -116,7 +116,15 @@ function _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace) {
 			</Schema>
 		</edmx:DataServices>
 	*/
-	edmx = edmx.replace(multipleSchemas, '').replace(/<Schema Namespace="[^"]+"/, `<Schema Namespace="${namespace}"`);
+
+	// Remove the ending and beginning of the first and second schema tag
+	edmx = edmx.replace(multipleSchemas, '');
+	// Now capture the schema tag details
+	let schemaDetails = edmx.match(/(<Schema [^>]*>)/);
+	// Replace the Namespace value with the correct one
+	schemaDetails = schemaDetails[0].replace(/Namespace="[^"]+"/, `Namespace="${namespace}"`);
+	// Place the above computed schema details in the edmx content
+	edmx = edmx.replace(/(<Schema [^>]*>)/, `${schemaDetails}`);
 
 	return edmx;
 }
@@ -132,7 +140,7 @@ async function edmx2csn(edmx, filename, context) {
     if (multipleSchemas.test(edmx)) {
         edmx = _convertEDMXWithMultipleSchemas(edmx, multipleSchemas, namespace);
     }
-	let csn = await generateCSN(edmx, true, context);
+	let csn = await generateCSN(edmx, false, true, context);
 	if (filename) {
 		// Replace namespace by given filename in the csn file instead of edmx file
         const re = RegExp(`([("/])${namespace}([/").])`, 'g');
@@ -151,20 +159,33 @@ async function _generateEDMX2JSON(edmx) {
 	return JSON.parse(cjson);
 }
 
-async function generateCSN(edmx, mockServerUc, context) {
+async function generateCSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
 	let csn;
 	let odataVersion;
 	let edmx2jsonModel;
+	let defaultNamespaces;
+	let namespaces = [];
+	if(context.namespaces) namespaces.push(...(context.namespaces));
 	odataVersion = await common.getVersion(edmx);
 	if (odataVersion === "V2") {
 		if(context){
 			context.oDataVersion = "V2";
 		}
+		//default namespaces to be present
+		if(!context.include_all_namespaces)
+		{
+			defaultNamespaces = ['edmx','sap','m'];
+			namespaces = namespaces.concat(defaultNamespaces);
+			namespaces = namespaces.filter((item,pos) => namespaces.indexOf(item) === pos); //removing duplicate values
+		}
+		context.namespaces = namespaces;
 		edmx2jsonModel = await _generateEDMX2JSON(edmx);
 		return new Promise(function getCsn(resolve, reject) {
 			csn = edmxv2CSN.getEdmxv2CSN(
 				edmx2jsonModel,
-				mockServerUc
+				ignorePersistenceSkip,
+				mockServerUc,
+				context
 			);
 			if (csn) {
 				resolve(csn);
@@ -177,7 +198,15 @@ async function generateCSN(edmx, mockServerUc, context) {
 		if(context){
 			context.oDataVersion = "V4";
 		}
-		return edmxv4CSN.getEdmxv4CSN(edmx, mockServerUc);
+		//default namespaces to be present
+		if(!context.include_all_namespaces)
+		{
+			defaultNamespaces = ['edmx'];
+			namespaces = namespaces.concat(defaultNamespaces);
+			namespaces = namespaces.filter((item,pos) => namespaces.indexOf(item) === pos); //removing duplicate values
+		}
+		context.namespaces = namespaces;
+		return edmxv4CSN.getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context);
 	}
 	return new Promise(function invalidFile(resolve, reject) {
 		reject(new Error(messages.INVALID_EDMX_METADATA));

package/lib/import/message.js

@@ -9,10 +9,11 @@ const messages = {
 	MISSING_ENTITY_CONTAINER: 'There is no entity container in the OData model. Specify the correct OData model.',
 	MISSING_ENTITY_SETS: 'There are no entity sets in the OData model. Specify the correct OData model.',
 	INVALID_INPUT_FILE: 'Input file provided is not valid. Please provide a file with either .edmx or .xml extension.',
-	FILE_MODIFIED: 'The file with the same name exists and is been modified. Use --f flag to forcefully overwrite the file.',
+	FILE_MODIFIED: 'The file with the same name exists and is been modified. Use --force flag to forcefully overwrite the file.',
 	OUTPUT_FILE_MISMATCH: 'Specify the file extension that --as option supports.',
 	INVALID_AS_OPTION: 'For --as option, please specify one of these output file format [cds, csn, json].',
 	INCORRECT_EXTENSION: 'If --as option is not provided, then please provide either .json or .csn output file extension.',
+	INCORRECT_INPUT_NAMESPACES: 'Invalid value for --include-namespaces option. Specify namespaces as comma-separated list or "*"'
 };
 
 function getMessages() {

package/lib/import/utils/MetadataConverter.js

@@ -396,7 +396,7 @@ class Expression {
         const target = this.getTarget();
         const element = this.getElement();
         const attribs = element.attributes;
-
+        let custom_namespace = MetadataConverter.custom_namespace;
         if (attribs == null) return;
         let realType = attribs.Type || attribs.EntityType || attribs.UnderlyingType;
         const propertyName = attribs.UnderlyingType == null ? '$Type' : '$UnderlyingType';
@@ -574,9 +574,29 @@ class Expression {
             !(target.$Kind === 'NavigationProperty' && target.$Collection === true)) {
             target.$Nullable = true;
         }
+        const nonStdAttributes = this.getNonStdAttributes(element.attributes);
+        for (let i = 0; i < nonStdAttributes.length; i++) {
+            let attr = nonStdAttributes[i];
+            let [prefix, attrName] = attr.split(':');
+            if(attrName)
+                attrName = attrName.replace(/-/g,'.');
+            let attribute;
+            if ((custom_namespace.includes(prefix) && attrName !== undefined) || custom_namespace.includes(true))
+                attribute = "@" + prefix + "." + attrName;
+            else if (attrName === undefined)
+                attribute = "$" + prefix;
+            if (attribute !== undefined)
+                target[attribute] = element.attributes[attr];
+        }
+    }
+    getNonStdAttributes(attributes) {
+        const attributeList = [];
+        const standardArrtibutes = ['MaxLength', 'Precision', 'Scale', 'Nullable', 'DefaultValue', 
+            'Name', 'Type', 'HasStream', 'IsFlags', 'Alias', 'Namespace', 'BaseType', 'Partner', 
+            'IsComposable', 'ContainsTarget', 'IsBound', 'EntitySet', 'EntitySetPath', 'EntityType'];
+        attributeList.push(...Object.keys(attributes).filter(attribute => standardArrtibutes.indexOf(attribute) === -1));
+        return attributeList;
     }
-
-
 }
 
 class EdmPrimitiveType {
@@ -2361,7 +2381,8 @@ class OnDeleteExpression extends Expression {
 }
 
 
-MetadataConverter.createOdataV4MetadataXmlToOdataV4CsdlStrategy = () => {
+MetadataConverter.createOdataV4MetadataXmlToOdataV4CsdlStrategy = (name_space) => {
+    MetadataConverter.custom_namespace = name_space;
     return new MetadataConverter.DefaultXmlStrategy()
         .use('http://docs.oasis-open.org/odata/ns/edmx:Edmx', (element, parentExpression, context) => {
             return new EdmxRootExpression(element, null, context);

package/lib/import/utils/MetadataConverterFactory.js

@@ -1,5 +1,4 @@
 'use strict';
-
 const xmljs = require('xml-js');
 const MetadataConverterV4 = require('../utils/MetadataConverter');
 
@@ -61,7 +60,7 @@ class MetadataConverterFactory {
      *
      */
     static createEdmxV40XmlToV40Json(options = {}) {
-        const defaultStrategy = MetadataConverterV4.createOdataV4MetadataXmlToOdataV4CsdlStrategy();
+        const defaultStrategy = MetadataConverterV4.createOdataV4MetadataXmlToOdataV4CsdlStrategy(options);
 
         if (options.astFactory) {
             defaultStrategy.setASTFactory(options.astFactory);

package/lib/import/utils/MultiMap.js

@@ -67,6 +67,32 @@ var Multimap = (function () {
         return this;
     };
 
+    /**
+   * @return {Array} all the keys in the map
+   */
+    Multimap.prototype.keys = function () {
+        if (this._map)
+            return makeIterator(this._.keys());
+
+        return makeIterator(Object.keys(this._));
+    };
+
+    function makeIterator(iterator) {
+        if (Array.isArray(iterator)) {
+            var nextIndex = 0;
+
+            return {
+                next: function () {
+                    return nextIndex < iterator.length ?
+                        { value: iterator[nextIndex++], done: false } :
+                        { done: true };
+                }
+            };
+        }
+
+        return iterator;
+    }
+
     return Multimap;
 })();
 

package/lib/import/v2parser.js

@@ -15,7 +15,10 @@ 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;
@@ -57,9 +60,49 @@ function _initialize() {
 	allAssociationSets = {};
 	allComplexTypes = {};
 	allComplexTypeDocs = {};
+	allComplexTypeNamespaces = {};
 	allInheritedComplexTypes = {};
+	allowedNamespaces = [];
+	allowAllNamespaces = false;
 }
 
+// Function to extract allowed namespace attributes from given set of attributes
+function namespaceAttributeFilter(attributes) {
+	let namespaceAttributes = allowAllNamespaces
+		? Object.keys(attributes).filter((attr) => attr.includes(':'))
+		: Object.keys(attributes).filter(
+				(attr) =>
+					attr.includes(':') &&
+					allowedNamespaces.includes(attr.split(':')[0]));
+			
+
+	namespaceAttributes = namespaceAttributes.map(attribute => {
+		const index = attribute.indexOf(':');
+		let namespace = attribute.slice(0, index);
+		let name = attribute.slice(index + 1);
+
+		name = name.replace(/-/g, '.');
+
+		let formattedAttribute = {};
+		formattedAttribute[`${namespace}.${name}`] = _replaceSpecialCharacters(attributes[attribute]);
+		return formattedAttribute;
+	});
+
+	return namespaceAttributes;
+}
+
+//Function to generate CSN for namespace attributes 
+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';
+	});
+
+	return csn;
+}
 function _isValidEDMX(jsonObj) {
 	let isValid = false;
 	let edmx;
@@ -300,20 +343,20 @@ function _extractAllFunctionImports(functionImports, serviceNamespaceParam)
 	}
 }
 
-function _removeCarriageReturn(text) {
-    return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\\n").replace(/\s+/g, ' ').trim();
+function _replaceSpecialCharacters(text) {
+    return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\\n").replace(/\s+/g, ' ').replace(/"/g, """).trim();
 }
 
 // to parse the documentation tag
 function _parseDocumentationTag(documentedContent) {
 	let documentation = "";
 	if (documentedContent.Summary && documentedContent.Summary._text) {
-		documentation = _removeCarriageReturn(documentedContent.Summary._text);
+		documentation = _replaceSpecialCharacters(documentedContent.Summary._text);
 	}	
 	if (documentedContent.LongDescription && documentedContent.LongDescription._text) {
 		if (documentedContent.Summary)
 			documentation += "\\n\\n";
-		documentation += _removeCarriageReturn(documentedContent.LongDescription._text);
+		documentation += _replaceSpecialCharacters(documentedContent.LongDescription._text);
 	}
 	return documentation;
 }
@@ -322,10 +365,12 @@ function _extractComplexType(complexType, serviceNamespaceParam) {
 	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]);
 			baseType = complexType[key].BaseType;
 		} else if (key === "Property") {
 			properties = complexType.Property;
@@ -337,6 +382,9 @@ function _extractComplexType(complexType, serviceNamespaceParam) {
 	if (complexTypeKey && baseType) {
 		allInheritedComplexTypes[complexTypeKey] = baseType;
 	}
+	if (namespaceAttributes.length) {
+		allComplexTypeNamespaces[complexTypeKey] = namespaceAttributes;
+	}
 }
 
 function _extractAllComplexTypes(complexTypes, serviceNamespaceParam) {
@@ -361,7 +409,8 @@ function _getServiceEntityProperty(
 	displayFormat,
 	isKey,
 	documentation,
-	isCollection
+	isCollection,
+	allowedNamespaceAttributes = -1
 ) {
 	let cdsDataType = null;
 	let hasInvalidPrecision = false;
@@ -427,6 +476,10 @@ function _getServiceEntityProperty(
 		propertyJson = propertyJson + ',\n"doc":"' + documentation + '"';
 	}
 
+	if (allowedNamespaceAttributes !== -1) {
+		propertyJson += _generateNamespaceAttributes(allowedNamespaceAttributes, true);
+	}
+
 	if(propertyName)
 		propertyJson = propertyJson + "\n}";
 	return propertyJson;
@@ -437,6 +490,9 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 	let complexTypeProperty;
 	let i;
 	complexTypeCSN = complexTypeCSN + '"kind": "type",\n';
+	if(allComplexTypeNamespaces[complexTypeKey]) {
+		complexTypeCSN += _generateNamespaceAttributes(allComplexTypeNamespaces[complexTypeKey], false);
+	}
 	if (allComplexTypeDocs[complexTypeKey])
 		complexTypeCSN = complexTypeCSN + '"doc":' + `"${allComplexTypeDocs[complexTypeKey]}",` + "\n";
 	complexTypeCSN = complexTypeCSN + '"elements": {\n';
@@ -447,6 +503,10 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 				complexTypeProperty = complexType[i]._attributes;
 				if(complexType[i].Documentation)
 					complexTypeProperty.doc = _parseDocumentationTag(complexType[i].Documentation);
+
+				let namespaceAttributes = namespaceAttributeFilter(complexTypeProperty)	
+				const complexTypePropertyNamespace = namespaceAttributes.length ? namespaceAttributes : -1
+					
 				complexTypeCSN =
 					complexTypeCSN +
 					_getServiceEntityProperty(
@@ -458,7 +518,8 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 						complexTypeProperty["sap:display-format"],
 						false,
 						complexTypeProperty.doc,
-						-1
+						-1,
+						complexTypePropertyNamespace
 					);
 				if (i !== complexType.length - 1) {
 					complexTypeCSN = complexTypeCSN + ",\n";
@@ -471,6 +532,10 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 			complexTypeProperty = complexType._attributes;
 			if(complexType.Documentation)
 				complexTypeProperty.doc = _parseDocumentationTag(complexType.Documentation);
+
+			let namespaceAttributes = namespaceAttributeFilter(complexTypeProperty);
+			const complexTypePropertyNamespace = namespaceAttributes.length ? namespaceAttributes : -1;
+			
 			complexTypeCSN =
 				complexTypeCSN +
 				_getServiceEntityProperty(
@@ -482,7 +547,8 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 					complexTypeProperty["sap:display-format"],
 					false,
 					complexTypeProperty.doc,
-					-1
+					-1,
+					complexTypePropertyNamespace
 				);
 		}
 	}
@@ -527,6 +593,10 @@ function _parseParameter(parameter)
 	let isCollection = -1;
 	if(parameter.Documentation)
 		doc = _parseDocumentationTag(parameter.Documentation);
+
+	let namespaceAttributes = namespaceAttributeFilter(parameter._attributes);
+	const parameterNamespaceAttributes = namespaceAttributes.length ? namespaceAttributes : -1;
+
 	let type = parameter["_attributes"].Type;
 	if(type.substring(0,10) === 'Collection')
 	{
@@ -541,7 +611,8 @@ function _parseParameter(parameter)
 				parameter["_attributes"]["sap:display-format"],
 				false,
 				doc,
-				isCollection);
+				isCollection,
+				parameterNamespaceAttributes);
 	return csn;
 }
 
@@ -605,7 +676,7 @@ function _getFunctionImport(functionImport,isBounded) {
 	}
 	if(functionImport[4] !== -1)
 	{
-		csn = csn + ',\n "doc": "' + functionImport[4] + '"'; 
+		csn = csn + ',\n "doc": "' + _replaceSpecialCharacters(functionImport[4]) + '"';
 	}
 
 	csn = csn + "\n }";
@@ -640,6 +711,8 @@ function _parseEntityAttributes(attributes) {
 	entityAttributes.Name = attributes.Name;
 	entityAttributes.BaseType = attributes.BaseType;
 	entityAttributes.Abstract = attributes.Abstract;
+	entityAttributes.allowedNamespaceAttributes = namespaceAttributeFilter(attributes);
+
 	return entityAttributes;
 }
 
@@ -661,6 +734,9 @@ function _parseEntityKeys(keys) {
 
 function _getPropertyAttributes(propAttributes) {
 	let propOthers = [];
+
+	let namespaceAttributes = namespaceAttributeFilter(propAttributes)
+
 	propOthers.push(propAttributes.Type);
 	if (propAttributes.MaxLength) {
 		propOthers.push(propAttributes.MaxLength);
@@ -690,6 +766,13 @@ function _getPropertyAttributes(propAttributes) {
 	}else{
 		propOthers.push(-1);
 	}
+
+	if (namespaceAttributes.length) {
+		propOthers.push(namespaceAttributes);
+	} else {
+		propOthers.push(-1);
+	}
+
 	return propOthers;
 }
 
@@ -758,7 +841,8 @@ function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap) {
 				propAttributes[4],
 				true,
 				propAttributes[5],
-				-1
+				-1,
+				propAttributes[6]
 			);
 		if (i !== entityKeysList.length - 1) {
 			csnEntity = csnEntity + ",\n";
@@ -796,7 +880,8 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
 					propAttributes[4],
 					false,
 					propAttributes[5],
-					-1
+					-1,
+					propAttributes[6]
 				);
 			if (i !== entityProperties.length - 1) {
 				csnEntity = csnEntity + ",\n";
@@ -1078,6 +1163,7 @@ function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc) {
 	let navPropName;
 	let relationshipName;
 	let navPropDoc;
+	let allowedNamespaceAttributes = namespaceAttributeFilter(navPropAttributes);
 	// var fromRole;
 	let toRole;
 	if (!navPropAttributes) {
@@ -1090,6 +1176,9 @@ function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc) {
 	navPropDoc = navPropAttributes.doc;
 
 	csn = csn + '"' + navPropName + '": {\n';
+	if(allowedNamespaceAttributes.length) {
+		csn += _generateNamespaceAttributes(allowedNamespaceAttributes, false);
+	}
 	// if documentatin exists for navigation property
 	if (navPropDoc) {
 		csn = csn + '"doc":' + `"Please add  an ON condition\\n${navPropDoc}",\n`;
@@ -1156,6 +1245,7 @@ function _constructServiceEntity(
 	entityPropertiesMap,
 	entityNavigationPropertiesMap,
 	entityAttributes,
+	ignorePersistenceSkip,
 	mockServerUc,
 	documentation
 ) {
@@ -1165,12 +1255,20 @@ function _constructServiceEntity(
 	let csnProperties;
 	let hasProperties;
 	csnEntity = csnEntity + '"kind": "entity",\n';
+	if (ignorePersistenceSkip === false) {	
+		csnEntity = csnEntity + '"@cds.persistence.skip": true,\n';	
+	}
 	if (
 		entityAttributes.Abstract &&
 		entityAttributes.Abstract.toUpperCase() === "TRUE"
 	) {
 		csnEntity = csnEntity + '"abstract": true,\n';
 	}
+
+	if(entityAttributes.allowedNamespaceAttributes.length)
+	{
+		csnEntity += _generateNamespaceAttributes(entityAttributes.allowedNamespaceAttributes, false);
+	}
 	// if documentation exists for the entity
 	if (documentation) {
 		csnEntity = csnEntity + `"doc": "${documentation}",` + '\n';
@@ -1230,6 +1328,7 @@ function _parseServiceEntity(
 	serviceNamespaceParam,
 	entityName,
 	entity,
+	ignorePersistenceSkip,
 	mockServerUc
 ) {
 	let entityAttributes;
@@ -1278,6 +1377,7 @@ function _parseServiceEntity(
 		entityPropertiesMap,
 		entityNavigationPropertiesMap,
 		entityAttributes,
+		ignorePersistenceSkip,
 		mockServerUc,
 		documentation
 	);
@@ -1318,6 +1418,7 @@ function _getEntitesWithNamesFromEntitySets(
 function _getServiceEntitites(
 	serviceNamespaceParam,
 	entityJson = [],
+	ignorePersistenceSkip,
 	mockServerUc
 ) {
 	const entities = Array.isArray(entityJson) ? entityJson : [entityJson];
@@ -1335,6 +1436,7 @@ function _getServiceEntitites(
 						serviceNamespaceParam,
 						entityName,
 						entityWithName.entity,
+						ignorePersistenceSkip,
 						mockServerUc
 					)
 				)
@@ -1348,6 +1450,7 @@ function _getServiceEntitites(
 function _generateEDMXJSON2CSN(
 	jsonObj,
 	serviceNamespaceParam,
+	ignorePersistenceSkip,
 	mockServerUc
 ) {
 	const csn = {};
@@ -1422,6 +1525,7 @@ function _generateEDMXJSON2CSN(
 			_getServiceEntitites(
 				serviceNamespaceParam,
 				entityJson,
+				ignorePersistenceSkip,
 				mockServerUc
 			)
 		);
@@ -1437,17 +1541,32 @@ function _generateEDMXJSON2CSN(
 
 function getEdmxv2CSN(
 	edmx2jsonModel,
-	mockServerUc
+	ignorePersistenceSkip,
+	mockServerUc,
+	context
 ) {
 	let csnDataModel;
 	let isValid;
 	_initialize();
+	if (!context.include_all_namespaces && context.namespaces.length) {
+		allowedNamespaces = allowedNamespaces.concat(context.namespaces)
+	}
+	else if(context.include_all_namespaces) {
+		allowAllNamespaces = true;
+	} 
+
 	isValid = _validateEDMX(edmx2jsonModel);
 	if (isValid) {
 		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);
+		}
 		csnDataModel = _generateEDMXJSON2CSN(
 			edmx2jsonModel,
 			serviceNamespace,
+			ignorePersistenceSkip,
 			mockServerUc
 		);
 	}