@sap/cds-dk 9.6.0 → 9.7.0

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

@@ -1,19 +1,19 @@
-const path = require('path')
 const cds = require('../../../cds')
-const fs = require('fs')
-const { FOLDER_GEN, DEFAULT_CSN_FILE_NAME, MTX_SIDECAR_DB_VALIDATION, CONTENT_EDMX, FLAVOR_LOCALIZED_EDMX } = require('../../constants')
-const NodejsBuildPlugin = require('../nodejs')
+const { exists, path } = cds.utils
+const { SEVERITY_ERROR: ERROR, FOLDER_GEN, MTX_SIDECAR_DB_VALIDATION, CONTENT_EDMX, FLAVOR_LOCALIZED_EDMX } = require('../../constants')
 const ResourcesTarBuilder = require('../mtx/resourcesTarBuilder')
-const { ERROR } = NodejsBuildPlugin
 const { relativePaths, BuildError, resolveRequiredSapModels, getI18nDefaultFolder } = require('../../util')
 const DEBUG = cds.debug('cli|build')
 
 const DEFAULT_MAIN_FOLDER = "_main"
 
-class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
+const [major, minor] = cds.version.split('.').map(Number)
+const COMPAT = major === 9 && minor < 7 // cds10: remove
+
+module.exports = class extends require('../nodejs') {
+
     get priority() {
-        // must run after 'hana' build task
-        return super.priority - 10
+        return super.priority - 10 // must run after 'hana' build task
     }
     init() {
         super.init()
@@ -23,43 +23,51 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
     }
 
     /**
-     * Builds the mtx sidecar app consisting of:
-     * - nodejs app model defined by the required sidecar services
-     * - main app model defined by the build task's model options including feature models and resources TAR
+     * Builds the MTX sidecar app consisting of:
+     * - Node.js app model defined by the required sidecar services
+     * - Main app model defined by the build task's model options, including feature models and resources TAR
      *
      * build.target=".": 'dest' -> 'model-provider/gen'
      * build.target="gen": 'dest' -> 'gen/model-provider'
      */
     async build() {
-        // nodejs app parts have to be built using sidecar env
-        const sidecarEnv = cds.env.for("cds", this.task.src)
-        // build main application
-        await this._buildMainApp(sidecarEnv)
-        // build node application
-        await this._buildNodeApp(sidecarEnv)
+        // REVISIT: required to load plugins from mtx/sidecar, not the main app for the sidecar CSN
+        const oldRoot = cds.root
+        cds.root = this.task.src
+        const sidecarEnv = cds.env.for('cds', this.task.src)
+        cds.root = oldRoot
+
+        const [rMain, rNode] = await Promise.allSettled([
+            this._buildMainApp(sidecarEnv),
+            this._buildSidecarApp(sidecarEnv)
+        ])
+        if (rMain.status === 'rejected') throw rMain.reason
+        if (rNode.status === 'rejected') throw rNode.reason
     }
 
     /**
-     * Builds the mtx sidecar nodejs app parts.
-     * @param {object} sidecarEnv cds env based on the sidecar dir
+     * Builds the MTX sidecar Node.js app parts.
+     * @param {import('../../../cds').env} sidecarEnv `cds.env` based on the MTX sidecar directory.
      */
-    async _buildNodeApp(sidecarEnv) {
-        const destSidecar = this.task.dest
-        const destSidecarSrc = path.join(destSidecar, sidecarEnv.folders.srv)
-        const model = this._compileSidecarSync(sidecarEnv)
-        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)
-
+    async _buildSidecarApp(sidecarEnv) {
+        const { dest, src } = this.task
+        const model = COMPAT ? this._compatCompileSidecarSync(sidecarEnv) : this._compileSidecarSync(sidecarEnv)
+        const srv = path.join(dest, sidecarEnv.folders.srv)
+        const promises = [
+            this.compileToJson(model, path.join(srv, 'csn.json')),
+            this.collectLanguageBundles(model, path.join(srv, getI18nDefaultFolder())),
+            this.copySrvContent(src, dest, dest)
+        ]
         // 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'))
+        if (!exists(path.join(dest, '.npmrc')) && exists('.npmrc')) {
+            promises.push(this.copy(path.join(cds.root, '.npmrc')).to(path.join(dest, '.npmrc')))
         }
+        await Promise.all(promises)
     }
 
     /**
      * Builds the main app parts containing base model CSN with feature CSNs and resources TAR.
-     * @param {object} sidecarEnv cds env based on the sidecar dir
+     * @param {import('../../../cds').env} sidecarEnv `cds.env` based on the MTX sidecar directory.
      */
     async _buildMainApp(sidecarEnv) {
         let main = sidecarEnv.requires['cds.xt.ModelProviderService']?.root
@@ -78,85 +86,85 @@ class MtxSidecarBuildPlugin extends NodejsBuildPlugin {
             main = DEFAULT_MAIN_FOLDER
         }
 
-        const destRoot = this.task.dest
-        const destMain = path.join(destRoot, main)
+        const destMain = path.join(this.task.dest, main)
         const destMainSrv = path.join(destMain, cds.env.folders.srv)
         const model = await this.model()
         if (!model) {
             return
         }
+
         const { dictionary, sources } = await this.compileAll(model, destMainSrv, destMain)
-        // await this.collectAllLanguageBundles(dictionary, sources, destMainSrv, destMain)
-        await this.collectAllLanguageBundles(dictionary, sources, destMain, destMain)
+
+        const promises = []
+        promises.push(this.collectAllLanguageBundles(dictionary, sources, destMainSrv, destMain))
+        // promises.push(this.collectAllLanguageBundles(dictionary, sources, destMain, destMain))
 
         if (!this.hasBuildOption(CONTENT_EDMX, false)) {
-            //inferred model expected by cds.compile.to.edmx()
+            // inferred model expected by cds.compile.to.edmx()
             const compileOptions = { [FLAVOR_LOCALIZED_EDMX]: this.hasBuildOption(FLAVOR_LOCALIZED_EDMX, true) } // disabled by default
             const baseModel = cds.compiler.compileSources({ 'base.json': dictionary.base }, { messages: this.messages })
-            await this.compileToEdmx(baseModel, path.join(destMainSrv, 'odata', cds.env.odata.version), compileOptions)
+            promises.push(this.compileToEdmx(baseModel, path.join(destMainSrv, 'odata', cds.env.odata.version), compileOptions))
         }
 
         // create resources TAR
         // resources are determined based on available database build task, SQLite as fallback
-        await new ResourcesTarBuilder(this).createTar(destMain, model)
+        promises.push(new ResourcesTarBuilder(this).createTar(destMain, model))
 
         // copy package.json and .cdsrc.json from project root
-        await this._copyMainConfigFiles(cds.root, destMain)
+        const packageJson = path.join(cds.root, 'package.json')
+        const cdsrcJson = path.join(cds.root, '.cdsrc.json')
+        if (exists('package.json')) {
+            promises.push(this.copy(packageJson).to(path.join(destMain, 'package.json')))
+        }
+        if (exists('.cdsrc.json')) {
+            promises.push(this.copy(cdsrcJson).to(path.join(destMain, '.cdsrc.json')))
+        }
+        return Promise.all(promises)
     }
 
     /**
-     * Synchronous compilation using the sidecar context.
-     * @param {object} sidecarEnv cds env based on the sidecar dir
-     * @returns the compiled mtx sidecar CSN
+     * Synchronous compilation using the MTX sidecar context.
+     * @param {import('../../../cds').env} env `cds.env` based on the MTX sidecar directory.
+     * @returns the compiled MTX sidecar CSN
      */
-    _compileSidecarSync(sidecarEnv) {
+     _compileSidecarSync(env) {
+        const options = { env, root: this.task.src }
+        const modelPaths = COMPAT ? cds.resolve('*', false) : cds.resolve('*', { ...options, dry: true })
+        const modelFilePaths = COMPAT ? cds.resolve(modelPaths) : cds.resolve(modelPaths, options)
+        if (!modelFilePaths || modelFilePaths.length === 0) {
+            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(", ")}`)
+
+        // check whether all models belonging to the @sap namespace can be resolved
+        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. 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
+        // using different messages array ensures that cds compilation doesn't fail because of
+        // existing compilation error messages that have been downgraded to warnings
+        // see cap/issues/issues/16401#issuecomment-7205397
+        const messages = []
+        const model = cds.load(modelFilePaths, { sync: true, messages })
+        messages.forEach(msg => this.messages.push(msg))
+        return model
+    }
+
+    // cds10: remove
+    _compatCompileSidecarSync(sidecarEnv) {
         const env = cds.env
         const root = cds.root
         try {
             cds.root = this.task.src
             cds.env = sidecarEnv
-            const modelPaths = cds.resolve('*', false)
-            const modelFilePaths = cds.resolve(modelPaths)
-
-            if (!modelFilePaths || modelFilePaths.length === 0) {
-                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(", ")}`)
-
-            // check whether all models belonging to the @sap namespace can be resolved
-            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. 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
-            // using different messages array ensures that cds compilation doesn't fail because of 
-            // existing compilation error messages that have been downgraded to warnings
-            // see cap/issues/issues/16401#issuecomment-7205397
-            const messages = []
-            const model = cds.load(modelFilePaths, { sync: true, messages })
-            messages.forEach(msg => this.messages.push(msg))
-            
-            return model
+            return this._compileSidecarSync(sidecarEnv)
         } finally {
             // restore project scope
             cds.root = root
             cds.env = env
         }
     }
-
-    async _copyMainConfigFiles(src, dest) {
-        const packageJson = path.join(src, 'package.json')
-        const cdsrcJson = path.join(src, '.cdsrc.json')
-        const promises = []
-        if (fs.existsSync(packageJson)) {
-            promises.push(this.copy(packageJson).to(path.join(dest, 'package.json')))
-        }
-        if (fs.existsSync(cdsrcJson)) {
-            promises.push(this.copy(cdsrcJson).to(path.join(dest, '.cdsrc.json')))
-        }
-        return promises
-    }
 }
-module.exports = MtxSidecarBuildPlugin

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

@@ -23,9 +23,6 @@ const arrayify = x => Array.isArray(x) ? x : [x]
 class NodejsBuildPlugin extends EdmxBuildPlugin {
     init() {
         super.init()
-        if (this.task.options.compileDest) {
-            throw new BuildError("Option not supported - compileDest")
-        }
         // fallback if src has been defined as '.'
         this.destSrv = this.isStagingBuild() ? path.resolve(this.task.dest, cds.env.folders.srv) : path.join(this.task.dest, FOLDER_GEN)
     }
@@ -53,8 +50,8 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         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, destRoot, destRoot)
-            // await this.collectAllLanguageBundles(dictionary, sources, destSrv, destRoot)
+            // await this.collectAllLanguageBundles(dictionary, sources, destRoot, destRoot)
+            await this.collectAllLanguageBundles(dictionary, sources, destSrv, destRoot)
 
             if (!this.hasBuildOption(CONTENT_EDMX, false)) {
                 const compileOptions = { [FLAVOR_LOCALIZED_EDMX]: this.hasBuildOption(FLAVOR_LOCALIZED_EDMX, true) }
@@ -159,7 +156,7 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
 
     async _copyNativeContent(srcRoot, srcSrv, destRoot, destSrv) {
         // project/srv/** -> 'gen/srv/srv/**'
-        const filesFilter = await this.copySrvContent(srcSrv, destRoot, this.hasBuildOption('flatDeployLayout', true) ? destRoot : destSrv)
+        const filesFilter = await this.copySrvContent(srcSrv, destRoot, destSrv)
 
         // project/* -> 'gen/srv/*'
         await this.copyProjectRootContent(srcRoot, destRoot, (entry) => !filesFilter.includes(path.basename(entry)))
@@ -300,8 +297,6 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
     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.join(', ')}`)
         const result = await cmd.spawnCommand('npm', args, { cwd: wsRoot }, true, !!LOG._debug)
         DEBUG?.(result)
         return JSON.parse(result)

package/lib/build/util.js

@@ -1,9 +1,10 @@
 // @ts-check
-const cp = require('node:child_process');
+const cp = require('node:child_process')
 const fs = require('node:fs')
 const path = require('node:path')
 
 const cds = require('../cds')
+const { exists } = cds.utils
 const execAsync = require('node:util').promisify(cp.exec)
 const { isRoot } = require('../util/fs')
 
@@ -14,6 +15,7 @@ const DEBUG = cds.debug('cli|build')
 // failsafe to avoid too deep recursions
 // increased from 2 to 5, adding a config options in the future
 const WS_MAX_DEPTH = 5
+const FLATTEN_MAX_DEPTH = 20 // should suffice, was infinite in earlier versions
 
 /** @typedef {{col?: number, endCol?: number, line?: number, endLine?: number, file: string}} SourceLocation */
 /** @typedef {object[] | object} Credentials */
@@ -92,7 +94,7 @@ function relativePaths(root, qualifiedPaths) {
  * Returns a list of fully qualified model names belonging to the '@sap' namespace that cannot be resolved.
  * E.g. the module might NOT have been installed.
  * @param {string[]} modelPaths
- * @returns {string[]}
+ * @returns {boolean | string[]}
  */
 function resolveRequiredSapModels(modelPaths) {
     return Array.isArray(modelPaths) && modelPaths.filter(p => {
@@ -104,14 +106,35 @@ function resolveRequiredSapModels(modelPaths) {
 }
 
 /**
- * Returns the default model options for the given workspace.
+ * Returns the default model paths for the given workspace.
  * @param {boolean} ws - whether to include workspace models
- * @param {Function | undefined} filter - filter function for model paths
+ * @returns {Promise<string[]>} array of model paths
  */
-async function getDefaultModelOptions(ws = false, filter = undefined) {
-    // Note: requires.toggles holds the actual kind representation and not the value 'true'
-    const wildcards = cds.env.requires.toggles && cds.env.features.folders ? ['*', cds.env.features.folders] : '*'
-    let paths = _filterModelPaths(cds.resolve(wildcards, false), filter)
+async function getDefaultModelPaths(ws = false) {
+    const { toggles } = cds.env.requires, { folders } = cds.env.features
+    const wildcards = toggles && folders ? ['*', folders] : '*'
+    if (!cds.resolve.locations) return _compatGetDefaultModelPaths(ws, wildcards)
+
+    let paths = _filterModelPaths(cds.resolve.locations(wildcards))
+    if (ws) {
+        const workspaces = (await getWorkspaces())
+          .map(ws => ws.workspace)
+        workspaces.forEach(workspace => {
+            const root = path.join(cds.root, workspace)
+            const env = cds.env.for('cds', root)
+            const resolved = cds.resolve.locations(env.requires.toggles ? wildcards : '*', { env, root })
+            paths.push(..._filterModelPaths(resolved, { root, env })
+                .map(p => normalizePath(path.join(workspace, p))))
+        })
+        // exclude redundant built-in models starting with workspace path, e.g. 'books/@sap/cds-mtxs/srv/bootstrap'
+        paths = paths.filter(p => NODEJS_MODEL_EXCLUDE_LIST.includes(p) || !NODEJS_MODEL_EXCLUDE_LIST.some(ex => p.endsWith(ex)))
+    }
+    return paths
+}
+
+// cds10: remove
+async function _compatGetDefaultModelPaths(ws, wildcards) {
+    let paths = _filterModelPaths(cds.resolve(wildcards, false))
 
     if (ws) {
         const workspaces = (await getWorkspaces())
@@ -122,15 +145,15 @@ async function getDefaultModelOptions(ws = false, filter = undefined) {
             workspaces.forEach(workspace => {
                 cds.root = path.join(root, workspace)
                 cds.env = cds.env.for('cds', cds.root)
-                paths = paths.concat(_filterModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false), filter).map(p => normalizePath(path.join(workspace, p))))
+                const fromWorkspace = _filterModelPaths(cds.resolve(cds.env.requires.toggles ? wildcards : '*', false))
+                paths.push(...fromWorkspace.map(p => normalizePath(path.join(workspace, p))))
             })
         } finally {
             cds.root = root
             cds.env = env
         }
         // exclude redundant built-in models starting with workspace path, e.g. 'books/@sap/cds-mtxs/srv/bootstrap'
-        paths = paths
-            .filter(p => typeof(p) === 'string' && (NODEJS_MODEL_EXCLUDE_LIST.includes(p) || !NODEJS_MODEL_EXCLUDE_LIST.some(ex => p.endsWith(ex))))
+        paths = paths.filter(p => NODEJS_MODEL_EXCLUDE_LIST.includes(p) || !NODEJS_MODEL_EXCLUDE_LIST.some(ex => p.endsWith(ex)))
     }
     return paths
 }
@@ -143,7 +166,7 @@ async function getDefaultModelOptions(ws = false, filter = undefined) {
 /**
  * @overload
  * @param {unknown} dir
- * @returns {unknown} 
+ * @returns {unknown}
  */
 /**
  * For valid paths replace '\\' with '/' and remove trailing '/'. Otherwise return as is
@@ -154,21 +177,6 @@ function normalizePath(dir) {
     return typeof dir === "string" ? dir.replace(/\\/g, '/').replace(/\/$/, '') : dir
 }
 
-/**
- * @param {NestedStringArray} modelPaths
- */
-function flatten(modelPaths) {
-    // TODO: I guess this could be modelPaths.flat(Infinity) in the future
-    return /** @type{string[]}*/(modelPaths.reduce((/** @type {string[]}*/acc, m) => {
-        if (Array.isArray(m)) {
-            acc = acc.concat(flatten(m))
-        } else if (m) {
-            acc.push(m)
-        }
-        return acc
-    }, []))
-}
-
 function getI18nDefaultFolder() {
     // keep '_i18n' as preferred folder for compatibility reasons
     // if (cds.env.i18n.folders.includes('_i18n')) return '_i18n'
@@ -176,10 +184,6 @@ function getI18nDefaultFolder() {
     return cds.env.i18n.folders?.[0] ?? '_i18n'
 }
 
-async function pathExists(path) {
-    return fs.promises.access(path).then(() => true).catch(() => false);
-}
-
 async function getWorkspacePaths() {
     const wsRoot = findWorkspaceRoot(cds.root)
     if (!wsRoot) {
@@ -246,15 +250,15 @@ async function getWorkspacesDeclarations (root) {
  * needs to be defined resulting in a corresponding symlink.
  * @returns {Promise<Workspace[]>} the paths are relative to 'wsRoot'.
  */
-async function getWorkspaces(wsRoot, resolve = false, devDependencies = true, visited = new Set()) {
-    wsRoot ??= findWorkspaceRoot(cds.root)
+async function getWorkspaces(wsRoot, resolve = false, devDependencies = true, visited = new Set(), root = cds.root) {
+    wsRoot ??= findWorkspaceRoot(root)
     if (!wsRoot) {
         return []
     }
     const pkgJsonWsRoot = require(path.join(wsRoot, 'package.json'))
     let pkgJson = pkgJsonWsRoot
-    if (wsRoot !== cds.root) {
-        pkgJson = require(path.join(cds.root, 'package.json'))
+    if (wsRoot !== root) {
+        pkgJson = require(path.join(root, 'package.json'))
     }
     const workspaceDependencies = []
     if (pkgJsonWsRoot.workspaces) {
@@ -271,11 +275,8 @@ async function getWorkspaces(wsRoot, resolve = false, devDependencies = true, vi
                 if (subproject && !visited.has(pkg)) {
                     visited.add(pkg)
                     workspaceDependencies.push(subproject)
-                    // temporarily set cds.root to the dependency to resolve transitive deps thereof
-                    const cdsr = cds.root
-                    cds.root = subproject.path
-                    workspaceDependencies.push(...(await getWorkspaces(wsRoot, resolve, devDependencies, visited)))
-                    cds.root = cdsr
+                    // recursively resolve transitive deps with the subproject as root
+                    workspaceDependencies.push(...(await getWorkspaces(wsRoot, resolve, devDependencies, visited, subproject.path)))
                 }
             }
         }
@@ -398,22 +399,21 @@ function _validateWsDependencies(wsRoot, dependencies, devDependencies) {
 
 /**
  * Returns a flat array of existing files and folders, trailing '/' or '\\' characters have been removed.
- * @param  {NestedStringArray} modelPaths array of files and folders - optionally nested
- * @param  {((m: string) => boolean) | undefined} filter filter function to apply to the found files
- * @returns 
+ * @param {NestedStringArray | object | undefined } modelPaths array of files and folders - optionally nested
+ * @returns {string[] } flat array of existing files and folders
  */
-function _filterModelPaths(modelPaths, filter = undefined) {
+function _filterModelPaths(modelPaths, { env = cds.env, root = cds.root } = {}) {
     const model = /** @type {Set<string>}*/(new Set())
     // may contain nested arrays
-    const flatModelPaths = flatten(modelPaths)
-    const { roots } = cds.env
+    const flatModelPaths = Array.isArray(modelPaths) ? modelPaths.flat(FLATTEN_MAX_DEPTH) : modelPaths ? [modelPaths] : []
+    const { roots } = env
     flatModelPaths.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)
-                // dir + FILE_EXT_CDS: might be cds file name, compatibility to old build configs
-                if (fs.existsSync(dir) || fs.existsSync(dir + FILE_EXT_CDS)) {
+                const dirent = path.resolve(root, m)
+                // might be cds file name, compatibility to old build configs
+                if (exists(dirent) || exists(dirent + FILE_EXT_CDS) || exists(dirent.replaceAll('*', ''))) {
                     model.add(m)
                 }
             } else {
@@ -422,41 +422,9 @@ function _filterModelPaths(modelPaths, filter = undefined) {
         }
     })
     return [...model]
-        .filter(m => filter ? filter(m) : true)
         .map(m => normalizePath(m))
 }
 
-/**
- * Returns a set of files found in the given directory and its subdirectories.
- * @param {string} srcDir - the directory to search for files
- * @param {(file: string) => boolean} [filter] - the filter function to apply to the found files
- * @param {string[]} files - the set of files to add the found files to
- * @param {boolean} [ignoreSymlinks=false] - whether to ignore symlinks
- * @returns {string[]} files found in the given directory and its subdirectories
- */
-function getFiles(srcDir, filter, files = [], ignoreSymlinks = false) {
-    function handleResource(/** @type {string} entry */ entry) {
-        if (!filter || filter.call(this, entry)) {
-            const stats = fs.lstatSync(entry)
-            if (cds.utils.isdir(entry)) {
-                getFiles(entry, filter, files)
-            } else if (stats.isFile() || (!ignoreSymlinks && stats.isSymbolicLink())) {
-                files.push(entry)
-            }
-        }
-    }
-    let entries = []
-    try {
-        entries = fs.readdirSync(srcDir)
-    } catch {
-        // ignore if not existing
-    }
-    entries.map(subDirEntry => path.join(srcDir, subDirEntry)).forEach((entry) => {
-        handleResource(entry)
-    })
-    return files
-}
-
 /**
  * Return gnu-style error string for location `loc`:
  *  - 'File:Line:Col' without `loc.end`
@@ -494,7 +462,7 @@ class BuildMessage {
      * @param {string} message The message text
      * @param {import('./constants').Severity} [severity='Error'] severity - severity of the message
      * @param {SourceLocation | undefined} location Location of the message
-     * 
+     *
      * @memberOf BuildMessage
      */
     constructor(message, severity = SEVERITY_ERROR, location = undefined) {
@@ -521,7 +489,7 @@ class BuildError extends Error {
     /** @type {string[] | {message: string}[]} */
     messages
 
-    /** 
+    /**
      * @param {string} message
      * @param {string | string[]} messages
      */
@@ -548,16 +516,13 @@ module.exports = {
     hasOptionValue,
     relativePaths,
     resolveRequiredSapModels,
-    getDefaultModelOptions,
-    flatten,
+    getDefaultModelPaths,
     getI18nDefaultFolder,
     normalizePath,
-    pathExists,
     getWorkspacePaths,
     getWorkspaces,
     findWorkspaceRoot,
     filterFeaturePaths,
-    getFiles,
     BuildMessage,
     BuildError
 }