@sap/cds-dk 4.4.2 → 4.5.4

package/lib/import/v4parser.js

@@ -6,13 +6,21 @@
 'use strict';
 
 let messages = require("./message").getMessages();
+let common = require("./common");
 let versionInfo = require('../../package.json').version;
 let namespace;
 let complexTypes = {};
 let enumTypes = {};
+let typeDefinitions = {};
+let unboundedActions = {};
+let boundedActions = {};
+let unboundedFunctions = {};
+let boundedFunctions = {};
 let errors = [];
 let Multimap = require('../import/utils/MultiMap.js');
 let entitySetToEntityTypeMap = new Multimap();
+let actionImportToActionMap = new Multimap();
+let functionImportToFunctionMap = new Multimap();
 let validEdmDatatypes = ['Edm.DateTimeOffset'];
 let jsonEntityContainerName;
 const ignoreObjects = ['$Reference']; // add all the objects that needs to be ignored for parsing.
@@ -145,6 +153,12 @@ function _generateComplexTypePropertyCsn(propertyType) {
     return property;
 }
 
+function _generateTypeDefinitionPropertyCsn(propertyType) {
+    let property = {};
+    property.type = propertyType.$Type;
+    return property;
+}
+
 function _parseAssociationProperty(foreignReference, associationNode, mockServerUc) {
     let associationProperty = {};
     let foreignKeys;
@@ -154,6 +168,7 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     let data;
     let ref;
     associationProperty.type = 'cds.Association';
+    associationProperty.doc = 'Please add an ON condition\n';
     // associationProperty.target = associationNode.$Type;
     if (mockServerUc && entitySetToEntityTypeMap && entitySetToEntityTypeMap.get(associationNode.$Type)) {
         if (entitySetToEntityTypeMap.get(associationNode.$Type).length > 1) {
@@ -197,11 +212,16 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
                 associationProperty.on.push(' and ');
             }
         }
+    }
+	// Convert managed associations and compositions in unmanaged with empty key to avoid
+    // "generation" of keys, that do not exist in the external service.
+    if (common.checkForEmptyKeys(associationProperty, "V4")) {
+        associationProperty.keys = [];
     }
     return associationProperty;
 }
 
-function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServerUc) {
+function _generateCSNForEntityType(entityTypes, mockServerUc) {
     let entityCsn = {};
     let keySet;
     let curKey;
@@ -215,9 +235,6 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
         if (key) {
             entityCsn[key] = {};
             entityCsn[key].kind = 'entity';
-            if (!ignorePersistenceSkip) {
-                entityCsn[key]['@cds.persistence.skip'] = true;
-            }
             // inheritance
             if (baseType) {
                 entityCsn[key].includes = [];
@@ -258,6 +275,10 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
                         } else if (element[key][property].$Kind === 'NavigationProperty') {
                             entityCsn[key].elements[property] = _parseAssociationProperty(property,
                                 element[key][property], mockServerUc);
+                        } else if (typeDefinitions[element[key][property].$Type]){
+                            // for TypeDefinitions
+                            propertyType = element[key][property];
+                            entityCsn[key].elements[property] = _generateTypeDefinitionPropertyCsn(propertyType);
                         }
                     }
                 }
@@ -305,17 +326,16 @@ function _generateEntityType(entityTypes, schemaData, mockServerUc) {
     });
 }
 
-function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc) {
+function _parseEntityType(schemaDataList, mockServerUc) {
     // collect entity types
     let entityTypes = [];
     let schemaData;
-    let i = 0;
-    for (i = 0; i < schemaDataList.length; i++) {
+    for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
         _generateEntityType(entityTypes, schemaData, mockServerUc);
     }
     // parse it
-    return _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServerUc);
+    return _generateCSNForEntityType(entityTypes, mockServerUc);
 }
 
 function _generateEnumType(schemaData) {
@@ -333,16 +353,167 @@ function _generateEnumType(schemaData) {
 }
 
 function _collectEnumType(schemaDataList) {
-    // collect complex types
     let schemaData;
-    let i = 0;
-    for (i = 0; i < schemaDataList.length; i++) {
+    for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
         enumTypes = _generateEnumType(schemaData);
     }
     return enumTypes;
 }
 
+function _generateTypeDefinition(schemaData) {
+    let typeDefDict = {};
+    let temp;
+    Object.keys(schemaData).forEach(curTypeDef => {
+        if (schemaData[curTypeDef] instanceof Object) {
+            if (schemaData[curTypeDef].$Kind && schemaData[curTypeDef].$Kind === 'TypeDefinition') {
+                temp = namespace + '.' + curTypeDef;
+                typeDefDict[temp] = schemaData[curTypeDef];
+            }
+        }
+    });
+    return typeDefDict;
+}
+
+function _collectTypeDefinition(schemaDataList) {
+    let schemaData;
+    for (let i = 0; i < schemaDataList.length; i++) {
+        schemaData = schemaDataList[i];
+        typeDefinitions = _generateTypeDefinition(schemaData);
+    }
+}
+
+function _generateBounded(schemaData, flag) {
+    let bFunction = {};
+    let boundedFunction = [];
+    let temp;
+    let kindString;
+    if (flag == 1) {
+        kindString = 'Function'; 
+    }
+    else {
+        kindString = 'Action';
+    }
+    Object.keys(schemaData).forEach(curFunction => {
+        if (schemaData[curFunction] instanceof Array && schemaData[curFunction][0].$Kind === kindString && schemaData[curFunction][0].$IsBound === true) {
+            boundedFunction = [];
+            temp = namespace + '.' + curFunction;
+            for (let i = 0; i < schemaData[curFunction].length; i++) {
+                boundedFunction.push(schemaData[curFunction][i]);
+                bFunction[temp] = boundedFunction;
+            }
+        }
+    });
+    return bFunction;
+}
+
+function _collectBounded(schemaDataList, flag) {
+    let schemaData;
+    for (let i = 0; i < schemaDataList.length; i++) {
+        schemaData = schemaDataList[i];
+        if (flag == 0) {
+            boundedActions = _generateBounded(schemaData, 0);
+        }
+        else {
+            boundedFunctions = _generateBounded(schemaData, 1);
+        }    
+    }
+}
+
+function _parseBounded(csnDefs, flag) {
+    let boundedEdmxKind, boundedObj, boundedCsnKind, boundedEntityName, obj, paramType, paramName, paramObj, name, returnType;
+    if (flag == 0) {
+        boundedEdmxKind = "Action";
+        boundedCsnKind = "action";
+        boundedObj = boundedActions;
+    }
+    else {
+        boundedEdmxKind = "Function";
+        boundedCsnKind = "function";
+        boundedObj = boundedFunctions;
+    }
+    if (Object.keys(boundedObj).length > 0) {
+        Object.keys(boundedObj).forEach(b => {
+            for (let j = 0; j < boundedObj[b].length; j++) {
+                if (boundedObj[b][j].$Kind === boundedEdmxKind) {
+                    name = b.substring(b.lastIndexOf(".") + 1);
+                    obj = boundedObj[b];
+                    boundedEntityName = obj[j].$Parameter[0].$Type;
+                    if (csnDefs[boundedEntityName] === undefined) {
+                        boundedEntityName = namespace + "." + entitySetToEntityTypeMap.get(boundedEntityName)[0];
+                    }
+                    if (csnDefs[boundedEntityName]) {
+                        if (csnDefs[boundedEntityName].actions === undefined)
+                            csnDefs[boundedEntityName].actions = {};
+                        csnDefs[boundedEntityName].actions[name] = {};
+                        csnDefs[boundedEntityName].actions[name].kind = boundedCsnKind;
+                        // add params
+                        if (obj[j].$Parameter && obj[j].$Parameter.length >= 2) {
+                            /** 
+                             * 1. Considering length >= 2 because we need to consider from the 2nd
+                             *    parameter onwards. 1st parameter only tells which entity is this
+                             *    action/function bounded to and that parameter is no where used 
+                             *    to retrieve any data during service runtime. So skipping it and
+                             *    the details of 1st parameter will not be preserved in the csn.
+                             * 2. The 1st parameter will be reflected back as parameter name  "in" 
+                             *    during csn to edmx conversion by the compiler.
+                             * */
+                            csnDefs[boundedEntityName].actions[name].params = {};
+                            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
+                                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 };
+                                    }
+                                }
+                                // 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;
+                            }
+                        }
+                        // add returns
+                        if (obj[j].$ReturnType) {
+                            csnDefs[boundedEntityName].actions[name].returns = {};
+                            // 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 };
+                                }
+                            }
+                            // 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;
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+
 function _generateComplexType(schemaData) {
     let complexTypeDict = {};
     let temp;
@@ -360,8 +531,7 @@ function _generateComplexType(schemaData) {
 function _collectComplexType(schemaDataList) {
     // collect complex types
     let schemaData;
-    let i = 0;
-    for (i = 0; i < schemaDataList.length; i++) {
+    for (let i = 0; i < schemaDataList.length; i++) {
         schemaData = schemaDataList[i];
         complexTypes = _generateComplexType(schemaData);
     }
@@ -399,10 +569,116 @@ function _generateCSNForComplexType(schemaData) {
     return complexCsn;
 }
 
-function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
+function _parseTypeDefinition() {
+    let typeDef = {};
+    let propertyType;
+    Object.keys(typeDefinitions).forEach(element => {
+        typeDef[element] = {};
+        typeDef[element].kind = 'type';
+        if (!typeDefinitions[element].$Type || edmxncdsdatatype[typeDefinitions[element].$Type]) {
+            propertyType = typeDefinitions[element];
+            typeDef[element] = Object.assign(typeDef[element], generatePropertyCsn(propertyType, false));
+        }
+    });
+    return typeDef;
+}
+
+function _parseUnbounded(schemaData, flag) {
+    let unboundedObj = {}, unbounded, unboundedCsnKind;
+    let importToMap = new Multimap();
+    if (flag == 0) {
+        unbounded = unboundedActions;
+        importToMap = actionImportToActionMap;
+        unboundedCsnKind = "action";
+    }
+    else {
+        unbounded = unboundedFunctions;
+        importToMap = functionImportToFunctionMap;
+        unboundedCsnKind = "function";
+    }
+    if (Object.keys(unbounded).length > 0) {
+        Object.keys(unbounded).forEach(ub => {
+            let obj = {};
+            let objType = {}, objData = {}, temp;
+            if (importToMap && importToMap.get(ub)) {
+                temp = importToMap.get(ub)[0];
+                objType = namespace + "." + temp;
+                objData = schemaData[0][temp][0];
+                obj[objType] = {};
+                obj[objType].kind = unboundedCsnKind;
+                // add params
+                if (objData.$Parameter && objData.$Parameter.length > 0) {
+                    obj[objType].params = {};
+                    let type;
+                    let typeProperties = {};
+                    for (let i = 0; i < objData.$Parameter.length; i++) {
+                        obj[objType].params[objData.$Parameter[i].$Name] = {};
+                        // check if the parameter type is pre-defined, undefined or custom defined
+                        if (edmxncdsdatatype[objData.$Parameter[i].$Type]) {
+                            const parameterProperties = generatePropertyCsn(objData.$Parameter[i], false);
+                            ({type, ...typeProperties} = parameterProperties);
+                        }
+                        else if (objData.$Parameter[i].$Type === undefined) {
+                            type = "cds.LargeString"; // intentionally used LargeString
+                        }
+                        else {
+                            if (entitySetToEntityTypeMap.get(objData.$Parameter[i].$Type))
+                                type = namespace + "." + entitySetToEntityTypeMap.get(objData.$Parameter[i].$Type)[0];
+                            else
+                                type = objData.$Parameter[i].$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
+                            obj[objType].params[objData.$Parameter[i].$Name] = parameterObj;
+                    }
+                }
+                // add returns
+                if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
+                    obj[objType].returns = {};
+                    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 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 };
+                    }
+                    // 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);
+        });
+    }
+    return unboundedObj;
+}
+
+function _generateCSN(edmxAsJson, mockServerUc) {
     let schemaCounter = 0;
     let csn = {};
     let schemaData = [];
+    unboundedActions = {};
+    boundedActions = {};
+    unboundedFunctions = {};
+    boundedFunctions = {};
     csn.meta = {};
     csn.meta.creator = 'cds-dk ' + versionInfo;
     csn.$version = '2.0';
@@ -421,6 +697,14 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
             if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
                 entityContainer[data].$Type && entityContainer[data].$Collection) {
                 entitySetToEntityTypeMap.set(entityContainer[data].$Type, data);
+            } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
+                entityContainer[data].$Action) {
+                actionImportToActionMap.set(entityContainer[data].$Action, data);
+                unboundedActions[entityContainer[data].$Action] = entitySetData[data];
+            } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
+                entityContainer[data].$Function) {
+                functionImportToFunctionMap.set(entityContainer[data].$Function, data);
+                unboundedFunctions[entityContainer[data].$Function] = entitySetData[data];
             }
         });
     }
@@ -437,74 +721,113 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc) {
         errors.push(errorMsg);
         // throw errorMsg;
     }
-    // Step 1: get all complex types.
+
     csn.definitions[namespace] = {};
     csn.definitions[namespace].kind = 'service';
+    csn.definitions[namespace]['@cds.external'] = true;
+
     _collectEnumType(schemaData);
+    _collectTypeDefinition(schemaData);
+    _collectBounded(schemaData, 0);
+    _collectBounded(schemaData, 1);
+
+    // Step 1: get all complex types.
     csn.definitions = Object.assign(_generateCSNForComplexType(schemaData), csn.definitions);
-    // Step 2: Parsing entity type
-    csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc), csn.definitions);
-    _generateDocumentation(schemaData,csn.definitions);
+    // Step 2: get all type definition
+    csn.definitions = Object.assign(_parseTypeDefinition(), csn.definitions);
+    // Step 3: get all unbounded action & function
+    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);
+    // Step 5: get all bounded action & function
+    _parseBounded(csn.definitions, 0);
+    _parseBounded(csn.definitions, 1);
+    // Step 6: get all annotations
+    _generateDocumentation(schemaData, csn.definitions);
+
     return JSON.stringify(csn, null, 4);
 }
 
-function _generateDocumentation(schemaData,cdsDefs){
-    
-    Object.entries(schemaData[0].$Annotations).map(annotation => {
-        let flag;
-        // 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 = annotation[1]["@Core.Description"];
-                }
-                if(cdsDefs[annotation[0]]){
-                    cdsDefs[annotation[0]].doc = annotation[1]["@Core.Description"];
+function _removeCarriageReturn(text) {
+    return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').trim();
+}
+
+function _generateDocumentation(schemaData, cdsDefs) {
+    if (schemaData[0].$Annotations) {
+        Object.entries(schemaData[0].$Annotations).map(annotation => {
+            let flag;
+            // 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"]);
+                    }
                 }
-            }else{
-                let path = annotation[0].split('/');
-                if(cdsDefs[path[0]]["elements"][path[1]]){
-                    cdsDefs[path[0]]["elements"][path[1]].doc = annotation[1]["@Core.Description"];
-                }          
-            }}
-               // eslint-disable-next-line no-prototype-builtins
-            if (annotation[1].hasOwnProperty('@Core.LongDescription') ) {
-                if(annotation[0].indexOf('/') === -1){
-                    if(annotation[0].endsWith(".EntityContainer")){
+            }
+            // 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 ";
+                        if (flag === true) {
+                            cdsDefs[path].doc += "\n\n";
                         } else {
-                            cdsDefs[path].doc = "";
+                            if (cdsDefs[path].doc){
+                                cdsDefs[path].doc += "";
+                            }
+                            else{
+                                cdsDefs[path].doc = "";
+                            }         
                         }
-                        cdsDefs[path].doc += annotation[1]["@Core.LongDescription"];
+                        cdsDefs[path].doc += _removeCarriageReturn(annotation[1]["@Core.LongDescription"]);
                     }
-                    if(cdsDefs[annotation[0]]){
-                        if(flag === true){
-                            cdsDefs[annotation[0]].doc += "\n\n ";
+                    if (cdsDefs[annotation[0]]) {
+                        if (flag === true) {
+                            cdsDefs[annotation[0]].doc += "\n\n";
                         } else {
-                            cdsDefs[annotation[0]].doc = "";
+                            if (cdsDefs[annotation[0]].doc){
+                                cdsDefs[annotation[0]].doc += "";
+                            }
+                            else{
+                                cdsDefs[annotation[0]].doc = "";
+                            }                            
                         }
-                        cdsDefs[annotation[0]].doc += annotation[1]["Core.LongDescription"];
+                        cdsDefs[annotation[0]].doc += _removeCarriageReturn(annotation[1]["@Core.LongDescription"]);
                     }
-                }else{
+                } 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 ";
+                    if (cdsDefs[path[0]]["elements"][path[1]]) {
+                        if (flag === true) {
+                            cdsDefs[path[0]]["elements"][path[1]].doc += "\n\n";
                         } else {
-                            cdsDefs[path[0]]["elements"][path[1]].doc = "";
+                            if (cdsDefs[path[0]]["elements"][path[1]].doc){
+                                cdsDefs[path[0]]["elements"][path[1]].doc += "";
+                            }  
+                            else{
+                                cdsDefs[path[0]]["elements"][path[1]].doc = "";
+                            }
                         }
-                        cdsDefs[path[0]]["elements"][path[1]].doc += annotation[1]["Core.LongDescription"];
-                    }          
-         }}
-    })}
-    
-                    
-            
-                    
+                        cdsDefs[path[0]]["elements"][path[1]].doc += _removeCarriageReturn(annotation[1]["@Core.LongDescription"]);
+                    }
+                }  
+            }
+        });
+    }
+}
 
 function _generateEDMX2JSON(edmx) {
     return new Promise(function getJson(resolve, reject) {
@@ -513,13 +836,10 @@ function _generateEDMX2JSON(edmx) {
             // create converter
             const v4Conv = MetadataConverterFactory.createEdmxV40XmlToV40Json();
             v4Conv.execute(inputBuffer, (error, json, missingReferencedDocuments) => {
-                if (error) {
-                    throw error;
-                }
                 if (missingReferencedDocuments.length > 0) {
                     console.log(missingReferencedDocuments); // eslint-disable-line no-console
                 }
-    
+
                 if (_validateJSON(json)) {
                     resolve(json);
                 }
@@ -530,7 +850,7 @@ function _generateEDMX2JSON(edmx) {
     });
 }
 
-function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc) {
+function getEdmxv4CSN(edmx, mockServerUc) {
     let csn;
     let edmjConverted;
     if (_isJson(edmx)) {
@@ -538,7 +858,7 @@ function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc) {
             try {
                 edmjConverted = JSON.parse(edmx);
                 if (_validateJSON(edmjConverted)) {
-                    csn = _generateCSN(edmjConverted, ignorePersistenceSkip, mockServerUc);
+                    csn = _generateCSN(edmjConverted, mockServerUc);
                     if (csn) {
                         resolve(csn);
                     } else {
@@ -552,7 +872,7 @@ function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc) {
     }
     return _generateEDMX2JSON(edmx).then(function getCsn(edmj) {
         // now parsing logic
-        return _generateCSN(edmj, ignorePersistenceSkip, mockServerUc);
+        return _generateCSN(edmj, mockServerUc);
     });
 }
 

package/lib/init/constants.js

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