@sap/cds 5.9.7 → 6.0.2

package/bin/build/provider/node-cf/index.js

@@ -1,308 +1 @@
-const { fs } = require('@sap/cds-foss')
-const path = require('path')
-const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
-const { getHanaDbModuleDescriptor, getServiceModuleDescriptor } = require('../../mtaUtil')
-const { BuildError } = require('../../util')
-const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, ODATA_VERSION, ODATA_VERSION_V2,
-    BUILD_TASK_HANA, FOLDER_GEN, BUILD_NODEJS_EDMX_GENERAION, EDMX_GENERATION,
-    SKIP_PACKAGE_JSON_GENERATION, SKIP_MANIFEST_GENERATION,
-    CONTENT_EDMX, CONTENT_MANIFEST, CONTENT_PACKAGE_JSON, CONTENT_PACKAGELOCK_JSON }
-    = require('../../constants')
-const { WARNING } = require('../../buildTaskHandler')
-
-const FILE_NAME_MANIFEST_YML = "manifest.yml"
-
-class NodeCfModuleBuilder extends BuildTaskHandlerEdmx {
-    init() {
-        super.init()
-        // set unified option values in order to easy access later on
-        this.task.options[CONTENT_EDMX] = this.hasBuildOption(CONTENT_EDMX, true) || this.hasCdsEnvOption(BUILD_NODEJS_EDMX_GENERAION, true) || this.hasBuildOption(EDMX_GENERATION, true) ? true : false
-        this.task.options[CONTENT_MANIFEST] = !this.hasBuildOption(CONTENT_MANIFEST, false) && !this.hasBuildOption(SKIP_MANIFEST_GENERATION, true) ? true : false
-        this.task.options[CONTENT_PACKAGE_JSON] = !this.hasBuildOption(CONTENT_PACKAGE_JSON, false) && !this.hasBuildOption(SKIP_PACKAGE_JSON_GENERATION, true) ? true : false
-        this.task.options[CONTENT_PACKAGELOCK_JSON] = !this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false) ? true : false
-
-        if (this.task.options.compileDest) {
-            throw new BuildError("Option not supported - compileDest")
-        }
-        // fallback if src has been defined as '.'
-        this.destGen = this.isStagingBuild() ? path.resolve(this.task.dest, path.relative(this.buildOptions.root, this.task.src) || this.env.folders.srv) : path.join(this.task.dest, FOLDER_GEN)
-    }
-
-    async build() {
-        if (this.env.get(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)
-        }
-        // by default model contains all features
-        const model = await this.model()
-        if (!model) {
-            return this._result
-        }
-
-        const { dictionary, sources } = await this._compileAll(model)
-
-        // collect and write language bundles into single i18n.json file
-        await this._collectAllLanguageBundles(dictionary, sources, this.destGen)
-
-        if (this.hasBuildOption(CONTENT_EDMX, true)) {
-            await this.compileToEdmx(dictionary.base, this.destGen)
-        }
-
-        if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            await this._copyNativeContent(this.task.src, this.isStagingBuild() ? this.destGen : path.dirname(this.destGen))
-
-            if (this.hasBuildOption(CONTENT_MANIFEST, true)) {
-                await Promise.all([this._writeManifestYml(), this._writeCfIgnore()])
-            }
-        }
-        return this._result
-    }
-
-    async clean() {
-        // staging build content is deleted by BuildTaskEngine
-        if (this.buildOptions.target === this.buildOptions.root) {
-            // delete the entire 'task.dest' folder otherwise, for details see #constructor
-            // - the value of the folder 'src' has been appended to the origin 'task.dest' dir
-            this.logger._debug && this.logger.debug(`Deleting build target folder ${this.destGen}`)
-            await fs.remove(this.isStagingBuild() ? this.task.dest : this.destGen)
-        }
-    }
-
-    async _copyNativeContent(src, dest) {
-        const regex = RegExp('\\.cds$|package\\.json|package-lock\\.json|manifest\\.y.?ml')
-
-        await super.copyNativeContent(src, dest, (entry) => {
-            if (fs.statSync(entry).isDirectory()) {
-                return true // using common filter for folders
-            }
-            return !regex.test(path.basename(entry))
-        })
-
-        // copy relevant content located at project root, e.g. *.js, i18n/*, package.json -> gen/srv
-        let packageJsonCopy = false
-        let { folders = ['i18n'] } = this.env.i18n
-        folders.push('handlers')
-        folders = folders.map(folder => path.join(this.buildOptions.root, folder))
-
-        await super.copyNativeContent(this.buildOptions.root, this.task.dest, (entry) => {
-            if (fs.statSync(entry).isDirectory()) {
-                return folders.some(folder => entry.startsWith(folder))
-            }
-            if (/\.js$|\.properties$/.test(entry)) {
-                return true
-            }
-            if (/package\.json$/.test(entry) && this.hasBuildOption(CONTENT_PACKAGE_JSON, true)) {
-                packageJsonCopy = true
-                return true
-            }
-            if (/package-lock\.json$/.test(entry) && this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, true)) {
-                return true
-            }
-            return false
-        })
-
-        if (packageJsonCopy) {
-            await this._modifyPackageJson(path.join(this.task.dest, 'package.json'))
-        }
-    }
-
-    /**
-     * Filter file dependencies for CF deployment.<p>
-     *
-     * On CF, any ../file or file:... dependency is not resolvable anyways, so we can safely filter it out.
-     * In CAP samples, we use these to refer to other CDS modules at build time.
-     * @param {string} file
-     */
-    async _modifyPackageJson(file) {
-        function _deleteFileDependencies(deps = {}) {
-            let changed = false
-            Object.keys(deps).forEach(key => {
-                if (typeof deps[key] === 'string' && deps[key].startsWith('.') || deps[key].startsWith('file:')) {
-                    this.logger.log(`${this.task.for}: removing file dependency '${deps[key]}' from ${path.relative(this.buildOptions.root, file)}`)
-                    delete deps[key]
-                    changed = true
-                }
-            })
-            return changed
-        }
-        function _addEnginesField(content) {
-            if (!content.engines || !content.engines.node) {
-                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 || {}
-                    content.engines.node = engines.node
-                    return true
-                }
-            }
-            return false
-        }
-
-        let content = await fs.readFile(file)
-        let changed = false
-        if (content) {
-            content = JSON.parse(content)
-            changed |= _deleteFileDependencies.call(this, content.dependencies)
-            changed |= _deleteFileDependencies.call(this, content.devDependencies)
-            changed |= _addEnginesField.call(this, content)
-        }
-        if (changed) {
-            await this.write(content).to(file)
-        }
-    }
-
-    // this is to have a dev fast-turnaround
-    async _writeCfIgnore() {
-        if (this.isStagingBuild()) {
-            const content = `node_modules/\n`
-            await this.write(content).to('.cfignore')
-        }
-    }
-
-    async _writeManifestYml() {
-        if (!this.isStagingBuild()) {
-            return
-        }
-
-        let manifest = path.join(this.task.src, FILE_NAME_MANIFEST_YML)
-        if (await fs.pathExists(manifest)) {
-            // copy existing manifest to service root folder in staging area
-            await this.copy(manifest).to(FILE_NAME_MANIFEST_YML)
-            return
-        }
-        manifest = path.join(this.task.src, 'manifest.yml')
-        if (await fs.pathExists(manifest)) {
-            // copy existing manifest to service root folder in staging area
-            await this.copy(manifest).to('manifest.yml')
-            return
-        }
-
-        // generate one...
-        // check whether a hdi service binding is required
-        const hanaBuildTask = this.buildOptions.tasks.find(task => task.for === BUILD_TASK_HANA)
-        let hanaServiceBinding = ""
-
-        if (hanaBuildTask) {
-            const dbModuleDescriptor = await getHanaDbModuleDescriptor(this.buildOptions.root, path.basename(hanaBuildTask.src), this.logger)
-            hanaServiceBinding = `      - ${dbModuleDescriptor.hdiServiceName}`
-        } else {
-            this.logger.debug("generating manifest.yml without HANA service binding, using sqlite database")
-        }
-
-        try {
-            const srvModuleDescriptor = await getServiceModuleDescriptor(this.buildOptions.root, path.basename(this.task.src), "nodejs", this.logger)
-            const MANIFEST_YML_CONTENT = `---
-applications:
-  - name: ${srvModuleDescriptor.appName}
-    path: .
-    memory: 256M
-    buildpacks:
-      - nodejs_buildpack
-    services:
-${hanaServiceBinding}`
-
-            await this.write(MANIFEST_YML_CONTENT).to(FILE_NAME_MANIFEST_YML)
-        } catch (e) {
-            if (e.name === 'YAMLSyntaxError') {
-                this.logger.error("Failed to parse [mta.yaml]")
-            }
-            this.logger.error(e)
-        }
-    }
-
-    async _compileAll(csn) {
-        const sources = await this._resolveSourcePaths(csn)
-        const dictionary = { base: null, features: null }
-
-        if (sources.features) {
-            // create base model
-            dictionary.base = await this.cds.load(sources.base, this.options())
-            dictionary.features = await this._compileFeatures(dictionary.base, sources.features)
-        } else {
-            // model already represents the base model as no feature toggles exist
-            dictionary.base = csn
-        }
-        // adding csn to build result containing @source and _where persisted properties
-        await this.compileToJson(dictionary.base, this.destGen)
-
-        return { dictionary, sources }
-    }
-
-    async _collectAllLanguageBundles(dictionary, paths, dest) {
-        // create language bundle for base model
-        await this.collectLanguageBundles(dictionary.base, dest)
-        if (dictionary.features) {
-            const fts = path.dirname(this.env.features.folders)
-            // create language bundles for all features
-            for (const ftName in dictionary.features) {
-                // attach the sources information for i18n location reference
-                dictionary.features[ftName]['$sources'] = paths.features[ftName]
-                await this.collectLanguageBundles(dictionary.features[ftName], path.join(dest, fts, ftName), false)
-            }
-        }
-    }
-
-    async _resolveSourcePaths(csn) {
-        const fts = this.env.features.folders ? path.dirname(this.env.features.folders) : undefined
-        const regex = new RegExp(path.resolve(this.buildOptions.root, fts || 'fts').replace(/\\/g, '\\\\') + '[/|\\\\](?<ftName>[^/|\\\\]*)')
-        let paths = { base: [] }
-
-        // add ROOT source file paths for the base model
-        paths.base = this._resolveModel().reduce((acc, file) => {
-            const match = file.match(regex)
-            if (!match) {
-                acc.push(file)
-            }
-            return acc
-        }, [])
-
-        // check whether feature toggles are used by this project
-        if (!fts || !await fs.pathExists(path.join(this.buildOptions.root, fts))) {
-            return paths
-        }
-
-        // add source file paths for the features
-        paths.features = csn['$sources'].reduce((acc, file) => {
-            const match = file.match(regex)
-            if (match) {
-                const { ftName } = match.groups
-                //feature
-                if (!acc[ftName]) {
-                    acc[ftName] = []
-                }
-                acc[ftName].push(file)
-            }
-            return acc
-        }, {})
-
-        return paths
-    }
-
-    async _compileFeatures(baseCsn, ftsPaths) {
-        if (!ftsPaths) {
-            return
-        }
-        const features = {}
-        const fts = path.dirname(this.env.features.folders)
-        const options = { ...this.options(), ...{ flavor: 'parsed' } }
-        // create feature models
-        for (const ftName in ftsPaths) {
-            const parsedCsn = await this.cds.load(ftsPaths[ftName], options)
-            // delete any requires references
-            if (parsedCsn.requires) {
-                delete parsedCsn.requires
-            }
-            await this.compileToJson(parsedCsn, path.join(this.destGen, fts, ftName), false)
-            this._validateFeature(baseCsn, parsedCsn)
-            features[ftName] = parsedCsn
-        }
-        return features
-    }
-
-    _validateFeature(baseCsn, parsedCsn) {
-        // features must not contain any other dependencies than base model
-        require('@sap/cds-compiler').compileSources({ 'base.csn': baseCsn, 'parsed.csn': parsedCsn }, this.options())
-    }
-}
-
-module.exports = NodeCfModuleBuilder
+module.exports = require('../nodejs')

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

@@ -0,0 +1,189 @@
+const fs = require('fs')
+const path = require('path')
+const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const { BuildError } = require('../../util')
+const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, ODATA_VERSION, 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 } = require('../../constants')
+const { WARNING } = require('../../buildTaskHandler')
+
+class NodeCfModuleBuilder extends BuildTaskHandlerEdmx {
+    init() {
+        super.init()
+        // set unified option values in order to ease access later on
+        // default value true
+        this.task.options[CONTENT_PACKAGE_JSON] = !this.hasBuildOption(CONTENT_PACKAGE_JSON, false) && !this.hasBuildOption(SKIP_PACKAGE_JSON_GENERATION, true) ? true : false
+        this.task.options[CONTENT_PACKAGELOCK_JSON] = !this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, false) ? true : false
+        this.task.options[CONTENT_NPMRC] = !this.hasBuildOption(CONTENT_NPMRC, false) ? true : false
+        this.task.options[CONTENT_CDSRC_JSON] = !this.hasBuildOption(CONTENT_CDSRC_JSON, false) ? true : false
+
+        // default value false
+        this.task.options[CONTENT_EDMX] = this.hasBuildOption(CONTENT_EDMX, true) || this.hasCdsEnvOption(BUILD_NODEJS_EDMX_GENERAION, true) || this.hasBuildOption(EDMX_GENERATION, true) ? true : false
+        this.task.options[CONTENT_ENV] = this.hasBuildOption(CONTENT_ENV, true) ? true : false
+        this.task.options[CONTENT_DEFAULT_ENV_JSON] = this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? true : false
+
+        if (this.task.options.compileDest) {
+            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)
+    }
+
+    async build() {
+        const destSrv = this.isStagingBuild() ? this.destSrv : path.resolve(this.destSrv, this.env.folders.srv)
+        const destRoot = this.isStagingBuild() ? this.task.dest : this.destSrv
+
+        if (this.env.get(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)
+        }
+        // by default model contains all features
+        const model = await this.model()
+        if (!model) {
+            return this._result
+        }
+
+        const { dictionary, sources } = await this.compileAll(model, destSrv, destRoot)
+
+        // collect and write language bundles into single i18n.json file
+        await this.collectAllLanguageBundles(dictionary, sources, destSrv, destRoot)
+
+        if (this.hasBuildOption(CONTENT_EDMX, true)) {
+            await this.compileToEdmx(dictionary.base, this.destSrv)
+        }
+
+        if (!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
+            await this._copyNativeContent(this.buildOptions.root, srcSrv, destRoot, destSrv)
+        }
+        return this._result
+    }
+
+    async clean() {
+        // staging build content is deleted by BuildTaskEngine
+        if (this.buildOptions.target === this.buildOptions.root) {
+            // delete the entire 'task.dest' folder otherwise, for details see #constructor
+            // - the value of the folder 'src' has been appended to the origin 'task.dest' dir
+            this.logger._debug && this.logger.debug(`Deleting build target folder ${this.destSrv}`)
+            await fs.promises.rm(this.isStagingBuild() ? this.task.dest : this.destSrv, { force: true, recursive: true })
+        }
+    }
+
+    async _copyNativeContent(srcRoot, srcSrv, destRoot, destSrv) {
+        // project/srv/** -> 'gen/srv/srv/**'
+        const filesFilter = await this._copySrvContent(srcSrv, destRoot, destSrv)
+
+        // project/* -> 'gen/srv/*'
+        await this._copyProjectRootContent(srcRoot, destRoot, (entry) => !filesFilter.includes(path.basename(entry)))
+    }
+
+    /**
+     * Copy files from the given <em>src</em>' folder (e.g. 'project/srv') to either <em>destRoot</em> (e.g. 'project/gen/srv') 
+     * or <em>destSrv</em> (e.g. 'project/gen/srv/srv') folders according to the file semantics.
+     * Files with project semantics like 'package.json' or '.npmrc' file are copied to <em>destRoot</em> while others like '.js' service handlers 
+     * are copied to <em>destSrv</em>.
+     * @param {*} src 
+     * @param {*} destRoot - folder name representing the app root folder (e.g. gen/srv)
+     * @param {*} destSrv - folder name representing the app sub-folder (e.g. gen/srv/srv)
+     * @returns the list of files that have been copied
+     */
+    async _copySrvContent(src, destRoot, destSrv) {
+        const srvRootBlockList = RegExp('package\\.json$|package-lock\\.json$|\\.npmrc$|\\.cdsrc\\.json$')
+        const srvBlockList = RegExp('\\.cds$|csn\\.json$|\\.csn$|manifest\\.y.?ml$|\\.env($|\\..*$)|default-env\\.json$')
+        const srvRootFileNames = []
+
+        // 1. copy all files to 'destSrv' except those contained in the blocklist (including node_modules)
+        // project/srv -> 'gen/srv/srv'
+        await super.copyNativeContent(src, destSrv, (entry) => {
+            if (fs.statSync(entry).isDirectory()) {
+                // TODO shall not copy language bundles - return !/(\/|\\)(node_modules|_i18n)(\/|\\)?$/.test(entry)
+                return !/(\/|\\)node_modules(\/|\\)?$/.test(entry)
+            }
+            if (srvRootBlockList.test(entry)) {
+                srvRootFileNames.push(path.basename(entry))
+                return false
+            }
+            return !srvBlockList.test(entry)
+        })
+
+        // 2. copy dedicated files like package.json, .npmrc to 'destRoot'
+        // project/srv -> 'gen/srv'
+        let srvAllowList = "package\\.json$" // always copy package.json, modify only if CONTENT_PACKAGE_JSON is true
+        srvAllowList += this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, true) ? "|package-lock\\.json$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_NPMRC, true) ? "|\\.npmrc$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_CDSRC_JSON, true) ? "|\\.cdsrc\\.json$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_ENV, true) ? "|\\.env($|\\..*$)" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? "|default-env\\.json$" : ""
+        srvAllowList = new RegExp(srvAllowList)
+        await Promise.all(srvRootFileNames.map(fileName => {
+            if (srvAllowList.test(fileName)) {
+                return this.copy(path.join(src, fileName)).to(path.join(destRoot, fileName))
+            }
+        }))
+        return srvRootFileNames
+    }
+
+    /**
+     * Copy dedicated files (files with project semantics like package.json, .npmrc, .cdsrc, etc.)
+     * from the given <em>src</em> folder (e.g. 'project') into the given <em>dest</em> folder (e.g. 'project/gen/srv')
+     * @param {*} src 
+     * @param {*} dest 
+     * @param {*} filter - copy file if filter function returns true
+     */
+    async _copyProjectRootContent(src, dest, filter) {
+        let { folders = ['i18n'] } = this.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
+        srvAllowList += this.hasBuildOption(CONTENT_PACKAGELOCK_JSON, true) ? "|package-lock\\.json$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_NPMRC, true) ? "|\\.npmrc$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_CDSRC_JSON, true) ? "|\\.cdsrc\\.json$" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_ENV, true) ? "|\\.env($|\\..*$)" : ""
+        srvAllowList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? "|default-env\\.json$" : ""
+        srvAllowList = new RegExp(srvAllowList)
+
+        await super.copyNativeContent(src, dest, (entry) => {
+            if (fs.statSync(entry).isDirectory()) {
+                return folders.some(folder => entry.startsWith(folder))
+            }
+            if (/\.js$|\.properties$/.test(entry)) {
+                return true
+            }
+            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) {
+                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 || {}
+                    content.engines.node = engines.node
+                    return true
+                }
+            }
+            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)
+        }
+    }
+}
+
+module.exports = NodeCfModuleBuilder

package/bin/build/util.js

@@ -1,4 +1,4 @@
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs')
 const path = require('path')
 const { SEVERITY_ERROR } = require('./constants')
 
@@ -84,36 +84,13 @@ async function isOldJavaStack(dirs) {
     const files = readPomFilePaths(dirs)
     if (files.length > 0) {
         return (await Promise.all(files.map(async file => {
-            const content = await fs.readFile(file, 'utf-8')
+            const content = await fs.promises.readFile(file, 'utf-8')
             return content && /<groupId>\s*com\.sap\.cloud\.servicesdk/.test(content) && !(/<groupId>\s*com\.sap\.cds\s*<\/groupId>/.test(content) && /<artifactId>\s*cds-/.test(content))
         }))).some(result => result)
     }
     return false
 }
 
-/**
- * Returns a promise that resolves after all of the given promises have either resolved or rejected,
- * with an array of objects that each describes the outcome of each promise.
- *
- * @param {*} promises An iterable object, such as an Array, in which each member is a Promise.
- * @returns A pending Promise that will be asynchronously fulfilled once every promise in the specified
- * collection of promises has completed, either by successfully being fulfilled or by being rejected.
- * At that time, the returned promise's handler is passed as input an array containing the outcome of
- * each promise in the original set of promises.<br>
- * For each outcome object, a status string is present. If the status is fulfilled, then a value is present.
- * If the status is rejected, then a reason is present. The value (or reason) reflects what value each
- * promise was fulfilled (or rejected) with.
- */
-function allSettled(promises) {
-    let wrappedPromises = Array.from(promises).map(p =>
-        Promise.resolve(p).then(
-            val => ({ state: 'fulfilled', value: val }),
-            err => ({ state: 'rejected', reason: err })
-        )
-    );
-    return Promise.all(wrappedPromises);
-}
-
 function redactCredentials(config, o) {
     return JSON.stringify(config, (k, v) => {
         if (!v) {
@@ -128,10 +105,6 @@ function redactCredentials(config, o) {
     }, o && o.indents || 2)
 }
 
-function isAbsolutePath(pathName) {
-    return /^(?:\/|[a-z]+:\/\/)/.test(pathName)
-}
-
 /** redacts password-like strings, also reducing clutter in output */
 function _redacted(cred) {
     const secrets = /(password)|(certificate)|(ca)/i // 'certificate' and 'ca' on HANA
@@ -142,6 +115,22 @@ function _redacted(cred) {
     return newCred
 }
 
+/**
+ * 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
+ */
+function isStreamlinedMtx(cds) {
+    if (process.env.OLD_MTX) return false
+    return !cds.mtx && (cds.env.get("requires.toggles") !== undefined
+        || cds.env.requires['cds.xt.ModelProviderService']
+        || cds.env.get("requires.multitenancy.streamlined") === true
+        || (typeof cds.env.get("requires.multitenancy") === "object" && cds.env.get("requires.multitenancy.streamlined") === undefined))
+}
+
 class BuildMessage extends Error {
     constructor(message, severity) {
         super(message)
@@ -175,11 +164,10 @@ module.exports = {
     setProperty,
     hasJavaNature,
     isOldJavaStack,
-    allSettled,
     redactCredentials,
     hasOptionValue,
     relativePaths,
-    isAbsolutePath,
+    isStreamlinedMtx,
     BuildMessage,
     BuildError
 }

package/bin/cds.js

@@ -16,11 +16,13 @@ const cli = { //NOSONAR
     if (process.env.NODE_ENV !== 'test')  this.errorHandlers()
     if (cmd in this.Shortcuts) cmd = process.argv[2] = this.Shortcuts[cmd]
     let task = this.load ('./'+cmd)
-    if (task)  return task.apply (this, this.args(task,argv))
+    if (task && cmd !== 'build')  return task.apply (this, this.args(task,argv))
 
-    // delegate to cds-dk for rest of commands (usually shortcuts like `cds c`)
+    // delegate to cds-dk for rest of commands (usually shortcuts like `cds c` including cds build if cds-dk is available)
     const dk = _requireDk('cds')
-    return dk ? dk.exec(cmd, ...argv) : _die_needsDk (cmd)
+    if (dk) return dk.exec(cmd, ...argv)
+    if (cmd === 'build') return task.apply (this, this.args(task,argv))
+    _die_needsDk (cmd)
   },
 
   load (cmd) {

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

@@ -1,4 +1,7 @@
 const cp = require('child_process');
+const fsp = require('fs').promises;
+const os = require('os');
+const path = require('path');
 
 const cds = require('../../../lib');
 const LOG = cds.log ? cds.log('deploy') : console;
@@ -27,6 +30,7 @@ class CfUtil {
     async _cfRun(...args) {
         const cmdLine = `${CF_COMMAND} ${args.join(' ')}`;
         if (DEBUG) {
+            // eslint-disable-next-line no-console
             console.time(cmdLine);
             LOG.debug('>>> ' + cmdLine);
         }
@@ -65,6 +69,7 @@ class CfUtil {
                 });
             });
         } finally {
+            // eslint-disable-next-line no-console
             DEBUG && console.timeEnd(cmdLine);
         }
     }
@@ -100,22 +105,42 @@ class CfUtil {
         return match[1];
     }
 
+    async getCfTargetFromConfigFile() {
+        const cfHome = process.env.CF_HOME || process.env.cf_home || path.join(os.homedir(), '.cf');
+        try {
+            const fileContent = await fsp.readFile(path.join(cfHome, 'config.json'));
+            const config = JSON.parse(fileContent);
+            if (config) {
+                return {
+                    apiEndpoint: this._extract(config.Target, /\s*(.+)\s*/, `CF API endpoint is missing. Use 'cf login' to login.`),
+                    org: this._extract(config.OrganizationFields.Name, /\s*(.+)\s*/, `CF org is missing. Use 'cf target -o <ORG> to specify.`),
+                    space: this._extract(config.SpaceFields.Name, /\s*(.+)\s*/, `CF space is missing. Use 'cf target -s <SPACE>' to specify.`)
+                }
+            }
+        } catch (err) {
+            LOG.debug(`getCfTargetFromConfigFile: ${err}`);
+        }
+    }
+
     async getCfTargetFromCli() {
         const result = await this._cfRun('target');
-
         return {
-            apiEndpoint: this._extract(result, /api endpoint\s*:\s*(.*)/i, `CF API endpoint is missing. Use 'cf login' to login.`),
-            user: this._extract(result, /user\s*:\s*(.*)/i, `CF user is missing. Use 'cf login' to login.`),
-            org: this._extract(result, /org\s*:\s*(.*)/i, `CF org is missing. Use 'cf target -o <ORG> to specify.`),
-            space: this._extract(result, /space\s*:\s*(.*)/i, `CF space is missing. Use 'cf target -s <SPACE>' to specify.`),
+            apiEndpoint: this._extract(result, /api endpoint\s*:\s*(.+)/i, `CF API endpoint is missing. Use 'cf login' to login.`),
+            user: this._extract(result, /user\s*:\s*(.+)/i, `CF user is missing. Use 'cf login' to login.`),
+            org: this._extract(result, /org\s*:\s*(.+)/i, `CF org is missing. Use 'cf target -o <ORG> to specify.`),
+            space: this._extract(result, /space\s*:\s*(.+)/i, `CF space is missing. Use 'cf target -s <SPACE>' to specify.`),
         };
     }
 
+    async getCfTarget() {
+        return await this.getCfTargetFromConfigFile() || await this.getCfTargetFromCli();
+    }
+
     async getCfSpaceInfo() {
         if (!this.spaceInfo) {
             DEBUG && LOG.debug('getting space info');
 
-            const target = await this.getCfTargetFromCli();
+            const target = await this.getCfTarget();
 
             const { org, space } = target;
             const orgs = await this._cfRequest(`/v3/organizations`, { names: org });