@sap/cds-dk 7.2.0 → 7.3.1

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, DEFAULT_SRC_FOLDER } = 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,45 @@ 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.getPluginClass(task)
+        const resolvedTask = this._resolveTask(task)
+        this.logger._debug && this.logger.debug(`loaded build plugin [${resolvedTask.use}]`)
+
+        const plugin = new BuildPluginClass()
+        if (!(plugin instanceof BuildPlugin)) {
+            throw new Error(`Invalid Build plugin type ${task.for}`)
+        }
+        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}'`)
-        }
+    getPluginClass(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.getPluginClass(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,10 +115,7 @@ 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) {
         // 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,75 @@ 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
+    }
+
+    getPluginClass(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.
+ */
+class PluginBuildTaskProvider extends BuildTaskProvider {
+    constructor(logger) {
+        super()
+        this._logger = logger
+        this._plugins = require('./plugins').getPlugins()
+    }
+
+    get plugins() {
+        return this._plugins
+    }
+
+    providesTask(key) {
+        return this.plugins.has(key.for)
+    }
+
+    getPluginClass(task) {
+        return this.plugins.get(task.for).class
+    }
+
+    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).taskDefaults
+        task.for = key.for
+        task.src ??= DEFAULT_SRC_FOLDER
+        task.src = task.src.replace(/\/$/, '')
+        return task
+    }
+}
 module.exports = BuildTaskProviderFactory

package/lib/build/constants.js

@@ -3,6 +3,7 @@ exports.OUTPUT_MODE_NONE = 0x0
 exports.OUTPUT_MODE_FILESYSTEM = 0x1
 exports.OUTPUT_MODE_RESULT = 0x2
 
+exports.DEFAULT_SRC_FOLDER = '.'
 exports.BUILD_TASK_NPM_SCOPE = "@sap"
 exports.BUILD_TASK_PREFIX = exports.BUILD_TASK_NPM_SCOPE + "/cds/build"
 exports.BUILD_TASK_JAVA = "java"
@@ -19,9 +20,11 @@ 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_LOCALIZED_EDMX = "contentLocalizedEdmx"         // create EDMX for required languages - ENABLED for Java 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 +59,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

@@ -1,11 +1,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, register, BuildPlugin }
 
 /**
  * Executes cds build in the directory defined by cds.root.
@@ -21,10 +20,15 @@ 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
         }
         throw e
     }
+}
+
+function register(id, options) {
+    return require('./plugins').register(id, options)
 }

package/lib/build/plugins.js

@@ -0,0 +1,35 @@
+const cds = require('../cds')
+
+module.exports = new (class BuildPlugins {
+    constructor() {
+        this._plugins = new Map()
+    }
+    getPlugins() {
+        return this._plugins
+    }
+    getPlugin(id) {
+        return this._plugins.get(id)
+    }
+    register(id, options) {
+        if (!id || !options?.impl) {
+            throw Error("Invalid build plugin parameter")
+        }
+        if (this._plugins.has(id)) {
+            throw Error(`Build plugin ${id} already registered`)
+        }
+        this._plugins.set(id, {
+            id,
+            class: this._loadPlugin(id, options.impl),
+            description: options.description,
+            taskDefaults: options.taskDefaults ?? {}
+        })
+    }
+    _loadPlugin(id, impl) {
+        try {
+            // project-local module is preferred - otherwise from our own dependencies
+            return require(require.resolve(impl, { paths: [cds.root, __dirname] })) 
+        } catch (e) {
+            throw new Error(`Custom build plugin implementation '${impl}' for '${id}' cannot be loaded:\n` + e)
+        }
+    }
+})

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
@@ -51,7 +51,11 @@ class BuildTaskHandlerEdmx extends BuildTaskHandlerFeatureToggles {
     }
 
     _isOdataProtocol(srv) {
-        return cds.service.protocols.protocol4(srv).startsWith('odata')
+        let protocols = cds.service.protocols.protocol4(srv)
+        if (typeof protocols === "string") {
+            protocols = [protocols]
+        }
+        return protocols.some(p => p && p.startsWith('odata'))
     }
 
     _options4odata() {
@@ -80,4 +84,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 = {
@@ -125,9 +125,9 @@ class FeatureToggleBuilder extends BuildTaskHandlerInternal {
     _validateFeature(ftCsn, baseCsn) {
         // features must not have other dependencies than base model dependencies - cross feature dependencies are not supported
         // do not pass options.messages in order to avoid duplicate compiler messages
-        // version 2.13.9 of compileSources does not read the requires definition of parsed CSNs
-        cds.compiler.compileSources({ '../..csn.json': baseCsn, 'feature.csn': ftCsn }, this.options())
+        // version 2.13.9 of compileSources does not read the 'requires' definition of parsed CSNs
+        cds.compiler.compileSources({ [ftCsn.requires[0]]: baseCsn, 'feature.csn': ftCsn }, this.options())
     }
 }
 
-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