@sap/cds-dk 9.7.2 → 9.8.0

package/lib/build/buildTaskFactory.js

@@ -1,198 +0,0 @@
-// @ts-check
-const cds = require('../cds')
-const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
-const { hasJavaNature, getDefaultModelPaths, hasOptionValue, BuildError } = require('./util')
-const { OPTION_WS, IGNORE_DEFAULT_MODELS, NODEJS_MODEL_EXCLUDE_LIST, BUILD_TASK_NODEJS, BUILD_TASK_NODE_CF } = require("./constants")
-const DEBUG = cds.debug('cli|build')
-
-module.exports = class BuildTaskFactory {
-    constructor(options) {
-        this._providerFactory = new BuildTaskProviderFactory(options)
-    }
-    get providerFactory() {
-        return this._providerFactory
-    }
-    get options() {
-        return this.providerFactory.options
-    }
-
-    // the following order for determining build tasks is used
-    // 1. create from command line input, e.g. cds build/all --for hana --src db --model srv --dest db
-    // 2. read using cds.env.build.tasks
-    // 3. create from cds.env.folders config data
-    async getTasks() {
-        const tasks = await this._createTasks()
-        // always resolve tasks for input validation
-        const resolvedTasks = this.providerFactory.resolveTasks(tasks)
-        if (this.options.resolve) {
-            return resolvedTasks
-        }
-        return tasks
-    }
-
-    createPlugin(task) {
-        return this.providerFactory.createPlugin(task)
-    }
-
-    async _createTasks() {
-        DEBUG?.(`determining build tasks for project [${cds.root}].`)
-
-        let tasks = BuildTaskFactory._getExistingTasks()
-        if (tasks.length === 0) {
-            tasks = await this.providerFactory.lookupTasks()
-            this._applyCliOptions(tasks)
-        } else {
-            this._applyCliOptions(tasks)
-            // 1. apply default values including task.for and ensure that for all tasks a provider exists - throwing error otherwise
-            await this.providerFactory.applyTaskDefaults(tasks)
-            // ensure that dependencies get wired up before filtering
-            await this.providerFactory.lookupTasks(tasks, true)
-        }
-
-        // 2. filters the list of build tasks
-        // Note: A new task might get created, e.g. 'cds build --for hana' will enforce a hana build even if sqlite has been configured
-        let existingTasks = tasks
-        tasks = await this._filterTasksForCli(tasks)
-        if (tasks.length === 0) {
-            return tasks
-        }
-
-        // 3. add dependencies
-        existingTasks = [...tasks]
-        await this.providerFactory.lookupTasks(tasks, true)
-        if (tasks.length > existingTasks.length) {
-            const newTasks = tasks.filter(task => !existingTasks.includes(task))
-            // a dependant task was added
-            this._applyCliOptions(newTasks)
-        }
-
-        // obligatory task defaults shared by all tasks
-        await BuildTaskFactory._applyCommonTaskDefaults(tasks)
-
-        BuildTaskFactory._setDefaultBuildTargetFolder()
-        return tasks
-    }
-
-    static _getExistingTasks() {
-        return Array.isArray(cds.env.build?.tasks) ? structuredClone(cds.env.build.tasks) : []
-    }
-
-    static async _applyCommonTaskDefaults(tasks) {
-        // normalize model options
-        tasks.forEach(task => {
-            if (task.options?.model && !Array.isArray(task.options.model)) {
-                task.options.model = [task.options.model]
-            }
-        })
-        const modelPaths = await getDefaultModelPaths(false)
-        let wsModelPaths
-        // calculate only once
-        if (cds.cli.options?.[OPTION_WS] || tasks.some(task => hasOptionValue(task.options?.[OPTION_WS], true))) {
-            wsModelPaths = await getDefaultModelPaths(true)
-        }
-        // set default model options
-        tasks.forEach(task => {
-            if (!task.src) {
-                throw new BuildError(`Mandatory property 'src' not defined for build task '${task.for}'.`)
-            }
-            const optionWs = cds.cli.options?.[OPTION_WS] || hasOptionValue(task.options?.[OPTION_WS], true)
-            // shallow copy model paths
-            this._setTaskModelOptions(task, optionWs ? [...wsModelPaths] : [...modelPaths])
-        })
-    }
-
-    static _setDefaultBuildTargetFolder() {
-        // Java projects use "." as the default build target folder
-        if (hasJavaNature() && this._adaptBuildTargetSettingForJava()) {
-            DEBUG?.("using inplace build for java project instead of default staging build")
-        }
-    }
-
-    /**
-    * Use inplace build for java projects if build.target has not been configured.
-    * @returns {boolean} true if changed, false otherwise
-    */
-    static _adaptBuildTargetSettingForJava() {
-        if (cds.env.build.target !== ".") {
-            // filter user settings of cds.env
-            const userEnv = cds.env.for("cds", cds.root, false)
-
-            // use helper as env.build might be undefined
-            if (!userEnv.build?.target) {
-                cds.env.build.target = "."
-                return true
-            }
-        }
-        return false
-    }
-
-    async _filterTasksForCli(tasks) {
-        const options = this.options
-        // filter tasks using either option for, use, src
-        let resultTasks = tasks.filter(task => {
-            return (!options.for || options.for === task.for)
-                && (!options.src || options.src === task.src)
-        })
-        if (resultTasks.length === 0) {
-            if (options.for) {
-                const task = this.providerFactory.getTask({ for: options.for })
-                if (options.src) {
-                    task.src = options.src
-                }
-                resultTasks.push(task)
-                this._applyCliOptions(resultTasks)
-                await this.providerFactory.applyTaskDefaults(resultTasks)
-            }
-        } else if (resultTasks.length <= tasks.length) {
-            // return the same array as long as it contains a subset of the given tasks
-            tasks.length = 0
-            resultTasks.forEach(task => tasks.push(task))
-            resultTasks = tasks
-        }
-        return resultTasks
-    }
-
-    _applyCliOptions(tasks) {
-        const options = this.options
-        // apply remaining cli options to filtered tasks
-        tasks.forEach(task => {
-            if (options.dest) {
-                task.dest = options.dest
-            }
-            if (options.taskOptions) {
-                const taskOptions = JSON.parse(JSON.stringify(options.taskOptions))
-                task.options = task.options ? Object.assign(task.options, taskOptions) : taskOptions
-            }
-        })
-    }
-
-    static _setTaskModelOptions(task, defaultModelPaths) {
-        // bootstrap service model is only required for Nodejs build task - issues/12770#issuecomment-1805719
-        if (task.for !== BUILD_TASK_NODEJS && task.for !== BUILD_TASK_NODE_CF) {
-            defaultModelPaths = defaultModelPaths.filter(p => !NODEJS_MODEL_EXCLUDE_LIST.includes(p))
-        }
-
-        let taskModelPaths = task.options?.model
-        if (taskModelPaths && !Array.isArray(taskModelPaths)) {
-            taskModelPaths = [taskModelPaths]
-        }
-        const allowList = new RegExp(`^@sap/cds${cds.env.requires.toggles ? '|^' + cds.env.features.folders.replace('*', '') : ''}`)
-        task.options = task.options || {}
-        let modelPaths = []
-        if (taskModelPaths?.length) {
-            if (!hasOptionValue(task.options?.[IGNORE_DEFAULT_MODELS], true)) {
-                modelPaths = defaultModelPaths.filter(p => p.match(allowList))
-            }
-        } else {
-            modelPaths = [...defaultModelPaths]
-            if (!modelPaths.includes(task.src)) {
-                modelPaths.push(task.src)
-            }
-            if (hasOptionValue(task.options?.[IGNORE_DEFAULT_MODELS], true)) {
-                // all default models except the built-in models
-                modelPaths = modelPaths.filter(p => !p.match(allowList))
-            }
-        }
-        task.options.model = [...new Set(taskModelPaths?.length ? taskModelPaths.concat(modelPaths) : modelPaths)]
-    }
-}

package/lib/build/buildTaskProvider.js

@@ -1,38 +0,0 @@
-/* eslint-disable no-unused-vars */
-
-/** @typedef {import("./buildTaskProviderFactory").Task} Task */
-/** @typedef {import("./plugin")} Plugin_ */
-
-/**
- * @abstract
- */
-module.exports = class BuildTaskProvider {
-    /**
-     * @abstract
-     * @param {{for: string}} key 
-     * @returns {boolean | undefined}
-     */
-    providesTask(key) { }
-    /**
-     * @param {{for: string}} key 
-     * @returns {} task 
-     */
-    getTask(key) { return key }
-    /**
-     * @abstract
-     * @param {Task} task
-     * @returns {typeof Plugin_}
-     */
-    getPlugin(task) { /** abstract */ }
-    /**
-     * @abstract
-     * @param {Array} tasks 
-     * @param {boolean} dependencies 
-     */
-    async lookupTasks(tasks, dependencies) { /* abstract */ }
-    /**
-     * @abstract
-     * @param {Task} task 
-     */
-    async applyTaskDefaults(task) { /** abstract */ }
-}

package/lib/build/buildTaskProviderFactory.js

@@ -1,233 +0,0 @@
-// @ts-check
-const fs = require('fs')
-const path = require('path')
-const cds = require('../cds')
-const { OUTPUT_MODE_FILESYSTEM, DEFAULT_SRC_FOLDER } = require('./constants')
-const InternalBuildTaskProvider = require('./provider/internalBuildTaskProvider')
-const BuildTaskProvider = require('./buildTaskProvider')
-const { BuildError, normalizePath } = require('./util')
-const DEBUG = cds.debug('cli|build')
-
-/**
- * @typedef {import('./plugin').Task} Task
- */
-
-class BuildTaskProviderFactory {
-    /**
-     * @param {import('./index').BuildOptions} options - build options
-     */
-    constructor(options = {}) {
-        options.outputMode = options.outputMode || OUTPUT_MODE_FILESYSTEM
-        if (options.clean === undefined) {
-            options.clean = true
-        }
-        ['for', 'src', 'dest'].forEach(key => {
-            if (options[key]) {
-                if (typeof options[key] !== 'string') {
-                    throw new BuildError(`Invalid build options - property '${key}' must be a string`)
-                }
-                if (key === 'src' || key === 'dest') {
-                    // normalize path separator and remove trailing slash
-                    options[key] = normalizePath(options[key])
-                }
-            }
-        })
-        /** @type {{ options: import('./index').BuildOptions, tasks: Task[]}} */
-        this._context = { options, tasks: [] } // resolved tasks
-    }
-    get options() {
-        return this._context.options
-    }
-    get context() {
-        return this._context
-    }
-    get providers() {
-        if (!this._providers) {
-            this._providers = this._loadProviders()
-        }
-        return this._providers
-    }
-
-    getTask(key) {
-        return this._getProvider(key).getTask(key)
-    }
-
-    async applyTaskDefaults(tasks) {
-        return Promise.all(tasks.map(async (task) => {
-            if (!task.for) {
-                throw new BuildError(`Mandatory property 'for' not defined for build task.`)
-            }
-            return this._applyTaskDefaults(this._getProvider(task), [task])
-        }))
-    }
-
-    async lookupTasks(tasks = [], dependencies) {
-        for (const provider of this.providers) {
-            const existingTasks = [...tasks]
-            await this._lookupTasks(provider, tasks, dependencies)
-            if (existingTasks.length < tasks.length) {
-                // apply defaults
-                const newTasks = tasks.filter(task => !existingTasks.includes(task))
-                await this._applyTaskDefaults(provider, newTasks)
-                DEBUG?.(`Build task provider ${provider.constructor.name} returned build tasks ${JSON.stringify(newTasks)}`)
-            }
-        }
-        return tasks
-    }
-
-    /**
-     * Create a Plugin instance for the given build task.
-     * The implementation is loaded based on the build task's 'for' or 'use' option.
-     * @param {Task} task
-     */
-    createPlugin(task) {
-        const Plugin = this.getPlugin(task)
-        const resolvedTask = this._resolveTask(task)
-        DEBUG?.(`loaded build plugin [${resolvedTask.for}]`)
-
-        const plugin = new Plugin()
-        if (!(plugin instanceof Plugin)) {
-            throw new Error(`Invalid Build plugin type ${task.for}`)
-        }
-        plugin._task = resolvedTask
-        plugin._context = this.context
-        this.context.tasks.push(resolvedTask)
-        DEBUG?.(`created build plugin [${resolvedTask.for}]`)
-        return plugin
-    }
-
-    /**
-     * Loads the build plugin implementation for the given build task.
-     * 'for' defines an alias for built-in plugins like 'hana', 'java', 'node', 'fiori' or 'mtx'.
-     * 'use' defines the fully qualified module name of custom build plugins implementations.
-     * @param {Task} task
-     * @returns {typeof import('./plugin')}
-     */
-    getPlugin(task) {
-        const provider = this._getProvider(task)
-        try {
-            return provider.getPlugin(task)
-        } catch (e) {
-            console.error(`Provider failed to load build plugin class ${task.for} - provider: ${provider.constructor.name}`)
-            throw e
-        }
-    }
-
-    /**
-     * @param {Task[]} tasks
-     */
-    resolveTasks(tasks) {
-        return tasks.map(task => this._resolveTask(task))
-    }
-
-    /**
-     * Resolves the given build task based on the project root folder.<br>
-     * The task is validated in order to ensure that 'src' refers to a valid folder and 'for' or 'use' reference can be required.
-     * @private
-     * @param {Task} task
-     */
-    _resolveTask(task) {
-        // second validate src path
-        const resolvedTask = JSON.parse(JSON.stringify(task))
-
-        // Do not store resolved symlinks as this is causing issues on Windows, e.g. if git projects are
-        // located under 'C:\SAPDevelop\git\...' using a sym-link from '%USERHOME%\git' to 'C:\SAPDevelop\git'.
-        // see cap/issues/#8694
-        resolvedTask.src = path.resolve(cds.root, task.src)
-        // if --ws is passed, the db/ folder is not required, as the task will gather the model from the workspaces
-        if (!this.options.ws) {
-            try {
-                //validate source path
-                fs.realpathSync(resolvedTask.src)
-            } catch {
-                throw new BuildError(`The 'src' folder '${path.resolve(cds.root, task.src)}' for build task '${resolvedTask.for}' does not exist`)
-            }
-        }
-        resolvedTask.dest = path.resolve(cds.root, cds.env.build.target, task.dest || task.src)
-        resolvedTask.options = task.options || {}
-        return resolvedTask
-    }
-
-    _getProvider(key) {
-        const provider = this.providers.find(provider => {
-            try {
-                return provider.providesTask(key)
-            } catch (e) {
-                console.error(`Build task provider ${provider.constructor.name} returned an error`)
-                throw e
-            }
-        })
-        if (!provider) {
-            throw new BuildError(`No provider found for build task '${key.for}'. Ensure that all required dependencies have been added and 'npm install' has been executed.`)
-        }
-        return provider
-    }
-
-    async _lookupTasks(provider, tasks, dependencies) {
-        return provider.lookupTasks(tasks, dependencies)
-    }
-
-    async _applyTaskDefaults(provider, tasks) {
-        return Promise.all(tasks.map(task => provider.applyTaskDefaults(task)))
-    }
-
-    _loadProviders() {
-        return [
-            new InternalBuildTaskProvider(),
-            new PluginBuildTaskProvider()
-        ]
-    }
-}
-
-/**
- * Default provider implementation handling fully qualified custom build task declarations.
- */
-class PluginBuildTaskProvider extends BuildTaskProvider {
-    #plugins = require('./plugins').plugins
-    get plugins() {
-        return this.#plugins
-    }
-
-    /**
-     * @param {{for: string}} key
-     */
-    providesTask(key) {
-        return this.plugins.has(key.for)
-    }
-
-    getPlugin(task) {
-        return this.plugins.get(task.for)
-    }
-
-    async lookupTasks(tasks, dependencies) {
-        if (!dependencies) {
-            for (const [id, plugin] of this.plugins) {
-                if (plugin.hasTask()) {
-                    tasks.push(this.getTask({ for: id }))
-                }
-            }
-        }
-    }
-
-    async applyTaskDefaults(task) {
-        const defaultTask = this.getTask(task)
-        const names = Object.getOwnPropertyNames(defaultTask)
-        names.forEach(name => {
-            task[name] ??= defaultTask[name]
-        })
-    }
-
-    /**
-     * @param {{for: string}} key
-     * @returns {Task}
-     */
-    getTask(key) {
-        // plugin entry is already validated, a taskDefaults default member exists
-        const task = JSON.parse(JSON.stringify(this.plugins.get(key.for)?.taskDefaults ?? {}))
-        task.for = key.for
-        task.src ??= DEFAULT_SRC_FOLDER
-        task.src = task.src.replace(/\/$/, '')
-        return task
-    }
-}
-module.exports = BuildTaskProviderFactory

package/lib/build/provider/internalBuildTaskProvider.js

@@ -1,227 +0,0 @@
-const cds = require('../../cds')
-const { exists, isdir, path } = cds.utils
-const { hasJavaNature, BuildError, normalizePath } = 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_TASKS, BUILD_TASK_MTX_SIDECAR, MTX_SIDECAR_FOLDER, BUILD_TASK_MTX_EXTENSION } = require("../constants")
-const ResourcesTarBuilder = require('./mtx/resourcesTarBuilder')
-const DEBUG = cds.debug('cli|build')
-const ModelProviderService = 'cds.xt.ModelProviderService'
-
-module.exports = class InternalBuildTaskProvider extends BuildTaskProvider {
-    providesTask(key) {
-        return BUILD_TASKS.includes(key.for)
-    }
-
-    async lookupTasks(tasks, dependencies) {
-        return this._createTasks(tasks, dependencies)
-    }
-
-    async applyTaskDefaults(task) {
-        InternalBuildTaskProvider._setDefaultSrcFolder(task)
-    }
-
-    getPlugin(task) {
-        return require(`./${task.for}`)
-    }
-
-    async _createTasks(tasks, dependencies) {
-        let db = typeof cds.env.folders.db === "string" ? [normalizePath(cds.env.folders.db)] : cds.env.folders.db
-        let srv = typeof cds.env.folders.srv === "string" ? [normalizePath(cds.env.folders.srv)] : cds.env.folders.srv
-
-        const folder4 = filesOrFolders => {
-            const entry = filesOrFolders
-                .flatMap(r => path.extname(r) === FILE_EXT_CDS ? [r] : [r, r + FILE_EXT_CDS])
-                .find(r => exists(r))
-            return entry && (isdir(entry) ? entry : path.dirname(entry))
-        }
-        const dbOptions = { model: [] }
-        const srvOptions = { model: [] }
-        if (Array.isArray(db) && db.length > 0) {
-            db = folder4(db)
-            if (!db && !dependencies) { // log once
-                DEBUG?.("No database module found")
-            }
-        }
-        if (Array.isArray(srv) && srv.length > 0) {
-            srv = folder4(srv)
-            if (!srv && !dependencies) { // log once
-                DEBUG?.("No service module found")
-            }
-        }
-
-        // order of creation is relevant
-        if (dependencies) {
-            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 = ResourcesTarBuilder.getHanaTenantDbTask(tasks, mtxTask)
-                if (!dbTask) {
-                    //  db task might be missing if mtx task is enforced by 'cds build --for mtx'
-                    if (cds.env.build.tasks) {
-                        dbTask = ResourcesTarBuilder.getHanaTenantDbTask(cds.env.build.tasks, mtxTask)
-                    }
-                    if (!dbTask) {
-                        dbTask = this._createDbTask(db, dbOptions)
-                    }
-                    if (dbTask) {
-                        tasks.push(dbTask)
-                    }
-                }
-                if (dbTask && !mtxTask._uses?.map(use => use.task).includes(dbTask)) {
-                    const use = { task: dbTask }
-                    mtxTask._uses ? mtxTask._uses.push(use) : mtxTask._uses = [use]
-                }
-            }
-        } else {
-            !db && DEBUG?.(`project doesn't have a database module '${cds.env.folders.db}'`)
-            !srv && 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)
-            if (mtxTask) {
-                tasks.push(mtxTask)
-            }
-        }
-    }
-
-    _createDbTask(src, taskOptions) {
-        if (!src || InternalBuildTaskProvider._isMtxExtension()) {
-            return null
-        }
-        let task = null
-        if (this._useHana()) {
-            DEBUG?.("found HANA database")
-            task = {
-                src: src,
-                for: BUILD_TASK_HANA,
-                options: taskOptions
-            }
-        } else {
-            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
-        }
-    }
-
-    _createMtxTask(src) {
-        const main = cds.env
-        if (main.extends) {
-            return { for: BUILD_TASK_MTX_EXTENSION }
-        }
-        const isMtxs = main.requires.toggles || main.requires.multitenancy || main.requires[ModelProviderService]
-        if (isMtxs) {
-            if (main.requires?.[ModelProviderService]?._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.`)
-            }
-            const sidecarPath = path.join(cds.root, MTX_SIDECAR_FOLDER)
-            const sidecar = cds.env.for("cds", sidecarPath)
-            if (sidecar?.requires[ModelProviderService]?._in_sidecar) {
-                if (!exists(sidecarPath)) {
-                    throw new BuildError(`MTX sidecar directory '${MTX_SIDECAR_FOLDER}' does not exist. Custom build task configuration required if the folder is named differently.`)
-                }
-                return { src: MTX_SIDECAR_FOLDER, for: BUILD_TASK_MTX_SIDECAR }
-            }
-            if (!hasJavaNature()) { // only Node.js: embedded multitenancy
-                return { src, for: BUILD_TASK_MTX }
-            }
-        }
-    }
-
-    _createSrvTask(src, taskOptions) {
-        if (!src || InternalBuildTaskProvider._isMtxExtension()) {
-            return null
-        }
-        let task = null
-        if (hasJavaNature()) {
-            task = this._createJavaTask(src, taskOptions)
-        } else {
-            task = this._createNodeTask(src, taskOptions)
-        }
-        return task
-    }
-
-    _createJavaTask(src, taskOptions) {
-        DEBUG?.("found Java runtime")
-        return {
-            src: src,
-            for: BUILD_TASK_JAVA,
-            options: taskOptions
-        }
-    }
-
-    _createNodeTask(src, taskOptions) {
-        DEBUG?.("found Nodejs runtime")
-        if (!exists('package.json')) {
-            throw new BuildError(`No 'package.json' found in project root folder '${cds.root}'`)
-        }
-        return {
-            src: src,
-            for: BUILD_TASK_NODEJS,
-            options: taskOptions
-        }
-    }
-
-    static _isMtxExtension() {
-        return !!cds.env.extends
-    }
-
-    static _setDefaultSrcFolder(task) {
-        switch (task.for) {
-            case BUILD_TASK_HANA:
-                task.src ||= 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 ||= normalizePath(cds.env.folders.srv)
-                break
-            case BUILD_TASK_FIORI:
-                task.src ||= normalizePath(cds.env.folders.app)
-                break
-            case BUILD_TASK_MTX_SIDECAR:
-                task.src ||= MTX_SIDECAR_FOLDER
-                break
-            case BUILD_TASK_MTX_EXTENSION:
-                if (task.src && task.src !== cds.root) {
-                    throw new BuildError("Invalid 'src' property value for build task 'mtx-extension', the only allowed value is '.'")
-                }
-                task.src ||= "."
-                break
-            case BUILD_TASK_MTX:
-                // mtxs with nodejs, but without sidecar
-                task.src ||= normalizePath(cds.env.folders.srv)
-                break
-            default:
-                throw new Error(`Unknown build task '${task.for}'`)
-        }
-    }
-}

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

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