@sap/cds-dk 6.7.2 → 6.8.0

package/lib/import/odata/v4parser.js

@@ -9,58 +9,52 @@ let common = require("../common");
 let versionInfo = require("../../../package.json").version;
 let Multimap = require("./util/MultiMap");
 const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ignored for parsing.
-const validEdmDatatypes = ["Edm.DateTimeOffset"];
 const { warn } = require("../../util/term");
 const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
 
-const edmxncdsdatatype = {
-    "Edm.String": "cds.LargeString",
-    "Edm.Boolean": "cds.Boolean",
-    "Edm.Int16": "cds.Integer",
-    "Edm.Int32": "cds.Integer",
-    "Edm.Int64": "cds.Integer64",
-    "Edm.Decimal": "cds.Decimal",
-    "Edm.DateTimeOffset": "cds.DateTime",
-    "Edm.TimeOfDay": "cds.Time",
-    "Edm.Date": "cds.Date",
-    "Edm.Binary": "cds.LargeBinary",
-    "Edm.Guid": "cds.UUID",
-    "Edm.Double": "cds.Double",
-    // 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.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.Byte_a": "cds.Integer",
-    "Edm.SByte_a": "cds.Integer",
-    "Edm.Single_a": "cds.Double",
-    "Edm.Stream_a": "cds.LargeBinary",
-    "Edm.DateTimeOffset_a": "cds.Timestamp",
+const edmPrimitiveTypes = [
+    'Edm.Binary', 'Edm.Boolean', 'Edm.Byte', 'Edm.Date', 'Edm.DateTimeOffset',
+    'Edm.Decimal', 'Edm.Double', 'Edm.Duration', 'Edm.Guid', 'Edm.Int16', 'Edm.Int32',
+    'Edm.Int64', 'Edm.SByte', 'Edm.Single', 'Edm.Stream', 'Edm.String', 'Edm.TimeOfDay',
+    '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 edmToCdsTypeMapping = {
+    'Edm.Binary': 'cds.LargeBinary',
+    'Edm.Boolean': 'cds.Boolean',
+    'Edm.Date': 'cds.Date',
+    'Edm.Decimal': 'cds.Decimal',
+    'Edm.Double': 'cds.Double',
+    'Edm.Guid': 'cds.UUID',
+    'Edm.Int16': 'cds.Integer',
+    'Edm.Int32': 'cds.Integer',
+    'Edm.Int64': 'cds.Integer64',
+    'Edm.String': 'cds.LargeString',
+    'Edm.TimeOfDay': 'cds.Time',
 };
 
-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 edmToCdsTypeMappingWithMaxLength = {
+    'Edm.Binary': 'cds.Binary',
+    'Edm.Byte': 'cds.Binary', // couldn't find any example
+    'Edm.String': 'cds.String'
+};
+
+const edmToCdsTypeMappingWithPrecision = {
+    'Edm.Decimal': 'cds.Decimal'
+};
+
+const edmToCdsTypeSpecialHandling = {
+    'Edm.Byte': 'cds.Integer',
+    'Edm.DateTimeOffset': ['cds.DateTime', 'cds.Timestamp'],
+    'Edm.Double': 'cds.Double', // couldn't find an example
+    'Edm.SByte': 'cds.Integer',
+    'Edm.Single': 'cds.Double',
+    'Edm.Stream': 'cds.LargeBinary'
+};
 
 const known_vocabularies = {
     'Org.OData.Authorization.V1': 'Authorization',
@@ -69,15 +63,20 @@ const known_vocabularies = {
     'Org.OData.Capabilities.V1': 'Capabilities',
     'Org.OData.Validation.V1': 'Validation',
     'Org.OData.Measures.V1': 'Measures',
+    'Org.OData.JSON.V1': 'JSON',
     'Org.OData.Repeatability.V1': 'Repeatability',
 
     'com.sap.vocabularies.Analytics.v1': 'Analytics',
     'com.sap.vocabularies.CodeList.v1': 'CodeList',
     'com.sap.vocabularies.Common.v1': 'Common',
     'com.sap.vocabularies.Communication.v1': 'Communication',
+    'com.sap.vocabularies.DataIntegration.v1': 'DataIntegration',
     'com.sap.vocabularies.Graph.v1': 'Graph',
+    'com.sap.vocabularies.Hierarchy.v1': 'Hierarchy',
     'com.sap.vocabularies.HTML5.v1': 'HTML5',
     'com.sap.vocabularies.ODM.v1': 'ODM',
+    'com.sap.vocabularies.Offline.v1': 'Offline',
+    'com.sap.vocabularies.PDF.v1': 'PDF',
     'com.sap.vocabularies.PersonalData.v1': 'PersonalData',
     'com.sap.vocabularies.Session.v1': 'Session',
     'com.sap.vocabularies.UI.v1': 'UI',
@@ -85,20 +84,25 @@ const known_vocabularies = {
 
 function _initialize(parserContext) {
     parserContext.unboundedActions = {};
-    parserContext.boundedActions = {};
     parserContext.unboundedFunctions = {};
-    parserContext.boundedFunctions = {};
     parserContext.entityTypes = [];
     parserContext.entityTypeOpenEntries = [];
     parserContext.complexTypeOpenEntries = [];
-    parserContext.namespace = "";
-    parserContext.complexTypes = {};
-    parserContext.enumTypes = {};
-    parserContext.typeDefinitions = {};
-    parserContext.jsonEntityContainerName = "";
-    parserContext.entitySetToEntityTypeMap = new Multimap();
-    parserContext.actionImportToActionMap = new Multimap();
-    parserContext.functionImportToFunctionMap = new Multimap();
+    parserContext.complexTypes = [];
+    parserContext.enumTypes = [];
+    parserContext.typeDefinitions = [];
+    parserContext.entityContainerName = "";
+    parserContext.entityToEntitySetMap = new Multimap();
+    parserContext.entityToSingletonMap = new Multimap();
+    parserContext.actionToActionImportMap = new Multimap();
+    parserContext.functionToFunctionImportMap = new Multimap();
+    parserContext.primarySchema = "";
+    parserContext.schemaAliasToNamespace = {};
+    parserContext.schemaToSchemaDataIndex = {};
+    parserContext.vocabAliasToNamespace = {};
+    parserContext.entityToBoundedActions = {};
+    parserContext.entityToBoundedFunctions = {};
+    parserContext.entityContainerAnnotations = {};
 }
 
 function _isJson(edmx) {
@@ -112,15 +116,47 @@ function _isJson(edmx) {
     return isJson;
 }
 
-function _isValidDataType(propertyType) {
-    if (validEdmDatatypes.includes(propertyType)) {
-        return true;
+function _extractSchemaNameAndElementName(name) {
+    let lastIndex = name.lastIndexOf('.');
+    let schemaName = name.substring(0, lastIndex);
+    let elementName = name.substring(lastIndex + 1);
+    return [schemaName, elementName];
+}
+
+/**
+ * @param {String} fqName 
+ * @param {String} schemaName 
+ * @param {Object} parserContext
+ * @returns index of schemaName in the schemaDataList
+ */
+function _getIndexAndNamespaceOfSchema(fqName, schemaName, parserContext) {
+    let aliasNameMapping = parserContext.schemaAliasToNamespace;
+    let schemaIndexMap = parserContext.schemaToSchemaDataIndex;
+
+    // if prefix is schema `alias` value
+    if (Object.keys(aliasNameMapping).includes(schemaName)) {
+        schemaName = aliasNameMapping[schemaName];
+        return [schemaIndexMap[schemaName], schemaName];
+    }
+    // if the prefix is schema `namespace` value
+    else if (Object.keys(schemaIndexMap).includes(schemaName)) {
+        return [schemaIndexMap[schemaName], schemaName];
+    }
+    // the schema namespace is not resolvable, throw error
+    else {
+        throw new Error(messages.UNRESOLVED_SCHEMA_NAMESPACE + fqName );
     }
-    return false;
 }
 
-function _isValidJSON(jsonObj, parserContext) {
-    if (jsonObj.$Version && _hasEntityContainer(jsonObj, parserContext) && jsonObj[parserContext.namespace]) {
+function _resolveAliasedElementName(fqName, parserContext) {
+    let [schemaName, elementName] = _extractSchemaNameAndElementName(fqName);
+    [, schemaName] = _getIndexAndNamespaceOfSchema(fqName, schemaName, parserContext);
+
+    return schemaName + '.' + elementName;
+}
+
+function _isValidJSON(jsonObj, parserContext, context) {
+    if (jsonObj.$Version && _hasEntityContainer(jsonObj, parserContext, context) && jsonObj[parserContext.primarySchema]) {
         return true;
     }
     else {
@@ -128,17 +164,17 @@ function _isValidJSON(jsonObj, parserContext) {
     }
 }
 
-function _hasEntityContainer(jsonObj, parserContext) {
+function _hasEntityContainer(jsonObj, parserContext, context) {
     let jsonObjEntityContainer = jsonObj.$EntityContainer;
     try {
         if (jsonObjEntityContainer) {
             // scenario: Schema Namespace="A.B.C.D" & jsonObjEntityContainer is "A.B.C.D.EntityContainerName"
-            let lastIndex = jsonObjEntityContainer.lastIndexOf('.');
-            parserContext.namespace = jsonObjEntityContainer.substring(0, lastIndex);
-            parserContext.jsonEntityContainerName = jsonObjEntityContainer.substring(lastIndex + 1);
+            [parserContext.primarySchema, parserContext.entityContainerName] = _extractSchemaNameAndElementName(jsonObjEntityContainer);
+            // required for `--keep-namespace` scenario
+            context.schemaNamespace = parserContext.primarySchema;
         }
-        if (jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] &&
-            jsonObj[parserContext.namespace][parserContext.jsonEntityContainerName] instanceof Object
+        if (jsonObj[parserContext.primarySchema][parserContext.entityContainerName] &&
+            jsonObj[parserContext.primarySchema][parserContext.entityContainerName] instanceof Object
         ) {
             return true;
         }
@@ -147,164 +183,461 @@ function _hasEntityContainer(jsonObj, parserContext) {
     }
 }
 
-function _includeExternalNamespaceAnnotation(source, target) {
-    Object.entries(source).forEach(element => {
-        if (element[0].startsWith('@')) {
-            target[element[0]] = element[1];
+function _updateElementObjectForCollection(dataTypeObj, isPrimaryKey, propertyDataType) {
+    if (isPrimaryKey) {
+        throw new Error(messages.COLLECTION_IN_KEY);
+    }
+    if (propertyDataType === 'Edm.Stream') {
+        throw new Error(messages.STREAM_NO_COLLECTION);
+    }
+
+    dataTypeObj.items = {};
+
+    Object.keys(dataTypeObj).forEach(objKey => {
+        if (!objKey.startsWith('@') && !(dataTypeObj[objKey] instanceof Object)) {
+            dataTypeObj.items[objKey] = dataTypeObj[objKey];
+            delete dataTypeObj[objKey];
         }
     });
 }
 
-function _addNotNull(property, isCollection) {
-    if (isCollection) property.items["notNull"] = true;
-    else property["notNull"] = true;
+function _updateElementObjectForDefaultValue(dataTypeObj, defaultvalue) {
+    // for collection, default value isin't expected
+    if (dataTypeObj.items === undefined) {
+        dataTypeObj.default = {};
+        dataTypeObj.default.val = (defaultvalue) ? defaultvalue : null;
+    }
+    else {
+        console.log(warn("Collection type cannot have a Default value."));
+    }
 }
 
-function _typeWithCollections(property, type, isCollection) {
-    if (isCollection) {
-        let typeKeys = Object.keys(type);
-        for (let i = 0; i < typeKeys.length; i++) {
-            if (typeKeys[i].startsWith("@")) {
-                property[typeKeys[i]] = type[typeKeys[i]];
-                delete type[typeKeys[i]];
-            }
-        }
-        property.items = type;
-    } else {
-        Object.assign(property, type);
+function _updateDataTypeObjectForMaxLength(dataTypeObj, propertyDataType, maxLength) {
+    const mappedValue = edmToCdsTypeMappingWithMaxLength[propertyDataType]; 
+
+    if (mappedValue) {
+        dataTypeObj.type = mappedValue
+        dataTypeObj.length = maxLength;
+    }
+    if (propertyDataType === 'Edm.Binary' && maxLength >= 5000) {
+        console.log(warn("MaxLength for type Edm.Binary should not exceed 5000"));
     }
 }
 
-function generatePropertyCsn(propertyType, isPrimaryKey) {
-    let property = {};
-    let typeProperties = {};
-    if (isPrimaryKey) {
-        property.key = true;
-        // primary key cannot be of type Collection
-        if (propertyType.$Collection)
-            throw new Error(messages.COLLECTION_IN_KEY);
-        if (propertyType.$Nullable) {
-            console.log(warn("Expected key element to be not nullable"));
+function _updateDataTypeObjectForPrecision(dataTypeObj, propertyDataType, precision, scale) {
+    const mappedValue = edmToCdsTypeMappingWithPrecision[propertyDataType];
+
+    if (mappedValue) {
+        dataTypeObj.type = mappedValue;
+        if (Number(precision) > 0) {
+            dataTypeObj.precision = precision;
+        }
+        if (Number(scale) > 0 || scale === 'floating' || scale === 'variable') {
+            dataTypeObj.scale = scale;
         }
-        typeProperties["notNull"] = true;
     }
-    else {
-        if ((!propertyType.$Nullable) && (propertyType.$Kind !== 'TypeDefinition')) {
-            typeProperties["notNull"] = true;
+}
+
+function _updateDataTypeObjectForSpecialHandling(dataTypeObj, propertyDataType, maxLength, precision) {
+    if (propertyDataType === 'Edm.Byte' && maxLength) {
+        return; // already taken care with direct mapping with maxlength so returning
+    }
+    else if (['Edm.DateTimeOffset', 'Edm.Double'].includes(propertyDataType)) {
+        if (propertyDataType === 'Edm.Double' && precision) {
+            dataTypeObj['@odata.Precision'] = precision;
+        }
+        if (propertyDataType === 'Edm.DateTimeOffset') {
+            dataTypeObj['@odata.Precision'] = precision;
+            dataTypeObj['@odata.Type'] = propertyDataType;
+            dataTypeObj.type = (precision) ?
+                edmToCdsTypeSpecialHandling[propertyDataType][1] :
+                edmToCdsTypeSpecialHandling[propertyDataType][0];
         }
+        return;
+    }
+    else if (propertyDataType === 'Edm.Stream') {
+        dataTypeObj['@Core.MediaType'] = 'application/octet-stream';
+    }
+
+    dataTypeObj['@odata.Type'] = propertyDataType;
+    dataTypeObj.type = edmToCdsTypeSpecialHandling[propertyDataType];
+}
+
+function _captureAnnotationInCSN(targetString, annotationObject, csnDefsTargetObject) {
+    /**
+     * For scenarios like:
+     * <Annotation Term="Core.Computed" />
+     * Here, 'annotationObject' would be null but in CSN we need to treat it as:
+     * @Core.Computed : true
+     */
+    if (annotationObject === null) {
+        annotationObject = true;
+    }
+    /**
+     * if anntationObject is empty list or empty object, we won't capture it.
+     * eg., <Annotation Term="Core.OptimisticConcurrency"> <Collection /> </Annotation>
+     * TODO: we might have to revisit it later for nested scenario.
+     */
+    if ((annotationObject instanceof Array && annotationObject.length === 0) ||
+        (annotationObject instanceof Object && Object.keys(annotationObject).length === 0)
+    ) {
+        return;
     }
-    _includeExternalNamespaceAnnotation(propertyType, property);
-    // conditions have to be made
-    if (propertyType.$MaxLength) {
-        if (propertyType.$Type) {
-            if (propertyType.$Type == "Edm.Binary" && propertyType.$MaxLength >= 5000) {
-                console.log(warn("MaxLength for type Edm.Binary should not exceed 5000"));
+    /**
+     * <Annotation Term="Common.Text" Path="name"/> --> annotationTermObject = { "=": annotationTermObject.$Path };
+     */
+    if (annotationObject.$Path) {
+        annotationObject = { "=": annotationObject.$Path };
+    }
+
+    csnDefsTargetObject[targetString] = annotationObject;
+}
+
+function _replaceSpecialCharacters(text) {
+    return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').replace(/"/g, "&quot;").trim();
+}
+
+function _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+    if (annotationTerm === "@Core.Description" || annotationTerm === "@Core.LongDescription") {
+        // we don't capture `null` value for doc
+        if (annotationTermObject === null)  return;
+        
+        annotationTermObject = _replaceSpecialCharacters(annotationTermObject);
+
+        if (csnDefsTargetObject.doc) {
+            if (annotationTerm === "@Core.Description") {
+                annotationTermObject = annotationTermObject + '\n\n' + csnDefsTargetObject.doc;
+            } else {
+                annotationTermObject = csnDefsTargetObject.doc + '\n\n' + annotationTermObject;
             }
-            typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_m'];
-        } else {
-            typeProperties.type = 'cds.String'; // if type is missing, then it is String type
         }
-        typeProperties.length = propertyType.$MaxLength;
-    } else if (_isValidDataType(propertyType.$Type)) {
-        if (propertyType.$Precision && propertyType.$Precision > 0) {
-            typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_a'];
-            typeProperties["@odata.Precision"] = propertyType.$Precision;
+        return _captureAnnotationInCSN('doc', annotationTermObject, csnDefsTargetObject);
+    }
+    /**
+     * <Annotation Term="Core.XYZ"/>
+     * For such scenario, mark the `anntationTermObject` as `true`
+     */
+    if (annotationTermObject === null) annotationTermObject = true;
+
+    if (annotationTerm === "@Core.OptionalParameter") {
+        _updateElementObjectForDefaultValue(csnDefsTargetObject, annotationTermObject.DefaultValue);
+    }
+    else {
+        _captureAnnotationInCSN(annotationTerm, annotationTermObject, csnDefsTargetObject);
+    }
+}
+
+function _flattenAnnotationObject(annotationPrefix, annotationObject) {
+    let flattenedResult = [];
+
+    Object.entries(annotationObject).forEach(annotation => {
+        let currentResult = [];
+        /**
+         * if annotation looks like:
+         * { "#" : <value> } or { "=" : <value> }
+         * don't flatten because it is for the `EnumMember` & `Path` use cases respectively
+         */
+        if (annotation[0] === '#' || annotation[0] === '=') {
+            currentResult[0] = annotationPrefix;
+            currentResult[1] = annotationObject;
         } else {
-            typeProperties.type = edmxncdsdatatype[propertyType.$Type];
-            // typeProperties["@odata.Precision"] = 0;
+            currentResult[0] = annotationPrefix + '.' + annotation[0];
+            currentResult[1] = annotation[1];
         }
-    } else if (propertyType.$Precision && !_isValidDataType(propertyType.$Type)) {
-        typeProperties.type = edmxncdsdatatype[propertyType.$Type + '_p'];
-        if (propertyType.$Scale && !(propertyType.$Scale == 'variable' || propertyType.$Scale == 'floating')) {
-            typeProperties.scale = propertyType.$Scale;
-            typeProperties.precision = propertyType.$Precision;
+        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]);
         }
-    } else if (edmxncdsdatatype[propertyType.$Type + "_a"]) {
-        typeProperties.type = edmxncdsdatatype[propertyType.$Type + "_a"];
-    } else if (propertyType.$Type) {
-        if (edmxncdsdatatype[propertyType.$Type]) {
-            typeProperties.type = edmxncdsdatatype[propertyType.$Type];
+    });
+}
+
+function _parseCapabilitiesTerm(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+    let targetString;
+    /**
+     * <Annotation Term="Capabilities.KeyAsSegmentSupported" />
+     * For such scenario, mark the `anntationTermObject` as `true`
+     */
+    if (annotationTermObject === null) annotationTermObject = true;
+
+    _removeTypeInAnnotation(annotationTermObject);
+    /**
+     * 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 (annotationTermObject instanceof Array || !(annotationTermObject instanceof Object)) {
+        _captureAnnotationInCSN(annotationTerm, annotationTermObject, csnDefsTargetObject);
+    }
+    else {
+        Object.keys(annotationTermObject).forEach(annoKey => {
+            let currentAnnoValue = annotationTermObject[annoKey];
+            // if the currentAnnoValue is an Object, we need to flatten it
+            if (currentAnnoValue instanceof Object && !(currentAnnoValue instanceof Array)) {
+                targetString = annotationTerm + '.' + annoKey;
+                let flattenedResultList = _flattenAnnotationObject(targetString, currentAnnoValue);
+
+                for (let idx = 0; idx < flattenedResultList.length; idx++) {
+                    _captureAnnotationInCSN(flattenedResultList[idx][0], flattenedResultList[idx][1], csnDefsTargetObject);
+                }
+            }
+            // if the currentAnnoValue is a list or direct value, we preserve as it is
+            else {
+                targetString = annotationTerm + '.' + annoKey;
+                _captureAnnotationInCSN(targetString, currentAnnoValue, csnDefsTargetObject);
+            }
+        });
+    }
+}
+
+function _parseValidationTerm(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+    const resolveCastFor = ["Minimum", "Maximum", "MaxItems"];
+    const term = annotationTerm.split('.')[1];
+
+    if (resolveCastFor.includes(term) && annotationTermObject.$Cast) {
+        annotationTermObject = Number(annotationTermObject.$Cast);
+    }
+
+    _captureAnnotationInCSN(annotationTerm, annotationTermObject, csnDefsTargetObject);
+}
+
+function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+    const term = annotationTerm.split('.');
+    const vocabAlias = term[0];
+
+    switch (vocabAlias) {
+        case "@Core":
+            _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObject);
+            break;
+        case "@Capabilities":
+            _parseCapabilitiesTerm(annotationTerm, annotationTermObject, csnDefsTargetObject);
+            break;
+        case "@Validation":
+            _parseValidationTerm(annotationTerm, annotationTermObject, csnDefsTargetObject);
+            break;
+        default:
+            _captureAnnotationInCSN(annotationTerm, annotationTermObject, csnDefsTargetObject);
+            break;
+    }
+}
+
+function _resolveAnotationTerm(schemaDataAnnotation, parserContext) {
+    // Case 1: We have the Namespace and Alias for the vocabulary
+    for (const [alias, namespace] of Object.entries(parserContext.vocabAliasToNamespace)) {
+        if (schemaDataAnnotation.includes(alias)) {
+            schemaDataAnnotation = schemaDataAnnotation.split(alias).join(known_vocabularies[namespace]);
         }
-        else {
-            typeProperties.type = propertyType.$Type;
+    }
+    /**
+     * Case 2: We only have the Namespace for the vocabulary
+     * Case 3: We don't have the edmx:Reference at all
+     */
+    for (const [vocabulary, alias] of Object.entries(known_vocabularies)) {
+        if (schemaDataAnnotation.includes(vocabulary)) {
+            schemaDataAnnotation = schemaDataAnnotation.split(vocabulary).join(alias);
         }
-    } else {
-        typeProperties.type = 'cds.LargeString'; // if type is missing, then it is String type
     }
 
-    if (edmxncdsdatatype[propertyType.$Type + '_a']) {
-        if (edmxncdsdatatype[propertyType.$Type + '_a'] === 'cds.LargeBinary') {
-            typeProperties["@Core.MediaType"] = 'application/octet-stream';
+    return JSON.parse(schemaDataAnnotation);
+}
+
+/**
+ * Capture all the annotation cases withtin an Element
+ * 
+ * UnKnown term: <Annotation Term="Org.OData.ASDF.V1.qwe"/>
+ * Known term: <Annotation Term="Org.OData.Measures.V1.Unit" String="Centimeters"/>
+ * 
+ * if "--include-namespaces *" then we also capture for ABS and QWE
+ * <TypeDefinition Name="TD_2" UnderlyingType="Edm.Int32" ABS:asdf="testing" QWE:qwe="testing"/>
+ */
+function _captureAnnotationWithinElement(sourceObject, targetObject, parserContext) {
+    let element;
+
+    Object.keys(sourceObject).forEach(key => {
+        if (key.startsWith('@')) {
+            element = _resolveAnotationTerm(JSON.stringify(key), parserContext);
+            _parseAnnotationTerms(element, sourceObject[key], targetObject);
         }
-        else {
-            typeProperties["@odata.Type"] = propertyType.$Type;
+    });
+}
+
+function _generatePrimitiveDataTypeCsn(propertyObject, isPrimaryKey, parserContext) {
+    const dataTypeObj = {};
+    const propertyDataType = propertyObject.$Type;
+    const maxLength = Number(propertyObject.$MaxLength);
+    const precision = Number(propertyObject.$Precision);
+    const scale = propertyObject.$Scale;
+    const underlyingType = propertyObject.$UnderlyingType;
+    const isCollection = propertyObject.$Collection;
+    const nullable = propertyObject.$Nullable;
+    const defaultvalue = propertyObject.$DefaultValue;
+
+    if (isPrimaryKey) {
+        dataTypeObj.key = true;
+        if (nullable) {
+            console.log(warn("Key element cannot be Nullable."));
         }
     }
-    _typeWithCollections(property, typeProperties, propertyType.$Collection);
+    _captureAnnotationWithinElement(propertyObject, dataTypeObj, parserContext);
 
-    if (propertyType.$DefaultValue) {
-        if (propertyType.$Collection) console.log(warn("Type with Collection cannot have DefaultValue"));
-        _addDefaultValueObject(property, propertyType.$DefaultValue);
+    dataTypeObj.type = edmToCdsTypeMapping[propertyDataType];
+
+    if (maxLength) {
+        _updateDataTypeObjectForMaxLength(dataTypeObj, propertyDataType, maxLength);
+    }
+    if (precision || scale) {
+        _updateDataTypeObjectForPrecision(dataTypeObj, propertyDataType, precision, scale);
+    }
+    if (edmToCdsTypeSpecialHandling[propertyDataType]) {
+        _updateDataTypeObjectForSpecialHandling(dataTypeObj, propertyDataType, maxLength, precision);
+    }
+    if (!edmToCdsTypeMapping[propertyDataType] && !edmToCdsTypeSpecialHandling[propertyDataType]) {
+        dataTypeObj['@odata.Type'] = propertyDataType;
+        dataTypeObj.type = 'cds.String';
+    }
+    /**
+     * When called from TypeDefinition or EnumType we,
+     * don't want to process Nullable, Collection, DefaultValue.
+     */
+    if (underlyingType) {
+        return dataTypeObj;
     }
 
-    return property;
-}
+    if (!nullable) {
+        dataTypeObj['notNull'] = true;
+    }
+    if (isCollection) {
+        _updateElementObjectForCollection(dataTypeObj, isPrimaryKey, propertyDataType);
+    }
+    if (defaultvalue) {
+        _updateElementObjectForDefaultValue(dataTypeObj, defaultvalue);
+    }
 
-function _generateComplexTypePropertyCsn(propertyType) {
-    let property = {};
-    let type = { type: propertyType.$Type }
-    _typeWithCollections(property, type, propertyType.$Collection);
-    if (!propertyType.$Nullable) _addNotNull(property, propertyType.$Collection);
+    return dataTypeObj;
+}
 
-    if (propertyType.$DefaultValue && !propertyType.$Collection) {
-        _addDefaultValueObject(property, propertyType.$DefaultValue);
+function _getEntityTypeMappedName(entityType, parserContext) {
+    const mappedResult = parserContext.entityToEntitySetMap.get(entityType);
+    // if one entity type has mapping to multiple entity sets, use the first entity set
+    if (mappedResult.length > 1) {
+        return parserContext.primarySchema + '.' + mappedResult[0];
+    }
+    else {
+        return parserContext.primarySchema + '.' + mappedResult;
     }
-
-    return property;
 }
 
-function _generateTypeDefinitionPropertyCsn(propertyType) {
-    let property = {};
-    let type = { type: propertyType.$Type };
+function _generateStructuredDataTypeCsn(dataType, propertyObject, isPrimaryKey, dataTypeKind, elementKind, mockServerUc, parserContext) {
+    const dataTypeObj = {};
+    const isCollection = propertyObject.$Collection;
+    const nullable = propertyObject.$Nullable;
+    const defaultvalue = propertyObject.$DefaultValue;
+    let propertyDataType = propertyObject.$Type;
+    // const underlyingType = propertyObject.$UnderlyingType; // might have to use later
+
+    /**
+     * for a typeDefintion to be a Primary key, it has to be
+     * based out of one of the entries in the edmPrimitiveTypes list
+     * We might have to decide if we want to throw an error if we get
+     * an entry not following this rule.
+     */
+    if (isPrimaryKey) {
+        dataTypeObj.key = true;
+        if (nullable) {
+            console.log(warn("Key element cannot be Nullable."));
+        }
+    }
+
+    // if dataTypeKind is EntityType, also check for mapped entity name
+    if (mockServerUc && dataTypeKind === 'EntityType') {
+        // propertyDataType is resolved fully qualified name
+        if (parserContext.entityToEntitySetMap?.get(propertyDataType)) {
+            propertyDataType = _getEntityTypeMappedName(propertyDataType, parserContext);
+        }
+        // dataType can be aliased name, so check that too.
+        else if (parserContext.entityToEntitySetMap?.get(dataType)) {
+            propertyDataType = _getEntityTypeMappedName(dataType, parserContext);
+        }
+    }
+    dataTypeObj.type = propertyDataType;
 
-    _includeExternalNamespaceAnnotation(propertyType, property);
-    _typeWithCollections(property, type, propertyType.$Collection);
-    if (!propertyType.$Nullable) _addNotNull(property, propertyType.$Collection);
-    // Verify: Can DefaultValue be present here?
+    if (!nullable) {
+        dataTypeObj['notNull'] = true;
+    }
+    if (isCollection) {
+        _updateElementObjectForCollection(dataTypeObj, isPrimaryKey, propertyDataType);
+    }
+    /**
+     * only Primitive type and EnumType can have DefaultValue facet as per documentation
+     * but compiler accepts it for TypeDefintion and ComplexType as well, 
+     * do we also need to handle it for TypeDefintion and ComplexType?
+     * 
+     * For parameters, default value is added via OptionalParamter Annotation
+     */
+    if (defaultvalue && dataTypeKind === 'EnumType' && elementKind === 'property') {
+        _updateElementObjectForDefaultValue(dataTypeObj, defaultvalue);
+    }
+    else {
+        // throw error, because only primitive or enumeration type can have DefaultValue.
+    }
+    _captureAnnotationWithinElement(propertyObject, dataTypeObj, parserContext);
 
-    return property;
+    return dataTypeObj;
 }
 
 function _parseAssociationProperty(foreignReference, associationNode, mockServerUc, parserContext) {
-    let associationProperty = {};
+    const associationProperty = {};
     let foreignKeys;
     // var foreignReference = associationNode.$Type;
     let refConstraint = associationNode.$ReferentialConstraint;
-    let i;
     let data;
     let ref;
+
     associationProperty.type = (associationNode.$OnDelete === 'Cascade') ? 'cds.Composition' : 'cds.Association';
     // annotation for ON condition
     associationProperty["@cds.ambiguous"] = 'missing on condition?';
     // associationProperty.target = associationNode.$Type;
 
-    //Code for NavigationProperty for notNull
-    /*if(associationProperty.$Nullable != true){
-        associationProperty["notNull"] = true;
-    }*/
-    if (mockServerUc && parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)) {
-        if (parserContext.entitySetToEntityTypeMap.get(associationNode.$Type).length > 1) {
-            for (let j = 0; j < parserContext.entitySetToEntityTypeMap.get(associationNode.$Type).length; j++) {
-                if (parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)[j] === foreignReference) {
-                    associationProperty.target = parserContext.namespace + '.' +
-                        parserContext.entitySetToEntityTypeMap.get(associationNode.$Type)[j];
+    // Code for NavigationProperty for notNull
+    // if (!associationProperty.$Nullable) {
+    //     associationProperty["notNull"] = true;
+    // }
+
+    let resolvedEntityName;
+    let entityTypeMapping = (
+        parserContext.entityToEntitySetMap?.get(associationNode.$Type) ||
+        parserContext.entityToSingletonMap?.get(associationNode.$Type)
+    );
+    // if entityTypeMapping is `undefined`, means the associationNode.$Type could be aliased
+    if (!entityTypeMapping) {
+        resolvedEntityName = _resolveAliasedElementName(associationNode.$Type, parserContext);
+        entityTypeMapping = (
+            parserContext.entityToEntitySetMap?.get(resolvedEntityName) ||
+            parserContext.entityToSingletonMap?.get(resolvedEntityName)
+        );
+    }
+
+    if (mockServerUc && entityTypeMapping) {
+        if (entityTypeMapping.length > 1) {
+            for (let j = 0; j < entityTypeMapping.length; j++) {
+                if (entityTypeMapping[j] === foreignReference) {
+                    associationProperty.target = parserContext.primarySchema + '.' + entityTypeMapping[j];
                 }
             }
         } else {
-            associationProperty.target = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(associationNode.$Type);
+            associationProperty.target = parserContext.primarySchema + '.' + entityTypeMapping;
         }
     } else {
-        associationProperty.target = associationNode.$Type;
+        associationProperty.target = resolvedEntityName;
     }
     // cardinality
     associationProperty.cardinality = {};
@@ -317,7 +650,8 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     if (refConstraint) {
         associationProperty.on = [];
         foreignKeys = Object.keys(refConstraint);
-        for (i = 0; i < foreignKeys.length; i++) {
+
+        for (let i = 0; i < foreignKeys.length; i++) {
             data = {};
             ref = [];
             ref.push(foreignReference);
@@ -340,18 +674,95 @@ function _parseAssociationProperty(foreignReference, associationNode, mockServer
     if (common.checkForEmptyKeys(associationProperty, "V4")) {
         associationProperty.keys = [];
     }
-    _includeExternalNamespaceAnnotation(associationNode, associationProperty);
+    _captureAnnotationWithinElement(associationNode, associationProperty, parserContext);
+
     return associationProperty;
 }
 
-function _getBaseTypeEntityName(baseType, parserContext) {
-    const mappedResult = parserContext.entitySetToEntityTypeMap.get(baseType);
-    // if one entity type has mapping to multiple entity sets, use the first entity set
-    if (mappedResult.length > 1) {
-        return parserContext.namespace + '.' + mappedResult[0];
-    } else {
-        return parserContext.namespace + '.' + mappedResult;
+function _checkIsStructureTypeAndReturnDataKind(dataType, contentObject, elementKind, parserContext) {
+    let fqName = dataType;
+    let [schemaName, elementName] = _extractSchemaNameAndElementName(dataType);
+
+    if (parserContext.schemaAliasToNamespace[schemaName]) {
+        fqName = parserContext.schemaAliasToNamespace[schemaName] + "." + elementName;
+        contentObject.$Type = fqName;
+    }
+    if (parserContext.complexTypes.includes(fqName)) {
+        return 'ComplexType';
+    }
+    else if (parserContext.typeDefinitions.includes(fqName)) {
+        return 'TypeDefinition';
     }
+    else if (parserContext.enumTypes.includes(fqName)) {
+        return 'EnumType';
+    }
+    else if (elementKind === 'property' && parserContext.entityTypes.includes(fqName)) {
+        throw new Error(messages.UNSUPPORTED_PROPERTY_TYPE + dataType);
+    }
+    else if (elementKind === 'parameter' && parserContext.entityTypes.includes(fqName)) {
+        return 'EntityType';
+    }
+    else {
+        throw new Error(messages.UNRESOLVED_TYPE + dataType);
+    }
+}
+
+/**
+ * @param {Object} csnObj
+ * @param {Object} elementObj
+ * @param {Object} parserContext
+ */
+function _parsePropertyContent(csnObj, elementObj, mockServerUc, parserContext) {
+    let contentObj = {};
+    const isPrimaryKey = true;
+    let dataType, isPrimitiveType, keySet = [];
+
+    Object.keys(elementObj).forEach(objKey => {
+        const contentKind = elementObj[objKey].$Kind;
+        contentObj = elementObj[objKey];
+
+        if ((objKey.indexOf('@') === -1) && (objKey.indexOf('.') === -1)) {
+            if (contentObj instanceof Object) {
+                if (contentObj.$Type) {
+                    dataType = contentObj.$Type;
+                    isPrimitiveType = dataType.startsWith('Edm') ? true : false;
+                }
+                if (objKey === '$Key') {
+                    keySet.push(...elementObj.$Key);
+                }
+                // primitive datatypes
+                else if (isPrimitiveType) {
+                    if (edmPrimitiveTypes.includes(dataType)) {
+                        csnObj.elements[objKey] = _generatePrimitiveDataTypeCsn(contentObj,
+                            (keySet.includes(objKey) ? isPrimaryKey : !isPrimaryKey),
+                            parserContext
+                        );
+                    } else {
+                        throw new Error(messages.INVALID_DATATYPE + `'${dataType}' in element: '${objKey}'`)
+                    }
+                }
+                // structured datatypes
+                else if (!isPrimitiveType && !(contentKind === 'NavigationProperty')) {
+                    const dataKind = _checkIsStructureTypeAndReturnDataKind(dataType, contentObj, 'property', parserContext);
+
+                    if (['EnumType', 'TypeDefinition'].includes(dataKind)) {
+                        csnObj.elements[objKey] = _generateStructuredDataTypeCsn(dataType, contentObj,
+                            (keySet.includes(dataType) ? isPrimaryKey : !isPrimaryKey),
+                            dataKind, 'property', mockServerUc, parserContext
+                        );
+                    }
+                    else {
+                        csnObj.elements[objKey] = _generateStructuredDataTypeCsn(dataType, contentObj,
+                            !isPrimaryKey, dataKind, 'property', mockServerUc, parserContext
+                        );
+                    }
+                }
+                else if (contentKind === 'NavigationProperty') {
+                    csnObj.elements[objKey] = _parseAssociationProperty(objKey, elementObj[objKey], mockServerUc, parserContext);
+                }
+            }
+        }
+    });
 }
 
 function _addBlobElement() {
@@ -363,1085 +774,813 @@ function _addBlobElement() {
     }
 }
 
-function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserContext) {
-    let entityCsn = {};
-    let keySet;
-    let curKey;
-    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;
-        let isAbstract = element[key].$Abstract;
-        let isOpenType = element[key].$OpenType;
-        if (key) {
-            entityCsn[key] = {};
-            entityCsn[key].kind = 'entity';
-            entityCsn[key]['@cds.external'] = true;
-            if (!ignorePersistenceSkip) {
-                entityCsn[key]['@cds.persistence.skip'] = true;
-            }
-            if (element[key].$Singleton) {
-                entityCsn[key]['@odata.singleton'] = true;
-            }
-            if (element[key].$SingletonNullable) {
-                entityCsn[key]['@odata.singleton.nullable'] = true;
-            }
-            _includeExternalNamespaceAnnotation(element[key], entityCsn[key]);
-            // inheritance
-            if (baseType) {
-                entityCsn[key].includes = [];
-                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}'.`);
+/**
+ * to handle the Abstract, Open & Base Type scenarios
+ * @param {String} fqName, element name
+ * @param {Object} csnObj,
+ * @param {Object} elementObj,
+ * @param {Object} parserContext
+ */
+function _captureOpenTypes(fqName, csnObj, elementObj, isEntity, mockServerUc, parserContext) {
+    let baseTypeName = elementObj.$BaseType;
+    let isAbstract = elementObj.$Abstract;
+    let isOpenType = elementObj.$OpenType;
+
+    if (baseTypeName) {
+        let resolvedBaseTypeName = _resolveAliasedElementName(baseTypeName, parserContext);
+
+        if (isEntity) {
+            if (parserContext.entityTypes.includes(resolvedBaseTypeName)) {
+                if (!parserContext.entityTypeOpenEntries.includes(resolvedBaseTypeName)) {
+                    parserContext.entityTypeOpenEntries.push(resolvedBaseTypeName);
                 }
-                if (!parserContext.entityTypeOpenEntries.includes(baseType)) parserContext.entityTypeOpenEntries.push(baseType);
-            } 
-            if ((isAbstract || isOpenType) && !parserContext.entityTypeOpenEntries.includes(key)) {
-                parserContext.entityTypeOpenEntries.push(key);
-            }
-            entityCsn[key].elements = {};
-            keySet = [];
-            Object.keys(element[key]).forEach(property => {
-                // Annotations names can have either @ or .; Don't add in generated CSN as property.
-                // CDS compiler will throw error when property name has special characters
-                if ((property.indexOf('@') == -1) && (property.indexOf('.') == -1)) {
-                    if (element[key][property] instanceof Object) {
-                        if (property === '$Key') {
-                            curKey = element[key].$Key;
-                            for (j = 0; j < curKey.length; j++) {
-                                keySet.push(curKey[j]);
-                            }
-                        } 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);
-                            } else {
-                                entityCsn[key].elements[property] = generatePropertyCsn(propertyType, false);
-                            }
-                        } else if (!element[key][property].$Type || parserContext.enumTypes[element[key][property].$Type]) {
-                            enumType = element[key][property];
-                            if (keySet.includes(property)) {
-                                entityCsn[key].elements[property] = generatePropertyCsn(enumType, true);
-                            } else {
-                                entityCsn[key].elements[property] = generatePropertyCsn(enumType, false);
-                            }
-                        } else if (parserContext.complexTypes[element[key][property].$Type]) {
-                            propertyType = element[key][property];
-                            entityCsn[key].elements[property] = _generateComplexTypePropertyCsn(propertyType);
-                        } else if (element[key][property].$Kind === 'NavigationProperty') {
-                            entityCsn[key].elements[property] = _parseAssociationProperty(property, element[key][property], mockServerUc, parserContext);
-                        } else if (parserContext.typeDefinitions[element[key][property].$Type]) {
-                            // 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));
-                            throw new Error(messages.UNRESOLVED_TYPE + `'${element[key][property].$Type}' in element: '${property}'.`);
+                if (mockServerUc) {
+                    let entityMapping = (
+                        parserContext.entityToEntitySetMap?.get(baseTypeName) ||
+                        parserContext.entityToSingletonMap?.get(baseTypeName)
+                    );
+                    if (entityMapping) {
+                        resolvedBaseTypeName = _getEntityTypeMappedName(baseTypeName, parserContext);
+                    }
+                    else {
+                        entityMapping = (
+                            parserContext.entityToEntitySetMap?.get(resolvedBaseTypeName) ||
+                            parserContext.entityToSingletonMap?.get(resolvedBaseTypeName)
+                        );
+                        if (entityMapping) {
+                            resolvedBaseTypeName = parserContext.primarySchema + '.' + entityMapping[0];
                         }
                     }
                 }
-            });
-            if (element[key].$HasStream) {
-                entityCsn[key].elements = { ...entityCsn[key].elements, ..._addBlobElement() }
+            } else {
+                throw new Error(messages.UNRESOLVED_TYPE + `'${baseTypeName}'`);
+            }
+        } else {
+            if (parserContext.complexTypes.includes(resolvedBaseTypeName) &&
+                !parserContext.complexTypeOpenEntries.includes(resolvedBaseTypeName)
+            ) {
+                parserContext.complexTypeOpenEntries.push(resolvedBaseTypeName);
+            }
+            else if (!parserContext.complexTypes.includes(resolvedBaseTypeName)) {
+                throw new Error(messages.UNRESOLVED_TYPE + `'${baseTypeName}'`);
             }
         }
-    });
+        csnObj.includes = [resolvedBaseTypeName];
+    }
+    if (isAbstract || isOpenType) {
+        if (isEntity && !parserContext.entityTypeOpenEntries.includes(fqName)) {
+            parserContext.entityTypeOpenEntries.push(fqName);
+        }
+        else if (!parserContext.complexTypeOpenEntries.includes(fqName)) {
+            parserContext.complexTypeOpenEntries.push(fqName);
+        }
+    }
+}
 
-    // add @open annotations
-    parserContext.entityTypeOpenEntries.forEach(key => {
-        if (entityCsn[key]) entityCsn[key]['@open'] = true;
-    });
+function _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, entityList, parserContext) {
+    const csnEntity = {};
+    let isEntity = true;
+    entityList.forEach(entityElement => {
+        let entityName = Object.keys(entityElement)[0];
 
-    return entityCsn;
-}
+        csnEntity[entityName] = {};
+        csnEntity[entityName].kind = 'entity';
+        csnEntity[entityName]['@cds.external'] = true;
 
-function _generateEntityType(schemaData, mockServerUc, parserContext) {
-    let entity = {};
-    let temp;
-    Object.keys(schemaData).forEach(entityType => {
-        entity = {};
-        if (schemaData[entityType] instanceof Object) {
-            if (schemaData[entityType].$Kind && schemaData[entityType].$Kind === 'EntityType') {
-                if (mockServerUc) {
-                    let entityTypeName = parserContext.namespace + '.' + entityType;
-                    if (parserContext.entitySetToEntityTypeMap && parserContext.entitySetToEntityTypeMap.get(entityTypeName)) {
-                        if (parserContext.entitySetToEntityTypeMap.get(entityTypeName).length > 1) {
-                            let entity1 = {};
-                            for (let i = 0; i < parserContext.entitySetToEntityTypeMap.get(entityTypeName).length; i++) {
-                                entity1 = {};
-                                let entityDetails = {};
-                                let temp1 = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(entityTypeName)[i];
-                                entity1[temp1] = Object.assign({}, schemaData[entityType]);
-                                entityDetails = schemaData[parserContext.jsonEntityContainerName][parserContext.entitySetToEntityTypeMap.get(entityTypeName)[i]];
-                                if (entityDetails.$Singleton)
-                                    entity1[temp1].$Singleton = entityDetails.$Singleton;
-                                if (entityDetails.$SingletonNullable)
-                                    entity1[temp1].$SingletonNullable = entityDetails.$SingletonNullable;
-                                parserContext.entityTypes.push(entity1);
-                            }
-                        } else {
-                            temp = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(entityTypeName);
-                            entity[temp] = schemaData[entityType];
-                            let entityDetails = schemaData[parserContext.jsonEntityContainerName][parserContext.entitySetToEntityTypeMap.get(entityTypeName)];
-                            if (entityDetails.$Singleton)
-                                entity[temp].$Singleton = entityDetails.$Singleton;
-                            if (entityDetails.$SingletonNullable)
-                                entity[temp].$SingletonNullable = entityDetails.$SingletonNullable;
-                            parserContext.entityTypes.push(entity);
-                        }
-                    } else {
-                        temp = parserContext.namespace + '.' + entityType;
-                        entity[temp] = schemaData[entityType];
-                        parserContext.entityTypes.push(entity);
-                    }
-                } else {
-                    temp = parserContext.namespace + '.' + entityType;
-                    entity[temp] = schemaData[entityType];
-                    parserContext.entityTypes.push(entity);
-                }
-            }
+        if (!ignorePersistenceSkip) {
+            csnEntity[entityName]['@cds.persistence.skip'] = true;
         }
-    });
-}
 
-function _parseEntityType(schemaDataList, ignorePersistenceSkip, mockServerUc, parserContext) {
-    // collect entity types
-    let schemaData;
-    for (let i = 0; i < schemaDataList.length; i++) {
-        schemaData = schemaDataList[i];
-        _generateEntityType(schemaData, mockServerUc, parserContext);
-    }
-    return _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, parserContext);
-}
+        _captureOpenTypes(entityName, csnEntity[entityName], entityElement[entityName], isEntity, mockServerUc, parserContext);
+        _captureAnnotationWithinElement(entityElement[entityName], csnEntity[entityName], parserContext);
+
+        csnEntity[entityName].elements = {};
+
+        _parsePropertyContent(csnEntity[entityName], entityElement[entityName], mockServerUc, parserContext);
 
-function _parseEntityContainer(entityCSN, schemaData, parserContext) {
-    Object.entries(schemaData[0][parserContext.jsonEntityContainerName]).forEach(entry => {
-        if (entityCSN[parserContext.namespace + '.' + entry[0]])
-            // Captured the annotations at entity set and entity type name level
-            _includeExternalNamespaceAnnotation(entry[1], entityCSN[parserContext.namespace + '.' + entry[0]]);
-        if (entry[0].startsWith('@')) {
-            // Captured the annotations at entity container name level
-            entityCSN[parserContext.namespace][entry[0]] = entry[1];
+        // needs to be checked if this is necessary
+        if (entityElement[entityName].$HasStream) {
+            csnEntity[entityName].elements = { ...csnEntity[entityName].elements, ..._addBlobElement() };
         }
     });
-    return entityCSN;
-}
-
-function _generateEnumType(schemaData, parserContext) {
-    let enumTypeDict = {};
-    let temp;
-    Object.keys(schemaData).forEach(curEnumType => {
-        if (schemaData[curEnumType] instanceof Object) {
-            if (schemaData[curEnumType].$Kind && schemaData[curEnumType].$Kind === 'EnumType') {
-                temp = parserContext.namespace + '.' + curEnumType;
-                enumTypeDict[temp] = schemaData[curEnumType];
-            }
-        }
+    // add @open annotations
+    parserContext.entityTypeOpenEntries.forEach(entityName => {
+        if (csnEntity[entityName]) csnEntity[entityName]['@open'] = true;
     });
-    return enumTypeDict;
+
+    return csnEntity;
 }
 
-function _collectEnumType(schemaDataList, parserContext) {
-    let schemaData;
-    for (let i = 0; i < schemaDataList.length; i++) {
-        schemaData = schemaDataList[i];
-        parserContext.enumTypes = _generateEnumType(schemaData, parserContext);
+function _parseCSNForEntityType(schemaData, ignorePersistenceSkip, mockServerUc, parserContext) {
+    let entitiesList = [];
+    for (let fqName of parserContext.entityTypes) {
+        let entity = {};
+        let [schemaName, elementName] = _extractSchemaNameAndElementName(fqName);
+        let entityObj = schemaData[elementName];
+
+        if (entityObj?.$Kind === 'EntityType' && schemaName === schemaData.$SchemaNamespace) {
+            entity[fqName] = entityObj;
+            entitiesList.push(entity);
+        }
     }
-    return parserContext.enumTypes;
+
+    return _generateCSNForEntityType(ignorePersistenceSkip, mockServerUc, entitiesList, parserContext);
 }
 
-function _generateCSNForEnumType(schemaData, parserContext) {
-    const nonMemberList = ["$Kind", "$Type", "$UnderlyingType", "$IsFlags"];
-    let enumCsn = {};
-    let eTypes;
-    eTypes = _collectEnumType(schemaData, parserContext);
-    Object.keys(eTypes).forEach(element => {
-        enumCsn[element] = {};
-        enumCsn[element].kind = 'type';
-        enumCsn[element]['@cds.external'] = true;
-        enumCsn[element].enum = {};
-        /**
-         * If UnderlyingType not specified, default is Edm.Int32 --> cds.Integer
-         */
-        let underlyingType = eTypes[element].$UnderlyingType;
-        enumCsn[element].type = underlyingType ? edmxncdsdatatype[underlyingType] : 'cds.Integer';
+function _parseParameterAndReturnTypeContent(elementObject, mockServerUc, parserContext) {
+    let dataType = elementObject.$Type;
+    const isPrimitiveType = dataType.startsWith('Edm') ? true : false;
+    const isPrimaryKey = true;
 
-        if (!enumCsn[element].type || enumCsn[element].type !== "cds.Integer" ) {
-            throw new Error(messages.INVALID_ENUM_TYPE + `'${underlyingType}'`);
+    // primitive type
+    if (isPrimitiveType) {
+        if (edmPrimitiveTypes.includes(dataType)) {
+            return _generatePrimitiveDataTypeCsn(elementObject, !isPrimaryKey, parserContext);
         }
-        Object.keys(eTypes[element]).forEach(member => {
-            if (!nonMemberList.includes(member)) {
-                enumCsn[element].enum[member] = {};
-                enumCsn[element].enum[member].val = eTypes[element][member];
+        else {
+            throw new Error(messages.INVALID_DATATYPE + `'${dataType}' in element: '${elementObject.$Name}'`)
+        }
+    }
+    // structured type
+    else {
+        const dataKind = _checkIsStructureTypeAndReturnDataKind(dataType, elementObject, 'parameter', parserContext);
+        return _generateStructuredDataTypeCsn(dataType, elementObject, !isPrimaryKey, dataKind, 'parameter', mockServerUc, parserContext);
+    }
+}
+
+function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, mockServerUc, parserContext) {
+    const csnObj = {};
+    const isBounded = actionFunctionObject.$IsBound;
+    const parameters = actionFunctionObject.$Parameter;
+    const returnType = actionFunctionObject.$ReturnType;
+
+    csnObj.kind = kind;
+    _captureAnnotationWithinElement(actionFunctionObject, csnObj, parserContext);
+
+    if (parameters) {
+        csnObj.params = {};
+
+        for (let index = 0; index < parameters.length; index++) {
+            let isCollection = parameters[index].$Collection;
+            csnObj.params[parameters[index].$Name] = _parseParameterAndReturnTypeContent(parameters[index], mockServerUc, parserContext);
+            /**
+             * binding parameter handling - only first parameter will contain the binding
+             * parameter information, so only make change to the first parameter information.
+             * NOTE: Edm.Stream can act as the binding parameter for action/function
+             * We don't have any example for it, so not handled as of now
+             */
+            if (isBounded && index === 0) {
+                if (isCollection) {
+                    csnObj.params[parameters[index].$Name].items.type = '$self';
+                }
+                else {
+                    csnObj.params[parameters[index].$Name].type = '$self';
+                }
             }
-        });
-    });
-    return enumCsn;
+        }
+    }
+    if (returnType) {
+        csnObj.returns = _parseParameterAndReturnTypeContent(returnType, mockServerUc, parserContext);
+    }
+
+    return csnObj;
 }
 
-function _generateTypeDefinition(schemaData, parserContext) {
-    let typeDefDict = {};
-    let temp;
-    Object.keys(schemaData).forEach(curTypeDef => {
-        if (schemaData[curTypeDef] instanceof Object) {
-            if (schemaData[curTypeDef].$Kind && schemaData[curTypeDef].$Kind === 'TypeDefinition') {
-                temp = parserContext.namespace + '.' + curTypeDef;
-                typeDefDict[temp] = schemaData[curTypeDef];
+function _parseBoundedActionFunction(schemaData, csnObj, kind, mockServerUc, parserContext) {
+    const boundedObject = (kind === 'action') ? parserContext.entityToBoundedActions : parserContext.entityToBoundedFunctions;
+
+    Object.keys(boundedObject).forEach(fqEntityName => {
+        const [schemaName, ] = _extractSchemaNameAndElementName(fqEntityName);
+
+        if (schemaName === schemaData.$SchemaNamespace) {
+            const actionFunctionObjectList = boundedObject[fqEntityName];
+
+            if (!csnObj[fqEntityName].actions) {
+                csnObj[fqEntityName].actions = {};
             }
+            Object.keys(actionFunctionObjectList).forEach(actionFunctionName => {
+                csnObj[fqEntityName].actions[actionFunctionName] = _generateCSNForBoundedActionFunction(
+                    actionFunctionObjectList[actionFunctionName], kind, mockServerUc, parserContext
+                );
+            });
         }
     });
-    return typeDefDict;
 }
 
-function _collectTypeDefinition(schemaDataList, parserContext) {
-    let schemaData;
-    for (let i = 0; i < schemaDataList.length; i++) {
-        schemaData = schemaDataList[i];
-        parserContext.typeDefinitions = _generateTypeDefinition(schemaData, parserContext);
-    }
-}
+function _parseUnBoundedActionFunction(schemaData, kind, mockServerUc, parserContext) {
+    const unBoundedObject = (kind === 'action') ? parserContext.unboundedActions : parserContext.unboundedFunctions;
+    const csnObj = {};
 
-function _generateBounded(schemaData, flag, parserContext) {
-    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 = parserContext.namespace + '.' + curFunction;
-            for (let i = 0; i < schemaData[curFunction].length; i++) {
-                boundedFunction.push(schemaData[curFunction][i]);
-                bFunction[temp] = boundedFunction;
+    Object.keys(unBoundedObject).forEach(fqName => {
+        const [schemaName, ] = _extractSchemaNameAndElementName(fqName);
+
+        if (schemaName === schemaData.$SchemaNamespace) {
+            const actionFunctionObject = unBoundedObject[fqName];
+            const parameters = actionFunctionObject.$Parameter;
+            const returnType = actionFunctionObject.$ReturnType;
+
+            csnObj[fqName] = {};
+            csnObj[fqName].kind = kind;
+            csnObj[fqName]['@cds.external'] = true;
+            _captureAnnotationWithinElement(actionFunctionObject, csnObj[fqName], parserContext);
+
+            if (parameters) {
+                csnObj[fqName].params = {};
+
+                for (let paramObj of parameters) {
+                    csnObj[fqName].params[paramObj.$Name] = _parseParameterAndReturnTypeContent(paramObj, mockServerUc, parserContext);
+                }
+            }
+            if (returnType) {
+                csnObj[fqName].returns = _parseParameterAndReturnTypeContent(returnType, mockServerUc, parserContext);
             }
         }
     });
-    return bFunction;
+
+    return csnObj;
 }
 
-function _captureOptionalParameter(annotation, path) {
-    let param = annotation[0].split('/');
-    let defaultvalue = annotation[1]["@Core.OptionalParameter"]["DefaultValue"];
-    if (path.params === undefined) {
-        _addDefaultValueObject(path, defaultvalue);
+function _parserCSNForComplexType(schemaData, mockServerUc, parserContext) {
+    const complexCsn = {};
+    const isEntity = true;
+
+    for (let fqName of parserContext.complexTypes) {
+        let [schemaName, elementName] = _extractSchemaNameAndElementName(fqName);
+        let complexObj = schemaData[elementName];
+
+        if (complexObj?.$Kind === 'ComplexType' && schemaName === schemaData.$SchemaNamespace) {
+            complexCsn[fqName] = {};
+            complexCsn[fqName].kind = 'type';
+            complexCsn[fqName]['@cds.external'] = true;
+            complexCsn[fqName].elements = {};
+            // inheritance handling
+            _captureOpenTypes(fqName, complexCsn[fqName], complexObj, !isEntity, !mockServerUc, parserContext);
+            _captureAnnotationWithinElement(complexObj, complexCsn[fqName], parserContext);
+            _parsePropertyContent(complexCsn[fqName], complexObj, mockServerUc, parserContext);
+        }
     }
-    else {
-        _addDefaultValueObject(path.params[param[1]], defaultvalue);
+    // add @open annotations
+    parserContext.complexTypeOpenEntries.forEach(key => {
+        if (complexCsn[key]) complexCsn[key]['@open'] = true;
+    });
+
+    return complexCsn;
+}
+
+function _parseCSNForEnumType(schemaData, parserContext) {
+    const nonMemberList = ["$Kind", "$Type", "$UnderlyingType", "$IsFlags"];
+    const possibleCdsTypes = ['cds.Integer',  'cds.Integer64'];
+    const enumCsn = {};
+    const isKey = true;
+
+    for (let fqName of parserContext.enumTypes) {
+        let [schemaName, elementName] = _extractSchemaNameAndElementName(fqName);
+        let enumObj = schemaData[elementName];
+
+        if (enumObj?.$Kind === 'EnumType' && schemaName === schemaData.$SchemaNamespace) {
+            enumCsn[fqName] = {};
+            enumCsn[fqName].kind = 'type';
+            enumCsn[fqName]['@cds.external'] = true;
+            enumCsn[fqName].enum = {};
+            /**
+             * If UnderlyingType not specified, default is Edm.Int32 --> cds.Integer
+             */
+            let underlyingType = enumObj.$UnderlyingType;
+            enumObj.$Type = underlyingType;
+
+            let cdsType = underlyingType ? (_generatePrimitiveDataTypeCsn(enumObj, !isKey, parserContext)) : { type : 'cds.Integer' };
+            enumCsn[fqName].type = cdsType.type;
+
+            if (cdsType['@odata.Type']) {
+                enumCsn[fqName]['@odata.Type'] = cdsType['@odata.Type'];
+            }
+            if (!possibleCdsTypes.includes(enumCsn[fqName].type)) {
+                throw new Error(messages.INVALID_ENUM_TYPE + `'${underlyingType}'`);
+            }
+
+            Object.keys(enumObj).forEach(member => {
+                if (!nonMemberList.includes(member)) {
+                    enumCsn[fqName].enum[member] = {};
+                    enumCsn[fqName].enum[member].val = enumObj[member];
+                }
+            });
+        }
     }
-    return path;
+
+    return enumCsn;
 }
 
-function _addDefaultValueObject(path, defaultvalue) {
-    // for collection, default value isin't expected
-    if (path.items === undefined) {
-        path.default = {};
-        path.default.val = (defaultvalue) ? defaultvalue : null;
+function _parseCSNForTypeDefinition(schemaData, parserContext) {
+    const typeDef = {};
+    const isKey = true;
+
+    for (let fqName of parserContext.typeDefinitions) {
+        let [schemaName, elementName] = _extractSchemaNameAndElementName(fqName);
+        let typeDefObj = schemaData[elementName];
+
+        if (typeDefObj?.$Kind === 'TypeDefinition' && schemaName === schemaData.$SchemaNamespace) {
+            typeDef[fqName] = {};
+            typeDef[fqName].kind = 'type';
+            typeDef[fqName]['@cds.external'] = true;
+
+            let underlyingType = typeDefObj.$UnderlyingType;
+            typeDefObj.$Type = underlyingType;
+
+            if (edmPrimitiveTypes.includes(underlyingType)) {
+                typeDef[fqName] = Object.assign(typeDef[fqName], _generatePrimitiveDataTypeCsn(typeDefObj, !isKey, parserContext));
+            }
+            else {
+                throw new Error(messages.UNRESOLVED_TYPE + `'${underlyingType}'`);
+            }
+        }
     }
+
+    return typeDef;
 }
 
-function _collectBounded(schemaDataList, flag, parserContext) {
-    let schemaData;
-    for (let i = 0; i < schemaDataList.length; i++) {
-        schemaData = schemaDataList[i];
-        if (flag == 0) {
-            parserContext.boundedActions = _generateBounded(schemaData, 0, parserContext);
+function _resolveEntityContainerAnnotationTarget(targetPath, csnDefs, hasProperty, parserContext) {
+    /**
+     * format: <schemaName_or_Alias><EntityContainerName>/<ContainerElement>
+     * <schemaName_or_Alias><EntityContainerName>/<ContainerElement>/...
+     * 
+     * needs to be handled without 'EntityContainerName'
+     */
+    if (hasProperty) {
+        const eleNameList = targetPath.split('/');
+        // based on the length of eleName list, do the processing
+        if (eleNameList.length === 2) {
+            return csnDefs[parserContext.primarySchema + '.' + eleNameList[1]];
         }
         else {
-            parserContext.boundedFunctions = _generateBounded(schemaData, 1, parserContext);
+            // TODO: We might have to take care of such senarios in the future.
         }
     }
+    // direct path to service object
+    else {
+       return csnDefs[parserContext.primarySchema];
+    }
 }
 
-function _getDatatype(datatype, parserContext) {
-    let type = undefined;
-    if (datatype === undefined) {
-        type = "cds.LargeString"; // intentionally used LargeString
-    } else if (parserContext.entitySetToEntityTypeMap.get(datatype) && parserContext.entitySetToEntityTypeMap.get(datatype)[0]) {
-        // mapping to entity set if type is entity type
-        type = parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(datatype)[0];
-    } else if (parserContext.complexTypes[datatype] || parserContext.typeDefinitions[datatype] || parserContext.enumTypes[datatype]) {
-        // if type is complex type, type definition or an enum type
-        type = datatype;
-    } else {
-        // checking if type is an entity set
-        for (const element of parserContext.entitySetToEntityTypeMap.keys()) {
-            if (parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(element) === datatype)
-                type = datatype;
+function _resolveActionFunctionAnnotationTarget(targetPath, csnDefs, hasParameter, parserContext) {
+    let elemNameList = targetPath.split('(');
+    const fqActFunName = _resolveAliasedElementName(elemNameList[0], parserContext);
+    const paramName = hasParameter ? targetPath.split('/')[1] : null;
+
+    // unbounded action or function
+    if (csnDefs[fqActFunName]) {
+        // with parameter
+        if (hasParameter && csnDefs[fqActFunName].params[paramName]) {
+            return csnDefs[fqActFunName]?.params[paramName];
+        }
+        // without parameter
+        else if (!hasParameter) {
+            return csnDefs[fqActFunName];
         }
-        parserContext.entityTypes.forEach(entity => {
-            if (entity[datatype])
-                type = datatype;
-        })
     }
+    // bounded action or function
+    else {
+        const [, elementName] = _extractSchemaNameAndElementName(fqActFunName);
+        const isCollection = elemNameList[1] === 'Collection' ? true : false;
+        let parameterList = isCollection ? elemNameList[2].split(')') : elemNameList[1].split(')');
+        let bindingParameter = parameterList[0];
 
-    // will return undefined if type is not supported
-    return type;
-}
+        if (bindingParameter.includes(',')) {
+            bindingParameter = bindingParameter.split(',')[0];
+        }
+        const entityType = _resolveAliasedElementName(bindingParameter, parserContext);
 
-function _parseBounded(csnDefs, flag, parserContext) {
-    let boundedEdmxKind, boundedObj, boundedCsnKind, boundedEntityName, obj, paramName, paramObj, name;
-    if (flag == 0) {
-        boundedEdmxKind = "Action";
-        boundedCsnKind = "action";
-        boundedObj = parserContext.boundedActions;
-    }
-    else {
-        boundedEdmxKind = "Function";
-        boundedCsnKind = "function";
-        boundedObj = parserContext.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 = parserContext.namespace + "." + parserContext.entitySetToEntityTypeMap.get(boundedEntityName)[0];
-                    }
-                    if (csnDefs[boundedEntityName]) {
-                        if (csnDefs[boundedEntityName].actions === undefined)
-                            csnDefs[boundedEntityName].actions = {};
-                        csnDefs[boundedEntityName].actions[name] = {};
-                        _includeExternalNamespaceAnnotation(obj[0], csnDefs[boundedEntityName].actions[name]);
-                        csnDefs[boundedEntityName].actions[name].kind = boundedCsnKind;
-                        // add params
-                        if (obj[j].$Parameter && obj[j].$Parameter.length >= 2) {
-                            /** 
-                             * 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;
-                                let paramType = {};
-                                let annotations = {};
-                                _includeExternalNamespaceAnnotation(paramObj, annotations);
-                                // check if the parameter type is pre-defined, undefined or custom defined
-                                if (edmxncdsdatatype[paramObj.$Type] || edmxncdsdatatype[paramObj.$Type + "_a"])
-                                    paramType = generatePropertyCsn(paramObj, false);
-                                else {
-                                    let type = _getDatatype(paramObj.$Type, parserContext);
-                                    if (type) paramType["type"] = type;
-                                }
-                                if (Object.keys(paramType).length > 0) {
-                                    if (paramType.type || paramType.items.type) {
-                                        // check if parameter type is a collection
-                                        if (paramObj.$Collection && !paramType.items) {
-                                            csnDefs[boundedEntityName].actions[name].params[paramName] = {};
-                                            csnDefs[boundedEntityName].actions[name].params[paramName].items = paramType;
-                                            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) {
-                                                    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);
-                                }
-                            }
-                        }
-                        // 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 = {};
-                            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 {
-                                    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 {
-                            if (obj[j].$Kind === 'Function')
-                                throw new Error(messages.NO_RETURN_TYPE + `'${name}'.`);
-                        }
-                    }
-                }
+        if (csnDefs[entityType]?.actions[elementName]) {
+            // with parameter
+            if (hasParameter && csnDefs[entityType].actions[elementName].params[paramName]) {
+                return csnDefs[entityType].actions[elementName].params[paramName];
             }
-        });
+            // without parameter
+            else if (!hasParameter) {
+                return csnDefs[entityType].actions[elementName];
+            }
+        }
     }
 }
 
-function _generateComplexType(schemaData, parserContext) {
-    let complexTypeDict = {};
-    let temp;
-    Object.keys(schemaData).forEach(curComplexType => {
-        if (schemaData[curComplexType] instanceof Object) {
-            if (schemaData[curComplexType].$Kind && schemaData[curComplexType].$Kind === 'ComplexType') {
-                temp = parserContext.namespace + '.' + curComplexType;
-                complexTypeDict[temp] = schemaData[curComplexType];
+function _resolveAnnotationTarget(targetPath, csnDefs, parserContext) {
+    const indexOfSlash = targetPath.indexOf('/');
+    const indexOfOpenBrace = targetPath.indexOf('(');
+    const hasPropOrParam = (indexOfSlash > 0);
+    let elemNameList, fqName;
+ 
+    // Case 1: Direct path
+    if (indexOfOpenBrace === -1 && indexOfSlash === -1) {
+        fqName = _resolveAliasedElementName(targetPath, parserContext);
+
+        if (csnDefs[fqName]) {
+            return csnDefs[fqName];
+        }
+        else if (parserContext.entityContainerAnnotations[targetPath]) {
+            return _resolveEntityContainerAnnotationTarget(fqName, csnDefs, hasPropOrParam, parserContext);
+        }
+    }
+    // Case 2: Direct path with /
+    else if (indexOfOpenBrace === -1 && indexOfSlash !== -1) {
+        elemNameList = targetPath.split('/');
+        fqName = _resolveAliasedElementName(elemNameList[0], parserContext);
+
+        if (csnDefs[fqName]) {
+            if (csnDefs[fqName]?.elements?.[elemNameList[1]]) {
+                return csnDefs[fqName].elements[elemNameList[1]];
+            }
+            else if (csnDefs[fqName]?.enum?.[elemNameList[1]]) {
+                return csnDefs[fqName].enum[elemNameList[1]];
             }
         }
-    });
-    return complexTypeDict;
+        // Entity Container path with /
+        else if (parserContext.entityContainerAnnotations[targetPath]) {
+            return _resolveEntityContainerAnnotationTarget(targetPath, csnDefs, hasPropOrParam, parserContext);
+        }
+    }
+    // Case 3: actions and functions path with or without parameter
+    else {
+        return _resolveActionFunctionAnnotationTarget(targetPath, csnDefs, hasPropOrParam, parserContext);
+    }
 }
 
-function _collectComplexType(schemaDataList, parserContext) {
-    // collect complex types
-    let schemaData;
-    for (let i = 0; i < schemaDataList.length; i++) {
-        schemaData = schemaDataList[i];
-        parserContext.complexTypes = _generateComplexType(schemaData, parserContext);
-    }
-    return parserContext.complexTypes;
+function _parseAnnotations(schemaAnnotations, csnDefs, parserContext) {
+    Object.keys(schemaAnnotations).forEach(annotationTargetPath => {
+        let csnDefsTargetObject = _resolveAnnotationTarget(annotationTargetPath, csnDefs, parserContext);
+        // if the target object exists, process the annotation terms
+        if (csnDefsTargetObject) {
+            let annotationTerms = schemaAnnotations[annotationTargetPath];
+            Object.keys(annotationTerms).forEach(annotationTerm => {
+                let annotationTermObject = schemaAnnotations[annotationTargetPath][annotationTerm];
+                _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject);
+            });
+        }
+    });
 }
 
-function _generateCSNForComplexType(schemaData, parserContext) {
-    let complexCsn = {};
-    let cTypes;
-    let propertyType;
-    let baseType, isAbstract, isOpenType;
-    let enumType;
-    cTypes = _collectComplexType(schemaData, parserContext);
-    Object.keys(cTypes).forEach(element => {
-        complexCsn[element] = {};
-        complexCsn[element].kind = 'type';
-        complexCsn[element]['@cds.external'] = true;
-        complexCsn[element].elements = {};
-        // inheritance handling
-        baseType = cTypes[element].$BaseType;
-        isAbstract = cTypes[element].$Abstract;
-        isOpenType = cTypes[element].$OpenType;
-        if (baseType) {
-            if (parserContext.complexTypes[baseType]) {
-                complexCsn[element].includes = [];
-                complexCsn[element].includes.push(baseType);
-                if (!parserContext.complexTypeOpenEntries.includes(baseType)) parserContext.complexTypeOpenEntries.push(baseType);
+function _parseEntityContainer(csnDefs, entityContainerElements, parserContext) {
+    const entityContainerElementNames = Object.keys(entityContainerElements);
+    const redundantElementNames = [];
+
+    entityContainerElementNames.forEach(ecElement => {
+        if (entityContainerElements[ecElement] instanceof Object) {
+            let definitionRefName, kind;
+            
+            if (entityContainerElements[ecElement].$Action) {
+                definitionRefName = entityContainerElements[ecElement].$Action;
+                kind = 'action';
+            }
+            else if (entityContainerElements[ecElement].$Function) {
+                definitionRefName = entityContainerElements[ecElement].$Function;
+                kind = 'function';
             }
             else {
-                throw new Error(messages.UNRESOLVED_TYPE + `'${baseType}' in element: '${element}'.`);
+                definitionRefName = entityContainerElements[ecElement].$Type;
+                kind = 'entity';
             }
-        }
-        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 ||
-                    edmxncdsdatatype[cTypes[element][property].$Type] ||
-                    edmxncdsdatatype[cTypes[element][property].$Type + "_a"]
-                ) {
-                    propertyType = cTypes[element][property];
-                    complexCsn[element].elements[property] = generatePropertyCsn(propertyType, false);
-                } else if (parserContext.complexTypes[cTypes[element][property].$Type]) {
-                    propertyType = cTypes[element][property];
-                    complexCsn[element].elements[property] = _generateComplexTypePropertyCsn(propertyType);
-                } else if (parserContext.typeDefinitions[cTypes[element][property].$Type]) {
-                    propertyType = cTypes[element][property];
-                    complexCsn[element].elements[property] = _generateTypeDefinitionPropertyCsn(propertyType);
-                } else if (parserContext.enumTypes[cTypes[element][property].$Type]) {
-                    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));
-                    throw new Error(messages.UNRESOLVED_TYPE + `'${cTypes[element][property].$Type}' in element: '${property}'.`);
-                }
-            } else if (property.startsWith("@")) {
-                complexCsn[element][property] = cTypes[element][property];
+
+            let [, elementName] = _extractSchemaNameAndElementName(definitionRefName);
+            let fqDefRefName = _resolveAliasedElementName(definitionRefName, parserContext);
+            let fqElementName = parserContext.primarySchema + "." + ecElement;
+
+            /**
+             * For now we don't support the collision between entitycontainer element name
+             * and any of the schema elemetents like entitytype, complextype, etc.
+             * TODO: In future we might have to support it. 
+             */
+            if (csnDefs[fqElementName] && csnDefs[fqElementName].kind !== kind) {
+                throw new Error(messages.ELEMENT_NAME_COLLISION + ecElement);
             }
-        });
-    });
 
-    // add @open annotations
-    parserContext.complexTypeOpenEntries.forEach(key => {
-        if (complexCsn[key]) complexCsn[key]['@open'] = true;
+            if (fqElementName !== fqDefRefName) {
+                csnDefs[fqElementName] = Object.assign({}, csnDefs[fqDefRefName]);
+                /**
+                 * Capture all the defintion reference element name which are no
+                 * longer required after the entity container elements are populated.
+                 * We will delete their entries from the csnDefs later.
+                 */
+                if (!entityContainerElementNames.includes(elementName)) {
+                    redundantElementNames.push(fqDefRefName);
+                }
+            }
+            if (entityContainerElements[ecElement].$Singleton) {
+                csnDefs[fqElementName]['@odata.singleton'] = true;
+            }
+            if (entityContainerElements[ecElement].$SingletonNullable) {
+                csnDefs[fqElementName]['@odata.singleton.nullable'] = true;
+            }
+        }
     });
 
-    return complexCsn;
-}
-
-function _parseTypeDefinition(parserContext) {
-    let typeDef = {};
-    let propertyType;
-    Object.keys(parserContext.typeDefinitions).forEach(element => {
-        typeDef[element] = {};
-        typeDef[element].kind = 'type';
-        typeDef[element]['@cds.external'] = true;
-
-        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}'`);
-        }
+    /**
+     * remove all the entries from the csnDefs which had a mapping in entity
+     * container and we have successfully copied their content to mapped elements
+     */
+    redundantElementNames.forEach(name => {
+        delete csnDefs[name];
     });
-    return typeDef;
-}
 
-function _parseUnbounded(schemaData, flag, parserContext) {
-    let unboundedObj = {}, unbounded, unboundedCsnKind;
-    let importToMap = new Multimap();
-    if (flag == 0) {
-        unbounded = parserContext.unboundedActions;
-        importToMap = parserContext.actionImportToActionMap;
-        unboundedCsnKind = "action";
-    }
-    else {
-        unbounded = parserContext.unboundedFunctions;
-        importToMap = parserContext.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 = ub.split(".").pop();
-                objType = parserContext.namespace + "." + temp;
-                objData = schemaData[0][temp][0];
-                obj[objType] = {};
-                obj[objType].kind = unboundedCsnKind;
-                obj[objType]['@cds.external'] = true;
-                _includeExternalNamespaceAnnotation(objData, obj[objType]);
-                // add params
-                if (objData.$Parameter && objData.$Parameter.length > 0) {
-                    obj[objType].params = {};
-                    for (let i = 0; i < objData.$Parameter.length; i++) {
-                        let paramType = {};
-                        let annotations = {};
-                        _includeExternalNamespaceAnnotation(objData.$Parameter[i], annotations);
-                        // check if the parameter type is pre-defined, undefined or custom defined
-                        if (edmxncdsdatatype[objData.$Parameter[i].$Type] || edmxncdsdatatype[objData.$Parameter[i].$Type + "_a"]) {
-                            paramType = generatePropertyCsn(objData.$Parameter[i], false)
-                        } else {
-                            let type = _getDatatype(objData.$Parameter[i].$Type, parserContext);
-                            if (type) paramType["type"] = type;
-                        }
-                        if (Object.keys(paramType).length > 0) {
-                            if (paramType.type || paramType.items.type) {
-                                // check if parameter type is a collection
-                                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) {
-                                        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) {
-                                            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));
-                            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)
-                    }
-                }
-                // if parameters has no entries
-                if (obj[objType].params && Object.keys(obj[objType].params).length === 0) {
-                    delete obj[objType].params;
-                }
-                // add returns
-                if (objData.$ReturnType && Object.keys(objData.$ReturnType).length > 0 && obj) {
-                    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"] ||
-                        (!objData.$ReturnType.$Type && objData.$ReturnType.$MaxLength)
-                    ){
-                        returnValue = generatePropertyCsn(objData.$ReturnType, false);
-                    } else {
-                        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) {
-                            obj[objType].returns = {};
-                            // check if return type is a collection
-                            if (objData.$ReturnType.$Collection && !returnValue.items) {
-                                obj[objType].returns.items = {};
-                                obj[objType].returns.items = returnValue;
-                                if (!objData.$ReturnType.$Nullable) {
-                                    obj[objType].returns.items["notNull"] = true;
-                                }
-                            } else {
-                                obj[objType].returns = returnValue;
-                                if (!returnValue.items) {
-                                    if (!objData.$ReturnType.$Nullable) {
-                                        obj[objType].returns["notNull"] = true;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    else {
-                        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);
-        });
+    // parse all the entity container annotations
+    if (parserContext.entityContainerAnnotations) {
+        _parseAnnotations(parserContext.entityContainerAnnotations, csnDefs, parserContext);
     }
-    return unboundedObj;
+
+    return csnDefs;
 }
 
-function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserContext) {
-    let csn = {};
-    let schemaData = [];
-    csn.meta = {};
-    csn.meta.creator = 'cds-dk ' + versionInfo;
-    csn.$version = '2.0';
-    csn.definitions = {};
+/**
+ * @param {List<Object>} dataObjList, action/function object list
+ * @returns unique parameter list
+ */
+function _collectAllParameters(dataObjList) {
+    let uniqueParams = [], paramNames = [], params;
 
-    Object.keys(edmxAsJson).forEach(data => {
-        if (ignoreObjects.indexOf(data) === -1 && edmxAsJson[data] instanceof Object) {
-            // replace the namespace alias value with original namespace value
-            if (edmxAsJson[data].$Alias)
-                edmxAsJson[data] = common.replaceAliasValue(JSON.stringify(edmxAsJson[data]), data, edmxAsJson[data].$Alias);
-            schemaData.push(edmxAsJson[data]);
-        }
-    });
+    for (let dataObj of dataObjList) {
+        params = dataObj.$Parameter;
 
-    if (mockServerUc) {
-        let entitySetData = edmxAsJson[parserContext.namespace];
-        let entityContainer;
-        Object.keys(entitySetData).forEach(data => {
-            if (ignoreObjects.indexOf(data) === -1 && entitySetData[data] instanceof Object) {
-                if (entitySetData[data].$Kind && entitySetData[data].$Kind === 'EntityContainer') {
-                    entityContainer = entitySetData[data];
+        if (params) {
+            for (let i = 0; i < params.length; i++) {
+                if (!paramNames.includes(params[i].$Name)) {
+                    paramNames.push(params[i].$Name);
+                    uniqueParams.push(params[i]);
                 }
             }
-        });
-        Object.keys(entityContainer).forEach(data => {
-            if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
-                entityContainer[data].$Type && (entityContainer[data].$Collection || entityContainer[data].$Singleton)) {
-                parserContext.entitySetToEntityTypeMap.set(entityContainer[data].$Type, data);
-            } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
-                entityContainer[data].$Action) {
-                parserContext.actionImportToActionMap.set(entityContainer[data].$Action, data);
-                parserContext.unboundedActions[entityContainer[data].$Action] = entitySetData[data];
-            } else if (ignoreObjects.indexOf(data) === -1 && entityContainer[data] instanceof Object &&
-                entityContainer[data].$Function) {
-                parserContext.functionImportToFunctionMap.set(entityContainer[data].$Function, data);
-                parserContext.unboundedFunctions[entityContainer[data].$Function] = entitySetData[data];
-            }
-        });
+        }
     }
 
-    csn.definitions[parserContext.namespace] = {};
-    csn.definitions[parserContext.namespace].kind = 'service';
-    csn.definitions[parserContext.namespace]['@cds.external'] = true;
-
-    _collectEnumType(schemaData, parserContext);
-    _collectTypeDefinition(schemaData, parserContext);
-    _collectBounded(schemaData, 0, parserContext);
-    _collectBounded(schemaData, 1, parserContext);
-
-    // Step 1: get all complex types.
-    csn.definitions = Object.assign(_generateCSNForComplexType(schemaData, parserContext), csn.definitions);
-    // Step 2: get all type definition
-    csn.definitions = Object.assign(_parseTypeDefinition(parserContext), csn.definitions);
-    // Step 3: get all entity type
-    csn.definitions = Object.assign(_parseEntityType(schemaData, ignorePersistenceSkip, mockServerUc, parserContext), csn.definitions);
-    // Step 4: get all unbounded action & function
-    csn.definitions = Object.assign(_parseUnbounded(schemaData, 0, parserContext), csn.definitions);
-    csn.definitions = Object.assign(_parseUnbounded(schemaData, 1, parserContext), csn.definitions);
-    // Step 5: get all enum types
-    csn.definitions = Object.assign(_generateCSNForEnumType(schemaData, parserContext), csn.definitions);
-    // Step 6: add entity container properties
-    csn.definitions = Object.assign(_parseEntityContainer(csn.definitions, schemaData, parserContext, parserContext), csn.definitions);
-    // Step 7: get all bounded action & function
-    _parseBounded(csn.definitions, 0, parserContext);
-    _parseBounded(csn.definitions, 1, parserContext);
-    // Step 8: get all annotations
-    _generateDocumentation(edmxAsJson, schemaData, csn.definitions, parserContext);
-
-    return JSON.stringify(csn, null, 4);
-}
-
-function _replaceSpecialCharacters(text) {
-    return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').replace(/"/g, "&quot;").trim();
+    return uniqueParams;
 }
 
-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)
-                path.doc = _replaceSpecialCharacters(annotation[1]["@Core.Description"]);
-            else
-                path.doc += _replaceSpecialCharacters(annotation[1]["@Core.Description"]);
+/**
+ * @param {Boolean} isAction, to identify action/function
+ * @param {String} fqName, fully qualified name
+ * @param {List<Object>} schemaDataList
+ * @param {Object} parserContext
+ * 
+ * Scenarios:
+ * 1. UnBounded Actions can't have collision. Action name must be unique.
+ * 2. UnBounded Functions can have collision; capture the max number of parameters.
+ */
+function _populateUnboundedActionFunction(isAction, fqName, schemaDataList, parserContext) {
+    let [schemaName, actFunName] = _extractSchemaNameAndElementName(fqName);
+    let indexOfSchema;
+    [indexOfSchema, schemaName] = _getIndexAndNamespaceOfSchema(fqName, schemaName, parserContext);
+    const dataList = schemaDataList[indexOfSchema][actFunName];
+    let actionFunctionObject = dataList[0];
+    fqName = schemaName + '.' + actFunName; // modified fqName as per new schemaName
+
+    if (isAction) {
+        if (dataList.length === 1) {
+            parserContext.unboundedActions[fqName] = actionFunctionObject;
+        }
+        else {
+            throw new Error(messages.UNBOUNDED_ACTION_COLLISION + `'${actFunName}' of Schema: ${schemaName} `);
         }
-        else if (targetString === "@Core.LongDescription" && annotation[1]["@Core.LongDescription"]) {
-            _generateLongDescription(annotation, path, no_of_terms);
+    }
+    else {
+        if (dataList.length > 1) {
+            actionFunctionObject['$Parameter'] = _collectAllParameters(dataList);
+            parserContext.unboundedFunctions[fqName] = actionFunctionObject;
         }
-        else if (targetString === "@Core.OptionalParameter" && annotation[1]["@Core.OptionalParameter"]) {
-            _captureOptionalParameter(annotation, path);
+        else {
+            parserContext.unboundedFunctions[fqName] = actionFunctionObject;
         }
-        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];
-                }
-            }
+        // throw error if the return type is missing
+        if (!parserContext.unboundedFunctions[fqName].$ReturnType) {
+            throw new Error(messages.NO_RETURN_TYPE + actFunName);
         }
     }
 }
 
-function checkEntitySetMap(pathName, parserContext, index = 0) {
-    if (parserContext.entitySetToEntityTypeMap.get(pathName) != null) {
-        pathName = parserContext.namespace + '.' + parserContext.entitySetToEntityTypeMap.get(pathName)[index];
+function _collectUnboundedActionFunction(schemaDataList, parserContext) {
+    for (let actionName of parserContext.actionToActionImportMap.keys()) {
+        _populateUnboundedActionFunction(true, actionName, schemaDataList, parserContext);
+    }
+    for (let functionName of parserContext.functionToFunctionImportMap.keys()) {
+        _populateUnboundedActionFunction(false, functionName, schemaDataList, parserContext);
     }
-    return pathName;
 }
 
-function _checkAnnotationTarget(annotation, csnDefs, str, no_of_terms, vocab, parserContext) {
-    if ((annotation[0].indexOf('/') === -1 && annotation[0].indexOf('(') === -1) || annotation[0].includes("Container")) {
-        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, csnDefs[path1], no_of_terms, str, vocab);
-                    }
-                } else {
-                    _checkAnnotatationTerm(annotation, csnDefs[annotation[0]], no_of_terms, str, vocab);
-                }
-            }
-            else {
-                _checkAnnotatationTerm(annotation, csnDefs[annotation[0]], no_of_terms, str, vocab);
-            }
-        }
+/**
+ * @param {Boolean} isAction
+ * @param {String} currNamespace
+ * @param {String} elementName
+ * @param {List<Object>} elementDataList, bounded action/function details
+ * @param {Object} parserContext
+ * 
+ * Scenarios for bounded actions, functions:
+ * 1. Actions with same name and binding parameter type can't have collision.
+ * 2. Functions can have collision and we will capture the max number of parameters.
+ * Special scenario is when same function name is bounded to different entity as well.
+ */
+function _collectBoundedActionFunction(isAction, currNamespace, elementName, elementDataList, parserContext) {
+    let functionObjList; // list to collect all the collision obj for function
 
-        if (annotation[0].indexOf('/') > 0) {
-            let path = annotation[0].split('/');
-            let temp = parserContext.namespace + '.' + path[1];
-            let path1 = checkEntitySetMap(temp, parserContext);
-            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, csnDefs[actualPath], no_of_terms, str, vocab);
+    for (let i = 0; i < elementDataList.length; i++) {
+        let dataObj = elementDataList[i];
+        let boundedEntityName = dataObj.$Parameter[0].$Type;
+        let [schemaName, entityName] = _extractSchemaNameAndElementName(boundedEntityName);
+
+        // binding parameter type should be within the current schema only
+        if (currNamespace !== schemaName && currNamespace !== parserContext.schemaAliasToNamespace[schemaName]) {
+            throw new Error(messages.INVALID_BOUNDED_PARAM_TYPE + ` Check the Element: ${elementName} of Schema: ${currNamespace} `);
         }
-        else if (annotation[0].indexOf('(') === -1 && (annotation[0].indexOf('/') === -1)) {
-            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, csnDefs[path1], no_of_terms, str, vocab);
-                    }
-                }
-            }
+        if (!parserContext.entityTypes.includes(currNamespace + '.' + entityName)) {
+            throw new Error(messages.UNRESOLVED_TYPE + boundedEntityName);
         }
-    }
-    else if (annotation[0].indexOf('(') === -1 && !(annotation[0].indexOf('/') === -1)) {
-        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, csnDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
+        boundedEntityName = currNamespace + '.' + entityName;
+
+        if (isAction) {
+            if (!parserContext.entityToBoundedActions[boundedEntityName]?.[elementName]) {
+                if (!parserContext.entityToBoundedActions[boundedEntityName]) {
+                    parserContext.entityToBoundedActions[boundedEntityName] = {};
                 }
+                parserContext.entityToBoundedActions[boundedEntityName][elementName] = dataObj;
             }
             else {
-                let path1 = checkEntitySetMap(path[0], parserContext);
-                if (csnDefs[path1]) {
-                    _checkAnnotatationTerm(annotation, csnDefs[path1]["elements"][path[1]], no_of_terms, str, vocab);
-                }
+                throw new Error(messages.BOUNDED_ACTION_COLLISION + ` Check the Element: ${elementName} of Schema: ${currNamespace} `);
             }
         }
         else {
-            if (csnDefs[path[0]]) {
-                _checkAnnotatationTerm(annotation, csnDefs[path[0]]["elements"][path[1]], no_of_terms, str, vocab);
+            if (!parserContext.entityToBoundedFunctions[boundedEntityName]?.[elementName]) {
+                if (!parserContext.entityToBoundedFunctions[boundedEntityName]) {
+                    parserContext.entityToBoundedFunctions[boundedEntityName] = {};
+                }
+                if (!functionObjList || !parserContext.entityToBoundedFunctions[boundedEntityName][elementName]) {
+                    functionObjList = [];
+                }
+                parserContext.entityToBoundedFunctions[boundedEntityName][elementName] = dataObj;
+                functionObjList.push(dataObj);
             }
-        }
-    }
-    else {
-        let path = annotation[0].split('(');
-        let actualPath = checkEntitySetMap(path[0], parserContext);
-        if (csnDefs[actualPath] === undefined) {
-            let temp = path[1].split(')');
-            let path1 = temp[0].split(',');
-            let path2 = path[0].split('.');
-            if (csnDefs[path1[0]]) {
-                _checkAnnotatationTerm(annotation, csnDefs[path1[0]]["actions"][path2[1]], no_of_terms, str, vocab);
+            else {
+                functionObjList.push(dataObj);
+                let functionObject = functionObjList[0];
+                functionObject['$Parameter'] = _collectAllParameters(functionObjList);
+                functionObjList = [functionObject]; // reset the function object list with recently formed object
+                parserContext.entityToBoundedFunctions[boundedEntityName][elementName] = functionObject;
             }
-        } else {
-            if (path[1].indexOf('/') === -1) {
-                _checkAnnotatationTerm(annotation, csnDefs[path[0]], no_of_terms, str, vocab);
-            } else {
-                let path1 = path[1].split('/');
-                if (csnDefs[path[0]] && csnDefs[path[0]]["params"]) {
-                    _checkAnnotatationTerm(annotation, csnDefs[path[0]]["params"][path1[1]], no_of_terms, str, vocab);
-                }
+            // throw error if the return type is missing
+            if (!parserContext.entityToBoundedFunctions[boundedEntityName][elementName].$ReturnType) {
+                throw new Error(messages.NO_RETURN_TYPE + elementName);
             }
         }
     }
 }
 
-function _replaceSchemaDataAnnotation(vocabAlias, vocabNamespce, schemaDataAnnotation) {
-    for (let v in vocabAlias) {
-        if (schemaDataAnnotation.includes(vocabAlias[v])) {
-            schemaDataAnnotation = schemaDataAnnotation.split(vocabAlias[v]).join(known_vocabularies[vocabNamespce[v]]);
-        }
-        if (schemaDataAnnotation.includes(vocabNamespce[v])) {
-            schemaDataAnnotation = schemaDataAnnotation.split(vocabNamespce[v]).join(known_vocabularies[vocabNamespce[v]]);
-        }
+/**
+ * @param {Object} edmxAsJson, intermediate JSON
+ * @param {List<Object>} schemaDataList, list of all the schema contents
+ * @param {Object} parserContext, contains parser level context informations
+ */
+function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
+
+    _collectUnboundedActionFunction(schemaDataList, parserContext);
+
+    // collect entityType, enumType, complexType, typeDefinition, bounded action/function, annotations
+    for (let schemaData of schemaDataList) {
+        let currNamespace = schemaData.$SchemaNamespace;
+
+        Object.keys(schemaData).forEach(elementName => {
+            let fqName = currNamespace + '.' + elementName;
+            let elementData = schemaData[elementName];
+
+            if (elementData instanceof Object) {
+                if (elementData.$Kind === 'EntityType') parserContext.entityTypes.push(fqName);
+                else if (elementData.$Kind === 'EnumType') parserContext.enumTypes.push(fqName);
+                else if (elementData.$Kind === 'ComplexType') parserContext.complexTypes.push(fqName);
+                else if (elementData.$Kind === 'TypeDefinition') parserContext.typeDefinitions.push(fqName);
+                // bounded actions/functions
+                else if (elementData instanceof Array) {
+                    let isAction = elementData[0].$Kind === 'Action' ? true : false;
+                    if (elementData[0].$IsBound) {
+                        _collectBoundedActionFunction(isAction, currNamespace, elementName, elementData, parserContext);
+                    }
+                }
+                // annotations
+                else if (elementName === '$Annotations') {
+                    if (edmxAsJson.$Reference) {
+                        Object.entries(edmxAsJson.$Reference).forEach(ref => {
+                            if (ref[1].$Include[0].$Alias &&
+                                known_vocabularies.hasOwnProperty(ref[1].$Include[0].$Namespace)
+                            ) {
+                                parserContext.vocabAliasToNamespace[ref[1].$Include[0].$Alias] = ref[1].$Include[0].$Namespace;
+                            }
+                        });
+                    }
+                    schemaData.$Annotations = _resolveAnotationTerm(JSON.stringify(schemaData.$Annotations), parserContext);
+                    /**
+                     * collect entity container annotations with the assumption that
+                     * we only have a single entity container
+                     */
+                    if (currNamespace === parserContext.primarySchema) {
+                        Object.keys(schemaData.$Annotations).forEach(annotationTarget => { 
+                            if (annotationTarget.includes(parserContext.entityContainerName)) {
+                                parserContext.entityContainerAnnotations[annotationTarget] = schemaData.$Annotations[annotationTarget];
+                                /**
+                                 * since already captured in the parserContext, we will directly make
+                                 * use of that itself. Hence delete from the schema annotaions here.
+                                 */
+                                delete schemaData.$Annotations[annotationTarget];
+                            }
+                        });
+                    }
+                }
+            }
+        });
     }
-    return JSON.parse(schemaDataAnnotation);
 }
 
-function _generateDocumentation(edmxAsJson, schemaData, csnDefs, parserContext) {
-    let vocabAlias = [];
-    let vocab = [];
-    let vocabNamespce = [];
-    let controlFieldFlag = 0;
-    if (schemaData[0].$Annotations) {
-        if (edmxAsJson.$Reference) {
-            Object.entries(edmxAsJson.$Reference).forEach(a => {
-                if (known_vocabularies.hasOwnProperty(a[1].$Include[0].$Namespace)) {
-                    vocabAlias.push(a[1].$Include[0].$Alias);
-                    vocabNamespce.push(a[1].$Include[0].$Namespace);
-                    vocab.push(known_vocabularies[a[1].$Include[0].$Namespace])
-                }
-            });
+function _preProcess(edmxAsJson, mockServerUc, parserContext) {
+    let schemaDataList = [], indexOfSchema = 0;
+
+    Object.keys(edmxAsJson).forEach(schemaName => {
+        let schemaData = edmxAsJson[schemaName];
+        // collect the schema data
+        if (ignoreObjects.indexOf(schemaName) === -1 && schemaData instanceof Object) {
+            schemaData.$SchemaNamespace = schemaName;
+            schemaDataList.push(schemaData);
+            if (schemaData.$Alias) {
+                parserContext.schemaAliasToNamespace[schemaData.$Alias] = schemaName;
+            }
+            parserContext.schemaToSchemaDataIndex[schemaName] = indexOfSchema;
+            indexOfSchema++;
         }
-
-        schemaData[0].$Annotations = _replaceSchemaDataAnnotation(vocabAlias, vocabNamespce, JSON.stringify(schemaData[0].$Annotations));
-
-        Object.entries(schemaData[0].$Annotations).map(annotation => {
-            let no_of_terms;
-            Object.entries(annotation[1]).forEach(anno => {
-                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 mock server use case & traversing primary schema, collect relevant mappings
+        if (mockServerUc && schemaName === parserContext.primarySchema) {
+            let entityContainerData = schemaData[parserContext.entityContainerName];
+            Object.keys(entityContainerData).forEach(elementName => {
+                let elementObj = entityContainerData[elementName];
+                let allowedObject = (ignoreObjects.indexOf(elementName) === -1) && (elementObj instanceof Object);
+                // EntityType - EntitySet, Singleton mapping
+                if (allowedObject && elementObj.$Type) {
+                    if (elementObj.$Collection) {
+                        parserContext.entityToEntitySetMap.set(entityContainerData[elementName].$Type, elementName);
                     }
-                    if (annotation[1].hasOwnProperty('@Common.FieldControl') && controlFieldFlag === 0) {
-                        annotation[1]["@Common.FieldControl"] = { "#": annotation[1]["@Common.FieldControl"] };
-                        controlFieldFlag = 1;
+                    if (elementObj.$Singleton) {
+                        parserContext.entityToSingletonMap.set(entityContainerData[elementName].$Type, elementName);
                     }
-                    if (annotation[1].hasOwnProperty('@Common.IsUpperCase')) {
-                        annotation[1]["@Common.IsUpperCase"] = true;
-                    }
-                    _checkAnnotationTarget(annotation, csnDefs, anno[0], no_of_terms, vocab, parserContext);
                 }
-                if (vocab.includes(annoTerm) && annoTerm === 'Capabilities') {
-                    _parseCapabilitiesAnnotation(annotation[0], anno, csnDefs, vocab, parserContext);
+                // Action - ActionImport mapping
+                else if (allowedObject && elementObj.$Action) {
+                    parserContext.actionToActionImportMap.set(elementObj.$Action, elementName);
+                }
+                // Function - FunctionImport mapping
+                else if (allowedObject && elementObj.$Function) {
+                    parserContext.functionToFunctionImportMap.set(elementObj.$Function, elementName);
                 }
             });
-            controlFieldFlag = 0;
-        });
-    }
-}
-
-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;
+    _collectSchemaElements(edmxAsJson, schemaDataList, parserContext);
 
-    _removeTypeInAnnotation(currentAnnotation);
+    return schemaDataList;
+}
 
-    /**
-     * 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);
+function _generateCSN(edmxAsJson, ignorePersistenceSkip, mockServerUc, parserContext) {
+    let csn = {};
+    csn.meta = {};
+    csn.meta.creator = 'cds-dk ' + versionInfo;
+    csn.$version = '2.0';
+    csn.definitions = {};
+    let schemaDataList = _preProcess(edmxAsJson, mockServerUc, parserContext);
+
+    for (let schemaData of schemaDataList) {
+        // Step 1: parse all type definition
+        csn.definitions = Object.assign(_parseCSNForTypeDefinition(schemaData, parserContext), csn.definitions);
+        // Step 2: parse all enum types
+        csn.definitions = Object.assign(_parseCSNForEnumType(schemaData, parserContext), csn.definitions);
+        // Step 3: parse all complex types
+        csn.definitions = Object.assign(_parserCSNForComplexType(schemaData, mockServerUc, parserContext), csn.definitions);
+        // Step 4: parse all entity type
+        csn.definitions = Object.assign(_parseCSNForEntityType(schemaData, ignorePersistenceSkip, mockServerUc, parserContext), csn.definitions);
+        // Step 5: parse all bounded action & function
+        _parseBoundedActionFunction(schemaData, csn.definitions, 'action', mockServerUc, parserContext);
+        _parseBoundedActionFunction(schemaData, csn.definitions, 'function', mockServerUc, parserContext);
+        // Step 6: parse all unbounded action & function
+        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'action', mockServerUc, parserContext), csn.definitions);
+        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'function', mockServerUc, parserContext), csn.definitions);
+        // Step 7: parse all annotations
+        if (schemaData.$Annotations) {
+            _parseAnnotations(schemaData.$Annotations, csn.definitions, 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);
-            }
-        });
+    // add Service object and EntityContainer items only if it is mock server use case
+    if (mockServerUc) {
+        csn.definitions[parserContext.primarySchema] = {};
+        csn.definitions[parserContext.primarySchema].kind = 'service';
+        csn.definitions[parserContext.primarySchema]['@cds.external'] = true;
+
+        // Step 8: parse entity container contents and their annotations
+        let schemaData = schemaDataList[parserContext.schemaToSchemaDataIndex[parserContext.primarySchema]];
+        let entityContainerElements = schemaData[parserContext.entityContainerName];
+        csn.definitions = Object.assign(_parseEntityContainer(csn.definitions, entityContainerElements, parserContext), csn.definitions);
     }
-}
 
-function _generateLongDescription(annotation, path, no_of_terms) {
-    if (path) {
-        path.doc = no_of_terms ? (path.doc += "\n\n") : (path.doc ? (path.doc += "") : (path.doc = ""));
-        path.doc += _replaceSpecialCharacters(annotation[1]["@Core.LongDescription"]);
-        return (path.doc);
-    }
+    return JSON.stringify(csn, null, 4);
 }
 
-function _generateEDMX2JSON(edmx, name_space, parserContext) {
+function _generateEDMX2JSON(edmx, name_space, parserContext, context) {
     return new Promise(function getJson(resolve, reject) {
         try {
             const inputBuffer = edmx;
@@ -1451,7 +1590,7 @@ function _generateEDMX2JSON(edmx, name_space, parserContext) {
                 if (missingReferencedDocuments?.length > 0) {
                     console.log(missingReferencedDocuments); // eslint-disable-line no-console
                 }
-                if (_isValidJSON(json, parserContext)) {
+                if (_isValidJSON(json, parserContext, context)) {
                     resolve(json);
                 }
             });
@@ -1464,21 +1603,23 @@ function _generateEDMX2JSON(edmx, name_space, parserContext) {
 async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context) {
     let csn;
     let edmjConverted;
-    let name_space = []
+    let name_space = [];
 
     const parserContext = {};
     _initialize(parserContext);
 
-    if (context.include_all_namespaces === true)
+    if (context.include_all_namespaces) {
         name_space.push(true);
-    else
+    }
+    else {
         name_space = context.namespaces;
+    }
 
     if (_isJson(edmx)) {
         return new Promise(function getCsn(resolve, reject) {
             try {
                 edmjConverted = JSON.parse(edmx);
-                if (_isValidJSON(edmjConverted, parserContext)) {
+                if (_isValidJSON(edmjConverted, parserContext, context)) {
                     csn = _generateCSN(edmjConverted, ignorePersistenceSkip, mockServerUc, parserContext);
                     if (csn) resolve(csn);
                 }
@@ -1487,7 +1628,8 @@ async function getEdmxv4CSN(edmx, ignorePersistenceSkip, mockServerUc, context)
             }
         });
     }
-    const edmj = await _generateEDMX2JSON(edmx, name_space, parserContext);
+    const edmj = await _generateEDMX2JSON(edmx, name_space, parserContext, context);
+
     return _generateCSN(edmj, ignorePersistenceSkip, mockServerUc, parserContext);
 }