@sap/cds-dk 8.1.1 → 8.2.0

package/lib/import/odata/index.js

@@ -61,7 +61,7 @@ async function edmx2csn(edmx, filename, context) {
 		namespace = (index > 0) ? result[1].substring(0, index) : result[1];
 	}
 	else {
-		// to support edmx without entities - unbounded actions and functions only
+		// to support edmx without entities - unbound actions and functions only
 		console.warn('There are no entities in the OData model');
 		let schema = edmx.match(/(<Schema [^>]*>)/);
 		if (!schema) throw new Error(messages.INVALID_EDMX_METADATA);

package/lib/import/odata/v2parser.js

@@ -303,21 +303,21 @@ function _getFunctionAttributes(functionImport, serviceNamespaceParam) {
 }
 
 function _extractFunctionImport(functionImport, parserContext) {
-	//extracting the bounded and unbounded function import
-	let boundedFunctionImports = [];
+	//extracting the bound and unbound function import
+	let boundFunctionImports = [];
 	let entityName;
 	Object.keys(functionImport).forEach((key) => {
 		if (key === "_attributes") {
 			if (functionImport[key]["sap:action-for"]) {
-				//storing bounded function imports 
+				//storing bound function imports 
 				entityName = _extractEntityFromNamespace(functionImport[key]["sap:action-for"]);
-				boundedFunctionImports = (parserContext.allFunctionImportsMap[entityName])
+				boundFunctionImports = (parserContext.allFunctionImportsMap[entityName])
 					? parserContext.allFunctionImportsMap[entityName] : [];
-				boundedFunctionImports.push(_getFunctionAttributes(functionImport, ""));
-				parserContext.allFunctionImportsMap[entityName] = boundedFunctionImports;
+				boundFunctionImports.push(_getFunctionAttributes(functionImport, ""));
+				parserContext.allFunctionImportsMap[entityName] = boundFunctionImports;
 			}
 			else {
-				//storing unbounded function imports
+				//storing unbound function imports
 				parserContext.allFunctionImports.push(
 					_getFunctionAttributes(functionImport, parserContext.serviceNamespace + ".")
 				);
@@ -786,7 +786,7 @@ function _parseParametersFunctionImport(parameters, entityKeysList, parserContex
 	return csn;
 }
 
-function _getFunctionImport(functionImport, isBounded, entityKeysList, parserContext) {
+function _getFunctionImport(functionImport, isBound, entityKeysList, parserContext) {
 	let noValue;
 	let csn = "";
 	csn = csn + '"' + functionImport[0] + '": { \n';
@@ -803,10 +803,10 @@ function _getFunctionImport(functionImport, isBounded, entityKeysList, parserCon
 		return "";
 	}
 	csn = csn + '"';
-	if (!isBounded) csn = csn + ',\n"@cds.external": true';
+	if (!isBound) csn = csn + ',\n"@cds.external": true';
 
 	if (functionImport[3] !== -1) {
-		if (isBounded === 0 || (isBounded === 1 && functionImport[3] instanceof Array)) {
+		if (isBound === 0 || (isBound === 1 && functionImport[3] instanceof Array)) {
 			let parametersCsn = _parseParametersFunctionImport(functionImport[3], entityKeysList, parserContext);
 			if (parametersCsn != "") {
 				csn = csn + ", \n";
@@ -846,12 +846,12 @@ function _getFunctionImport(functionImport, isBounded, entityKeysList, parserCon
 	return csn;
 }
 
-function _getAllFunctionImports(functionImports, isBounded, entityKeysList, parserContext) {
+function _getAllFunctionImports(functionImports, isBound, entityKeysList, parserContext) {
 	let functionImportsCSN = "";
 	let i;
 	let functionImportCSN = "";
 	for (i = 0; i < functionImports.length; i++) {
-		functionImportCSN = _getFunctionImport(functionImports[i], isBounded, entityKeysList, parserContext);
+		functionImportCSN = _getFunctionImport(functionImports[i], isBound, entityKeysList, parserContext);
 		functionImportsCSN = functionImportsCSN + functionImportCSN;
 		if (i !== functionImports.length - 1 && functionImportCSN !== "") {
 			functionImportsCSN = functionImportsCSN + ",\n";
@@ -1439,7 +1439,7 @@ function _constructServiceEntity(
 		}
 	}
 
-	// if the function import is bounded to entitySet 
+	// if the function import is bound to entitySet 
 	if (parserContext.allFunctionImportsMap[entityName]) {	
 		csnEntity = csnEntity + ', \n "actions": {\n';
 		csnEntity = csnEntity + 
@@ -1448,7 +1448,7 @@ function _constructServiceEntity(
 			);
 		csnEntity = csnEntity + "}";
 	}
-	// if the function import is bounded to entityType
+	// if the function import is bound to entityType
 	else if (parserContext.allFunctionImportsMap[_extractEntityFromNamespace(parserContext.allEntitySetMap[entityName])]) {
 		csnEntity = csnEntity + ', \n "actions": {\n';
 		csnEntity = csnEntity +
@@ -1650,7 +1650,8 @@ function _generateEDMXJSON2CSN(jsonObj, ignorePersistenceSkip, parserContext) {
 	}
 
 	// Construct CSN entity based on EDMX entity
-	const entityJson = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityType;
+	let entityJson = jsonObj["edmx:Edmx"]["edmx:DataServices"].Schema.EntityType;	
+	if (!Array.isArray(entityJson)) entityJson = [entityJson];
 	const definitions = [];
 
 	if (parserContext.mockServerUc) {
@@ -1695,9 +1696,9 @@ function _generateEDMXJSON2CSN(jsonObj, ignorePersistenceSkip, parserContext) {
 		definitions.push(_getServiceComplexTypes(parserContext));
 	}
 
-	// if there are unbounded function imports
+	// if there are unbound function imports
 	if (Object.keys(parserContext.allFunctionImports).length > 0) {
-		// passing 0 for unbounded actions/functions and 0 for entityKeysList 
+		// passing 0 for unbound actions/functions and 0 for entityKeysList 
 		definitions.push(
 			_getAllFunctionImports(parserContext.allFunctionImports, 0, 0, parserContext)
 		);

package/lib/import/odata/v4parser.js

@@ -83,8 +83,8 @@ const known_vocabularies = {
 };
 
 function _initialize(parserContext) {
-    parserContext.unboundedActions = {};
-    parserContext.unboundedFunctions = {};
+    parserContext.unboundActions = {};
+    parserContext.unboundFunctions = {};
     parserContext.entityTypes = [];
     parserContext.entityTypeOpenEntries = [];
     parserContext.complexTypeOpenEntries = [];
@@ -100,8 +100,8 @@ function _initialize(parserContext) {
     parserContext.schemaAliasToNamespace = {};
     parserContext.schemaToSchemaDataIndex = {};
     parserContext.vocabNamespaceToAlias = {};
-    parserContext.entityToBoundedActions = {};
-    parserContext.entityToBoundedFunctions = {};
+    parserContext.entityToBoundActions = {};
+    parserContext.entityToBoundFunctions = {};
     parserContext.entityContainerAnnotations = {};
     parserContext.mockServerUc = true;
     parserContext.beta = false;
@@ -911,9 +911,9 @@ function _parseParameterAndReturnTypeContent(elementObject, parserContext) {
     }
 }
 
-function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, parserContext) {
+function _generateCSNForBoundActionFunction(actionFunctionObject, kind, parserContext) {
     const csnObj = {};
-    const isBounded = actionFunctionObject.$IsBound;
+    const isBound = actionFunctionObject.$IsBound;
     const parameters = actionFunctionObject.$Parameter;
     const returnType = actionFunctionObject.$ReturnType;
 
@@ -932,7 +932,7 @@ function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, parser
              * 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 (isBound && index === 0) {
                 if (isCollection) {
                     csnObj.params[parameters[index].$Name].items.type = '$self';
                 }
@@ -949,20 +949,20 @@ function _generateCSNForBoundedActionFunction(actionFunctionObject, kind, parser
     return csnObj;
 }
 
-function _parseBoundedActionFunction(schemaData, csnObj, kind, parserContext) {
-    const boundedObject = (kind === 'action') ? parserContext.entityToBoundedActions : parserContext.entityToBoundedFunctions;
+function _parseBoundActionFunction(schemaData, csnObj, kind, parserContext) {
+    const boundObject = (kind === 'action') ? parserContext.entityToBoundActions : parserContext.entityToBoundFunctions;
 
-    Object.keys(boundedObject).forEach(fqEntityName => {
+    Object.keys(boundObject).forEach(fqEntityName => {
         const [schemaName, ] = _extractSchemaNameAndElementName(fqEntityName);
 
         if (schemaName === schemaData.$SchemaNamespace) {
-            const actionFunctionObjectList = boundedObject[fqEntityName];
+            const actionFunctionObjectList = boundObject[fqEntityName];
 
             if (!csnObj[fqEntityName].actions) {
                 csnObj[fqEntityName].actions = {};
             }
             Object.keys(actionFunctionObjectList).forEach(actionFunctionName => {
-                csnObj[fqEntityName].actions[actionFunctionName] = _generateCSNForBoundedActionFunction(
+                csnObj[fqEntityName].actions[actionFunctionName] = _generateCSNForBoundActionFunction(
                     actionFunctionObjectList[actionFunctionName], kind, parserContext
                 );
             });
@@ -970,15 +970,15 @@ function _parseBoundedActionFunction(schemaData, csnObj, kind, parserContext) {
     });
 }
 
-function _parseUnBoundedActionFunction(schemaData, kind, parserContext) {
-    const unBoundedObject = (kind === 'action') ? parserContext.unboundedActions : parserContext.unboundedFunctions;
+function _parseUnboundActionFunction(schemaData, kind, parserContext) {
+    const unboundObject = (kind === 'action') ? parserContext.unboundActions : parserContext.unboundFunctions;
     const csnObj = {};
 
-    Object.keys(unBoundedObject).forEach(fqName => {
+    Object.keys(unboundObject).forEach(fqName => {
         const [schemaName, ] = _extractSchemaNameAndElementName(fqName);
 
         if (schemaName === schemaData.$SchemaNamespace) {
-            const actionFunctionObject = unBoundedObject[fqName];
+            const actionFunctionObject = unboundObject[fqName];
             const parameters = actionFunctionObject.$Parameter;
             const returnType = actionFunctionObject.$ReturnType;
 
@@ -1129,7 +1129,7 @@ function _resolveActionFunctionAnnotationTarget(targetPath, csnDefs, hasParamete
     const fqActFunName = _resolveAliasedElementName(elemNameList[0], parserContext);
     const paramName = hasParameter ? targetPath.split('/')[1] : null;
 
-    // unbounded action or function
+    // unbound action or function
     if (csnDefs[fqActFunName]) {
         // with parameter
         if (hasParameter && csnDefs[fqActFunName].params[paramName]) {
@@ -1140,7 +1140,7 @@ function _resolveActionFunctionAnnotationTarget(targetPath, csnDefs, hasParamete
             return csnDefs[fqActFunName];
         }
     }
-    // bounded action or function
+    // bound action or function
     else {
         const [, elementName] = _extractSchemaNameAndElementName(fqActFunName);
         const isCollection = elemNameList[1] === 'Collection' ? true : false;
@@ -1388,10 +1388,10 @@ function _collectAllParameters(dataObjList) {
  * @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.
+ * 1. Unbound Actions can't have collision. Action name must be unique.
+ * 2. Unbound Functions can have collision; capture the max number of parameters.
  */
-function _populateUnboundedActionFunction(isAction, fqName, schemaDataList, parserContext) {
+function _populateUnboundActionFunction(isAction, fqName, schemaDataList, parserContext) {
     let [schemaName, actFunName] = _extractSchemaNameAndElementName(fqName);
     let indexOfSchema;
     [indexOfSchema, schemaName] = _getIndexAndNamespaceOfSchema(fqName, schemaName, parserContext);
@@ -1401,33 +1401,33 @@ function _populateUnboundedActionFunction(isAction, fqName, schemaDataList, pars
 
     if (isAction) {
         if (dataList.length === 1) {
-            parserContext.unboundedActions[fqName] = actionFunctionObject;
+            parserContext.unboundActions[fqName] = actionFunctionObject;
         }
         else {
-            throw new Error(messages.UNBOUNDED_ACTION_COLLISION + `'${actFunName}' of Schema: ${schemaName} `);
+            throw new Error(messages.UNBOUND_ACTION_COLLISION + `'${actFunName}' of Schema: ${schemaName} `);
         }
     }
     else {
         if (dataList.length > 1) {
             actionFunctionObject['$Parameter'] = _collectAllParameters(dataList);
-            parserContext.unboundedFunctions[fqName] = actionFunctionObject;
+            parserContext.unboundFunctions[fqName] = actionFunctionObject;
         }
         else {
-            parserContext.unboundedFunctions[fqName] = actionFunctionObject;
+            parserContext.unboundFunctions[fqName] = actionFunctionObject;
         }
         // throw error if the return type is missing
-        if (!parserContext.unboundedFunctions[fqName].$ReturnType) {
+        if (!parserContext.unboundFunctions[fqName].$ReturnType) {
             throw new Error(messages.NO_RETURN_TYPE + actFunName);
         }
     }
 }
 
-function _collectUnboundedActionFunction(schemaDataList, parserContext) {
+function _collectUnboundActionFunction(schemaDataList, parserContext) {
     for (let actionName of parserContext.actionToActionImportMap.keys()) {
-        _populateUnboundedActionFunction(true, actionName, schemaDataList, parserContext);
+        _populateUnboundActionFunction(true, actionName, schemaDataList, parserContext);
     }
     for (let functionName of parserContext.functionToFunctionImportMap.keys()) {
-        _populateUnboundedActionFunction(false, functionName, schemaDataList, parserContext);
+        _populateUnboundActionFunction(false, functionName, schemaDataList, parserContext);
     }
 }
 
@@ -1435,22 +1435,22 @@ function _collectUnboundedActionFunction(schemaDataList, parserContext) {
  * @param {Boolean} isAction
  * @param {String} currNamespace
  * @param {String} elementName
- * @param {List<Object>} elementDataList, bounded action/function details
+ * @param {List<Object>} elementDataList, bound action/function details
  * @param {Object} parserContext
  *
- * Scenarios for bounded actions, functions:
+ * Scenarios for bound 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.
+ * Special scenario is when same function name is bound to different entity as well.
  */
-function _collectBoundedActionFunction(isAction, currNamespace, elementName, elementDataList, parserContext) {
+function _collectBoundActionFunction(isAction, currNamespace, elementName, elementDataList, parserContext) {
     let functionObjList; // list to collect all the collision obj for function
 
     for (let i = 0; i < elementDataList.length; i++) {
         let dataObj = elementDataList[i];
-        let boundedEntityName = dataObj.$Parameter[0].$Type;
+        let boundEntityName = dataObj.$Parameter[0].$Type;
         let entityTypeNamespace = currNamespace;
-        let [schemaName, entityName] = _extractSchemaNameAndElementName(boundedEntityName);
+        let [schemaName, entityName] = _extractSchemaNameAndElementName(boundEntityName);
 
         // binding parameter type should be within the available namespaces in the scope of a document.
         if (entityTypeNamespace !== schemaName && entityTypeNamespace !== parserContext.schemaAliasToNamespace[schemaName]) {
@@ -1463,35 +1463,35 @@ function _collectBoundedActionFunction(isAction, currNamespace, elementName, ele
             else if (parserContext.schemaAliasToNamespace[schemaName]) {
                 entityTypeNamespace = parserContext.schemaAliasToNamespace[schemaName];
             } else {
-                throw new Error(messages.INVALID_BOUNDED_PARAM_TYPE + ` Check the Element: ${elementName} of Schema: ${currNamespace} `);
+                throw new Error(messages.INVALID_BOUND_PARAM_TYPE + ` Check the Element: ${elementName} of Schema: ${currNamespace} `);
             }
         }
 
         if (!parserContext.entityTypes.includes(entityTypeNamespace + '.' + entityName)) {
-            throw new Error(messages.UNRESOLVED_TYPE + boundedEntityName);
+            throw new Error(messages.UNRESOLVED_TYPE + boundEntityName);
         }
-        boundedEntityName = entityTypeNamespace + '.' + entityName;
+        boundEntityName = entityTypeNamespace + '.' + entityName;
 
         if (isAction) {
-            if (!parserContext.entityToBoundedActions[boundedEntityName]?.[elementName]) {
-                if (!parserContext.entityToBoundedActions[boundedEntityName]) {
-                    parserContext.entityToBoundedActions[boundedEntityName] = {};
+            if (!parserContext.entityToBoundActions[boundEntityName]?.[elementName]) {
+                if (!parserContext.entityToBoundActions[boundEntityName]) {
+                    parserContext.entityToBoundActions[boundEntityName] = {};
                 }
-                parserContext.entityToBoundedActions[boundedEntityName][elementName] = dataObj;
+                parserContext.entityToBoundActions[boundEntityName][elementName] = dataObj;
             }
             else {
-                throw new Error(messages.BOUNDED_ACTION_COLLISION + ` Check the Element: ${elementName} of Schema: ${currNamespace} `);
+                throw new Error(messages.BOUND_ACTION_COLLISION + `${elementName} in entity ${entityName} of schema ${currNamespace}.`);
             }
         }
         else {
-            if (!parserContext.entityToBoundedFunctions[boundedEntityName]?.[elementName]) {
-                if (!parserContext.entityToBoundedFunctions[boundedEntityName]) {
-                    parserContext.entityToBoundedFunctions[boundedEntityName] = {};
+            if (!parserContext.entityToBoundFunctions[boundEntityName]?.[elementName]) {
+                if (!parserContext.entityToBoundFunctions[boundEntityName]) {
+                    parserContext.entityToBoundFunctions[boundEntityName] = {};
                 }
-                if (!functionObjList || !parserContext.entityToBoundedFunctions[boundedEntityName][elementName]) {
+                if (!functionObjList || !parserContext.entityToBoundFunctions[boundEntityName][elementName]) {
                     functionObjList = [];
                 }
-                parserContext.entityToBoundedFunctions[boundedEntityName][elementName] = dataObj;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName] = dataObj;
                 functionObjList.push(dataObj);
             }
             else {
@@ -1499,10 +1499,10 @@ function _collectBoundedActionFunction(isAction, currNamespace, elementName, ele
                 let functionObject = functionObjList[0];
                 functionObject['$Parameter'] = _collectAllParameters(functionObjList);
                 functionObjList = [functionObject]; // reset the function object list with recently formed object
-                parserContext.entityToBoundedFunctions[boundedEntityName][elementName] = functionObject;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName] = functionObject;
             }
             // throw error if the return type is missing
-            if (!parserContext.entityToBoundedFunctions[boundedEntityName][elementName].$ReturnType) {
+            if (!parserContext.entityToBoundFunctions[boundEntityName][elementName].$ReturnType) {
                 throw new Error(messages.NO_RETURN_TYPE + elementName);
             }
         }
@@ -1515,10 +1515,10 @@ function _collectBoundedActionFunction(isAction, currNamespace, elementName, ele
  * @param {Object} parserContext, contains parser level context informations
  */
 function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
-    // This array is used to store the parameter values which will be used later to call _collectBoundedActionFunction.
+    // This array is used to store the parameter values which will be used later to call _collectBoundActionFunction.
     let boundActionFunctionDetails = [];
 
-    _collectUnboundedActionFunction(schemaDataList, parserContext);
+    _collectUnboundActionFunction(schemaDataList, parserContext);
 
     // capture all the references
     if (edmxAsJson.$Reference) {
@@ -1527,7 +1527,7 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
         });
     }
 
-    // collect entityType, enumType, complexType, typeDefinition, bounded action/function, annotations
+    // collect entityType, enumType, complexType, typeDefinition, bound action/function, annotations
     for (let schemaData of schemaDataList) {
         let currNamespace = schemaData.$SchemaNamespace;
 
@@ -1540,7 +1540,7 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
                 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
+                // bound actions/functions
                 else if (elementData instanceof Array) {
                     let isAction = elementData[0].$Kind === 'Action' ? true : false;
                     if (elementData[0].$IsBound) {
@@ -1570,9 +1570,9 @@ function _collectSchemaElements(edmxAsJson, schemaDataList, parserContext) {
             }
         });
     }
-    // This will delay the execution of _collectBoundedActionFunction, as we need to collect all the entityTypes first.
+    // This will delay the execution of _collectBoundActionFunction, as we need to collect all the entityTypes first.
     boundActionFunctionDetails.forEach(paramValues => {
-        _collectBoundedActionFunction(...paramValues, parserContext);
+        _collectBoundActionFunction(...paramValues, parserContext);
     });
 }
 
@@ -1651,12 +1651,12 @@ function _generateCSN(edmxAsJson, ignorePersistenceSkip, parserContext, importer
         csn.definitions = Object.assign(_parserCSNForComplexType(schemaData, parserContext), csn.definitions);
         // Step 4: parse all entity type
         csn.definitions = Object.assign(_parseCSNForEntityType(schemaData, ignorePersistenceSkip, parserContext), csn.definitions);
-        // Step 5: parse all bounded action & function
-        _parseBoundedActionFunction(schemaData, csn.definitions, 'action', parserContext);
-        _parseBoundedActionFunction(schemaData, csn.definitions, 'function', parserContext);
-        // Step 6: parse all unbounded action & function
-        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'action', parserContext), csn.definitions);
-        csn.definitions = Object.assign(_parseUnBoundedActionFunction(schemaData, 'function', parserContext), csn.definitions);
+        // Step 5: parse all bound action & function
+        _parseBoundActionFunction(schemaData, csn.definitions, 'action', parserContext);
+        _parseBoundActionFunction(schemaData, csn.definitions, 'function', parserContext);
+        // Step 6: parse all unbound action & function
+        csn.definitions = Object.assign(_parseUnboundActionFunction(schemaData, 'action', parserContext), csn.definitions);
+        csn.definitions = Object.assign(_parseUnboundActionFunction(schemaData, 'function', parserContext), csn.definitions);
         // Step 7: parse all annotations
         if (schemaData.$Annotations) {
             _parseAnnotations(schemaData.$Annotations, csn.definitions, parserContext);

package/lib/init/constants.js

@@ -5,7 +5,7 @@ module.exports = {
     COMMAND_ADD: 'add',
 
     JAVA_LTS_VERSIONS: [17, 21],
-    MAVEN_ARCHETYPE_VERSION: '3.1.1',
+    MAVEN_ARCHETYPE_VERSION: '3.2.0',
 
     OPTIONS: Object.freeze({
         COMPLETION: 'completion',
@@ -72,7 +72,8 @@ module.exports = {
         MAVEN_INSTALL_HELP: `https://maven.apache.org/install.html`,
         CAP_JS_COMMUNITY_ODATA_V2: 'https://github.com/cap-js-community/odata-v2-adapter',
         CAP_JS_COMMUNITY_EVENT_QUEUE: 'https://github.com/cap-js-community/event-queue',
-        CAP_JS_COMMUNITY_WEBSOCKET: 'https://github.com/cap-js-community/websocket'
+        CAP_JS_COMMUNITY_WEBSOCKET: 'https://github.com/cap-js-community/websocket',
+        CF_CLI: 'https://github.com/cloudfoundry/cli'
     }),
 
     PROJECT_FILES: ['package.json', 'pom.xml', '.cdsrc.json']

package/lib/init/mvn.js

@@ -1,4 +1,5 @@
 const util = require('util')
+const path = require('path');
 const { exec } = require('child_process')
 const execAsync = util.promisify(exec)
 
@@ -6,7 +7,7 @@ const term = require('../util/term')
 const cmd = require('../util/command')
 
 const cds = require('../cds')
-const DEBUG = cds.debug('cli|init|add|mvn')
+const LOG = cds.log('cli|init|add|mvn'), DEBUG = cds.debug('cli|init|add|mvn')
 
 const { URLS, MAVEN_ARCHETYPE_VERSION, OPTIONS: { JAVA_PACKAGE, HANA }, REGEX_JAVA_PACKAGE } = require('./constants')
 
@@ -16,9 +17,9 @@ module.exports.add = async function (feature) {
     const { 'java:mvn': javaMvn, force } = cds.cli.options
     if (javaMvn) _scan(javaMvn).forEach(([k,v]) => params.set(k,v))
     const archetypeVersion = params.get('-DarchetypeVersion') ?? MAVEN_ARCHETYPE_VERSION
-    if (feature === HANA) { // REVISIT: compat for HANA when -Dfeature HANA is provided by Java
+    if (feature === HANA) { // REVISIT: compat for HANA until -Dfeature HANA is provided by Java
         params.set(`com.sap.cds:cds-maven-plugin:${archetypeVersion}:addTargetPlatform`)
-        params.set(`-DtargetPlatform`, `cloudfoundry`) // REVISIT: No special handling for HANA
+        params.set(`-DtargetPlatform`, `cloudfoundry`) // REVISIT: Should get rid of CF dependency for Kyma scenarios
     } else {
         params.set(`com.sap.cds:cds-maven-plugin:${archetypeVersion}:add`)
         params.set(`-Dfeature`, feature)
@@ -46,6 +47,7 @@ module.exports.init = async function (projectName, options = cds.cli.options) {
     params.set(`-DarchetypeGroupId`, `com.sap.cds`);
     params.set(`-DarchetypeVersion`, MAVEN_ARCHETYPE_VERSION);
     params.set('-DinteractiveMode', false);
+    if (cds.cli.options['no-db']) params.set('-Dpersistence', false)
 
     // set defaults, might be changed by java:mvn param
     params.set(`-DartifactId`, projectName);
@@ -101,6 +103,41 @@ module.exports.init = async function (projectName, options = cds.cli.options) {
     return { params: _finalize(params), archetypeVersion, artifactId }
 }
 
+module.exports.generate = async function (feature, options = cds.cli.options) {
+    const command = this.generateMvnParams(feature, options)
+    const cwd = options.cwd
+
+    try {
+        console.log(`Executing command: `, term.highlight('mvn ' + command.join(' ')))
+        await cmd.spawnCommand('mvn', command, { cwd: cwd ?? path.join(cds.root, 'srv') })
+        return command
+    } catch (err) {
+        if (err.code === 'ENOENT' && err.path === 'mvn') {
+            throw `Maven executable 'mvn' not found. Follow ${term.info(URLS.MAVEN_INSTALL_HELP)} and install Maven on your machine.`
+        }
+        throw err
+    }
+}
+
+module.exports.generateMvnParams = function (feature, options = cds.cli.options) {
+    const params = new Map()
+
+    const { 'java:mvn': javaMvn, force, filter, out } = options
+    if (javaMvn) _scan(javaMvn).forEach(([k,v]) => params.set(k,v))
+    const archVersion = params.get(`-DarchetypeVersion`) ?? ''
+    params.set(`cds:${archVersion}:generate`)
+
+    switch (feature) {
+        case 'handler':
+            params.set(`-Dcds.generate.feature=EVENT_HANDLERS`)
+            break
+    }
+    if (filter) params.set(`-Dcds.generate.includes=**.${filter.replace(/\*+\.?/, '')}**`)
+    if (out) params.set(`-Dcds.generate.handlers.package=${out.replaceAll('/', '.')}`)
+    if (force) params.set(`-Dcds.generate.overwrite`, true)
+    return _finalize(params)
+}
+
 const sanitize = module.exports.sanitize = name => name
     .toLowerCase()
     .replace(/-/g, '_')
@@ -123,10 +160,10 @@ function _scan(mvnParams) {
 
 function _finalize(params) {
     params.set(`-Dstyle.color`, `always`)
-    if (DEBUG) params.set('-X')
-    if (DEBUG) params.set('-e')
+    if (LOG._debug) params.set('-X')
+    if (LOG._debug) params.set('-e')
     if (process.env.CI) params.set('--batch-mode')
     const final = Array.from(params, ([arg, val]) => val !== null && val !== undefined ? `${arg}=${val}` : arg)
-    DEBUG?.(term.highlight('mvn' + final.join(' ')))
+    DEBUG?.(term.highlight('mvn ' + final.join(' ')))
     return final
 }

package/lib/init/plugin.js

@@ -1,7 +1,6 @@
 const { join } = require('path')
 const cds = require('../cds')
 const { readdir } = cds.utils
-const DEBUG = cds.debug('cli|add')
 
 module.exports = class Plugin {
 
@@ -68,6 +67,7 @@ module.exports = class Plugin {
        –––––––––––– */
 
     async combineSupported() {
+        const DEBUG = cds.log('cli|add')._debug
         DEBUG && console.log()
         DEBUG && console.log('Plugins active for production:')
         const fromDk = await readdir(join(__dirname, './template'))

package/lib/init/projectReader.js

@@ -145,7 +145,7 @@ module.exports = new class ProjectReader {
                     const inbounds = manifest?.['sap.app']?.crossNavigation?.inbounds
                     const [firstInbound] = Object.values(inbounds ?? { intent: { semanticObject: 'Books', action: 'display' }})
                     const vizId = firstInbound.semanticObject + '-' + firstInbound.action
-                    return { app, strippedApp: app.replace(/-/g, ''), vizId, isNotLast: i < apps.length - 1 }
+                    return { app, strippedApp: app.replace(/-/g, ''), vizId, isNotLast: i < apps.length - 1, manifestAppId: manifest?.['sap.app']?.id ?? app}
                 })
             },
             appUIPaths: () => (fs.readdirSync(path.resolve(cds.root, cds.env.folders.app))).filter(e =>

package/lib/init/template/approuter/files/containerize.yaml.hbs

@@ -3,8 +3,13 @@ modules:
   - name: {{appName}}-approuter
     build-parameters:
       buildpack:
+        {{#hasHelmUnifiedRuntime}}
+        builder: proxy-unified-runtime-dmz.int.repositories.cloud.sap/builder/noble
+        {{/hasHelmUnifiedRuntime}}
+        {{^hasHelmUnifiedRuntime}}
         type: nodejs
         builder: builder-jammy-base
+        {{/hasHelmUnifiedRuntime}}
         path: app/router
         env:
           BP_NODE_RUN_SCRIPTS: ""

package/lib/init/template/cloud-logging/files/mta.yaml.hbs

@@ -0,0 +1,25 @@
+---
+modules:
+  - name: {{appName}}-srv
+    type: {{language}}
+    path: {{& srvPath}}
+    requires:
+      - name: {{appName}}-cloud-logging
+  - name: {{appName}}-mtx
+    type: nodejs
+    path: {{#isNodejs}}gen/{{/isNodejs}}mtx/sidecar
+    requires:
+      - name: {{appName}}-cloud-logging
+  - name: {{appName}}
+    type: approuter.nodejs
+    requires:
+      - name: {{appName}}-cloud-logging
+resources:
+  - name: {{appName}}-cloud-logging
+    type: org.cloudfoundry.managed-service
+    parameters:
+      service: cloud-logging
+      service-plan: {{cloudLoggingServicePlan}}
+      config:
+      ingest_otlp:
+        enabled: true

package/lib/init/template/cloud-logging/files/package.json

@@ -0,0 +1,14 @@
+{
+  "dependencies": {
+    "@cap-js/telemetry": ">=0",
+    "@grpc/grpc-js": "^1",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0",
+    "@opentelemetry/host-metrics": "^0"
+  },
+  "cds": {
+    "requires": {
+      "telemetry": "to-cloud-logging"
+    }
+  }
+}