@sap/cds-dk 8.4.2 → 8.5.0

package/CHANGELOG.md

@@ -7,6 +7,33 @@ This project adheres to [Semantic Versioning](http://semver.org/).
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## Version 8.5.0 - 2024-11-26
+
+### Changed
+
+-  `cds import` now generates generic action/function in case of bound action/function collision and unbound function collision with @cds.validate = false.
+- `cds add typescript` creates projects with `cds-tsx` to run apps instead of former `cds-ts`.
+- `cds deploy` writes error output to `stderr`.
+- `cds add http` now evaluates mocks users when creating `Authorization` headers
+
+### Added
+
+- `cds debug` lets you debug Node.js applications running locally or in Cloud Foundry.
+- `cds watch --inspect` and `cds watch --inspect-brk` activate the debugger in the same way as the standard Node.js CLI options, i.e. they accept a `host:port` combination and `0` as values.
+- The existing `cds watch --debug` is now an alias to `cds watch --inspect`.
+- `cds add cloud-logging` adds cloud-logging as an alternative for application logging in Kyma.
+- `cds add cloud-logging --with-telemetry` or `cds add telemetry` adds cloud-logging as well as support for `cap-js/telemetry` plugin in Kyma.
+- `cds add handler` now also works for Node.js projects. It creates an implementation file for each service with event handlers for all entites and actions.
+- `cds add esm` creates ESM-compatible Node.js projects. Sample code added by `add sample` and `add handler` will respect this setting if added aftwards. Existing code will not be adjusted by `cds add esm`, though.
+
+### Fixed
+
+- `cds import` throws proper error message if Annotation element doesn't have Term attribute.
+- `cds add approuter` no longer enforces Node.js 22, which is not supporter by current `@sap/approuter` version 17. The previous Node.js version 20 is used again.
+- `cds add http` works for actions without parameters.
+- `cds add workzone` includes the `updateManifestJson` task on initial generation.
+- `cds build --ws` no longer creates migration tables in shared database or wrong workspace.
+
 ## Version 8.4.2 - 2024-11-19
 
 ### Changed
@@ -23,7 +50,6 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - `cds add hana` adds the `requires.db` entry to `.cdsrc.json` for Java projects.
 - `cds add data` creates decimal values with correct scale `0` if only precision is given, like in `Decimal(15)`.
 
-
 ## Version 8.4.1 - 2024-11-08
 
 ### Added

package/bin/debug.js

@@ -0,0 +1,90 @@
+module.exports = Object.assign(debug, {
+    options: ['--port', '--host'],
+    shortcuts: [],
+    flags: [/*'--vscode', '--k8s'*/],
+    help: `
+# SYNOPSIS
+
+    *cds debug* [<app>]
+
+    Debugs a CAP-based application in the Chrome Developer Tools.
+
+    If <app> is given, it's assumed to be running on the currently logged-in Cloud Foundry space.
+
+    If no <app> is given, the app in the current working is started with 'cds watch --debug'.
+
+# OPTIONS
+
+    *--host* the debug host (default: '127.0.0.1')
+
+    *--port* the debug port (default: 9229)
+
+# EXAMPLES
+
+    *cds debug*
+    *cds debug* bookshop-srv
+`})
+
+async function debug() {
+  const cds = require('../lib/cds')
+  const { fork, spawn, execSync, exec } = require('node:child_process')
+  const os = require('node:os').platform()
+
+  const [appName] = cds.cli.argv
+  const { port = 9229, host = '127.0.0.1', vscode } = cds.cli.options
+  const ide = vscode ? 'vscode' : 'chrome'
+
+  if (!appName) { // local app
+    const script = process.argv[1] // `.../cds` or `.../cds-tsx`
+    console.log(`Starting '${cds.utils.path.basename(script)} watch --debug'`)
+    fork(script, ['watch', '--debug']).on('error', e => { throw 'Failed to start debug process:' + e.message })
+  } else if (cds.cli.options.k8s) { // Kyma/Kubernetes
+    // to be implemented
+  } else { // Cloud Foundry
+    const script = `ps aux | grep '[n]ode' | awk '{print \\$2}' | head -n 1`
+    const pid = execSync(`cf ssh ${appName} -c "${script}"`, { encoding: 'utf-8', shell: true }).trim()
+    if (!pid) throw `Node.js process for app '${appName}' not found`
+    execSync(`cf ssh ${appName} -c "kill -usr1 ${pid}"`, { stdio: 'inherit' })
+    console.log(`Opening SSH tunnel for CF app '${appName}'`)
+    spawn('cf', ['ssh', '-N', '-L', `${port}:${host}:${port}`, appName], { stdio: 'inherit' })
+  }
+
+  const maxAttempts = 15
+  let attempts = 0
+
+  const openDevTools = async () => {
+    attempts++
+    try {
+      switch (ide) {
+        case 'chrome': {
+          const res = await fetch(`http://localhost:${port}/json/list`)
+          const data = await res.json()
+          if (!data?.length) throw 'No debugger found on port ' + port
+          const wsUrl = data[0].webSocketDebuggerUrl
+          let command
+          const url = `devtools://devtools/bundled/inspector.html?ws=${wsUrl.split('ws://')[1]}`
+          console.log(`Opening Chrome DevTools at ${url}`)
+          if (os === 'darwin') {
+            command = `open -a "Google Chrome" '${url}'`
+          } else if (os === 'win32') {
+            command = `start chrome "${url}"`
+          } else {
+            command = `google-chrome '${url}' || chromium-browser '${url}' || chromium '${url}'`
+          }
+          exec(command, (error) => { if (error) throw 'Failed to open DevTools: ' + error.message })
+          break
+        }
+        case 'vscode': {
+          // to be implemented
+        }
+      }
+    } catch (err) {
+      if (attempts < maxAttempts) {
+        setTimeout(openDevTools, 1000) // connection fails sometimes, retry
+      } else {
+        throw `Failed to connect to debugger after ${maxAttempts} attempts: ${err}`
+      }
+    }
+  }
+  openDevTools()
+}

package/bin/watch.js

@@ -1,6 +1,6 @@
-const watchOnlyOptions = ['--ext', '--livereload', '--open']
+const watchOnlyOptions = ['--ext', '--livereload', '--open', '--debug', '--inspect', '--inspect-brk']
 module.exports = Object.assign ( watch, {
-  flags: [ '--debug', '--in-memory', '--in-memory?', '--with-mocks' ],
+  flags: [ '--in-memory', '--in-memory?', '--with-mocks' ],
   options: [ '--port', ...watchOnlyOptions ],
   help: `
 # SYNOPSIS
@@ -42,6 +42,16 @@ module.exports = Object.assign ( watch, {
     Specify from which profile(s) the binding information is taken.
     *Example:* cds w --profile hybrid,production
 
+  *--debug* / *--inspect* <host:port | 127.0.0.1:9229>
+
+    Activate debugger on the given host:port.
+    If port 0 is specified, a random available port will be used.
+
+  *--inspect-brk* <host:port | 127.0.0.1:9229>
+
+    Activate debugger on the given host:port and break at start of user script.
+    If port 0 is specified, a random available port will be used.
+
 # SEE ALSO
 
   *cds serve --help* for the different start options.

package/lib/bind/userCdsrcJsonStorageProvider.js

@@ -1,6 +1,5 @@
 const os = require('os');
 const path = require('path');
-const readline = require('readline');
 
 const fs = require('fs').promises;
 const { bold } = require('../util/term');
@@ -11,24 +10,6 @@ const gitUtil = require('../util/git');
 const CDSRC_FILENAME = '.cdsrc-private.json';
 
 class UserCdsrcJsonStorageProvider {
-    async askBooleanQuestion(question) {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-
-        question = question.trim() + ' ';
-        return new Promise(resolve => {
-            rl.question(question, answer => {
-                if (answer === 'y' || answer === 'Y') {
-                    resolve(true);
-                } else {
-                    resolve(false);
-                }
-                rl.close();
-            });
-        });
-    }
 
     async storeServices(services, options = {}) {
         let jsonPath = options.out || CDSRC_FILENAME;

package/lib/build/buildTaskEngine.js

@@ -39,7 +39,7 @@ class BuildTaskEngine {
         // validate required @sap namespace models - log only
         const unresolved = BuildTaskEngine._resolveRequiredSapServices(tasks)
         if (unresolved.length > 0) {
-            throw new BuildError(`Required CDS models [${unresolved.join(', ')}] cannot be resolved. Use the 'npm install' command to install up-to-date versions of the missing packages.`)
+            throw new BuildError(`Required CDS models [${unresolved.join(', ')}] cannot be resolved. Run the 'npm install' command to install up-to-date versions of the missing packages.`)
         }
 
         // create build plugins

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

@@ -7,15 +7,15 @@ const cdscVersion = `-- generated by cds-compiler version ${cdsc.version()}`
 const { getArtifactCdsPersistenceName } = cdsc
 const LOG = cds.log('cli|build'), DEBUG = cds.debug('cli|build')
 
-module.exports = async (model, beforeImage, srcPath, options = {}) => {
-    const { definitions, migrations, afterImage, journalFileNames } = _compileToHana(model, options, beforeImage)
+async function compileToHdbMigration(model, beforeImage, srcPath, options = {}) {
+    const { definitions, migrations, afterImage, migrationTableNames } = _compileToHana(model, options, beforeImage)
     const definitionResult = []
 
     for (const { name, suffix, sql } of definitions) {
         let definitionEntry = { name, suffix, content: sql }
 
         if (suffix === '.hdbtable') {
-            if (journalFileNames.has(name)) {
+            if (migrationTableNames.has(name)) {
                 const migration = migrations.find(migration => migration.name === name)
                 definitionEntry = await _2migrationtable(srcPath, migration || _emptyMigration(name), sql)
             }
@@ -27,6 +27,22 @@ module.exports = async (model, beforeImage, srcPath, options = {}) => {
     return { definitions: definitionResult, afterImage }
 }
 
+function getJournalEntities(model, options = {}) {
+    return cds.reflect(model).all(item => {
+        if (item.kind === 'entity' && item['@cds.persistence.journal'] === true) {
+            if (item['@cds.persistence.skip'] === true || item['@cds.persistence.exists'] === true) {
+                options.messages?.push(new BuildMessage(`[hdbmigrationtable] annotation @cds.persistence.journal skipped for entity '${item.name}' as persistence exists`, SEVERITY_WARNING))
+            }
+            return true
+        }
+        return false
+    })
+}
+
+function getMigrationTableName(entity, model) {
+    return getArtifactCdsPersistenceName(entity.name, 'quoted', model, 'hana')
+}
+
 function _compileToHana(model, options, beforeImage) {
     let definitions = []
     let migrations = []
@@ -58,20 +74,20 @@ function _compileToHana(model, options, beforeImage) {
         migrations = result.migrations
         afterImage = result.afterImage
     }
-    let journalFileNames = new Set()
+    let migrationTableNames = new Set()
     if (afterImage) {
         // 1. determine journal file names before _filterJournalArtifacts is called as getArtifactCdsPersistenceName
         // might no longer return the proper file name for the reduced CSN, e.g. for draft entities
-        journalFileNames = _getJournalFileNames(afterImage, options)
+        migrationTableNames = _getMigrationTableNames(afterImage, options)
 
         // 2. leave only persisted journal-related entities in afterImage
         afterImage = _filterJournalArtifacts(afterImage)
     }
 
-    _debug(definitions, migrations, journalFileNames)
+    _debug(definitions, migrations, migrationTableNames)
 
     return {
-        definitions, migrations, afterImage, journalFileNames
+        definitions, migrations, afterImage, migrationTableNames
     }
 }
 
@@ -158,21 +174,13 @@ function _emptyMigration(name) {
     return { name, suffix: ".hdbmigrationtable", changeset: [] }
 }
 
-function _getJournalFileNames(model, options) {
-    const journalNames = new Set(cds.reflect(model).all(item => {
-        if (item.kind === 'entity' && item['@cds.persistence.journal'] === true) {
-            if (item['@cds.persistence.skip'] === true || item['@cds.persistence.exists'] === true) {
-                options.messages?.push(new BuildMessage(`[hdbmigrationtable] annotation @cds.persistence.journal skipped for entity '${item.name}' as persistence exists`, SEVERITY_WARNING))
-            }
-            return true
-        }
-        return false
-    }).map(entity => getArtifactCdsPersistenceName(entity.name, 'quoted', model, 'hana')))
+function _getMigrationTableNames(model, options) {
+    const migrationTableNames = getJournalEntities(model, options).map(entity => getMigrationTableName(entity, model))
 
-    DEBUG?.(`\n[hdbmigrationtable] found ${journalNames.size} model entities annotated with '@cds.persistence.journal`)
-    DEBUG?.(`[hdbmigrationtable] ${[...journalNames].join(', ')}\n`)
+    DEBUG?.(`\n[hdbmigrationtable] found ${migrationTableNames.length} model entities annotated with '@cds.persistence.journal`)
+    DEBUG?.(`[hdbmigrationtable] ${migrationTableNames.join(', ')}\n`)
 
-    return journalNames
+    return new Set(migrationTableNames)
 }
 
 // only keep journal related entities
@@ -217,3 +225,9 @@ ${migration ? migration.changeset.map(change => change.sql).join('\n') : 'Empty
         }
     }
 }
+
+module.exports = {
+    compileToHdbMigration,
+    getJournalEntities,
+    getMigrationTableName
+}

package/lib/build/provider/hana/index.js

@@ -1,9 +1,9 @@
 const fs = require('fs')
 const path = require('path')
 const cds = require('../../../cds')
-const to_hdbmigration = require('./2migration')
+const { compileToHdbMigration, getJournalEntities, getMigrationTableName } = require('./2migration')
 const InternalBuildPlugin = require('../internalBuildPlugin')
-const { BuildError, relativePaths, BuildMessage, getWorkspaces, hasOptionValue, getFiles } = require('../../util')
+const { BuildError, relativePaths, BuildMessage, hasOptionValue, getFiles, getWorkspacePaths } = require('../../util')
 const { OUTPUT_MODE_NONE, OUTPUT_MODE, CONTENT_PACKAGE_JSON, CONTENT_HDBTABLEDATA, CSV_FILE_DETECTION,
     CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, CONTENT_NODE_MODULES, OUTPUT_MODE_RESULT, CONTINUE_UNRESOLVED_SCHEMA_CHANGES,
     CSV_FILE_TARGET, OPTION_WS } = require('../../constants')
@@ -38,14 +38,15 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         if (!model) {
             return
         }
-        let workspaceFiles
-        if (cds.cli.options?.[OPTION_WS] || hasOptionValue(this.task.options[OPTION_WS], true)) {
-            workspaceFiles = await this._getWorkspaceFiles()
+        let wsPaths = []
+        if(getJournalEntities(model).length || cds.cli.options?.[OPTION_WS] || hasOptionValue(this.task.options[OPTION_WS], true)) {
+            // workspace paths don't include the current project root
+            wsPaths = await getWorkspacePaths()
         }
 
         // the order of 1 and 2 is important
         // 1. compile
-        const hdiPlugins = await this._compileToHana(model, workspaceFiles)
+        const hdiPlugins = await this._compileToHana(model, wsPaths)
 
         if (!this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_NONE)) {
             // 2. copy resources
@@ -54,16 +55,6 @@ class HanaBuildPlugin extends InternalBuildPlugin {
             } else {
                 await this._copyResourcesExt(src, dest, model)
             }
-            // copy native hana artifacts from workspaces
-            if (workspaceFiles) {
-                const dest = path.join(this.task.dest, this.isStagingBuild() ? 'src' : 'src/gen')
-                await Promise.all(
-                    workspaceFiles.map((src) => {
-                        const { dir, filePath } = src
-                        return this.copy(path.join(dir, filePath)).to(path.join(dest, filePath))
-                    })
-                )
-            }
 
             // create additional stuff in dest
             await this._writeHdiConfig(hdiPlugins)
@@ -78,6 +69,28 @@ class HanaBuildPlugin extends InternalBuildPlugin {
             if (!this.hasBuildOption(CONTENT_PACKAGE_JSON, false)) {
                 await this._writePackageJson()
             }
+
+            // copy native hana artifacts from other workspaces including .hdbmigrationtable files defined for 
+            // common model artifacts that are not part of the current project
+            if (wsPaths.length || cds.cli.options?.[OPTION_WS] || hasOptionValue(this.task.options[OPTION_WS], true)) {
+                // first is winning, e.g. a .hdiconfig file might exist in multiple workspaces
+                const wsFiles = (await this._getWorkspaceFiles(wsPaths)).reduce((acc, src) => {
+                    const { filePath } = src;
+                    if (!acc.some(file => file.filePath === filePath)) {
+                        acc.push(src);
+                    }
+                    return acc;
+                }, []);
+
+                // copy artifacts to the src/gen folder in inplace mode
+                const dest = path.join(this.task.dest, this.isStagingBuild() ? 'src' : 'src/gen')
+                await Promise.all(
+                    wsFiles.map((src) => {
+                        const { dir, filePath } = src
+                        return this.copy(path.join(dir, filePath)).to(path.join(dest, filePath))
+                    })
+                )
+            }
         }
         return this._result
     }
@@ -264,20 +277,18 @@ class HanaBuildPlugin extends InternalBuildPlugin {
      *
      * @param {object} model The compiled csn model
      */
-    async _compileToHana(model, workspaceFiles) {
+    async _compileToHana(model, wsPaths) {
         // compile to old format (.hdbcds) or new format (.hdbtable / .hdbview)
         const format = this.getBuildOption(DEPLOY_FORMAT) || cds.env.requires.db?.[DEPLOY_FORMAT] || cds.env.hana?.[DEPLOY_FORMAT]
         if (!cds.compile.to[format]) {
             return Promise.reject(new Error(`Invalid deploy-format defined: ${format}`))
         }
 
-        if (cds.env.features.journal === false
-            || format === 'hdbcds'
-            || (!cds.compile.to.hana && Object.values(model.definitions).every(def => !def['@cds.persistence.journal']))) {
+        if (cds.env.features.journal === false || format === 'hdbcds') {
             // compatibility with existing cds.compile.to.hdbtable plugins cds < 8.0.0
             return await this._compileToHdb(model, format)
         } else {
-            return await this._compileToHdbmigration(model, format, workspaceFiles)
+            return await this._compileToHdbmigration(model, format, wsPaths)
         }
     }
 
@@ -313,7 +324,7 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         return hdiPlugins
     }
 
-    async _compileToHdbmigration(model, format, workspaceFiles) {
+    async _compileToHdbmigration(model, format, wsPaths) {
         const hdiPlugins = new Set()
         const relDestDir = path.relative(this.task.dest, this.task.options.compileDest)
         const relDbDestDir = path.relative(cds.root, this.task.options.compileDest)
@@ -328,19 +339,30 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         if (fs.existsSync(lastDevCsnDir)) {
             lastDev = JSON.parse((await fs.promises.readFile(lastDevCsnDir, 'utf-8')).toString())
         }
+
         // enforces sqlNames option for compiler in tests, pass options from cds env, ensures that the correct format is taken
         const options = { ...this.options(), messages: this.messages, sql_mapping: cds.env.sql.names, "deploy-format": format }
-
-        const { definitions, afterImage } = await to_hdbmigration(model, lastDev, dbSrcDir, options)
+        const { definitions, afterImage } = await compileToHdbMigration(model, lastDev, dbSrcDir, options)
         let validationError
 
+        // determine the migration tables originating from a different workspaces
+        const journalEntities = getJournalEntities(model)
+        const wsMigrationTables = new Set()
+        if (journalEntities.length) {
+            for (const entity of journalEntities) {
+                if (entity['$location']?.file && wsPaths.some(wsPath => path.resolve(cds.root, entity['$location'].file).startsWith(wsPath))) {
+                    wsMigrationTables.add(getMigrationTableName(entity, model))
+                }
+            }
+        }
+
         for (const { name, suffix, content, changed } of definitions) {
             hdiPlugins.add(suffix)
             const fileName = name + suffix
             if (suffix === FILE_EXT_HDBMIGRATIONTABLE) {
-                // Skip the .hdbmigrationtable file if its origin is a different workspace.
-                // The workspace build copies artifacts located in 'db/src/**' workspace folders.
-                if (!workspaceFiles?.find(wsFile => wsFile.fileName === fileName)) {
+                // do not create .hdbmigrationtable files originating from a different workspace
+                // the --ws build option will copy these artifacts to either gen/db/src or db/src/gen
+                if (!wsMigrationTables.has(name)) {
                     migrationTableFiles.push(path.join(relDbSrcDir, fileName))
                     if (changed) {
                         if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
@@ -350,6 +372,8 @@ class HanaBuildPlugin extends InternalBuildPlugin {
                     } else {
                         DEBUG?.(`no change, keep existing ${fileName}`)
                     }
+                } else {
+                    DEBUG?.(`skip generation of migration table [${fileName}] as it originates from a different workspace`)
                 }
             } else {
                 if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
@@ -547,21 +571,26 @@ class HanaBuildPlugin extends InternalBuildPlugin {
 
     /**
      * Returns all hana native artifacts located in db/src/** workspace folders.
+     * @param {Array} workspacePaths Array of workspace paths, 'cds.root' is excluded from the list
      * @returns {Array} Array of workspace files, each entry contains the db src directory, 
      * the relative file path and the file name.
      */
-    async _getWorkspaceFiles() {
+    async _getWorkspaceFiles(workspacePaths) {
+        if (!workspacePaths || !workspacePaths.length) {
+            return []
+        }
         const dbPaths = new Set()
-        const workspaces = await getWorkspaces()
-
-        workspaces.forEach(workspace => {
-            const dbSrc = path.join(cds.root, workspace, 'db/src')
-            const dbCfg = path.join(cds.root, workspace, 'db/cfg')
-            if (fs.existsSync(dbSrc)) {
-                dbPaths.add(dbSrc)
-            }
-            if (fs.existsSync(dbCfg)) {
-                dbPaths.add(dbCfg)
+        workspacePaths.forEach(workspacePath => {
+            // skip workspace matching the current project if cds build is executed in a workspace folder
+            if (cds.root !== workspacePath) {
+                const dbSrc = path.join(workspacePath, 'db/src')
+                const dbCfg = path.join(workspacePath, 'db/cfg')
+                if (fs.existsSync(dbSrc)) {
+                    dbPaths.add(dbSrc)
+                }
+                if (fs.existsSync(dbCfg)) {
+                    dbPaths.add(dbCfg)
+                }
             }
         })
         const workspaceFiles = [...dbPaths].reduce((acc, src) => {
@@ -572,11 +601,15 @@ class HanaBuildPlugin extends InternalBuildPlugin {
                 }
                 return true
             })
-            files.forEach(file => acc.add({ dir: src, filePath: path.relative(src, file), fileName: path.basename(file) }))
+            files.forEach(file => acc.push({ dir: src, filePath: path.relative(src, file), fileName: path.basename(file) }))
             return acc
-        }, new Set())
+        }, [])
+
+        return workspaceFiles
+    }
 
-        return [...workspaceFiles]
+    _hasJournalDefinitions(model) {
+        return Object.values(model.definitions).some(def => def['@cds.persistence.journal'])
     }
 
     static async _readTemplateAsJson(template) {

package/lib/build/provider/internalBuildTaskProvider.js

@@ -167,7 +167,7 @@ class InternalBuildTaskProvider extends BuildTaskProvider {
                 if (!sidecarEnv.requires["cds.xt.ModelProviderService"]?._in_sidecar) {
                     if (sidecarEnv.profiles?.includes('mtx-sidecar')) {
                         // profile has been set, but cannot be resolved
-                        throw new BuildError("MTX configuration cannot be resolved. Use the 'npm install' command to install up-to-date versions of @sap/cds-mtxs and @sap/cds.")
+                        throw new BuildError("MTX configuration cannot be resolved. Run the 'npm install' command to install up-to-date versions of @sap/cds-mtxs and @sap/cds.")
                     }
                     throw new BuildError(`Invalid MTX sidecar configuration - profile 'mtx-sidecar' not set.`)
                 }

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

@@ -85,13 +85,13 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
         // existence already checked
         await this.copy(path.join(cds.root, 'package.json')).to(path.join(destExt, 'package.json'))
 
-        // copy handlers
-        const folders = [path.join(cds.root, cds.env.folders.srv, 'handlers')]
+        // copy handlers from srv folder
+        const folder = path.join(cds.root, cds.env.folders.srv).replace(/[/\\]$/, '')
         await this.copyNativeContent(cds.root, destExt, res => {
             if (fs.statSync(res).isDirectory()) {
-                return folders.some(folder => folder.startsWith(res))
+                return res.startsWith(folder)
             }
-            if (folders.includes(path.dirname(res)) && /\.js$/.test(res)) {
+            if (path.dirname(res).startsWith(folder) && /\.js$/.test(res)) {
                 return true
             }
         })

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

@@ -118,7 +118,7 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
             const modelFilePaths = cds.resolve(modelPaths)
 
             if (!modelFilePaths || modelFilePaths.length === 0) {
-                throw new BuildError("No CDS models found in MTX sidecar. Make sure up-to-date versions of the required npm modules are installed.")
+                throw new BuildError("No CDS models found in MTX sidecar. Run the 'npm install' command to install up-to-date versions of the required packages.")
             }
             DEBUG?.(`sidecar model: ${relativePaths(cds.root, modelFilePaths).join(", ")}`)
 
@@ -126,7 +126,7 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
             const unresolved = resolveRequiredSapModels(modelPaths)
             if (unresolved.length > 0) {
                 // log error, but don't fail
-                this.pushMessage(`CDS models [${unresolved.join(', ')}] required by MTX sidecar cannot be resolved. Make sure up-to-date versions of the missing npm modules are installed.`, ERROR)
+                this.pushMessage(`CDS models [${unresolved.join(', ')}] required by MTX sidecar cannot be resolved. Run the 'npm install' command to install up-to-date versions of the required packages.`, ERROR)
             }
 
             // using synchronous compilation as cds.root and cds.env have been switched to mtx/sidecar

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

@@ -3,7 +3,7 @@ const path = require('path')
 const cds = require('../../../cds')
 const cmd = require('../../../util/command');
 const EdmxBuildPlugin = require('../edmxBuildPlugin')
-const { BuildError, getWorkspaces } = require('../../util')
+const { BuildError, getWorkspaces, findWorkspaceRoot } = require('../../util')
 const { OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, ODATA_VERSION_V2, FOLDER_GEN, CONTENT_EDMX, CONTENT_PACKAGELOCK_JSON,
     CONTENT_NPMRC, CONTENT_CDSRC_JSON, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, FLAVOR_LOCALIZED_EDMX,
     OPTION_WS_PACK} = require('../../constants')
@@ -160,14 +160,14 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
     }
 
     async _packWorkspaceDependencies(dest) {
-        const wsRoot = NodejsBuildPlugin._findWorkspaceRoot(cds.root)
+        const wsRoot = findWorkspaceRoot(cds.root)
         const appPkg = require(path.join(dest, 'package.json'))
         let workspaces
         if (this.task.options.workspaces) {
             workspaces = Array.isArray(this.task.options.workspaces) ? this.task.options.workspaces : [this.task.options.workspaces]
         } else {
             // devDependencies are not considered
-            workspaces = await getWorkspaces(true, false, wsRoot);
+            workspaces = await getWorkspaces(wsRoot, true, false);
         }
         if (workspaces.length) {
             let pkgDescriptors
@@ -197,22 +197,6 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         }
     }
 
-    static _findWorkspaceRoot(dir) {
-        try {
-            if (require(path.join(dir, 'package.json')).workspaces) {
-                return dir
-            }
-        } catch (err) {
-            // ignore
-        }
-        if (fs.existsSync(path.join(dir, '.gitmodules'))) {
-            return // project root reached
-        }
-        if (path.dirname(dir) !== dir) {
-            return this._findWorkspaceRoot(path.dirname(dir))
-        }
-    }
-
     static async _execNpmPack(dest, wsRoot, workspaces) {
         const args = ['pack', '-ws', '--json', `--pack-destination=${dest}`]
         workspaces.forEach(w => args.push(`-w=${w}`))