@sap/cds 6.1.3 → 6.2.1

package/bin/build/buildTaskEngine.js

@@ -1,10 +1,10 @@
 const fs = require('fs')
 const path = require('path')
 const _cds = require('./cds'), { log } = _cds.exec
-const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
 const { sortMessagesSeverityAware, deduplicateMessages, CompilationError } = require('@sap/cds-compiler')
-const { relativePaths, BuildError, BuildMessage } = require('./util')
+const { relativePaths, BuildError, BuildMessage, resolveRequiredSapModels } = require('./util')
 const { OUTPUT_MODE_DEFAULT, SEVERITIES, LOG_LEVELS, LOG_MODULE_NAMES } = require('./constants')
+const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
 const BuildTaskHandlerInternal = require('./provider/buildTaskHandlerInternal')
 
 const COMPILATION_ERROR = 'CompilationError'
@@ -27,7 +27,6 @@ class BuildTaskEngine {
     }
 
     async processTasks(tasks, buildOptions, clean = true) {
-        const handlers = []
         const startTime = Date.now()
 
         if (buildOptions) {
@@ -49,6 +48,18 @@ class BuildTaskEngine {
             buildOptions.target = path.resolve(buildOptions.root, this.env.build.target)
         }
 
+        // validate required @sap namespace models - log only
+        const { unresolved, missing } = this._resolveRequiredSapServices(tasks)
+        const messages = []
+        if (unresolved.length > 0) {
+            messages.push(new BuildMessage(`Required CDS service models [${unresolved.join(', ')}] cannot be resolved. Make sure to install the missing npm modules.`))
+        }
+        if (missing.length > 0) {
+            messages.push(new BuildMessage(`Required CDS service models [${missing.join(', ')}] are missing in custom build tasks. Make sure to add the missing models.`))
+        }
+
+        // create build task handlers
+        const handlers = []
         tasks.forEach((task) => {
             if (task) {
                 const handler = this._createHandler(task, buildOptions)
@@ -62,17 +73,22 @@ class BuildTaskEngine {
         try {
             await this._executePrepare(handlers, buildOptions)
             await this._executeCleanBuildTasks(handlers, buildOptions, clean)
+
+            // throwing Exception in case of compilation errors
             const buildResult = await this._executeBuildTasks(handlers, buildOptions)
-            await this._logBuildOutput(handlers, buildOptions)
-            this._logMessages(buildOptions, BuildTaskEngine._getHandlerMessages(handlers))
+
+            await this._writeGenerationLog(handlers, buildOptions)
+            this._logBuildOutput(handlers, buildOptions)
+            this._logMessages(buildOptions, [...BuildTaskEngine._getHandlerMessages(handlers), ...messages])
             this._logTimer(startTime, Date.now())
 
             return buildResult
         } catch (error) {
-            await this._logBuildOutput(handlers, buildOptions, false)
-            // cds CLI layer is doing the logging if invoked using CLI
+            this._logBuildOutput(handlers, buildOptions)
+            
+            // cds CLI layer logs in case of an exception if invoked from CLI
             if (!buildOptions.cli) {
-                this._logMessages(buildOptions, BuildTaskEngine._getErrorMessages([error]))
+                this._logMessages(buildOptions, [...BuildTaskEngine._getErrorMessages([error]), ...messages])
             }
 
             if (error.name === BuildError.name && error.errors.length > 0 && error.errors[0].constructor.name === COMPILATION_ERROR) {
@@ -128,7 +144,7 @@ class BuildTaskEngine {
             // clean entire build staging folder once
             if (buildOptions.target !== buildOptions.root) {
                 this.logger._debug && this.logger.debug(`cleaning staging folder ${buildOptions.target}`)
-                await fs.promises.rm(buildOptions.target, {force: true, recursive: true})
+                await fs.promises.rm(buildOptions.target, { force: true, recursive: true })
             }
 
             const results = await Promise.allSettled(handlers.map((handler) => {
@@ -249,7 +265,7 @@ class BuildTaskEngine {
         return files.map(file => path.relative(buildOptions.root, file))
     }
 
-    async _logBuildOutput(handlers, buildOptions, writeOutputFile = true) {
+    _logBuildOutput(handlers, buildOptions) {
         // log all generated files
         const files = this._getBuildOutput(handlers, buildOptions)
         if (files.length > 0) {
@@ -257,18 +273,18 @@ class BuildTaskEngine {
         } else {
             this.logger.log('done >')
         }
+    }
 
-        if (writeOutputFile) {
-            const outputFile = this.env.build.outputfile || process.env.GENERATION_LOG
-            if (outputFile) {
-                this.logger.log(`writing generation log to [${outputFile}]\n`)
-                await fs.promises.mkdir(path.dirname(outputFile), {recursive: true}).then(() =>
-                    fs.promises.writeFile(outputFile, files.join('\n'))
-                ).catch((error) => {
-                    this.logger.error(`failed to write generation log`)
-                    this.logger.error(error.stack || error)
-                    return Promise.resolve()
-                })
+    async _writeGenerationLog(handlers, buildOptions) {
+        const outputFile = this.env.build.outputfile || process.env.GENERATION_LOG
+        if (outputFile) {
+            const files = this._getBuildOutput(handlers, buildOptions)
+            this.logger.log(`writing generation log to [${outputFile}]\n`)
+            try {
+                await fs.promises.mkdir(path.dirname(outputFile), { recursive: true }).then(() => fs.promises.writeFile(outputFile, files.join('\n')))
+            } catch (error) {
+                this.logger.error(`failed to write generation log`)
+                this.logger.error(error.stack || error)
             }
         }
     }
@@ -283,7 +299,7 @@ class BuildTaskEngine {
     }
 
     _logMessages(buildOptions, messages) {
-        if (messages && messages.length > 0) {
+        if (messages.length > 0) {
             const options = {
                 log: this.logger.log,
                 "log-level": this._getLogLevel(buildOptions) // ensures that for tests the correct cds.env is used
@@ -293,6 +309,38 @@ class BuildTaskEngine {
         }
     }
 
+    _resolveRequiredSapServices(tasks) {
+        const taskModelPaths = tasks.reduce((acc, task) => {
+            const model = task.options?.model
+            if (model) {
+                if (Array.isArray(model)) {
+                    model.forEach(m => acc.add(m))
+                } else {
+                    acc.add(model)
+                }
+            }
+            return acc
+        }, new Set())
+
+        const srvModelPaths = [...Object.keys(this.env.requires || {}).reduce((acc, srvName) => {
+            const model = this.env.requires[srvName]?.model;
+            if (model) {
+                if (Array.isArray(model)) {
+                    model.forEach(m => acc.add(m))
+                } else {
+                    acc.add(model)
+                }
+            }
+            return acc
+        }, new Set())]
+
+        const unresolved = resolveRequiredSapModels(this.cds, [...taskModelPaths])
+        // are the required service models contained in the task's options.model
+        const missing = srvModelPaths.filter(m => m.startsWith('@sap/') && !taskModelPaths.has(m) && !unresolved.find(u => u === m))
+
+        return { unresolved, missing }
+    }
+
     /**
      * Returns a sorted and flatend list of all messages extracted from the given errors.
      * @param {Array<Error>} errors

package/bin/build/buildTaskFactory.js

@@ -81,9 +81,15 @@ class BuildTaskFactory {
         }
 
         // 3. filters the list of build tasks and adapts according to given CLI options
+        // Note: A new task will be created if invoked using CLI 'cds build --for <xxx>' 
+        // where <xxx> matches a valid task type like 'hana', 'java' etc.
         const existingTasks = tasks
         tasks = await this._applyCliTaskOptions(providerFactory, tasks)
 
+        if (tasks.length === 0) {
+            return tasks
+        }
+
         // 2. add dependencies
         await providerFactory.lookupTasks(tasks)
 
@@ -107,8 +113,10 @@ class BuildTaskFactory {
     }
 
     _applyCommonTaskDefaults(tasks, buildOptions) {
+        const modelPaths = this._getDefaultModelOptions(buildOptions.root)
+
         tasks.forEach(task => {
-            this._setTaskOptions(task, buildOptions.root)
+            this._setTaskModelOptions(task, modelPaths)
             if (!task.src) {
                 throw new Error(`Invalid build task definition - value of property 'src' is missing in [${task.for || task.use}].`)
             }
@@ -137,7 +145,7 @@ class BuildTaskFactory {
     _getDefaultModelOptions(projectPath) {
         const fts = this.env.features.folders
         const modelPaths = this.cds.resolve(!fts ? '*' : ['*', fts], false)
-        return this._pushModelPaths(projectPath, [], modelPaths)
+        return this._pushModelPaths(projectPath, modelPaths)
     }
 
     /**
@@ -206,16 +214,15 @@ class BuildTaskFactory {
         return tasks
     }
 
-    _setTaskOptions(task, projectPath) {
+    _setTaskModelOptions(task, defaultModelPaths) {
         task.options = task.options || {}
         if (!task.options.model || Array.isArray(task.options.model) && task.options.model.length === 0) {
-            const models = new Set(this._getDefaultModelOptions(projectPath))
+            defaultModelPaths = new Set(defaultModelPaths)
             if (task.src) {
-                models.add(task.src)
+                defaultModelPaths.add(task.src)
             }
-            task.options.model = [...models]
-        }
-        else if (!Array.isArray(task.options.model)) {
+            task.options.model = [...defaultModelPaths]
+        } else if (!Array.isArray(task.options.model)) {
             task.options.model = [task.options.model]
         }
     }
@@ -251,8 +258,8 @@ class BuildTaskFactory {
         return taskOptions
     }
 
-    _pushModelPaths(projectPath, model, ...modelPaths) {
-        model = new Set(model)
+    _pushModelPaths(projectPath, ...modelPaths) {
+        const model = new Set()
         // may contain nested arrays
         modelPaths = BuildTaskFactory._flatten(modelPaths)
         const { roots } = this.env
@@ -272,7 +279,7 @@ class BuildTaskFactory {
                 }
             }
         })
-        return [...model]
+        return model
     }
 
     static _flatten(modelPaths) {

package/bin/build/buildTaskHandler.js

@@ -86,7 +86,7 @@ class BuildTaskHandler {
     init() { }
 
     /**
-     * Called by the framework to create the artefacts of this build task handler.
+     * Called by the framework to create the artifacts of this build task handler.
      */
     async build() {
         throw new TypeError(OVERRIDE_METHOD_MSG)

package/bin/build/buildTaskProviderFactory.js

@@ -55,7 +55,7 @@ class BuildTaskProviderFactory {
         }))
     }
 
-    async lookupTasks(tasks=[]) {
+    async lookupTasks(tasks = []) {
         await Promise.all(this.providers.map(async (provider) => {
             const snapShot = tasks
             await this._lookupTasks(provider, tasks)
@@ -140,21 +140,11 @@ class BuildTaskProviderFactory {
     }
 
     async _lookupTasks(provider, tasks) {
-        try {
-            await provider.lookupTasks(tasks, this.buildOptions)
-        } catch (e) {
-            this.logger.error(`Build task provider ${provider.constructor.name} returned error:\n` + e)
-            throw e
-        }
+        return provider.lookupTasks(tasks, this.buildOptions)
     }
 
     async _applyTaskDefaults(provider, tasks) {
-        try {
-            return Promise.all(tasks.map(task => provider.applyTaskDefaults(task)))
-        } catch (e) {
-            this.logger.error(`Build task provider ${provider.constructor.name} returned error:\n` + e)
-            throw e
-        }
+        return Promise.all(tasks.map(task => provider.applyTaskDefaults(task)))
     }
 
     _loadProviders() {

package/bin/build/constants.js

@@ -17,7 +17,6 @@ exports.BUILD_TASK_MTX_SIDECAR = "mtx-sidecar"
 exports.BUILD_TASK_MTX_EXTENSION = "mtx-extension"
 exports.BUILD_TASKS = [this.BUILD_TASK_JAVA, this.BUILD_TASK_JAVA_CF, this.BUILD_TASK_NODEJS, this.BUILD_TASK_NODE_CF, this.BUILD_TASK_HANA, this.BUILD_TASK_FIORI, this.BUILD_TASK_MTX, this.BUILD_TASK_MTX_SIDECAR, this.BUILD_TASK_MTX_EXTENSION]
 
-exports.ODATA_VERSION = "odata.version"
 exports.ODATA_VERSION_V2 = "v2"
 exports.ODATA_VERSION_V4 = "v4"
 

package/bin/build/index.js

@@ -17,7 +17,6 @@ module.exports = Object.assign(build,
  */
 async function build(options = {}) {
     const projectPath = path.resolve(options.project || '.')
-
     if (!fs.lstatSync(projectPath).isDirectory()) {
         return Promise.reject(`Project [${projectPath}] does not exist`)
     }
@@ -25,15 +24,24 @@ async function build(options = {}) {
     const cds = require('./cds')
     if (projectPath !== process.cwd()) {
         const env = cds.env.for('cds', projectPath);
-        cds.env = env
-        cds.root = projectPath
+        cds.env = env // REVISIT: not good / fragile
+        cds.root = projectPath // REVISIT: not good / fragile
     }
     const logger = options.logger || cds.log(LOG_MODULE_NAMES)
-
     const buildOptions = _mergeCliOptions({ root: projectPath }, options)
+    const buildTaskFactory = new BuildTaskFactory(logger)
+    const buildTaskEngine = new BuildTaskEngine(logger)
 
-    let tasks = await new BuildTaskFactory(logger).getTasks(buildOptions)
-    return new BuildTaskEngine(logger).processTasks(tasks, buildOptions)
+    try {
+        const tasks = await buildTaskFactory.getTasks(buildOptions)
+        return buildTaskEngine.processTasks(tasks, buildOptions)
+    } catch (e) {
+        // cds CLI layer logs if invoked from CLI
+        if (!buildOptions.cli) {
+            buildTaskEngine._logMessages(buildOptions, [e])
+        }
+        throw e
+    }
 }
 
 function _mergeCliOptions(buildOptions, options) {

package/bin/build/provider/buildTaskHandlerEdmx.js

@@ -50,9 +50,8 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
         return Promise.all(promises)
     }
 
-    _isOdataProtocol(service) {
-        const { _protocol4Service } = this.cds.service.adapters
-        return /^odata/.test(_protocol4Service(service))
+    _isOdataProtocol(srv) {
+        return this.cds.service.protocols.protocol4(srv).startsWith('odata')
     }
 
     _options4odata() {

package/bin/build/provider/buildTaskHandlerFeatureToggles.js

@@ -72,7 +72,7 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
             return acc
         }, [])
 
-        // keep existing behaviour and return paths returned by cds.resolve if features are not supported by this project
+        // keep existing behavior and return paths returned by cds.resolve if features are not supported by this project
         if (!fs.existsSync(path.join(this.buildOptions.root, this.ftsName))) {
             return paths
         }
@@ -106,7 +106,7 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
             const ftCsn = await this.cds.load(ftsPaths[ftName], options)
             const ftPath = path.join(destFts, this.ftsName, ftName)
 
-            // replace require paths by base model path to ensure precedence of feature annos
+            // replace require paths by base model path to ensure precedence of feature annotations
             // see https://pages.github.tools.sap/cap/docs/cds/compiler-messages#anno-duplicate-unrelated-layer
             ftCsn.requires = [path.join(path.relative(ftPath, destBase), DEFAULT_CSN_FILE_NAME).replace(/\\/g,'/')]
 

package/bin/build/provider/buildTaskHandlerInternal.js

@@ -37,7 +37,7 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
     }
     /**
      * Custom build handlers are executed before internal handlers in order
-     * ensure and content cannot be overwriten by mistake.
+     * ensure and content cannot be overwritten by mistake.
      */
     get priority() {
         return BuildTaskHandlerInternal.PRIORITY_MAX_VALUE
@@ -140,19 +140,16 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
      * or in a separate staging folder which is not part of the build tasks src folder.
      */
     isStagingBuild() {
-        return this.task.src !== this.task.dest
+        return !this.task.src.startsWith(this.task.dest)
     }
 
     async copyNativeContent(srcDir, destDir, customFilter) {
-        if (!this.isStagingBuild()) {
-            return Promise.resolve()
-        }
         const files = BuildTaskHandlerInternal._find(srcDir, (src) => {
             // do not copy files that:
             // - are contained in the 'buildOptions.target' folder
             // - are contained in this modules 'dest' folder
             // - are contained in some generation folder
-            // - do NOT fullfill additional specific filter criteria
+            // - do NOT fulfill additional specific filter criteria
             return this._commonStagingBuildFilter(src, destDir) && (!customFilter || customFilter.call(this, src))
         })
         return Promise.all(

package/bin/build/provider/buildTaskProviderInternal.js

@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-const { hasJavaNature, getProperty, isStreamlinedMtx } = require('../util')
+const { hasJavaNature, getProperty, isStreamlinedMtx, BuildError } = require('../util')
 const BuildTaskProvider = require('../buildTaskProvider')
 
 const { FILE_EXT_CDS, BUILD_TASK_HANA, BUILD_TASK_FIORI, BUILD_TASK_JAVA, BUILD_TASK_JAVA_CF, BUILD_TASK_NODEJS, BUILD_TASK_NODE_CF, BUILD_TASK_MTX,
@@ -83,9 +83,15 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         }
         if (Array.isArray(db) && db.length > 0) {
             db = BuildTaskProviderInternal._getModuleFolder(projectPath, db) || null
+            if (!db && !addRequiredTasks) { // log once
+                this.logger.log("No database module found")
+            }
         }
         if (Array.isArray(srv) && srv.length > 0) {
             srv = BuildTaskProviderInternal._getModuleFolder(projectPath, srv) || null
+            if (!srv && !addRequiredTasks) { // log once
+                this.logger.log("No service module found")
+            }
         }
         // create required build tasks
         if (addRequiredTasks) {
@@ -143,7 +149,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         if (this._useHana(projectPath, buildOptions)) {
             this.logger.debug("found HANA database.")
             // legacy build supports dest property
-            const compileDest = this.env.get("data.dest")
+            const compileDest = this.env.data?.dest
             if (compileDest) {
                 //../db/src/gen
                 // compileDest is relative to src folder in modular build - resolve correctly
@@ -163,62 +169,72 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
     _useHana(projectPath, buildOptions) {
         if (getProperty(buildOptions, "for.hana.skipManifestGeneration") // deprecated fallback for webide fullstack and mtx
             || getProperty(buildOptions, "for.hana.contentManifest") === false // fallback for webide fullstack and mtx
-            || this.env.get("requires.db.kind") === "hana"
-            || this.env.get("requires.db.dialect") === "hana") {
+            || this.env.requires.db?.kind === "hana"
+            || this.env.requires.db?.dialect === "hana") {
 
             return true
         }
         // false if other db has been defined
-        if (this.env.get("requires.db.kind")) {
+        if (this.env.requires.db?.kind) {
             return false
         }
         // check whether cds config represents a legacy build system config for which requires.db was not configured
         // Note: compat layer sets requires.db: {}
         const userEnv = this.cds.env.for("cds", projectPath, false)
-        return userEnv && (userEnv.get("data.model") || userEnv.get("service.model"))
+        return userEnv && (userEnv.data?.model || userEnv.service?.model)
     }
 
     _createMtxTask(projectPath, src, dest, tasks) {
-        let task = null
-        const isJava = tasks.some(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)
-        const isNode = tasks.some(task => task.for === BUILD_TASK_NODEJS || task.for === BUILD_TASK_NODE_CF)
-
+        // MTX build task creation is NOT supported for Java projects
+        if (tasks.find(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)) {
+            return null
+        }
         this.logger.debug("determining mtx type for nodejs")
-        if (isStreamlinedMtx(this.cds) && !isJava) {
-            if (this.env.requires["cds.xt.ModelProviderService"]) {
-                // sidecar scenario for Nodejs or Java
-                const sidecarEnv = this.env.for("cds", path.join(projectPath, MTX_SIDECAR_FOLDER))
-                if (BuildTaskProviderInternal._isSidecar(sidecarEnv)) {
-                    task = {
+
+        if (isStreamlinedMtx(this.cds)) {
+            if (this.env.requires["cds.xt.ModelProviderService"]?.kind === "rest") { // "cds.xt.ModelProviderService": "from-sidecar"
+                this.logger.debug("Nodejs Streamlined MTX app with sidecar")
+
+                const sidecarPath = path.join(projectPath, MTX_SIDECAR_FOLDER)
+                if (!fs.existsSync(sidecarPath)) {
+                    throw new BuildError("CDS build failed", `MTX sidecar directory '${sidecarPath}' not existing. Custom build task configuration necessary if the folder is named differently.`)
+                }
+                const sidecarEnv = this.env.for("cds", sidecarPath)
+                if (sidecarEnv.requires["cds.xt.ModelProviderService"]?.kind === "in-sidecar") {
+                    return {
                         for: BUILD_TASK_MTX_SIDECAR
                     }
-                    this.logger.debug(`${isJava ? "Java" : "Nodejs"} MTX sidecar scenario`)
-                } else {
-                    throw Error(`MTX sidecar module '${MTX_SIDECAR_FOLDER}' not found`)
                 }
-            } else if (isNode) {
-                task = {
-                    for: BUILD_TASK_MTX,
-                    src
-                }
-                this.logger.debug("Nodejs MTX scenario without sidecar")
+                throw new BuildError("CDS build failed", 'Invalid MTX sidecar configuration. Make sure to add required service "cds.xt.ModelProviderService": "in-sidecar".')
             }
-        } else if (BuildTaskProviderInternal._isExtension(this.env)) {
-            // streamlined mtx extension project
-            task = {
+
+            if (this.env.requires["cds.xt.ModelProviderService"]?.kind === "in-sidecar") {
+                // cds build is executed in sidecar folder
+                throw new BuildError("CDS build failed", "Invalid working directory. Make sure to execute 'cds build' in CAP project root directory.")
+            }
+
+            this.logger.debug("Nodejs Streamlined MTX app without sidecar")
+            return {
+                for: BUILD_TASK_MTX,
+                src
+            }
+        }
+
+        if (BuildTaskProviderInternal._isExtension(this.env)) {
+            this.logger.debug("Streamlined MTX extension app")
+            return {
                 for: BUILD_TASK_MTX_EXTENSION
             }
-            this.logger.debug("Streamlined MTX extension")
-        } else if (this.env.get("requires.multitenancy") && isNode) {
-            // classic mtx
-            task = {
+        }
+
+        if (this.env.requires.multitenancy) {
+            this.logger.debug("Nodejs Classic MTX app without sidecar")
+            return {
                 src: ".",
                 for: BUILD_TASK_MTX,
                 dest
             }
-            this.logger.debug("classic Nodejs MTX scenario")
         }
-        return task
     }
 
     _createSrvTask(projectPath, src, taskOptions) {
@@ -238,7 +254,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
     _createJavaTask(projectPath, src, taskOptions) {
         this.logger.debug("found implementation technology java")
         // legacy build supports dest property
-        const compileDest = this.env.get("service.dest")
+        const compileDest = this.env.service?.dest
         if (compileDest) {
             // compileDest is relative to src folder in modular build - resolve correctly
             taskOptions.compileDest = path.relative(path.resolve(projectPath, src), path.resolve(projectPath, compileDest))
@@ -259,10 +275,6 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         }
     }
 
-    static _isSidecar(env) {
-        return env.requires['cds.xt.ModelProviderService']?.kind === "in-sidecar"
-    }
-
     static _isExtension(env) {
         return !!env.extends
     }

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

@@ -3,7 +3,7 @@ const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
 const URL = require('url')
 const { getProperty, isOldJavaStack, relativePaths } = require('../../util')
 
-const { ODATA_VERSION, ODATA_VERSION_V2, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, BUILD_TASK_FIORI, BUILD_TASK_JAVA_CF, CDS_CONFIG_PATH_SEP, BUILD_TASK_JAVA } = require('../../constants')
+const { ODATA_VERSION_V2, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY, BUILD_TASK_FIORI, BUILD_TASK_JAVA_CF, CDS_CONFIG_PATH_SEP, BUILD_TASK_JAVA } = require('../../constants')
 
 /**
  * With cds 4 service metadata for the UI service binding is no longer created by default.
@@ -44,14 +44,14 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
         fioriBuildOptions[BUILD_OPTION_OUTPUT_MODE] = OUTPUT_MODE_RESULT_ONLY
 
         try {
-            const edmxOptions = { version: this.env.get(ODATA_VERSION) }
+            const edmxOptions = { version: this.env.odata?.version }
 
             if (edmxOptions.version !== ODATA_VERSION_V2) {
                 const javaTask = this.buildOptions.tasks.find(task => task.for === BUILD_TASK_JAVA_CF || task.for === BUILD_TASK_JAVA)
 
                 if (javaTask
                     && await isOldJavaStack([javaTask.src, this.buildOptions.root])
-                    && !this.env.for("cds", this.buildOptions.root, false).get(ODATA_VERSION)) {
+                    && !this.env.for("cds", this.buildOptions.root, false).odata?.version) {
 
                     // old java stack
                     // default is now v4 and not v2 anymore, so overwrite with v2 if using default

package/bin/build/provider/hana/2migration.js

@@ -97,7 +97,7 @@ function _getNewMigrationEntry(changeset, currentVersion) {
   if (changeset && changeset.length > 0) {
     const dropColumns = changeset.some(e => e.drop)
     const manualChange = changeset.some(e => !e.sql)
-    const enableDrop = cds.env.get('hana.journal.enable-drop')
+    const enableDrop = cds.env.hana?.journal?.['enable-drop']
     const content = changeset.reduce((acc, e) => {
       if (!acc) {
         acc = `== migration=${currentVersion + 1}\n`