@sap/cds 6.3.1 → 6.4.0

package/bin/build/provider/java/index.js

@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-
+const cds = require('../../cds')
 const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
 const { isOldJavaStack, BuildError } = require('../../util')
 
@@ -19,22 +19,22 @@ class JavaModuleBuilder extends BuildTaskHandlerEdmx {
         const { src, dest } = this.task
 
         const odataOptions = {
-            version: this.env.odata?.version
+            version: cds.env.odata?.version
         }
 
         if (await isOldJavaStack([src, this.buildOptions.root])) {
-            if (!this._isCompilerV1() && !this.env.build?.[SKIP_ASSERT_COMPILER_V2]) {
+            if (!this._isCompilerV1() && !cds.env.build?.[SKIP_ASSERT_COMPILER_V2]) {
                 throw new BuildError('CDS compiler version 2 does no longer support the classic CAP Java runtime. It is recommended to migrate to the current CAP Java runtime SDK. See https://cap.cloud.sap/docs/java/migration for more.')
             }
             // default is now v4 and not v2 anymore, so warn and overwrite with v2 if using default
-            if (!this.env.for('cds', this.buildOptions.root, false).odata?.version) {
+            if (!cds.env.for('cds', this.buildOptions.root, false).odata?.version) {
                 odataOptions.version = ODATA_VERSION_V2
                 this.pushMessage('Forcing OData v2 for building though the default is v4. Make sure to define OData v2 in cds configuration.', INFO)
             }
 
-            // 'sql_mapping' and 'cds.persinstence.name' annotations are required by old java stack
-            if (this.env.sql.names !== 'plain') {
-                odataOptions.sql_mapping = this.env.sql.names
+            // 'sql_mapping' and 'cds.persistence.name' annotations are required by old java stack
+            if (cds.env.sql.names !== 'plain') {
+                odataOptions.sql_mapping = cds.env.sql.names
             }
         }
 
@@ -48,7 +48,7 @@ class JavaModuleBuilder extends BuildTaskHandlerEdmx {
 
         if (this.hasBuildOption(CONTENT_LANGUAGE_BUNDLES, true)) {
             // collect and write language bundles into single i18n.json file
-            const i18nFolder = this.env.i18n.folders?.[0] || 'i18n'
+            const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
             const i18n = await this.collectLanguageBundles(model, path.join(this.task.dest, i18nFolder))
             if (i18n) {
                 this._result.languageBundles = i18n.bundles
@@ -81,7 +81,7 @@ class JavaModuleBuilder extends BuildTaskHandlerEdmx {
 
     async _compileForOdata(model, csnDest, compileOptions) {
         // csn for service providers
-        const m = this.cds.compile.for.java(model, {
+        const m = cds.compile.for.java(model, {
             ...this._options4odata(),
             ...compileOptions
         })
@@ -103,7 +103,7 @@ class JavaModuleBuilder extends BuildTaskHandlerEdmx {
     }
 
     _isCompilerV1() {
-        const version = this.cds.compiler.version()
+        const version = cds.compiler.version()
         const match = version.match(/(\d+)\.?(\d*)\.?(\d*)/)
         return match && match[1] === 1
     }

package/bin/build/provider/mtx/index.js

@@ -1,9 +1,10 @@
 /* eslint-disable no-empty */
 const fs = require('fs')
 const path = require('path')
+const cds = require('../../cds')
 const BuildTaskProviderInternal = require("../buildTaskProviderInternal")
 const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
-const { isStreamlinedMtx } = require('../../util')
+const { isStreamlinedMtx, hasJavaNature } = require('../../util')
 const ResourcesTarProvider = require('./resourcesTarBuilder')
 
 const { BUILD_TASK_HANA, FOLDER_GEN } = require('../../constants')
@@ -19,10 +20,18 @@ class MtxModuleBuilder extends BuildTaskHandlerEdmx {
     }
     init() {
         super.init()
-        if (isStreamlinedMtx(this.cds)) {
-            this._delegate = new StreamlinedMtxBuilder(this)
-        } else {
+
+        if (hasJavaNature([this.buildOptions.root, this.task.src, cds.env.folders.srv])) {
+            // Java projects having this build task configured are using Classic MTX
+            // Streamlined MTX based Java projects have to configure the 'mtx-sidecar' build task instead.
             this._delegate = new ClassicMtxBuilder(this)
+        } else {
+            // Nodejs projects
+            if (isStreamlinedMtx()) {
+                this._delegate = new StreamlinedMtxBuilder(this)
+            } else {
+                this._delegate = new ClassicMtxBuilder(this)
+            }
         }
     }
 
@@ -42,7 +51,7 @@ class StreamlinedMtxBuilder {
     async build() {
         // Non-sidecar scenario: model-provider is implemented by the Nodejs app itself (default for Nodejs).
         // Only create resources TAR, compiled CSN(s) are created by the Nodejs app build task.
-        const dest = this._handler.env.build?.target !== "." ? this._handler.task.dest : path.join(this._handler.task.dest, FOLDER_GEN)
+        const dest = cds.env.build?.target !== "." ? this._handler.task.dest : path.join(this._handler.task.dest, FOLDER_GEN)
         const model = await this._handler.model()
         if (!model) {
             return
@@ -64,7 +73,7 @@ class ClassicMtxBuilder {
     }
 
     async build() {
-        if (this._handler.env.requires.toggles === true) {
+        if (cds.env.requires.toggles === true) {
             throw new Error("Feature toggles are only supported by Streamlined MTX")
         }
 
@@ -96,7 +105,7 @@ class ClassicMtxBuilder {
         }))
 
         // collect and write language bundles into single i18n.json file
-        const i18nFolder = this._handler.env.i18n.folders?.[0] || 'i18n'
+        const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
         const i18n = await this._handler.collectLanguageBundles(model, path.join(destSdc, i18nFolder))
         if (i18n) {
             this._handler._result.languageBundles = i18n.bundles
@@ -163,13 +172,13 @@ class ClassicMtxBuilder {
      * @param {Object} model - the reflected csn for this SaaS application
      */
     _validateExtensionAllowLists(model, tenantDbPath) {
-        let entityWhitelist = this._handler.env.mtx?.["entity-whitelist"]
-        let serviceWhitelist = this._handler.env.mtx?.["service-whitelist"]
-        let extensionAllowlist = this._handler.env.mtx?.["extension-allowlist"]
+        let entityWhitelist = cds.env.mtx?.["entity-whitelist"]
+        let serviceWhitelist = cds.env.mtx?.["service-whitelist"]
+        let extensionAllowlist = cds.env.mtx?.["extension-allowlist"]
 
         // for java projects mtx configuration is part of sidecar config
         if (!entityWhitelist && !serviceWhitelist && !extensionAllowlist && tenantDbPath) {
-            const dbEnv = this._handler.env.for("cds", tenantDbPath)
+            const dbEnv = cds.env.for("cds", tenantDbPath)
             entityWhitelist = dbEnv.mtx?.["entity-whitelist"]
             serviceWhitelist = dbEnv.mtx?.["service-whitelist"]
             extensionAllowlist = dbEnv.mtx?.["extension-allowlist"]
@@ -181,7 +190,7 @@ class ClassicMtxBuilder {
 
         if (extensionAllowlist || entityWhitelist || serviceWhitelist) {
             const invalidEntries = new Set()
-            const reflected = this._handler.cds.reflect(model)
+            const reflected = cds.reflect(model)
 
             if (Array.isArray(extensionAllowlist)) {
                 extensionAllowlist.forEach(allowListEntry => {
@@ -234,19 +243,19 @@ class ClassicMtxBuilder {
         // ensure that the hana task is contained even if this mtx task has been executed solely using "cds build --for mtx"
         if (!tasks.find(task => task.for === BUILD_TASK_HANA)) {
             //mtx task might have been executed as separate task
-            tasks = this._handler.env.build?.tasks || []
+            tasks = cds.env.build?.tasks || []
             if (tasks.length === 0) {
-                const provider = new BuildTaskProviderInternal(this._handler.cds, this._handler.logger)
+                const provider = new BuildTaskProviderInternal(this._handler.logger)
                 await provider.lookupTasks(tasks, this._handler.buildOptions)
             }
         }
         // the SaaS app might use a tenant aware db as well as a shared db deployed using static hdi-deployer
         // pick the hana build task referring to the tenant aware db - the src path has to be contained in this build task's model options
-        const hanaDbPaths = tasks.filter(task => task.for === BUILD_TASK_HANA).map(hanaTask => path.resolve(this._handler.buildOptions.root, hanaTask.src || this._handler.env.folders.db))
+        const hanaDbPaths = tasks.filter(task => task.for === BUILD_TASK_HANA).map(hanaTask => path.resolve(this._handler.buildOptions.root, hanaTask.src || cds.env.folders.db))
         let tenantDbPath = hanaDbPaths.find(hanaDbPath => hanaDbPaths.length === 1 || modelPaths.some(modelPath => path.dirname(modelPath) === hanaDbPath))
 
         if (!tenantDbPath) {
-            tenantDbPath = path.join(this._handler.buildOptions.root, this._handler.env.folders.db)
+            tenantDbPath = path.join(this._handler.buildOptions.root, cds.env.folders.db)
             if (hanaDbPaths.length === 0) {
                 this._handler.pushMessage(`no 'hana' build task found, use default location '${tenantDbPath}'`, WARNING)
             } else {

package/bin/build/provider/mtx/resourcesTarBuilder.js

@@ -1,7 +1,9 @@
 const path = require('path')
+const cds = require('../../cds')
 const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
 
 const { BUILD_TASK_HANA } = require('../../constants')
+const { fs } = require('../../../../lib/utils/cds-utils')
 const { WARNING } = BuildTaskHandlerInternal
 const DEFAULT_TAR_NAME = "resources.tgz"
 
@@ -13,52 +15,51 @@ class ResourcesTarBuilder {
     get handler() { return this._handler }
 
     async createTar(dest, model) {
-        const { root, files } = await this._getResources(model)
-        if (files.length === 0) {
+        const { root, resources } = await this._getResources(model)
+        if (resources.length === 0) {
             // packTarArchive fails otherwise
             this.handler.pushMessage("No deployment resources found - skip resources.tgz", WARNING)
             return
         }
-        await this.writeTarFile(files, root, path.join(dest, DEFAULT_TAR_NAME))
+        await this.writeTarFile(resources, root, path.join(dest, DEFAULT_TAR_NAME))
     }
 
-    async writeTarFile(files, root, tarFile) {
+    async writeTarFile(resources, root, tarFile) {
         const { tar } = require('../../../../lib').utils
-        await tar.czfd (tarFile, root, files) // REVISIT: tar.czfd was created for this case only -> it ensures the target's dir exists
+        await tar.czfd(tarFile, root, resources) // REVISIT: tar.czfd was created for this case only -> it ensures the target's dir exists
         this.handler.pushFile(tarFile)
     }
 
     async _getResources(model) {
         // distinguish HANA and SQLITE deployment
         let root = await this._getHanaTenantDbDest()
-        let files
+        let resources
         if (root) {
-            files = this._getHanaResources(root)
+            resources = this._getHanaResources(root)
         } else {
-            root = path.join(this.handler.buildOptions.root, this.handler.env.folders.db)
-            files = await this._getSqliteResources(model)
+            root = path.join(this.handler.buildOptions.root, cds.env.folders.db)
+            resources = await this._getSqliteResources(model)
         }
-        return { root, files }
+        return { root, resources }
     }
 
     /**
-     * Reads all resources for HANA deployment - 'db/src/**' and 'db/undeploy.json'.
-     * - CSV files, native HANA artifacts, generated HANA artifacts, undeploy.json
+     * Reads a list of files and folders required for HANA deployment.
+     * This is a subset of all files contained in the directory.
+     * - 'db/src', 'db/cfg', 'db/undeploy.json'...
      * See '../../../../lib.deploy'
      * Note: the hana build task has already been executed
      * @param {string} root
      * @returns an array containing all resources
      */
     _getHanaResources(root) {
-        const hanaNativeFolders = [path.join(root, 'src'), path.join(root, 'cfg')]
-        const hanaNativeFiles = [path.join(root, 'undeploy.json'), path.join(root, '.hdiignore')]
-
-        return BuildTaskHandlerInternal._find(root, (res) => {
-            if (hanaNativeFolders.some(folder => res.startsWith(folder)) || hanaNativeFiles.some(file => res === file)) {
-                return true
+        return ['src', 'cfg', 'undeploy.json', '.hdiignore'].reduce((acc, res) => {
+            const resPath = path.join(root, res)
+            if (fs.existsSync(resPath)) {
+                acc.push(resPath)
             }
-            return false
-        })
+            return acc
+        }, [])
     }
 
     /**
@@ -68,16 +69,10 @@ class ResourcesTarBuilder {
      * @returns
      */
     async _getSqliteResources(model) {
-        const { resources } = this.handler.cds.deploy
+        const { resources } = cds.deploy
         return Object.keys(await resources(model))
     }
 
-    /**
-     * Returns the build tasks of this project - either user defined or calculated by BuildTaskFactory.
-     * A build task of type 'hana' is enforced in order to copy existing native hana artifacts later on.
-     *
-     * @returns {string} the src folder of the tenant db module
-     */
     async _getHanaTenantDbDest() {
         const buildOptions = this.handler.buildOptions
         let hanaTask = buildOptions.tasks ? buildOptions.tasks.find(task => task.for === BUILD_TASK_HANA) : undefined

package/bin/build/provider/mtx-extension/index.js

@@ -1,4 +1,5 @@
 const path = require('path')
+const cds = require('../../cds')
 const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
 const { FOLDER_GEN } = require('../../constants')
 const ResourcesTarBuilder = require('../mtx/resourcesTarBuilder')
@@ -25,7 +26,7 @@ class MtxExtensionModuleBuilder extends BuildTaskHandlerInternal {
 
         // extension CSN using parsed format
         const options = { ...this.options(), flavor: 'parsed' }
-        const extCsn = await this.cds.load(this.resolveModel(), options)
+        const extCsn = await cds.load(this.resolveModel(), options)
         if (extCsn.requires) {
             extCsn.requires.length = 0
         }
@@ -39,7 +40,7 @@ class MtxExtensionModuleBuilder extends BuildTaskHandlerInternal {
             allFiles.push(i18n.file)
         }
 
-        const files = Object.keys(await this.cds.deploy.resources(model))
+        const files = Object.keys(await cds.deploy.resources(model))
         if (files.length > 0) {
             const dataDest = path.join(destExt, 'data')
             await Promise.all(

package/bin/build/provider/mtx-sidecar/index.js

@@ -1,4 +1,5 @@
 const path = require('path')
+const cds = require('../../cds')
 const fs = require('fs')
 const { FOLDER_GEN, DEFAULT_CSN_FILE_NAME } = require('../../constants')
 const NodeCfModuleBuilder = require('../nodejs')
@@ -30,7 +31,7 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
      */
     async build() {
         // nodejs app parts have to be built using sidecar env
-        const sidecarEnv = this.env.for("cds", this.task.src)
+        const sidecarEnv = cds.env.for("cds", this.task.src)
         // build main application
         await this._buildMainApp(sidecarEnv)
         // build node application
@@ -43,8 +44,8 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
      */
     async _buildNodeApp(sidecarEnv) {
         const destSidecar = this.task.dest
-        const destSidecarSrc = path.join(destSidecar, this.env.folders.srv)
-        const i18nFolder = this.env.i18n.folders?.[0] || 'i18n'
+        const destSidecarSrc = path.join(destSidecar, cds.env.folders.srv)
+        const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
         const model = this._compileSidecarSync(sidecarEnv)
         await this.compileToJson(model, path.join(destSidecarSrc, DEFAULT_CSN_FILE_NAME))
 
@@ -61,7 +62,7 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
             throw new BuildError("CDS build failed", "Invalid MTX sidecar configuration - \"cds.xt.ModelProviderService\": \"in-sidecar\" missing.")
         }
         let main = sidecarEnv.requires['cds.xt.ModelProviderService']?.root
-        const profiles = this.env.profiles || []
+        const profiles = cds.env.profiles || []
 
         if (!profiles.includes("production") && !profiles.includes("prod")) {
             main = DEFAULT_MAIN_FOLDER
@@ -70,7 +71,7 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
         }
         const destRoot = this.task.dest
         const destMain = path.join(destRoot, main)
-        const destMainSrv = path.join(destMain, this.env.folders.srv)
+        const destMainSrv = path.join(destMain, cds.env.folders.srv)
         const csn = await this.model()
         if (!csn) {
             return
@@ -83,7 +84,7 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
         await new ResourcesTarProvider(this).createTar(destMain, csn)
 
         // copy package.json and .cdsrc.json from project root
-        await this._copyMainConfigFiles(this.cds.root, destMain)
+        await this._copyMainConfigFiles(cds.root, destMain)
     }
 
     /**
@@ -92,12 +93,12 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
      * @returns the compiled mtx sidecar CSN
      */
     _compileSidecarSync(sidecarEnv) {
-        const env = this.env
+        const env = cds.env
         try {
-            this.cds.root = this.task.src
-            this.cds.env = sidecarEnv
-            const modelPaths = this.cds.resolve('*', false)
-            const modelFilePaths = this.cds.resolve(modelPaths)
+            cds.root = this.task.src
+            cds.env = sidecarEnv
+            const modelPaths = cds.resolve('*', false)
+            const modelFilePaths = cds.resolve(modelPaths)
 
             if (!modelFilePaths || modelFilePaths.length === 0) {
                 throw new BuildError("No CDS service models found in MTX sidecar. Make sure required npm modules are installed.")
@@ -105,18 +106,18 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
             this._logger._debug && this._logger.debug(`sidecar model: ${relativePaths(this.buildOptions.root, modelFilePaths).join(", ")}`)
 
             // check whether all models belonging to the @sap namespace can be resolved
-            const unresolved = resolveRequiredSapModels(this.cds, modelPaths)
+            const unresolved = resolveRequiredSapModels(modelPaths)
             if (unresolved.length > 0) {
                 // log error, but don't fail
                 this.pushMessage(`CDS service models [${unresolved.join(', ')}] required by MTX sidecar cannot be resolved. Make sure to install the missing npm modules.`, ERROR)
             }
 
             // synchronous compilation
-            return this.cds.load(modelFilePaths, { sync: true, ...this.options() })
+            return cds.load(modelFilePaths, { sync: true, ...this.options() })
         } finally {
             // restore project scope
-            this.cds.root = this.buildOptions.root
-            this.cds.env = env
+            cds.root = this.buildOptions.root
+            cds.env = env
         }
     }
 

package/bin/build/provider/nodejs/index.js

@@ -1,10 +1,12 @@
 const fs = require('fs')
 const path = require('path')
+const cds = require('../../cds')
 const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
 const { BuildError } = require('../../util')
 const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, ODATA_VERSION_V2, FOLDER_GEN, BUILD_NODEJS_EDMX_GENERAION, EDMX_GENERATION,
-    SKIP_PACKAGE_JSON_GENERATION, CONTENT_EDMX, CONTENT_PACKAGE_JSON, CONTENT_PACKAGELOCK_JSON, CONTENT_NPMRC, CONTENT_CDSRC_JSON, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, SEMVER_REGEX } = require('../../constants')
-const { WARNING, ERROR } = BuildTaskHandlerEdmx
+    SKIP_PACKAGE_JSON_GENERATION, CONTENT_EDMX, CONTENT_PACKAGE_JSON, CONTENT_PACKAGELOCK_JSON, CONTENT_NPMRC, CONTENT_CDSRC_JSON,
+    CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON } = require('../../constants')
+const { WARNING } = BuildTaskHandlerEdmx
 
 class NodejsModuleBuilder extends BuildTaskHandlerEdmx {
     init() {
@@ -25,20 +27,22 @@ class NodejsModuleBuilder extends BuildTaskHandlerEdmx {
             throw new BuildError("Option not supported - compileDest")
         }
         // fallback if src has been defined as '.'
-        this.destSrv = this.isStagingBuild() ? path.resolve(this.task.dest, this.env.folders.srv) : path.join(this.task.dest, FOLDER_GEN)
+        this.destSrv = this.isStagingBuild() ? path.resolve(this.task.dest, cds.env.folders.srv) : path.join(this.task.dest, FOLDER_GEN)
     }
 
     options() {
-        const options = super.options(), { cds } = this
-        if (cds.requires.extensibility || cds.requires.toggles) options.flavor = 'xtended'
+        const options = super.options()
+        if (cds.env.requires.extensibility || cds.env.requires.toggles) {
+            options.flavor = 'xtended'
+        }
         return options
     }
 
     async build() {
-        const destSrv = this.isStagingBuild() ? this.destSrv : path.resolve(this.destSrv, this.env.folders.srv)
+        const destSrv = this.isStagingBuild() ? this.destSrv : path.resolve(this.destSrv, cds.env.folders.srv)
         const destRoot = this.isStagingBuild() ? this.task.dest : this.destSrv
 
-        if (this.env.odata?.version === ODATA_VERSION_V2) {
+        if (cds.env.odata?.version === ODATA_VERSION_V2) {
             // log warning as nodejs is only supporting odata version V4
             this.pushMessage("OData v2 is not supported by node runtime. Make sure to define OData v2 in cds configuration.", WARNING)
         }
@@ -54,12 +58,12 @@ class NodejsModuleBuilder extends BuildTaskHandlerEdmx {
         await this.collectAllLanguageBundles(dictionary, sources, destSrv, destRoot)
 
         if (this.hasBuildOption(CONTENT_EDMX, true)) {
-            const m = await this.cds.load(sources.base, super.options()) // REVISIT: Quick hack to get inferred model as expected by cds.compile.to.edmx()
+            const m = await cds.load(sources.base, super.options()) // REVISIT: Quick hack to get inferred model as expected by cds.compile.to.edmx()
             await this.compileToEdmx(m, this.destSrv)
         }
 
         if (this.isStagingBuild() && !this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            const srcSrv = this.task.src === this.buildOptions.root ? path.resolve(this.task.src, this.env.folders.srv) : this.task.src
+            const srcSrv = this.task.src === this.buildOptions.root ? path.resolve(this.task.src, cds.env.folders.srv) : this.task.src
             await this._copyNativeContent(this.buildOptions.root, srcSrv, destRoot, destSrv)
         }
         return this._result
@@ -139,7 +143,7 @@ class NodejsModuleBuilder extends BuildTaskHandlerEdmx {
      * @param {*} filter - copy file if filter function returns true
      */
     async copyProjectRootContent(src, dest, filter) {
-        let { folders = ['i18n'] } = this.env.i18n
+        let { folders = ['i18n'] } = cds.env.i18n
         folders.push('handlers')
         folders = folders.map(folder => path.join(src, folder))
         let srvAllowList = "package\\.json$" // always copy package.json, modify only if CONTENT_PACKAGE_JSON is true
@@ -159,52 +163,6 @@ class NodejsModuleBuilder extends BuildTaskHandlerEdmx {
             }
             return srvAllowList.test(entry) && (!filter || filter.call(this, entry))
         })
-
-        if (this.hasBuildOption(CONTENT_PACKAGE_JSON, true) && fs.existsSync(path.join(dest, 'package.json'))) {
-            await this._modifyPackageJson(path.join(dest, 'package.json'))
-        }
-    }
-
-    /**
-     * Modify package.json file defined by the given file path.
-     * @param {string} file
-     */
-    async _modifyPackageJson(file) {
-        function _addEnginesField(content) {
-            if (!content.engines || !content.engines.node) {
-                // use minimum node version of @sap/cds
-                const { engines } = require('../../../../package.json')
-                if (engines && engines.node) {
-                    this.logger.log(`${this.task.for}: adding node engines version to package.json ${engines.node}`)
-                    content.engines = content.engines || {}
-                    const nodeVersion = NodejsModuleBuilder._convertToClosedVersionRange(engines.node)
-                    if (nodeVersion) {
-                        content.engines.node = nodeVersion
-                        return true
-                    } else {
-                        this.pushMessage(`Invalid node version defined in engines definition for @sap/cds ${engines.node} - skip node engines definition`, ERROR)
-                    }
-                }
-            }
-            return false
-        }
-
-        let content = await fs.promises.readFile(file)
-        let changed = false
-        if (content) {
-            content = JSON.parse(content)
-            changed |= _addEnginesField.call(this, content)
-        }
-        if (changed) {
-            await this.write(content).to(file)
-        }
-    }
-
-    static _convertToClosedVersionRange(rtVersion) {
-        rtVersion = rtVersion.trim()
-        if (rtVersion.match(SEMVER_REGEX)) {
-            return rtVersion.replace(SEMVER_REGEX, '^$2$3$4')
-        }
     }
 }
 

package/bin/build/util.js

@@ -1,6 +1,7 @@
 const fs = require('fs')
 const path = require('path')
-const { SEVERITY_ERROR, CDS_MODEL_EXCLUDE_LIST } = require('./constants')
+const cds = require('./cds')
+const { SEVERITY_ERROR, CDS_MODEL_EXCLUDE_LIST, FILE_EXT_CDS } = require('./constants')
 
 function getProperty(src, segments) {
     segments = Array.isArray(segments) ? segments : segments.split('.')
@@ -26,10 +27,12 @@ function setProperty(src, segments, value) {
  * @param {Array} dirs - the absolute path names to check.
  */
 function readPomFilePaths(dirs) {
-    return dirs.reduce((acc, dir) => {
-        const file = path.join(dir, 'pom.xml')
-        if (fs.existsSync(file)) {
-            acc.push(file)
+    return dirs.flat().reduce((acc, dir) => {
+        if (dir) {
+            const file = path.join(dir, 'pom.xml')
+            if (fs.existsSync(file)) {
+                acc.push(file)
+            }
         }
         return acc
     }, [])
@@ -44,7 +47,7 @@ function hasJavaNature(dirs) {
 }
 
 /**
- * Determines wheter the both values are identical.
+ * Determines whether the both values are identical.
  * @param {*} actual
  * @param {*} expected
  */
@@ -116,15 +119,10 @@ function _redacted(cred) {
 }
 
 /**
- * Distinguishes whether the project uses the new ModelProviderService based approach as
- * defined by the new Streamlined MTX (cds >=6) or whether it represents an old MTX project
- * using the cds-mtx library.
- *
- * @param {object} env
- * @returns
+ * Distinguishes whether the Nodejs project is a Streamlined MTX (cds >=6) or an old MTX project.
  */
-function isStreamlinedMtx(cds) {
-    if (hasOptionValue(process.env.OLD_MTX, true)) {
+function isStreamlinedMtx() {
+    if (cds.utils._oldMtx()) {
         return false
     }
     return (cds.env.requires.toggles
@@ -136,11 +134,10 @@ function isStreamlinedMtx(cds) {
 /**
  * Returns a list of fully qualified model names belonging to the '@sap' namespace that cannot be resolved. 
  * E.g. the npm module might NOT be installed.
- * @param {*} cds 
  * @param {Array} modelPaths 
  * @returns {Array}
  */
-function resolveRequiredSapModels(cds, modelPaths) {
+function resolveRequiredSapModels(modelPaths) {
     return modelPaths.filter(p => {
         if (p.startsWith('@sap/') && !CDS_MODEL_EXCLUDE_LIST.includes(p)) {
             const files = cds.resolve(p)
@@ -149,6 +146,47 @@ function resolveRequiredSapModels(cds, modelPaths) {
     })
 }
 
+function getDefaultModelOptions(projectPath) {
+    const fts = cds.env.features.folders
+    const modelPaths = cds.resolve(!fts ? '*' : ['*', fts], false)
+    return _pushModelPaths(projectPath, modelPaths)
+}
+
+function _pushModelPaths(projectPath, ...modelPaths) {
+    const model = new Set()
+    // may contain nested arrays
+    modelPaths = flatten(modelPaths)
+    const { roots } = cds.env
+    modelPaths.forEach(m => {
+        if (m && !model.has(m) && !model.has(m + "/")) {
+            // filter root model paths that do not exist
+            // other entries are added as is, e.g. reuse model entries
+            if (roots.includes(m)) {
+                const dir = path.resolve(projectPath, m)
+                if (fs.existsSync(dir)) {
+                    model.add(m.replace(/\/$/, ''))
+                } else if (fs.existsSync(dir + FILE_EXT_CDS)) { //might be cds file name, compatibility to old build configs
+                    model.add(m)
+                }
+            } else {
+                model.add(m)
+            }
+        }
+    })
+    return model
+}
+
+function flatten(modelPaths) {
+    return modelPaths.reduce((acc, m) => {
+        if (Array.isArray(m)) {
+            acc = acc.concat(flatten(m))
+        } else if (m) {
+            acc.push(m)
+        }
+        return acc
+    }, [])
+}
+
 class BuildMessage extends Error {
     constructor(message, severity = SEVERITY_ERROR) {
         super(message)
@@ -188,6 +226,8 @@ module.exports = {
     relativePaths,
     isStreamlinedMtx,
     resolveRequiredSapModels,
+    getDefaultModelOptions,
+    flatten,
     BuildMessage,
     BuildError
 }

package/bin/deploy/to-hana/cfUtil.js

@@ -1,3 +1,5 @@
+// eslint-disable-next-line no-console
+
 const cp = require('child_process');
 const fsp = require('fs').promises;
 const os = require('os');
@@ -88,9 +90,10 @@ class CfUtil {
         }
 
         if (response.errors) {
-            const errorMessage = result.errors.map((entry) => `${entry.title}: ${entry.detail} (${entry.code})`).join('\n');
+            const errorMessage = response.errors.map((entry) => `${entry.title || ''}: ${entry.detail || ''} (${entry.code || ''})`).join('\n');
             throw new Error(errorMessage);
         }
+
         return response;
     }
 

package/bin/deploy/to-hana/gitUtil.js

@@ -34,7 +34,7 @@ class GitUtil {
             }
         }
 
-        LOG.log(`adding entry '${file}' to ${GIT_IGNORE_FILE}.`);
+        console.log(`adding entry '${file}' to ${GIT_IGNORE_FILE}.`);
         let gitignore = await this.readFileSafely(gitIgnorePath);
         gitignore = gitignore + `
     # added by cds deploy