@sap/cds-dk 6.5.2 → 6.6.1

package/lib/import/odata/v4parser.js

@@ -12,7 +12,6 @@ const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ig
 const validEdmDatatypes = ["Edm.DateTimeOffset"];
 const { warn } = require("../../util/term");
 const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
-const cds = require('../../cds');
 
 const edmxncdsdatatype = {
     "Edm.String": "cds.LargeString",
@@ -43,6 +42,26 @@ const edmxncdsdatatype = {
     "Edm.DateTimeOffset_a": "cds.Timestamp",
 };
 
+const extendedPrimitiveTypes = [
+    "Edm.Duration",
+	"Edm.Geography",
+	"Edm.GeographyPoint",
+	"Edm.GeographyLineString",
+	"Edm.GeographyPolygon",
+	"Edm.GeographyMultiPoint",
+	"Edm.GeographyMultiLineString",
+	"Edm.GeographyMultiPolygon",
+	"Edm.GeographyCollection",
+	"Edm.Geometry",
+	"Edm.GeometryPoint",
+	"Edm.GeometryLineString",
+	"Edm.GeometryPolygon",
+	"Edm.GeometryMultiPoint",
+	"Edm.GeometryMultiLineString",
+	"Edm.GeometryMultiPolygon",
+	"Edm.GeometryCollection"
+];
+
 const known_vocabularies = {
     'Org.OData.Authorization.V1': 'Authorization',
     'Org.OData.Aggregation.V1': 'Aggregation',
@@ -122,7 +141,7 @@ function _hasEntityContainer(jsonObj, parserContext) {
             jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] instanceof Object
         ) {
             return true;
-        } 
+        }
     } catch (err) {
         throw new Error(messages.MISSING_ENTITY_CONTAINER);
     }
@@ -138,11 +157,11 @@ function _includeExternalNamespaceAnnotation(source, target) {
 
 function _addNotNull(property, isCollection) {
     if (isCollection) property.items["notNull"] = true;
-    else property["notNull"] = true; 
+    else property["notNull"] = true;
 }
 
 function _typeWithCollections(property, type, isCollection) {
-    if (isCollection === true) {
+    if (isCollection) {
         let typeKeys = Object.keys(type);
         for (let i = 0; i < typeKeys.length; i++) {
             if (typeKeys[i].startsWith("@")) {
@@ -164,13 +183,13 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
         // primary key cannot be of type Collection
         if (propertyType.$Collection)
             throw new Error(messages.COLLECTION_IN_KEY);
-        if (propertyType.$Nullable === true) {
+        if (propertyType.$Nullable) {
             console.log(warn("Expected key element to be not nullable"));
         }
         typeProperties["notNull"] = true;
     }
     else {
-        if ((propertyType.$Nullable !== true) && (propertyType.$Kind !== 'TypeDefinition')) {
+        if ((!propertyType.$Nullable) && (propertyType.$Kind !== 'TypeDefinition')) {
             typeProperties["notNull"] = true;
         }
     }
@@ -221,9 +240,13 @@ function generatePropertyCsn(propertyType, isPrimaryKey) {
             typeProperties["@odata.Type"] = propertyType.$Type;
         }
     }
-
     _typeWithCollections(property, typeProperties, propertyType.$Collection);
 
+    if (propertyType.$DefaultValue) {
+        if (propertyType.$Collection) console.log(warn("Type with Collection cannot have DefaultValue"));
+        _addDefaultValueObject(property, propertyType.$DefaultValue);
+    }
+
     return property;
 }
 
@@ -233,6 +256,10 @@ function _generateComplexTypePropertyCsn(propertyType) {
     _typeWithCollections(property, type, propertyType.$Collection);
     if (!propertyType.$Nullable) _addNotNull(property, propertyType.$Collection);
 
+    if (propertyType.$DefaultValue && !propertyType.$Collection) {
+        _addDefaultValueObject(property, propertyType.$DefaultValue);
+    }
+
     return property;
 }
 
@@ -243,6 +270,7 @@ function _generateTypeDefinitionPropertyCsn(propertyType) {
     _includeExternalNamespaceAnnotation(propertyType, property);
     _typeWithCollections(property, type, propertyType.$Collection);
     if (!propertyType.$Nullable) _addNotNull(property, propertyType.$Collection);
+    // Verify: Can DefaultValue be present here?
 
     return property;
 }
@@ -342,6 +370,10 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
     let j;
     let propertyType;
     let enumType = {};
+    const entityTypeNames = parserContext.entityTypes.map(elementObject => {
+        return Object.keys(elementObject)[0];
+    });
+
     parserContext.entityTypes.forEach(element => {
         let key = Object.keys(element)[0];
         let baseType = element[key].$BaseType;
@@ -364,13 +396,18 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
             // inheritance
             if (baseType) {
                 entityCsn[key].includes = [];
-                // if the baseType has a mapping to an entity set use that
-                if (parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(baseType)) {
+                if (entityTypeNames.includes(baseType)) {
+                    entityCsn[key].includes.push(baseType);
+                }
+                else if (parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(baseType)) {
                     baseType = _getBaseTypeEntityName(baseType, parserContext);
+                    entityCsn[key].includes.push(baseType);
+                } else {
+                    delete entityCsn[key].includes;
+                    throw new Error(messages.UNRESOLVED_TYPE + `'${baseType}' in element: '${element}'.`);
                 }
-                entityCsn[key].includes.push(baseType);
                 if (!parserContext.entityTypeOpenEntries.includes(baseType)) parserContext.entityTypeOpenEntries.push(baseType);
-            }
+            } 
             if ((isAbstract || isOpenType) && !parserContext.entityTypeOpenEntries.includes(key)) {
                 parserContext.entityTypeOpenEntries.push(key);
             }
@@ -412,8 +449,9 @@ function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserCo
                             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));
+                            // let message = '"' + element[key][property].$Type + '" is not supported (in element:"' + property + '")';
+                            // console.log(warn(message));
+                            throw new Error(messages.UNRESOLVED_TYPE + `'${element[key][property].$Type}' in element: '${property}'.`);
                         }
                     }
                 }
@@ -528,6 +566,7 @@ function _collectEnumType(schemaDataList, parserContext) {
 }
 
 function _generateCSNForEnumType(schemaData, parserContext) {
+    const nonMemberList = ["$Kind", "$Type", "$UnderlyingType", "$IsFlags"];
     let enumCsn = {};
     let eTypes;
     eTypes = _collectEnumType(schemaData, parserContext);
@@ -536,15 +575,19 @@ function _generateCSNForEnumType(schemaData, parserContext) {
         enumCsn[element].kind = 'type';
         enumCsn[element]['@cds.external'] = true;
         enumCsn[element].enum = {};
-        enumCsn[element].type = eTypes[element].$Type != null ? edmxncdsdatatype[eTypes[element].$Type] : 'cds.LargeString';
-        Object.keys(eTypes[element]).forEach(property => {
-            if (property != "$Kind" && property != "$Type") {
-                if (enumCsn[element].type == 'cds.LargeString') {
-                    enumCsn[element].enum[property] = cds.parse.expr(`'${(eTypes[element][property])}'`);
-                }
-                else {
-                    enumCsn[element].enum[property] = cds.parse.expr(`${(eTypes[element][property])}`);
-                }
+        /**
+         * If UnderlyingType not specified, default is Edm.Int32 --> cds.Integer
+         */
+        let underlyingType = eTypes[element].$UnderlyingType;
+        enumCsn[element].type = underlyingType ? edmxncdsdatatype[underlyingType] : 'cds.Integer';
+
+        if (!enumCsn[element].type || enumCsn[element].type !== "cds.Integer" ) {
+            throw new Error(messages.INVALID_ENUM_TYPE + `'${underlyingType}'`);
+        }
+        Object.keys(eTypes[element]).forEach(member => {
+            if (!nonMemberList.includes(member)) {
+                enumCsn[element].enum[member] = {};
+                enumCsn[element].enum[member].val = eTypes[element][member];
             }
         });
     });
@@ -718,72 +761,93 @@ function _parseBounded(csnDefs, flag, parserContext) {
                                         if (paramObj.$Collection && !paramType.items) {
                                             csnDefs[boundedEntityName].actions[name].params[paramName] = {};
                                             csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
-                                            if(paramObj.$Nullable != true){
+                                            if (!paramObj.$Nullable) {
                                                 csnDefs[boundedEntityName].actions[name].params[paramName].items["notNull"] = true;
                                             }
                                         } else {
                                             csnDefs[boundedEntityName].actions[name].params[paramName] = paramType;
                                             if (!paramType.items) {
-                                                if(paramObj.$Nullable != true){
+                                                if (!paramObj.$Nullable) {
                                                     csnDefs[boundedEntityName].actions[name].params[paramName].notNull = true;
                                                 }
                                             }
+                                        }
                                     }
+                                    else {
+                                        // let message = '"' + paramObj.$Type + '" is not supported (in element:"' + name + '")';
+                                        // console.log(warn(message));
+                                        throw new Error(messages.UNRESOLVED_TYPE + `'${paramObj.$Type}' in element: '${name}'.`);
+                                    }
+                                    if (csnDefs[boundedEntityName].actions[name].params[paramName])
+                                        Object.assign(csnDefs[boundedEntityName].actions[name].params[paramName], annotations);
                                 }
-                                else {
-                                    let message = '"' + paramObj.$Type + '" is not supported (in element:"' + name + '")';
-                                    console.log(warn(message));
-                                }
-                                if (csnDefs[boundedEntityName].actions[name].params[paramName])
-                                    Object.assign(csnDefs[boundedEntityName].actions[name].params[paramName], annotations);
                             }
                         }
-                    }
-                    // 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) {
-                        let returnType = {};
-                        let annotations = {};
-                        // check if the return type is pre-defined, undefined or custom defined
-                        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, parserContext);
-                            _includeExternalNamespaceAnnotation(obj[j].$ReturnType, annotations);
-                            if (type) returnType["type"] = type;
+                        // 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;
                         }
-                        if (Object.keys(returnType).length > 0) {
-                            if (returnType.type || returnType.items.type) {
-                                csnDefs[boundedEntityName].actions[name].returns = {};
-                                // check if return type is a collection
-                                if (obj[j].$ReturnType.$Collection && !returnType.items) {
-                                    csnDefs[boundedEntityName].actions[name].returns.items = returnType;
-                                    if(obj[j].$ReturnType.$Nullable != true){
-                                        csnDefs[boundedEntityName].actions[name].returns.items["notNull"] = true;
-                                    }
+                        // add returns
+                        if (obj[j].$ReturnType) {
+                            let returnType = {};
+                            let annotations = {};
+                            let hasCdsTypeMapping = false;
+                            // check if the return type is pre-defined, undefined or custom defined
+                            if (edmxncdsdatatype[obj[j].$ReturnType.$Type] || edmxncdsdatatype[obj[j].$ReturnType.$Type + "_a"] ||
+                                (!obj[j].$ReturnType.$Type && obj[j].$ReturnType.$MaxLength)
+                            )
+                                returnType = generatePropertyCsn(obj[j].$ReturnType, false);
+                            else {
+                                let type;
+                                if (extendedPrimitiveTypes.includes(obj[j].$ReturnType.$Type)) {
+                                    hasCdsTypeMapping = true;
                                 }
                                 else {
-                                    csnDefs[boundedEntityName].actions[name].returns = returnType;
-                                    if (!returnType.items) {
-                                        if(obj[j].$ReturnType.$Nullable != true){
-                                            csnDefs[boundedEntityName].actions[name].returns["notNull"] = true;
+                                    type = _getDatatype(obj[j].$ReturnType.$Type, parserContext);
+                                }
+                                _includeExternalNamespaceAnnotation(obj[j].$ReturnType, annotations);
+                                if (type) returnType["type"] = type;
+                                if (!type && !hasCdsTypeMapping) {
+                                    throw new Error(messages.UNRESOLVED_TYPE + `'${obj[j].$ReturnType.$Type}'`);
+                                }
+                            }
+                            if (Object.keys(returnType).length > 0) {
+                                if (returnType.type || returnType.items.type) {
+                                    csnDefs[boundedEntityName].actions[name].returns = {};
+                                    // check if return type is a collection
+                                    if (obj[j].$ReturnType.$Collection && !returnType.items) {
+                                        csnDefs[boundedEntityName].actions[name].returns.items = returnType;
+                                        if (!obj[j].$ReturnType.$Nullable) {
+                                            csnDefs[boundedEntityName].actions[name].returns.items["notNull"] = true;
+                                        }
+                                    }
+                                    else {
+                                        csnDefs[boundedEntityName].actions[name].returns = returnType;
+                                        if (!returnType.items) {
+                                            if (!obj[j].$ReturnType.$Nullable){
+                                                csnDefs[boundedEntityName].actions[name].returns["notNull"] = true;
+                                            }
                                         }
                                     }
                                 }
+                            } else {
+                                csnDefs[boundedEntityName].actions[name].returns = {};
+                                if (obj[j].$ReturnType.$Collection && !returnType.items) {
+                                    csnDefs[boundedEntityName].actions[name].returns = { "@odata.Type": obj[j].$ReturnType.$Type };
+                                    csnDefs[boundedEntityName].actions[name].returns.items = { "type": "cds.String" };
+                                }
+                                else
+                                    csnDefs[boundedEntityName].actions[name].returns = { "type": "cds.String", "@odata.Type": obj[j].$ReturnType.$Type };
                             }
+                            if (csnDefs[boundedEntityName].actions[name].returns)
+                                Object.assign(csnDefs[boundedEntityName].actions[name].returns, annotations);
                         } else {
-                            let message = '"' + obj[j].$ReturnType.$Type + '" is not supported (in return type)';
-                            console.log(warn(message));
+                            if (obj[j].$Kind === 'Function')
+                                throw new Error(messages.NO_RETURN_TYPE + `'${name}'.`);
                         }
-                        if (csnDefs[boundedEntityName].actions[name].returns)
-                            Object.assign(csnDefs[boundedEntityName].actions[name].returns, annotations)
                     }
                 }
             }
-        }
         });
     }
 }
@@ -829,13 +893,18 @@ function _generateCSNForComplexType(schemaData, parserContext) {
         isAbstract = cTypes[element].$Abstract;
         isOpenType = cTypes[element].$OpenType;
         if (baseType) {
-            complexCsn[element].includes = [];
-            complexCsn[element].includes.push(baseType);
-            if (!parserContext.complexTypeOpenEntries.includes(baseType)) parserContext.complexTypeOpenEntries.push(baseType);
+            if (parserContext.complexTypes[baseType]) {
+                complexCsn[element].includes = [];
+                complexCsn[element].includes.push(baseType);
+                if (!parserContext.complexTypeOpenEntries.includes(baseType)) parserContext.complexTypeOpenEntries.push(baseType);
+            }
+            else {
+                throw new Error(messages.UNRESOLVED_TYPE + `'${baseType}' in element: '${element}'.`);
+            }
         }
         if ((isAbstract || isOpenType) && !parserContext.complexTypeOpenEntries.includes(element)) {
             parserContext.complexTypeOpenEntries.push(element);
-        }        
+        }
         Object.keys(cTypes[element]).forEach(property => { // cTypes[element][property].$Type.startsWith('Edm.')
             if (cTypes[element][property] instanceof Object) {
                 if (!cTypes[element][property].$Type ||
@@ -854,8 +923,9 @@ function _generateCSNForComplexType(schemaData, parserContext) {
                     enumType = cTypes[element][property];
                     complexCsn[element].elements[property] = generatePropertyCsn(enumType, false);
                 } else {
-                    let message = '"' + cTypes[element][property].$Type + '" is not supported (in element:"' + property + '")';
-                    console.log(warn(message));
+                    // let message = '"' + cTypes[element][property].$Type + '" is not supported (in element:"' + property + '")';
+                    // console.log(warn(message));
+                    throw new Error(messages.UNRESOLVED_TYPE + `'${cTypes[element][property].$Type}' in element: '${property}'.`);
                 }
             } else if (property.startsWith("@")) {
                 complexCsn[element][property] = cTypes[element][property];
@@ -878,11 +948,16 @@ function _parseTypeDefinition(parserContext) {
         typeDef[element] = {};
         typeDef[element].kind = 'type';
         typeDef[element]['@cds.external'] = true;
-        if (!parserContext.typeDefinitions[element].$Type ||
-            edmxncdsdatatype[parserContext.typeDefinitions[element].$Type]
-        ) {
+
+        let underlyingType = parserContext.typeDefinitions[element].$UnderlyingType;
+        parserContext.typeDefinitions[element].$Type = underlyingType;
+
+        if (edmxncdsdatatype[underlyingType] ) {
             propertyType = parserContext.typeDefinitions[element];
             typeDef[element] = Object.assign(typeDef[element], generatePropertyCsn(propertyType, false));
+            if (typeDef[element].type === "cds.LargeString") typeDef[element].type = "cds.String";
+        } else {
+            throw new Error(messages.UNRESOLVED_TYPE + `'${underlyingType}'`);
         }
     });
     return typeDef;
@@ -933,21 +1008,22 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                                 if (objData.$Parameter[i].$Collection && !paramType.items) {
                                     obj[objType].params[objData.$Parameter[i].$Name] = {};
                                     obj[objType].params[objData.$Parameter[i].$Name].items = paramType;
-                                    if(objData.$Parameter[i].$Nullable != true){
+                                    if (!objData.$Parameter[i].$Nullable) {
                                         obj[objType].params[objData.$Parameter[i].$Name].items["notNull"] = true;
                                     }
                                 } else {
                                     obj[objType].params[objData.$Parameter[i].$Name] = paramType;
                                     if (!paramType.items) {
-                                        if(objData.$Parameter[i].$Nullable != true){
+                                        if (!objData.$Parameter[i].$Nullable) {
                                             obj[objType].params[objData.$Parameter[i].$Name]["notNull"] = true;
                                         }
                                     }
                                 }
                             }
                         } else {
-                            let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")';
-                            console.log(warn(message));
+                            // let message = '"' + objData.$Parameter[i].$Type + '" is not supported (in element:"' + temp + '")';
+                            // console.log(warn(message));
+                            throw new Error(messages.UNRESOLVED_TYPE + `'${objData.$Parameter[i].$Type}' in element: '${temp}'.`);
                         }
                         if (obj[objType].params[objData.$Parameter[i].$Name])
                             Object.assign(obj[objType].params[objData.$Parameter[i].$Name], annotations)
@@ -961,13 +1037,24 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                 if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
                     let returnValue = {};
                     let annotations = {};
+                    let hasCdsTypeMapping = false; 
                     // check if the return type is pre-defined, undefined or custom defined
-                    if (edmxncdsdatatype[objData.$ReturnType.$Type] || edmxncdsdatatype[objData.$ReturnType.$Type + "_a"]) {
+                    if (edmxncdsdatatype[objData.$ReturnType.$Type] || edmxncdsdatatype[objData.$ReturnType.$Type + "_a"] ||
+                        (!objData.$ReturnType.$Type && objData.$ReturnType.$MaxLength)
+                    ){
                         returnValue = generatePropertyCsn(objData.$ReturnType, false);
                     } else {
-                        let type = _getDatatype(objData.$ReturnType.$Type, parserContext);
+                        let type;
+                        if (extendedPrimitiveTypes.includes(objData.$ReturnType.$Type)) {
+                            hasCdsTypeMapping = true;
+                        } else {
+                            type = _getDatatype(objData.$ReturnType.$Type, parserContext);
+                        }
                         _includeExternalNamespaceAnnotation(objData.$ReturnType, annotations);
                         if (type) returnValue["type"] = type;
+                        if (!type && !hasCdsTypeMapping) {
+                            throw new Error(messages.UNRESOLVED_TYPE + `'${objData.$ReturnType.$Type}'`);
+                        }
                     }
                     if (Object.keys(returnValue).length > 0) {
                         if (returnValue.type || returnValue.items.type) {
@@ -976,25 +1063,34 @@ function _parseUnbounded(schemaData, flag, parserContext) {
                             if (objData.$ReturnType.$Collection && !returnValue.items) {
                                 obj[objType].returns.items = {};
                                 obj[objType].returns.items = returnValue;
-                                if(objData.$ReturnType.$Nullable != true){
+                                if (!objData.$ReturnType.$Nullable) {
                                     obj[objType].returns.items["notNull"] = true;
                                 }
                             } else {
                                 obj[objType].returns = returnValue;
                                 if (!returnValue.items) {
-                                    if(objData.$ReturnType.$Nullable != true){
-                                    obj[objType].returns["notNull"] = true;
-                                }
+                                    if (!objData.$ReturnType.$Nullable) {
+                                        obj[objType].returns["notNull"] = true;
+                                    }
                                 }
                             }
                         }
                     }
                     else {
-                        let message = '"' + objData.$ReturnType.$Type + '" is not supported (in return type of' + temp + ')';
-                        console.log(warn(message));
+                        obj[objType].returns = {};
+                        // check if return type is a collection
+                        if ((objData.$ReturnType.$Collection && !returnValue.items)) {
+                            obj[objType].returns = { "@odata.Type":objData.$ReturnType.$Type };
+                            obj[objType].returns.items = {};
+                            obj[objType].returns.items = { "type": "cds.String" };
+                        } else
+                            obj[objType].returns = { "type": "cds.String", "@odata.Type": objData.$ReturnType.$Type };
                     }
                     if (obj[objType].returns)
                         Object.assign(obj[objType].returns, annotations);
+                } else {
+                    if (objData.$Kind === 'Function')
+                        throw new Error(messages.NO_RETURN_TYPE + `'${ub}'.`);
                 }
             }
             unboundedObj = Object.assign(unboundedObj, obj);
@@ -1082,6 +1178,7 @@ function _replaceSpecialCharacters(text) {
 }
 
 function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString, vocab) {
+    let annoTerm = targetString.substring(targetString.indexOf('@') + 1).split('.')[0];
     if (path) {
         if (targetString === "@Core.Description" && annotation[1]["@Core.Description"]) {
             if (path.doc === undefined)
@@ -1095,9 +1192,20 @@ function _checkAnnotatationTerm(annotation, path, no_of_terms, targetString, voc
         else if (targetString === "@Core.OptionalParameter" && annotation[1]["@Core.OptionalParameter"]) {
             _captureOptionalParameter(annotation, path);
         }
-        else if (vocab) { 
-            if (vocab.includes(targetString.substring(targetString.indexOf('@') + 1, targetString.lastIndexOf('.')))) {
-                path[targetString] = annotation[1][targetString] === null ? true : annotation[1][targetString];
+        else if (vocab) {
+            if (vocab.includes(annoTerm)) {
+                if (annoTerm === "Capabilities") {
+                    path[targetString] = annotation[1][1];
+                }
+                else if (annotation[1][targetString]?.$Cast) {
+                    path[targetString] = Number(annotation[1][targetString].$Cast);
+                }
+                else if (annotation[1][targetString]?.$Path) {
+                    path[targetString] = { "=": annotation[1][targetString].$Path };
+                }
+                else {
+                    path[targetString] = annotation[1][targetString] === null ? true : annotation[1][targetString];
+                }
             }
         }
     }
@@ -1110,37 +1218,38 @@ function checkEntitySetMap(pathName, parserContext, index = 0) {
     return pathName;
 }
 
-function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, parserContext) {
+function _checkAnnotationTarget(annotation, csnDefs, str, no_of_terms, vocab, parserContext) {
     if ((annotation[0].indexOf('/') === -1 && annotation[0].indexOf('(') === -1) || annotation[0].includes("Container")) {
-        if (cdsDefs[annotation[0]]) {
+        if (csnDefs[annotation[0]]) {
             let path = annotation[0].split('/');
             let pathFromEntityTypeMap = parserContext.entitySetToEntityTypeMap.get(path[0]);
             if (pathFromEntityTypeMap != null) {
                 if (pathFromEntityTypeMap.length > 1) {
                     for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
                         let path1 = checkEntitySetMap(path[0], parserContext, index);
-                        _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+                        _checkAnnotatationTerm(annotation, csnDefs[path1], no_of_terms, str, vocab);
                     }
                 } else {
-                    _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+                    _checkAnnotatationTerm(annotation, csnDefs[annotation[0]], no_of_terms, str, vocab);
                 }
             }
             else {
-                _checkAnnotatationTerm(annotation, cdsDefs[annotation[0]], no_of_terms, str, vocab);
+                _checkAnnotatationTerm(annotation, csnDefs[annotation[0]], no_of_terms, str, vocab);
             }
         }
+
         if (annotation[0].indexOf('/') > 0) {
             let path = annotation[0].split('/');
             let temp = parserContext.namespace + '.' + path[1];
             let path1 = checkEntitySetMap(temp, parserContext);
-            if (cdsDefs[path1]) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+            if (csnDefs[path1]) {
+                _checkAnnotatationTerm(annotation, csnDefs[path1], no_of_terms, str, vocab);
             }
         }
         else if (annotation[0].includes("Container")) {
             let path = annotation[0].substring(0, annotation[0].lastIndexOf('.'));
             let actualPath = checkEntitySetMap(path, parserContext);
-            _checkAnnotatationTerm(annotation, cdsDefs[actualPath], no_of_terms, str, vocab);
+            _checkAnnotatationTerm(annotation, csnDefs[actualPath], no_of_terms, str, vocab);
         }
         else if (annotation[0].indexOf('(') === -1 && (annotation[0].indexOf('/') === -1)) {
             let path = annotation[0].split('/');
@@ -1149,7 +1258,7 @@ function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, pa
                 if (pathFromEntityTypeMap.length > 1) {
                     for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
                         let path1 = checkEntitySetMap(path[0], parserContext, index);
-                        _checkAnnotatationTerm(annotation, cdsDefs[path1], no_of_terms, str, vocab);
+                        _checkAnnotatationTerm(annotation, csnDefs[path1], no_of_terms, str, vocab);
                     }
                 }
             }
@@ -1162,39 +1271,39 @@ function _checkAnnotationTarget(annotation, cdsDefs, str, no_of_terms, vocab, pa
             if (pathFromEntityTypeMap.length > 1) {
                 for (let index = 0; index < pathFromEntityTypeMap.length; index++) {
                     let path1 = checkEntitySetMap(path[0], parserContext, index);
-                    _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+                    _checkAnnotatationTerm(annotation, csnDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
                 }
             }
             else {
                 let path1 = checkEntitySetMap(path[0], parserContext);
-                if (cdsDefs[path1]) {
-                    _checkAnnotatationTerm(annotation, cdsDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+                if (csnDefs[path1]) {
+                    _checkAnnotatationTerm(annotation, csnDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
                 }
             }
         }
         else {
-            if (cdsDefs[path[0]]) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["elements"][path[1]], no_of_terms, str, vocab);
+            if (csnDefs[path[0]]) {
+                _checkAnnotatationTerm(annotation, csnDefs[path[0]]["elements"][path[1]], no_of_terms, str, vocab);
             }
         }
     }
     else {
         let path = annotation[0].split('(');
         let actualPath = checkEntitySetMap(path[0], parserContext);
-        if (cdsDefs[actualPath] === undefined) {
+        if (csnDefs[actualPath] === 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, vocab);
+            if (csnDefs[path1[0]]) {
+                _checkAnnotatationTerm(annotation, csnDefs[path1[0]]["actions"][path2[1]], no_of_terms, str, vocab);
             }
         } else {
             if (path[1].indexOf('/') === -1) {
-                _checkAnnotatationTerm(annotation, cdsDefs[path[0]], no_of_terms, str, vocab);
+                _checkAnnotatationTerm(annotation, csnDefs[path[0]], no_of_terms, str, vocab);
             } else {
                 let path1 = path[1].split('/');
-                if (cdsDefs[path[0]] && cdsDefs[path[0]]["params"]) {
-                    _checkAnnotatationTerm(annotation, cdsDefs[path[0]]["params"][path1[1]], no_of_terms, str, vocab);
+                if (csnDefs[path[0]] && csnDefs[path[0]]["params"]) {
+                    _checkAnnotatationTerm(annotation, csnDefs[path[0]]["params"][path1[1]], no_of_terms, str, vocab);
                 }
             }
         }
@@ -1213,7 +1322,7 @@ function _replaceSchemaDataAnnotation(vocabAlias, vocabNamespce, schemaDataAnnot
     return JSON.parse(schemaDataAnnotation);
 }
 
-function _generateDocumentation(edmxAsJson, schemaData, cdsDefs, parserContext) {
+function _generateDocumentation(edmxAsJson, schemaData, csnDefs, parserContext) {
     let vocabAlias = [];
     let vocab = [];
     let vocabNamespce = [];
@@ -1234,18 +1343,23 @@ function _generateDocumentation(edmxAsJson, schemaData, cdsDefs, parserContext)
         Object.entries(schemaData[0].$Annotations).map(annotation => {
             let no_of_terms;
             Object.entries(annotation[1]).forEach(anno => {
-                if (vocab.includes(anno[0].substring(anno[0].indexOf('@') + 1, anno[0].lastIndexOf('.')))) {
+                let annoTerm = anno[0].substring(anno[0].indexOf('@') + 1).split('.')[0];
+
+                if (vocab.includes(annoTerm) && annoTerm !== 'Capabilities') {
                     if (annotation[1].hasOwnProperty('@Core.Description')) {
                         no_of_terms = true;
                     }
                     if (annotation[1].hasOwnProperty('@Common.FieldControl') && controlFieldFlag === 0) {
-                        annotation[1]["@Common.FieldControl"] = { "#": annotation[1]["@Common.FieldControl"]}
+                        annotation[1]["@Common.FieldControl"] = { "#": annotation[1]["@Common.FieldControl"] };
                         controlFieldFlag = 1;
                     }
                     if (annotation[1].hasOwnProperty('@Common.IsUpperCase')) {
                         annotation[1]["@Common.IsUpperCase"] = true;
                     }
-                    _checkAnnotationTarget(annotation, cdsDefs, anno[0], no_of_terms, vocab, parserContext);
+                    _checkAnnotationTarget(annotation, csnDefs, anno[0], no_of_terms, vocab, parserContext);
+                }
+                if (vocab.includes(annoTerm) && annoTerm === 'Capabilities') {
+                    _parseCapabilitiesAnnotation(annotation[0], anno, csnDefs, vocab, parserContext);
                 }
             });
             controlFieldFlag = 0;
@@ -1253,6 +1367,72 @@ function _generateDocumentation(edmxAsJson, schemaData, cdsDefs, parserContext)
     }
 }
 
+function _flattenAnnotationObject(annotationPrefix, annotationObject) {
+    let flattenedResult = [];
+
+    Object.entries(annotationObject).forEach(annotation => {
+        let currentResult = [];
+        currentResult[0] = annotationPrefix + '.' + annotation[0];
+        currentResult[1] = annotation[1];
+        flattenedResult.push(currentResult);
+    });
+
+    return flattenedResult;
+}
+
+function _removeTypeInAnnotation(annotationObject) {
+    Object.keys(annotationObject).forEach(key => {
+        if (key === "$Type") delete annotationObject[key];
+        else if (annotationObject[key] instanceof Object) {
+            _removeTypeInAnnotation(annotationObject[key]);
+        }
+    });
+}
+
+function _parseCapabilitiesAnnotation(annotationTargetPath, currentAnnotation, csnDefs, vocab, parserContext) {
+    let annotationResult = [annotationTargetPath, ''], currentResult = [], targetString;
+
+    _removeTypeInAnnotation(currentAnnotation);
+
+    /**
+     * For entries like:
+     * <Annotation Term="Capabilities.FilterFunctions"> <Collection> <String>eq</String> <String>ne</String> </Collection> </Annotation>
+     * <Annotation Term="Capabilities.DeleteRestrictions.Deletable" Bool="true"/>
+     * 
+     * simply preserve the value as it is
+     */
+    if (currentAnnotation[1] instanceof Array || !(currentAnnotation[1] instanceof Object)) {
+        targetString = currentAnnotation[0];
+        currentResult = [targetString, currentAnnotation[1]];
+        annotationResult[1] = currentResult;
+        _checkAnnotationTarget(annotationResult, csnDefs, targetString, undefined, vocab, parserContext);
+    }
+    else {
+        Object.keys(currentAnnotation[1]).forEach(annoKey => {
+            let currentAnnoValue = currentAnnotation[1][annoKey];
+            // if the currentAnnoValue is an Object, we need to flatten it
+            if (currentAnnoValue instanceof Object && !(currentAnnoValue instanceof Array)) {
+                targetString = currentAnnotation[0] + '.' + annoKey;
+                let currentResultList = _flattenAnnotationObject(targetString, currentAnnoValue);
+
+                for (let idx = 0; idx < currentResultList.length; idx++) {
+                    targetString = currentResultList[idx][0];
+                    annotationResult[1] = currentResultList[idx];
+                    _checkAnnotationTarget(annotationResult, csnDefs, targetString, undefined, vocab, parserContext);    
+                }
+            } 
+            // if the currentAnnoValue is a list or direct value, we preserve as it is
+            else {
+                targetString = currentAnnotation[0] + '.' + annoKey;
+                currentResult[0] = targetString;
+                currentResult[1] = currentAnnoValue;
+                annotationResult[1] = currentResult;
+                _checkAnnotationTarget(annotationResult, csnDefs, targetString, undefined, vocab, parserContext);
+            }
+        });
+    }
+}
+
 function _generateLongDescription(annotation, path, no_of_terms) {
     if (path) {
         path.doc = no_of_terms ? (path.doc += "\n\n") : (path.doc ? (path.doc += "") : (path.doc = ""));