@sap/cds-dk 4.6.2 → 4.7.2

package/lib/import/v2parser.js

@@ -22,6 +22,7 @@ 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 edmxncdsdatatype = {
 	"Edm.String": "cds.LargeString",
@@ -30,15 +31,14 @@ let edmxncdsdatatype = {
 	"Edm.Int32": "cds.Integer",
 	"Edm.Int64": "cds.Integer64",
 	"Edm.Decimal": "cds.DecimalFloat",
-	"Edm.DateTime": "cds.DateTime",
-	"Edm.DateTimeOffset": "cds.Timestamp",
+	"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",
-	"Edm.Single": "cds.DecimalFloat",
 	// Special handling of data types
 	"Edm.String_m": "cds.String", // Max length
 	"Edm.Decimal_p": "cds.Decimal", // Precision, scale
@@ -47,6 +47,11 @@ let edmxncdsdatatype = {
 	"Edm.Binary_m": "cds.Binary", // Max Length
 	"Edm.Byte_m": "cds.Integer", // Max Length
 	"Edm.Double_p": "cds.Double", // Precision, scale
+	// Special handling with annotations
+	"Edm.Single_a": "cds.Double",
+	"Edm.Stream_a" : "cds.LargeBinary",
+	"Edm.DateTimeOffset_a" : "cds.Timestamp", //precision > 0
+	"Edm.DateTime_a" : "cds.Timestamp" //precision > 0
 };
 
 function _initialize() {
@@ -420,8 +425,9 @@ function _getServiceEntityProperty(
 	} else if (precision && precision > 0) {
 		cdsDataType = edmxncdsdatatype[dataType + "_p"];
 		// Falling back to actual data type as precision has no meaning for 'Date' related data types
+		// Using _a data type if precision is there for 'Date' related data types
 		if (cdsDataType === undefined) {
-			cdsDataType = edmxncdsdatatype[dataType];
+			cdsDataType = edmxncdsdatatype[dataType + "_a"];
 			hasInvalidPrecision = true;
 		}
 	} else if (displayFormat && displayFormat === "Date") {
@@ -430,6 +436,10 @@ function _getServiceEntityProperty(
 		cdsDataType = edmxncdsdatatype[dataType];
 	}
 
+	//checks if it's an annotation case
+	if (!cdsDataType) {
+		cdsDataType = edmxncdsdatatype[dataType + "_a"];
+	}
 	// Lookup from complex type properties
 	if (!cdsDataType && allComplexTypes[dataType]) {
 		cdsDataType = dataType;
@@ -447,6 +457,18 @@ function _getServiceEntityProperty(
 		cdsDataType = dataType;
 	}
 
+	//if the cdsDataType is undefined/ not supported
+	if(cdsDataType === undefined)
+	{
+		let message = '"' + dataType + '" is not supported'; 
+		if(propertyName)
+			message += ' (in element:"' + propertyName + '")';
+		else
+			message += ' (in return type)'
+		console.log(warn(message));
+		return "";
+	}
+
 	if(propertyName)
 		propertyJson = '"' + propertyName + '": {\n';
 
@@ -458,6 +480,13 @@ function _getServiceEntityProperty(
 		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 (length && length > 0) {
 		propertyJson = propertyJson + ',\n"length":' + length;
 	} else if (precision && precision > 0 && hasInvalidPrecision === false) {
@@ -468,11 +497,19 @@ 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(isCollection === 1)
 	{
 		propertyJson = propertyJson + '\n}'
 	}
-	if(documentation != -1 && documentation != undefined){
+	if(documentation != -1 && documentation){
 		propertyJson = propertyJson + ',\n"doc":"' + documentation + '"';
 	}
 
@@ -503,12 +540,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 +
+				let complexProperty =
 					_getServiceEntityProperty(
 						complexTypeProperty.Name,
 						complexTypeProperty.Type,
@@ -521,7 +556,8 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 						-1,
 						complexTypePropertyNamespace
 					);
-				if (i !== complexType.length - 1) {
+				complexTypeCSN = complexTypeCSN + complexProperty;
+				if (i !== complexType.length - 1 && complexProperty != "") {
 					complexTypeCSN = complexTypeCSN + ",\n";
 				} else {
 					complexTypeCSN = complexTypeCSN + "\n";
@@ -551,6 +587,10 @@ function _getServiceComplexType(complexTypeKey, complexType) {
 					complexTypePropertyNamespace
 				);
 		}
+
+		if (complexTypeCSN && (complexTypeCSN.endsWith(",\n") || complexTypeCSN.endsWith(",\n\n"))) {
+			complexTypeCSN = complexTypeCSN.substring(0, complexTypeCSN.lastIndexOf(",\n")) + "\n";
+		}
 	}
 	complexTypeCSN = complexTypeCSN + "}\n";
 	if (allInheritedComplexTypes[complexTypeKey]) {
@@ -618,13 +658,15 @@ function _parseParameter(parameter)
 
 function  _parseParametersFunctionImport(parameters, isBounded) {
 	let csn = "";
+	let parameterCsn = "";
 	let i = isBounded===1 ? 1 : 0;
 	if(parameters.length)
 	{
 		for(i;i<parameters.length;i++)
 		{
-			csn = csn + _parseParameter(parameters[i]);
-			if(i!== parameters.length - 1) {
+			parameterCsn = _parseParameter(parameters[i]);
+			csn = csn + parameterCsn;
+			if(i!== parameters.length - 1 && parameterCsn != "") {
 				csn = csn + ",\n";
 			} else {
 				csn = csn + "\n";
@@ -634,6 +676,9 @@ function  _parseParametersFunctionImport(parameters, isBounded) {
 		csn = csn + _parseParameter(parameters);
 	}
 
+	if (csn && (csn.endsWith(",\n") || csn.endsWith(",\n\n"))) {
+		csn= csn.substring(0, csn.lastIndexOf(",\n")) + "\n";
+	}
 	return csn;
 }
 
@@ -654,27 +699,35 @@ function _getFunctionImport(functionImport,isBounded) {
 	{
 		if(isBounded === 0 || (isBounded === 1 && functionImport[3] instanceof Array ))
 		{
-			csn = csn + ", \n";
-			csn = csn + '"params": { \n';
-			csn = csn + _parseParametersFunctionImport(functionImport[3],isBounded);
-			csn = csn + '\n }';
+			let parametersCsn = _parseParametersFunctionImport(functionImport[3],isBounded);
+			if(parametersCsn != "")
+			{
+				csn = csn + ", \n";
+				csn = csn + '"params": { \n';
+				csn = csn + _parseParametersFunctionImport(functionImport[3],isBounded);
+				csn = csn + '\n }';
+			}
 		}
 	}
 	if(functionImport[2] !== -1)
 	{
-		csn = csn + ", \n";
-		csn = csn + '"returns": { \n';
 		let isCollection = -1;
 		if(functionImport[2].substring(0,10) === 'Collection')
 		{
 			functionImport[2] = functionImport[2].substring(11,functionImport[2].length-1);
 			isCollection = 1;
 		}
-		//return type
-		csn = csn + _getServiceEntityProperty(noValue,functionImport[2],noValue,noValue,noValue,noValue,noValue,noValue,isCollection);
-		csn = csn + '\n }';
+		let returnCsn = _getServiceEntityProperty(noValue,functionImport[2],noValue,noValue,noValue,noValue,noValue,noValue,isCollection);
+		if(returnCsn != "")
+		{
+			csn = csn + ", \n";
+			csn = csn + '"returns": { \n';
+			//return type
+			csn = csn + _getServiceEntityProperty(noValue,functionImport[2],noValue,noValue,noValue,noValue,noValue,noValue,isCollection);
+			csn = csn + '\n }';
+		}
 	}
-	if(functionImport[4] !== -1)
+	if(functionImport[4] !== -1 && functionImport[4])
 	{
 		csn = csn + ',\n "doc": "' + _replaceSpecialCharacters(functionImport[4]) + '"';
 	}
@@ -830,8 +883,7 @@ function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap) {
 	let i;
 	for (i = 0; i < entityKeysList.length; i++) {
 		propAttributes = entityPropertiesMap[entityKeysList[i]];
-		csnEntity =
-			csnEntity +
+		let keyCsn =
 			_getServiceEntityProperty(
 				entityKeysList[i],
 				propAttributes[0],
@@ -844,10 +896,14 @@ function _generateCSNEntityKeys(entityKeysList, entityPropertiesMap) {
 				-1,
 				propAttributes[6]
 			);
-		if (i !== entityKeysList.length - 1) {
+		csnEntity = csnEntity + keyCsn;
+		if (i !== entityKeysList.length - 1 && keyCsn != "") {
 			csnEntity = csnEntity + ",\n";
 		}
 	}
+	if (csnEntity && (csnEntity.endsWith(",\n") || csnEntity.endsWith(",\n\n"))) {
+		csnEntity= csnEntity.substring(0, csnEntity.lastIndexOf(",\n")) + "\n";
+	}
 	return csnEntity;
 }
 
@@ -869,8 +925,7 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
 		// Include Property which are not part of keys
 		if (entityKeysList.indexOf(property) === -1) {
 			propAttributes = entityPropertiesMap[property];
-			csnEntity =
-				csnEntity +
+			let propertyString =
 				_getServiceEntityProperty(
 					property,
 					propAttributes[0],
@@ -883,7 +938,8 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
 					-1,
 					propAttributes[6]
 				);
-			if (i !== entityProperties.length - 1) {
+			csnEntity = csnEntity + propertyString;
+			if (i !== entityProperties.length - 1 && propertyString != "") {
 				csnEntity = csnEntity + ",\n";
 			} else {
 				csnEntity = csnEntity + "\n";
@@ -891,7 +947,9 @@ function _generateCSNEntityProperties(entityKeysList, entityPropertiesMap) {
 		}
 	}
 	// Last property can be an key; eliminate additional delimiter.
-	if (csnEntity && csnEntity.endsWith(",\n")) {
+	// 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;
@@ -1179,12 +1237,11 @@ function _getServiceEntityNavigationProperty(navPropAttributes, mockServerUc) {
 	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`;
-	} else {
-		csn = csn + '"doc": "Please add  an ON condition", \n';
-	}
+	// annotation for on conditions
+	csn = csn + `"@cds.ambiguous": "missing on condition?",\n`;
+	// if documentation exists for navigation property
+	if (navPropDoc)
+		csn = csn + '"doc":' + ` "${navPropDoc}",\n`;
 	csn = csn + '"type": "cds.Association",\n';
 	csn = csn +
 		_getCSNAssociatedEntitySet(
@@ -1277,13 +1334,18 @@ function _constructServiceEntity(
 
 	// Key Entity attributes
 	csnKeys = _generateCSNEntityKeys(entityKeysList, entityPropertiesMap);
-	csnEntity = csnEntity + csnKeys;
 
 	// Non key Entity attributes
 	csnProperties = _generateCSNEntityProperties(
 		entityKeysList,
 		entityPropertiesMap
 	);
+	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
@@ -1400,6 +1462,7 @@ function _getEntitesWithNamesFromEntitySets(
 		: (name) => allEntities.indexOf(name) >= 0;
 
 	const getEntitySetNames = entityWithName => {
+		if (!entityWithName.name) return false;
 		for (let i = 0; i < entityWithName.name.length; i++) {
 			if (!isNameInEntitySet(entityWithName.name[i]))
 				return false;
@@ -1503,8 +1566,10 @@ function _generateEDMXJSON2CSN(
 		
 		let serviceDoc = jsonObj["edmx:Edmx"]["edmx:DataServices"]["Schema"].EntityContainer.Documentation;
 		// if documentation exists for service
-		if(serviceDoc)
-			def += ',\n' + `"doc": "${_parseDocumentationTag(serviceDoc)}"`;
+		if (serviceDoc) {
+			let doc = _parseDocumentationTag(serviceDoc);
+			if (doc) def += ',\n' + `"doc": "${doc}"`;
+		}
 		def += "}";
 		definitions.push(def);
 	}

package/lib/import/v4parser.js

@@ -24,6 +24,8 @@ 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 { warn } = require('@sap/cds/bin/utils/term');
+
 const MetadataConverterFactory = require('../import/utils/MetadataConverterFactory');
 const edmxncdsdatatype = {
     'Edm.String': 'cds.LargeString',
@@ -32,7 +34,7 @@ const edmxncdsdatatype = {
     'Edm.Int32': 'cds.Integer',
     'Edm.Int64': 'cds.Integer64',
     'Edm.Decimal': 'cds.DecimalFloat',
-    'Edm.DateTimeOffset': 'cds.Timestamp',
+    'Edm.DateTimeOffset': 'cds.DateTime',
     'Edm.TimeOfDay': 'cds.Time',
     'Edm.Date': 'cds.Date',
     'Edm.Binary': 'cds.LargeBinary',
@@ -40,16 +42,18 @@ const edmxncdsdatatype = {
     'Edm.Byte': 'cds.Integer',
     'Edm.SByte': 'cds.Integer',
     'Edm.Double': 'cds.Double',
-    'Edm.Single': 'cds.DecimalFloat',
     // Special handling of data types
     'Edm.String_m': 'cds.String', // Max length
     'Edm.Decimal_p': 'cds.Decimal', // Precision, scale
-    'Edm.DateTime_f': 'cds.Date', // sap:display-format="Date"
-    'Edm.DateTimeOffset_f': 'cds.Date', // sap:display-format="Date"
+    //'Edm.DateTime_f': 'cds.Date', // sap:display-format="Date"
+    //'Edm.DateTimeOffset_f': 'cds.Date', // sap:display-format="Date"
     'Edm.Binary_m': 'cds.Binary', // Max Length
     'Edm.Byte_m': 'cds.Integer', // Max Length
-    'Edm.Double_p': 'cds.Double' // Precision, scale
-
+    'Edm.Double_p': 'cds.Double', // Precision, scale
+    // Special handling with annotations
+	"Edm.Single_a": "cds.Double",
+	"Edm.Stream_a" : "cds.LargeBinary",
+	"Edm.DateTimeOffset_a" : "cds.Timestamp"
 };
 
 function _isJson(edmx) {
@@ -137,6 +141,15 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
             property.type = 'cds.String'; // if type is missing, then it is String type
         }
         property.length = propertyType.$MaxLength;
+    } else if(_isValidDataType(propertyType.$Type)) {
+        if(propertyType.$Precision && propertyType.$Precision > 0)
+        {
+            property.type = edmxncdsdatatype[propertyType.$Type + '_a'];
+            property["@odata.precision"] = propertyType.$Precision;
+        } else {
+            property.type = edmxncdsdatatype[propertyType.$Type];
+            property["@odata.precision"] = 0;
+        }
     } else if (propertyType.$Precision && !_isValidDataType(propertyType.$Type)) {
         property.type = edmxncdsdatatype[propertyType.$Type + '_p'];
         property.precision = propertyType.$Precision;
@@ -146,11 +159,19 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
         } else {
             property.scale = propertyType.$Scale;
         }
+    } else if (edmxncdsdatatype[propertyType.$Type + "_a"]) {
+        property.type = edmxncdsdatatype[propertyType.$Type + "_a"];
     } else if (propertyType.$Type) {
         property.type = edmxncdsdatatype[propertyType.$Type];
     } else{
         property.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
+
+    if(edmxncdsdatatype[propertyType.$Type + '_a'])
+    {
+        property["@odata.type"] = propertyType.$Type;
+    }
+
     return property;
 }
 
@@ -175,7 +196,8 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     let data;
     let ref;
     associationProperty.type = 'cds.Association';
-    associationProperty.doc = 'Please add an ON condition\n';
+    // annotation for ON condition
+    associationProperty["@cds.ambiguous"] = 'missing on condition?';
     // associationProperty.target = associationNode.$Type;
     if (mockServerUc && entitySetToEntityTypeMap && entitySetToEntityTypeMap.get(associationNode.$Type)) {
         if (entitySetToEntityTypeMap.get(associationNode.$Type).length > 1) {
@@ -267,7 +289,7 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
                             for (j = 0; j < curKey.length; j++) {
                                 keySet.push(curKey[j]);
                             }
-                        } else if (!element[key][property].$Type || edmxncdsdatatype[element[key][property].$Type]) {
+                        } else if (!element[key][property].$Type || edmxncdsdatatype[element[key][property].$Type] || edmxncdsdatatype[element[key][property].$Type + "_a"]) {
                             propertyType = element[key][property];
                             if (keySet.includes(property)) {
                                 entityCsn[key].elements[property] = generatePropertyCsn(propertyType, true);
@@ -291,6 +313,9 @@ function _generateCSNForEntityType(entityTypes, ignorePersistenceSkip, mockServe
                             // for TypeDefinitions
                             propertyType = element[key][property];
                             entityCsn[key].elements[property] = _generateTypeDefinitionPropertyCsn(propertyType);
+                        } else {
+                            let message = '"' + element[key][property].$Type + '" is not supported (in element:"' + property + '")'; 
+                            console.log(warn(message));
                         }
                     }
                 }
@@ -500,19 +525,22 @@ function _parseBounded(csnDefs, flag) {
                                 let paramType ={};
                                 _includeExternalNamespaceAnnotation(paramObj,paramType);
                                 //check if the parameter type is pre-defined, undefined or custom defined
-                                if (edmxncdsdatatype[paramObj.$Type])
+                                if (edmxncdsdatatype[paramObj.$Type] || edmxncdsdatatype[paramObj.$Type + "_a"])
                                     paramType = generatePropertyCsn(paramObj, false);
                                 else {
                                     let type = _getDatatype(paramObj.$Type);
                                     if(type) paramType["type"] = type;
                                 }
-                                if (paramType) {
+                                if (paramType.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;
+                                } else {
+                                    let message = '"' + paramObj.$Type + '" is not supported (in element:"' + name + '")'; 
+                                    console.log(warn(message));
                                 }
                             }
                                 
@@ -527,20 +555,23 @@ function _parseBounded(csnDefs, flag) {
                         if (obj[j].$ReturnType) {
                             let returnType={};
                             // check if the return type is pre-defined, undefined or custom defined
-                            if (edmxncdsdatatype[obj[j].$ReturnType.$Type])
+                            if (edmxncdsdatatype[obj[j].$ReturnType.$Type] || edmxncdsdatatype[obj[j].$ReturnType.$Type + "_a"])
                                 returnType = generatePropertyCsn(obj[j].$ReturnType, false);
                             else {
                                 let type = _getDatatype(obj[j].$ReturnType.$Type);
                                 _includeExternalNamespaceAnnotation(obj[j].$ReturnType,returnType);
                                 if(type) returnType["type"] = type ;
                             }
-                            if (returnType) {
+                            if (returnType.type) {
                                 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;
+                            } else {
+                                let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)'; 
+                                console.log(warn(message));
                             }
                         }
                     }
@@ -592,9 +623,12 @@ 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] || edmxncdsdatatype[cTypes[element][property].$Type + "_a"]) {
                     propertyType = cTypes[element][property];
                     complexCsn[element].elements[property] = generatePropertyCsn(propertyType, false);
+                } else {
+                    let message = '"' + cTypes[element][property].$Type + '" is not supported (in element:"' + property + '")'; 
+                    console.log(warn(message));
                 }
             } else if (complexTypes[cTypes[element][property].$Type]) {
                 propertyType = cTypes[element][property];
@@ -653,14 +687,13 @@ function _parseUnbounded(schemaData, flag) {
                         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]) {
+                        if (edmxncdsdatatype[objData.$Parameter[i].$Type] || edmxncdsdatatype[objData.$Parameter[i].$Type + "_a"]) {
                             const parameterProperties = generatePropertyCsn(objData.$Parameter[i], false);
                             ({type, ...typeProperties} = parameterProperties);
                         } else {
                             type = _getDatatype(objData.$Parameter[i].$Type);
                         }
                         if (type) {
-
                             // Adds type properties like scale, precision, etc if any
                             const parameterObj = Object.keys(typeProperties).length > 0 ? { type, ...typeProperties } : { type };
 
@@ -670,6 +703,9 @@ function _parseUnbounded(schemaData, flag) {
                             else
                                 obj[objType].params[objData.$Parameter[i].$Name] = parameterObj;
 
+                        } else {
+                            let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")'; 
+                            console.log(warn(message));
                         }
                     }
                 }
@@ -682,14 +718,14 @@ function _parseUnbounded(schemaData, flag) {
                 if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
                     let returnValue = {};
                     // check if the return type is pre-defined, undefined or custom defined
-                    if (edmxncdsdatatype[objData.$ReturnType.$Type]) {
+                    if (edmxncdsdatatype[objData.$ReturnType.$Type] || edmxncdsdatatype[objData.$ReturnType.$Type + "_a"]) {
                         returnValue = generatePropertyCsn(objData.$ReturnType, false);
                     } else {
                         let type = _getDatatype(objData.$ReturnType.$Type);
                         _includeExternalNamespaceAnnotation(objData.$ReturnType,returnValue);
                         if(type) returnValue["type"] = type;
                     }
-                    if (returnValue) {
+                    if (returnValue.type) {
                         obj[objType].returns = {};
                         // check if return type is a collection
                         if (objData.$ReturnType.$Collection) {
@@ -697,6 +733,9 @@ function _parseUnbounded(schemaData, flag) {
                             obj[objType].returns.items = returnValue;
                         } else
                             obj[objType].returns = returnValue;
+                    } else {
+                        let message = '"' + objData.$ReturnType.$Type + '" is not supported (in return type of' + temp + ')'; 
+                        console.log(warn(message));
                     }
                 }
             }
@@ -786,13 +825,13 @@ function _replaceSpecialCharacters(text) {
 
 function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString){
    if(path){
-        if(targetString === "@Core.Description"){
+        if(targetString === "@Core.Description" && annotation[1]["@Core.Description"]){
             if(path.doc === undefined)
                 path.doc = _replaceSpecialCharacters(annotation[1]["@Core.Description"]);
             else
                 path.doc += _replaceSpecialCharacters(annotation[1]["@Core.Description"]);
         }
-        else if(targetString === "@Core.LongDescription"){
+        else if(targetString === "@Core.LongDescription" && annotation[1]["@Core.LongDescription"]){
             _generateLongDescription(annotation,path,no_of_terms);
         }
     }
@@ -826,7 +865,7 @@ function _checkAnnotationTarget(annotation, cdsDefs , str, no_of_terms){
             _checkAnnotatationTerm(annotation,cdsDefs[path[0]],no_of_terms,str);   
             } else{
                 let path1 = path[1].split('/');
-                if(cdsDefs[path[0]]){
+                if(cdsDefs[path[0]] && cdsDefs[path[0]]["params"]){
                     _checkAnnotatationTerm(annotation,cdsDefs[path[0]]["params"][path1[1]],no_of_terms,str);
                 }
             }    

package/lib/index.js

@@ -1,5 +1,5 @@
 const cds = require ('@sap/cds')
-const get_compile = Reflect.getOwnPropertyDescriptor(cds,'compile').get
+const compile_desc = Reflect.getOwnPropertyDescriptor(cds,'compile')
 
 // extending cds to lazy-load additional submodules provided by cds-dk
 module.exports = Object.defineProperties (cds, {
@@ -9,10 +9,11 @@ module.exports = Object.defineProperties (cds, {
   compile: {enumerable:true, get:()=> {
     // lazy-extending cds.compile.to only when cds.compile getter is invoked
     // otherwise we might cause cds.env being invoked too early.
-    const compile = get_compile.call(cds)
-    Object.defineProperties (compile.to, {
-      openapi: {enumerable:true, get:()=> require('./compile/openapi')}
-    })
+    const compile = compile_desc.value || compile_desc.get.call(cds)
+    if (!Reflect.getOwnPropertyDescriptor(compile.to, 'openapi'))
+      Object.defineProperties (compile.to, {
+        openapi: {enumerable:true, get:()=> require('./compile/openapi')}
+      })
     return compile
   }},
 })

package/lib/init/constants.js

@@ -1,6 +1,6 @@
 const os = require('os');
 
-const MAVEN_ARCHETYPE_VERSION = '1.20.0';
+const MAVEN_ARCHETYPE_VERSION = '1.21.0';
 
 const constants = {
     IS_WIN: (os.platform() === 'win32'),
@@ -41,7 +41,7 @@ const constants = {
         MAVEN_ARCHETYPE_HELP: `https://cap.cloud.sap/docs/java/development/#the-maven-archetype`,
         MAVEN_INSTALL_HELP: `https://maven.apache.org/install.html`,
         PYTHON: 'https://www.python.org/downloads/',
-        PYTHON_PIP: 'https://packaging.python.org/guides/',
+        PYTHON_PIP: 'https://packaging.python.org/en/latest/guides/',
         VSCODE: 'https://code.visualstudio.com/',
         VSCODE_NBVIEWER: 'https://marketplace.visualstudio.com/items?itemName=ms-python.python',
         VSCODE_ESLINT: 'https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint'

package/lib/init/index.js

@@ -6,6 +6,7 @@ const term = require('../util/term');
 const Spinner = require('./util/spinner');
 
 const { OPTIONS_PRIORITY, COMMAND_ADD, COMMAND_INIT,
+    // eslint-disable-next-line no-unused-vars
     OPTION_HANA, OPTION_JAVA, OPTION_MTA, OPTION_MTX, OPTION_NODEJS,
     OPTION_PIPELINE, OPTION_SAMPLES, OPTION_CF_MANIFEST, PROJECT_FILES, REGEX_PROJECT_NAME } = require('./constants');