@sap/cds-dk 9.9.2 → 9.9.3

package/CHANGELOG.md

@@ -6,6 +6,13 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## Version 9.9.3 - 2026-06-29
+
+### Fixed
+
+- `cds import` for OData v2 now can import annotations.
+- `cds watch` on Windows no longer restarts the server for read-only file opens (antivirus, Windows Search indexer, TypeScript loaders like tsx). A mtime guard now confirms a file was actually written before emitting a `change` event.
+
 ## Version 9.9.2 - 2026-05-28
 
 ### Fixed

package/bin/import.js

@@ -2,7 +2,7 @@ module.exports = Object.assign(_import, {
     _name: 'import',
     options:   [ '--services', '--for', '--out', '--as', '--name', '--include-namespaces', '--dependencies', '--from', '--config', '--destination', '--group', '--into-namespace' ],
     shortcuts: [ '-s',            '-4',    '-o',  '-as',     '-n',                  '-ns',             '-d',undefined,       '-c',       undefined, undefined,                '-2',        '-', '-f', '-b'],
-    flags: [ '--dry', '--force', '--resolve-bindings', '--no-copy', '--no-save', '--keep-namespace', '--data-product', '--edmx', '--rfc', '--odata', '--openapi', '--asyncapi' ],
+    flags: [ '--dry', '--force', '--resolve-bindings', '--no-copy', '--no-save', '--keep-namespace', '--data-product', '--edmx', '--rfc', '--odata', '--openapi', '--asyncapi', '--odata-v2-annotations' ],
     help: `
 # SYNOPSIS
 
@@ -79,6 +79,11 @@ module.exports = Object.assign(_import, {
         Keeps the original namespace from the edmx content instead of using
         the filename by default.
 
+    *--odata-v2-annotations*
+        Imports OData annotations into the CSN output. For OData V2, annotations
+        are not imported by default and must be explicitly enabled with this flag.
+        For OData V4, annotations are always imported.
+
     *-ns | --include-namespaces <string_of_namespaces> or* "\x2A"
         Imports only entities matching to the given list of namespaces.
         For OData V2 attributes with the namespace "sap" & "m" are captured by

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

package/lib/import/odata/v4parser.js

@@ -11,6 +11,7 @@ const ParserContext = require("./ParserContext");
 const ignoreObjects = ["$Reference"]; // add all the objects that needs to be ignored for parsing.
 const { warn, info } = require("../../util/term");
 const MetadataConverterFactory = require("./metadataconverter/MetadataConverterFactory");
+const annotationParser = require("./annotationParser");
 
 const edmPrimitiveTypes = [
     'Edm.Binary', 'Edm.Boolean', 'Edm.Byte', 'Edm.Date', 'Edm.DateTimeOffset',
@@ -56,33 +57,6 @@ const edmToCdsTypeSpecialHandling = {
     'Edm.Stream': 'cds.LargeBinary'
 };
 
-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 _isJson(edmx) {
     let isJson = false;
     try {
@@ -235,52 +209,7 @@ function _updateDataTypeObjectForSpecialHandling(dataTypeObj, 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;
-    }
-    /**
-     * <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;
-    }
+    annotationParser.captureAnnotationInCSN(targetString, annotationObject, csnDefsTargetObject);
 }
 
 function _replaceSpecialCharacters(text) {
@@ -316,170 +245,17 @@ function _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObj
     }
 }
 
-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 _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 _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;
-        }
+    // @Core needs special v4 handling for @Core.OptionalParameter (uses _updateElementObjectForDefaultValue)
+    if (annotationTerm.startsWith('@Core.')) {
+        _resolveCoreTerm(annotationTerm, annotationTermObject, csnDefsTargetObject);
+    } else {
+        annotationParser.parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTargetObject);
     }
-
-    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);
+    return annotationParser.resolveAnnotationTerm(schemaDataAnnotation, parserContext);
 }
 
 /**

package/lib/watch/watcher.js

@@ -46,6 +46,32 @@ module.exports = function watch(paths, { filter, ignore, hotReload } = {}) {
 
   const useNativeRecursive = process.platform === 'darwin' || process.platform === 'win32'
   if (useNativeRecursive) {
+    // On Windows, ReadDirectoryChangesW fires FILE_NOTIFY_CHANGE events for mere
+    // file opens (antivirus, search indexer, TypeScript loaders) without a write
+    // having occurred, causing spurious server restarts.  Guard by confirming
+    // mtime actually changed before emitting 'change'.  The cache is seeded on
+    // the first event for each path so buffered pre-startup events are suppressed.
+    // Mac uses kqueue/FSEvents which only fires on real writes — no guard needed.
+    const _mtimes = process.platform === 'win32' ? new Map() : null
+    const _watcherStart = _mtimes && Date.now()
+    const _changedOnDisk = _mtimes
+      ? async fullPath => {
+        try {
+          const { mtimeMs } = await fs.promises.stat(fullPath)
+          const prev = _mtimes.get(fullPath)
+          _mtimes.set(fullPath, mtimeMs)
+          if (prev === undefined) return false          // first event: seed cache, suppress
+          if (prev === mtimeMs) return false            // mtime unchanged: read-only open
+          if (mtimeMs < _watcherStart) return false    // older than watcher: buffered OS event
+          return true
+        } catch (err) {
+          _mtimes.delete(fullPath)
+          if (err.code !== 'ENOENT' && err.code !== 'ENOTDIR') throw err
+          return true  // stat failed (deleted file): let it through
+        }
+      }
+      : () => true  // non-Windows: always emit
+
     const _watch = async root => {
       try {
         if (!fs.existsSync(root)) return
@@ -56,7 +82,7 @@ module.exports = function watch(paths, { filter, ignore, hotReload } = {}) {
           const fullPath = resolve(root, name)
           if (_hotReload(fullPath)) {
             ee.emit('refreshModel', fs.existsSync(fullPath) ? 'update' : 'remove', fullPath)
-          } else if (_allow(fullPath) && _narrowJSONreloads(fullPath)) {
+          } else if (_allow(fullPath) && _narrowJSONreloads(fullPath) && await _changedOnDisk(fullPath)) {
             ee.emit('change', fs.existsSync(fullPath) ? 'update' : 'remove', fullPath)
           }
         }

package/npm-shrinkwrap.json

@@ -1,18 +1,18 @@
 {
   "name": "@sap/cds-dk",
-  "version": "9.9.2",
+  "version": "9.9.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@sap/cds-dk",
-      "version": "9.9.2",
+      "version": "9.9.3",
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@cap-js/asyncapi": "^1.0.0",
         "@cap-js/openapi": "^1.0.0",
-        "@sap/cds": "^8.3 || ^9",
-        "@sap/cds-mtxs": "^2 || ^3",
+        "@sap/cds": "^9",
+        "@sap/cds-mtxs": "^3",
         "@sap/hdi-deploy": "^5",
         "express": "^4.22.1 || ^5",
         "hdb": "^2.0.0",
@@ -28,13 +28,13 @@
         "cds-tsx": "bin/cds-tsx.js"
       },
       "optionalDependencies": {
-        "@cap-js/sqlite": ">=1"
+        "@cap-js/sqlite": "^1 || ^2"
       }
     },
     "node_modules/@cap-js/asyncapi": {
-      "version": "1.0.3",
-      "integrity": "sha512-vZSWKAe+3qfvZDXV5SSFiObGWmqyS9MDyEADb5PLVT8kzO39qGaSDPv/GzI/gwvRfCayGAjU4ThiBKrFA7Gclg==",
-      "license": "SEE LICENSE IN LICENSE",
+      "version": "1.1.0",
+      "integrity": "sha512-ywO5NfGwoeEx6/jneOMpNMs4PFmuueet8HOEg13VAiXpu4W5juAZQ/Jv2xE0QcW9m1qiCmI1ymypmz7UI+YGbw==",
+      "license": "Apache-2.0",
       "peerDependencies": {
         "@sap/cds": ">=7.6"
       }
@@ -52,8 +52,8 @@
       }
     },
     "node_modules/@cap-js/openapi": {
-      "version": "1.4.2",
-      "integrity": "sha512-Mi02XsSlLy+h9tBLPX1/re2Obsmb1rnIj18AUb1jD5dLvbfedfDojtsuZIQHQImdYNeD6nMgaBQw0g1JRHTdow==",
+      "version": "1.5.0",
+      "integrity": "sha512-JDzENNC80vnP9W31Skz6PfgPnpaxNTgIP8CtDK3bJ0FCbr5sXshRqes1pc17kNMXDbJAtEshS0dN7GYBW2THWA==",
       "license": "Apache-2.0",
       "dependencies": {
         "pluralize": "^8.0.0"
@@ -129,8 +129,8 @@
       }
     },
     "node_modules/@sap/cds-compiler": {
-      "version": "6.9.2",
-      "integrity": "sha512-Qv7Zb3RhG92WVm1AjHEJaYbOi3tNT051/EWPYTsYdUe5epYXbR4dJfGpD1eEgo82ThrKCFx0BZfT0b28t0/vqg==",
+      "version": "6.9.3",
+      "integrity": "sha512-8fEeM6D059ruqLWoJqzFSNLkGoUCMnycx7Zv4OP4nA9zZeHzFC3nAe6s3ak2kASSiub1xAMMPzDE/9EnSXQKLw==",
       "license": "SEE LICENSE IN LICENSE",
       "bin": {
         "cdsc": "bin/cdsc.js",
@@ -150,8 +150,8 @@
       }
     },
     "node_modules/@sap/cds-mtxs": {
-      "version": "3.9.3",
-      "integrity": "sha512-NdL+ctu1YmxRMFFk8ip3PZHXxIrDv93gK+ZUE+e5B+9MNDvalQcav4QllqwiGJ/CJcfJROWGTt+a554A81dxow==",
+      "version": "3.9.4",
+      "integrity": "sha512-A3FRCGCMNhml8MLpGv+OUHwDhAUgvAiE38qdTL87/KQ932CTNZ1frohQtT24iszoamB7NI8lp9RR3BFD6HR/FQ==",
       "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
         "@sap/hdi-deploy": "^5"
@@ -188,15 +188,15 @@
       }
     },
     "node_modules/@sap/hdi-deploy": {
-      "version": "5.6.1",
-      "integrity": "sha512-+qQ7qwG8lko303L5yRj2dud/nDAVuVblV/mmzJT44oPbF0Nry18eD2LUS23hFeuxjRa7rYK5YKQ8ffGgWxVrYQ==",
-      "license": "See LICENSE file",
+      "version": "5.7.0",
+      "integrity": "sha512-ENBCtCBnJEKBlvC5mQT/G7OAteOENo7ygSeRJgVdz7AHikcHUxegtavXkJtFCJ/PSjpjytFKfGRmG8peUVAmNQ==",
+      "license": "SEE LICENSE IN LICENSE",
       "dependencies": {
-        "@sap/hdi": "^4.8.0",
+        "@sap/hdi": "^4.8.1",
         "@sap/xsenv": "^6.0.0",
         "async": "^3.2.6",
         "dotenv": "^16.4.5",
-        "handlebars": "^4.7.8",
+        "handlebars": "^4.7.9",
         "micromatch": "^4.0.8"
       },
       "engines": {
@@ -274,8 +274,8 @@
       "optional": true
     },
     "node_modules/better-sqlite3": {
-      "version": "12.10.0",
-      "integrity": "sha512-CyzaZRQKyHkB2ZInfTTl2nvT33EbDpjkLEbE8/Zck3Ll6O0qqvuGdrJ45HgtH+HykRg88ITY3AdreBGN70aBSQ==",
+      "version": "12.11.1",
+      "integrity": "sha512-dq9AtApgg5PGFtBzPFSBl3HZQjHok5gaQCM6zh2Yk0aSmDCs1CbnVI8/HgASQkNKsWFpseIO9beg5xxpYhbIfA==",
       "hasInstallScript": true,
       "license": "MIT",
       "optional": true,
@@ -308,20 +308,32 @@
       }
     },
     "node_modules/body-parser": {
-      "version": "2.2.2",
-      "integrity": "sha512-oP5VkATKlNwcgvxi0vM0p/D3n2C3EReYVX+DNYs5TjZFn/oQt2j+4sVJtSMr18pdRr8wjTcBl6LoV+FUwzPmNA==",
+      "version": "2.3.0",
+      "integrity": "sha512-2cGmJupaNgg+QUwVLAucDuWuoMZ6EX9iHDRswZ5lsNYEmwPaRknMPCLZz07yTzVq/83p4o/wzbDZbBrTvGGTIw==",
       "license": "MIT",
       "dependencies": {
         "bytes": "^3.1.2",
-        "content-type": "^1.0.5",
+        "content-type": "^2.0.0",
         "debug": "^4.4.3",
-        "http-errors": "^2.0.0",
-        "iconv-lite": "^0.7.0",
+        "http-errors": "^2.0.1",
+        "iconv-lite": "^0.7.2",
         "on-finished": "^2.4.1",
-        "qs": "^6.14.1",
-        "raw-body": "^3.0.1",
-        "type-is": "^2.0.1"
+        "qs": "^6.15.2",
+        "raw-body": "^3.0.2",
+        "type-is": "^2.1.0"
+      },
+      "engines": {
+        "node": ">=18"
       },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/body-parser/node_modules/content-type": {
+      "version": "2.0.0",
+      "integrity": "sha512-j/O/d7GcZCyNl7/hwZAb606rzqkyvaDctLmckbxLzHvFBzTJHuGEdodATcP3yIRoDrLHkIATJuvzbFlp/ki2cQ==",
+      "license": "MIT",
       "engines": {
         "node": ">=18"
       },
@@ -817,8 +829,8 @@
       }
     },
     "node_modules/hasown": {
-      "version": "2.0.3",
-      "integrity": "sha512-ej4AhfhfL2Q2zpMmLo7U1Uv9+PyhIZpgQLGT1F9miIGmiCJIoCgSmczFdrc97mWT4kVY72KA+WnnhJ5pghSvSg==",
+      "version": "2.0.4",
+      "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==",
       "license": "MIT",
       "dependencies": {
         "function-bind": "^1.1.2"
@@ -828,8 +840,8 @@
       }
     },
     "node_modules/hdb": {
-      "version": "2.27.1",
-      "integrity": "sha512-xYL/W+fq2TyGHyzm8muolQnw8tdh4+2NQ8mQP2FpLSuhfJ8l0jQNSUZoAXic7NfMEan1Jvf8V1L4blwkgTc6+A==",
+      "version": "2.29.4",
+      "integrity": "sha512-9L7/xjx4NU2YWatqLSHXhuEIuvNlV/4eRFg7u/L63U1Dc5LocP4yWeH8UGKTLBCJkt548OQ+A7PqqimZwEuqdw==",
       "license": "Apache-2.0",
       "dependencies": {
         "iconv-lite": "0.7.0"
@@ -1212,11 +1224,12 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.15.2",
-      "integrity": "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw==",
+      "version": "6.15.3",
+      "integrity": "sha512-O9gl3zCl5h5blw1KGUzQKhA5oUXSl8rwUIM5o0S3nCXMliSvy5Dzx7/DJcI+SwgICv+IneSZwhBh1oSyEHA71A==",
       "license": "BSD-3-Clause",
       "dependencies": {
-        "side-channel": "^1.1.0"
+        "es-define-property": "^1.0.1",
+        "side-channel": "^1.1.1"
       },
       "engines": {
         "node": ">=0.6"
@@ -1325,8 +1338,8 @@
       }
     },
     "node_modules/semver": {
-      "version": "7.8.1",
-      "integrity": "sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==",
+      "version": "7.8.5",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
       "devOptional": true,
       "license": "ISC",
       "bin": {
@@ -1385,13 +1398,13 @@
       "license": "ISC"
     },
     "node_modules/side-channel": {
-      "version": "1.1.0",
-      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "version": "1.1.1",
+      "integrity": "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ==",
       "license": "MIT",
       "dependencies": {
         "es-errors": "^1.3.0",
-        "object-inspect": "^1.13.3",
-        "side-channel-list": "^1.0.0",
+        "object-inspect": "^1.13.4",
+        "side-channel-list": "^1.0.1",
         "side-channel-map": "^1.0.1",
         "side-channel-weakmap": "^1.0.2"
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds-dk",
-  "version": "9.9.2",
+  "version": "9.9.3",
   "description": "Command line client and development toolkit for the SAP Cloud Application Programming Model",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -19,8 +19,8 @@
   "dependencies": {
     "@cap-js/asyncapi": "^1.0.0",
     "@cap-js/openapi": "^1.0.0",
-    "@sap/cds": "^8.3 || ^9",
-    "@sap/cds-mtxs": "^2 || ^3",
+    "@sap/cds": "^9",
+    "@sap/cds-mtxs": "^3",
     "@sap/hdi-deploy": "^5",
     "express": "^4.22.1 || ^5",
     "hdb": "^2.0.0",
@@ -31,7 +31,7 @@
     "yaml": "^2"
   },
   "optionalDependencies": {
-    "@cap-js/sqlite": ">=1"
+    "@cap-js/sqlite": "^1 || ^2"
   },
   "files": [
     "bin/",