@sap/cds-dk 8.4.2 → 8.5.0

package/lib/build/util.js

@@ -7,6 +7,7 @@ const IS_WIN = require('os').platform() === 'win32'
 const { SEVERITY_ERROR, FILE_EXT_CDS } = require('./constants');
 const DEBUG = cds.debug('cli|build')
 const SECRETS = /(passw)|(cert)|(ca)|(secret)|(key)/i
+const WS_MAX_DEPTH = 2
 
 function getProperty(src, segments) {
     segments = Array.isArray(segments) ? segments : segments.split('.')
@@ -98,13 +99,13 @@ function _redacted(cred) {
     if (!cred) return cred
     if (Array.isArray(cred)) return cred.map(c => typeof c === 'string' ? '...' : _redacted(c))
     if (typeof cred === 'object') {
-      const newCred = Object.assign({}, cred)
-      Object.keys(newCred).forEach(k => (typeof newCred[k] === 'string' && SECRETS.test(k)) ? (newCred[k] = '...') : (newCred[k] = _redacted(newCred[k])))
-      return newCred
+        const newCred = Object.assign({}, cred)
+        Object.keys(newCred).forEach(k => (typeof newCred[k] === 'string' && SECRETS.test(k)) ? (newCred[k] = '...') : (newCred[k] = _redacted(newCred[k])))
+        return newCred
     }
     return cred
 }
-  
+
 /**
  * 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.
@@ -173,28 +174,30 @@ async function pathExists(path) {
     return fs.promises.access(path).then(() => true).catch(() => false);
 }
 
+async function getWorkspacePaths() {
+    const wsRoot = findWorkspaceRoot(cds.root)
+    if (!wsRoot) {
+        return []
+    }
+    return (await getWorkspaces(wsRoot)).filter(ws => cds.root !== path.join(wsRoot, ws)).map(ws => path.join(wsRoot, ws))
+}
+
 /**
  * Returns the list of workspaces defined for the current project. A workspace dependency
  * needs to be defined resulting in a corresponding sym-link.
- * @returns the paths are relative to 'cds.root'.
+ * @returns the paths are relative to 'wsRoot'.
  */
-async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = cds.root) {
-    let pgkJsonWsRoot
-    try {
-        pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
-    } catch (e) {
-        if (e.code === 'MODULE_NOT_FOUND') {
-            DEBUG?.(`No package.json found in project '${wsRoot}', skipping workspace resolution.`)
-            return []
-        }
-        throw e
+async function getWorkspaces(wsRoot, resolve = false, devDependencies = true) {
+    wsRoot ??= findWorkspaceRoot(cds.root)
+    if (!wsRoot) {
+        return []
     }
-
-    const workspaces = []
+    const pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
     let pgkJson = pgkJsonWsRoot
     if (wsRoot !== cds.root) {
         pgkJson = require(path.join(cds.root, 'package.json'))
     }
+    const workspaces = []
     if (pgkJsonWsRoot.workspaces) {
         if (resolve) {
             _validateWsDependencies(wsRoot, pgkJson.dependencies, devDependencies ? pgkJson.devDependencies : {})
@@ -215,6 +218,25 @@ async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = c
     return workspaces
 }
 
+function findWorkspaceRoot(currentPath, depth = 0) {
+    if (depth > WS_MAX_DEPTH) {
+        DEBUG?.(`No workspaces exist, max depth of ${WS_MAX_DEPTH} reached`)
+        return
+    }
+    const packageJson = path.join(currentPath, 'package.json')
+    if (fs.existsSync(packageJson)) {
+        if (require(path.join(currentPath, 'package.json')).workspaces) {
+            return currentPath
+        }
+    }
+    if (fs.existsSync(path.join(currentPath, '.gitmodules'))) {
+        return // project root reached
+    }
+    if (path.dirname(currentPath) !== currentPath) {
+        return findWorkspaceRoot(path.dirname(currentPath), depth + 1)
+    }
+}
+
 /**
  * This JavaScript function filterFeaturePaths is used to filter and categorize file paths 
  * from a given model into two categories: base and features.
@@ -452,7 +474,9 @@ module.exports = {
     getI18nDefaultFolder,
     normalizePath,
     pathExists,
+    getWorkspacePaths,
     getWorkspaces,
+    findWorkspaceRoot,
     filterFeaturePaths,
     getFiles,
     BuildMessage,

package/lib/deploy/to-hana/hdiDeployUtil.js

@@ -1,5 +1,4 @@
 const path = require('path');
-const util = require('util');
 const { bold } = require('../../util/term');
 
 const HDI_DEPLOY_LIB = '@sap/hdi-deploy';
@@ -40,15 +39,20 @@ module.exports = new class HdiDeployUtil {
         if (options.use_hdb === false) options.use_hdb = undefined
         deployerEnv.HDI_DEPLOY_OPTIONS = JSON.stringify(options)
 
-        const asyncDeploy = util.promisify(deploy);
-        const { exitCode, signal } = await asyncDeploy(dbDir, deployerEnv);
-        if (exitCode) {
-            let message = `HDI deployment failed with exit code ${exitCode}`;
-            if (signal) {
-                message += `. ${signal}`;
-            }
-            throw new Error(message);
-        }
+        return await new Promise((resolve, reject) => {
+            deploy(dbDir, deployerEnv, (error, response) => {
+                if (error) return reject(error)
+                if (response?.exitCode) {
+                    let message = `HDI deployment failed with exit code ${response.exitCode}.`
+                    if (response.signal) message += `. ${response.signal}`
+                    return reject(new Error(message))
+                }
+                return resolve()
+            }, {
+              stderrCB: buffer => console.error(buffer.toString()),
+              stdoutCB: buffer => console.log(buffer.toString())
+          })
+        })
     }
 
     _loadHdiDeployLib(cwd) {

package/lib/import/message.js

@@ -28,7 +28,7 @@ const messages = {
 	BOUND_ACTION_COLLISION: 'The combination of Action name and binding parameter type must be unique for Bound Action ',
 	STREAM_NO_COLLECTION: `'Edm.Stream' cannot be of Collection type.`,
 	UNSUPPORTED_PROPERTY_TYPE: 'Property cannot be of EntityType. Check the type: ',
-  UNRESOLVED_SCHEMA_NAMESPACE: `Could not resolve the schema `,
+	UNRESOLVED_SCHEMA_NAMESPACE: `Could not resolve the schema `,
 	INVALID_DATATYPE: `Invalid Data Type `,
 	ELEMENT_NAME_COLLISION: 'Collision between EntityContainer Element Name and Schema Element Name is currently not supported. Please check the element name: ',
 	NO_DEFAULT_FOR_COLLECTIONS: 'WARNING: Collection type cannot have a Default value.',
@@ -38,6 +38,7 @@ const messages = {
 	NULLABLE_KEY: 'WARNING: Key element cannot be Nullable.',
 	COLLISION_DETECTED: `INFO: Element name collision detected. Adding suffix to affected type category.`,
 	SPECIFY_CONFIG: 'For --config option, please specify correct JSON Object.',
+	INVALID_ANNOTATION: 'Annotation element must have a Term attribute',
 };
 
 function getMessages() {

package/lib/import/odata/metadataconverter/MetadataConverter.js

@@ -1,4 +1,6 @@
 'use strict';
+
+const message = require("../../message").getMessages();
  
 const vocabulariesMap = new Map([
     ['org.odata.core.v1', () => require('../vocabularies/Org.OData.Core.V1.json')],
@@ -1754,6 +1756,9 @@ class AnnotationExpression extends Expression {
     annotate(result) { super.annotate(this.getTargetPropertyName(), this.getTarget(), result); }
     interpret() {
         const element = this.getElement();
+        if(!Object.hasOwn(element, "attributes") || !Object.hasOwn(element.attributes, "Term")) {
+            throw new Error(message.INVALID_ANNOTATION);
+        }
         let name = element.attributes.Term;
         if (element.attributes.Qualifier) name += '#' + element.attributes.Qualifier;
         name = '@' + name;

package/lib/import/odata/v4parser.js

@@ -4,10 +4,10 @@
  */
 
 "use strict";
-let messages = require("../message").getMessages();
-let common = require("../common");
-let versionInfo = require("../../../package.json").version;
-let Multimap = require("./util/MultiMap");
+const messages = require("../message").getMessages();
+const common = require("../common");
+const versionInfo = require("../../../package.json").version;
+const Multimap = require("./util/MultiMap");
 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");
@@ -428,6 +428,11 @@ function _parseAnnotationTerms(annotationTerm, annotationTermObject, csnDefsTarg
 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;
@@ -1358,29 +1363,6 @@ function _parseEntityContainer(csnDefs, entityContainerElements, parserContext)
     return csnDefs;
 }
 
-/**
- * @param {List<Object>} dataObjList, action/function object list
- * @returns unique parameter list
- */
-function _collectAllParameters(dataObjList) {
-    let uniqueParams = [], paramNames = [], params;
-
-    for (let dataObj of dataObjList) {
-        params = dataObj.$Parameter;
-
-        if (params) {
-            for (let i = 0; i < params.length; i++) {
-                if (!paramNames.includes(params[i].$Name)) {
-                    paramNames.push(params[i].$Name);
-                    uniqueParams.push(params[i]);
-                }
-            }
-        }
-    }
-
-    return uniqueParams;
-}
-
 /**
  * @param {Boolean} isAction, to identify action/function
  * @param {String} fqName, fully qualified name
@@ -1389,7 +1371,7 @@ function _collectAllParameters(dataObjList) {
  *
  * Scenarios:
  * 1. Unbound Actions can't have collision. Action name must be unique.
- * 2. Unbound Functions can have collision; capture the max number of parameters.
+ * 2. Unbound Functions can have collision; we will parse only one function with the same name having no paramter and a generic String return type.
  */
 function _populateUnboundActionFunction(isAction, fqName, schemaDataList, parserContext) {
     let [schemaName, actFunName] = _extractSchemaNameAndElementName(fqName);
@@ -1409,8 +1391,12 @@ function _populateUnboundActionFunction(isAction, fqName, schemaDataList, parser
     }
     else {
         if (dataList.length > 1) {
-            actionFunctionObject['$Parameter'] = _collectAllParameters(dataList);
+            actionFunctionObject['$Parameter'] = [];
             parserContext.unboundFunctions[fqName] = actionFunctionObject;
+            parserContext.unboundFunctions[fqName]["@cds.validate"] = false;
+            if(parserContext.unboundFunctions[fqName].$ReturnType){
+                parserContext.unboundFunctions[fqName].$ReturnType.$Type = "Edm.String";
+            }
         }
         else {
             parserContext.unboundFunctions[fqName] = actionFunctionObject;
@@ -1439,12 +1425,11 @@ function _collectUnboundActionFunction(schemaDataList, parserContext) {
  * @param {Object} parserContext
  *
  * 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.
+ * 1. Actions with same name and binding parameter type can have collision and we will parse only one action with that name having no paramter and a genric String return type.
+ * 2. Functions can have collision and we will parse only one function with that name having no paramter and a genric String return type.
  * Special scenario is when same function name is bound to different entity as well.
  */
 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];
@@ -1480,7 +1465,12 @@ function _collectBoundActionFunction(isAction, currNamespace, elementName, eleme
                 parserContext.entityToBoundActions[boundEntityName][elementName] = dataObj;
             }
             else {
-                throw new Error(messages.BOUND_ACTION_COLLISION + `${elementName} in entity ${entityName} of schema ${currNamespace}.`);
+                parserContext.entityToBoundActions[boundEntityName][elementName]["@cds.validate"] = false;
+                parserContext.entityToBoundActions[boundEntityName][elementName]["$Parameter"] = [];
+                if (!parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType) {
+                    parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType = {};
+                }
+                parserContext.entityToBoundActions[boundEntityName][elementName].$ReturnType.$Type = "Edm.String";
             }
         }
         else {
@@ -1488,18 +1478,12 @@ function _collectBoundActionFunction(isAction, currNamespace, elementName, eleme
                 if (!parserContext.entityToBoundFunctions[boundEntityName]) {
                     parserContext.entityToBoundFunctions[boundEntityName] = {};
                 }
-                if (!functionObjList || !parserContext.entityToBoundFunctions[boundEntityName][elementName]) {
-                    functionObjList = [];
-                }
                 parserContext.entityToBoundFunctions[boundEntityName][elementName] = dataObj;
-                functionObjList.push(dataObj);
             }
             else {
-                functionObjList.push(dataObj);
-                let functionObject = functionObjList[0];
-                functionObject['$Parameter'] = _collectAllParameters(functionObjList);
-                functionObjList = [functionObject]; // reset the function object list with recently formed object
-                parserContext.entityToBoundFunctions[boundEntityName][elementName] = functionObject;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName]["@cds.validate"] = false;
+                parserContext.entityToBoundFunctions[boundEntityName][elementName]["$Parameter"] = [];
+                parserContext.entityToBoundFunctions[boundEntityName][elementName].$ReturnType.$Type = "Edm.String";
             }
             // throw error if the return type is missing
             if (!parserContext.entityToBoundFunctions[boundEntityName][elementName].$ReturnType) {
@@ -1688,7 +1672,12 @@ function _generateEDMX2JSON(edmx, name_space) {
                 if (missingReferencedDocuments?.length > 0) {
                     console.log(missingReferencedDocuments);  
                 }
-                resolve(json);
+
+                if (error) {
+                    reject(error);
+                } else {
+                    resolve(json);
+                }
             });
         } catch (err) {
             reject(err);

package/lib/init/add.js

@@ -15,5 +15,31 @@ module.exports = {
   register: (name, plugin) => {
     registered.set(name, plugin)
   },
+  filterStringAsRegex,
   registered
 }
+
+/**
+ * Turns a filter string with optional meta characters into a regular expression.
+ * If no meta characters are found, the string is treated as an include pattern.
+ *
+ * @param {string} spec the filter string
+ * @returns {RegExp} the regular expression
+ */
+function filterStringAsRegex(spec) {
+  if (typeof spec === 'string') {
+    try {
+      if (spec.match(/[\^$|*]/)) {
+        spec = spec.replace(/^\*/, '.*')  // * at start would be invalid, so make it a .*
+        return new RegExp(spec, 'i')
+      }
+      else { // no meta chars -> include semantics
+        spec = spec.replace(/\./g, '\\.') // escape literal dot
+        return new RegExp(spec, 'i')
+      }
+    } catch (err) {
+      throw err.message // user error, so cut off stack trace
+    }
+  }
+  return /.*/
+}

package/lib/init/constants.js

@@ -13,9 +13,13 @@ module.exports = {
         JAVA_MVN: 'java:mvn',
         JAVA_PACKAGE: 'java:package',
         NODEJS: 'nodejs',
+        ESM: 'esm',
         SAMPLES: 'samples', // deprecated
         TINY_SAMPLE: 'tiny-sample',
         SAMPLE: 'sample',
+        TYPER: 'typer',
+        TYPESCRIPT: 'typescript',
+        HANDLER: 'handler', // influenced by esm, typer and typescript
         MTA: 'mta',
         CF_MANIFEST: 'cf-manifest',
         HELM: 'helm',
@@ -57,8 +61,6 @@ module.exports = {
         LINT_GLOBAL: 'lint:global',
         LINT_DEV: 'lint:dev',
         PIPELINE: 'pipeline',
-        TYPER: 'typer',
-        TYPESCRIPT: 'typescript'
     }),
 
     REGEX_JAVA_PACKAGE: /^[a-z_][a-z0-9_]*(\.[a-z_][a-z0-9_]*)*$/g,
@@ -71,9 +73,6 @@ module.exports = {
         CAPIRE: 'https://cap.cloud.sap',
         MAVEN_ARCHETYPE_HELP: `https://cap.cloud.sap/docs/java/developing-applications/building#the-maven-archetype`,
         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',
         CF_CLI: 'https://github.com/cloudfoundry/cli'
     }),
 

package/lib/init/index.js

@@ -12,17 +12,13 @@ const DEBUG = /\b(y|all|cli)\b/.test(process.env.DEBUG) ? console.debug : undefi
 
 module.exports = class CDSGenerator {
 
-    /** @returns {string[]} */
-    static #findPlugins(excluded) {
-        // actually needs to be sync to be usable in module.exports of dk/bin/init.js
-        const fromDk = readdirSync(join(__dirname, 'template'))
-        const fromPlugins = Object.keys(Object.fromEntries(require('./add').registered))
-        return [...fromDk, ...fromPlugins]
-            .filter(plugin => !excluded?.includes(plugin))
+    constructor() {
+        this.cwd = process.cwd()
+        this.uiConfig = require('./bas') // Used by CAP Generator
     }
 
     static help({ exclude = [] } = {}) {
-        if (!cds.add) return // use case shell completion: cds.add is undefined and not needed
+        if (!cds.add) return // shell completion: cds.add is undefined and not needed
 
         const plugins = this.readPlugins(exclude)
         const nameFixedLength = Math.max(...plugins.map(plugin => plugin.name.length))
@@ -35,10 +31,14 @@ module.exports = class CDSGenerator {
     }
 
     /**
+     * @param excluded {string[]}
      * @returns {{name: string, module: import('module')}[]}
      */
     static readPlugins(excluded = []) {
-        const plugins = this.#findPlugins(excluded)
+        const fromDk = readdirSync(join(__dirname, 'template'))
+        const fromPlugins = Object.keys(Object.fromEntries(require('./add').registered))
+        const all = [...fromDk, ...fromPlugins]
+            .filter(plugin => !excluded?.includes(plugin))
             .map(plugin => ({
                 name: plugin,
                 module: cds.add.registered.get(plugin) ?? require('./template/' + plugin)
@@ -51,12 +51,7 @@ module.exports = class CDSGenerator {
             if (b === -1) return -1
             return a - b
         }
-        return plugins.sort(byPriority)
-    }
-
-    constructor() {
-        this.cwd = process.cwd()
-        this.uiConfig = require('./bas') // Used by CAP Generator
+        return all.sort(byPriority)
     }
 
     /**
@@ -216,15 +211,14 @@ module.exports = class CDSGenerator {
         }
 
         const cmds = Object.values(OPTIONS)
-        this.templateList = Array.from(templates.entries())
-            .sort(([lhs], [rhs]) => {
-                const a = cmds.indexOf(lhs), b = cmds.indexOf(rhs)
-                if (a === -1 && b === -1) return 0
-                if (a === -1) return 1
-                if (b === -1) return -1
+        const priorities = new Map(cmds.map((cmd, i) => [cmd, i]))
+        this.templateList = Array.from(templates.keys())
+            .sort((lhs, rhs) => {
+                const a = priorities.get(lhs) ?? Infinity
+                const b = priorities.get(rhs) ?? Infinity
                 return a - b
             })
-            .map((entry) => entry[1])
+            .map(key => templates.get(key))
 
         DEBUG?.(`Features: ${this.templateList.map(({ name }) => name).join(', ')}`);
     }
@@ -240,11 +234,9 @@ module.exports = class CDSGenerator {
 
         const { options } = cds.cli
         if (typeof options.add === 'string') {
-            tokens = options.add.split(/[,\s+]/g);
-
+            tokens = options.add.split(/[,\s+]/g)
         } else if (Array.isArray(options.add)) {
             tokens = options.add
-
         } else if (options.add instanceof Set) {
             tokens = [...options.add];
         }

package/lib/init/merge.js

@@ -6,11 +6,8 @@ const { readYAML, writeYAML, readJSON } = require('../util/fs')
 const { detectIndent } = require('./indent')
 const { colors } = require('../util/term')
 
-function _isObject(item) {
-  return item && typeof item === 'object' && !Array.isArray(item)
-}
-
 function _mergeObject(target, source) {
+  const _isObject = item => item && typeof item === 'object' && !Array.isArray(item)
   const unique = array => [...new Set(array.map(JSON.stringify))].map(JSON.parse)
   if (_isObject(target) && _isObject(source)) {
       for (const key in source) {

package/lib/init/projectReader.js

@@ -1,6 +1,6 @@
 const cds = require('../cds')
 const { join, resolve, basename } = require('path')
-const { fs, exists, isdir, path } = cds.utils
+const { fs, exists, isfile, isdir, path } = cds.utils
 const { parseXml } = require('./xml')
 const { REGEX_JAVA_VERSION, JAVA_LTS_VERSIONS } = require('./constants')
 const TRACE = cds.debug('trace')
@@ -12,13 +12,15 @@ module.exports = new class ProjectReader {
     }
 
     #setPackageInfo() {
+        this.isJava = (exists('pom.xml') || cds.cli.options?.add?.has('java'))
+                        && !cds.env.for('cds').profiles.includes('node') // opt-out for hybrid projects like sflight
+
         // 1. Use project name and static default values
-        this.appVersion = cds.cli.options?.add?.has('java') ? '1.0.0-SNAPSHOT' : '1.0.0'
+        this.appVersion = this.isJava ? '1.0.0-SNAPSHOT' : '1.0.0'
         this.appName = this.appId = basename(cds.root)
         this.appDescription = 'A simple CAP project.'
 
-        const isJava = exists('pom.xml') || cds.cli.options?.add?.has('java')
-        if (isJava) {
+        if (this.isJava) {
             let artifactId, description, version, properties
             try {
                 ({ artifactId, description, version, properties } = parseXml(resolve(cds.root, 'pom.xml')) ?? {})
@@ -74,6 +76,10 @@ module.exports = new class ProjectReader {
      * @property {boolean} isUI5 Indicates if the project is a UI5 project.
      * @property {boolean} isJava Indicates if the project is using Java.
      * @property {boolean} isNodejs Indicates if the project is using Node.js.
+     * @property {boolean} isESM Indicates if the project is an ESM project (type 'module')
+     * @property {boolean} hasEsmStyle Indicates if code supports ESM-style imports and exports. This is true for ESM and Typescript projects.
+     * @property {boolean} isTypescript Indicates if the project is a Typescript project.
+     * @property {boolean} hasTyper Indicates if code supports CDS typer.
      * @property {boolean} hasHelmUnifiedRuntime Indicates if the project uses Unified Runtime Helm deployment.
      * @property {boolean} hasHelm Indicates if the project uses CAP Helm deployment.
      * @property {boolean} hasMta Indicates if the project uses MTA deployment.
@@ -95,7 +101,7 @@ module.exports = new class ProjectReader {
      * @property {boolean} hasMTXRouteJava Indicates if the approuter should have a multitenant subscription route (java).
      * @property {boolean} hasMalwareScanner Indicates if the project uses the SAP Malware Scanning service.
      * @property {boolean} hasDynatrace Indicates if the project uses Dynatrace.
-     *
+     * @property {boolean} hasCloudLogging Indicates if the project uses Cloud Logging.
      */
 
     /**
@@ -110,18 +116,27 @@ module.exports = new class ProjectReader {
         const { appVersion, appName, appId, appDescription, jdkVersion } = this
         TRACE?.({ env })
 
+        const pkgJson = () => exists('package.json') ? JSON.parse(fs.readFileSync(join(cds.root, 'package.json'))) : {}
+        const _isESM        = () => pkgJson().type === 'module'
+        const _isTypescript = () => !!pkgJson().dependencies?.typescript || !!pkgJson().devDependencies?.typescript
+        const _hasTyper     = () => !!pkgJson().dependencies?.['@cap-js/cds-typer'] || !!pkgJson().devDependencies?.['@cap-js/cds-typer']
+
         const _inProd = plugin => require(`./template/${plugin}`).hasInProduction(env)
-        const _ui5 = () => exists('package.json') && !!JSON.parse(fs.readFileSync(path.resolve(cds.root, 'package.json'))).sapux
+        const _ui5 = () => pkgJson().sapux
         const _uiEmbedded = () => exists(join(env.folders.app, 'xs-app.json'))
         const _uiModule = () => !_uiEmbedded() && isdir(env.folders.app) && fs.readdirSync(resolve(cds.root, env.folders.app)).length > 0
-        const _isJava = () => exists('pom.xml') || cds.cli.options?.add?.has('java')
+        const _isJava = () => this.isJava
         const isApp = name => name !== 'appconfig' && !name.startsWith('_') && name !== 'router' && name !== 'portal'
         const reserved = {
             has: x => _inProd(x),
             profile: () => cds.cli.options?.for,
-            language: () => exists('pom.xml') ? 'java' : 'nodejs',
+            language: () => _isJava() ? 'java' : 'nodejs',
             isJava: () => _isJava(),
             isNodejs: () => !_isJava(),
+            isTypescript: () => _isTypescript(),
+            isESM: () => _isESM,
+            hasEsmStyle: () => _isTypescript() || _isESM(),
+            hasTyper: () => _hasTyper(),
             srvPath: () => join(env.build.target, env.folders.srv.replace(/\/$/, '')).replace(/\\/g, '/'),
             archiveName: () => {
                 const pomXmlPath = resolve(cds.root, env.folders.srv, 'pom.xml')
@@ -135,7 +150,7 @@ module.exports = new class ProjectReader {
                 const path = join(env.build.target, name).replace(/\\/g, '/')
                 return { folder, name, path }
             },
-            configFile: () => exists('pom.xml') ? '.cdsrc.json' : 'package.json',
+            configFile: () => _isJava() ? '.cdsrc.json' : 'package.json',
             apps: () => {
                 const apps = fs.readdirSync(path.resolve(cds.root, cds.env.folders.app)).filter(e =>
                     isdir(path.join(cds.root, cds.env.folders.app, e)) && isApp(e)
@@ -191,3 +206,54 @@ module.exports = new class ProjectReader {
         return project
     }
 }
+
+/**
+ * Finds and reads SpringBoot configuration in `cds.root/srv` dir.
+ * This is done in a best-effort way. In no way can we replciate all of SpringBoot's
+ * config variants.
+ * @param {string[]?} roots array of directories to search for application.yaml, like `srv`
+ * @returns {Promise<object[]>} array of objects with `cds` property
+ */
+module.exports._readSpringBootConfig = async function (roots=[cds.env.folders.srv]) {
+    const configNodes = []
+    const rootDirs = roots.map(d => join(cds.root, d))
+    for (let r of rootDirs) {
+      const file = isfile (join (r,'./src/main/resources/application.yaml'))
+      if (file) {
+        const yaml = cds.load.yaml(file)
+        for (let yamlDoc of Array.isArray(yaml) ? yaml : [yaml]) {
+          let cds = yamlDoc?.cds;
+          if (!cds)   continue
+          cds = _normalizeSpringBootCfg(cds)
+          configNodes.push({cds})
+        }
+      }
+    }
+    return configNodes
+  }
+
+/**
+ * Normalize SpringBoot's dots in keys to express nested objects
+ *
+ * @example: `cds.foo.bar = 1` --> `cds: { foo: { bar: 1 } }`
+ * @param {object} obj
+ * @returns {object}
+ */
+function _normalizeSpringBootCfg(obj) {
+    if (typeof obj !== 'object')  return obj
+    Object.keys(obj).forEach(k => {
+        const prop = k.split('.')
+        const last = prop.pop()
+        // and define the object if not already defined
+        const res = prop.reduce((o, key) => {
+            // define the object if not defined and return
+            return o[key] = o[key] ?? {}
+        }, obj)
+        res[last] = obj[k]
+        // recursively normalize
+        _normalizeSpringBootCfg(obj[k])
+        // delete the original property from object if it was rewritten
+        if (prop.length)  delete obj[k]
+    })
+    return obj
+}

package/lib/init/registries/mta.js

@@ -1,4 +1,3 @@
-// Registry of sequence matchers in mta.yaml files
 const cds = require('../../cds')
 
 const srvNode4 = path => ({ in: 'modules', where: { type: 'nodejs', path } })

package/lib/init/template/approuter/files/package.json

@@ -4,7 +4,7 @@
     "@sap/approuter": "^17.0.0"
   },
   "engines": {
-    "node": "^22.0.0"
+    "node": "^20"
   },
   "scripts": {
     "start": "node node_modules/@sap/approuter/approuter.js"

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

@@ -1,18 +1,7 @@
 {
-  "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": {
-      "[{{profile}}]": {
-        "telemetry": {
-          "kind": "to-cloud-logging"
-        }
-      }
+      "cloud-logging": true
     }
   }
 }