@sap/cds-dk 6.8.3 → 7.0.0

package/lib/build/provider/buildTaskProviderInternal.js

@@ -0,0 +1,370 @@
+const fs = require('fs')
+const path = require('path')
+const cds = require('../../cds')
+const { hasJavaNature, getDefaultModelOptions, BuildError, hasOptionValue } = 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, BUILD_TASK_MTX_EXTENSION, NODEJS_MODEL_EXCLUDE_LIST,
+    DEFAULT_BUILT_IN_MODELS } = require("../constants")
+
+class BuildTaskProviderInternal extends BuildTaskProvider {
+    constructor(logger) {
+        super()
+        this._logger = logger
+    }
+    get logger() {
+        return this._logger
+    }
+
+    canHandleTask(task) {
+        return BUILD_TASKS.includes(task.for)
+            || task.use && task.use.startsWith(BUILD_TASK_PREFIX)
+        // support different build task implementations of the same build task ID defined by 'for'
+        //return (BUILD_TASKS.includes(task.for) && !task.use) || (task.use && task.use.startsWith(BUILD_TASK_PREFIX))
+    }
+
+    loadHandler(task) {
+        return require(`./${BuildTaskProviderInternal._getForValueFromTask(task)}`)
+    }
+
+    async lookupTasks(tasks) {
+        return this._createTasks(tasks, tasks.length > 0)
+    }
+
+    async applyTaskDefaults(task) {
+        const taskFor = BuildTaskProviderInternal._getForValueFromTask(task)
+        task.for = task.for || taskFor
+        task.use = task.use || `${BUILD_TASK_PREFIX}/${taskFor}`
+
+        // src folder needs to be initialized first
+        BuildTaskProviderInternal._setDefaultSrcFolder(task)
+
+        BuildTaskProviderInternal._setDefaultModel(task)
+    }
+
+    async _createTasks(tasks, addRequiredTasks) {
+        let db = typeof cds.env.folders.db === "string" ? [BuildTaskProviderInternal._normalizePath(cds.env.folders.db)] : cds.env.folders.db
+        let srv = typeof cds.env.folders.srv === "string" ? [BuildTaskProviderInternal._normalizePath(cds.env.folders.srv)] : cds.env.folders.srv
+
+        const dbOptions = {
+            model: []
+        }
+        const srvOptions = {
+            model: []
+        }
+        if (Array.isArray(db) && db.length > 0) {
+            db = BuildTaskProviderInternal._getModuleFolder(db) || null
+            if (!db && !addRequiredTasks) { // log once
+                this.logger.debug("No database module found")
+            }
+        }
+        if (Array.isArray(srv) && srv.length > 0) {
+            srv = BuildTaskProviderInternal._getModuleFolder(srv) || null
+            if (!srv && !addRequiredTasks) { // log once
+                this.logger.debug("No service module found")
+            }
+        }
+        // create required build tasks
+        if (addRequiredTasks) {
+            const mtxTask = tasks.find(task => task.for === BUILD_TASK_MTX || task.for === BUILD_TASK_MTX_SIDECAR)
+            if (mtxTask) {
+                //restore used tasks as they might have been filtered by 'cds build --for mtx'
+                if (mtxTask._uses) {
+                    mtxTask._uses.map(use => use.task).forEach(task => {
+                        if (!tasks.includes(task)) {
+                            tasks.push(task)
+                        }
+                    })
+                }
+                let dbTask = tasks.find(task => task.for === BUILD_TASK_HANA)
+                if (!dbTask) {
+                    //  db task might be missing if mtx task is enforced by 'cds build --for mtx'
+                    dbTask = this._createDbTask(db, dbOptions)
+                    if (dbTask) {
+                        tasks.push(dbTask)
+                    }
+                }
+                if (dbTask && (!mtxTask._uses || !mtxTask._uses.map(use => use.task).includes(dbTask))) {
+                    const use = { task: dbTask }
+                    mtxTask._uses ? mtxTask._uses.push(use) : mtxTask._uses = [use]
+                }
+            }
+        } else {
+            !db && this.logger._debug && this.logger.debug(`project doesn't have a database module '${cds.env.folders.db}'`)
+            !srv && this.logger._debug && this.logger.debug(`project doesn't have a service module '${cds.env.folders.srv}'`)
+
+            // create hana build task
+            const dbTask = this._createDbTask(db, dbOptions)
+            if (dbTask) {
+                tasks.push(dbTask)
+            }
+            // create java or node build task
+            const srvTask = this._createSrvTask(srv, srvOptions)
+            if (srvTask) {
+                tasks.push(srvTask)
+            }
+
+            // create mtx build task
+            const mtxTask = this._createMtxTask(srv, tasks)
+            if (mtxTask) {
+                tasks.push(mtxTask)
+            }
+        }
+    }
+
+    _createDbTask(src, taskOptions) {
+        this.logger.debug("determining database kind")
+        if (!src || BuildTaskProviderInternal._isMtxExtension()) {
+            return null
+        }
+        let task = null
+        if (this._useHana()) {
+            this.logger.debug("found HANA database")
+            // legacy build supports dest property
+            const compileDest = cds.env.data?.dest
+            if (compileDest) {
+                //../db/src/gen
+                // compileDest is relative to src folder in modular build - resolve correctly
+                taskOptions.compileDest = path.relative(path.resolve(cds.root, src), path.resolve(cds.root, compileDest))
+            }
+            task = {
+                src: src,
+                for: BUILD_TASK_HANA,
+                options: taskOptions
+            }
+        } else {
+            this.logger.debug("found sqlite database - skipping HANA build task")
+        }
+        return task
+    }
+
+    _useHana() {
+        if (cds.env.requires.db?.kind === "hana" || cds.env.requires.db?.dialect === "hana") {
+            return true
+        }
+        // false if other db has been defined
+        if (cds.env.requires.db?.kind) {
+            return false
+        }
+        // check whether cds config represents a legacy build system config for which requires.db was not configured
+        // Note: compat layer sets requires.db: {}
+        const userEnv = cds.env.for("cds", cds.root, false)
+        return userEnv && (userEnv.data?.model || userEnv.service?.model)
+    }
+
+    _createMtxTask(src, tasks) {
+        this.logger.debug("determining MTX architecture")
+
+        // preserve order of creation
+        if (BuildTaskProviderInternal._isMtxExtension()) {
+            this.logger.debug("MTX extension app")
+            return { for: BUILD_TASK_MTX_EXTENSION }
+        }
+
+        if (BuildTaskProviderInternal._isMtxs()) {
+            const sidecarPath = path.join(cds.root, MTX_SIDECAR_FOLDER)
+            let sidecarEnv
+            if (fs.existsSync(sidecarPath)) {
+                sidecarEnv = cds.env.for("cds", sidecarPath)
+            }
+            if (
+                cds.env.profiles?.includes('with-mtx-sidecar') || // new presets
+                cds.env.requires["cds.xt.ModelProviderService"]?.external // for compatibility with former mtxs presets
+            ) {
+                this.logger.debug("MTX app with sidecar")
+                if (!sidecarEnv) {
+                    throw new BuildError(`MTX sidecar directory '${sidecarPath}' not existing. Custom build task configuration required if the folder is named differently.`)
+                }
+                if (!sidecarEnv.requires["cds.xt.ModelProviderService"]?._in_sidecar) {
+                    // correct profile might have been set, but couldn't be resolved
+                    if (sidecarEnv.profiles?.includes('mtx-sidecar')) {
+                        throw new BuildError('MTX configuration cannot be resolved. Make sure an up-to-date version of @sap/cds-mtxs is installed.')
+                    }
+                    throw new BuildError(`Invalid MTX sidecar configuration - profile 'mtx-sidecar' not set.`)
+                }
+                return { for: BUILD_TASK_MTX_SIDECAR }
+            }
+            if (sidecarEnv?.requires["cds.xt.ModelProviderService"]?._in_sidecar || sidecarEnv?.profiles?.includes('mtx-sidecar')) {
+                throw new BuildError(`MTX sidecar requires profile 'with-mtx-sidecar' in project root configuration.`)
+            }
+
+            if (cds.env.requires["cds.xt.ModelProviderService"]?._in_sidecar || cds.env.profiles?.includes('mtx-sidecar')) {
+                // cds build is executed in sidecar folder
+                throw new BuildError(`Seems that you are executing 'cds build' in the 'mtx/sidecar' folder. Execute 'cds build' in the project root folder instead.`)
+            }
+
+            // mtxs with nodejs, but without sidecar
+            if (!tasks.some(task => task.for === BUILD_TASK_JAVA || task.for === BUILD_TASK_JAVA_CF)) {
+                this.logger.debug("MTX app without sidecar")
+                return {
+                    for: BUILD_TASK_MTX,
+                    src
+                }
+            }
+        }
+    }
+
+    _createSrvTask(src, taskOptions) {
+        this.logger.debug("determining implementation technology")
+        if (!src || BuildTaskProviderInternal._isMtxExtension()) {
+            return null
+        }
+        let task = null
+        if (BuildTaskProviderInternal._hasJavaNature(src)) {
+            task = this._createJavaTask(src, taskOptions)
+        } else {
+            task = this._createNodeTask(src, taskOptions)
+        }
+        return task
+    }
+
+    _createJavaTask(src, taskOptions) {
+        this.logger.debug("found implementation technology Java")
+        // legacy build supports dest property
+        const compileDest = cds.env.service?.dest
+        if (compileDest) {
+            // compileDest is relative to src folder in modular build - resolve correctly
+            taskOptions.compileDest = path.relative(path.resolve(cds.root, src), path.resolve(cds.root, compileDest))
+        }
+        return {
+            src: src,
+            for: BUILD_TASK_JAVA,
+            options: taskOptions
+        }
+    }
+
+    _createNodeTask(src, taskOptions) {
+        this.logger.debug("found implementation technology Nodejs")
+        return {
+            src: src,
+            for: BUILD_TASK_NODEJS,
+            options: taskOptions
+        }
+    }
+
+    static _isMtxExtension() {
+        return !!cds.env.extends
+    }
+
+    /**
+     * Distinguishes whether the Nodejs project is a Streamlined MTX (cds >=6) or an old MTX project.
+     */
+    static _isMtxs() {
+        return cds.env.requires.toggles
+            || cds.env.profiles.includes('with-mtx-sidecar')
+            || cds.env.requires['cds.xt.ModelProviderService']
+            || (typeof cds.env.requires.multitenancy === "object")
+    }
+
+    static _setDefaultSrcFolder(task) {
+        switch (task.for) {
+            case BUILD_TASK_HANA:
+                task.src = task.src || this._normalizePath(cds.env.folders.db)
+                break
+            case BUILD_TASK_JAVA:
+            case BUILD_TASK_JAVA_CF:
+            case BUILD_TASK_NODEJS:
+            case BUILD_TASK_NODE_CF:
+                task.src = task.src || this._normalizePath(cds.env.folders.srv)
+                break
+            case BUILD_TASK_FIORI:
+                task.src = task.src || this._normalizePath(cds.env.folders.app)
+                break
+            case BUILD_TASK_MTX_SIDECAR:
+                task.src = task.src || MTX_SIDECAR_FOLDER
+                break
+            case BUILD_TASK_MTX_EXTENSION:
+                task.src = task.src || "."
+                break
+            case BUILD_TASK_MTX:
+                require('../../util/version').checkMtx(cds)
+                // mtxs with nodejs, but without sidecar
+                task.src = task.src || this._normalizePath(cds.env.folders.srv)
+                break
+            default:
+                throw new Error(`Unknown build task '${task.use || task.for}'`)
+        }
+    }
+
+    static _setDefaultModel(task) {
+        let taskModelPaths = task.options?.model
+        if (taskModelPaths && !Array.isArray(taskModelPaths)) {
+            taskModelPaths = [taskModelPaths]
+        }
+        task.options = task.options || {}
+        let defaultModelPaths = []
+        // add default models to custom build tasks if this hasn't been disabled
+        if (taskModelPaths?.length) {
+            if (!hasOptionValue(task.options?.[DEFAULT_BUILT_IN_MODELS], false)) {
+                // get the built-in models
+                defaultModelPaths = getDefaultModelOptions().filter(p => p.match('@sap/cds'))
+            }
+        } else {
+            defaultModelPaths = getDefaultModelOptions()
+            defaultModelPaths.push(task.src)
+            if (hasOptionValue(task.options?.[DEFAULT_BUILT_IN_MODELS], false)) {
+                // all default models except the built-in models
+                defaultModelPaths = defaultModelPaths.filter(p => !p.match('@sap/cds'))
+            }
+        }
+
+        // REVISIT: filter nodejs bootstrap service models for Java - issues/12770#issuecomment-1805719
+        if (this._hasJavaNature(cds.env.folders.srv)) {
+            defaultModelPaths = defaultModelPaths.filter(p => !NODEJS_MODEL_EXCLUDE_LIST.includes(p))
+        }
+        // also add built-in models to custom build tasks already containing model options
+        if (!taskModelPaths || defaultModelPaths.length) {
+            task.options.model = [...new Set(taskModelPaths?.length ? taskModelPaths.concat(defaultModelPaths) : defaultModelPaths)]
+        }
+    }
+
+    /**
+     * Returns whether this project is a java project or not.
+     * @param {string} srv - the folder name of the service module
+     */
+    static _hasJavaNature(srv) {
+        srv = this._getModuleFolder(Array.isArray(srv) ? srv : [srv])
+        return hasJavaNature([cds.root, srv && path.join(cds.root, srv)])
+    }
+
+    static _getForValueFromTask(task) {
+        return task.for ? task.for : task.use && task.use.substring(BUILD_TASK_PREFIX.length + 1)
+    }
+
+    /**
+     * For valid paths remove trailing '/'. Otherwise return as is - important!!
+     * @param {*} dir
+     */
+    static _normalizePath(dir) {
+        return typeof dir === "string" ? dir.replace(/\/$/, '') : dir
+    }
+
+    /**
+     * Determines the module folder from the past list that may represent files or folders w or w/o .cds file extension.
+     * @param {Array} filesOrFolders
+     */
+    static _getModuleFolder(filesOrFolders) {
+        const resources = [...filesOrFolders]
+        filesOrFolders.forEach(fileOrFolder => {
+            if (path.extname(fileOrFolder) !== FILE_EXT_CDS) {
+                resources.push(fileOrFolder + FILE_EXT_CDS)
+            }
+        })
+        return resources.reduce((acc, resource) => {
+            if (!acc) {
+                let resourcePath = path.resolve(cds.root, resource)
+                if (fs.existsSync(resourcePath)) {
+                    if (fs.lstatSync(resourcePath).isDirectory()) {
+                        acc = resource
+                    } else {
+                        // represents file
+                        acc = path.dirname(resource)
+                    }
+                }
+            }
+            return acc
+        }, null)
+    }
+}
+module.exports = BuildTaskProviderInternal

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

@@ -0,0 +1,167 @@
+const path = require('path')
+const cds = require('../../../cds')
+const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const URL = require('url')
+const { getProperty, relativePaths } = require('../../util')
+
+const { OUTPUT_MODE, OUTPUT_MODE_RESULT, BUILD_TASK_FIORI, CDS_CONFIG_PATH_SEP, OUTPUT_MODE_FILESYSTEM } = require('../../constants')
+
+/**
+ * With cds 4 service metadata for the UI service binding is no longer created by default.
+ * For SAP Web IDE Full-Stack compatibility a corresponding metadata.xml is still generated.
+ * Though, 'fiori' build tasks can still be configured for UI5 mock server usage - see https://github.wdf.sap.corp/cap/issues/issues/8673
+ */
+class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
+    init() {
+        // enforce
+        this._result = {
+            dest: this.task.dest,
+            edmx: new Map(),
+            languages: new Set(),
+            services: new Set()
+        }
+    }
+
+    async prepare() {
+        this.context.for = this.context.for || {}
+        this.context.for[BUILD_TASK_FIORI] = this.context.for[BUILD_TASK_FIORI] || {}
+
+        // cache for later use across multiple FioriAppModuleBuilder instances
+        const fioriBuildOptions = this.context.for[BUILD_TASK_FIORI]
+        fioriBuildOptions.appModel = new Map()
+        fioriBuildOptions.appEdmx = new Map()
+
+        // group tasks that have a common application root folder
+        const appTaskGroups = new Map()
+        this.context.tasks.forEach(task => {
+            if (task.for === BUILD_TASK_FIORI) {
+                const appFolder = path.relative(cds.root, task.src).split(CDS_CONFIG_PATH_SEP)[0]
+                appTaskGroups.has(appFolder) ? appTaskGroups.get(appFolder).push(task) : appTaskGroups.set(appFolder, [task])
+            }
+        })
+
+        // merge all model references to resolve the model later on
+        const appModelGroups = new Map()
+        for (let [appFolder, appTaskGroup] of appTaskGroups.entries()) {
+            const appModels = new Set()
+            appTaskGroup.forEach(task => {
+                if (Array.isArray(task.options.model)) {
+                    task.options.model.forEach(model => appModels.add(model))
+                }
+            })
+            appModelGroups.set(appFolder, appModels)
+        }
+
+        const originFioriBuildOption = fioriBuildOptions[OUTPUT_MODE]
+        fioriBuildOptions[OUTPUT_MODE] = OUTPUT_MODE_RESULT
+
+        try {
+            const edmxOptions = { version: cds.env.odata?.version }
+            for (let [appFolder, appModelGroup] of appModelGroups.entries()) {
+                this.logger.debug(`building module [${appFolder}] using [${this.constructor.name}]`)
+                const modelPaths = cds.resolve(Array.from(appModelGroup.values()))
+                if (!modelPaths || modelPaths.length === 0) {
+                    continue
+                }
+                this.logger._debug && this.logger.debug(`model: ${relativePaths(cds.root, modelPaths).join(", ")}`)
+
+                //cache model per fiori app root folder
+                const options = this.options()
+                const model = await cds.load(modelPaths, options)
+                fioriBuildOptions.appModel.set(appFolder, model)
+
+                await this.compileToEdmx(model, null, edmxOptions)
+
+                // cache edmx per fiori app root folder
+                fioriBuildOptions.appEdmx.set(appFolder, this._result.edmx)
+            }
+        } finally {
+            fioriBuildOptions[OUTPUT_MODE] = originFioriBuildOption
+        }
+        return false
+    }
+
+    /**
+     * This version only creates a odata representation for the 'mainService' data source
+     * as defined by the fiori wizard - everything else is currently not supported.
+     * Therefore errors are only logged, the build does not fail in case a service
+     * cannot be resolved based on the defined service URI
+     */
+    async build() {
+        const model = await this.model()
+        if (!model) {
+            return
+        }
+        await this._writeEdmxToWebapp(this.task.src, this.task.dest)
+    }
+
+    async _writeEdmxToWebapp(src, dest) {
+        const manifestPath = path.join(src, 'webapp', 'manifest.json')
+        let manifest
+
+        try {
+            manifest = require(manifestPath)
+        } catch (error) {
+            this.logger.log(`UI module does not contain a manifest.json [${relativePaths(cds.root, manifestPath)}], skipping build`)
+            return
+        }
+
+        const mainService = getProperty(manifest, ['sap.app', 'dataSources', 'mainService'])
+        if (!mainService) {
+            // no mainService defined - not supported
+            this.logger._debug && this.logger.debug(`UI module does not have a datasource [mainService], [${relativePaths(cds.root, manifestPath)}], skipping build`)
+            return
+        }
+
+        const localUri = getProperty(mainService, ['settings', 'localUri'])
+        const uri = mainService.uri
+
+        if (!localUri || !uri) {
+            this.logger._debug && this.logger.warn(`local uri setting missing for data source [mainService], [${relativePaths(cds.root, manifestPath)}]`)
+            return
+        }
+
+        const appFolder = path.relative(cds.root, src).split(CDS_CONFIG_PATH_SEP)[0]
+        const model = this.context.for[BUILD_TASK_FIORI].appModel.get(appFolder)
+        if (!model) {
+            this.logger.error(`failed to load model for service uri ${uri}, data source [mainService]`)
+            return
+        }
+
+        const edmx = this._getEdmxForUri(model, appFolder, uri)
+        if (!edmx) {
+            this.logger.error(`failed to resolve service definition for service uri ${uri}, data source [mainService]`)
+            return
+        }
+
+        if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_FILESYSTEM)) {
+            const edmxPath = path.resolve(path.join(dest, 'webapp'), this._strippedUrlPath(localUri))
+            return this.write(edmx).to(edmxPath)
+        }
+    }
+
+    _getEdmxForUri(model, appFolder, uri) {
+        const uriSegments = this._strippedUrlPath(uri).split('/')
+
+        // one segment of the URI has to match a service name
+        // NOTE: assumption is that the service definition can be resolved - either by
+        // - defining corresponding using statement in annotations model or
+        // - adding the service module folder to the model option
+        let service = cds.reflect(model).find(service => uriSegments.find(segment => service.name === segment))
+
+        if (service) {
+            const allServices = this.context.for[BUILD_TASK_FIORI].appEdmx.get(appFolder)
+            if (allServices) {
+                return allServices.get(service.name + ".xml")
+            }
+        }
+        return null
+    }
+
+    _strippedUrlPath(urlString) {
+        const url = URL.parse(urlString)
+        return url.pathname.replace(/^(\/|\\)/, '').replace(/(\/|\\)$/, '') // strip leading and trailing slash or backslash)
+    }
+}
+
+module.exports = FioriAppModuleBuilder