@sap/cds 6.3.1 → 6.4.0

package/bin/build/buildTaskEngine.js

@@ -1,6 +1,6 @@
 const fs = require('fs')
 const path = require('path')
-const _cds = require('./cds'), { log } = _cds.exec
+const cds = require('./cds'), { log } = cds.exec
 const { sortMessagesSeverityAware, deduplicateMessages, CompilationError } = require('@sap/cds-compiler')
 const { relativePaths, BuildError, BuildMessage, resolveRequiredSapModels, hasJavaNature } = require('./util')
 const { OUTPUT_MODE_DEFAULT, SEVERITIES, LOG_LEVELS, LOG_MODULE_NAMES, CDS_MODEL_EXCLUDE_LIST } = require('./constants')
@@ -11,16 +11,8 @@ const COMPILATION_ERROR = 'CompilationError'
 const COMPILE_MESSAGE = 'CompileMessage'
 
 class BuildTaskEngine {
-    constructor(logger, cds) {
-        this._cds = cds ? cds : _cds
-        this._logger = logger || this._cds.log(LOG_MODULE_NAMES)
-    }
-
-    get cds() {
-        return this._cds
-    }
-    get env() {
-        return this._cds.env
+    constructor(logger) {
+        this._logger = logger || cds.log(LOG_MODULE_NAMES)
     }
     get logger() {
         return this._logger
@@ -43,16 +35,16 @@ class BuildTaskEngine {
         }
 
         this.logger.log(`building project [${buildOptions.root}], clean [${clean}]`)
-        this.logger.log(`cds [${_cds.version}], compiler [${_cds.compiler.version()}], home [${_cds.home}]\n`)
+        this.logger.log(`cds [${cds.version}], compiler [${cds.compiler.version()}], home [${cds.home}]\n`)
 
         if (!buildOptions.target) {
-            buildOptions.target = path.resolve(buildOptions.root, this.env.build.target)
+            buildOptions.target = path.resolve(buildOptions.root, cds.env.build.target)
         }
 
         // Java projects don't have node modules installed on project root level
         if (!hasJavaNature([buildOptions.root])) {
             // validate required @sap namespace models - log only
-            const { unresolved, missing } = this._resolveRequiredSapServices(tasks)
+            const { unresolved, missing } = BuildTaskEngine._resolveRequiredSapServices(tasks)
             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.`))
             }
@@ -155,7 +147,7 @@ class BuildTaskEngine {
                 return handler.clean()
             }))
             // check for errors and throw exception
-            this._resolveHandlerResponse(results, buildOptions)
+            BuildTaskEngine._resolveHandlerResponse(results, buildOptions)
         }
     }
 
@@ -182,7 +174,7 @@ class BuildTaskEngine {
         const results = await this._executePipeline(buildOptions, buildPipeline)
 
         // check for errors and throw exception - return results otherwise including any compiler and build status messages
-        return this._resolveHandlerResponse(results, buildOptions, BuildTaskEngine._getHandlerMessages(handlers))
+        return BuildTaskEngine._resolveHandlerResponse(results, buildOptions, BuildTaskEngine._getHandlerMessages(handlers))
     }
 
     async _executePipeline(buildOptions, pipeline) {
@@ -195,7 +187,7 @@ class BuildTaskEngine {
                         return Promise.resolve({
                             task: handler.task,
                             result: handlerResult,
-                            messages: this._sortCompilationErrorsUnique(buildOptions, handler.messages)
+                            messages: BuildTaskEngine._sortCompilationErrorsUnique(buildOptions, handler.messages)
                         })
                     })
             }))
@@ -204,7 +196,7 @@ class BuildTaskEngine {
         return allResults
     }
 
-    _resolveHandlerResponse(results, buildOptions, handlerMessages = []) {
+    static _resolveHandlerResponse(results, buildOptions, handlerMessages = []) {
         const errors = []
         const resolvedResults = results.reduce((acc, r) => {
             if (r.status === 'fulfilled') {
@@ -228,7 +220,7 @@ class BuildTaskEngine {
             // 1. compiler warnings are returned as handler messages
             const compileMessages = handlerMessages.filter(message => message.constructor.name === COMPILE_MESSAGE)
             if (compileErrors.length > 0) {
-                const compileError = new CompilationError(this._sortCompilationErrorsUnique(buildOptions, BuildTaskEngine._getErrorMessages(compileErrors), compileMessages))
+                const compileError = new CompilationError(BuildTaskEngine._sortCompilationErrorsUnique(buildOptions, BuildTaskEngine._getErrorMessages(compileErrors), compileMessages))
                 buildErrors.push(compileError)
             }
 
@@ -245,7 +237,7 @@ class BuildTaskEngine {
 
     _createHandler(task, buildOptions) {
         try {
-            const providerFactory = new BuildTaskProviderFactory(this._logger, this._cds, buildOptions)
+            const providerFactory = new BuildTaskProviderFactory(this._logger, buildOptions)
             const handler = providerFactory.createHandler(task)
             handler.init()
 
@@ -263,14 +255,9 @@ class BuildTaskEngine {
         }
     }
 
-    _getBuildOutput(handlers, buildOptions) {
-        const files = handlers.reduce((acc, handler) => acc.concat(handler.files), []).sort()
-        return files.map(file => path.relative(buildOptions.root, file))
-    }
-
     _logBuildOutput(handlers, buildOptions) {
         // log all generated files
-        const files = this._getBuildOutput(handlers, buildOptions)
+        const files = BuildTaskEngine._getBuildOutput(handlers, buildOptions)
         if (files.length > 0) {
             this.logger.log(`done > wrote output to:\n   ${files.join("\n   ")}\n`)
         } else {
@@ -279,9 +266,9 @@ class BuildTaskEngine {
     }
 
     async _writeGenerationLog(handlers, buildOptions) {
-        const outputFile = this.env.build.outputfile || process.env.GENERATION_LOG
+        const outputFile = cds.env.build.outputfile || process.env.GENERATION_LOG
         if (outputFile) {
-            const files = this._getBuildOutput(handlers, buildOptions)
+            const files = BuildTaskEngine._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')))
@@ -292,6 +279,11 @@ class BuildTaskEngine {
         }
     }
 
+    static _getBuildOutput(handlers, buildOptions) {
+        const files = handlers.reduce((acc, handler) => acc.concat(handler.files), []).sort()
+        return files.map(file => path.relative(buildOptions.root, file))
+    }
+
     _logTimer(start, end) {
         this.logger.log(`build completed in ${end - start} ms\n`)
     }
@@ -305,14 +297,14 @@ class BuildTaskEngine {
         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
+                "log-level": BuildTaskEngine._getLogLevel(buildOptions) // ensures that for tests the correct cds.env is used
             }
             deduplicateMessages(messages)
             log(messages, options)
         }
     }
 
-    _resolveRequiredSapServices(tasks) {
+    static _resolveRequiredSapServices(tasks) {
         const taskModelPaths = tasks.reduce((acc, task) => {
             const model = task.options?.model
             if (model) {
@@ -325,8 +317,8 @@ class BuildTaskEngine {
             return acc
         }, new Set())
 
-        const srvModelPaths = [...Object.keys(this.env.requires || {}).reduce((acc, srvName) => {
-            const model = this.env.requires[srvName]?.model;
+        const srvModelPaths = [...Object.keys(cds.env.requires || {}).reduce((acc, srvName) => {
+            const model = cds.env.requires[srvName]?.model;
             if (model) {
                 if (Array.isArray(model)) {
                     model.forEach(m => acc.add(m))
@@ -337,7 +329,7 @@ class BuildTaskEngine {
             return acc
         }, new Set())]
 
-        const unresolved = resolveRequiredSapModels(this.cds, [...taskModelPaths])
+        const unresolved = resolveRequiredSapModels([...taskModelPaths])
         // are the required service models contained in the task's options.model
         const missing = srvModelPaths.filter(m => m.startsWith('@sap/') && !CDS_MODEL_EXCLUDE_LIST.includes(m) && !taskModelPaths.has(m) && !unresolved.find(u => u === m))
 
@@ -376,7 +368,7 @@ class BuildTaskEngine {
      * @param {object} buildOptions
      * @param  {...Error} messages
      */
-    _sortCompilationErrorsUnique(buildOptions, ...messages) {
+    static _sortCompilationErrorsUnique(buildOptions, ...messages) {
         const logLevelIdx = LOG_LEVELS.indexOf(this._getLogLevel(buildOptions))
         // flatten
         messages = messages.reduce((acc, m) => acc.concat(m), [])
@@ -392,8 +384,8 @@ class BuildTaskEngine {
      * Return user defined log level or default value 'warn'
      * @param {string} buildOptions
      */
-    _getLogLevel(buildOptions) {
-        return buildOptions["log-level"] || this.env["log-level"]
+    static _getLogLevel(buildOptions) {
+        return buildOptions["log-level"] || cds.env["log-level"]
     }
 }
 module.exports = BuildTaskEngine

package/bin/build/buildTaskFactory.js

@@ -1,38 +1,31 @@
 const fs = require('fs')
 const path = require('path')
-const _cds = require('./cds'), { log } = _cds.exec
+const cds = require('./cds'), { log } = cds.exec
 const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
-const { hasJavaNature, getProperty, redactCredentials } = require('./util')
+const { hasJavaNature, getProperty, redactCredentials, flatten, getDefaultModelOptions } = require('./util')
 const { FILE_EXT_CDS, BUILD_TASK_JAVA_CF, LOG_MODULE_NAMES, BUILD_TASK_JAVA } = require("./constants")
 
 class BuildTaskFactory {
-    constructor(logger, cds) {
-        this._cds = cds ? cds : _cds
-        this._logger = logger || this._cds.log(LOG_MODULE_NAMES)
-    }
-    get cds() {
-        return this._cds
-    }
-    get env() {
-        return this._cds.env
+    constructor(logger) {
+        this._logger = logger || cds.log(LOG_MODULE_NAMES)
     }
     get logger() {
         return this._logger
     }
 
     // the following order for determining build tasks is used
-    // 1. create from commandline input, e.g. cds build/all --for hana --src db --model srv --dest db
+    // 1. create from command line input, e.g. cds build/all --for hana --src db --model srv --dest db
     // 2. read using cds.env.build.tasks
     // 3. create from cds.env.folders config data
     async getTasks(buildOptions = { root: process.env._TEST_CWD || process.cwd() }) {
         try {
-            const providerFactory = new BuildTaskProviderFactory(this._logger, this._cds, buildOptions)
+            const providerFactory = new BuildTaskProviderFactory(this._logger, buildOptions)
             const tasks = await this._createTasks(providerFactory)
-            buildOptions.target = path.resolve(buildOptions.root, this.env.build.target)
+            buildOptions.target = path.resolve(buildOptions.root, cds.env.build.target)
 
             // log build tasks
             this.logger.log(`the following build tasks will be executed`)
-            let tasksOutput = "   {\n     \"build\": {\n       \"target\": \"" + this.env.build.target + "\",\n       \"tasks\": ["
+            let tasksOutput = "   {\n     \"build\": {\n       \"target\": \"" + cds.env.build.target + "\",\n       \"tasks\": ["
             for (let i = 0; i < tasks.length; i++) {
                 tasksOutput += "\n         " + BuildTaskFactory._stringifyTask(tasks[i]) + (i + 1 < tasks.length ? "," : "")
             }
@@ -41,7 +34,7 @@ class BuildTaskFactory {
 
             // for testing purposes
             this.logger.debug("cds.env used for build:")
-            this.logger._debug && this.logger.debug(redactCredentials(this.env))
+            this.logger._debug && this.logger.debug(redactCredentials(cds.env))
 
             // always resolve tasks for input validation
             if (buildOptions.resolve || buildOptions.cli) {
@@ -65,12 +58,11 @@ class BuildTaskFactory {
         const buildOptions = providerFactory.buildOptions
         this.logger.log(`determining build tasks for project [${buildOptions.root}].`)
 
-        // clear model cache - see https://github.tools.sap/cap/cds/pull/181
-        // Required as cds.serve is invoking cds.resolve('*') which caused cds to cache the current model state
-        // which in turn screwed-up all subsequent tests - see ./lib/compile/resolve.js#L67 and ./lib/compile/resolve.js#L58
-        this.cds.resolve.cache = {}
+        // clearing model cache (details https://github.tools.sap/cap/cds/pull/181) is no longer required 
+        // because of changes https://github.tools.sap/cap/cds/pull/1121
+        // cds.resolve.cache = {}
 
-        let tasks = this._getExistingTasks()
+        let tasks = BuildTaskFactory._getExistingTasks()
         if (tasks.length === 0) {
             tasks = await providerFactory.lookupTasks()
             await providerFactory.applyTaskDefaults(tasks)
@@ -84,7 +76,7 @@ class BuildTaskFactory {
         // 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)
+        tasks = await BuildTaskFactory._applyCliTaskOptions(providerFactory, tasks)
 
         if (tasks.length === 0) {
             return tasks
@@ -99,21 +91,21 @@ class BuildTaskFactory {
         }
 
         // obligatory task defaults shared by all tasks
-        this._applyCommonTaskDefaults(tasks, buildOptions)
+        BuildTaskFactory._applyCommonTaskDefaults(tasks, buildOptions)
 
         // ensure correct values for optional build task properties, error for missing mandatory properties
-        this._validateBuildTasks(tasks)
+        BuildTaskFactory._validateBuildTasks(tasks)
 
         this._setDefaultBuildTargetFolder(tasks, buildOptions)
         return tasks
     }
 
-    _getExistingTasks() {
-        return Array.isArray(getProperty(this.env, 'build.tasks')) ? JSON.parse(JSON.stringify(this.env.build.tasks)) : []
+    static _getExistingTasks() {
+        return Array.isArray(getProperty(cds.env, 'build.tasks')) ? JSON.parse(JSON.stringify(cds.env.build.tasks)) : []
     }
 
-    _applyCommonTaskDefaults(tasks, buildOptions) {
-        const modelPaths = this._getDefaultModelOptions(buildOptions.root)
+    static _applyCommonTaskDefaults(tasks, buildOptions) {
+        const modelPaths = getDefaultModelOptions(buildOptions.root)
 
         tasks.forEach(task => {
             this._setTaskModelOptions(task, modelPaths)
@@ -123,7 +115,7 @@ class BuildTaskFactory {
         })
     }
 
-    _validateBuildTasks(tasks) {
+    static _validateBuildTasks(tasks) {
         tasks.forEach(task => {
             if (!task.src) {
                 throw new Error(`Invalid build task definition - value of property 'src' is missing in [${task.for || task.use}].`)
@@ -133,19 +125,13 @@ class BuildTaskFactory {
 
     _setDefaultBuildTargetFolder(tasks, buildOptions) {
         const task = tasks.find(task => task.for === BUILD_TASK_JAVA_CF || task.for === BUILD_TASK_JAVA)
-        const srv = task ? task.src : BuildTaskFactory._getModuleFolder(buildOptions.root, BuildTaskFactory._flatten([this.env.folders.srv])) || "srv"
+        const srv = task ? task.src : BuildTaskFactory._getModuleFolder(buildOptions.root, flatten([cds.env.folders.srv])) || "srv"
 
         // Java projects use "." as the default build target folder
-        if (this._hasJavaNature(buildOptions.root, srv) && this._adaptBuildTargetSettingForJava(buildOptions.root)) {
+        if (BuildTaskFactory._hasJavaNature(buildOptions.root, srv) && BuildTaskFactory._adaptBuildTargetSettingForJava(buildOptions.root)) {
             this.logger.debug("using inplace build for java project instead of default staging build")
         }
-        buildOptions.target = path.resolve(buildOptions.root, this.env.build.target)
-    }
-
-    _getDefaultModelOptions(projectPath) {
-        const fts = this.env.features.folders
-        const modelPaths = this.cds.resolve(!fts ? '*' : ['*', fts], false)
-        return this._pushModelPaths(projectPath, modelPaths)
+        buildOptions.target = path.resolve(buildOptions.root, cds.env.build.target)
     }
 
     /**
@@ -153,7 +139,7 @@ class BuildTaskFactory {
      * @param {string} projectPath - the absolute project path
      * @param {string} src - the folder name of the service module
      */
-    _hasJavaNature(projectPath, src) {
+    static _hasJavaNature(projectPath, src) {
         return hasJavaNature([path.join(projectPath, src), projectPath])
     }
 
@@ -162,21 +148,21 @@ class BuildTaskFactory {
     * @param {string} projectPath
     * @returns {boolean} true if changed, false otherwise
     */
-    _adaptBuildTargetSettingForJava(projectPath) {
-        if (this.env.build.target !== ".") {
+    static _adaptBuildTargetSettingForJava(projectPath) {
+        if (cds.env.build.target !== ".") {
             // filter user settings of cds.env
-            const userEnv = this.env.for("cds", projectPath, false)
+            const userEnv = cds.env.for("cds", projectPath, false)
 
             // use helper as env.build might be undefined
             if (!getProperty(userEnv, "build.target")) {
-                this.env.build.target = "."
+                cds.env.build.target = "."
                 return true
             }
         }
         return false
     }
 
-    async _applyCliTaskOptions(providerFactory, tasks) {
+    static async _applyCliTaskOptions(providerFactory, tasks) {
         const { buildOptions } = providerFactory
         if (buildOptions.cmdOptions) {
             const options = buildOptions.cmdOptions
@@ -206,7 +192,7 @@ class BuildTaskFactory {
                     task.dest = options.dest
                 }
                 if (options.opts) {
-                    const opts = BuildTaskFactory._scanTaskOptionParams(options.opts)
+                    const opts = this._scanTaskOptionParams(options.opts)
                     task.options = task.options ? Object.assign(task.options, opts) : opts
                 }
             })
@@ -214,7 +200,7 @@ class BuildTaskFactory {
         return tasks
     }
 
-    _setTaskModelOptions(task, defaultModelPaths) {
+    static _setTaskModelOptions(task, defaultModelPaths) {
         task.options = task.options || {}
         if (!task.options.model || Array.isArray(task.options.model) && task.options.model.length === 0) {
             defaultModelPaths = new Set(defaultModelPaths)
@@ -258,41 +244,6 @@ class BuildTaskFactory {
         return taskOptions
     }
 
-    _pushModelPaths(projectPath, ...modelPaths) {
-        const model = new Set()
-        // may contain nested arrays
-        modelPaths = BuildTaskFactory._flatten(modelPaths)
-        const { roots } = this.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(BuildTaskFactory._normalizePath(m))
-                    } else if (fs.existsSync(dir + FILE_EXT_CDS)) { //might be cds file name, compability to old build configs
-                        model.add(m)
-                    }
-                } else {
-                    model.add(m)
-                }
-            }
-        })
-        return model
-    }
-
-    static _flatten(modelPaths) {
-        return modelPaths.reduce((acc, m) => {
-            if (Array.isArray(m)) {
-                acc = acc.concat(BuildTaskFactory._flatten(m))
-            } else if (m) {
-                acc.push(m)
-            }
-            return acc
-        }, [])
-    }
-
     /**
      * For valid paths remove trailing '/'. Otherwise return as is - important!!
      * @param {*} dir

package/bin/build/buildTaskHandler.js

@@ -1,5 +1,6 @@
 const path = require('path')
 const fs = require('fs').promises
+const cds = require('./cds')
 
 const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_DEFAULT, OUTPUT_MODE_RESULT_ONLY, SEVERITY_INFO, SEVERITY_WARNING, SEVERITY_ERROR, OVERRIDE_METHOD_MSG } = require('./constants')
 const { hasOptionValue, getProperty, relativePaths, BuildMessage } = require('./util')
@@ -190,7 +191,7 @@ class BuildTaskHandler {
         // $location paths are relative to current working dir by default - make sure a given project root folder is taken
         const options = { ...this.options(), cwd: this._buildOptions.root }
 
-        const model = await this._cds.load(files, options)
+        const model = await cds.load(files, options)
         if (!model) {
             return null
         }
@@ -214,7 +215,7 @@ class BuildTaskHandler {
      */
     _resolveModel() {
         const modelPaths = Array.isArray(this.task.options.model) && this.task.options.model.length > 0 ? this.task.options.model : !Array.isArray(this.task.options.model) && this.task.options.model || this.task.src
-        return this._cds.resolve(modelPaths, this._buildOptions)
+        return cds.resolve(modelPaths, this._buildOptions)
     }
     /** Determines whether the given build option value has been set for this build task.
       * If the value is omitted, the existence of the given property name is checked.

package/bin/build/buildTaskProvider.js

@@ -10,8 +10,8 @@ module.exports = class BuildTaskProvider {
     loadHandler(task) {
         // return module.require(`${this._plugin.path}/${task.for || this._getTaskId(task.use)}`)
     }
-    async lookupTasks(tasks) { }
-    async applyTaskDefaults(task) {
+    async lookupTasks(tasks, options) { }
+    async applyTaskDefaults(task, options) {
         // task.for = task.for || this._getTaskId(task.use)
     }
     _getTaskId(use) {

package/bin/build/buildTaskProviderFactory.js

@@ -1,24 +1,17 @@
 const fs = require('fs')
 const path = require('path')
-const _cds = require('./cds')
+const cds = require('./cds')
 const { OUTPUT_MODE_DEFAULT, LOG_MODULE_NAMES } = require("./constants")
 const BuildTaskProviderInternal = require('./provider/buildTaskProviderInternal')
 const BuildTaskProvider = require('./buildTaskProvider')
 
 class BuildTaskProviderFactory {
-    constructor(logger, cds, buildOptions) {
-        this._cds = cds ? cds : _cds
-        this._logger = logger || this._cds.log(LOG_MODULE_NAMES)
+    constructor(logger, buildOptions) {
+        this._logger = logger || cds.log(LOG_MODULE_NAMES)
         buildOptions.for = buildOptions.for || {}
         buildOptions.outputMode = buildOptions.outputMode || OUTPUT_MODE_DEFAULT
         this._buildOptions = buildOptions
     }
-    get cds() {
-        return this._cds
-    }
-    get env() {
-        return this._cds.env
-    }
     get logger() {
         return this._logger
     }
@@ -80,7 +73,6 @@ class BuildTaskProviderFactory {
 
         const handler = new BuildTaskHandlerClass()
         handler._task = resolvedTask
-        handler._cds = this.cds
         handler._logger = this.logger
         handler._buildOptions = this.buildOptions
         this.logger._debug && this.logger.debug(`created BuildTaskHandler [${resolvedTask.use}]`)
@@ -144,7 +136,7 @@ class BuildTaskProviderFactory {
     }
 
     async _applyTaskDefaults(provider, tasks) {
-        return Promise.all(tasks.map(task => provider.applyTaskDefaults(task)))
+        return Promise.all(tasks.map(task => provider.applyTaskDefaults(task, this.buildOptions)))
     }
 
     _loadProviders() {
@@ -154,7 +146,6 @@ class BuildTaskProviderFactory {
 
     _createProvider(clazz, plugin) {
         const provider = new clazz()
-        provider._cds = this.cds
         provider._logger = this.logger
         provider._plugin = plugin
         return provider
@@ -174,7 +165,7 @@ class DefaultBuildTaskProvider extends BuildTaskProvider {
             throw new Error(`Invalid build task definition [${task.for}] - property 'use' missing`)
         }
         try {
-            return require(require.resolve(task.use, { paths: [this._cds.root] }))
+            return require(require.resolve(task.use, { paths: [cds.root] }))
         }
         catch (e) {
             throw new Error(`Build task could not be resolved - module [${task.use}] cannot be loaded:\n` + e)

package/bin/build/constants.js

@@ -62,4 +62,3 @@ exports.LOG_LEVEL_DEBUG = "debug"
 exports.LOG_LEVELS = [exports.LOG_LEVEL_ERROR, exports.LOG_LEVEL_WARN, exports.LOG_LEVEL_INFO, exports.LOG_LEVEL_DEBUG]
 exports.LOG_MODULE_NAMES = "cds|build"
 exports.OVERRIDE_METHOD_MSG = "Must override method"
-exports.SEMVER_REGEX = /^(\D*)(\d+\.)?(\d+\.)?(\*|\d+)/

package/bin/build/provider/buildTaskHandlerEdmx.js

@@ -1,4 +1,5 @@
 const path = require('path')
+const cds = require('../cds')
 const BuildTaskHandlerFeatureToggles = require('./buildTaskHandlerFeatureToggles')
 const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = require('../constants')
 
@@ -7,7 +8,7 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
         const promises = []
 
         // generate edmx for services only that have the odata protocol
-        const serviceNames = this.cds.reflect(model).services
+        const serviceNames = cds.reflect(model).services
             .filter(service => this._isOdataProtocol(service))
             .map(service => service.name)
 
@@ -23,10 +24,10 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
             }
             this.logger._debug && this.logger.debug(`compiling edmx files using OData version ${options.version}`)
 
-            const result = this.cds.compile.to.edmx(model, options)
+            const result = cds.compile.to.edmx(model, options)
 
             if (result) {
-                let langs = this.task.options.lang || this.env.i18n.languages
+                let langs = this.task.options.lang || cds.env.i18n.languages
                 if (langs.split) { // string to array
                     langs = langs.split(',')
                 }
@@ -36,7 +37,7 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
                 for (let [content, key] of result) {
                     const serviceName = key.file ? key.file : key.name
                     this._result.services.add(serviceName)
-                    const locResult = this.cds.localize(model, langs, content)
+                    const locResult = cds.localize(model, langs, content)
                     if (locResult[Symbol.iterator]) { // multi result
                         for (let [localizedContent, { lang }] of locResult) {
                             promises.push(this._writeEdmxForLang(localizedContent, serviceName, lang, edmxDest))
@@ -51,12 +52,12 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
     }
 
     _isOdataProtocol(srv) {
-        return this.cds.service.protocols.protocol4(srv).startsWith('odata')
+        return cds.service.protocols.protocol4(srv).startsWith('odata')
     }
 
     _options4odata() {
         const o = this.options()
-        o.version = this.env.odata.version
+        o.version = cds.env.odata.version
         return o
     }
 

package/bin/build/provider/buildTaskHandlerFeatureToggles.js

@@ -1,5 +1,6 @@
 const fs = require('fs')
 const path = require('path')
+const cds = require('../cds')
 const { DEFAULT_CSN_FILE_NAME } = require('../constants')
 const BuildTaskHandlerInternal = require('./buildTaskHandlerInternal')
 
@@ -16,7 +17,7 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
     }
 
     get ftsName() {
-        return path.dirname(this.env.features.folders || 'fts/*')
+        return path.dirname(cds.env.features.folders || 'fts/*')
     }
 
     async compileAll(csn, destBase, destFts) {
@@ -25,7 +26,7 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
 
         if (sources.features) {
             // create base model as the given CSN is containing all features
-            dictionary.base = await this.cds.load(sources.base, this.options())
+            dictionary.base = await cds.load(sources.base, this.options())
         } else {
             // CSN already represents the base model as no features exist
             dictionary.base = csn
@@ -43,7 +44,7 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
     }
 
     async collectAllLanguageBundles(dictionary, paths, destBase, destFts) {
-        const i18nFolder = this.env.i18n.folders?.[0] || 'i18n'
+        const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
         // create language bundle for base model
         const i18n = await this.collectLanguageBundles(dictionary.base, path.join(destBase, i18nFolder))
         if (i18n) {
@@ -104,7 +105,7 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
 
         // create feature models
         for (const ftName in ftsPaths) {
-            const ftCsn = await this.cds.load(ftsPaths[ftName], options)
+            const ftCsn = await 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 annotations
@@ -121,7 +122,7 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
     async _validateFeature(ftPath) {
         // features must not have other than base model dependencies, cross feature dependencies are not supported
         // do not pass options.messages in order to avoid duplicate compiler messages
-        return this.cds.load([ftPath])
+        return cds.load([ftPath])
         // version 2.13.9 of compileSources does not read the requires definition of parsed CSNs
         // require('@sap/cds-compiler').compileSources({ '../..csn.json': baseCsn, 'feature.csn': ftCsn }, this.options())
     }