@sap/cds 5.9.6 → 6.0.1

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

@@ -1,30 +1,76 @@
 /* eslint-disable no-empty */
-const { fs } = require('@sap/cds-foss')
+const fs = require('fs')
 const path = require('path')
-const { BUILD_TASK_HANA, FOLDER_GEN } = require('../../constants')
-const { WARNING } = require('../../buildTaskHandler')
 const BuildTaskProviderInternal = require("../buildTaskProviderInternal")
 const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const { isStreamlinedMtx } = require('../../util')
+const ResourcesTarProvider = require('./resourcesTarBuilder')
 
+const { BUILD_TASK_HANA, FOLDER_GEN } = require('../../constants')
+const { WARNING } = require('../../buildTaskHandler')
 const FOLDER_SDC = "sdc"
 const FOLDER_NODE_MODULES = "node_modules"
 const FOLDER_TEMPLATES = "tpl"
 
 class MtxModuleBuilder extends BuildTaskHandlerEdmx {
     get priority() {
-        // should be scheduled after all other build tasks are finished
+        // should be scheduled after 'hana' build tasks are finished
         return BuildTaskHandlerEdmx.PRIORITY_MIN_VALUE
     }
     init() {
         super.init()
-        if (this.buildOptions.root === this.buildOptions.target) {
-            this.task.dest = path.join(this.task.dest, FOLDER_GEN, FOLDER_SDC)
+        if (isStreamlinedMtx(this.cds)) {
+            this._delegate = new StreamlinedMtxBuilder(this)
         } else {
-            this.task.dest = path.join(this.task.dest, FOLDER_SDC)
+            this._delegate = new ClassicMtxBuilder(this)
+        }
+    }
+
+    async build() {
+        return this._delegate.build()
+    }
+
+    async clean() {
+        return this._delegate.clean()
+    }
+}
+
+class StreamlinedMtxBuilder {
+    constructor(handler) {
+        this._handler = handler
+    }
+    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 = this._handler.env.get("build.target") !== "." ? this._handler.task.dest : path.join(this._handler.task.dest, FOLDER_GEN)
+        const model = await this._handler.model()
+        if (!model) {
+            return
+        }
+        return new ResourcesTarProvider(this._handler).writeTar(dest, model)
+    }
+    async clean() {
+        // staging build content is deleted by BuildTaskEngine
+        if (this._handler.buildOptions.root === this._handler.buildOptions.target) {
+            // remove 'gen' folder
+            return fs.promises.rm(path.join(this._handler.task.dest, FOLDER_GEN), { force: true, recursive: true })
         }
     }
+}
+
+class ClassicMtxBuilder {
+    constructor(handler) {
+        this._handler = handler
+    }
+
     async build() {
-        const model = await this.model()
+        if (this._handler.env.get("requires.toggles") === true) {
+            throw new Error("Feature toggles are only supported by Streamlined MTX")
+        }
+
+        const buildOptions = this._handler.buildOptions
+        const destSdc = buildOptions.root === buildOptions.target ? path.join(this._handler.task.dest, FOLDER_GEN, FOLDER_SDC) : path.join(this._handler.task.dest, FOLDER_SDC)
+        const model = await this._handler.model()
         if (!model) {
             return
         }
@@ -38,33 +84,29 @@ class MtxModuleBuilder extends BuildTaskHandlerEdmx {
         // copy base model sources
         await Promise.all(model.$sources.map(src => {
             if (src.includes(FOLDER_NODE_MODULES)) {
-                return this.copy(src).to(src.substr(src.indexOf(FOLDER_NODE_MODULES)))
+                return this._handler.copy(src).to(path.join(destSdc, src.substr(src.indexOf(FOLDER_NODE_MODULES))))
             } else {
-                const relSrc = path.relative(this.buildOptions.root, src)
+                const relSrc = path.relative(buildOptions.root, src)
                 if (relSrc.startsWith("..")) {
-                    this.logger.warn(`model file is out of project scope, skipping file ${src}`)
+                    this._handler.logger.warn(`model file is out of project scope, skipping file ${src}`)
                     return Promise.resolve()
                 }
-                return this.copy(src).to(relSrc)
+                return this._handler.copy(src).to(path.join(destSdc, relSrc))
             }
         }))
 
         // collect and write language bundles into single i18n.json file
-        await this.collectLanguageBundles(model, this.task.dest)
+        await this._handler.collectLanguageBundles(model, destSdc)
 
         // copy native hana content and templates
-        await this._copyNativeContent(this.task.src, this.task.dest, tenantDbPath)
+        await this._copyNativeContent(this._handler.task.src, destSdc, tenantDbPath)
     }
 
     async clean() {
         // staging build content is deleted by BuildTaskEngine
-        if (this.buildOptions.root === this.buildOptions.target) {
-            // delete entire folder 'gen'
-            const genDest = path.dirname(this.task.dest)
-            if (path.basename(genDest) === FOLDER_GEN) {
-                this.logger._debug && this.logger.debug(`Deleting build target folder ${genDest}`)
-                await fs.remove(genDest)
-            }
+        if (this._handler.buildOptions.root === this._handler.buildOptions.target) {
+            // remove 'gen' folder
+            return fs.promises.rm(path.join(this._handler.task.dest, FOLDER_GEN), { force: true, recursive: true })
         }
     }
 
@@ -78,13 +120,13 @@ class MtxModuleBuilder extends BuildTaskHandlerEdmx {
 
         if (tenantDbPath) {
             // copy any static HANA artifacts, e.g. .csv files
-            const dbDest = path.resolve(dest, path.relative(this.buildOptions.root, tenantDbPath))
+            const dbDest = path.resolve(dest, path.relative(this._handler.buildOptions.root, tenantDbPath))
             await this._copyNativeHanaContent(tenantDbPath, dbDest)
         }
     }
 
     async _copyNativeHanaContent(src, dest) {
-        return super.copyNativeContent(src, dest, (entry) => {
+        return this._handler.copyNativeContent(src, dest, (entry) => {
             if (fs.statSync(entry).isDirectory()) {
                 const folderName = path.basename(entry)
                 return folderName !== FOLDER_NODE_MODULES
@@ -95,7 +137,7 @@ class MtxModuleBuilder extends BuildTaskHandlerEdmx {
     }
 
     async _copyTemplates(src, dest) {
-        return super.copyNativeContent(src, dest, (entry) => {
+        return this._handler.copyNativeContent(src, dest, (entry) => {
             if (fs.statSync(entry).isFile()) {
                 return /\.cds$/.test(path.basename(entry))
             }
@@ -113,13 +155,13 @@ class MtxModuleBuilder extends BuildTaskHandlerEdmx {
      * @param {Object} model - the reflected csn for this SaaS application
      */
     _validateExtensionAllowLists(model, tenantDbPath) {
-        let entityWhitelist = this.env.get("mtx.entity-whitelist")
-        let serviceWhitelist = this.env.get("mtx.service-whitelist")
-        let extensionAllowlist = this.env.get("mtx.extension-allowlist")
+        let entityWhitelist = this._handler.env.get("mtx.entity-whitelist")
+        let serviceWhitelist = this._handler.env.get("mtx.service-whitelist")
+        let extensionAllowlist = this._handler.env.get("mtx.extension-allowlist")
 
         // for java projects mtx configuration is part of sidecar config
         if (!entityWhitelist && !serviceWhitelist && !extensionAllowlist && tenantDbPath) {
-            const dbEnv = this.env.for("cds", tenantDbPath)
+            const dbEnv = this._handler.env.for("cds", tenantDbPath)
             if (dbEnv && dbEnv.get("mtx")) {
                 entityWhitelist = dbEnv.get("mtx.entity-whitelist")
                 serviceWhitelist = dbEnv.get("mtx.service-whitelist")
@@ -127,52 +169,47 @@ class MtxModuleBuilder extends BuildTaskHandlerEdmx {
             }
         }
 
+        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.cds.reflect(model)
-            const services = reflected.services
-            const entities = Object.values(reflected.entities)
+            const reflected = this._handler.cds.reflect(model)
 
             if (Array.isArray(extensionAllowlist)) {
                 extensionAllowlist.forEach(allowListEntry => {
                     if (Array.isArray(allowListEntry.for)) {
                         allowListEntry.for.forEach(pattern => {
                             if (pattern !== '*') {
-                                const nsPattern = pattern + '.'
-                                if (allowListEntry.kind === 'service') {
-                                    if (!services.some(service => service.name === pattern || service.name.startsWith(nsPattern))) {
-                                        invalidEntries.add(pattern)
-                                    }
-                                } else {
-                                    if (!entities.some(entity => entity.name === pattern || entity.name.startsWith(nsPattern))) {
-                                        invalidEntries.add(pattern)
-                                    }
+                                if (!reflected.find(e => isValid(e, pattern, pattern + '.', allowListEntry.kind))) {
+                                    invalidEntries.add(pattern)
                                 }
                             }
                         })
                     }
                 })
                 if (invalidEntries.size > 0) {
-                    this.pushMessage(`Invalid entries found in 'extension-allowlist' - [${[...invalidEntries].join(', ')}]`, WARNING)
+                    this._handler.pushMessage(`Invalid entries found in 'extension-allowlist' - [${[...invalidEntries].join(', ')}]`, WARNING)
                 }
             } else if (Array.isArray(entityWhitelist) || Array.isArray(serviceWhitelist)) {
                 // validate whitelist entries
                 if (Array.isArray(entityWhitelist)) {
                     entityWhitelist.forEach(name => {
-                        if (!entities.some(entity => entity.name === name && entity.kind === 'entity')) {
+                        if (!reflected.find(e => isValid(e, name, null, "entity"))) {
                             invalidEntries.add(name)
                         }
                     })
                 }
                 if (Array.isArray(serviceWhitelist)) {
                     serviceWhitelist.forEach(name => {
-                        if (!services.some(service => service.name === name && service.kind === 'service')) {
+                        if (!reflected.find(e => isValid(e, name, null, "service"))) {
                             invalidEntries.add(name)
                         }
                     })
                 }
                 if (invalidEntries.size > 0) {
-                    this.pushMessage(`Invalid entries found in 'entity-whitelist' or 'service-whitelist' - [${[...invalidEntries].join(', ')}]`, WARNING) //NOSONAR
+                    this._handler.pushMessage(`Invalid entries found in 'entity-whitelist' or 'service-whitelist' - [${[...invalidEntries].join(', ')}]`, WARNING) //NOSONAR
                 }
             }
         }
@@ -185,29 +222,29 @@ class MtxModuleBuilder extends BuildTaskHandlerEdmx {
      * @returns {string} the src folder of the tenant db module
      */
     async _getHanaTenantDbPath() {
-        let tasks = this.buildOptions.tasks || []
-        const modelPaths = this.resolveModel()
+        let tasks = this._handler.buildOptions.tasks || []
+        const modelPaths = this._handler.resolveModel()
 
         // ensure that the hana task is contained even if this mtx task has been executed solely using "cds build --for mtx"
         if (!tasks.find(task => task.for === BUILD_TASK_HANA)) {
             //mtx task might have been executed as separate task
-            tasks = this.env.get("build.tasks") || []
+            tasks = this._handler.env.get("build.tasks") || []
             if (tasks.length === 0) {
-                const provider = new BuildTaskProviderInternal(this.cds, this.logger)
-                tasks = await provider.lookupTasks(this.buildOptions)
+                const provider = new BuildTaskProviderInternal(this._handler.cds, this._handler.logger)
+                await provider.lookupTasks(tasks, this._handler.buildOptions)
             }
         }
         // the SaaS app might use a tenant aware db as well as a shared db deployed using static hdi-deployer
         // pick the hana build task refering to the tenant aware db - the src path has to be contained in this build task's model options
-        const hanaDbPaths = tasks.filter(task => task.for === BUILD_TASK_HANA).map(hanaTask => path.resolve(this.buildOptions.root, hanaTask.src || this.env.folders.db))
+        const hanaDbPaths = tasks.filter(task => task.for === BUILD_TASK_HANA).map(hanaTask => path.resolve(this._handler.buildOptions.root, hanaTask.src || this._handler.env.folders.db))
         let tenantDbPath = hanaDbPaths.find(hanaDbPath => hanaDbPaths.length === 1 || modelPaths.some(modelPath => path.dirname(modelPath) === hanaDbPath))
 
         if (!tenantDbPath) {
-            tenantDbPath = path.join(this.buildOptions.root, this.env.folders.db)
+            tenantDbPath = path.join(this._handler.buildOptions.root, this._handler.env.folders.db)
             if (hanaDbPaths.length === 0) {
-                this.pushMessage(`no 'hana' build task found, use default location '${tenantDbPath}'`, WARNING)
+                this._handler.pushMessage(`no 'hana' build task found, use default location '${tenantDbPath}'`, WARNING)
             } else {
-                this.pushMessage(`no 'hana' build task found matching model scope '${this.task.options.model}', use default location '${tenantDbPath}'`, WARNING)
+                this._handler.pushMessage(`no 'hana' build task found matching model scope '${this._handler.task.options.model}', use default location '${tenantDbPath}'`, WARNING)
             }
         }
         return tenantDbPath

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

@@ -0,0 +1,68 @@
+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'
+
+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')
+
+            // 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 writeTar(dest, model) {
+        const buffer = await this.packTar(model)
+        if (buffer) {
+            await this._handler.write(buffer).to(path.join(dest, TAR_NAME))
+        }
+        await fs.promises.mkdir(dest, { recursive: true })
+    }
+
+    /**
+     * Returns the build tasks of this project - either user defined or calculated by BuildTaskFactory.
+     * A build task of type 'hana' is enforced in order to copy existing native hana artifacts later on.
+     *
+     * @returns {string} the src folder of the tenant db module
+     */
+    async _getHanaTenantDbDest() {
+        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)
+            return null
+        }
+        return hanaTask.dest
+    }
+}
+module.exports = ResourcesTarBuilder

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

@@ -0,0 +1,80 @@
+/* eslint-disable no-empty */
+const path = require('path')
+const { FOLDER_GEN } = require('../../constants')
+const BuildTaskHandlerInternal = require('../buildTaskHandlerInternal')
+const NodeCfModuleBuilder = require('../nodejs')
+const ResourcesTarProvider = require('../mtx/resourcesTarBuilder')
+const { INFO } = require('../buildTaskHandlerInternal')
+
+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
+    }
+    init() {
+        super.init()
+        if (this.buildOptions.root === this.buildOptions.target) {
+            this.task.dest = path.join(this.task.dest, FOLDER_GEN)
+        }
+    }
+
+    async build() {
+        // Sidecar scenario: model-provider is implemented as separate Nodejs app.
+        // Create resources TAR AND and compiled CSN(s) for the sidecar app.
+        // build.target=".": 'dest' -> 'model-provider/gen'
+        // build.target="gen": 'dest' -> 'gen/model-provider'
+        const sidecarEnv = this.env.for("cds", this.task.src)
+
+        // 1. build node application
+        await this._buildNodeApp(sidecarEnv)
+
+        // 2. build main application
+        await this._buildMainApp(sidecarEnv)
+    }
+
+    async _buildNodeApp(sidecarEnv) {
+        const sources = []
+        for (const name in sidecarEnv.requires) {
+            const service = sidecarEnv.requires[name]
+            if (service.model) {
+                sources.push(service.model)
+            }
+        }
+        const model = await this.cds.load(sources, this.options)
+        const destSidecar = this.task.dest
+        const destSidecarSrc = path.join(destSidecar, this.env.folders.srv)
+
+        await this.compileToJson(model, destSidecarSrc)
+        await this.collectLanguageBundles(model, destSidecarSrc)
+        await this._copyProjectRootContent(this.task.src, destSidecar)
+    }
+
+    async _buildMainApp(sidecarEnv) {
+        let main = sidecarEnv.requires['cds.xt.ModelProviderService']?.root
+        if (!main) {
+            throw new Error("Invalid sidecar configuration - model-provider.root configuration missing")
+        }
+        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
+            this.pushMessage(`Sidecar main application build results are created in folder '${main}'. Use the 'production' profile if the folder is configured differently.`, INFO)
+        }
+        const destRoot = this.task.dest
+        const destMain = path.join(destRoot, main)
+        const destMainSrv = path.join(destMain, this.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).writeTar(destMain, csn)
+    }
+}
+module.exports = MtxSidecarModuleBuilder