@sap/cds 6.0.3 → 6.1.1

package/bin/build/provider/buildTaskHandlerInternal.js

@@ -2,7 +2,7 @@ const fs = require('fs')
 const path = require('path')
 const BuildTaskHandler = require('../buildTaskHandler')
 const { hasOptionValue } = require('../util')
-const { FOLDER_GEN } = require('../constants')
+const { FOLDER_GEN, BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY } = require('../constants')
 
 class BuildTaskHandlerInternal extends BuildTaskHandler {
     /**
@@ -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.promises.rm(this.task.dest, {force: true, recursive: true})
+            await fs.promises.rm(this.task.dest, { force: true, recursive: true })
         }
     }
 
@@ -164,8 +164,60 @@ class BuildTaskHandlerInternal extends BuildTaskHandler {
         )
     }
 
-    options() {
-        return { messages: this._messages }
+    async compileToJson(model, csnFile) {
+        // 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)
+        if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
+            await this.write(csnStr).to(csnFile)
+        }
+        return csnStr
+    }
+
+    /**
+     * Collect and write language bundles into a single i18n.json file.
+     * @param {Object} model
+     * @param {string} bundleDest
+     */
+    async collectLanguageBundles(model, bundleDest) {
+        // collect effective i18n properties...
+        let bundles = {}
+        const bundleGenerator = this.cds.localize.bundles4(model)
+        if (bundleGenerator && bundleGenerator[Symbol.iterator]) {
+            for (let [locale, bundle] of bundleGenerator) {
+                // fallback bundle has the name ""
+                if (typeof locale === 'string') {
+                    bundles[locale] = bundle
+                }
+            }
+        }
+
+        // omit bundles in case the fallback bundle is the only existing entry
+        const keys = Object.keys(bundles)
+        if (keys.length === 1 && keys[0] === "" && Object.keys(bundles[keys[0]]).length === 0) {
+            bundles = {}
+        }
+        // copied from ../compile/i18n.js
+        const { folders = ['i18n'], file: base = 'i18n' } = this.env.i18n
+        const file = path.join(bundleDest, folders[0], base + '.json')
+
+        // bundleDest might be null
+        if (bundleDest && Object.keys(bundles).length > 0) {
+            if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
+                await this.write(bundles).to(file)
+            }
+            return { file, bundles }
+        }
+        return null
     }
 
     _isSubDirectory(parent, child) {

package/bin/build/provider/buildTaskProviderInternal.js

@@ -4,7 +4,7 @@ const { hasJavaNature, getProperty, isStreamlinedMtx } = require('../util')
 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 } = require("../constants")
+    BUILD_TASK_PREFIX, BUILD_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION } = require("../constants")
 
 class BuildTaskProviderInternal extends BuildTaskProvider {
     constructor(cds, logger) {
@@ -57,6 +57,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                 case BUILD_TASK_FIORI:
                     task.src = BuildTaskProviderInternal._normalizePath(this.env.folders.app)
                     break
+                case BUILD_TASK_MTX_EXTENSION:
                 case BUILD_TASK_MTX:
                     task.src = "."
                     break
@@ -112,12 +113,9 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                 }
             }
         } else {
-            if (!db) {
-                this.logger.log(`project doesn't have a database module [${this.env.folders.db}]`)
-            }
-            if (!srv) {
-                this.logger.log(`project doesn't have a service module '${this.env.folders.srv}'`)
-            }
+            !db && this.logger._debug && this.logger.debug(`project doesn't have a database module '${this.env.folders.db}'`)
+            !srv && this.logger._debug && this.logger.debug(`project doesn't have a service module '${this.env.folders.srv}'`)
+
             // create hana build task
             const dbTask = this._createDbTask(projectPath, db, dbOptions, buildOptions)
             if (dbTask) {
@@ -138,7 +136,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
 
     _createDbTask(projectPath, src, taskOptions, buildOptions) {
         this.logger.debug("determining database kind.")
-        if (!src) {
+        if (!src || BuildTaskProviderInternal._isExtension(this.env)) {
             return null
         }
         let task = null
@@ -190,7 +188,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
             if (this.env.requires["cds.xt.ModelProviderService"]) {
                 // sidecar scenario for Nodejs or Java
                 const sidecarEnv = this.env.for("cds", path.join(projectPath, MTX_SIDECAR_FOLDER))
-                if (this._isSidecar(sidecarEnv)) {
+                if (BuildTaskProviderInternal._isSidecar(sidecarEnv)) {
                     task = {
                         for: BUILD_TASK_MTX_SIDECAR
                     }
@@ -205,6 +203,12 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
                 }
                 this.logger.debug("Nodejs MTX scenario without sidecar")
             }
+        } else if (BuildTaskProviderInternal._isExtension(this.env)) {
+            // streamlined mtx extension project
+            task = {
+                for: BUILD_TASK_MTX_EXTENSION
+            }
+            this.logger.debug("Streamlined MTX extension")
         } else if (this.env.get("requires.multitenancy") && isNode) {
             // classic mtx
             task = {
@@ -219,11 +223,11 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
 
     _createSrvTask(projectPath, src, taskOptions) {
         this.logger.debug("determining implementation technology")
-        if (!src) {
+        if (!src || BuildTaskProviderInternal._isExtension(this.env)) {
             return null
         }
         let task = null
-        if (this._hasJavaNature(projectPath, src)) {
+        if (BuildTaskProviderInternal._hasJavaNature(projectPath, src)) {
             task = this._createJavaTask(projectPath, src, taskOptions)
         } else {
             task = this._createNodeTask(src, taskOptions)
@@ -255,8 +259,12 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
         }
     }
 
-    _isSidecar(env) {
-        return env.requires['cds.xt.ModelProviderService']?.root
+    static _isSidecar(env) {
+        return env.requires['cds.xt.ModelProviderService']?.kind === "in-sidecar"
+    }
+
+    static _isExtension(env) {
+        return !!env.extends
     }
 
     /**
@@ -264,7 +272,7 @@ class BuildTaskProviderInternal extends BuildTaskProvider {
      * @param {string} projectPath - the absolute project path
      * @param {string} src - the folder name of the service module
      */
-    _hasJavaNature(projectPath, src) {
+    static _hasJavaNature(projectPath, src) {
         return hasJavaNature([path.join(projectPath, src), projectPath])
     }
 

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

@@ -22,6 +22,8 @@ const FILE_NAME_PACKAGE_JSON = "package.json"
 const PATH_LAST_DEV_CSN = "last-dev/csn.json"
 const FILE_NAME_UNDEPLOY_JSON = "undeploy.json"
 
+const DEPLOY_FORMAT = "deploy-format"
+
 // add well-known types supported by HANA Cloud Edition - see also https://github.wdf.sap.corp/cap/issues/issues/8056
 const REQUIRED_PLUGIN_TYPES = [FILE_EXT_CSV, FILE_EXT_HDBTABLEDATA, FILE_EXT_HDBTABLE, ".hdbview", ".hdbindex", ".hdbconstraint"]
 class HanaModuleBuilder extends BuildTaskHandlerInternal {
@@ -91,22 +93,24 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
     /**
      * Copies all files located at <src> (except HANA artefacts not contained in <db>/src/**) to the folder <dest>.
      * '*.csv' files are read based on the corresponding CDS model file location and copied as flat list into folder '<dest>/src/gen>'.
-     * 
-     * @param {string} src 
-     * @param {string} dest 
-     * @param {Object} model 
+     *
+     * @param {string} src
+     * @param {string} dest
+     * @param {Object} model
      */
     async _copyResourcesExt(src, dest, model) {
-        const deploy = require('../../../../lib/deploy')
-        const resources = Object.keys(await deploy.resources(model))
+        const resources = Object.keys(await this.cds.deploy.resources(model))
         const csvPath = path.join(src, "data")
         // determine subfolder name used by the application for backward compatibility
         const csvFolder = resources.some(res => res && res.startsWith(csvPath)) ? "data" : "csv"
 
         // 1. copy csv files into 'src/gen/data' or 'src/gen/csv' subfolder
         const promises = []
+        const dbSrc = path.join(src, 'src')
+
         resources.forEach(res => {
-            if (res && /\.csv$/.test(res)) {
+            // do not duplicate resources that are already contained in db/src/**
+            if (res && /\.csv$/.test(res) && !res.startsWith(dbSrc)) {
                 promises.push(this.copy(res).to(path.join(this.task.options.compileDest, csvFolder, path.basename(res))))
             }
         })
@@ -117,7 +121,6 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         blockList += this.hasBuildOption(CONTENT_ENV, false) ? "|\\.env($|\\..*$)" : ""
         blockList += this.hasBuildOption(CONTENT_DEFAULT_ENV_JSON, false) ? "|default-env\\.json$" : ""
         blockList = new RegExp(blockList)
-        const dbSrc = path.join(src, 'src')
 
         await this.copyNativeContent(src, dest, (entry) => {
             if (entry.startsWith(dbSrc)) {
@@ -241,7 +244,7 @@ class HanaModuleBuilder extends BuildTaskHandlerInternal {
         const pluginTypes = new Set([...REQUIRED_PLUGIN_TYPES, ...undeployTypes])
 
         // compile to old format (.hdbcds) or new format (.hdbtable / .hdbview)
-        const format = this.env.get("requires.db.deploy-format") || this.env.get("hana.deploy-format")
+        const format = this.getBuildOption(DEPLOY_FORMAT) || this.env.get("requires.db." + DEPLOY_FORMAT) || this.env.get("hana." + DEPLOY_FORMAT)
         if (!this.cds.compile.to[format]) {
             return Promise.reject(new Error(`Invalid deploy-format defined: ${format}`))
         }

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

@@ -4,12 +4,12 @@ const path = require('path')
 const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
 const { isOldJavaStack, BuildError } = require('../../util')
 
-const { BUILD_OPTION_OUTPUT_MODE, ODATA_VERSION, ODATA_VERSION_V2, OUTPUT_MODE_RESULT_ONLY, FILE_EXT_CDS, SKIP_ASSERT_COMPILER_V2, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN } = require('../../constants')
+const { BUILD_OPTION_OUTPUT_MODE, ODATA_VERSION, ODATA_VERSION_V2, OUTPUT_MODE_RESULT_ONLY, FILE_EXT_CDS, SKIP_ASSERT_COMPILER_V2, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN, DEFAULT_CSN_FILE_NAME } = require('../../constants')
 const { INFO } = require('../../buildTaskHandler')
 
 const DEFAULT_COMPILE_DEST_FOLDER = path.normalize('src/main/resources/edmx')
 
-class JavaCfModuleBuilder extends BuildTaskHandlerEdmx {
+class JavaModuleBuilder extends BuildTaskHandlerEdmx {
     init() {
         super.init()
         this.task.options.compileDest = path.resolve(this.task.dest, this.task.options.compileDest || DEFAULT_COMPILE_DEST_FOLDER)
@@ -48,7 +48,10 @@ class JavaCfModuleBuilder extends BuildTaskHandlerEdmx {
 
         if (this.hasBuildOption(CONTENT_LANGUAGE_BUNDLES, true)) {
             // collect and write language bundles into single i18n.json file
-            await this.collectLanguageBundles(model, this.task.dest)
+            const i18n = await this.collectLanguageBundles(model, this.task.dest)
+            if (i18n) {
+                this._result.languageBundles = i18n.bundles
+            }
         }
         if (!this.hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
             await this._copyNativeContent(src, dest)
@@ -62,7 +65,7 @@ class JavaCfModuleBuilder extends BuildTaskHandlerEdmx {
             return
         }
         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})
+        await fs.promises.rm(this.task.options.compileDest, { force: true, recursive: true })
     }
 
     async _copyNativeContent(src, dest) {
@@ -82,13 +85,20 @@ class JavaCfModuleBuilder extends BuildTaskHandlerEdmx {
             ...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
-            await this.compileToJson(model, csnDest)
+            const csnStr = await this.compileToJson(model, csnFile)
+            csnModel = JSON.parse(csnStr)
+            csnModel.meta = model.meta
         } else {
-            await this.compileToJson(m, csnDest)
+            const csnStr = await this.compileToJson(m, csnFile)
+            csnModel = JSON.parse(csnStr)
+            csnModel.meta = m.meta
         }
+        this._result.csn = csnModel
+
         return m
     }
 
@@ -98,4 +108,4 @@ class JavaCfModuleBuilder extends BuildTaskHandlerEdmx {
         return match && match[1] === 1
     }
 }
-module.exports = JavaCfModuleBuilder
+module.exports = JavaModuleBuilder

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

@@ -47,7 +47,7 @@ class StreamlinedMtxBuilder {
         if (!model) {
             return
         }
-        return new ResourcesTarProvider(this._handler).writeTar(dest, model)
+        return new ResourcesTarProvider(this._handler).createTar(dest, model)
     }
     async clean() {
         // staging build content is deleted by BuildTaskEngine
@@ -96,8 +96,11 @@ class ClassicMtxBuilder {
         }))
 
         // collect and write language bundles into single i18n.json file
-        await this._handler.collectLanguageBundles(model, destSdc)
-
+        const i18n = await this._handler.collectLanguageBundles(model, destSdc)
+        if (i18n) {
+            this._handler._result.languageBundles = i18n.bundles
+        }
+        
         // copy native hana content and templates
         await this._copyNativeContent(this._handler.task.src, destSdc, tenantDbPath)
     }
@@ -172,7 +175,7 @@ class ClassicMtxBuilder {
         function isValid(e, pattern, nsPattern, kind) {
             return e && e.name && (e.name === pattern || (nsPattern && e.name.startsWith(nsPattern))) && (!kind || e.kind === kind)
         }
-        
+
         if (extensionAllowlist || entityWhitelist || serviceWhitelist) {
             const invalidEntries = new Set()
             const reflected = this._handler.cds.reflect(model)

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

@@ -1,52 +1,77 @@
-const fs = require('fs')
 const path = require('path')
 const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
 
 const { BUILD_TASK_HANA } = require('../../constants')
-const { WARNING, INFO } = require('../../buildTaskHandler')
-const TAR_NAME = 'resources.tgz'
+const { WARNING } = BuildTaskHandlerInternal
+const DEFAULT_TAR_NAME = "resources.tgz"
 
 class ResourcesTarBuilder {
     constructor(handler) {
         this._handler = handler
     }
 
-    async packTar(model) {
-        let resourceRoot = await this._getHanaTenantDbDest()
-        let files
-        if (resourceRoot) {
-            const hanaSrcFolder = path.join(resourceRoot, 'src')
-            const undeployJson = path.join(resourceRoot, 'undeploy.json')
+    get handler() { return this._handler }
 
-            // hana build task has already been executed
-            files = BuildTaskHandlerInternal._find(resourceRoot, (res) => {
-                if (res === undeployJson) {
-                    return true
-                }
-                if (res.startsWith(hanaSrcFolder)) {
-                    return true
-                }
-                return false
-            })
-        } else {
-            resourceRoot = path.join(this._handler.buildOptions.root, this._handler.env.folders.db)
-            const deploy = require('../../../../lib/deploy')
-            files = Object.keys(await deploy.resources(model))
-        }
-        if (files.length > 0) {
-            const { packTarArchive } = require('../../../../lib/utils/resources')
-            return packTarArchive(files, resourceRoot, false)
-        } else {
-            this._handler.pushMessage("No deployment resources found - skip resource.tgz", WARNING)
+    async createTar(dest, model) {
+        const { root, files } = await this._getResources(model)
+        if (files.length === 0) {
+            // packTarArchive failes otherwise
+            this.handler.pushMessage("No deployment resources found - skip resources.tgz", WARNING)
+            return
         }
+        await this.writeTarFile(files, root, path.join(dest, DEFAULT_TAR_NAME))
     }
 
-    async writeTar(dest, model) {
-        const buffer = await this.packTar(model)
+    async writeTarFile(files, root, tarFile) {
+        const { packTarArchive } = require('../../../../lib/utils/resources')
+        const buffer = await packTarArchive(files, root)
         if (buffer) {
-            await this._handler.write(buffer).to(path.join(dest, TAR_NAME))
+            await this.handler.write(buffer).to(tarFile)
+        }
+    }
+
+    async _getResources(model) {
+        // distinguish HANA and SQLITE deployment
+        let root = await this._getHanaTenantDbDest()
+        let files
+        if (root) {
+            files = this._getHanaResources(root)
+        } else {
+            root = path.join(this.handler.buildOptions.root, this.handler.env.folders.db)
+            files = await this._getSqliteResources(model)
         }
-        await fs.promises.mkdir(dest, { recursive: true })
+        return { root, files }
+    }
+
+    /**
+     * Reads all resources for HANA deployment - 'db/src/**' and 'db/undeploy.json'.
+     * - CSV files, native HANA artefacts, generated HANA artefacts, 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) {
+        const hanaNativeFolders = [path.join(root, 'src'), path.join(root, 'cfg')]
+        const hanaNativeFiles = [path.join(root, 'undeploy.json'), path.join(root, '.hdiignore')]
+
+        return BuildTaskHandlerInternal._find(root, (res) => {
+            if (hanaNativeFolders.some(folder => res.startsWith(folder)) || hanaNativeFiles.some(file => res === file)) {
+                return true
+            }
+            return false
+        })
+    }
+
+    /**
+     * Reads all resources for Sqlite deployment - see '../../../../lib.deploy'
+     * 
+     * @param {object} model 
+     * @returns 
+     */
+    async _getSqliteResources(model) {
+        const { resources } = this.handler.cds.deploy
+        return Object.keys(await resources(model))
     }
 
     /**
@@ -56,10 +81,10 @@ class ResourcesTarBuilder {
      * @returns {string} the src folder of the tenant db module
      */
     async _getHanaTenantDbDest() {
-        const buildOptions = this._handler.buildOptions
+        const buildOptions = this.handler.buildOptions
         let hanaTask = buildOptions.tasks ? buildOptions.tasks.find(task => task.for === BUILD_TASK_HANA) : undefined
         if (!hanaTask) {
-            this._handler.pushMessage(`Found SQLite database configuration. Ensure that productive cloud deployments requiring SAP HANA database are built with 'production' profile.`, INFO)
+            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

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

@@ -0,0 +1,57 @@
+const path = require('path')
+const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
+const { FOLDER_GEN } = require('../../constants')
+const ResourcesTarBuilder = require('../mtx/resourcesTarBuilder')
+
+class MtxExtensionModuleBuilder extends BuildTaskHandlerInternal {
+    init() {
+        super.init()
+        if (this.buildOptions.root === this.buildOptions.target) {
+            this.task.dest = path.join(this.task.dest, FOLDER_GEN)
+        }
+    }
+
+    async build() {
+        const model = await this.model()
+        if (!model) {
+            return
+        }
+        const allFiles = []
+        const destExt = path.join(this.task.dest, 'ext')
+
+        const packageJson = path.join(destExt, 'package.json')
+        await this.copy(path.join(this.task.src, 'package.json')).to(packageJson)
+        allFiles.push(packageJson)
+
+        // extension CSN using parsed format
+        const options = { ...this.options(), flavor: 'parsed' }
+        const extCsn = await this.cds.load(this.resolveModel(), options)
+        if (extCsn.requires) {
+            extCsn.requires.length = 0
+        }
+        const csnFile = path.join(destExt, 'extension.csn')
+        await this.compileToJson(extCsn, csnFile)
+        allFiles.push(csnFile)
+
+        const i18n = await this.collectLanguageBundles(extCsn, destExt)
+        if (i18n) {
+            allFiles.push(i18n.file)
+        }
+
+        const files = Object.keys(await this.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 => {
+                        const csvFile = path.join(dataDest, path.basename(csv))
+                        allFiles.push(csvFile)
+                        return this.copy(csv).to(csvFile)
+                    })
+            )
+        }
+        await new ResourcesTarBuilder(this).writeTarFile(allFiles, destExt, path.join(this.task.dest, 'extension.tgz'))
+    }
+}
+module.exports = MtxExtensionModuleBuilder

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

@@ -1,18 +1,17 @@
-/* eslint-disable no-empty */
 const path = require('path')
-const { FOLDER_GEN } = require('../../constants')
-const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
+const fs = require('fs')
+const { FOLDER_GEN, DEFAULT_CSN_FILE_NAME } = require('../../constants')
 const NodeCfModuleBuilder = require('../nodejs')
 const ResourcesTarProvider = require('../mtx/resourcesTarBuilder')
-const { INFO } = require('../buildTaskHandlerInternal')
-const { relativePaths } = require('@sap/cds/bin/build/util')
+const { INFO, ERROR } = NodeCfModuleBuilder
+const { relativePaths, BuildError } = require('../../util')
 
 const DEFAULT_MAIN_FOLDER = "_main"
 
 class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
     get priority() {
         // should be scheduled after 'hana' build tasks are finished
-        return BuildTaskHandlerInternal.PRIORITY_MIN_VALUE
+        return NodeCfModuleBuilder.PRIORITY_MIN_VALUE
     }
     init() {
         super.init()
@@ -25,7 +24,7 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
      * 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'
      */
@@ -46,7 +45,7 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
         const destSidecar = this.task.dest
         const destSidecarSrc = path.join(destSidecar, this.env.folders.srv)
         const model = this._compileSidecarSync(sidecarEnv)
-        await this.compileToJson(model, destSidecarSrc)
+        await this.compileToJson(model, path.join(destSidecarSrc, DEFAULT_CSN_FILE_NAME))
         await this.collectLanguageBundles(model, destSidecarSrc)
         await this._copyProjectRootContent(this.task.src, destSidecar)
     }
@@ -56,11 +55,12 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
      * @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 Error("Invalid sidecar configuration - {\"model-provider\": \"in-sidecar\"} configuration missing")
+        if (sidecarEnv.requires['cds.xt.ModelProviderService']?.kind !== 'in-sidecar') {
+            throw new Error("Invalid MTX sidecar configuration - \"cds.xt.ModelProviderService\": \"in-sidecar\" missing")
         }
+        let main = sidecarEnv.requires['cds.xt.ModelProviderService']?.root
         const profiles = this.env.get("profiles") || []
+
         if (!profiles.includes("production") && !profiles.includes("prod")) {
             main = DEFAULT_MAIN_FOLDER
             // root should represent the production use case and not development
@@ -78,7 +78,10 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
 
         // create resources TAR
         // resources are determined based on available database build task, SQLite as fallback
-        await new ResourcesTarProvider(this).writeTar(destMain, csn)
+        await new ResourcesTarProvider(this).createTar(destMain, csn)
+
+        // copy package.json and .cdsrc.json from project root
+        await this._copyMainConfigFiles(this.cds.root, destMain)
     }
 
     /**
@@ -91,20 +94,45 @@ class MtxSidecarModuleBuilder extends NodeCfModuleBuilder {
         try {
             this.cds.root = this.task.src
             this.cds.env = sidecarEnv
-            let modelPaths = this.cds.resolve('*', false)
-            modelPaths = this.cds.resolve(modelPaths)
-            if (!modelPaths || modelPaths.length === 0) {
-                throw new Error("No model found for MTX sidecar app")
+            const modelPaths = this.cds.resolve('*', false)
+            const modelFilePaths = this.cds.resolve(modelPaths)
+
+            if (!modelFilePaths || modelFilePaths.length === 0) {
+                throw new BuildError("No model found for MTX sidecar app")
             }
-            this._logger._debug && this._logger.debug(`sidecar model: ${relativePaths(this.buildOptions.root, modelPaths).join(", ")}`)
+            // candidate for strict mode support
+            // entries for @sap/** model paths are missing if the module hasn't been installed, e.g. @sap/cds-mtxs
+            const missingModels = modelPaths.filter(p => {
+                if (p.startsWith('@sap/')) {
+                    const files = this.cds.resolve(p)
+                    return !files || files.length === 0
+                }
+            })
+            if (missingModels.length > 0) {
+                this.pushMessage(`Some model paths could not be resolved. Make sure the npm modules have been installed: ${missingModels.join(', ')}`, ERROR)
+            }
+            this._logger._debug && this._logger.debug(`sidecar model: ${relativePaths(this.buildOptions.root, modelFilePaths).join(", ")}`)
 
             // synchronous compilation
-            return this.cds.load(modelPaths, { sync: true, ...this.options() })
+            return this.cds.load(modelFilePaths, { sync: true, ...this.options() })
         } finally {
             // restore project scope
             this.cds.root = this.buildOptions.root
             this.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