@sap/cds-dk 6.8.2 → 7.0.0

package/lib/build/provider/hana/template/.hdiconfig-cloud

@@ -0,0 +1,137 @@
+
+{
+    "file_suffixes": {
+        "csv": {
+            "plugin_name": "com.sap.hana.di.tabledata.source"
+        },
+        "hdbafllangprocedure": {
+            "plugin_name": "com.sap.hana.di.afllangprocedure"
+        },
+        "hdbanalyticprivilege": {
+            "plugin_name": "com.sap.hana.di.analyticprivilege"
+        },
+        "hdbcalculationview": {
+            "plugin_name": "com.sap.hana.di.calculationview"
+        },
+        "hdbcollection": {
+            "plugin_name": "com.sap.hana.di.collection"
+        },
+        "hdbconstraint": {
+            "plugin_name": "com.sap.hana.di.constraint"
+        },
+        "hdbdropcreatetable": {
+            "plugin_name": "com.sap.hana.di.dropcreatetable"
+        },
+        "hdbflowgraph": {
+            "plugin_name": "com.sap.hana.di.flowgraph"
+        },
+        "hdbfunction": {
+            "plugin_name": "com.sap.hana.di.function"
+        },
+        "hdbgraphworkspace": {
+            "plugin_name": "com.sap.hana.di.graphworkspace"
+        },
+        "hdbhadoopmrjob": {
+            "plugin_name": "com.sap.hana.di.virtualfunctionpackage.hadoop"
+        },
+        "hdbindex": {
+            "plugin_name": "com.sap.hana.di.index"
+        },
+        "hdblibrary": {
+            "plugin_name": "com.sap.hana.di.library"
+        },
+        "hdbmigrationtable": {
+            "plugin_name": "com.sap.hana.di.table.migration"
+        },
+        "hdbprocedure": {
+            "plugin_name": "com.sap.hana.di.procedure"
+        },
+        "hdbprojectionview": {
+            "plugin_name": "com.sap.hana.di.projectionview"
+        },
+        "hdbprojectionviewconfig": {
+            "plugin_name": "com.sap.hana.di.projectionview.config"
+        },
+        "hdbreptask": {
+            "plugin_name": "com.sap.hana.di.reptask"
+        },
+        "hdbresultcache": {
+            "plugin_name": "com.sap.hana.di.resultcache"
+        },
+        "hdbrole": {
+            "plugin_name": "com.sap.hana.di.role"
+        },
+        "hdbroleconfig": {
+            "plugin_name": "com.sap.hana.di.role.config"
+        },
+        "hdbsearchruleset": {
+            "plugin_name": "com.sap.hana.di.searchruleset"
+        },
+        "hdbsequence": {
+            "plugin_name": "com.sap.hana.di.sequence"
+        },
+        "hdbstatistics": {
+            "plugin_name": "com.sap.hana.di.statistics"
+        },
+        "hdbstructuredprivilege": {
+            "plugin_name": "com.sap.hana.di.structuredprivilege"
+        },
+        "hdbsynonym": {
+            "plugin_name": "com.sap.hana.di.synonym"
+        },
+        "hdbsynonymconfig": {
+            "plugin_name": "com.sap.hana.di.synonym.config"
+        },
+        "hdbsystemversioning": {
+            "plugin_name": "com.sap.hana.di.systemversioning"
+        },
+        "hdbtable": {
+            "plugin_name": "com.sap.hana.di.table"
+        },
+        "hdbtabledata": {
+            "plugin_name": "com.sap.hana.di.tabledata"
+        },
+        "hdbtabletype": {
+            "plugin_name": "com.sap.hana.di.tabletype"
+        },
+        "hdbtrigger": {
+            "plugin_name": "com.sap.hana.di.trigger"
+        },
+        "hdbview": {
+            "plugin_name": "com.sap.hana.di.view"
+        },
+        "hdbvirtualfunction": {
+            "plugin_name": "com.sap.hana.di.virtualfunction"
+        },
+        "hdbvirtualfunctionconfig": {
+            "plugin_name": "com.sap.hana.di.virtualfunction.config"
+        },
+        "hdbvirtualpackagehadoop": {
+            "plugin_name": "com.sap.hana.di.virtualpackage.hadoop"
+        },
+        "hdbvirtualpackagesparksql": {
+            "plugin_name": "com.sap.hana.di.virtualpackage.sparksql"
+        },
+        "hdbvirtualprocedure": {
+            "plugin_name": "com.sap.hana.di.virtualprocedure"
+        },
+        "hdbvirtualprocedureconfig": {
+            "plugin_name": "com.sap.hana.di.virtualprocedure.config"
+        },
+        "hdbvirtualtable": {
+            "plugin_name": "com.sap.hana.di.virtualtable"
+        },
+        "hdbvirtualtableconfig": {
+            "plugin_name": "com.sap.hana.di.virtualtable.config"
+        },
+        "properties": {
+            "plugin_name": "com.sap.hana.di.tabledata.properties"
+        },
+        "tags": {
+            "plugin_name": "com.sap.hana.di.tabledata.properties"
+        },
+        "txt": {
+            "plugin_name": "com.sap.hana.di.copyonly"
+        }
+    }
+}

package/lib/build/provider/hana/template/.hdinamespace

@@ -0,0 +1,4 @@
+{
+    "name": "",
+    "subfolder": "ignore"
+}

package/lib/build/provider/hana/template/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "deploy",
+  "dependencies": {
+    "@sap/hdi-deploy": "^4"
+  },
+  "engines": {
+    "node": "^14 || ^16 || ^18"
+  },
+  "scripts": {
+    "start": "node node_modules/@sap/hdi-deploy/deploy.js"
+  }
+}

package/lib/build/provider/hana/template/undeploy.json

@@ -0,0 +1,5 @@
+[
+    "src/gen/**/*.hdbview",
+    "src/gen/**/*.hdbindex",
+    "src/gen/**/*.hdbconstraint"
+]

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

@@ -0,0 +1,93 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../../cds')
+const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const { OUTPUT_MODE, OUTPUT_MODE_RESULT, FILE_EXT_CDS, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN, DEFAULT_CSN_FILE_NAME } = require('../../constants')
+const DEFAULT_COMPILE_DEST_FOLDER = path.normalize('src/main/resources/edmx')
+
+class JavaModuleBuilder extends BuildTaskHandlerEdmx {
+    init() {
+        super.init()
+        this.task.options.compileDest = path.resolve(this.task.dest, this.task.options.compileDest || DEFAULT_COMPILE_DEST_FOLDER)
+    }
+
+    async build() {
+        const { src, dest } = this.task
+
+        const odataOptions = {
+            version: cds.env.odata?.version
+        }
+
+        const model = await this.model()
+        if (!model) {
+            return
+        }
+
+        const odata = await this._compileForOdata(model, this.task.options.compileDest, odataOptions)
+        await this.compileToEdmx(odata, this.task.options.compileDest, odataOptions)
+
+        if (this.hasBuildOption(CONTENT_LANGUAGE_BUNDLES, true)) {
+            // collect and write language bundles into single i18n.json file
+            const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
+            const i18n = await this.collectLanguageBundles(model, path.join(this.task.dest, i18nFolder))
+            if (i18n && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
+                this._result.languageBundles = i18n.bundles
+            }
+        }
+        if (this.isStagingBuild() && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
+            await this._copyNativeContent(src, dest)
+        }
+        return this._result
+    }
+
+    async clean() {
+        if (this.isStagingBuild()) {
+            return super.clean()
+        }
+        this.logger._debug && this.logger.debug(`Deleting build target folder ${this.task.options.compileDest}`)
+        await fs.promises.rm(this.task.options.compileDest, { force: true, recursive: true })
+    }
+
+    async _copyNativeContent(src, dest) {
+        return super.copyNativeContent(src, dest, (entry) => {
+            if (fs.statSync(entry).isDirectory()) {
+                return true // using common filter for folders
+            } else {
+                const extname = path.extname(entry)
+                return extname !== FILE_EXT_CDS
+            }
+        })
+    }
+
+    async _compileForOdata(model, csnDest, compileOptions) {
+        // csn for service providers
+        const m = cds.compile.for.java(model, {
+            ...this._options4odata(),
+            ...compileOptions
+        })
+        const csnFile = path.join(csnDest, DEFAULT_CSN_FILE_NAME)
+        let csnModel
+        // adding csn to build result containing @source and _where persisted properties
+        if (this.hasBuildOption(CONTENT_DEFAULT_CSN, true)) { //default true or undefined
+            const csnStr = await this.compileToJson(model, csnFile)
+            csnModel = JSON.parse(csnStr)
+            csnModel.meta = model.meta
+        } else {
+            const csnStr = await this.compileToJson(m, csnFile)
+            csnModel = JSON.parse(csnStr)
+            csnModel.meta = m.meta
+        }
+        if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
+            this._result.csn = csnModel
+        }
+
+        return m
+    }
+
+    _isCompilerV1() {
+        const version = cds.compiler.version()
+        const match = version.match(/(\d+)\.?(\d*)\.?(\d*)/)
+        return match && match[1] === 1
+    }
+}
+module.exports = JavaModuleBuilder

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

@@ -0,0 +1 @@
+module.exports = require('../java')

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

@@ -0,0 +1,37 @@
+/* eslint-disable no-empty */
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../../cds')
+const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const ResourcesTarProvider = require('./resourcesTarBuilder')
+const { FOLDER_GEN } = require('../../constants')
+
+class MtxModuleBuilder extends BuildTaskHandlerEdmx {
+    get priority() {
+        // should be scheduled after 'hana' build tasks are finished
+        return BuildTaskHandlerEdmx.PRIORITY_MIN_VALUE
+    }
+    init() {
+        super.init()
+    }
+
+    async build() {
+        // Non-sidecar scenario: model-provider is implemented by the Nodejs app itself (default for Nodejs).
+        // Only create resources TAR, compiled CSN(s) are created by the Nodejs app build task.
+        const dest = cds.env.build.target !== "." ? this.task.dest : path.join(this.task.dest, FOLDER_GEN)
+        const model = await this.model()
+        if (!model) {
+            return
+        }
+        return new ResourcesTarProvider(this).createTar(dest, model)
+    }
+
+    async clean() {
+        // staging build content is deleted by BuildTaskEngine
+        if (cds.env.build.target === '.') {
+            // remove 'gen' folder
+            return fs.promises.rm(path.join(this.task.dest, FOLDER_GEN), { force: true, recursive: true })
+        }
+    }
+}
+module.exports = MtxModuleBuilder

package/lib/build/provider/mtx/resourcesTarBuilder.js

@@ -0,0 +1,94 @@
+const path = require('path')
+const cds = require('../../../cds')
+const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
+
+const { BUILD_TASK_HANA } = require('../../constants')
+const fs = require('fs')
+const { WARNING } = BuildTaskHandlerInternal
+const DEFAULT_TAR_NAME = "resources.tgz"
+
+class ResourcesTarBuilder {
+    constructor(handler) {
+        this._handler = handler
+    }
+
+    get handler() { return this._handler }
+
+    async createTar(dest, model) {
+        const { root, resources } = await this._getResources(model)
+        if (resources.length === 0) {
+            // packTarArchive fails otherwise
+            this.handler.pushMessage("No deployment resources found - skip resources.tgz", WARNING)
+            return
+        }
+        await this.writeTarFile(path.join(dest, DEFAULT_TAR_NAME), root, resources)
+    }
+
+    /**
+     * Creates a TAR file at the given absolute tarPath. An optional resources list holds the files and folders 
+     * that will be added to the TAR. Paths are relative to the passed root directory. If omitted, the entire 
+     * root directory contents will be added. 
+     * @param {*} tarFile Absolute TAR file name.
+     * @param {*} root The root directory the passed resources are relative to.
+     * @param {*} resources Optional list of absolute or relative resource paths - relative to the given root directory. 
+     * If omitted all resources contained in the root directory are added to the TAR file.
+     */
+    async writeTarFile(tarFile, root, resources) {
+        const { tar } = require('../../../../lib').utils
+        await tar.czfd(tarFile, root, resources)
+        this.handler.pushFile(tarFile)
+    }
+
+    async _getResources(model) {
+        // distinguish HANA and SQLITE deployment
+        let root = await this._getHanaTenantDbDest()
+        let resources
+        if (root) {
+            resources = this._getHanaResources(root)
+        } else {
+            root = cds.root
+            resources = await this._getSqliteResources(model)
+        }
+        return { root, resources }
+    }
+
+    /**
+     * Reads a list of files and folders required for HANA deployment.
+     * This is a subset of all files contained in the directory.
+     * - 'db/src', 'db/cfg', 'db/undeploy.json'...
+     * See '../../../../lib.deploy'
+     * Note: the hana build task has already been executed
+     * @param {string} root
+     * @returns an array containing all resources
+     */
+    _getHanaResources(root) {
+        return ['src', 'cfg', 'undeploy.json', '.hdiignore'].reduce((acc, res) => {
+            const resPath = path.join(root, res)
+            if (fs.existsSync(resPath)) {
+                acc.push(resPath)
+            }
+            return acc
+        }, [])
+    }
+
+    /**
+     * Reads all resources for Sqlite deployment - see '../../../../lib.deploy'
+     *
+     * @param {object} model
+     * @returns
+     */
+    async _getSqliteResources(model) {
+        const { resources } = cds.deploy
+        return Object.keys(await resources(model))
+    }
+
+    async _getHanaTenantDbDest() {
+        let hanaTask = this.handler.context.tasks.find(task => task.for === BUILD_TASK_HANA)
+        if (!hanaTask) {
+            this.handler.pushMessage(`Found SQLite database configuration. Ensure that productive cloud deployments requiring SAP HANA database are built with 'production' profile.`, WARNING)
+            return null
+        }
+        return hanaTask.dest
+    }
+}
+module.exports = ResourcesTarBuilder

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

@@ -0,0 +1,131 @@
+const path = require('path')
+const fs = require('fs')
+const cds = require('../../../cds')
+
+const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
+const { FOLDER_GEN, EXTENSION_POINT_VALIDATION } = require('../../constants')
+const ResourcesTarBuilder = require('../mtx/resourcesTarBuilder')
+const { BuildError, BuildMessage } = require('../../util')
+
+class MtxExtensionModuleBuilder extends BuildTaskHandlerInternal {
+    init() {
+        super.init()
+        if (cds.env.build.target === '.') {
+            this.task.dest = path.join(this.task.dest, FOLDER_GEN)
+        }
+    }
+
+    async build() {
+        const { src, dest } = this.task
+        const destExt = path.join(dest, 'ext')
+        // check existence of appPackage folder only
+        // REVISIT: cds.resolve will fail as no index.csn file exists in this folder for the extension migration use case
+        // a compilation error is thrown anyhow if any base model refs cannot be resolved
+        const appPackageFolder = this._getAppPackageFolder()
+        if (!fs.existsSync(path.join(src, appPackageFolder))) {
+            throw new BuildError(`The SaaS application base model '${appPackageFolder}' is missing. Have you run the 'cds pull' command?`)
+        }
+
+        // full compile of the extension using base model - ensuring consistency
+        const model = await this.model()
+
+        if (model) {
+            // extension CSN using parsed format
+            const options = { ...this.options(), flavor: 'parsed' }
+            const extModel = await cds.load(this._resolveExtensionFiles(model), options)
+            if (extModel.requires) {
+                extModel.requires.length = 0
+            }
+
+            if (!this.hasBuildOption(EXTENSION_POINT_VALIDATION, false)) {
+                this._lintExtModel(extModel, model) // throws error in case of linting errors
+            }
+
+            await this.compileToJson(extModel, path.join(destExt, 'extension.csn'))
+
+            await this.collectLanguageBundles(extModel, path.join(destExt, 'i18n'))
+
+            const files = Object.keys(await cds.deploy.resources(model))
+            if (files.length > 0) {
+                const dataDest = path.join(destExt, 'data')
+                await Promise.all(
+                    files
+                        .filter(file => /\.csv$/.test(file))
+                        .map(csv => {
+                            return this.copy(csv).to(path.join(dataDest, path.basename(csv)))
+                        })
+                )
+            }
+        }
+
+        const packageJson = path.join(src, 'package.json')
+        if (!fs.existsSync(packageJson)) {
+            throw new BuildError(`package.json file not found in ${src}`)
+        }
+        await this.copy(packageJson).to(path.join(destExt, 'package.json'))
+
+        // copy handlers
+        const folders = [path.join(src, cds.env.folders.srv, 'handlers')]
+        await this.copyNativeContent(src, destExt, res => {
+            if (fs.statSync(res).isDirectory()) {
+                return folders.some(folder => folder.startsWith(res))
+            }
+            if (folders.includes(path.dirname(res)) && /\.js$/.test(res)) {
+                return true
+            }
+        })
+
+        // add all resources contained in 'gen/ext' folder
+        await new ResourcesTarBuilder(this).writeTarFile(path.join(this.task.dest, 'extension.tgz'), destExt)
+    }
+
+    _resolveExtensionFiles(model) {
+        const node_modules = path.join(this.task.src, 'node_modules')
+        const paths = model['$sources'].reduce((acc, file) => {
+            if (file.startsWith(this.task.src) && !file.startsWith(node_modules)) {
+                acc.push(file)
+            }
+            return acc
+        }, [])
+
+        return paths
+    }
+    
+    _lintExtModel(extModel, model) {
+        const linter = this._linter()
+        if (!linter) {
+            return
+        }
+        const env = cds.env.for('cds', path.join(this.task.src, this._getAppPackageFolder()))
+        this.logger._debug && this.logger.debug(`Saas extension point restrictions:\n${env.requires?.['cds.xt.ExtensibilityService']}`)
+
+        const messages = linter.lint(extModel, model, env)
+        if (messages.length) {
+            // REVISIT: lint messages can be passed as is with cds-mtxs version >= 1.7
+            throw new BuildError('SaaS extension point restrictions violated. Check the concrete restrictions defined by the SaaS app provider.',
+                messages.map(f => new BuildMessage(f.message, f.severity, f.location || f.element?.$location)))
+        }
+    }
+
+    _linter() {
+        let linter
+        try {
+            // Make sure cds-mtxs APIs are loaded
+            linter = require('@sap/cds-mtxs').xt?.linter
+            if (!linter) {
+                this.pushMessage('MTXS linter cannot be loaded. Update of @sap/cds-dk and @sap/cds-mtxs modules required? Skipping extension model lint step.')
+                return null // too old mtxs
+            }
+        } catch (e) {
+            if (e.code !== 'MODULE_NOT_FOUND') throw e
+            this.pushMessage('MTXS linter cannot be loaded, @sap/cds-mtxs not installed. Skipping extension model lint step.')
+        }
+        return linter
+    }
+
+    _getAppPackageFolder() {
+        return path.join('node_modules', cds.env.extends || '_base');
+    }
+}
+
+module.exports = MtxExtensionModuleBuilder

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

@@ -0,0 +1,138 @@
+const path = require('path')
+const cds = require('../../../cds')
+const fs = require('fs')
+const { FOLDER_GEN, DEFAULT_CSN_FILE_NAME } = require('../../constants')
+const NodeCfModuleBuilder = require('../nodejs')
+const ResourcesTarProvider = require('../mtx/resourcesTarBuilder')
+const { WARNING, ERROR } = NodeCfModuleBuilder
+const { relativePaths, BuildError, resolveRequiredSapModels } = require('../../util')
+
+const DEFAULT_MAIN_FOLDER = "_main"
+
+class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
+    get priority() {
+        // should be scheduled after 'hana' build tasks are finished
+        return NodeCfModuleBuilder.PRIORITY_MIN_VALUE
+    }
+    init() {
+        super.init()
+        if (cds.env.build.target === '.') {
+            this.task.dest = path.join(this.task.dest, FOLDER_GEN)
+        }
+    }
+
+    /**
+     * 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
+     *
+     * 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)
+    }
+
+    /**
+     * Builds the mtx sidecar nodejs app parts.
+     * @param {object} sidecarEnv cds env based on the sidecar dir
+     */
+    async _buildNodeApp(sidecarEnv) {
+        const destSidecar = this.task.dest
+        const destSidecarSrc = path.join(destSidecar, cds.env.folders.srv)
+        const i18nFolder = cds.env.i18n.folders?.[0] || 'i18n'
+        const model = this._compileSidecarSync(sidecarEnv)
+        await this.compileToJson(model, path.join(destSidecarSrc, DEFAULT_CSN_FILE_NAME))
+
+        await this.collectLanguageBundles(model, path.join(destSidecarSrc, i18nFolder))
+        await this.copyProjectRootContent(this.task.src, destSidecar)
+    }
+
+    /**
+     * 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
+     */
+    async _buildMainApp(sidecarEnv) {
+        let main = sidecarEnv.requires['cds.xt.ModelProviderService']?.root
+        if (!main) {
+            throw new BuildError(`Invalid MTX sidecar configuration. Make sure that the profile 'mtx-sidecar' is configured and an up-to-date version of @sap/cds-mtxs is installed.`)
+        }
+        const profiles = cds.env.profiles || []
+
+            if (!profiles.includes("production") && !profiles.includes("prod")) {
+                main = DEFAULT_MAIN_FOLDER
+                // root should represent the production use case and not development
+                this.pushMessage(`MTX sidecar build results are created in folder '${main}'. Enable 'production' or 'prod' profile if the folder is configured differently.`, WARNING)
+            }
+        const destRoot = this.task.dest
+        const destMain = path.join(destRoot, main)
+        const destMainSrv = path.join(destMain, cds.env.folders.srv)
+        const csn = await this.model()
+        if (!csn) {
+            return
+        }
+        const { dictionary, sources } = await this.compileAll(csn, destMainSrv, destMain)
+        await this.collectAllLanguageBundles(dictionary, sources, destMainSrv, destMain)
+
+        // create resources TAR
+        // resources are determined based on available database build task, SQLite as fallback
+        await new ResourcesTarProvider(this).createTar(destMain, csn)
+
+        // copy package.json and .cdsrc.json from project root
+        await this._copyMainConfigFiles(cds.root, destMain)
+    }
+
+    /**
+     * Synchronous compilation using the sidecar context.
+     * @param {object} sidecarEnv cds env based on the sidecar dir
+     * @returns the compiled mtx sidecar CSN
+     */
+    _compileSidecarSync(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. Make sure up-to-date versions of the required npm modules are installed.")
+            }
+            this._logger._debug && this._logger.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. Make sure up-to-date versions of the missing npm modules are installed.`, ERROR)
+            }
+
+            // synchronous compilation
+            return cds.load(modelFilePaths, { sync: true, ...this.options() })
+        } 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 = MtxSidecarModuleBuilder

package/lib/build/provider/node-cf/index.js

@@ -0,0 +1 @@
+module.exports = require('../nodejs')