@sap/cds-dk 9.7.2 → 9.8.0

package/lib/build/{provider → plugins}/java/index.js

@@ -1,15 +1,22 @@
 const fs = require('fs')
-const path = require('path')
 const cds = require('../../../cds')
-const EdmxBuildPlugin = require('../edmxBuildPlugin')
-const { OUTPUT_MODE, OUTPUT_MODE_RESULT, FILE_EXT_CDS, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN, DEFAULT_CSN_FILE_NAME,
-    OUTPUT_MODE_FILESYSTEM, FLAVOR_LOCALIZED_EDMX, CONTENT_EDMX, CONTENT_LOCALIZED_EDMX } = require('../../constants')
-const { getI18nDefaultFolder } = require('../../util')
+const { exists, isdir, path } = cds.utils
+const { FILE_EXT_CDS, CONTENT_LANGUAGE_BUNDLES, CONTENT_DEFAULT_CSN, DEFAULT_CSN_FILE_NAME, FLAVOR_LOCALIZED_EDMX, CONTENT_EDMX, CONTENT_LOCALIZED_EDMX } = require('../../constants')
+const { getI18nDefaultFolder, normalizePath } = require('../../util')
 const DEFAULT_COMPILE_DEST_FOLDER = path.normalize('src/main/resources/edmx')
 const DEBUG = cds.debug('cli|build')
 const LOG = cds.log('cli|build')
 
-class JavaBuildPlugin extends EdmxBuildPlugin {
+module.exports = class JavaBuildPlugin extends require('../edmx') {
+
+    static get taskDefaults() { return { src: normalizePath(cds.env.folders.srv) } }
+
+    static hasTask() {
+        const src = path.join(cds.root, this.taskDefaults?.src ?? 'srv')
+        const hasSrc = exists(src) || this.taskDefaults?.src === '.'
+        return cds.env['project-nature'] === 'java' && hasSrc && !cds.env.extends
+    }
+
     init() {
         super.init()
         this.task.options.compileDest = path.resolve(this.task.dest, this.task.options.compileDest || DEFAULT_COMPILE_DEST_FOLDER)
@@ -45,15 +52,11 @@ class JavaBuildPlugin extends EdmxBuildPlugin {
 
         if (!this.hasBuildOption(CONTENT_LANGUAGE_BUNDLES, false)) {
             // collect and write language bundles containing all features
-            const i18n = await this.collectLanguageBundles(model, path.join(compileDest, getI18nDefaultFolder()))
-            if (i18n && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
-                this._result.languageBundles = i18n.bundles
-            }
+            await this.collectLanguageBundles(model, path.join(compileDest, getI18nDefaultFolder()))
         }
-        if (this.isStagingBuild() && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM)) {
+        if (this.isStagingBuild()) {
             await this._copyNativeContent(src, dest)
         }
-        return this._result
     }
 
     async clean() {
@@ -66,7 +69,7 @@ class JavaBuildPlugin extends EdmxBuildPlugin {
 
     async _copyNativeContent(src, dest) {
         return super.copyNativeContent(src, dest, (entry) => {
-            if (cds.utils.isdir(entry)) {
+            if (isdir(entry)) {
                 return true // using common filter for folders
             } else {
                 const extname = path.extname(entry)
@@ -84,21 +87,10 @@ class JavaBuildPlugin extends EdmxBuildPlugin {
         const csnFile = path.join(csnDest, DEFAULT_CSN_FILE_NAME)
         // 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)
-            if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
-                const csnModel = JSON.parse(csnStr)
-                csnModel.meta = model.meta
-                this._result.csn = csnModel
-            }
+            await this.compileToJson(model, csnFile)
         } else {
-            const csnStr = await this.compileToJson(m, csnFile)
-            if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
-                const csnModel = JSON.parse(csnStr)
-                csnModel.meta = m.meta
-                this._result.csn = csnModel
-            }
+            await this.compileToJson(m, csnFile)
         }
         return m
     }
 }
-module.exports = JavaBuildPlugin

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

@@ -0,0 +1,41 @@
+const cds = require('../../../cds')
+const { path, exists, rimraf } = cds.utils
+const ResourcesTarBuilder = require('./resourcesTarBuilder')
+const { FOLDER_GEN } = require('../../constants')
+const { normalizePath } = require('../../util')
+
+module.exports = class MtxBuildPlugin extends require('../edmx') {
+
+    static get taskDefaults() { return { src: normalizePath(cds.env.folders.srv) } }
+
+    static hasTask() {
+        const isMtxs = cds.env.requires.multitenancy || cds.env.requires.toggles || cds.env.requires['cds.xt.ModelProviderService']
+        const hasSidecar = exists(path.join(cds.root, 'mtx/sidecar'))
+        return isMtxs && !hasSidecar && cds.env['project-nature'] === 'nodejs' && !cds.env.extends
+    }
+
+    get requires() {
+        return ['hana']
+    }
+
+    init() {
+        super.init()
+    }
+
+    async build() {
+        // 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 ResourcesTarBuilder(this).createTar(dest, model)
+    }
+
+    async clean() {
+        // staging build content is deleted by default
+        if (cds.env.build.target === '.') {
+            return rimraf(this.task.dest, FOLDER_GEN)
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+const cds = require('../../../cds')
+const { path, exists, tar } = cds.utils
+const { BUILD_TASK_HANA } = require('../../constants')
+const { WARNING } = require('../internal')
+
+module.exports = class ResourcesTarBuilder {
+    constructor(plugin) {
+        this._plugin = plugin
+    }
+
+    get plugin() { return this._plugin }
+
+    async createTar(dest, model) {
+        let root = getHanaTenantDbTask(this.plugin)?.dest
+        let resources
+        if (root) {
+            const items = ['src', 'cfg', 'undeploy.json', '.hdiignore']
+            resources = items.map(item => path.join(root, item)).filter(exists)
+        } else {
+            root = cds.root
+            resources = Object.keys(await cds.deploy.resources(model))
+        }
+        if (resources.length === 0) {
+            this.plugin.pushMessage("No deployment resources found - skip resources.tgz", WARNING)
+            return
+        }
+        const tarFile = path.join(dest, "resources.tgz")
+        await tar.czfd(tarFile, root, resources)
+        this.plugin.pushFile(tarFile)
+    }
+}
+
+function getHanaTenantDbTask({ task, context: { tasks } }) {
+    const hanaTasks = tasks.filter(task => task.for === BUILD_TASK_HANA)
+    if (hanaTasks.length === 1) return hanaTasks[0]
+    return hanaTasks.find(({ src }) => {
+        if (!src) return true // an existing second shared db always requires src to be set
+        const srcFolder = path.isAbsolute(src) ? path.relative(cds.root, src) : src
+        return task.options?.model?.includes(srcFolder) || srcFolder === cds.env.folders.db.replace('/', '')
+    })
+}

package/lib/build/{provider → plugins}/mtx-extension/extensionCompilation.js

@@ -31,7 +31,7 @@ class ExtensionCompilation {
                     const pkg = require(path.join(dirname, 'package.json'))
                     return pkg.name
                 }
-            } catch (e) {
+            } catch {
                 return getPkgName(path.dirname(dirname))
             }
         }

package/lib/build/{provider → plugins}/mtx-extension/index.js

@@ -1,8 +1,5 @@
-const path = require('path')
-const fs = require('fs')
 const cds = require('../../../cds')
-const InternalBuildPlugin = require('../internalBuildPlugin')
-const ResourcesTarBuilder = require('../mtx/resourcesTarBuilder')
+const { exists, path, isdir, rimraf, tar } = cds.utils
 const ExtensionCompilation = require('./extensionCompilation')
 const { FOLDER_GEN, EXTENSION_POINT_VALIDATION } = require('../../constants')
 const { BuildError, BuildMessage } = require('../../util')
@@ -10,7 +7,12 @@ const DEBUG = cds.debug('cli|build')
 
 const BUILT_IN_NAMESPACES = ['cds.core', 'cds.outbox', 'cds.xt']
 
-class MtxExtensionBuildPlugin extends InternalBuildPlugin {
+module.exports = class MtxExtensionBuildPlugin extends require('../internal') {
+
+    static get taskDefaults() { return { src: '.' } }
+
+    static hasTask() { return cds.env.extends }
+
     init() {
         super.init()
         if (cds.env.build.target === '.') {
@@ -27,7 +29,11 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
         // REVISIT: check existence of SaaS app package folder only
         // 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 saasPkgPath = MtxExtensionBuildPlugin._getSaasPkgPath()
+
+        if (!cds.env.extends) throw new BuildError(`Missing configuration 'cds.extends' in package.json`)
+        // cds.env.extends holds the SaaS app package name, also if the extends field is defined on root level
+        // older projects might not have a workspace definition
+        const saasPkgPath = _getWorkspacePath(cds.env.extends) ?? _getNodeModulesPath()
         const extensionCompilation = new ExtensionCompilation(this)
 
         // full model compilation including base model ensures consistency
@@ -92,8 +98,7 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
                     // throws error in case of linting errors
                     this._lintExtModel(extensionModel, model, saasPkgPath)
                 } catch (error) {
-                    // cleanup existing files in case of an error
-                    await fs.promises.rm(dest, { recursive: true })
+                    await rimraf(dest)
                     throw error
                 }
             }
@@ -105,7 +110,7 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
         // copy handlers from srv folder
         const folder = path.join(cds.root, cds.env.folders.srv).replace(/[/\\]$/, '')
         await this.copyNativeContent(cds.root, destExt, res => {
-            if (cds.utils.isdir(res)) {
+            if (isdir(res)) {
                 return res.startsWith(folder)
             }
             if (path.dirname(res).startsWith(folder) && /\.js$/.test(res)) {
@@ -114,7 +119,9 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
         })
 
         // add all resources contained in 'gen/ext' folder
-        return new ResourcesTarBuilder(this).writeTarFile(path.join(dest, 'extension.tgz'), destExt)
+        const tarFile = path.join(dest, 'extension.tgz')
+        await tar.czfd(tarFile, destExt)
+        this.pushFile(tarFile)
     }
 
     _lintExtModel(extModel, model, saasPkgPath) {
@@ -135,48 +142,32 @@ class MtxExtensionBuildPlugin extends InternalBuildPlugin {
 
     _linter() {
         try {
-            // Make sure cds-mtxs APIs are loaded, from local mtxs preferrably
-            const mtxs = require(require.resolve('@sap/cds-mtxs', { paths: [cds.root, __dirname] }))
-            return mtxs.xt.linter
+            // Make sure cds-mtxs APIs are loaded, from local mtxs preferably
+            return require(require.resolve('@sap/cds-mtxs', { paths: [cds.root, __dirname] })).xt.linter
         } 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.')
         }
     }
+}
 
-    static _getSaasPkgPath() {
-        if (!cds.env.extends) {
-            throw new BuildError(`Missing configuration 'cds.extends' in package.json`)
-        }
-        // cds.env.extends holds the SaaS app package name, also if the extends field is defined on root level
-        let saasPkgPath = this._getWorkspacePath(cds.env.extends)
-        if (!saasPkgPath) {
-            // older projects might not have a workspace definition
-            saasPkgPath = this._getNodeModulesPath(saasPkgPath)
-        }
-        return saasPkgPath
-    }
-
-    static _getWorkspacePath(pkg) {
-        const pkgJson = require(path.join(cds.root, 'package.json'))
-        if (pkgJson.workspaces) {
-            try {
-                // loading package.json of SaaS app - might not exist for older projects
-                return path.dirname(require.resolve(path.join(pkg, 'package.json'), { paths: [cds.root] }))
-            } catch (e) {
-                if (e.code !== 'MODULE_NOT_FOUND') throw e
-                throw new BuildError(`The SaaS application base model is missing. Did you execute 'cds pull' and 'npm install'?`)
-            }
-        }
-    }
-
-    static _getNodeModulesPath() {
-        const saasPkgPath = path.join(cds.root, 'node_modules', cds.env.extends)
-        if (!fs.existsSync(saasPkgPath)) {
+function _getWorkspacePath(pkg) {
+    const pkgJson = require(path.join(cds.root, 'package.json'))
+    if (pkgJson.workspaces) {
+        try {
+            // loading package.json of SaaS app - might not exist for older projects
+            return path.dirname(require.resolve(path.join(pkg, 'package.json'), { paths: [cds.root] }))
+        } catch (e) {
+            if (e.code !== 'MODULE_NOT_FOUND') throw e
             throw new BuildError(`The SaaS application base model is missing. Did you execute 'cds pull' and 'npm install'?`)
         }
-        return saasPkgPath
     }
 }
 
-module.exports = MtxExtensionBuildPlugin
+function _getNodeModulesPath() {
+    const saasPkgPath = path.join(cds.root, 'node_modules', cds.env.extends)
+    if (!exists(saasPkgPath)) {
+        throw new BuildError(`The SaaS application base model is missing. Did you execute 'cds pull' and 'npm install'?`)
+    }
+    return saasPkgPath
+}

package/lib/build/{provider → plugins}/mtx-sidecar/index.js

@@ -10,11 +10,25 @@ const DEFAULT_MAIN_FOLDER = "_main"
 const [major, minor] = cds.version.split('.').map(Number)
 const COMPAT = major === 9 && minor < 7 // cds10: remove
 
-module.exports = class extends require('../nodejs') {
+module.exports = class MtxSidecarBuildPlugin extends require('../nodejs') {
 
-    get priority() {
-        return super.priority - 10 // must run after 'hana' build task
+    static get taskDefaults() { return { src: 'mtx/sidecar' } }
+
+    static hasTask() {
+        if (cds.env.extends) return
+        const mps = cds.env.requires['cds.xt.ModelProviderService']
+        const isMtxs = cds.env.requires.multitenancy || cds.env.requires.toggles || cds.env.requires['cds.xt.ModelProviderService']
+        const src = path.join(cds.root, this.taskDefaults?.src ?? 'mtx/sidecar')
+        if (mps?._in_sidecar) {
+            throw new BuildError(`Seems that you are executing 'cds build' in the 'mtx/sidecar' folder. Execute 'cds build' in the project root folder instead.`)
+        }
+        return isMtxs && exists(src)
     }
+
+    get requires() {
+        return ['hana']
+    }
+
     init() {
         super.init()
         if (cds.env.build.target === '.') {

package/lib/build/{provider → plugins}/nodejs/index.js

@@ -1,26 +1,26 @@
-const fs = require('fs')
-const path = require('path')
 const cds = require('../../../cds')
-const cmd = require('../../../util/command');
-const EdmxBuildPlugin = require('../edmxBuildPlugin')
-const { BuildError, getWorkspaces, findWorkspaceRoot } = require('../../util')
-const { OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM, ODATA_VERSION_V2, FOLDER_GEN, CONTENT_EDMX, CONTENT_PACKAGELOCK_JSON,
+const { path, exists, rimraf, isdir, read, write } = cds.utils
+const cmd = require('../../../util/command')
+const { BuildError, getWorkspaces, findWorkspaceRoot, normalizePath } = require('../../util')
+const { ODATA_VERSION_V2, FOLDER_GEN, CONTENT_EDMX, CONTENT_PACKAGELOCK_JSON,
     CONTENT_NPMRC, CONTENT_CDSRC_JSON, CONTENT_ENV, CONTENT_DEFAULT_ENV_JSON, FLAVOR_LOCALIZED_EDMX,
-    OPTION_WS_PACK} = require('../../constants');
-const { WARNING } = EdmxBuildPlugin
+    OPTION_WS_PACK, SEVERITY_WARNING } = require('../../constants');
 const LOG = cds.log('cli|build')
 const DEBUG = cds.debug('cli|build')
 const NODE_ENGINE_VERSION = '>=20'
 const { exec } = require('node:child_process')
-const pexec = require('node:util').promisify(exec);
+const pexec = require('node:util').promisify(exec)
 
-/**
- * @param {T | T[]} x
- * @returns {T[]}
- */
-const arrayify = x => Array.isArray(x) ? x : [x]
+module.exports = class NodejsBuildPlugin extends require('../edmx') {
+
+    static get taskDefaults() { return { src: normalizePath(cds.env.folders.srv) } }
+
+    static hasTask() {
+        const src = path.join(cds.root, this.taskDefaults?.src || 'srv')
+        const hasSrc = exists(src) || (this.taskDefaults?.src === '.')
+        return cds.env['project-nature'] === 'nodejs' && hasSrc && !cds.env.extends
+    }
 
-class NodejsBuildPlugin extends EdmxBuildPlugin {
     init() {
         super.init()
         // fallback if src has been defined as '.'
@@ -36,11 +36,15 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
     }
 
     async build() {
+        if (!exists('package.json')) {
+            throw new BuildError(`No 'package.json' found in project root folder '${cds.root}'`)
+        }
+
         const destSrv = this.isStagingBuild() ? this.destSrv : path.resolve(this.destSrv, cds.env.folders.srv)
         const destRoot = this.isStagingBuild() ? this.task.dest : this.destSrv
         if (cds.env.odata.version === ODATA_VERSION_V2) {
             // log warning as nodejs is only supporting odata version V4
-            this.pushMessage("OData v2 is not supported by node runtime. Make sure to define OData v2 in cds configuration.", WARNING)
+            this.pushMessage("OData v2 is not supported by node runtime. Make sure to define OData v2 in cds configuration.", SEVERITY_WARNING)
         }
         // by default model contains all features
         const model = await this.model()
@@ -61,7 +65,7 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
                 await this.compileToEdmx(baseModel, path.join(this.destSrv, 'odata', cds.env.odata.version), compileOptions)
             }
         }
-        if (this.isStagingBuild() && this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM)) {
+        if (this.isStagingBuild()) {
             const srcSrv = this.task.src === cds.root ? path.resolve(this.task.src, cds.env.folders.srv) : this.task.src
             await this._copyNativeContent(cds.root, srcSrv, destRoot, destSrv)
             try {
@@ -87,8 +91,6 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         }
 
         await this.#cleanupPackageJson(destRoot)
-
-        return this._result
     }
 
     /**
@@ -101,7 +103,7 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
 
         const packageJsonPath = path.join(this.task.dest, 'package.json')
         try {
-            const packageJson = await cds.utils.read(packageJsonPath)
+            const packageJson = await read(packageJsonPath)
 
             DEBUG?.(`Sanitizing the package.json for "${this.task.src}'...`)
 
@@ -124,9 +126,9 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
             }
             // overwrite the package.json if it was modified only
             if (modified) {
-                await cds.utils.write(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8')
+                await write(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8')
                 // update the package-lock.json if it exists
-                if (cds.utils.exists(path.join(this.task.dest, 'package-lock.json'))) {
+                if (exists(path.join(this.task.dest, 'package-lock.json'))) {
                     DEBUG?.(`Updating the package-lock.json for '${this.task.src}'...`)
                     // run the npm install --package-lock-only to only update the package-lock.json
                     // without installing the dependencies to node_modules
@@ -145,12 +147,12 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
     }
 
     async clean() {
-        // staging build content is deleted by BuildTaskEngine
+        // staging build content is deleted by default
         if (cds.env.build.target === '.') {
             // delete the entire 'task.dest' folder otherwise, for details see #constructor
             // - the value of the folder 'src' has been appended to the origin 'task.dest' dir
             DEBUG?.(`Deleting build target folder ${this.destSrv}`)
-            await fs.promises.rm(this.isStagingBuild() ? this.task.dest : this.destSrv, { force: true, recursive: true })
+            await rimraf(this.isStagingBuild() ? this.task.dest : this.destSrv)
         }
     }
 
@@ -180,7 +182,7 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         // 1. copy all files to 'destSrv' except those contained in the blocklist (including node_modules)
         // project/srv -> 'gen/srv/srv'
         await super.copyNativeContent(src, destSrv, (entry) => {
-            if (cds.utils.isdir(entry)) {
+            if (isdir(entry)) {
                 // TODO shall not copy language bundles - return !/(\/|\\)(node_modules|_i18n)(\/|\\)?$/.test(entry)
                 return !/(\/|\\)node_modules(\/|\\)?$/.test(entry)
             }
@@ -230,7 +232,7 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         srvAllowList = new RegExp(srvAllowList)
 
         await super.copyNativeContent(src, dest, (entry) => {
-            if (cds.utils.isdir(entry)) {
+            if (isdir(entry)) {
                 return folders.some(folder => entry.startsWith(folder))
             }
             if (/\.js$|\.properties$/.test(entry)) {
@@ -246,6 +248,7 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         const allWorkspaces = await getWorkspaces(wsRoot, true, false)
         let workspaces
         if (this.task.options.workspaces) {
+            const arrayify = x => Array.isArray(x) ? x : [x]
             const relevantWorkspaces = new Set(arrayify(this.task.options.workspaces))
             workspaces = allWorkspaces
                 .filter(ws => relevantWorkspaces.has(ws.workspace))
@@ -302,5 +305,3 @@ class NodejsBuildPlugin extends EdmxBuildPlugin {
         return JSON.parse(result)
     }
 }
-
-module.exports = NodejsBuildPlugin