@sap/cds-dk 8.9.3 → 9.0.4

package/bin/watch.js

@@ -68,13 +68,11 @@ module.exports = Object.assign ( watch, {
 `})
 
 const cds = require('../lib/cds')
-const DEBUG = cds.log('cli|watch')
-const {delimiter,dirname,relative,resolve,sep} = require ('path')
+const DEBUG = /\b(y|all|cli|watch)\b/.test (process.env.DEBUG) ? ((..._) => console.debug ('[cli] -', ..._)) : undefined
+const {delimiter,relative,resolve,sep} = require ('path')
 const {codes} = require('../lib/util/term'), t = codes
 const fs = require ('fs')
 
-const extDefaults = 'cds,csn,csv,ts,mjs,cjs,js,json,properties,edmx,xml,env'
-
 const escapedSep = sep === '\\' ? '\\\\' : sep // escape backslash for windows
 const ignoreDefaults = [
   /\.git/,
@@ -93,21 +91,14 @@ const ignoreDefaults = [
 
 async function watch ([cwd], {
   args = ['serve', 'all'],
-  ext = extDefaults,
-  include = cds.env.watch?.include ?? [],
-  exclude = cds.env.watch?.exclude ?? [],
+  ext = 'cds,csn,csv,ts,mjs,cjs,js,json,properties,edmx,xml,env',
+  include = [],
+  exclude = [],
   ...options
 }={}) {
+  const log = (first,...more) => console.log (t.yellow + (first||''), ...more, t.reset)
   const paths4 = p => typeof p === 'string' ? p.split(',').map(p => p.trim()) : (p || [])
   const included = paths4(include), excluded = paths4(exclude)
-  const nonexisting = included.filter(p => !fs.existsSync(p))
-  if (nonexisting.length > 0) throw `${nonexisting.length > 1 ? 'Paths do' : 'Path does'} not exist: ${nonexisting.join(', ')}`
-  if (cwd && !cds.utils.exists(cwd)) try { // try module name like `@capire/bookshop`
-    cwd = require.resolve(cwd+'/package.json', {paths:[ process.cwd() ]}).slice(0,-13)
-  } catch (err) {
-    throw `Error: No such folder or package: '${cwd}'`
-  }
-  const _cwd = cwd || process.cwd()
 
   if (!Object.keys(options).includes('with-mocks'))               args.push ('--with-mocks')
   if (!Object.keys(options).find(a => /^in-memory\??$/.test(a)))  args.push ('--in-memory?')
@@ -117,59 +108,61 @@ async function watch ([cwd], {
     .filter(a => a !== '--watch')            // from `cds serve --watch`
     .filter(a => a !== cwd))
 
-  let env = Object.assign (process.env, {
+  if (cwd) {
+    const ocwd = process.env._original_cwd = process.cwd()
+    if (fs.existsSync(cwd)) cwd = resolve (cwd)
+    else try { // try module name like `@capire/bookshop`
+      cwd = require.resolve (cwd+'/package.json', {paths:[ ocwd ]}).slice(0,-13)
+    } catch (err) { throw `Error: No such folder or package: '${cwd}'` }
+    log (`cd ${relative(ocwd,cwd)}`)
+  }
+  else cwd = cds.root
+
+  log (`\n${t.bold}cds ${args.join(' ')}`)
+
+  const env = Object.assign (process.env, {
     _args: JSON.stringify(args),
     _options: JSON.stringify(options)
   })
   if (process.env.CDS_TYPESCRIPT === 'ts-node' || process.env.CDS_TYPESCRIPT === 'true') {
     // Needed by ts-node/tsc to find the tsconfig.json. Same as `--project`.
-    env.TS_NODE_PROJECT = env.TS_NODE_PROJECT ?? _cwd
+    env.TS_NODE_PROJECT ??= cwd
   }
 
   // if sap/cds is not installed locally, run with cds-dk's deps. (sap/cds, sqlite etc)
-  if (!installed('@sap/cds', _cwd)) {
-    env.NODE_PATH = [...paths(_cwd), ...paths(__dirname)].join(delimiter)
+  if (!installed('@sap/cds', cwd)) {
+    env.NODE_PATH = [...paths(cwd), ...paths(__dirname)].join(delimiter)
   }
 
-  if (typeof ext !== 'string')  ext = extDefaults
   const delay = parseInt(process.env.CDS_WATCH_DELAY) || 200
+  const escapedRegex = s => s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
+  const resolved = p => resolve(cwd, p)
+  const excludedPaths = excluded.map(resolved).map(escapedRegex)
+  const ignore = excluded.length
+    ? new RegExp(ignoreDefaults.map(d => d.source).concat(excludedPaths).join('|'))
+    : new RegExp(ignoreDefaults.map(d => d.source).join('|'))
+  const watched = [ cwd, ...included.map(resolved) ]
 
   let liveReload //= ...
-  let firstTime = true
-  if (!/false|no/.test(options['livereload']) && cds.env.for('cds', _cwd).livereload !== false) {
+  if (!/false|no/.test(options.livereload)) {
+    log ('( live reload enabled for browsers )')
     liveReload = new (require ('../lib/watch/livereload-server'))
     env.CDS_LIVERELOAD_PATH = require.resolve ('../lib/watch/livereload-connect')
     env.CDS_LIVERELOAD_URL = await liveReload.start (options['livereload'], cwd, delay)
       .catch(err => { console.log(`Error starting live reload: ${err.message}`); liveReload = null })
   }
 
-  const log = (first,...more) => console.log (t.yellow + (first||''), ...more, t.reset)
-  if (cwd) {
-    const ocwd = process.env._original_cwd = process.cwd()
-    if (fs.existsSync(cwd)) log (`cd ${cwd}`)
-    else try {
-      const resolved = dirname (require.resolve(cwd+'/package.json', {paths:[ocwd]}))
-      log (`cd ${relative(ocwd,cwd = resolved)}`)
-    } catch(_){ throw new Error(`No such folder or package: '${ocwd}' -> '${cwd}'`) }
-  }
-  log ()
-  log (`${t.bold}cds ${args.join(' ')}`)
-  const escapedRegex = s => s.replace(/[-/\\^$*+?.()|[\]{}]/g, '\\$&')
-  const resolved = p => resolve(_cwd, p)
-  const excludedPaths = excluded.map(resolved).map(escapedRegex)
-  const ignore = excluded.length
-    ? new RegExp(ignoreDefaults.map(d => d.source).concat(excludedPaths).join('|'))
-    : new RegExp(ignoreDefaults.map(d => d.source).join('|'))
-  const watched = [ _cwd, ...included.map(resolved) ]
-  if (DEBUG._debug) {
-    console.log(`\nwatching (pid ${process.pid})`, {
-      extensions:ext, roots:watched, ignoring: [...excludedPaths.map(s => new RegExp(s)), ...ignoreDefaults]
-    })
-  }
-  if (liveReload) console.log (`live reload enabled for browsers`)
+  DEBUG && DEBUG('watching:', {
+    pid: process.pid,
+    folders: watched,
+    extensions: ext,
+    ignoring: [ ...excludedPaths.map(s => new RegExp(s)), ...ignoreDefaults ]
+  })
 
-  const { bindingEnv, updateBindings } = require('../lib/bind/shared')
-  Object.assign(env, await bindingEnv({cwd}))
+  if (process.argv.includes('--profile') || process.env.CDS_ENV) {
+    const bind = require('../lib/bind/shared')
+    Object.assign(env, await bind.env({cwd}))
+  }
 
   const nodemon = require('../lib/watch/node-watch')
   const watcher = nodemon ({
@@ -179,23 +172,12 @@ async function watch ([cwd], {
   }).on('restart', (files)=>{
     log (`\n${t.bold}        ___________________________\n`)
     if (liveReload) liveReload.markPending(files)
-    if (this.delayed) clearTimeout (this.delayed)
-    this.delayed = setTimeout(()=>{
-      updateBindings({
-        onBeforeUpdate: () => watcher.stop(),
-        onAfterUpdate: ({env}) => {
-          Object.keys(env).forEach( name => watcher.setEnv(name, env[name]) )
-          watcher.restart()
-        }
-      })
-      FileHandlers.changed (files,cwd)
-    }, 111) .unref()
   }).on('message', async (msg) => { switch (msg.code) { // messages from child process
     case 'listening':
-      env.PORT = (msg.address && msg.address.port) || msg.port
-      liveReload && liveReload.reload()
-      firstTime && options['open'] && require('../lib/watch/open').openURL (options['open'], env.PORT)
-      firstTime = false
+      env.PORT = msg.address?.port || msg.port
+      if (options.open) require('../lib/watch/open').openURL (options.open, env.PORT)
+      else liveReload?.reload()
+      delete options.open
       break
     case 'EADDRINUSE': env.PORT = 0; _addr_in_use(msg); break
     default: console.error (msg)

package/lib/bind/cf.js

@@ -1,4 +1,5 @@
 const cds = require('../cds');
+const { merge } = cds.utils
 const DEBUG = cds.log('cli')._debug
 const cf = require('../util/cf');
 const { bold } = require('../util/term');
@@ -127,7 +128,7 @@ module.exports = new class CFBind extends require('./plugin') {
                     tags: instanceObj.tags
                 }
             },
-            credentials: mergeCredentials(credentials, customCredentials)
+            credentials: merge?.(credentials, customCredentials) ?? mergeCredentials(credentials, customCredentials)
         };
         return resolvedBinding;
     }

package/lib/bind/k8s.js

@@ -1,5 +1,5 @@
 const { execSync } = require('node:child_process')
-const { yaml } = require('../cds').utils
+const { yaml, merge } = require('../cds').utils
 const { mergeCredentials } = require('./shared')
 const { bold } = require('../util/term')
 
@@ -72,7 +72,7 @@ module.exports = new class K8SBind extends require('./plugin') {
         cluster, instance, namespace, secret,
         vcap
       },
-      credentials: mergeCredentials(credentials, customCredentials)
+      credentials: merge?.(credentials, customCredentials) ?? mergeCredentials(credentials, customCredentials)
     }
     return resolvedBinding
   }

package/lib/bind/plugin.js

@@ -1,7 +1,7 @@
 module.exports = class BindPlugin {
 
   /**
-   * Returns the display name of the binding plugin
+   * The product name used in the command line logs
    * @returns {string} The display name
    */
   displayName() {

package/lib/bind/shared.js

@@ -47,11 +47,15 @@ async function bind(options = { on: 'cf' }) {
             on = 'cf'
             break
         default:
-            throw `invalid value '${options.on}' for option --on.`
+            throw `invalid value '${options.on}' for option --on`
     }
+
+    /** @type {import('./plugin')} */
     const plugin = require(`./${on}`)
 
-    if (!options['to-app-services']) console.log(`retrieving data from ${bold(plugin.displayName())}...`)
+    if (!options['to-app-services']) {
+        console.log(`retrieving data from ${bold(plugin.displayName())}...`)
+    }
 
     const services = options.to.split(/,/g)
     const resolvedServices = await Promise.all(services.map(async service => {
@@ -116,6 +120,7 @@ async function storeBindings(resolvedServices, options) {
     console.log(`saving bindings to ${bold(jsonPath)} in profile ${bold(options.for)}`)
 }
 
+// MAJOR: Remove when cds 8 support is dropped
 function mergeCredentials(credentials, customCredentials) {
     if (!customCredentials) return credentials
     for (const key in customCredentials) {
@@ -134,28 +139,13 @@ function mergeCredentials(credentials, customCredentials) {
     return credentials
 }
 
-async function bindingEnv(options) {
+async function env(options) {
     const bindings = _getUnresolvedBindings(options)
     const resolvedBindings = await _resolveBindings({ ...options, bindings, cache: {} })
     return resolvedBindings ? { VCAP_SERVICES: _toVcapServices(resolvedBindings) } : undefined
 }
 
-async function updateBindings(options, { onBeforeUpdate, onAfterUpdate } = {}) {
-    const bindings = _getUnresolvedBindings(options)
-    if (onBeforeUpdate) await onBeforeUpdate()
-    let resolvedBindings
-    try {
-        resolvedBindings = await _resolveBindings({ ...options, bindings, cache: {} })
-    } catch (error) {
-        console.error(error.message) // REVISIT: Why not throw here?
-        return
-    }
-    const env = resolvedBindings ? { VCAP_SERVICES: _toVcapServices(resolvedBindings) } : { VCAP_SERVICES: '{}' }
-    if (onAfterUpdate) await onAfterUpdate({ bindings: resolvedBindings, env })
-    return { bindings: resolvedBindings, env }
-}
-
-module.exports = { bind, storeBindings, mergeCredentials, bindingEnv, updateBindings }
+module.exports = { bind, storeBindings, mergeCredentials, env }
 
 /* Private helpers */
 
@@ -185,8 +175,7 @@ function _determineKinds(services) {
     }
 
      // Auto configure services based on VCAP_SERVICES
-    const cds = require('../cds')
-    const env = cds.env.for('cds', process.cwd())
+    const env = _getEnv (process.cwd())
     if (!env._find_credentials_for_required_service) { // REVISIT: Proper API
         throw new Error(`Please provide a service kind or update @sap/cds version to use the kind detection.`)
     }
@@ -210,10 +199,11 @@ function _determineKinds(services) {
     }
 }
 
-function _getUnresolvedBindings({ cwd = process.cwd(), env } = {}) {
-    if (!env) {
-        env = cds.env.for('cds', path.resolve(cwd)) // REVISIT: This might load cds.env too early!
-    }
+function _getEnv (cwd) {
+    return _getEnv.cached ??= cwd === cds.root ? cds.env : cds.env.for('cds', path.resolve(cwd))
+}
+
+function _getUnresolvedBindings({ cwd = process.cwd(), env = _getEnv(cwd) } = {}) {
     const bindings = {}
     const requires = env.requires || {}
     for (const name in requires) {
@@ -246,6 +236,7 @@ async function _resolveBindings({ bindings, cwd = process.cwd(), env, cache = {}
 }
 
 function _toVcapServices(bindings) {
+    if (!bindings) return '{}'
     const services = {}
     for (const name in bindings) {
         const { binding, credentials } = bindings[name]

package/lib/build/buildTaskEngine.js

@@ -1,9 +1,11 @@
+// @ts-check
 const fs = require('node:fs')
 const path = require('node:path')
 const { inspect } = require('node:util')
+// @ts-expect-error - _log not declared in cds-types
 const cds = require('../cds'), { _log: log } = cds
 const { sortMessagesSeverityAware, deduplicateMessages, CompilationError } = cds.compiler
-const { relativePaths, BuildError, BuildMessage, resolveRequiredSapModels, redactCredentials } = require('./util')
+const { relativePaths, BuildError, BuildMessage, resolveRequiredSapModels } = require('./util')
 const { SEVERITIES, LOG_LEVELS } = require('./constants')
 const BuildTaskFactory = require('./buildTaskFactory')
 const InternalBuildPlugin = require('./provider/internalBuildPlugin')
@@ -11,8 +13,6 @@ const COMPILATION_ERROR = 'CompilationError'
 const COMPILE_MESSAGE = 'CompileMessage'
 const DEBUG = cds.debug('cli|build')
 const LOG_LIMIT = 30
-// TODO replace with cds.utils.clors.colors.enabled in cds-dk 9
-const colors = process.stdout.isTTY && !process.env.NO_COLOR || process.env.FORCE_COLOR
 
 class BuildTaskEngine {
     constructor(options) {
@@ -34,10 +34,7 @@ class BuildTaskEngine {
             target: cds.env.build.target,
             tasks: tasks.map(({ _uses, ...task }) => task),
             ...(!this.options.clean && { clean: this.options.clean }),
-        }, { depth: 11, colors, compact: 3, breakLength: 250 }))
-
-        DEBUG?.("cds configuration settings:")
-        DEBUG?.(redactCredentials(cds.env))
+        }, { depth: 11, colors: cds.utils.colors.enabled, compact: 3, breakLength: 250 }))
 
         // validate required @sap namespace models - log only
         const unresolved = BuildTaskEngine._resolveRequiredSapServices(tasks)
@@ -77,6 +74,7 @@ class BuildTaskEngine {
      * Plugin#prepare has been deprecated and was never part of the public API.
      * Currently only used by internal FioriBuildPlugin.
      * @deprecated
+     * @private
      * @param {*} plugins
      * @returns
      */
@@ -97,6 +95,7 @@ class BuildTaskEngine {
 
     /**
      * @deprecated
+     * @private
      * @param {*} pluginGroup
      */
     async _doPrepare(pluginGroup) {
@@ -112,6 +111,7 @@ class BuildTaskEngine {
         }
     }
 
+    /** @private */
     async _executeCleanBuildTasks(plugins) {
         if (this.options.clean) {
             // clean entire build staging folder once
@@ -130,6 +130,7 @@ class BuildTaskEngine {
         }
     }
 
+    /** @private */
     async _executeBuildTasks(plugins) {
         // sort plugins based on priority in
         plugins = plugins.sort((a, b) => {
@@ -156,6 +157,7 @@ class BuildTaskEngine {
         return this._resolveHandlerResponse(results, BuildTaskEngine._getMessages(plugins))
     }
 
+    /** @private */
     async _executePipeline(pipeline) {
         let allResults = []
         for (const group of pipeline) {
@@ -175,7 +177,9 @@ class BuildTaskEngine {
         return allResults
     }
 
+    /** @private */
     _resolveHandlerResponse(results, pluginMessages = []) {
+        /** @type {BuildError[]}*/
         const errors = []
         const resolvedResults = results.reduce((acc, r) => {
             if (r.status === 'fulfilled') {
@@ -207,6 +211,7 @@ class BuildTaskEngine {
         return resolvedResults
     }
 
+    /** @private */
     _createPlugin(task) {
         const plugin = this.taskFactory.createPlugin(task)
         plugin.init()
@@ -224,6 +229,7 @@ The higher the value the earlier the plugin is run.`
         return plugin
     }
 
+    /** @private */
     _logOutput(plugins) {
         // log all generated files
         const files = BuildTaskEngine._getOutput(plugins)
@@ -238,6 +244,7 @@ The higher the value the earlier the plugin is run.`
         }
     }
 
+    /** @private */
     async _writeGenerationLog(plugins) {
         const outputFile = cds.env.build.outputfile || process.env.GENERATION_LOG
         if (outputFile) {
@@ -253,6 +260,7 @@ The higher the value the earlier the plugin is run.`
         }
     }
 
+    /** @private */
     static _getOutput(plugins) {
         const files = plugins.reduce((acc, plugin) => acc.concat(plugin.files), []).sort()
         return files.map(file => {
@@ -263,15 +271,18 @@ The higher the value the earlier the plugin is run.`
         })
     }
 
+    /** @private */
     _logTimer(start, end) {
         console.log(`build completed in ${end - start} ms`)
     }
 
+    /** @private */
     _logTaskHandler(plugin) {
         DEBUG?.(`plugin ${plugin.constructor.name}`)
         DEBUG?.(`details src [${relativePaths(cds.root, plugin.task.src)}], dest [${relativePaths(cds.root, plugin.task.dest)}], options [${JSON.stringify(plugin.task.options)}]`)
     }
 
+    /** @private */
     _logMessages(messages) {
         if (messages.length > 0) {
             const options = {
@@ -284,6 +295,7 @@ The higher the value the earlier the plugin is run.`
         }
     }
 
+    /** @private */
     static _resolveRequiredSapServices(tasks) {
         const taskModelPaths = tasks.reduce((acc, task) => {
             const model = task.options?.model
@@ -302,13 +314,14 @@ The higher the value the earlier the plugin is run.`
 
     /**
      * Returns a sorted and flattened list of all messages extracted from the given errors.
-     * @param {Array<Error>} errors
+     * @private
+     * @param {(string | BuildError)[]} errors
      */
     static _getErrorMessages(errors) {
         let messages = []
         // flatten all compile messages in order to filter duplicates and sort later on
         errors.forEach(error => {
-            if (Array.isArray(error.errors) && error.errors.length > 0) {
+            if (typeof error !== 'string' && Array.isArray(error.errors) && error.errors.length > 0) {
                 messages = messages.concat(this._getErrorMessages(error.errors))
             } else {
                 messages.push(error)
@@ -329,7 +342,8 @@ The higher the value the earlier the plugin is run.`
      * Sort and filter the given errors of type CompileMessage or BuildMessage according to their severity and location,
      * but leave any other errors untouched as part of the result array.<br>
      * The log level ('command line' or 'cds.env' option) is used to filter the given messages.
-     * @param  {...Error} messages
+     * @private
+     * @param  {...{[key:string]: any, severity?: import('./constants').Severity}} messages
      */
     _sortMessagesUnique(...messages) {
         const logLevelIdx = LOG_LEVELS.indexOf(this._getLogLevel())
@@ -338,8 +352,10 @@ The higher the value the earlier the plugin is run.`
         // filter according to log-level
         const filteredMessages = messages.filter(message => message && (!message.severity || logLevelIdx >= SEVERITIES.indexOf(message.severity)))
         // remove duplicates
+        // @ts-expect-error - formally expects CompileMessage, but actually, an .severity is the only expected property
         deduplicateMessages(filteredMessages)
         // sort
+        // @ts-expect-error - see above
         return sortMessagesSeverityAware(filteredMessages)
     }
 

package/lib/build/buildTaskFactory.js

@@ -1,3 +1,4 @@
+// @ts-check
 const fs = require('fs')
 const path = require('path')
 const cds = require('../cds')
@@ -70,7 +71,7 @@ class BuildTaskFactory {
         // obligatory task defaults shared by all tasks
         await BuildTaskFactory._applyCommonTaskDefaults(tasks)
 
-        BuildTaskFactory._setDefaultBuildTargetFolder(tasks)
+        BuildTaskFactory._setDefaultBuildTargetFolder()
         return tasks
     }
 
@@ -212,7 +213,7 @@ class BuildTaskFactory {
             if (!acc) {
                 let resourcePath = path.resolve(cds.root, resource)
                 if (fs.existsSync(resourcePath)) {
-                    if (fs.lstatSync(resourcePath).isDirectory()) {
+                    if (cds.utils.isdir(resourcePath)) {
                         acc = resource
                     } else {
                         // represents file

package/lib/build/buildTaskProvider.js

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

package/lib/build/buildTaskProviderFactory.js

@@ -1,3 +1,4 @@
+// @ts-check
 const fs = require('fs')
 const path = require('path')
 const cds = require('../cds')
@@ -7,7 +8,25 @@ const BuildTaskProvider = require('./buildTaskProvider')
 const { BuildError, normalizePath } = require('./util')
 const DEBUG = cds.debug('cli|build')
 
+/** 
+ * @typedef {{
+ *  clean?: boolean,
+ *  outputMode?: number,
+ *  for?: string,
+ *  src?: string,
+ *  dest?: string,
+ * } & {[key:string]:unknown}} BuildTaskProviderFactoryOptions
+ */
+
+/**
+ * TODO
+ * @typedef {object} Task
+ */
+
 class BuildTaskProviderFactory {
+    /**
+     * @param {BuildTaskProviderFactoryOptions} options - build options
+     */
     constructor(options = {}) {
         options.outputMode = options.outputMode || OUTPUT_MODE_FILESYSTEM
         if (options.clean === undefined) {
@@ -24,6 +43,7 @@ class BuildTaskProviderFactory {
                 }
             }
         })
+        /** @type {{ options: BuildTaskProviderFactoryOptions, tasks: Task}} */
         this._context = { options, tasks: [] } // resolved tasks
     }
     get options() {
@@ -53,8 +73,7 @@ class BuildTaskProviderFactory {
     }
 
     async lookupTasks(tasks = [], dependencies) {
-        for (let i = 0; i < this.providers.length; i++) {
-            const provider = this.providers[i]
+        for (const provider of this.providers) {
             const existingTasks = [...tasks]
             await this._lookupTasks(provider, tasks, dependencies)
             if (existingTasks.length < tasks.length) {
@@ -70,7 +89,7 @@ class BuildTaskProviderFactory {
     /**
      * 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
+     * @param {Task} task
      */
     createPlugin(task) {
         const Plugin = this.getPlugin(task)
@@ -92,7 +111,7 @@ class BuildTaskProviderFactory {
      * 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
+     * @param {Task} task
      */
     getPlugin(task) {
         const provider = this._getProvider(task)
@@ -104,6 +123,9 @@ class BuildTaskProviderFactory {
         }
     }
 
+    /**
+     * @param {Task[]} tasks
+     */
     resolveTasks(tasks) {
         return tasks.map(task => this._resolveTask(task))
     }
@@ -111,7 +133,8 @@ class BuildTaskProviderFactory {
     /**
      * 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.
-     * @param {*} task
+     * @private
+     * @param {Task} task
      */
     _resolveTask(task) {
         // second validate src path
@@ -126,7 +149,7 @@ class BuildTaskProviderFactory {
             try {
                 //validate source path
                 fs.realpathSync(resolvedTask.src)
-            } catch (e) {
+            } catch {
                 throw new BuildError(`The 'src' folder '${path.resolve(cds.root, task.src)}' for build task '${resolvedTask.for}' does not exist`)
             }
         }
@@ -170,15 +193,14 @@ class BuildTaskProviderFactory {
  * Default provider implementation handling fully qualified custom build task declarations.
  */
 class PluginBuildTaskProvider extends BuildTaskProvider {
-    constructor() {
-        super()
-        this._plugins = require('./plugins').plugins
-    }
-
+    #plugins = require('./plugins').plugins
     get plugins() {
-        return this._plugins
+        return this.#plugins
     }
 
+    /**
+     * @param {{for: string}} key
+     */
     providesTask(key) {
         return this.plugins.has(key.for)
     }
@@ -207,7 +229,7 @@ class PluginBuildTaskProvider extends BuildTaskProvider {
 
     getTask(key) {
         // plugin entry is already validated, a taskDefaults default member exists
-        const task = JSON.parse(JSON.stringify(this.plugins.get(key.for).taskDefaults ?? {}))
+        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(/\/$/, '')

package/lib/build/constants.js

@@ -61,3 +61,7 @@ exports.LOG_LEVEL_WARN = "warn"
 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]
+
+/**
+ * @typedef {'Error' | 'Warning' | 'Info' | 'Debug'} Severity
+ **/