@sap/cds-dk 7.5.1 → 7.6.1

package/lib/build/provider/featureToggleBuildPlugin.js

@@ -1,4 +1,3 @@
-const fs = require('fs')
 const path = require('path')
 const cds = require('../../cds')
 const { DEFAULT_CSN_FILE_NAME, OUTPUT_MODE, OUTPUT_MODE_RESULT } = require('../constants')
@@ -65,7 +64,7 @@ class FeatureToggleBuildPlugin extends InternalBuildPlugin {
     }
 
     async _resolveSourcePaths(csn) {
-        const regex = new RegExp(path.resolve(cds.root, this.ftsName).replace(/\\/g, '\\\\') + '[/|\\\\](?<ftName>[^/|\\\\]*)')
+        const regex = new RegExp(this.ftsName + '[/|\\\\](?<ftName>[^/|\\\\]*)')
         let paths = { base: [] }
 
         // add ROOT source file paths for the base model
@@ -77,11 +76,6 @@ class FeatureToggleBuildPlugin extends InternalBuildPlugin {
             return acc
         }, [])
 
-        // keep existing behavior and return paths returned by cds.resolve if features are not supported by this project
-        if (!fs.existsSync(path.join(cds.root, this.ftsName))) {
-            return paths
-        }
-
         // add source file paths for the features
         paths.features = csn['$sources'].reduce((acc, file) => {
             const match = file.match(regex)

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

@@ -3,9 +3,10 @@ const path = require('path')
 const cds = require('../../../cds')
 const to_hdbmigration = require('./2migration')
 const InternalBuildPlugin = require('../internalBuildPlugin')
-const { BuildError, relativePaths, BuildMessage } = require('../../util')
+const { BuildError, relativePaths, BuildMessage, getWorkspaces, hasOptionValue } = 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 } = require('../../constants')
+    CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, CONTENT_NODE_MODULES, OUTPUT_MODE_RESULT, CONTINUE_UNRESOLVED_SCHEMA_CHANGES,
+    CSV_FILE_TARGET, CONTENT_WS } = require('../../constants')
 const { WARNING } = InternalBuildPlugin
 const DEFAULT_COMPILE_DEST_FOLDER = path.normalize("src/gen")
 const FILE_EXT_CSV = ".csv"
@@ -37,7 +38,7 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         if (!model) {
             return
         }
-        // the order is important
+        // the order of 1 and 2 is important
         // 1. compile
         const hdiPlugins = await this._compileToHana(model)
 
@@ -48,8 +49,12 @@ class HanaBuildPlugin extends InternalBuildPlugin {
             } else {
                 await this._copyResourcesExt(src, dest, model)
             }
+            // copy native hana artifacts from workspace dependencies
+            if (hasOptionValue(this.task.options?.[CONTENT_WS], true)) {
+                await this._addWorkspaceContent()
+            }
 
-            // 3. create additional stuff in dest
+            // create additional stuff in dest
             await this._writeHdiConfig(hdiPlugins)
             await this._writeHdiNamespace()
 
@@ -113,16 +118,15 @@ class HanaBuildPlugin extends InternalBuildPlugin {
             }
         }
 
-        // 2. staging build: copy files except *.cds, .env, default-env.json, ./node_modules/**
         if (this.isStagingBuild()) {
             let blockList = "\\.cds$|\\.csv$|\\.hdbtabledata$"
             blockList += !this.hasBuildOption(CONTENT_ENV, true) ? "|\\.env($|\\..*$)" : ""
             blockList += !this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, true) ? "|default-env\\.json$" : ""
             blockList = new RegExp(blockList)
 
+            // 2. staging build: copy files except *.cds, .env, default-env.json, ./node_modules/**
             await this.copyNativeContent(src, dest, (entry) => {
                 if (entry.startsWith(dbSrc)) {
-                    // entire native content
                     return true
                 }
                 if (fs.statSync(entry).isDirectory()) {
@@ -378,11 +382,11 @@ class HanaBuildPlugin extends InternalBuildPlugin {
     }
 
     async _writePackageJson() {
-        const packageJson = path.join(this.task.src, "package.json")
-        const exists = fs.existsSync(packageJson)
+        const pkgJson = path.join(this.task.src, "package.json")
+        const exists = fs.existsSync(pkgJson)
 
         if (exists) {
-            DEBUG?.(`skip create [${relativePaths(cds.root, packageJson)}], already existing`)
+            DEBUG?.(`skip create [${relativePaths(cds.root, pkgJson)}], already existing`)
         }
         if (this.isStagingBuild() && !exists) {
             const content = await HanaBuildPlugin._readTemplateAsJson(FILE_NAME_PACKAGE_JSON)
@@ -532,6 +536,37 @@ class HanaBuildPlugin extends InternalBuildPlugin {
         }
     }
 
+
+    /**
+     * Copy native hana content from workspaces.
+     */
+    async _addWorkspaceContent() {
+        const srcPaths = 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)) {
+                srcPaths.add(dbSrc)
+            }
+            if (fs.existsSync(dbCfg)) {
+                srcPaths.add(dbCfg)
+            }
+        })
+        DEBUG?.(`Copying hana native artifacts from folders '${[...srcPaths].map(f => path.relative(cds.root, f)).join(', ')}'`)
+        const dest = path.join(this.task.dest, 'src/gen')
+        for (const src of srcPaths) {
+            await this.copyNativeContent(src, dest, (entry) => {
+                if (entry.match(/(\/|\\)gen(\/|\\)?$/)) {
+                    // skip gen folder content
+                    return false
+                }
+                return true
+            })
+        }
+    }
+
     static async _readTemplateAsJson(template) {
         const content = await fs.promises.readFile(path.join(__dirname, 'template', template), 'utf-8')
         return JSON.parse(content.toString())

package/lib/build/provider/internalBuildTaskProvider.js

@@ -5,7 +5,7 @@ const { hasJavaNature, getDefaultModelOptions, BuildError, hasOptionValue, isCla
 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,
     BUILD_TASK_PREFIX, BUILD_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION, NODEJS_MODEL_EXCLUDE_LIST,
-    IGNORE_DEFAULT_MODELS } = require("../constants")
+    IGNORE_DEFAULT_MODELS, CONTENT_WS } = require("../constants")
 const DEBUG = cds.debug('cli|build')
 
 class InternalBuildTaskProvider extends BuildTaskProvider {
@@ -36,7 +36,7 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
         // src folder needs to be initialized first
         InternalBuildTaskProvider._setDefaultSrcFolder(task)
 
-        InternalBuildTaskProvider._setDefaultModel(task)
+        await InternalBuildTaskProvider._setDefaultModel(task)
     }
 
     getPlugin(task) {
@@ -290,7 +290,8 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
         }
     }
 
-    static _setDefaultModel(task) {
+    static async _setDefaultModel(task) {
+        const ws = hasOptionValue(task.options?.[CONTENT_WS], true)
         let taskModelPaths = task.options?.model
         if (taskModelPaths && !Array.isArray(taskModelPaths)) {
             taskModelPaths = [taskModelPaths]
@@ -301,10 +302,11 @@ Upgrade to @sap/cds-mtxs following the migration guide https://cap.cloud.sap/doc
         let defaultModelPaths = []
         if (taskModelPaths?.length) {
             if (!hasOptionValue(task.options?.[IGNORE_DEFAULT_MODELS], true)) {
-                defaultModelPaths = getDefaultModelOptions().filter(p => p.match(allowList))
+                defaultModelPaths = await getDefaultModelOptions(ws)
+                defaultModelPaths = defaultModelPaths.filter(p => p.match(allowList))
             }
         } else {
-            defaultModelPaths = getDefaultModelOptions()
+            defaultModelPaths = await getDefaultModelOptions(ws)
             defaultModelPaths.push(task.src)
             if (hasOptionValue(task.options?.[IGNORE_DEFAULT_MODELS], true)) {
                 // all default models except the built-in models

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

@@ -90,11 +90,5 @@ class JavaBuildPlugin extends EdmxBuildPlugin {
         }
         return m
     }
-
-    _isCompilerV1() {
-        const version = cds.compiler.version()
-        const match = version.match(/(\d+)\.?(\d*)\.?(\d*)/)
-        return match && match[1] === 1
-    }
 }
 module.exports = JavaBuildPlugin

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

@@ -50,6 +50,11 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
         await this.compileToJson(model, path.join(destSidecarSrc, DEFAULT_CSN_FILE_NAME))
         await this.collectLanguageBundles(model, path.join(destSidecarSrc, getI18nDefaultFolder()))
         await this.copySrvContent(this.task.src, destSidecar, destSidecar)
+
+        // copy .npmrc from project root, if it exists and no .npmrc exists in the sidecar
+        if (!fs.existsSync(path.join(destSidecar, '.npmrc')) && fs.existsSync(path.join(cds.root, '.npmrc'))) {
+            await this.copy(path.join(cds.root, '.npmrc')).to(path.join(destSidecar, '.npmrc'))
+        }
     }
 
     /**

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 } = require('../../util')
+const { BuildError, getWorkspaces } = 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 } = require('../../constants')
 const { WARNING } = EdmxBuildPlugin
@@ -36,27 +36,26 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         }
         // by default model contains all features
         const model = await this.model()
-        if (!model) {
+        if (!model && !this.context.options['ws']) {
             return
         }
-
-        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, false)) {
-            const compileOptions = { [FLAVOR_LOCALIZED_EDMX]: this.hasBuildOption(FLAVOR_LOCALIZED_EDMX, true) }
-            // inferred flavor is required by edmx compiler backend
-            // using cds.compile instead of cds.compiler.compileSources ensures that cds.env options are correctly read
-            const baseModel = dictionary.base.meta.flavor !== 'inferred' ? await cds.compile(sources.base, super.options(), 'inferred') : dictionary.base
-            await this.compileToEdmx(baseModel, path.join(this.destSrv, 'odata', cds.env.odata.version), compileOptions)
+        if (model) {
+            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, false)) {
+                const compileOptions = { [FLAVOR_LOCALIZED_EDMX]: this.hasBuildOption(FLAVOR_LOCALIZED_EDMX, true) }
+                // inferred flavor is required by edmx compiler backend
+                // using cds.compile instead of cds.compiler.compileSources ensures that cds.env options are correctly read
+                const baseModel = dictionary.base.meta.flavor !== 'inferred' ? await cds.compile(sources.base, super.options(), 'inferred') : dictionary.base
+                await this.compileToEdmx(baseModel, path.join(this.destSrv, 'odata', cds.env.odata.version), compileOptions)
+            }
         }
-
         if (this.isStagingBuild() && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM)) {
             const srcSrv = this.task.src === cds.root ? path.resolve(this.task.src, cds.env.folders.srv) : this.task.src
             await this._copyNativeContent(cds.root, srcSrv, destRoot, destSrv)
-            if (this.context.options.ws) {
+            if (this.context.options['ws']) {
                 await this._addWorkspaceDependencies(destRoot)
             }
         }
@@ -160,32 +159,18 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
     }
 
     async _addWorkspaceDependencies(dest) {
-        const wsRoot = this._findWorkspaceRoot(cds.root)
+        const wsRoot = NodejsBuildPlugin._findWorkspaceRoot(cds.root)
         const appPkg = require(path.join(dest, 'package.json'))
         let workspaces
-        if (this.task.options?.workspaces) {
+        if (this.task.options.workspaces) {
             workspaces = Array.isArray(this.task.options.workspaces) ? this.task.options.workspaces : [this.task.options.workspaces]
-        }
-        if (!workspaces) {
-            workspaces = []
-            for (const name in appPkg.dependencies) {
-                if (appPkg.dependencies[name] === '*') {
-                    try {
-                        const pkg = require.resolve(path.join(name, 'package.json'), { paths: [wsRoot] })
-                        workspaces.push(path.dirname(path.relative(wsRoot, pkg)))
-                    } catch(e) {
-                        if (e.code === 'MODULE_NOT_FOUND') {
-                            throw new BuildError(`Workspace packaging failed - module '${name}' not found. Make sure that configured npm workspaces are installed.`)
-                        }
-                        throw e
-                    }
-                }
-            }
+        } else {
+            workspaces = await getWorkspaces(true, false, wsRoot);
         }
         if (workspaces.length) {
             let pkgDescriptors
             try {
-                pkgDescriptors = await this._execNpmPack(dest, wsRoot, workspaces)
+                pkgDescriptors = await NodejsBuildPlugin._execNpmPack(dest, wsRoot, workspaces)
             } catch (e) {
                 DEBUG?.(e)
                 throw new BuildError(`Failed to package npm workspace dependencies\n${e.message}`)
@@ -193,9 +178,9 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
             if (pkgDescriptors?.length) {
                 let changed
                 for (const pkgDescriptor of pkgDescriptors) {
-                    const {name, filename: fileName} = pkgDescriptor
-                    const filePath = path.join(dest, fileName)                        
-                    if (appPkg.dependencies?.[name] === '*') {
+                    const { name, filename: fileName } = pkgDescriptor
+                    const filePath = path.join(dest, fileName)
+                    if (appPkg.dependencies?.[name]) {
                         appPkg.dependencies[name] = `file:${fileName}`
                         this.pushFile(filePath)
                         changed |= true
@@ -210,28 +195,28 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         }
     }
 
-    _findWorkspaceRoot(dir) {
+    static _findWorkspaceRoot(dir) {
         try {
-            if(require(path.join(dir, 'package.json')).workspaces) {
-              return dir
+            if (require(path.join(dir, 'package.json')).workspaces) {
+                return dir
             }
-        } catch(err) {
+        } catch (err) {
             // ignore
         }
-        if(fs.existsSync(path.join(dir, '.gitmodules')) || fs.existsSync(path.join(dir, 'node_modules'))) {
+        if (fs.existsSync(path.join(dir, '.gitmodules')) || fs.existsSync(path.join(dir, 'node_modules'))) {
             return // project root reached
         }
         if (path.dirname(dir) !== dir) {
             return this._findWorkspaceRoot(path.dirname(dir))
         }
     }
-    
-    async _execNpmPack(dest, wsRoot, workspaces) {
+
+    static async _execNpmPack(dest, wsRoot, workspaces) {
         const args = ['pack', '-ws', '--json', `--pack-destination=${dest}`]
         workspaces.forEach(w => args.push(`-w=${w}`))
 
-        DEBUG?.(`execute command: npm ${args}`)
-        const result = await cmd.spawnCommand( 'npm', args, { cwd: wsRoot }, true, !!DEBUG)
+        DEBUG?.(`execute command: npm ${args.join(', ')}`)
+        const result = await cmd.spawnCommand('npm', args, { cwd: wsRoot }, true, !!DEBUG)
         DEBUG?.(result)
         return JSON.parse(result)
     }

package/lib/build/util.js

@@ -1,7 +1,11 @@
 const fs = require('fs')
 const path = require('path')
 const cds = require('../cds')
-const { SEVERITY_ERROR, FILE_EXT_CDS } = require('./constants')
+const cp = require('child_process');
+const execAsync = require('util').promisify(cp.exec)
+const IS_WIN = require('os').platform() === 'win32'
+const { SEVERITY_ERROR, FILE_EXT_CDS } = require('./constants');
+const DEBUG = cds.debug('cli|build')
 
 function getProperty(src, segments) {
     segments = Array.isArray(segments) ? segments : segments.split('.')
@@ -113,10 +117,26 @@ function resolveRequiredSapModels(modelPaths) {
     })
 }
 
-function getDefaultModelOptions() {
-    const fts = cds.env.features.folders
-    const modelPaths = cds.resolve(!fts ? '*' : ['*', fts], false)
-    return _pushModelPaths(modelPaths)
+async function getDefaultModelOptions(ws = false) {
+    const wildcards = cds.env.requires.toggles && cds.env.features.folders ? ['*', cds.env.features.folders] : '*'
+    let paths = _pushModelPaths(cds.resolve(wildcards, false))
+
+    if (ws) {
+        const workspaces = await getWorkspaces()
+        const env = cds.env
+        const root = cds.root
+        try {
+            workspaces.forEach(workspace => {
+                cds.root = path.join(root, workspace)
+                cds.env = cds.env.for('cds', cds.root)
+                paths = paths.concat(_pushModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false)).map(p => path.join(workspace, p)))
+            })
+        } finally {
+            cds.root = root
+            cds.env = env
+        }
+    }
+    return paths
 }
 
 /**
@@ -127,30 +147,6 @@ function normalizePath(dir) {
     return typeof dir === "string" ? dir.replace(/\\/g, '/').replace(/\/$/, '') : dir
 }
 
-function _pushModelPaths(...modelPaths) {
-    const model = new Set()
-    // may contain nested arrays
-    modelPaths = flatten(modelPaths)
-    const { roots } = cds.env
-    modelPaths.forEach(m => {
-        if (m && !model.has(m) && !model.has(m + "/")) {
-            // filter root model paths that do not exist
-            // other entries are added as is, e.g. reuse model entries
-            if (roots.includes(m)) {
-                const dir = path.resolve(cds.root, m)
-                if (fs.existsSync(dir)) {
-                    model.add(m)
-                } else if (fs.existsSync(dir + FILE_EXT_CDS)) { //might be cds file name, compatibility to old build configs
-                    model.add(m)
-                }
-            } else {
-                model.add(m)
-            }
-        }
-    })
-    return [...model].map(m => normalizePath(m))
-}
-
 function flatten(modelPaths) {
     return modelPaths.reduce((acc, m) => {
         if (Array.isArray(m)) {
@@ -180,6 +176,114 @@ function isClassicMtx() {
     return /true/i.test(process.env.OLD_MTX) || _hasMtxDependency()
 }
 
+async function pathExists(path) {
+    return fs.promises.access(path).then(() => true).catch(() => false);
+}
+
+/**
+ * Returns the list of workspaces defined for the current project. A workspace dependency
+ * needs to be defined resulting in a corresponding sym-link.
+ * @returns the paths are relative to 'cds.root'.
+ */
+async function getWorkspaces(resolve = false, devDependencies = true, wsRoot = cds.root) {
+    const workspaces = []
+    const pgkJsonWsRoot = require(path.join(wsRoot, 'package.json'))
+    let pgkJson = pgkJsonWsRoot
+    if (wsRoot !== cds.root) {
+        pgkJson = require(path.join(cds.root, 'package.json'))
+    }
+    if (pgkJsonWsRoot.workspaces) {
+        if (resolve) {
+            _validateWsDependencies(wsRoot, pgkJson.dependencies, devDependencies ? pgkJson.devDependencies : {})
+        }
+        // read npm workspaces
+        const pkgs = await _execNpmWs(wsRoot)
+        pkgs.forEach(pkg => {
+            if (!resolve || devDependencies && pgkJson.devDependencies?.[pkg] || pgkJson.dependencies?.[pkg]) {
+                const workspace = _getWorkspace(wsRoot, pkg)
+                if (workspace) {
+                    workspaces.push(workspace)
+                }
+            }
+        })
+    }
+    DEBUG?.(`Found ${workspaces.length} workspaces ${workspaces.join(', ')}`)
+    return workspaces
+}
+
+/**
+ * Read installed npm workspaces using 'npm ls -ws --json'. 
+ * @returns {Array} list of package paths, or an empty array if either 
+ * no workspaces are defined or have not been installed.
+ */
+async function _execNpmWs(wsRoot) {
+    try {
+        const cmdLine = 'npm ls -ws --json'
+        DEBUG?.(`execute ${cmdLine}`)
+        let result = await execAsync(cmdLine, { shell: IS_WIN, stdio: ['inherit', 'pipe', 'inherit'], cwd: wsRoot })
+        // DEBUG?.(result.stdout)
+        result = JSON.parse(result.stdout)
+        if (result.dependencies) {
+            return Object.keys(result.dependencies)
+        } else if (result.name) {
+            return [result.name]
+        }
+    } catch (e) {
+        e.stderr = e.stderr?.replace(/npm ERR! /g, '')
+        throw e
+    }
+    return []
+}
+
+function _getWorkspace(wsRoot, pkg) {
+    try {
+        const pkgPath = require.resolve(path.join(pkg, 'package.json'), { paths: [wsRoot] })
+        if (!pkgPath.match(/(\/|\\)node_modules(\/|\\)?/) && pkgPath.startsWith(wsRoot)) {
+            return path.relative(wsRoot, path.dirname(pkgPath))
+        }
+    } catch (e) {
+        // ignore - workspace dependencies have already been validated
+    }
+}
+
+function _validateWsDependencies(wsRoot, dependencies, devDependencies) {
+    const allDependencies = {...dependencies, ...devDependencies}
+    for (const name in allDependencies) {
+        if (allDependencies[name] === '*') {
+            try {
+                require.resolve(path.join(name, 'package.json'), { paths: [wsRoot] })
+            } catch (e) {
+                if (e.code === 'MODULE_NOT_FOUND') {
+                    throw new BuildError(`npm packaging failed, module '${name}' not found. Make sure configured npm workspaces are installed.`)
+                }
+                throw e
+            }
+        }
+    }
+}
+
+function _pushModelPaths(...modelPaths) {
+    const model = new Set()
+    // may contain nested arrays
+    modelPaths = flatten(modelPaths)
+    const { roots } = cds.env
+    modelPaths.forEach(m => {
+        if (m && !model.has(m) && !model.has(m + "/")) {
+            // filter roots and absolute model paths that do not exist
+            if (roots.includes(m)) {
+                const dir = path.resolve(cds.root, m)
+                if (fs.existsSync(dir)) {
+                    model.add(m)
+                } else if (fs.existsSync(dir + FILE_EXT_CDS)) { //might be cds file name, compatibility to old build configs
+                    model.add(m)
+                }
+            } else {
+                model.add(m)
+            }
+        }
+    })
+    return [...model].map(m => normalizePath(m))
+}
 
 /**
  * Return gnu-style error string for location `loc`:
@@ -208,10 +312,6 @@ function _locationString(loc) {
         : `${loc.file}:${loc.line}.${loc.col}-${loc.endLine}.${loc.endCol}`;
 }
 
-async function pathExists(path) {
-    return fs.promises.access(path).then(() => true).catch(() => false);
-}
-
 /**
  * Class for individual build message.
  *
@@ -276,6 +376,7 @@ module.exports = {
     isClassicMtx,
     normalizePath,
     pathExists,
+    getWorkspaces,
     BuildMessage,
     BuildError
 }