@sap/cds-dk 7.2.0 → 7.3.0

package/lib/build/buildTaskProviderFactory.js

@@ -1,12 +1,17 @@
 const fs = require('fs')
 const path = require('path')
 const cds = require('../cds')
-const { LOG_MODULE_NAMES, OUTPUT_MODE_FILESYSTEM } = require("./constants")
-const BuildTaskProviderInternal = require('./provider/buildTaskProviderInternal')
+const { LOG_MODULE_NAMES, OUTPUT_MODE_FILESYSTEM } = require('./constants')
+const InternalBuildTaskProvider = require('./provider/internalBuildTaskProvider')
 const BuildTaskProvider = require('./buildTaskProvider')
+const { BuildError } = require('./util')
+const BuildPlugin = require('./buildPlugin')
 
 class BuildTaskProviderFactory {
     constructor(options = {}) {
+        // REVISIT: Logger is never passed to BuildTaskProviderFactory except for tests
+        // -> tests shouldn't pollute library coding
+        // see cds-dk/test/bin/eval.test.js for a non-invasive solution (intercepting console.log)
         options.logger = options.logger || cds.log(LOG_MODULE_NAMES)
         options.outputMode = options.outputMode || OUTPUT_MODE_FILESYSTEM
         if (options.clean === undefined) {
@@ -31,22 +36,16 @@ class BuildTaskProviderFactory {
         return this._providers
     }
 
+    getTask(key) {
+        return this._getProvider(key).getTask(key)
+    }
+
     async applyTaskDefaults(tasks) {
-        return Promise.all(tasks.map(async task => {
+        return Promise.all(tasks.map(async (task) => {
             if (!task.for && !task.use) {
-                throw new Error("Invalid build task definition - property 'for' and property 'use' missing")
-            }
-            const provider = this.providers.find(provider => {
-                try {
-                    return provider.canHandleTask(task)
-                } catch (e) {
-                    this.logger.error(`Build task provider ${provider.constructor.name} returned error:\n` + e)
-                    throw e
-                }
-            })
-            if (!provider) {
-                throw new Error(`No provider found for build task '${task.for || task.use}'`)
+                throw new Error(`Invalid build task definition - property 'for' and property 'use' missing`)
             }
+            const provider = this._getProvider(task)
             if (provider instanceof DefaultBuildTaskProvider) {
                 this.logger._debug && this.logger.debug(`No provider found for build task '${task.use}', using default provider`)
             }
@@ -54,11 +53,11 @@ class BuildTaskProviderFactory {
         }))
     }
 
-    async lookupTasks(tasks = []) {
+    async lookupTasks(tasks = [], dependencies) {
         for (let i = 0; i < this.providers.length; i++) {
             const provider = this.providers[i]
             const existingTasks = [...tasks]
-            await this._lookupTasks(provider, tasks)
+            await this._lookupTasks(provider, tasks, dependencies)
             if (existingTasks.length < tasks.length) {
                 // apply defaults
                 const newTasks = tasks.filter(task => !existingTasks.includes(task))
@@ -70,46 +69,42 @@ class BuildTaskProviderFactory {
     }
 
     /**
-     * Create a BuildTaskHandler instance for the given build task.
+     * Create a BuildPlugin instance for the given build task.
      * The implementation is loaded based on the build task's 'for' or 'use' option.
      * @param {*} task
      */
-    createHandler(task) {
-        const BuildTaskHandlerClass = this.loadHandler(task)
-        const resolvedTask = this.resolveTask(task)
-        this.logger._debug && this.logger.debug(`loaded build task handler [${resolvedTask.use}]`)
-
-        const handler = new BuildTaskHandlerClass()
-        handler._task = resolvedTask
-        handler._logger = this.logger
-        handler._context = this.context
+    createPlugin(task) {
+        const BuildPluginClass = this.loadPlugin(task)
+        const resolvedTask = this._resolveTask(task)
+        this.logger._debug && this.logger.debug(`loaded build plugin [${resolvedTask.use}]`)
+
+        const plugin = new BuildPluginClass()
+        plugin._task = resolvedTask
+        plugin._logger = this.logger
+        plugin._context = this.context
         this.context.tasks.push(resolvedTask)
-        this.logger._debug && this.logger.debug(`created BuildTaskHandler [${resolvedTask.use}]`)
-        return handler
+        this.logger._debug && this.logger.debug(`created build plugin [${resolvedTask.use}]`)
+        return plugin
     }
 
     /**
-     * Loads the build task handler implementation for the given build task.
-     * 'for' defines an alias for built-in handlers like 'hana', 'java', 'node', 'fiori' or 'mtx'.
-     * 'use' defines the fully qualified module name of external build task handler implemenations.
+     * 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 {object} task
      */
-    loadHandler(task) {
-        let provider = this.providers.find(provider => provider.canHandleTask(task))
-        if (!provider) {
-            throw new Error(`No provider found for build task '${task.for || task.use}'`)
-        }
+    loadPlugin(task) {
+        const provider = this._getProvider(task)
         try {
-            return provider.loadHandler(task)
-        }
-        catch (e) {
-            this.logger.error(`Provider failed to load handler class - provider: ${provider.constructor.name}, task: ${task.for || task.use} :\n` + e)
+            return provider.loadPlugin(task)
+        } catch (e) {
+            this.logger.error(`Provider failed to load build plugin class - provider: ${provider.constructor.name}, task: ${task.for || task.use} :\n` + e)
             throw e
         }
     }
 
     resolveTasks(tasks) {
-        return tasks.map(task => this.resolveTask(task))
+        return tasks.map(task => this._resolveTask(task))
     }
 
     /**
@@ -117,9 +112,9 @@ class BuildTaskProviderFactory {
      * The task is validated in order to ensure that 'src' refers to a valid folder and 'for' or 'use' reference can be required.
      * @param {*} task
      */
-    resolveTask(task) {
-        // first validate handler implementation
-        this.loadHandler(task)
+    _resolveTask(task) {
+        // first validate plugin implementation
+        this.loadPlugin(task)
 
         // second validate src path
         const resolvedTask = JSON.parse(JSON.stringify(task))
@@ -139,8 +134,23 @@ class BuildTaskProviderFactory {
         return resolvedTask
     }
 
-    async _lookupTasks(provider, tasks) {
-        return provider.lookupTasks(tasks)
+    _getProvider(key) {
+        const provider = this.providers.find(provider => {
+            try {
+                return provider.providesTask(key)
+            } catch (e) {
+                this.logger.error(`Build task provider ${provider.constructor.name} returned an error:\n` + e)
+                throw e
+            }
+        })
+        if (!provider) {
+            throw new BuildError(`No provider found for build task '${key.for || key.use}'. 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) {
@@ -150,8 +160,9 @@ class BuildTaskProviderFactory {
     _loadProviders() {
         // DefaultBuildTaskProvider must be last entry
         return [
-            new BuildTaskProviderInternal(this.logger),
-            new DefaultBuildTaskProvider()
+            new InternalBuildTaskProvider(this.logger),
+            new PluginBuildTaskProvider(this.logger),
+            new DefaultBuildTaskProvider(this.logger)
         ]
     }
 }
@@ -161,19 +172,121 @@ class BuildTaskProviderFactory {
  * Has to be the last entry in the providers list.
  */
 class DefaultBuildTaskProvider extends BuildTaskProvider {
-    canHandleTask(task) {
-        return !!task.use
+    constructor(logger) {
+        super()
+        this._logger = logger
     }
-    loadHandler(task) {
-        if (!task.use) {
-            throw new Error(`Invalid build task definition [${task.for}] - property 'use' missing`)
-        }
+
+    providesTask(key) {
+        return !!key.use
+    }
+
+    loadPlugin(task) {
         try {
             return require(require.resolve(task.use, { paths: [cds.root] }))
-        }
-        catch (e) {
+        } catch (e) {
             throw new Error(`Build task could not be resolved - module [${task.use}] cannot be loaded:\n` + e)
         }
     }
 }
+
+/**
+ * Default provider implementation handling fully qualified custom build task declarations.
+ * Has to be the last entry in the providers list. // REVISIT: Above it says DefaultBuildTaskProvider should be last entry? -> clarify
+ */
+class PluginBuildTaskProvider extends BuildTaskProvider {
+    constructor(logger) {
+        super()
+        this._logger = logger
+        const plugins = new Map()
+
+        // REVISIT: Remove once fetch mechanism is removed
+        function _local (id) {
+            return require(require.resolve (id, {paths:[
+                process.cwd(), // project-local module is preferred
+                __dirname      // otherwise from our own dependencies
+            ]}))
+        }
+
+        const cdsPlugins = _local('@sap/cds/lib/plugins').fetch?.() // REVISIT: Get rid of fetch mechanism
+        const buildPlugins = cds.env.build.plugins // REVISIT: Compat to old plugin mechanism, remove if possible
+
+        for (const [id, plugin] of Object.entries({ ...cdsPlugins, ...buildPlugins })) {
+            try {
+                const clazz = this._loadPlugin(id, plugin)
+                if (!clazz) continue
+                plugins.set(id, { id: id, impl: plugin.impl, class: clazz })
+            } catch (e) {
+                this._logger.error(`Skipping build plugin '${id}', it cannot be loaded.\n` + e + '\n') // REVISIT: why not throw? seems like an error one should fix, not exit with code 0
+            }
+        }
+        this._plugins = plugins
+    }
+    get plugins() {
+        return this._plugins
+    }
+
+    providesTask(key) {
+        return this.plugins.has(key.for)
+    }
+
+    loadPlugin(task) {
+        return this._loadPlugin(task.for, this.plugins.get(task.for))
+    }
+
+    async lookupTasks(tasks, dependencies) {
+        if (!dependencies) {
+            this.plugins.forEach(plugin => {
+                if (plugin.class?.hasTask()) {
+                    const task = this.getTask({ for: plugin.id })
+                    if (!task) {
+                        throw new Error(`Build task '${plugin.id}' required for custom plugin '${plugin.impl}'`)
+                    }
+                    task.for = plugin.id
+                    tasks.push(task)
+                }
+            })
+        }
+    }
+
+    async applyTaskDefaults(task) {
+        const defaultTask = this.getTask(task)
+        const names = Object.getOwnPropertyNames(defaultTask)
+        names.forEach(name => {
+            task[name] ??= defaultTask[name]
+        })
+    }
+
+    getTask(key) {
+        const task = this.plugins.get(key.for).class.getTaskDefaults() ?? key
+        task.src ??= '.'
+        if (task.src) {
+            task.src = task.src.replace(/\/$/, '')
+        }
+        task.for = key.for
+        return task
+    }
+
+    _loadPlugin(id, plugin) {
+        let pluginClass
+        try {
+            pluginClass = require(require.resolve(plugin.impl, { paths: [cds.root] }))
+            const inheritsFrom = (child, parent) => {
+                let proto = Object.getPrototypeOf(child)
+                while (proto) {
+                  if (proto === parent) return true
+                  proto = Object.getPrototypeOf(proto)
+                }
+                return false
+            }
+            if (!inheritsFrom(pluginClass, BuildPlugin)) return // REVISIT: better way to check if plugin is build-enabled than traversing prototype chain?
+        } catch (e) {
+            throw new Error(`Custom build plugin implementation '${plugin.impl}' for '${id}' cannot be loaded:\n` + e)
+        }
+        if (!pluginClass.hasTask || !pluginClass.getTaskDefaults) {
+            throw new Error(`Custom build plugin '${id}' must implement 'hasTask' and 'getTaskDefaults' methods`)
+        }
+        return pluginClass
+    }
+}
 module.exports = BuildTaskProviderFactory

package/lib/build/constants.js

@@ -19,9 +19,10 @@ exports.BUILD_TASKS = [this.BUILD_TASK_JAVA, this.BUILD_TASK_JAVA_CF, this.BUILD
 exports.ODATA_VERSION_V2 = "v2"
 exports.ODATA_VERSION_V4 = "v4"
 
-exports.CONTENT_LANGUAGE_BUNDLES = "contentLanguageBundles"     // create i18n.json language bundles - build task specific
-exports.CONTENT_DEFAULT_CSN = "contentDefaultCsn"               // create default CSN format flavor: "inferred" - build task specific
-exports.CONTENT_EDMX = "contentEdmx"                            // create EDMX for required languages - build task specific
+exports.CONTENT_LANGUAGE_BUNDLES = "contentLanguageBundles"     // create i18n.json language bundles
+exports.CONTENT_DEFAULT_CSN = "contentDefaultCsn"               // create default CSN format flavor: "inferred"
+exports.FLAVOR_LOCALIZED_EDMX = "flavorLocalizedEdmx"           // create localized EDMX languages based on existing properties files
+exports.CONTENT_EDMX = "contentEdmx"                            // create EDMX for required languages - ENABLED by default
 exports.CONTENT_PACKAGE_JSON = "contentPackageJson"             // create package.json file if not existing, or modify existing package.json - ENABLED by default
 exports.CONTENT_PACKAGELOCK_JSON = "contentPackageLockJson"     // copy package-lock.json file if existing into deployment folder - ENABLED by default
 exports.CONTENT_HDBTABLEDATA = "contentHdbtabledata"            // create .hdbtabledata files for .csv files if not existing - ENABLED by default
@@ -56,4 +57,3 @@ exports.LOG_LEVEL_INFO = "info"
 exports.LOG_LEVEL_DEBUG = "debug"
 exports.LOG_LEVELS = [exports.LOG_LEVEL_ERROR, exports.LOG_LEVEL_WARN, exports.LOG_LEVEL_INFO, exports.LOG_LEVEL_DEBUG]
 exports.LOG_MODULE_NAMES = "cds|build"
-exports.OVERRIDE_METHOD_MSG = "Must override method"

package/lib/build/index.js

@@ -2,10 +2,10 @@ const fs = require('fs')
 const cds = require('../cds')
 const BuildTaskEngine = require('./buildTaskEngine')
 const BuildTaskFactory = require('./buildTaskFactory')
-const BuildTaskHandler = require('./buildTaskHandler')
+const BuildPlugin = require('./buildPlugin')
 const { BuildError } = require('./util')
 
-module.exports = { build, BuildTaskFactory, BuildTaskEngine, BuildTaskHandler, BuildError }
+module.exports = { build, BuildTaskFactory, BuildTaskEngine, BuildPlugin, BuildError }
 
 /**
  * Executes cds build in the directory defined by cds.root.
@@ -21,6 +21,7 @@ async function build(options = {}) {
     } catch (e) {
         if (e instanceof BuildError || e.constructor.name === 'CompilationError') {
             cds._log(e.messages.length ? e.messages : e.message, { 'log-level': options['log-level'] || cds.env['log-level'] })
+            console.log('')
             // CompilationError.message also includes the detail messages - do not log twice
             const message = e.constructor.name === 'CompilationError' ? 'CDS compilation failed' : e.messages.length ? e.message : 'CDS build failed'
             throw message

package/lib/build/provider/{buildTaskHandlerEdmx.js → edmxBuildPlugin.js}

@@ -1,9 +1,9 @@
 const path = require('path')
 const cds = require('../../cds')
-const BuildTaskHandlerFeatureToggles = require('./buildTaskHandlerFeatureToggles')
-const { OUTPUT_MODE, OUTPUT_MODE_RESULT } = require('../constants')
+const FeatureToggleBuildPlugin = require('./featureToggleBuildPlugin')
+const { OUTPUT_MODE, OUTPUT_MODE_RESULT, FLAVOR_LOCALIZED_EDMX } = require('../constants')
 
-class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
+class EdmxBuildPlugin extends FeatureToggleBuildPlugin {
     async compileToEdmx(model, edmxDest, compileOptions = {}) { // NOSONAR
         const promises = []
 
@@ -24,12 +24,12 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
             const result = cds.compile.to.edmx(model, options)
 
             if (result) {
-                let langs = this.task.options.lang || cds.env.i18n.languages
+                let langs = compileOptions[FLAVOR_LOCALIZED_EDMX] === false ? [] : this.task.options.lang || cds.env.i18n.languages
                 if (langs.split) { // string to array
                     langs = langs.split(',')
                 }
                 if (langs.length > 0 && langs[0] !== 'all' && langs.indexOf('') < 0) {
-                    langs.push('')  // make sure fallback language is in, runtimes expect it
+                    langs.push('')  // make sure fallback language is in, runtime expects it
                 }
                 for (let [content, key] of result) {
                     const serviceName = key.file ? key.file : key.name
@@ -80,4 +80,4 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
         return Promise.resolve()
     }
 }
-module.exports = BuildTaskHandlerEdmx
+module.exports = EdmxBuildPlugin

package/lib/build/provider/{buildTaskHandlerFeatureToggles.js → featureToggleBuildPlugin.js}

@@ -2,10 +2,10 @@ const fs = require('fs')
 const path = require('path')
 const cds = require('../../cds')
 const { DEFAULT_CSN_FILE_NAME, OUTPUT_MODE, OUTPUT_MODE_RESULT } = require('../constants')
-const BuildTaskHandlerInternal = require('./buildTaskHandlerInternal')
+const InternalBuildPlugin = require('./internalBuildPlugin')
 const { getI18nDefaultFolder } = require('../util')
 
-class FeatureToggleBuilder extends BuildTaskHandlerInternal {
+class FeatureToggleBuildPlugin extends InternalBuildPlugin {
     init() {
         if (this.hasBuildOption(OUTPUT_MODE, OUTPUT_MODE_RESULT)) {
             this._result = {
@@ -130,4 +130,4 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
     }
 }
 
-module.exports = FeatureToggleBuilder
+module.exports = FeatureToggleBuildPlugin

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

@@ -1,6 +1,6 @@
 const path = require('path')
 const cds = require('../../../cds')
-const BuildTaskHandlerEdmx = require('../buildTaskHandlerEdmx')
+const EdmxBuildPlugin = require('../edmxBuildPlugin')
 const URL = require('url')
 const { getProperty, relativePaths } = require('../../util')
 
@@ -11,7 +11,7 @@ const { OUTPUT_MODE, OUTPUT_MODE_RESULT, BUILD_TASK_FIORI, CDS_CONFIG_PATH_SEP,
  * 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 {
+class FioriBuildPlugin extends EdmxBuildPlugin {
     init() {
         // enforce
         this._result = {
@@ -26,7 +26,7 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
         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
+        // cache for later use across multiple FioriBuildPlugin instances
         const fioriBuildOptions = this.context.for[BUILD_TASK_FIORI]
         fioriBuildOptions.appModel = new Map()
         fioriBuildOptions.appEdmx = new Map()
@@ -57,7 +57,6 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
         this.context.options[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()))
@@ -71,7 +70,7 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
                 const model = await cds.load(modelPaths, options)
                 fioriBuildOptions.appModel.set(appFolder, model)
 
-                await this.compileToEdmx(model, null, edmxOptions)
+                await this.compileToEdmx(model)
 
                 // cache edmx per fiori app root folder
                 fioriBuildOptions.appEdmx.set(appFolder, this._result.edmx)
@@ -165,4 +164,4 @@ class FioriAppModuleBuilder extends BuildTaskHandlerEdmx {
     }
 }
 
-module.exports = FioriAppModuleBuilder
+module.exports = FioriBuildPlugin