@sap/cds-dk 9.9.2 → 10.0.3

package/lib/build/util.js

@@ -45,18 +45,6 @@ function hasOptionValue(actual, expected) {
     return actual === expected
 }
 
-/**
- * Returning the project relative path representation of the given path(s),
- * @param {string} root - project root
- * @param {string | string[]} qualifiedPaths - fully qualified path(s)
- */
-function relativePaths(root, qualifiedPaths) {
-    qualifiedPaths = typeof qualifiedPaths === "string" ? [qualifiedPaths] : qualifiedPaths
-    return Array.isArray(qualifiedPaths)
-        ? qualifiedPaths.map(qualifiedPath => path.relative(root, qualifiedPath) ?? ".")
-        : qualifiedPaths
-}
-
 /**
  * Returns a list of fully qualified model names belonging to the '@sap' namespace that cannot be resolved.
  * E.g. the module might NOT have been installed.
@@ -80,8 +68,6 @@ function resolveRequiredSapModels(modelPaths) {
 async function getDefaultModelPaths(ws = false) {
     const { toggles } = cds.env.requires, { folders } = cds.env.features
     const wildcards = toggles && folders ? ['*', folders] : '*'
-    if (!cds.resolve.locations) return _compatGetDefaultModelPaths(ws, wildcards)
-
     let paths = _filterModelPaths(cds.resolve.locations(wildcards))
     if (ws) {
         const workspaces = (await getWorkspaces())
@@ -99,32 +85,6 @@ async function getDefaultModelPaths(ws = false) {
     return paths
 }
 
-// cds10: remove
-async function _compatGetDefaultModelPaths(ws, wildcards) {
-    let paths = _filterModelPaths(cds.resolve(wildcards, false))
-
-    if (ws) {
-        const workspaces = (await getWorkspaces())
-          .map(ws => ws.workspace)
-        const env = cds.env
-        const root = cds.root
-        try {
-            workspaces.forEach(workspace => {
-                cds.root = path.join(root, workspace)
-                cds.env = cds.env.for('cds', cds.root)
-                const fromWorkspace = _filterModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false))
-                paths.push(...fromWorkspace.map(p => normalizePath(path.join(workspace, p))))
-            })
-        } finally {
-            cds.root = root
-            cds.env = env
-        }
-        // exclude redundant built-in models starting with workspace path, e.g. 'books/@sap/cds-mtxs/srv/bootstrap'
-        paths = paths.filter(p => NODEJS_MODEL_EXCLUDE_LIST.includes(p) || !NODEJS_MODEL_EXCLUDE_LIST.some(ex => p.endsWith(ex)))
-    }
-    return paths
-}
-
 /**
  * @overload
  * @param {string} dir
@@ -488,7 +448,6 @@ class BuildError extends Error {
 
 module.exports = {
     hasOptionValue,
-    relativePaths,
     resolveRequiredSapModels,
     getDefaultModelPaths,
     getI18nDefaultFolder,

package/lib/import/common.js

@@ -15,10 +15,11 @@ let optionsMapping = {
     'keep-namespace': 'keepNamespace',
     'include-namespaces': 'includeNamespaces',
     'no-copy': 'no_copy',
-    'no-save': 'no_save'
+    'no-save': 'no_save',
+    'odata-v2-annotations': 'odataV2Annotations'
 };
 
-let apiOptions = ['includeNamespaces', 'keepNamespace'];
+let apiOptions = ['includeNamespaces', 'keepNamespace', 'odataV2Annotations'];
 let commonOptions = ['for', 'no_copy', 'no_save', 'out', 'dry', 'as', 'from', 'force', 'config', 'destination', 'group', 'name'];
 let usingStatements = [];
 

package/lib/import/importapi.js

@@ -64,7 +64,7 @@ async function cds_import_from_edmx(filepath, options = { keepNamespace: false }
     filepath = await common.isValidInputFile(path.resolve(process.cwd(), filepath));
     const src = await common.getContentFromFile(filepath);
     // takes the api specific options and reads it from env
-    let odataOptions = { include_namespaces: options.includeNamespaces, keep_namespace: options.keepNamespace};
+    let odataOptions = { include_namespaces: options.includeNamespaces, keep_namespace: options.keepNamespace, odataV2Annotations: options.odataV2Annotations};
     if (cds.env.import) {
         common.readEnvVariables(odataOptions, false);
     }

package/lib/import/odata/annotationParser.js

@@ -0,0 +1,316 @@
+// annotation parsing funtions common for v2parser.js and v4parser.js
+
+"use strict";
+
+const { warn } = require("../../util/term");
+
+const known_vocabularies = {
+	'Org.OData.Authorization.V1': 'Authorization',
+	'Org.OData.Aggregation.V1': 'Aggregation',
+	'Org.OData.Core.V1': 'Core',
+	'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'
+};
+
+function _replaceSpecialCharacters(text) {
+	return text.replace(/(?:\\[rn]|[\r\n]+)+/gm, "\n").replace(/\s+/g, ' ').replace(/"/g, """).trim();
+}
+
+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 annotationObject 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;
+	}
+	/**
+	 * <Annotation Term="Common.Text" Path="name"/> --> annotationTermObject = { "=": annotationTermObject.$Path };
+	 */
+	if (annotationObject.$Path) {
+		annotationObject = { "=": annotationObject.$Path };
+	}
+
+	/**
+	 * Annotations need to be flattened in CSN. E.g.
+	 *
+	 * @Core.ContentDisposition : {
+	 *  Type    : 'inline',
+	 *  Filename: typedImageFileName
+	 * }
+	 *
+	 * is represented as:
+	 *
+	 * @Core.ContentDisposition.Type : 'inline',
+	 * @Core.ContentDisposition.Filename : {'=': 'typedImageFileName'},
+	 */
+	if (annotationObject instanceof Object && !(annotationObject instanceof Array) && !(Object.keys(annotationObject).length === 1 && (Object.keys(annotationObject)[0] === '=' || Object.keys(annotationObject)[0] === 'xpr' || Object.keys(annotationObject)[0] === '#'))) {
+		Object.keys(annotationObject).forEach(innerTargetString => {
+			captureAnnotationInCSN(targetString + '.' + innerTargetString, annotationObject[innerTargetString], csnDefsTargetObject);
+		});
+	} else {
+		csnDefsTargetObject[targetString] = annotationObject;
+	}
+}
+
+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 {
+			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 parseCoreTerm(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;
+			}
+		}
+		return captureAnnotationInCSN('doc', annotationTermObject, csnDefsTargetObject);
+	}
+
+	/**
+	 * <Annotation Term="Core.XYZ"/>
+	 * For such scenario, mark the `annotationTermObject` as `true`
+	 */
+	if (annotationTermObject === null) annotationTermObject = true;
+
+	if (annotationTerm === "@Core.OptionalParameter") {
+		if (annotationTermObject && annotationTermObject.DefaultValue !== undefined) {
+			csnDefsTargetObject.default = { val: annotationTermObject.DefaultValue };
+		}
+	} else {
+		captureAnnotationInCSN(annotationTerm, annotationTermObject, csnDefsTargetObject);
+	}
+}
+
+function parseCapabilitiesTerm(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+	let targetString;
+	/**
+	 * <Annotation Term="Capabilities.KeyAsSegmentSupported" />
+	 * For such scenario, mark the `annotationTermObject` 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);
+}
+
+/**
+ * Capture all the annotation cases within 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 parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject) {
+	const term = annotationTerm.split('.');
+	const vocabAlias = term[0];
+
+	switch (vocabAlias) {
+		case "@Core":
+			parseCoreTerm(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 validateAnnotationNamespace(annotationTerm, vocabNamespaceToAlias) {
+	let aliasOrNamespace = annotationTerm.substring(1, annotationTerm.lastIndexOf('.'));
+
+	// This check is for ignoring the @cds annotations given for special cases, e.g. @cds.validate = false for collided action/function
+	if (aliasOrNamespace === "cds") {
+		return;
+	}
+
+	for (let alias of Object.values(known_vocabularies)) {
+		if (alias === aliasOrNamespace) {
+			return;
+		}
+	}
+
+	for (let [namespace, alias] of Object.entries(vocabNamespaceToAlias || {})) {
+		if (alias === aliasOrNamespace || namespace === aliasOrNamespace) {
+			console.log(warn(annotationTerm + " AnnotationTerm belongs to an unknown namespace: " + namespace));
+			return;
+		}
+	}
+
+	console.log(warn(annotationTerm + ": Reference of this AnnotationTerm is not present in the edmx file."));
+}
+
+function resolveAnnotationTerm(schemaDataAnnotation, parserContext) {
+	for (const [namespace, alias] of Object.entries(parserContext.vocabNamespaceToAlias || {})) {
+		if (known_vocabularies[namespace]) {
+			// Case 1: Namespace belongs to known vocabularies. Replacing the namespace/alias of the doc with standard alias
+			if (schemaDataAnnotation.includes('@' + alias + '.')) {
+				schemaDataAnnotation = schemaDataAnnotation.split('@' + alias + '.').join('@' + known_vocabularies[namespace] + '.');
+			}
+			if (schemaDataAnnotation.includes('@' + namespace + '.')) {
+				schemaDataAnnotation = schemaDataAnnotation.split('@' + namespace + '.').join('@' + known_vocabularies[namespace] + '.');
+			}
+		} else {
+			// Case 2: Namespace doesn't belong to known vocabularies. Replacing the namespace with alias(if provided) in the doc.
+			if (schemaDataAnnotation.includes('@' + namespace + '.') && alias) {
+				schemaDataAnnotation = schemaDataAnnotation.split('@' + namespace + '.').join('@' + alias + '.');
+			}
+		}
+	}
+	/**
+	 * Case 3: Namespace doesn't have edmx:Reference. But it is present in known_vocabularies.
+	 *         Replacing it with standard alias.
+	 */
+	for (const [namespace, alias] of Object.entries(known_vocabularies)) {
+		if (schemaDataAnnotation.includes(namespace)) {
+			schemaDataAnnotation = schemaDataAnnotation.split(namespace).join(alias);
+		}
+	}
+
+	let index = schemaDataAnnotation.indexOf('"@');
+	while (index != -1) {
+		let i = schemaDataAnnotation.indexOf('"', index + 1);
+		let annotationTerm = schemaDataAnnotation.substring(index + 1, i);
+		validateAnnotationNamespace(annotationTerm, parserContext.vocabNamespaceToAlias);
+		index = schemaDataAnnotation.indexOf('"@', i + 1);
+	}
+
+	return JSON.parse(schemaDataAnnotation);
+}
+
+function parseAnnotations(schemaAnnotations, csnDefs, parserContext, resolveTarget) {
+	Object.keys(schemaAnnotations || {}).forEach(annotationTargetPath => {
+		let csnDefsTargetObject = resolveTarget(annotationTargetPath, csnDefs, parserContext);
+		if (csnDefsTargetObject) {
+			let annotationTerms = schemaAnnotations[annotationTargetPath];
+			Object.keys(annotationTerms).forEach(annotationTerm => {
+				let annotationTermObject = schemaAnnotations[annotationTargetPath][annotationTerm];
+				parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject);
+			});
+		}
+	});
+}
+
+module.exports = {
+	captureAnnotationInCSN,
+	flattenAnnotationObject,
+	removeTypeInAnnotation,
+	parseCoreTerm,
+	parseCapabilitiesTerm,
+	parseValidationTerm,
+	parseAnnotationTerms,
+	validateAnnotationNamespace,
+	resolveAnnotationTerm,
+	parseAnnotations
+};

package/lib/import/odata/v2parser.js

@@ -8,6 +8,7 @@ let messages = require("../message").getMessages();
 let common = require("../common");
 let versionInfo = require('../../../package.json').version;
 const { warn } = require('../../util/term');
+const annotationParser = require("./annotationParser");
 
 const edmxncdsdatatype = {
 	"Edm.String": "cds.String",
@@ -78,6 +79,7 @@ function _initialize(parserContext) {
 	parserContext.allowedNamespaces = [];
 	parserContext.allowAllNamespaces = false;
 	parserContext.mockServerUc = true;
+	parserContext.vocabNamespaceToAlias = {};
 }
 
 // Function to extract allowed namespace attributes from given set of attributes
@@ -1673,6 +1675,25 @@ function _generateEDMXJSON2CSN(jsonObj, ignorePersistenceSkip, parserContext) {
 	csn.$version = '2.0';
 	csn.definitions = {};
 
+	// Parse edmx:Reference elements to build vocabNamespaceToAlias mapping
+	const references = jsonObj["edmx:Edmx"]["edmx:Reference"];
+	if (references) {
+		const refArray = Array.isArray(references) ? references : [references];
+		refArray.forEach(ref => {
+			const include = ref["edmx:Include"];
+			if (include) {
+				const includeArray = Array.isArray(include) ? include : [include];
+				includeArray.forEach(inc => {
+					const namespace = inc._attributes?.Namespace;
+					const alias = inc._attributes?.Alias;
+					if (namespace && alias) {
+						parserContext.vocabNamespaceToAlias[namespace] = alias;
+					}
+				});
+			}
+		});
+	}
+
 	// Extract associations
 	const associations = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.Association;
 	if (associations) {
@@ -1742,12 +1763,204 @@ function _generateEDMXJSON2CSN(jsonObj, ignorePersistenceSkip, parserContext) {
 
 	try {
 		csn.definitions = JSON.parse(`{${definitions.join(",")}}`);
+		
+		// Parse annotations after definitions are populated
+		// Note: V2 annotations are opt-in (disabled by default for backward compatibility)
+		// and require --odata-v2-annotations flag. V4 always imports annotations.
+		const schemaAnnotations = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.Annotations;
+		if (schemaAnnotations && parserContext.annotations) {
+			_parseV2SchemaAnnotations(schemaAnnotations, csn.definitions, parserContext);
+		}
+
 		return JSON.stringify(csn, null, 4);
 	} catch {
 		throw new Error("Unable to convert to csn file.");
 	}
 }
 
+function _toArray(node) {
+	if (!node) return [];
+	return Array.isArray(node) ? node : [node];
+}
+
+function _readAnnotationPrimitive(attributes) {
+	if (attributes == null) return null;
+
+	if (attributes.Bool !== undefined) return attributes.Bool === 'true';
+	if (attributes.String !== undefined) return attributes.String;
+	if (attributes.Int !== undefined) return Number(attributes.Int);
+	if (attributes.Decimal !== undefined) return Number(attributes.Decimal);
+	if (attributes.Path !== undefined) return { '=': attributes.Path };
+	if (attributes.PropertyPath !== undefined) return { '=': attributes.PropertyPath };
+	if (attributes.NavigationPropertyPath !== undefined) return { '=': attributes.NavigationPropertyPath };
+	if (attributes.AnnotationPath !== undefined) return { '=': attributes.AnnotationPath };
+
+	return null;
+}
+
+function _parseV2AnnotationNode(node) {
+	if (node === null || node === undefined) return null;
+	if (Array.isArray(node)) return node.map(item => _parseV2AnnotationNode(item));
+	if (typeof node !== 'object') return node;
+
+	if (node._attributes) {
+		const primitiveValue = _readAnnotationPrimitive(node._attributes);
+		const childKeys = Object.keys(node).filter(key => key !== '_attributes');
+		if (primitiveValue !== null && childKeys.length === 0) {
+			return primitiveValue;
+		}
+	}
+
+	if (node.Collection) return _parseV2Collection(node.Collection);
+	if (node.Record) return _parseV2Record(node.Record);
+
+	const result = {};
+	Object.keys(node).forEach(key => {
+		if (key === '_attributes') return;
+		if (key === 'PropertyValue') {
+			_toArray(node[key]).forEach(propertyValue => {
+				Object.assign(result, _parseV2PropertyValue(propertyValue));
+			});
+		} else if (key === 'Collection') {
+			return _parseV2Collection(node[key]);
+		} else if (key === 'Record') {
+			Object.assign(result, _parseV2Record(node[key]));
+		} else {
+			const parsedValue = _parseV2AnnotationNode(node[key]);
+			if (parsedValue !== null && parsedValue !== undefined) {
+				result[key] = parsedValue;
+			}
+		}
+	});
+
+	return Object.keys(result).length ? result : _readAnnotationPrimitive(node._attributes);
+}
+
+function _parseV2PropertyValue(propertyValueNode) {
+	const attributes = propertyValueNode._attributes || {};
+	const propertyName = attributes.Property;
+	const childKeys = Object.keys(propertyValueNode).filter(key => key !== '_attributes');
+	let propertyValue = null;
+
+	if (childKeys.length === 0) {
+		propertyValue = _readAnnotationPrimitive(attributes);
+	} else if (childKeys.length === 1) {
+		const childKey = childKeys[0];
+		if (childKey === 'Collection') {
+			propertyValue = _parseV2Collection(propertyValueNode[childKey]);
+		} else if (childKey === 'Record') {
+			propertyValue = _parseV2Record(propertyValueNode[childKey]);
+		} else {
+			propertyValue = _parseV2AnnotationNode(propertyValueNode[childKey]);
+		}
+	} else {
+		propertyValue = {};
+		childKeys.forEach(childKey => {
+			if (childKey === 'PropertyValue') {
+				_toArray(propertyValueNode[childKey]).forEach(item => {
+					Object.assign(propertyValue, _parseV2PropertyValue(item));
+				});
+			} else {
+				propertyValue[childKey] = _parseV2AnnotationNode(propertyValueNode[childKey]);
+			}
+		});
+	}
+
+	return { [propertyName]: propertyValue };
+}
+
+function _parseV2Record(recordNode) {
+	if (recordNode === null || recordNode === undefined) return null;
+	if (Array.isArray(recordNode)) return recordNode.map(item => _parseV2Record(item));
+
+	const attributes = recordNode._attributes || {};
+	const result = {};
+
+	if (attributes.Type) {
+		result.$Type = attributes.Type;
+	}
+
+	Object.keys(recordNode).forEach(key => {
+		if (key === '_attributes') return;
+		if (key === 'PropertyValue') {
+			_toArray(recordNode[key]).forEach(propertyValueNode => {
+				Object.assign(result, _parseV2PropertyValue(propertyValueNode));
+			});
+		} else {
+			result[key] = _parseV2AnnotationNode(recordNode[key]);
+		}
+	});
+
+	return result;
+}
+
+function _parseV2Collection(collectionNode) {
+	if (collectionNode === null || collectionNode === undefined) return null;
+	if (Array.isArray(collectionNode)) return collectionNode.map(item => _parseV2AnnotationNode(item));
+
+	const values = [];
+	Object.keys(collectionNode).forEach(key => {
+		if (key === '_attributes') return;
+		_toArray(collectionNode[key]).forEach(item => {
+			values.push(_parseV2AnnotationNode(item));
+		});
+	});
+
+	return values;
+}
+
+function _parseV2AnnotationTerm(annotationNode) {
+	const attributes = annotationNode._attributes || {};
+	const annotationTerm = '@' + attributes.Term;
+	let annotationTermObject = null;
+
+	Object.keys(annotationNode).forEach(key => {
+		if (key === '_attributes') return;
+		annotationTermObject = _parseV2AnnotationNode(annotationNode[key]);
+	});
+
+	return [annotationTerm, annotationTermObject];
+}
+
+function _resolveV2AnnotationTarget(targetPath, csnDefs, parserContext) {
+	const normalizedTargetPath = targetPath.replace(/\.$/, '');
+	const targetSegments = normalizedTargetPath.split('/');
+	const entityContainerPrefix = parserContext.primarySchema + '.EntityContainer';
+
+	if (targetSegments.length > 1 && targetSegments[0] === entityContainerPrefix) {
+		return csnDefs[parserContext.primarySchema + '.' + targetSegments[1]];
+	}
+
+	if (csnDefs[normalizedTargetPath]) {
+		return csnDefs[normalizedTargetPath];
+	}
+
+	const directTarget = parserContext.primarySchema + '.' + targetSegments[targetSegments.length - 1];
+	if (csnDefs[directTarget]) {
+		return csnDefs[directTarget];
+	}
+}
+
+function _parseV2SchemaAnnotations(schemaAnnotations, csnDefs, parserContext) {
+	const parsedAnnotations = {};
+
+	_toArray(schemaAnnotations).forEach(annotationsNode => {
+		const targetPath = annotationsNode._attributes && annotationsNode._attributes.Target;
+		if (!targetPath) return;
+
+		if (!parsedAnnotations[targetPath]) {
+			parsedAnnotations[targetPath] = {};
+		}
+
+		_toArray(annotationsNode.Annotation).forEach(annotationNode => {
+			const [annotationTerm, annotationTermObject] = _parseV2AnnotationTerm(annotationNode);
+			parsedAnnotations[targetPath][annotationTerm] = annotationTermObject;
+		});
+	});
+
+	annotationParser.parseAnnotations(parsedAnnotations, csnDefs, parserContext, _resolveV2AnnotationTarget);
+}
+
 function getEdmxv2CSN(edmx2jsonModel, ignorePersistenceSkip, mockServerUc, context) {
 	let csnDataModel;
 	let isValid;
@@ -1762,11 +1975,15 @@ function getEdmxv2CSN(edmx2jsonModel, ignorePersistenceSkip, mockServerUc, conte
 	else if (context.include_all_namespaces) {
 		parserContext.allowAllNamespaces = true;
 	}
+	// V2 annotations are opt-in (disabled by default for backward compatibility)
+	// Controlled via --odata-v2-annotations CLI flag
+	parserContext.annotations = !!context.odataV2Annotations;
 
 	isValid = _isValidEDMXProvided(edmx2jsonModel);
 	_settingMockServerUc(edmx2jsonModel, parserContext)
 	if (isValid) {
 		parserContext.serviceNamespace = _getServiceNameSpace(edmx2jsonModel);
+		parserContext.primarySchema = parserContext.serviceNamespace;
 		context.schemaNamespace = parserContext.serviceNamespace; // required for `--keep-namespace` scenario
 		let namespaceAlias = edmx2jsonModel["edmx:Edmx"]["edmx:DataServices"].Schema._attributes.Alias;
 		// replace the namespace alias value with original namespace value