@sap/cds 6.8.4 → 7.0.1

package/bin/build/buildTaskFactory.js

@@ -1,283 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const cds = require('./cds'), { log } = cds.exec
-const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
-const { hasJavaNature, getProperty, redactCredentials, flatten, getDefaultModelOptions } = require('./util')
-const { FILE_EXT_CDS, BUILD_TASK_JAVA_CF, LOG_MODULE_NAMES, BUILD_TASK_JAVA } = require("./constants")
-
-class BuildTaskFactory {
-    constructor(logger) {
-        this._logger = logger || cds.log(LOG_MODULE_NAMES)
-    }
-    get logger() {
-        return this._logger
-    }
-
-    // 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(buildOptions = { root: process.env._TEST_CWD || process.cwd() }) {
-        try {
-            const providerFactory = new BuildTaskProviderFactory(this._logger, buildOptions)
-            const tasks = await this._createTasks(providerFactory)
-            buildOptions.target = path.resolve(buildOptions.root, cds.env.build.target)
-
-            // log build tasks
-            this.logger.log(`the following build tasks will be executed`)
-            let tasksOutput = "   {\n     \"build\": {\n       \"target\": \"" + cds.env.build.target + "\",\n       \"tasks\": ["
-            for (let i = 0; i < tasks.length; i++) {
-                tasksOutput += "\n         " + BuildTaskFactory._stringifyTask(tasks[i]) + (i + 1 < tasks.length ? "," : "")
-            }
-            tasksOutput += "\n       ]\n     }\n   }\n"
-            this.logger.log(tasksOutput)
-
-            // for testing purposes
-            this.logger.debug("cds.env used for build:")
-            this.logger._debug && this.logger.debug(redactCredentials(cds.env))
-
-            // always resolve tasks for input validation
-            if (buildOptions.resolve || buildOptions.cli) {
-                const resolvedTasks = providerFactory.resolveTasks(tasks)
-                if (buildOptions.resolve) {
-                    return resolvedTasks
-                }
-            }
-            return tasks
-        } catch (e) {
-            this.logger.log('')
-            // cds CLI layer is doing the logging if invoked using CLI
-            if (!buildOptions.cli) {
-                log(e, { withStack: true, log: (message) => this.logger.log(message) })
-            }
-            throw e
-        }
-    }
-
-    async _createTasks(providerFactory) {
-        const buildOptions = providerFactory.buildOptions
-        this.logger.debug(`determining build tasks for project [${buildOptions.root}].`)
-
-        // clearing model cache (details https://github.tools.sap/cap/cds/pull/181) is no longer required 
-        // because of changes https://github.tools.sap/cap/cds/pull/1121
-        // cds.resolve.cache = {}
-
-        let tasks = BuildTaskFactory._getExistingTasks()
-        if (tasks.length === 0) {
-            tasks = await providerFactory.lookupTasks()
-            await providerFactory.applyTaskDefaults(tasks)
-        } else {
-            // 1. apply default values including task.for and task.use and ensure that for all tasks a provider exists - throwing error otherwise
-            await providerFactory.applyTaskDefaults(tasks)
-            await providerFactory.lookupTasks(tasks)
-        }
-
-        // 3. filters the list of build tasks and adapts according to given CLI options
-        // Note: A new task will be created if invoked using CLI 'cds build --for <xxx>' 
-        // where <xxx> matches a valid task type like 'hana', 'java' etc.
-        const existingTasks = tasks
-        tasks = await BuildTaskFactory._applyCliTaskOptions(providerFactory, tasks)
-
-        if (tasks.length === 0) {
-            return tasks
-        }
-
-        // 2. add dependencies
-        await providerFactory.lookupTasks(tasks)
-
-        if (tasks !== existingTasks && tasks.some(task => !existingTasks.find(existingTask => existingTask === task))) {
-            // a different task shall be executed
-            await providerFactory.applyTaskDefaults(tasks)
-        }
-
-        // obligatory task defaults shared by all tasks
-        BuildTaskFactory._applyCommonTaskDefaults(tasks, buildOptions)
-
-        // ensure correct values for optional build task properties, error for missing mandatory properties
-        BuildTaskFactory._validateBuildTasks(tasks)
-
-        this._setDefaultBuildTargetFolder(tasks, buildOptions)
-        return tasks
-    }
-
-    static _getExistingTasks() {
-        return Array.isArray(getProperty(cds.env, 'build.tasks')) ? JSON.parse(JSON.stringify(cds.env.build.tasks)) : []
-    }
-
-    static _applyCommonTaskDefaults(tasks, buildOptions) {
-        const modelPaths = getDefaultModelOptions(buildOptions.root)
-
-        tasks.forEach(task => {
-            this._setTaskModelOptions(task, modelPaths)
-            if (!task.src) {
-                throw new Error(`Invalid build task definition - value of property 'src' is missing in [${task.for || task.use}].`)
-            }
-        })
-    }
-
-    static _validateBuildTasks(tasks) {
-        tasks.forEach(task => {
-            if (!task.src) {
-                throw new Error(`Invalid build task definition - value of property 'src' is missing in [${task.for || task.use}].`)
-            }
-        })
-    }
-
-    _setDefaultBuildTargetFolder(tasks, buildOptions) {
-        const task = tasks.find(task => task.for === BUILD_TASK_JAVA_CF || task.for === BUILD_TASK_JAVA)
-        const srv = task ? task.src : BuildTaskFactory._getModuleFolder(buildOptions.root, flatten([cds.env.folders.srv])) || "srv"
-
-        // Java projects use "." as the default build target folder
-        if (BuildTaskFactory._hasJavaNature(buildOptions.root, srv) && BuildTaskFactory._adaptBuildTargetSettingForJava(buildOptions.root)) {
-            this.logger.debug("using inplace build for java project instead of default staging build")
-        }
-        buildOptions.target = path.resolve(buildOptions.root, cds.env.build.target)
-    }
-
-    /**
-     * Returns whether this project is a java project or not.
-     * @param {string} projectPath - the absolute project path
-     * @param {string} src - the folder name of the service module
-     */
-    static _hasJavaNature(projectPath, src) {
-        return hasJavaNature([path.join(projectPath, src), projectPath])
-    }
-
-    /**
-    * Use inplace build for java projects if build.target has not been configured.
-    * @param {string} projectPath
-    * @returns {boolean} true if changed, false otherwise
-    */
-    static _adaptBuildTargetSettingForJava(projectPath) {
-        if (cds.env.build.target !== ".") {
-            // filter user settings of cds.env
-            const userEnv = cds.env.for("cds", projectPath, false)
-
-            // use helper as env.build might be undefined
-            if (!getProperty(userEnv, "build.target")) {
-                cds.env.build.target = "."
-                return true
-            }
-        }
-        return false
-    }
-
-    static async _applyCliTaskOptions(providerFactory, tasks) {
-        const { buildOptions } = providerFactory
-        if (buildOptions.cmdOptions) {
-            const options = buildOptions.cmdOptions
-
-            // filter tasks using either option for, use, src
-            tasks = tasks.filter(task => {
-                return (!options.use || options.use === task.use)
-                    && (!options.for || options.for === task.for)
-                    && (!options.src || options.src === task.src)
-            })
-            if (tasks.length === 0 && (options.for || options.use)) {
-                const task = {}
-                if ((options.for)) {
-                    task.for = options.for
-                }
-                if ((options.use)) {
-                    task.use = options.use
-                }
-                if (options.src) {
-                    task.src = options.src
-                }
-                tasks.push(task)
-            }
-            // apply remaining cli options to filtered tasks
-            tasks.forEach(task => {
-                if (options.dest) {
-                    task.dest = options.dest
-                }
-                if (options.opts) {
-                    const opts = this._scanTaskOptionParams(options.opts)
-                    task.options = task.options ? Object.assign(task.options, opts) : opts
-                }
-            })
-        }
-        return tasks
-    }
-
-    static _setTaskModelOptions(task, defaultModelPaths) {
-        task.options = task.options || {}
-        if (!task.options.model || Array.isArray(task.options.model) && task.options.model.length === 0) {
-            defaultModelPaths = new Set(defaultModelPaths)
-            if (task.src) {
-                defaultModelPaths.add(task.src)
-            }
-            task.options.model = [...defaultModelPaths]
-        } else if (!Array.isArray(task.options.model)) {
-            task.options.model = [task.options.model]
-        }
-    }
-
-    static _stringifyTask(task) {
-        // ensures identical order of properties
-        const order = ["for", "use", "src", "dest", "options"]
-        const keys = Object.keys(task).sort((a, b) => order.indexOf(a) - order.indexOf(b))
-
-        return keys.reduce((acc, key, idx) => {
-            // render either "for" OR "use" value
-            return acc + (!key.match("^_") ? (key !== "use" || keys[idx - 1] !== "for" ? (acc !== "{" ? ", " : "") + JSON.stringify(key) + ":" + JSON.stringify(task[key]) : "") : "")
-        }, "{") + "}"
-    }
-
-    static _scanTaskOptionParams(optsParams) {
-        // need to create new regex every call since a constant would keep the match state
-        const quoteRegex = /([\w-]+)=([\w/.]+|\[([\w/,.]+)\])/g
-
-        // captures a=1             => a:1
-        //          a=[x,y,z]       => a:[x,y,z]
-        //          a=1,b=[x,y,z]   => a:1 b=[x,y,z]
-        let match = quoteRegex.exec(optsParams)
-        const taskOptions = {}
-
-        while (match != null) {
-            const key = match[1]
-            const value = match[3] || match[2]
-            const valueArray = value.split(",")
-            taskOptions[key] = valueArray.length > 1 ? valueArray.map((entry) => entry.trim()) : value
-            match = quoteRegex.exec(optsParams)
-        }
-        return taskOptions
-    }
-
-    /**
-     * 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 {string} projectPath
-     * @param {Array} filesOrFolders
-     */
-    static _getModuleFolder(projectPath, 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(projectPath, resource)
-                if (fs.existsSync(resourcePath)) {
-                    if (fs.lstatSync(resourcePath).isDirectory()) {
-                        acc = resource
-                    } else {
-                        // represents file
-                        acc = path.dirname(resource)
-                    }
-                }
-            }
-            return acc
-        }, null)
-    }
-}
-module.exports = BuildTaskFactory

package/bin/build/buildTaskHandler.js

@@ -1,241 +0,0 @@
-const path = require('path')
-const fs = require('fs').promises
-const cds = require('./cds')
-
-const { BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_DEFAULT, OUTPUT_MODE_RESULT_ONLY, SEVERITY_INFO, SEVERITY_WARNING, SEVERITY_ERROR, OVERRIDE_METHOD_MSG } = require('./constants')
-const { hasOptionValue, getProperty, relativePaths, copy, BuildMessage } = require('./util')
-
-/**
- * The build task handler creates the build output for a dedicated build task. It is uniquely identified
- * by the build task's <code>use</code> property. It represents the fully qualified node module path
- * of the build task handler implementation.
- * <p>
- * The build task engine defines the following protocol. The methods are invoked in descending order:
- * <ul>
- *  <li>init() - optional</li>
- *  <li>get priority() - optional</li>
- *  <li>async clean()</li>
- *  <li>async build()</li>
- * </ul>
- * The reflected CSN can be accessed using the async method <code>model()</code>.
- */
-class BuildTaskHandler {
-    /**
-     * @class
-     */
-    constructor() {
-        if (new.target === BuildTaskHandler) {
-            throw new TypeError("Cannot construct BuildTaskHandler instances directly");
-        }
-        this._written = new Set()
-        this._messages = []
-        //injected by framework
-        this._task
-        this._buildOptions
-    }
-    static get INFO() {
-        return SEVERITY_INFO
-    }
-    static get WARNING() {
-        return SEVERITY_WARNING
-    }
-    static get ERROR() {
-        return SEVERITY_ERROR
-    }
-    /**
-     * Returns the build task executed by this build task handler.
-     * @return {object}
-     */
-    get task() {
-        //injected by framework
-        return this._task
-    }
-
-    /**
-     * Returns the message object to add build task specific messages. Severity 'Info', 'Warning', and 'Error' are supported.
-     * @return {Array}
-     */
-    get messages() {
-        return this._messages
-    }
-
-    /**
-     * Returns the list of files written by this build task handler of current CDS build execution.
-     * @return {Array}
-     */
-    get files() {
-        return [...this._written]
-    }
-
-    /**
-     * Returns the priority of this handler as number, where 0 represents the minimum value and
-     * Number.MAX_SAFE_INTEGER the maximum value.
-     * Positive numbers mean higher and negative numbers lower priority. Build task handlers
-     * with higher priority value are executed before handlers with lower priority.
-     * <br>
-     * Note: Currently not supported for custom build task handlers as they are always executed
-     * before the built-in handlers.
-     * @return {number} the priority for this handler as integer.
-     */
-    get priority() {
-        return 1
-    }
-    /**
-     * Called by the framework immediately after this instance has been created.
-     * The instance has already been fully initialized.
-     */
-    init() { }
-
-    /**
-     * Called by the framework to create the artifacts of this build task handler.
-     */
-    async build() {
-        throw new TypeError(OVERRIDE_METHOD_MSG)
-    }
-
-    /**
-     * Called by the framework immediately before 'build' to delete any output created by this build task handler.
-     * <p>
-     * Note: The <code>BuildTaskEngine</code> is cleaning the common generation target folder if the build is
-     * executed in staging mode, e.g. build.target: "gen".
-     */
-    async clean() {
-        throw new TypeError(OVERRIDE_METHOD_MSG)
-    }
-
-    /**
-     * Asynchronously write the given content to a given file path.
-     * If the file exists the content is replaced. If the file does not exist, a new file will be created.
-     * The file name is stored in the list of files written by this build task handler.
-     * @param {string} dest - absolute or relative file path. Relative paths will be resolved to this task's destination path.
-     * @param {any} data - If data is of type object the JSON-stringified version is written.
-     */
-    write(data) {
-        return {
-            to: async (dest) => {
-                if (!this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-                    if (!path.isAbsolute(dest)) {
-                        // relative to build task's destination path
-                        dest = path.resolve(this.task.dest, dest)
-                    }
-                    this.pushFile(dest)
-                    if (this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_DEFAULT)) {
-                        await fs.mkdir(path.dirname(dest), { recursive: true })
-                        await fs.writeFile(dest, typeof data === "object" && !Buffer.isBuffer(data) ? JSON.stringify(data, null, 2) : data)
-                    }
-                }
-            }
-        }
-    }
-
-    // TODO only works with files due to fs.copyFile, check usages
-    /**
-     * Copy a file or directory if the build task option 'outputMode' does not have the value 'resultOnly'.
-     * The directory can have contents.
-     * <p>
-     * Note: The file name is stored in the list of files written by this build task handler.
-     * </p>
-     * @param {string} src The absolute or relative source path of the file or directory to copy.
-     * Relative paths will be resolved to this task's source path.
-     * @param {string} dest The absolute or relative target path. Relative paths will be resolved to this task's destination path.
-     *
-     */
-    copy(src) {
-        return {
-            to: async (dest) => {
-                if (!this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_RESULT_ONLY)) {
-                    if (!path.isAbsolute(src)) {
-                        // relative to build task's source path
-                        src = path.resolve(this.task.src, src)
-                    }
-                    if (!path.isAbsolute(dest)) {
-                        // relative to build task's destination path
-                        dest = path.resolve(this.task.dest, dest)
-                    }
-                    this.pushFile(dest)
-                    if (this._hasBuildOption(BUILD_OPTION_OUTPUT_MODE, OUTPUT_MODE_DEFAULT)) {
-                        if (fs.cp) { // Node.js >= 16.7
-                            return fs.cp(src, dest, { recursive: true })
-                        }
-                        return copy(src, dest)
-                    }
-                    return dest
-                }
-            }
-        }
-    }
-
-    /**
-     * Adds the given user message and severity to the list of messages issued by this build task.
-     * <p>
-     * User messages will be logged after CDS build has been finished based on the log-level that has been set.
-     * By default messages with severity <em>warning</em> and <em>error</em> will be logged.
-     * @param {string} message the message text
-     * @param {string} severity the severity of the message
-     */
-    pushMessage(message, severity) {
-        this.messages.push(new BuildMessage(message, severity))
-    }
-
-    /**
-     * Returns the reflected CSN model using this build task's model settings.
-     * @return {object} the reflected CSN
-     */
-    async model() {
-        const files = this._resolveModel()
-        if (!files || files.length === 0) {
-            this._logger.log(`no CDS model found for [${this.task.for}] build task [${this.task.src}] - nothing to be done`)
-            return null
-        }
-        this._logger._debug && this._logger.debug(`model: ${relativePaths(this._buildOptions.root, files).join(", ")}`)
-        // $location paths are relative to current working dir by default - make sure a given project root folder is taken
-        const options = { ...this.options(), cwd: this._buildOptions.root }
-
-        const model = await cds.load(files, options)
-        if (!model) {
-            return null
-        }
-        return model
-    }
-
-    options() {
-        return { messages: this._messages }
-    }
-
-    /**
-     * Adds the given fully qualified file path to the list of files that are written by this build task.
-     * @param {string} filePath
-     */
-    pushFile(filePath) {
-        this._written.add(filePath)
-    }
-    /**
-     * Returns a list of CDS model files defining the transitive closure of the CDS model based on the model options
-     * defined for this build task.
-     */
-    _resolveModel() {
-        const modelPaths = Array.isArray(this.task.options.model) && this.task.options.model.length > 0 ? this.task.options.model : !Array.isArray(this.task.options.model) && this.task.options.model || this.task.src
-        return cds.resolve(modelPaths, this._buildOptions)
-    }
-    /** Determines whether the given build option value has been set for this build task.
-      * If the value is omitted, the existence of the given property name is checked.
-      */
-    _hasBuildOption(qualifiedName, value) {
-        return hasOptionValue(this._getBuildOption(qualifiedName), value)
-    }
-
-    // Returns the value of the given build option defined for this build task.
-    _getBuildOption(qualifiedName) {
-        // build task options overwriting other settings
-        let value = getProperty(this.task.options, qualifiedName)
-        if (value !== undefined) {
-            return value
-        }
-        value = getProperty(this._buildOptions.for[this.task.for], qualifiedName)
-        if (value !== undefined) {
-            return value
-        }
-        return getProperty(this._buildOptions, qualifiedName)
-    }
-}
-module.exports = BuildTaskHandler

package/bin/build/buildTaskProvider.js

@@ -1,22 +0,0 @@
-/* eslint-disable no-unused-vars */
-module.exports = class BuildTaskProvider {
-    constructor() {
-        //injected by framework
-        this._plugin = null
-    }
-    canHandleTask(task) {
-        // return this._plugin.provides.includes(task.for || task.use && this._getTaskId(task.use))
-    }
-    loadHandler(task) {
-        // return module.require(`${this._plugin.path}/${task.for || this._getTaskId(task.use)}`)
-    }
-    async lookupTasks(tasks, options) { }
-    async applyTaskDefaults(task, options) {
-        // task.for = task.for || this._getTaskId(task.use)
-    }
-    _getTaskId(use) {
-        if (this._plugin && this._plugin.id) {
-            return use.substring(this._plugin.id.length + 1)
-        }
-    }
-}