@sap/cds-dk 4.5.2 → 4.6.2

package/lib/import/v4parser.js

@@ -3,8 +3,8 @@
  * OData V4 to CSN parser
  */
 
-'use strict';
 
+'use strict';
 let messages = require("./message").getMessages();
 let common = require("./common");
 let versionInfo = require('../../package.json').version;
@@ -24,7 +24,6 @@ let functionImportToFunctionMap = new Multimap();
 let validEdmDatatypes = ['Edm.DateTimeOffset'];
 let jsonEntityContainerName;
 const ignoreObjects = ['$Reference']; // add all the objects that needs to be ignored for parsing.
-
 const MetadataConverterFactory = require('../import/utils/MetadataConverterFactory');
 const edmxncdsdatatype = {
     'Edm.String': 'cds.LargeString',
@@ -117,11 +116,19 @@ function _validateJSON(jsonObj) {
     );
 }
 
+function _includeExternalNamespaceAnnotation(source,target){
+    Object.entries(source).forEach(element =>{
+        if(element[0].startsWith('@')){
+            target[element[0]] = element[1];
+            }
+    });
+}
 function generatePropertyCsn(propertyType, isPrimaryKey) {
     let property = {};
     if (isPrimaryKey) {
         property.key = true;
     }
+    _includeExternalNamespaceAnnotation(propertyType,property);
     // conditions have to be made
     if (propertyType.$MaxLength) {
         if (propertyType.$Type) {
@@ -141,7 +148,7 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
         }
     } else if (propertyType.$Type) {
         property.type = edmxncdsdatatype[propertyType.$Type];
-    } else {
+    } else{
         property.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
     return property;
@@ -218,10 +225,11 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     if (common.checkForEmptyKeys(associationProperty, "V4")) {
         associationProperty.keys = [];
     }
+    _includeExternalNamespaceAnnotation(associationNode,associationProperty);
     return associationProperty;
 }
 
-function _generateCSNForEntityType(entityTypes, mockServerUc) {
+function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServerUc) {
     let entityCsn = {};
     let keySet;
     let curKey;
@@ -235,6 +243,10 @@ function _generateCSNForEntityType(entityTypes, mockServerUc) {
         if (key) {
             entityCsn[key] = {};
             entityCsn[key].kind = 'entity';
+            if (!ignorePersistenceSkip) {	
+                entityCsn[key]['@cds.persistence.skip'] = true;	
+            }
+            _includeExternalNamespaceAnnotation(element[key],entityCsn[key]);
             // inheritance
             if (baseType) {
                 entityCsn[key].includes = [];
@@ -326,7 +338,7 @@ function _generateEntityType(entityTypes, schemaData, mockServerUc) {
     });
 }
 
-function _parseEntityType(schemaDataList, mockServerUc) {
+function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc) {
     // collect entity types
     let entityTypes = [];
     let schemaData;
@@ -335,7 +347,7 @@ function _parseEntityType(schemaDataList, mockServerUc) {
         _generateEntityType(entityTypes, schemaData, mockServerUc);
     }
     // parse it
-    return _generateCSNForEntityType(entityTypes, mockServerUc);
+    return _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServerUc);
 }
 
 function _generateEnumType(schemaData) {
@@ -420,8 +432,30 @@ function _collectBounded(schemaDataList, flag) {
     }
 }
 
+function _getDatatype(datatype) {
+    let type = undefined;
+    if (datatype === undefined) {
+        type = "cds.LargeString"; //intentionally used LargeString
+    } else if (entitySetToEntityTypeMap.get(datatype) && 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]) {
+        //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)
+                type = datatype;
+        }
+    }
+
+    //will return undefined if type is not supported
+    return type;
+}
+
 function _parseBounded(csnDefs, flag) {
-    let boundedEdmxKind, boundedObj, boundedCsnKind, boundedEntityName, obj, paramType, paramName, paramObj, name, returnType;
+    let boundedEdmxKind, boundedObj, boundedCsnKind, boundedEntityName, obj, paramName, paramObj, name;
     if (flag == 0) {
         boundedEdmxKind = "Action";
         boundedCsnKind = "action";
@@ -446,6 +480,7 @@ function _parseBounded(csnDefs, flag) {
                         if (csnDefs[boundedEntityName].actions === undefined)
                             csnDefs[boundedEntityName].actions = {};
                         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) {
@@ -462,55 +497,56 @@ function _parseBounded(csnDefs, flag) {
                             for (let i = 1; i < obj[j].$Parameter.length; i++) {
                                 paramObj = obj[j].$Parameter[i];
                                 paramName = obj[j].$Parameter[i].$Name;
-                                // check if the parameter type is pre-defined, undefined or custom defined
+                                let paramType ={};
+                                _includeExternalNamespaceAnnotation(paramObj,paramType);
+                                //check if the parameter type is pre-defined, undefined or custom defined
                                 if (edmxncdsdatatype[paramObj.$Type])
                                     paramType = generatePropertyCsn(paramObj, false);
-                                else if (paramObj.$Type === undefined)
-                                    paramType = { "type": "cds.LargeString" }; // intentionally used LargeString
                                 else {
-                                    if (entitySetToEntityTypeMap.get(obj[j].$Parameter[i].$Type)) {
-                                        let type = namespace + "." + entitySetToEntityTypeMap.get(obj[j].$Parameter[i].$Type)[0];
-                                        paramType = { "type": type };
-                                    }
-                                    else {
-                                        paramType = { "type": obj[j].$Parameter[i].$Type };
-                                    }
+                                    let type = _getDatatype(paramObj.$Type);
+                                    if(type) paramType["type"] = type;
                                 }
-                                // check if parameter type is a collection
-                                if (paramObj.$Collection) {
-                                    csnDefs[boundedEntityName].actions[name].params[paramName] = {};
-                                    csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
-                                } else
-                                    csnDefs[boundedEntityName].actions[name].params[paramName] = paramType;
+                                if (paramType) {
+                                    // check if parameter type is a collection
+                                    if (paramObj.$Collection) {
+                                        csnDefs[boundedEntityName].actions[name].params[paramName] = {};
+                                        csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
+                                    } else
+                                        csnDefs[boundedEntityName].actions[name].params[paramName] = paramType;
+                                }
+                            }
+                                
                             }
                         }
+                        //if parameters has no entries
+                        if(csnDefs[boundedEntityName].actions[name].params && Object.keys(csnDefs[boundedEntityName].actions[name].params).length === 0)
+                        {
+                            delete csnDefs[boundedEntityName].actions[name].params;
+                        }
                         // add returns
                         if (obj[j].$ReturnType) {
-                            csnDefs[boundedEntityName].actions[name].returns = {};
+                            let returnType={};
                             // check if the return type is pre-defined, undefined or custom defined
                             if (edmxncdsdatatype[obj[j].$ReturnType.$Type])
                                 returnType = generatePropertyCsn(obj[j].$ReturnType, false);
-                            else if (obj[j].$ReturnType.$Type === undefined)
-                                returnType = { "type": "cds.LargeString" }; // intentionally used LargeString
                             else {
-                                if (entitySetToEntityTypeMap.get(obj[j].$ReturnType.$Type) && entitySetToEntityTypeMap.get(obj[j].$ReturnType.$Type)[0]) {
-                                    let type = namespace + "." + entitySetToEntityTypeMap.get(obj[j].$ReturnType.$Type)[0];
-                                    returnType = { "type": type };
-                                }
-                                else {
-                                    returnType = { "type": obj[j].$ReturnType.$Type };
-                                }
+                                let type = _getDatatype(obj[j].$ReturnType.$Type);
+                                _includeExternalNamespaceAnnotation(obj[j].$ReturnType,returnType);
+                                if(type) returnType["type"] = type ;
+                            }
+                            if (returnType) {
+                                csnDefs[boundedEntityName].actions[name].returns = {};
+                                // check if return type is a collection
+                                if (obj[j].$ReturnType.$Collection)
+                                    csnDefs[boundedEntityName].actions[name].returns.items = returnType;
+                                else
+                                    csnDefs[boundedEntityName].actions[name].returns = returnType;
                             }
-                            // check if return type is a collection
-                            if (obj[j].$ReturnType.$Collection)
-                                csnDefs[boundedEntityName].actions[name].returns.items = returnType;
-                            else
-                                csnDefs[boundedEntityName].actions[name].returns = returnType;
                         }
                     }
                 }
             }
-        });
+        );
     }
 }
 
@@ -556,13 +592,15 @@ 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]) {
+                if (!cTypes[element][property].$Type || edmxncdsdatatype[cTypes[element][property].$Type] ) {
                     propertyType = cTypes[element][property];
                     complexCsn[element].elements[property] = generatePropertyCsn(propertyType, false);
                 }
             } else if (complexTypes[cTypes[element][property].$Type]) {
                 propertyType = cTypes[element][property];
                 complexCsn[element].elements[property] = _generateComplexTypePropertyCsn(propertyType);
+            } else if(property.startsWith("@")){
+                complexCsn[element][property] = cTypes[element][property];
             }
         });
     });
@@ -599,64 +637,67 @@ function _parseUnbounded(schemaData, flag) {
     if (Object.keys(unbounded).length > 0) {
         Object.keys(unbounded).forEach(ub => {
             let obj = {};
-            let objType = {}, objData = {}, temp;
-            if (importToMap && importToMap.get(ub)) {
-                temp = importToMap.get(ub)[0];
+            let objType = {}, objData = {}, temp = {};
+            if (importToMap && importToMap.get(ub)) { 
+                temp = ub.split(".").pop();
                 objType = namespace + "." + temp;
                 objData = schemaData[0][temp][0];
                 obj[objType] = {};
                 obj[objType].kind = unboundedCsnKind;
+                _includeExternalNamespaceAnnotation(objData,obj[objType]);
                 // add params
                 if (objData.$Parameter && objData.$Parameter.length > 0) {
                     obj[objType].params = {};
-                    let type;
+                    let type = {};   
                     for (let i = 0; i < objData.$Parameter.length; i++) {
-                        obj[objType].params[objData.$Parameter[i].$Name] = {};
+                        let typeProperties = {};
+                        _includeExternalNamespaceAnnotation(objData.$Parameter[i],typeProperties);
                         // check if the parameter type is pre-defined, undefined or custom defined
                         if (edmxncdsdatatype[objData.$Parameter[i].$Type]) {
-                            type = (generatePropertyCsn(objData.$Parameter[i], false)).type;
-                        }
-                        else if (objData.$Parameter[i].$Type === undefined) {
-                            type = "cds.LargeString"; // intentionally used LargeString
+                            const parameterProperties = generatePropertyCsn(objData.$Parameter[i], false);
+                            ({type, ...typeProperties} = parameterProperties);
+                        } else {
+                            type = _getDatatype(objData.$Parameter[i].$Type);
                         }
-                        else {
-                            if (entitySetToEntityTypeMap.get(objData.$Parameter[i].$Type))
-                                type = namespace + "." + entitySetToEntityTypeMap.get(objData.$Parameter[i].$Type)[0];
+                        if (type) {
+
+                            // Adds type properties like scale, precision, etc if any
+                            const parameterObj = Object.keys(typeProperties).length > 0 ? { type, ...typeProperties } : { type };
+
+                            // check if parameter type is a collection
+                            if (objData.$Parameter[i].$Collection)
+                                obj[objType].params[objData.$Parameter[i].$Name].items = parameterObj;
                             else
-                                type = objData.$Parameter[i].$Type;
+                                obj[objType].params[objData.$Parameter[i].$Name] = parameterObj;
+
                         }
-                        // check if parameter type is a collection
-                        if (objData.$Parameter[i].$Collection)
-                            obj[objType].params[objData.$Parameter[i].$Name].items = { "type": type };
-                        else
-                            obj[objType].params[objData.$Parameter[i].$Name] = { "type": type };
                     }
                 }
+                //if parameters has no entries
+                if(obj[objType].params && Object.keys(obj[objType].params).length === 0)
+                {
+                    delete obj[objType].params;
+                }
                 // add returns
                 if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
-                    obj[objType].returns = {};
-                    let returnValue;
+                    let returnValue = {};
                     // check if the return type is pre-defined, undefined or custom defined
                     if (edmxncdsdatatype[objData.$ReturnType.$Type]) {
                         returnValue = generatePropertyCsn(objData.$ReturnType, false);
+                    } else {
+                        let type = _getDatatype(objData.$ReturnType.$Type);
+                        _includeExternalNamespaceAnnotation(objData.$ReturnType,returnValue);
+                        if(type) returnValue["type"] = type;
                     }
-                    else if (objData.$ReturnType.$Type === undefined) {
-                        returnValue = { "type": "cds.LargeString" }; // intentionally used LargeString
-                    }                         
-                    else {
-                        if (entitySetToEntityTypeMap.get(objData.$ReturnType.$Type) && entitySetToEntityTypeMap.get(objData.$ReturnType.$Type)[0]) {
-                            let type = namespace + "." + entitySetToEntityTypeMap.get(objData.$ReturnType.$Type)[0];
-                            returnValue = { "type": type };
-                        }
-                        else
-                            returnValue = { "type": objData.$ReturnType.$Type };
+                    if (returnValue) {
+                        obj[objType].returns = {};
+                        // check if return type is a collection
+                        if (objData.$ReturnType.$Collection) {
+                            obj[objType].returns.items = {};
+                            obj[objType].returns.items = returnValue;
+                        } else
+                            obj[objType].returns = returnValue;
                     }
-                    // check if return type is a collection
-                    if (objData.$ReturnType.$Collection) {
-                        obj[objType].returns.items = {};
-                        obj[objType].returns.items = returnValue;
-                    } else
-                        obj[objType].returns = returnValue;
                 }
             }
             unboundedObj = Object.assign(unboundedObj, obj);
@@ -665,8 +706,7 @@ function _parseUnbounded(schemaData, flag) {
     return unboundedObj;
 }
 
-function _generateCSN(edmxAsJson, mockServerUc) {
-    let schemaCounter = 0;
+function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
     let csn = {};
     let schemaData = [];
     unboundedActions = {};
@@ -677,6 +717,16 @@ function _generateCSN(edmxAsJson, mockServerUc) {
     csn.meta.creator = 'cds-dk ' + versionInfo;
     csn.$version = '2.0';
     csn.definitions = {};
+
+    Object.keys(edmxAsJson).forEach(data => {
+        if (ignoreObjects.indexOf(data) === -1 && edmxAsJson[data] instanceof Object) {
+            // replace the namespace alias value with original namespace value
+            if (edmxAsJson[data].$Alias)
+                edmxAsJson[data] = common.replaceAliasValue(JSON.stringify(edmxAsJson[data]), data, edmxAsJson[data].$Alias);
+            schemaData.push(edmxAsJson[data]);
+        }
+    });
+
     if (mockServerUc) {
         let entitySetData = edmxAsJson[namespace];
         let entityContainer;
@@ -702,19 +752,6 @@ function _generateCSN(edmxAsJson, mockServerUc) {
             }
         });
     }
-    Object.keys(edmxAsJson).forEach(data => {
-        if (ignoreObjects.indexOf(data) === -1 && edmxAsJson[data] instanceof Object) {
-            schemaData.push(edmxAsJson[data]);
-            schemaCounter += 1;
-        }
-    });
-
-    // Multiple schema found and currently we don't support
-    if (schemaCounter > 1) {
-        let errorMsg = messages().MULTIPLE_SCHEMA_FOUND;
-        errors.push(errorMsg);
-        // throw errorMsg;
-    }
 
     csn.definitions[namespace] = {};
     csn.definitions[namespace].kind = 'service';
@@ -733,7 +770,7 @@ function _generateCSN(edmxAsJson, mockServerUc) {
     csn.definitions = Object.assign(_parseUnbounded(schemaData, 0), csn.definitions);
     csn.definitions = Object.assign(_parseUnbounded(schemaData , 1), csn.definitions);
     // Step 4: get all entity type
-    csn.definitions = Object.assign(_parseEntityType(schemaData, mockServerUc), csn.definitions);
+    csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc), csn.definitions);
     // Step 5: get all bounded action & function
     _parseBounded(csn.definitions, 0);
     _parseBounded(csn.definitions, 1);
@@ -743,116 +780,125 @@ function _generateCSN(edmxAsJson, mockServerUc) {
     return JSON.stringify(csn, null, 4);
 }
 
-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, "&quot;").trim();
+}
+
+function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString){
+   if(path){
+        if(targetString === "@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"){
+            _generateLongDescription(annotation,path,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);  
+        }
+        if (cdsDefs[annotation[0]]) {
+            _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms , str);
+        }
+    } 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{
+        let path = annotation[0].split('(');
+        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);
+            }
+        } 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]]){
+                    _checkAnnotatationTerm(annotation,cdsDefs[path[0]]["params"][path1[1]],no_of_terms,str);
+                }
+            }    
+        }
+    }
 }
 
 function _generateDocumentation(schemaData, cdsDefs) {
     if (schemaData[0].$Annotations) {
         Object.entries(schemaData[0].$Annotations).map(annotation => {
-            let flag;
+            let no_of_terms;
             // eslint-disable-next-line no-prototype-builtins
             if (annotation[1].hasOwnProperty('@Core.Description')) {
-                flag = true;
-                if (annotation[0].indexOf('/') === -1) {
-                    if (annotation[0].endsWith(".EntityContainer")) {
-                        let path = annotation[0].split(".")[0];
-                        cdsDefs[path].doc = _removeCarriageReturn(annotation[1]["@Core.Description"]);
-                    }
-                    if (cdsDefs[annotation[0]]) {
-                        cdsDefs[annotation[0]].doc = _removeCarriageReturn(annotation[1]["@Core.Description"]);
-                    }
-                } else {
-                    let path = annotation[0].split('/');
-                    if (cdsDefs[path[0]]["elements"][path[1]]) {
-                        if (!cdsDefs[path[0]]["elements"][path[1]].doc) {
-                            cdsDefs[path[0]]["elements"][path[1]].doc = "";
-                        }
-                        cdsDefs[path[0]]["elements"][path[1]].doc += _removeCarriageReturn(annotation[1]["@Core.Description"]);
-                    }
-                }
+
+                no_of_terms = true;
+                _checkAnnotationTarget(annotation,cdsDefs,"@Core.Description",no_of_terms);
             }
             // eslint-disable-next-line no-prototype-builtins
             if (annotation[1].hasOwnProperty('@Core.LongDescription')) {
-                if (annotation[0].indexOf('/') === -1) {
-                    if (annotation[0].endsWith(".EntityContainer")) {
-                        let path = annotation[0].split(".")[0];
-                        if (flag === true) {
-                            cdsDefs[path].doc += "\n\n";
-                        } else {
-                            if (cdsDefs[path].doc){
-                                cdsDefs[path].doc += "";
-                            }
-                            else{
-                                cdsDefs[path].doc = "";
-                            }         
-                        }
-                        cdsDefs[path].doc += _removeCarriageReturn(annotation[1]["@Core.LongDescription"]);
-                    }
-                    if (cdsDefs[annotation[0]]) {
-                        if (flag === true) {
-                            cdsDefs[annotation[0]].doc += "\n\n";
-                        } else {
-                            if (cdsDefs[annotation[0]].doc){
-                                cdsDefs[annotation[0]].doc += "";
-                            }
-                            else{
-                                cdsDefs[annotation[0]].doc = "";
-                            }                            
-                        }
-                        cdsDefs[annotation[0]].doc += _removeCarriageReturn(annotation[1]["@Core.LongDescription"]);
-                    }
-                } else {
-                    let path = annotation[0].split('/');
-                    if (cdsDefs[path[0]]["elements"][path[1]]) {
-                        if (flag === true) {
-                            cdsDefs[path[0]]["elements"][path[1]].doc += "\n\n";
-                        } else {
-                            if (cdsDefs[path[0]]["elements"][path[1]].doc){
-                                cdsDefs[path[0]]["elements"][path[1]].doc += "";
-                            }  
-                            else{
-                                cdsDefs[path[0]]["elements"][path[1]].doc = "";
+                _checkAnnotationTarget(annotation,cdsDefs,"@Core.LongDescription",no_of_terms);
+
                             }
-                        }
-                        cdsDefs[path[0]]["elements"][path[1]].doc += _removeCarriageReturn(annotation[1]["@Core.LongDescription"]);
-                    }
-                }  
-            }
         });
     }
 }
 
-function _generateEDMX2JSON(edmx) {
-    return new Promise(function getJson(resolve, reject) {
-        try {
+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);
+    }
+}
+
+
+function _generateEDMX2JSON(edmx, name_space) { 
+    return new Promise(function getJson(resolve, reject) { 
+        try { 
             const inputBuffer = edmx;
             // create converter
-            const v4Conv = MetadataConverterFactory.createEdmxV40XmlToV40Json();
-            v4Conv.execute(inputBuffer, (error, json, missingReferencedDocuments) => {
+            const v4Conv = MetadataConverterFactory.createEdmxV40XmlToV40Json(name_space);
+            v4Conv.execute(inputBuffer, (error, json, missingReferencedDocuments) => { 
                 if (missingReferencedDocuments.length > 0) {
                     console.log(missingReferencedDocuments); // eslint-disable-line no-console
                 }
-
                 if (_validateJSON(json)) {
                     resolve(json);
                 }
             });
-        } catch (err) {
+        } catch (err) { 
             reject(err);
         }
     });
 }
 
-function getEdmxv4CSN(edmx, mockServerUc) {
+function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
     let csn;
     let edmjConverted;
+    let name_space = []
+    if(context.include_all_namespaces === true)
+    {
+        name_space.push(true);
+    }
+    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, mockServerUc);
+                    csn = _generateCSN(edmjConverted, ignorePersistenceSkip, mockServerUc);
                     if (csn) {
                         resolve(csn);
                     } else {
@@ -864,9 +910,9 @@ function getEdmxv4CSN(edmx, mockServerUc) {
             }
         });
     }
-    return _generateEDMX2JSON(edmx).then(function getCsn(edmj) {
+    return _generateEDMX2JSON(edmx,name_space).then(function getCsn(edmj) {
         // now parsing logic
-        return _generateCSN(edmj, mockServerUc);
+        return _generateCSN(edmj, ignorePersistenceSkip, mockServerUc);
     });
 }
 

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.19.0';
+const MAVEN_ARCHETYPE_VERSION = '1.20.0';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),

package/lib/init/index.js

@@ -14,6 +14,8 @@ module.exports = class CDSGenerator {
         this.fsUtil = fsUtil || new FsUtil();
         this.logger = logger || defaultLogger;
 
+        this.cwd = process.cwd();
+
         this.uiConfig = [
             {
                 title: `Project Name`,