@sap/cds 5.9.8 → 6.0.1

package/bin/build/buildTaskHandler.js

@@ -1,8 +1,8 @@
 const path = require('path')
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs').promises
 
 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, isAbsolutePath, BuildMessage } = require('./util')
+const { hasOptionValue, getProperty, relativePaths, BuildMessage } = require('./util')
 
 /**
  * The build task handler creates the build output for a dedicated build task. It is uniquely identified
@@ -113,46 +113,50 @@ class BuildTaskHandler {
         return {
             to: async (dest) => {
                 if (!this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-                    if (!isAbsolutePath(dest)) {
+                    if (!path.isAbsolute(dest)) {
                         // relative to build task's destination path
                         dest = path.resolve(this.task.dest, dest)
                     }
                     this._pushFile(dest)
                     if (this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_DEFAULT)) {
-                        await fs.outputFile(dest, typeof data === "object" ? JSON.stringify(data, null, 2) : data)
+                        await fs.mkdir(path.dirname(dest), { recursive: true })
+                        await fs.writeFile(dest, typeof data === "object" && !Buffer.isBuffer(data) ? JSON.stringify(data, null, 2) : data)
                     }
                 }
             }
         }
     }
 
+    // TODO only works with files due to fs.copyFile, check usages
     /**
      * Copy a file or directory if the build task option 'outputMode' does not have the value 'resultOnly'.
      * The directory can have contents.
      * <p>
      * Note: The file name is stored in the list of files written by this build task handler.
      * </p>
-     * @param {string} source The absolute or relative source path of the file or directory to copy.
+     * @param {string} src The absolute or relative source path of the file or directory to copy.
      * Relative paths will be resolved to this task's source path.
      * @param {string} dest The absolute or relative target path. Relative paths will be resolved to this task's destination path.
      *
      */
-    copy(source) {
+    copy(src) {
         return {
             to: async (dest) => {
                 if (!this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-                    if (!isAbsolutePath(source)) {
+                    if (!path.isAbsolute(src)) {
                         // relative to build task's source path
-                        source = path.resolve(this.task.src, source)
+                        src = path.resolve(this.task.src, src)
                     }
-                    if (!isAbsolutePath(dest)) {
+                    if (!path.isAbsolute(dest)) {
                         // relative to build task's destination path
                         dest = path.resolve(this.task.dest, dest)
                     }
                     this._pushFile(dest)
                     if (this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_DEFAULT)) {
-                        // symlinks are not dereferenced
-                        await fs.copy(source, dest)
+                        if (fs.cp) { // Node.js >= 16.7
+                            return fs.cp(src, dest, { recursive: true })
+                        }
+                        return this._copy(src, dest)
                     }
                     return dest
                 }
@@ -215,6 +219,7 @@ class BuildTaskHandler {
     _hasBuildOption(qualifiedName, value) {
         return hasOptionValue(this._getBuildOption(qualifiedName), value)
     }
+
     // Returns the value of the given build option defined for this build task.
     _getBuildOption(qualifiedName) {
         // build task options overwriting other settings
@@ -228,5 +233,16 @@ class BuildTaskHandler {
         }
         return getProperty(this._buildOptions, qualifiedName)
     }
+
+    // Asynchronously copies the entire content from src to dest.
+    async _copy(src, dest) {
+        if ((await fs.stat(src)).isDirectory()) {
+            const entries = await fs.readdir(src)
+            return Promise.all(entries.map(async each => this._copy(path.join(src, each), path.join(dest, each))))
+        } else {
+            await fs.mkdir(path.dirname(dest), { recursive: true })
+            return fs.copyFile(src, dest)
+        }
+    }
 }
 module.exports = BuildTaskHandler

package/bin/build/buildTaskProvider.js

@@ -2,7 +2,7 @@
 module.exports = class BuildTaskProvider {
     constructor() {
         //injected by framework
-        this._plugin = null 
+        this._plugin = null
     }
     canHandleTask(task) {
         // return this._plugin.provides.includes(task.for || task.use && this._getTaskId(task.use))
@@ -10,9 +10,7 @@ module.exports = class BuildTaskProvider {
     loadHandler(task) {
         // return module.require(`${this._plugin.path}/${task.for || this._getTaskId(task.use)}`)
     }
-    async lookupTasks() {
-        return []
-    }
+    async lookupTasks(tasks) { }
     async applyTaskDefaults(task) {
         // task.for = task.for || this._getTaskId(task.use)
     }

package/bin/build/buildTaskProviderFactory.js

@@ -1,4 +1,4 @@
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs')
 const path = require('path')
 const _cds = require('./cds')
 const { OUTPUT_MODE_DEFAULT, LOG_MODULE_NAMES } = require("./constants")
@@ -33,7 +33,7 @@ class BuildTaskProviderFactory {
     }
 
     async applyTaskDefaults(tasks) {
-        await Promise.all(tasks.map(async task => {
+        return Promise.all(tasks.map(async task => {
             if (!task.for && !task.use) {
                 throw new Error("Invalid build task definition - property 'for' and property 'use' missing")
             }
@@ -55,19 +55,14 @@ class BuildTaskProviderFactory {
         }))
     }
 
-    async lookupTasks() {
-        this.logger.debug("determining CDS build tasks from CDS configuration - applying defaults")
-        let tasks = []
+    async lookupTasks(tasks=[]) {
         await Promise.all(this.providers.map(async (provider) => {
-            let pluginTasks = await this._lookupTasks(provider)
-            if (!Array.isArray(pluginTasks)) {
-                this.logger.error(`Build task provider ${provider.constructor.name} returned invalid type, array required.\nReceived ${JSON.stringify(pluginTasks)}`)
-            }
+            const snapShot = tasks
+            await this._lookupTasks(provider, tasks)
             // apply defaults
-            await this._applyTaskDefaults(provider, pluginTasks)
-
-            tasks = tasks.concat(pluginTasks)
-            this.logger._debug && this.logger.debug(`Build task provider ${provider.constructor.name} returned build tasks ${JSON.stringify(pluginTasks)}`)
+            const newTasks = tasks.filter(task => !snapShot.includes(task))
+            await this._applyTaskDefaults(provider, newTasks)
+            this.logger._debug && this.logger.debug(`Build task provider ${provider.constructor.name} returned build tasks ${JSON.stringify(newTasks)}`)
         }))
         return tasks
     }
@@ -94,7 +89,7 @@ class BuildTaskProviderFactory {
 
     /**
      * Loads the build task handler implementation for the given build task.
-     * 'for' defines an alias for built-in handlers like 'hana', 'java-cf', 'node-cf', 'fiori' or 'mtx'.
+     * 'for' defines an alias for built-in handlers like 'hana', 'java', 'node', 'fiori' or 'mtx'.
      * 'use' defines the fully qualified module name of external build task handler implemenations.
      * @param {object} task
      */
@@ -144,9 +139,9 @@ class BuildTaskProviderFactory {
         return resolvedTask
     }
 
-    async _lookupTasks(provider) {
+    async _lookupTasks(provider, tasks) {
         try {
-            return provider.lookupTasks(this.buildOptions)
+            await provider.lookupTasks(tasks, this.buildOptions)
         } catch (e) {
             this.logger.error(`Build task provider ${provider.constructor.name} returned error:\n` + e)
             throw e

package/bin/build/constants.js

@@ -6,20 +6,21 @@ exports.OUTPUT_MODE_RESULT_ONLY = "resultOnly"
 
 exports.BUILD_TASK_NPM_SCOPE = "@sap"
 exports.BUILD_TASK_PREFIX = exports.BUILD_TASK_NPM_SCOPE + "/cds/build"
-exports.BUILD_TASK_JAVA = "java-cf"
-exports.BUILD_TASK_NODE = "node-cf"
+exports.BUILD_TASK_JAVA = "java"
+exports.BUILD_TASK_JAVA_CF = "java-cf"
+exports.BUILD_TASK_NODEJS = "nodejs"
+exports.BUILD_TASK_NODE_CF = "node-cf"
 exports.BUILD_TASK_HANA = "hana"
 exports.BUILD_TASK_FIORI = "fiori"
 exports.BUILD_TASK_MTX = "mtx"
-exports.BUILD_TASKS = [this.BUILD_TASK_JAVA, this.BUILD_TASK_NODE, this.BUILD_TASK_HANA, this.BUILD_TASK_FIORI, this.BUILD_TASK_MTX]
+exports.BUILD_TASK_MTX_SIDECAR = "mtx-sidecar"
+exports.BUILD_TASKS = [this.BUILD_TASK_JAVA, this.BUILD_TASK_JAVA_CF, this.BUILD_TASK_NODEJS, this.BUILD_TASK_NODE_CF, this.BUILD_TASK_HANA, this.BUILD_TASK_FIORI, this.BUILD_TASK_MTX, this.BUILD_TASK_MTX_SIDECAR]
 
 exports.ODATA_VERSION = "odata.version"
 exports.ODATA_VERSION_V2 = "v2"
 exports.ODATA_VERSION_V4 = "v4"
 
-exports.BUILD_MODE_INPLACE = "inplace"
 exports.BUILD_NODEJS_EDMX_GENERAION = "build.nodejs.edmxgeneration" // WebIDE Fullstack
-
 exports.EDMX_GENERATION = "edmxGeneration"
 
 exports.SKIP_MANIFEST_GENERATION = "skipManifestGeneration"
@@ -31,11 +32,18 @@ exports.CONTENT_DEFAULT_CSN = "contentDefaultCsn"           // create default CS
 exports.CONTENT_EDMX = "contentEdmx"                        // create EDMX for required languages
 exports.CONTENT_MANIFEST = "contentManifest"                // create manifest.yml and .cfignore files
 exports.CONTENT_PACKAGE_JSON = "contentPackageJson"         // create package.json file if not existing, or modify existing package.json
-exports.CONTENT_PACKAGELOCK_JSON = "contentPackageLockJson" // copy package-lock.json file if existing
+exports.CONTENT_PACKAGELOCK_JSON = "contentPackageLockJson" // copy package-lock.json file if existing into deployment folder
 exports.CONTENT_HDBTABLEDATA = "contentHdbtabledata"        // create .hdbtabledata files for .csv files if not existing
+exports.CONTENT_NPMRC = "contentNpmrc"                      // copy .npmrc file if existing into deployment folder
+exports.CONTENT_CDSRC_JSON = "contentCdsrcJson"             // copy .cdsrc.json file if existing into deployment folder
+exports.CONTENT_NODE_MODULES = "contentNodeModules"         // copy node_modules folder if existing into deployment folder
+exports.CONTENT_ENV = "contentEnv"                          // copy .env file if existing into deployment folder
+exports.CONTENT_DEFAULT_ENV_JSON = "contentDefaultEnvJson"  // copy default-env.json file if existing into deployment folder
+exports.CSV_FILE_DETECTION = "csvFileDetection"             // detect CSV files based on CDS model location
 
 exports.FOLDER_GEN = "gen"
 exports.FILE_EXT_CDS = ".cds"
+exports.MTX_SIDECAR_FOLDER = "mtx/sidecar"                  // default name of the mtx sidecar folder
 
 exports.CDS_CONFIG_PATH_SEP = "/"
 exports.SKIP_ASSERT_COMPILER_V2 = "skip-assert-compiler-v2"

package/bin/build/csv-reader.js

@@ -1,9 +1,10 @@
 const {createReadStream, createWriteStream, readFile:rf} = require('fs')
 const readFile = require('util').promisify(rf)
 const {Readable} = require('stream')
+const cds = require('../../lib')
 
 const SEPARATOR = /[,;\t]/
-module.exports = { parse: global.cds.parse.csv, readHeader, stripComments, serialize }
+module.exports = { parse: cds.parse.csv, readHeader, stripComments, serialize }
 
 
 function serialize (rows, columns, bom='\ufeff') {

package/bin/build/index.js

@@ -1,11 +1,10 @@
 const path = require('path')
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs')
 const BuildTaskEngine = require('./buildTaskEngine')
 const BuildTaskFactory = require('./buildTaskFactory')
 const BuildTaskHandler = require('./buildTaskHandler')
 const { LOG_MODULE_NAMES } = require('./constants')
 const { BuildError } = require('./util')
-const { BUILD_MODE_INPLACE } = require('./constants')
 
 module.exports = Object.assign(build,
     { build, BuildTaskFactory, BuildTaskEngine, BuildTaskHandler, BuildError }
@@ -15,34 +14,29 @@ module.exports = Object.assign(build,
  * New modular build.
  *
  * @param {object} options - commmand options as defined by build command.
- * @param {object} _env - for testing purposes only, will be removed.
  */
-async function build(options = {}, _env = null /* for unit tests only: */) {
+async function build(options = {}) {
     const projectPath = path.resolve(options.project || '.')
 
     if (!fs.lstatSync(projectPath).isDirectory()) {
         return Promise.reject(`Project [${projectPath}] does not exist`)
     }
 
-    const cds = require('./cds').in(projectPath)
-    const logger = options.logger || cds.log(LOG_MODULE_NAMES)
-
-    if (_env) {
-        // REVISIT: please avoid using internal APIs
-        cds.env = cds.env._merge_with(_env)
+    const cds = require('./cds')
+    if (projectPath !== process.cwd()) {
+        const env = cds.env.for('cds', projectPath);
+        cds.env = env
+        cds.root = projectPath
     }
+    const logger = options.logger || cds.log(LOG_MODULE_NAMES)
 
-    const buildOptions = _mergeOptions({ root: projectPath }, options)
+    const buildOptions = _mergeCliOptions({ root: projectPath }, options)
 
-    // Webide Fullstack compatibility mode
-    if (cds.env.build.mode === BUILD_MODE_INPLACE) {
-        cds.env.build.target = "."
-    }
-    let tasks = await new BuildTaskFactory(logger, cds).getTasks(buildOptions)
-    return new BuildTaskEngine(logger, cds).processTasks(tasks, buildOptions)
+    let tasks = await new BuildTaskFactory(logger).getTasks(buildOptions)
+    return new BuildTaskEngine(logger).processTasks(tasks, buildOptions)
 }
 
-function _mergeOptions(buildOptions, options) {
+function _mergeCliOptions(buildOptions, options) {
     buildOptions["log-level"] = options["log-level"]
     buildOptions.cli = options.cli
     buildOptions.cmdOptions = options

package/bin/build/provider/buildTaskHandlerEdmx.js

@@ -1,18 +1,8 @@
 const path = require('path')
-const BuildTaskHandlerInternal = require('./buildTaskHandlerInternal')
+const BuildTaskHandlerFeatureToggles = require('./buildTaskHandlerFeatureToggles')
 const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = require('../constants')
 
-class BuildTaskHandlerEdmx extends BuildTaskHandlerInternal {
-    init() {
-        this._result = {
-            dest: this.task.dest,
-            csn: {},
-            edmx: new Map(),
-            languages: new Set(),
-            services: new Set(),
-            languageBundles: {}
-        }
-    }
+class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
     async compileToEdmx(model, edmxDest, compileOptions = {}) { // NOSONAR
         const promises = []
         const services = this.cds.reflect(model).services
@@ -55,38 +45,12 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerInternal {
         return Promise.all(promises)
     }
 
-    async compileToJson(model, csnDest, saveResult = true) {
-        // This will als add a @source prop containing the relative path to the origin .cds source file
-        // and a parsed _where clause for @restrict.{grant,where} annotations.
-        // The @source annotation is required for correct custom handler resolution if no @impl annotation has been defined as
-        // custom service handler implementations are relative to the origin .cds source files.
-        // For staging builds (task.src !== task.dest) the csn.json file that is served at runtime is copied into a corresponding srv subfolder.
-        // As a consequence the src folder name has to be included in the @source file name while for inplace builds (task.src === task.dest) this is not the case.
-        // This ensures that the paths are relative to the cwd when executing cds run.
-        const jsonOptions = {
-            cwd: this.buildOptions.root,
-            src: this.task.src === this.task.dest ? this.task.src : this.buildOptions.root
-        }
-        const csnStr = this.cds.compile.to.json(model, jsonOptions)
-        const csn = JSON.parse(csnStr)
-        if (saveResult) {
-            this._result.csn = csn
-            this._result.csn.meta = model.meta
-        }
-
-        // csnDest might be null
-        if (csnDest && !this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-            await this.write(csnStr).to(path.join(csnDest, 'csn.json'))
-        }
-        return csn
-    }
-
     /**
      * Collect and write language bundles into a single i18n.json file.
      * @param {Object} model
      * @param {string} bundleDest
      */
-    async collectLanguageBundles(model, bundleDest, saveResult = true) {
+     async collectLanguageBundles(model, bundleDest, saveResult = true) {
         // collect effective i18n properties...
         let bundles = {}
         const bundleGenerator = this.cds.localize.bundles4(model)

package/bin/build/provider/buildTaskHandlerFeatureToggles.js

@@ -0,0 +1,149 @@
+const fs = require('fs')
+const path = require('path')
+const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = require('../constants')
+const BuildTaskHandlerInternal = require('./buildTaskHandlerInternal')
+
+class FeatureToggleBuilder extends BuildTaskHandlerInternal {
+    init() {
+        this._result = {
+            dest: this.task.dest,
+            csn: {},
+            edmx: new Map(),
+            languages: new Set(),
+            services: new Set(),
+            languageBundles: {}
+        }
+    }
+
+    get ftsName() {
+        return path.dirname(this.env.features.folders || 'fts/*')
+    }
+
+    async compileAll(csn, destBase, destFts) {
+        const sources = await this._resolveSourcePaths(csn)
+        const dictionary = { base: null, features: null }
+
+        if (sources.features) {
+            // create base model as the given CSN is containing all features
+            dictionary.base = await this.cds.load(sources.base, this.options())
+        } else {
+            // CSN already represents the base model as no features exist
+            dictionary.base = csn
+        }
+        // preserve @location as @source properties
+        await this.compileToJson(dictionary.base, destBase)
+
+        if (sources.features) {
+            dictionary.features = await this._compileFeatures(sources.features, destBase, destFts)
+        }
+        return { dictionary, sources }
+    }
+
+    async collectAllLanguageBundles(dictionary, paths, destBase, destFts) {
+        // create language bundle for base model
+        await this.collectLanguageBundles(dictionary.base, destBase)
+        if (dictionary.features) {
+            // create language bundles for all features
+            for (const ftName in dictionary.features) {
+                // attach the sources information for i18n location reference
+                dictionary.features[ftName]['$sources'] = paths.features[ftName]
+                await this.collectLanguageBundles(dictionary.features[ftName], path.join(destFts, this.ftsName, ftName), false)
+            }
+        }
+    }
+
+    async _resolveSourcePaths(csn) {
+        const regex = new RegExp(path.resolve(this.buildOptions.root, this.ftsName).replace(/\\/g, '\\\\') + '[/|\\\\](?<ftName>[^/|\\\\]*)')
+        let paths = { base: [] }
+
+        // add ROOT source file paths for the base model
+        paths.base = this._resolveModel().reduce((acc, file) => {
+            const match = file.match(regex)
+            if (!match) {
+                acc.push(file)
+            }
+            return acc
+        }, [])
+
+        // keep existing behaviour and return paths returned by cds.resolve if features are not supported by this project
+        if (!fs.existsSync(path.join(this.buildOptions.root, this.ftsName))) {
+            return paths
+        }
+
+        // add source file paths for the features
+        paths.features = csn['$sources'].reduce((acc, file) => {
+            const match = file.match(regex)
+            if (match) {
+                const { ftName } = match.groups
+                //feature
+                if (!acc[ftName]) {
+                    acc[ftName] = []
+                }
+                acc[ftName].push(file)
+            }
+            return acc
+        }, {})
+
+        return paths
+    }
+
+    async compileToJson(model, csnDest, saveResult = true) {
+        // This will als add a @source prop containing the relative path to the origin .cds source file
+        // and a parsed _where clause for @restrict.{grant,where} annotations.
+        // The @source annotation is required for correct custom handler resolution if no @impl annotation has been defined as
+        // custom service handler implementations are relative to the origin .cds source files.
+        // For staging builds (task.src !== task.dest) the csn.json file that is served at runtime is copied into a corresponding srv subfolder.
+        // As a consequence the src folder name has to be included in the @source file name while for inplace builds (task.src === task.dest) this is not the case.
+        // This ensures that the paths are relative to the cwd when executing cds run.
+        const jsonOptions = {
+            cwd: this.buildOptions.root,
+            src: this.task.src === this.task.dest ? this.task.src : this.buildOptions.root
+        }
+        const csnStr = this.cds.compile.to.json(model, jsonOptions)
+        const csn = JSON.parse(csnStr)
+        if (saveResult) {
+            this._result.csn = csn
+            this._result.csn.meta = model.meta
+        }
+
+        // csnDest might be null
+        if (csnDest && !this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
+            await this.write(csnStr).to(path.join(csnDest, 'csn.json'))
+        }
+        return csn
+    }
+
+    async _compileFeatures(ftsPaths, destBase, destFts) {
+        if (!ftsPaths) {
+            return
+        }
+        const features = {}
+        const options = { ...this.options(), flavor: 'parsed' }
+        const srvFolder = path.relative(destFts, destBase)
+
+        // create feature models
+        for (const ftName in ftsPaths) {
+            const ftCsn = await this.cds.load(ftsPaths[ftName], options)
+
+            // replace require paths by base model path to ensure precedence of feature annos
+            // see https://pages.github.tools.sap/cap/docs/cds/compiler-messages#anno-duplicate-unrelated-layer
+            ftCsn.requires = [path.join('../..', srvFolder, 'csn.json')]
+
+            const ftPath = path.join(destFts, this.ftsName, ftName)
+            await this.compileToJson(ftCsn, ftPath, false)
+            await this._validateFeature(ftPath)
+            features[ftName] = ftCsn
+        }
+        return features
+    }
+
+    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])
+        // 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())
+    }
+}
+
+module.exports = FeatureToggleBuilder

package/bin/build/provider/buildTaskHandlerInternal.js

@@ -1,4 +1,4 @@
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs')
 const path = require('path')
 const BuildTaskHandler = require('../buildTaskHandler')
 const { hasOptionValue } = require('../util')
@@ -47,7 +47,7 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
         // the build results have already been deleted by the BuildTaskEngine if the build.target !== '.'
         // make sure that src is not a subfolder of dest
         if (this._buildOptions.root === this._buildOptions.target && this.task.src !== this.task.dest && !this._isSubDirectory(this.task.dest, this.task.src)) {
-            await fs.remove(this.task.dest)
+            await fs.promises.rm(this.task.dest, {force: true, recursive: true})
         }
     }
 
@@ -153,7 +153,6 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
             // - are contained in this modules 'dest' folder
             // - are contained in some generation folder
             // - do NOT fullfill additional specific filter criteria
-            // NOTE: there is no specific handling for content that is part of the 'node_modules' folder as it might be required later on, e.g. reuse model content
             return this._commonStagingBuildFilter(src, destDir) && (!customFilter || customFilter.call(this, src))
         })
         return Promise.all(