@sap/cds 6.8.4 → 7.0.1

package/app/fiori/preview.js

@@ -1,270 +0,0 @@
-const cds = require('../../lib')
-cds.on('served', ()=>{
-
-  const { app, env, service:{providers} } = cds
-
-  const mountPoint = '/$fiori-preview'
-  const appID = 'preview-app'
-  const _appURL = (srv, entity) => `${mountPoint}/${srv}/${entity}#${appID}`
-  const _componentURL = (srv, entity) => `${mountPoint}/${srv}/${entity}/app`
-
-  function _manifest(serviceName, entityName) {
-    const [serviceProv, serviceInfo] = _validate(serviceName, entityName)
-    const listPageInitialLoad = (env.preview && env.preview.fiori && env.preview.fiori.initialload !== undefined)
-      ? env.preview.fiori.initialload
-      : true
-    const manifest = {
-      _version: '1.8.0',
-      'sap.app': {
-        id: 'preview',
-        type: 'application',
-        title: `Preview ‒ List of ${serviceProv.name}.${entityName}`,
-        description: 'Preview Application',
-        dataSources: {
-          mainService: {
-            uri: `${serviceProv.path}/`,
-            type: 'OData',
-            settings: {
-              odataVersion: '4.0'
-            }
-          }
-        },
-      },
-      'sap.ui5': {
-        flexEnabled: true,
-        dependencies: {
-          minUI5Version: '1.96.0',
-          libs: {
-            'sap.ui.core': {},
-            'sap.fe.templates': {}
-          }
-        },
-        models: {
-          '': {
-            dataSource: 'mainService',
-            settings: {
-              synchronizationMode: 'None',
-              operationMode: 'Server',
-              autoExpandSelect: true,
-              earlyRequests: true,
-              groupProperties: {
-                default: {
-                  submit: 'Auto'
-                }
-              }
-            }
-          }
-        },
-        routing: {
-          routes: [
-            {
-              name: `${entityName}ListRoute`,
-              target: `${entityName}ListTarget`,
-              pattern: ':?query:',
-            },
-            {
-              name: `${entityName}DetailsRoute`,
-              target: `${entityName}DetailsTarget`,
-              pattern: `${entityName}({key}):?query:`,
-            }
-          ],
-          targets: {
-            [`${entityName}ListTarget`]: {
-              type: 'Component',
-              id: `${entityName}ListTarget`,
-              name: 'sap.fe.templates.ListReport',
-              options: {
-                settings: {
-                  entitySet: `${entityName}`,
-                  initialLoad: listPageInitialLoad,
-                  navigation: {
-                    [`${entityName}`]: {
-                      detail: {
-                        route: `${entityName}DetailsRoute`
-                      }
-                    }
-                  }
-                }
-              }
-            },
-            [`${entityName}DetailsTarget`]: {
-              type: 'Component',
-              id: `${entityName}DetailsTarget`,
-              name: 'sap.fe.templates.ObjectPage',
-              options: {
-                settings: {
-                  entitySet: `${entityName}`,
-                  navigation: {}
-                }
-              }
-            }
-          }
-        },
-      },
-      contentDensities: {
-        compact: true,
-        cozy: true
-      },
-      'sap.ui': {
-        technology: 'UI5',
-        fullWidth: true,
-        deviceTypes: {
-          desktop: true,
-          tablet: true,
-          phone: true
-        }
-      },
-      'sap.fiori': {
-        registrationIds: [],
-        archeType: 'transactional'
-      },
-    }
-
-    const { routing } = manifest['sap.ui5']
-    for (const {navProperty, targetEntity} of serviceInfo) {
-      // add a route for the navigation property
-      routing.routes.push(
-        {
-          name: `${navProperty}Route`,
-          target: `${navProperty}Target`,
-          pattern: `${entityName}({key})/${navProperty}({key2}):?query:`,
-        }
-      )
-      // add a route target leading to the target entity
-      routing.targets[`${navProperty}Target`] = {
-        type: 'Component',
-        id: `${navProperty}Target`,
-        name: 'sap.fe.templates.ObjectPage',
-        options: {
-          settings: {
-            entitySet: targetEntity
-          }
-        }
-      }
-      // wire the new route from the source entity's navigation (see above)
-      routing.targets[`${entityName}DetailsTarget`].options.settings.navigation[navProperty] = {
-        detail: {
-          route: `${navProperty}Route`
-        }
-      }
-    }
-
-    return manifest
-  }
-
-  function _html(serviceName, entityName) {
-    _validate(serviceName, entityName)
-    let ui5Version = (env.preview && env.preview.ui5 && env.preview.ui5.version) || ''
-    let ui5Host = (env.preview && env.preview.ui5 && env.preview.ui5.host) || `https://sapui5.hana.ondemand.com/${ui5Version}`
-    if (!ui5Host.endsWith('/'))  ui5Host += '/'
-
-    // copied from UI5's test-resources/sap/ushell/shells/sandbox/fioriSandbox.html
-    return `
-  <!DOCTYPE html>
-  <html>
-  <head>
-      <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-      <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
-      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-      <title>Preview for ${serviceName}.${entityName}</title>
-      <script>
-        window["sap-ushell-config"] = {
-          defaultRenderer: "fiori2",
-          applications: {
-            "${appID}": {
-              title: "Browse ${entityName}",
-              description: "from ${serviceName}",
-              additionalInformation: "SAPUI5.Component=app",
-              applicationType : "URL",
-              url: "${_componentURL(serviceName, entityName)}",
-              navigationMode: "embedded"
-            }
-          }
-        }
-      </script>
-      <script id="sap-ushell-bootstrap" src="${ui5Host}test-resources/sap/ushell/bootstrap/sandbox.js"></script>
-      <script id="sap-ui-bootstrap" src="${ui5Host}resources/sap-ui-core.js"
-      data-sap-ui-theme="sap_horizon"
-      data-sap-ui-oninit="module:sap/ui/core/ComponentSupport"
-      data-sap-ui-compatVersion="edge"
-      data-sap-ui-async="true"
-      data-sap-ui-preload="async"></script>
-      <script>
-          sap.ui.getCore().attachInit(function() { sap.ushell.Container.createRenderer().placeAt("content") })
-      </script>
-  </head>
-  <body class="sapUiBody sapUiSizeCompact" id="content"></body>
-  </html>
-  `
-  }
-
-  function _componentJs(serviceName, entityName) {
-    const manifest = _manifest(serviceName, entityName)
-    return `sap.ui.define(["sap/fe/core/AppComponent"], function(AppComponent) {
-      "use strict";
-      return AppComponent.extend("preview.Component", {
-        metadata: { manifest: ${JSON.stringify(manifest, null, 2)} }
-      });
-    });`
-  }
-
-  function _validate(serviceName, entityName) {
-    const serviceProv = providers.find (s => s.name === serviceName)
-    if (!serviceProv)  throw _badRequest (`No such service '${serviceName}'. Available: [${providers.map(p => p.name)}]`)
-    return _serviceInfo (serviceProv, entityName)
-  }
-
-  function _serviceInfo (serviceProv, entityName) {
-    const entities = serviceProv.model.entities(serviceProv.name)
-    const entity = entities[entityName]
-    if (!entity)  throw _badRequest (`No such entity '${entityName}' in service '${serviceProv.name}'`)
-    return [serviceProv, serviceProv.model.all ('Association', entity.elements)
-      .filter (a =>
-          !a.target.endsWith('.texts') &&
-          !a.target.endsWith('_texts') &&
-          !a.target.endsWith('DraftAdministrativeData') &&
-          a.name !== 'SiblingEntity')
-      .map (a => { return { navProperty: a.name, targetEntity: a.target.split('.')[1] } })
-    ]
-  }
-
-  const _badRequest = (message) => { const err = new Error (message); err.statusCode = 400; return err}
-
-
-  // fetch and instrument all OData providers
-  const any = providers.filter (srv =>
-    srv._adapters && srv._adapters [Object.keys(srv._adapters) .find (a => a.startsWith ('odata'))]
-  )
-  .map(srv => {
-    // called from ../index.js to provide the data for the HTML link
-    const link = linkProvider(srv)
-    srv.$linkProviders ? srv.$linkProviders.push (link) : srv.$linkProviders = [link]
-    return link
-  })
-  .length
-
-
-  // install middlewares once
-  if (any) {
-    // eslint-disable-next-line cds/no-missing-dependencies
-    const router = require('express').Router()
-    // UI5 component
-    router.get ('/:service/:entity/app/Component.js', ({ params }, resp) => resp.send(_componentJs(params.service, params.entity)))
-    // html
-    router.get ('/:service/:entity', ({ params }, resp) => resp.send(_html(params.service, params.entity)))
-
-    app.use(mountPoint.replace('$','\\$'), router)
-  }
-
-  function linkProvider(service) {
-    return (entity) => {
-      if (!entity)  return
-      return {
-        href: _appURL(service.name, entity),
-        title: 'Preview in Fiori elements',
-        name: 'Fiori preview'
-      }
-    }
-  }
-
-})

package/app/fiori/routes.js

@@ -1,59 +0,0 @@
-const cds = require('../../lib')
-const DEBUG = cds.debug('fiori/routes')
-const {dirname, relative, join} = require('path')
-
-// Only for local cds runs w/o approuter:
-// If there is a relative URL in UI5's manifest.json for the datasource,
-// like 'browse/' or 'prefix/browse/', we get called with a prefix to the
-// service path, like '/browse/webapp/browse/'.
-// Serve these requests by redirecting to the actual service URL.
-cds.on ('bootstrap', app => {
-
-  const { env, utils:{find,fs}} = cds
-  const v2Prefix = (env.odata.v2proxy && env.odata.v2proxy.urlpath) || '/v2'
-  const serviceForUri = {}
-
-  dataSourceURIs (env.folders.app).forEach(({appPath, dataSourceUri}) => {
-    const uiRoutes = [
-      join('/', appPath,      dataSourceUri, '*'), //  /uiApp/webapp/browse/*
-      join('/', appPath, '*', dataSourceUri, '*')  //  /uiApp/webapp/*/browse/*
-    ].map(r => r.replace(/\\/g, '/')) // handle Windows \
-    DEBUG && DEBUG ('Register routes', uiRoutes)
-
-    app.use(uiRoutes, ({originalUrl}, res, next)=> {
-      // any of our special URLs ($fiori-, $api-docs) ? -> next
-      if (originalUrl.startsWith('/$'))  return next()
-
-      // is there a service for '[prefix]/browse' ?
-      const srv = serviceForUri[dataSourceUri] || (serviceForUri[dataSourceUri] =
-        cds.service.providers.find (srv => ('/'+dataSourceUri).lastIndexOf(srv.path) >=0))
-      if (srv) {
-        let redirectUrl
-        // odata-proxy may be in the line with its /v2 prefix.  Make sure we retain it.
-        const v2Index = originalUrl.lastIndexOf(v2Prefix+srv.path)
-        if (v2Index >= 0)  // --> /browse/webapp[/prefix]/v2/browse/ -> /v2/browse
-          redirectUrl = originalUrl.substring(v2Index)
-        else // --> /browse/webapp[/prefix]/browse/ -> /browse
-          redirectUrl = originalUrl.substring(originalUrl.lastIndexOf(srv.path+'/'))
-        if (originalUrl !== redirectUrl)  {// safeguard to prevent running in loops
-          DEBUG && DEBUG ('Redirecting', {src: originalUrl}, '~>', {target: redirectUrl})
-          return res.redirect (308, redirectUrl)
-        }
-      }
-      next()
-    })
-  })
-
-  function dataSourceURIs (dir) {
-    const uris = new Set()
-    find (dir, ['*/manifest.json', '*/*/manifest.json']).forEach(file => {
-      const appPath = relative(join(cds.root, dir), dirname(file))
-      const {dataSources: ds} = JSON.parse(fs.readFileSync(file))['sap.app'] || {}
-      Object.keys (ds||[])
-        .filter (k => ds[k].uri && !ds[k].uri.startsWith('/')) // only consider relative URLs)
-        .forEach(k => uris.add({ appPath, dataSourceUri: ds[k].uri }))
-    })
-    return uris
-  }
-
-})

package/bin/build/buildTaskEngine.js

@@ -1,360 +0,0 @@
-const fs = require('fs')
-const path = require('path')
-const cds = require('./cds'), { log } = cds.exec
-const { sortMessagesSeverityAware, deduplicateMessages, CompilationError } = require('@sap/cds-compiler')
-const { relativePaths, BuildError, BuildMessage, resolveRequiredSapModels } = require('./util')
-const { OUTPUT_MODE_DEFAULT, SEVERITIES, LOG_LEVELS, LOG_MODULE_NAMES } = require('./constants')
-const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
-const BuildTaskHandlerInternal = require('./provider/buildTaskHandlerInternal')
-
-const COMPILATION_ERROR = 'CompilationError'
-const COMPILE_MESSAGE = 'CompileMessage'
-
-class BuildTaskEngine {
-    constructor(logger) {
-        this._logger = logger || cds.log(LOG_MODULE_NAMES)
-    }
-    get logger() {
-        return this._logger
-    }
-
-    async processTasks(tasks, buildOptions, clean = true) {
-        const startTime = Date.now()
-        const messages = []
-
-        if (buildOptions) {
-            // clone as data may be stored as part of the buildOptions object
-            buildOptions = JSON.parse(JSON.stringify(buildOptions))
-        } else {
-            buildOptions = {
-                root: process.env._TEST_CWD || process.cwd()
-            }
-        }
-        if (!buildOptions.outputMode) {
-            buildOptions.outputMode = OUTPUT_MODE_DEFAULT
-        }
-
-        this.logger.log(`building project [${buildOptions.root}], clean [${clean}]`)
-        this.logger.log(`cds [${cds.version}], compiler [${cds.compiler.version()}], home [${cds.home}]\n`)
-
-        if (!buildOptions.target) {
-            buildOptions.target = path.resolve(buildOptions.root, cds.env.build.target)
-        }
-
-        // validate required @sap namespace models - log only
-        const unresolved = BuildTaskEngine._resolveRequiredSapServices(tasks)
-        if (unresolved.length > 0) {
-            messages.push(new BuildMessage(`Required CDS models [${unresolved.join(', ')}] cannot be resolved. Make sure up-to-date versions of the missing modules are installed.`))
-        }
-
-        // create build task handlers
-        const handlers = []
-        tasks.forEach((task) => {
-            if (task) {
-                const handler = this._createHandler(task, buildOptions)
-                handlers.push(handler)
-            }
-        })
-
-        // use resolved tasks
-        buildOptions.tasks = handlers.map(handler => handler.task)
-
-        try {
-            await this._executePrepare(handlers, buildOptions)
-            await this._executeCleanBuildTasks(handlers, buildOptions, clean)
-
-            // throwing Exception in case of compilation errors
-            const buildResult = await this._executeBuildTasks(handlers, buildOptions)
-
-            await this._writeGenerationLog(handlers, buildOptions)
-            this._logBuildOutput(handlers, buildOptions)
-            this._logMessages(buildOptions, [...BuildTaskEngine._getHandlerMessages(handlers), ...messages])
-            this._logTimer(startTime, Date.now())
-
-            return buildResult
-        } catch (error) {
-            this._logBuildOutput(handlers, buildOptions)
-
-            // cds CLI layer logs in case of an exception if invoked from CLI
-            if (!buildOptions.cli) {
-                this._logMessages(buildOptions, [...BuildTaskEngine._getErrorMessages([error]), ...messages])
-            }
-
-            if (error.name === BuildError.name && error.errors.length > 0 && error.errors[0].constructor.name === COMPILATION_ERROR) {
-                // TODO: for compatibility reasons with cds-mtx we're throwing the actual cause of type CompiliationError
-                // Note: As a consequence we are loosing any info or warning messages issued by build task handlers
-                throw error.errors[0]
-            }
-            throw error
-        }
-    }
-
-    /**
-     * BuildTaskHandler#prepare has been deprecated and was never part of the public API.
-     * Currently only used by internal FioriBuildTaskHandller.
-     * @deprecated
-     * @param {*} handlers
-     * @returns
-     */
-    async _executePrepare(handlers, buildOptions) {
-        const handlerGroups = new Map()
-
-        // group handlers by type
-        handlers.forEach(handler => {
-            handlerGroups.has(handler.task.for) ? handlerGroups.get(handler.task.for).push(handler) : handlerGroups.set(handler.task.for, [handler])
-        })
-
-        const promises = []
-        for (let handlerGroup of handlerGroups.values()) {
-            promises.push(this._doPrepare(handlerGroup, buildOptions))
-        }
-        return Promise.all(promises)
-    }
-
-    /**
-     * @deprecated
-     * @param {*} handlerGroup
-     */
-    async _doPrepare(handlerGroup, buildOptions) {
-        for (let handler of handlerGroup) {
-            // prepare has been deprecated
-            if (handler instanceof BuildTaskHandlerInternal) {
-                this.logger._debug && this.logger.debug(`preparing, handler [${handler.constructor.name}], src [${relativePaths(buildOptions.root, handler.task.src)}]`)
-                const result = await handler.prepare()
-                if (result === false) {
-                    break
-                }
-            }
-        }
-    }
-
-    async _executeCleanBuildTasks(handlers, buildOptions, clean) {
-        if (clean) {
-            // clean entire build staging folder once
-            if (buildOptions.target !== buildOptions.root) {
-                this.logger._debug && this.logger.debug(`cleaning staging folder ${buildOptions.target}`)
-                await fs.promises.rm(buildOptions.target, { force: true, recursive: true })
-            }
-
-            const results = await Promise.allSettled(handlers.map((handler) => {
-                this.logger._debug && this.logger.debug(`cleaning, handler [${handler.constructor.name}], src [${relativePaths(buildOptions.root, handler.task.src)}]`)
-                return handler.clean()
-            }))
-            // check for errors and throw exception
-            BuildTaskEngine._resolveHandlerResponse(results, buildOptions)
-        }
-    }
-
-    async _executeBuildTasks(handlers, buildOptions) {
-        // sort handlers based on priority in
-        handlers = handlers.sort((a, b) => {
-            return a.priority === b.priority ? 0 : a.priority > b.priority ? -1 : 1
-        })
-        // group handlers with same priority in order to execute in parallel
-        const buildPipeline = handlers.reduce((acc, handler) => {
-            if (acc.length === 0) {
-                acc.push([handler])
-            } else {
-                const currGroup = acc[acc.length - 1]
-                if (currGroup[0].priority === handler.priority) {
-                    currGroup.push(handler)
-                } else {
-                    acc.push([handler])
-                }
-            }
-            return acc
-        }, [])
-
-        const results = await this._executePipeline(buildOptions, buildPipeline)
-
-        // check for errors and throw exception - return results otherwise including any compiler and build status messages
-        return BuildTaskEngine._resolveHandlerResponse(results, buildOptions, BuildTaskEngine._getHandlerMessages(handlers))
-    }
-
-    async _executePipeline(buildOptions, pipeline) {
-        let allResults = []
-        for (const group of pipeline) {
-            const results = await Promise.allSettled(group.map((handler) => {
-                this.logger._debug && this.logger.debug(`building, handler [${handler.constructor.name}], src [${relativePaths(buildOptions.root, handler.task.src)}]`)
-                return handler.build()
-                    .then(handlerResult => {
-                        return Promise.resolve({
-                            task: handler.task,
-                            result: handlerResult,
-                            messages: BuildTaskEngine._sortMessagesUnique(buildOptions, handler.messages)
-                        })
-                    })
-            }))
-            allResults = allResults.concat(results)
-        }
-        return allResults
-    }
-
-    static _resolveHandlerResponse(results, buildOptions, handlerMessages = []) {
-        const errors = []
-        const resolvedResults = results.reduce((acc, r) => {
-            if (r.status === 'fulfilled') {
-                acc.push(r.value)
-            }
-            if (r.status === 'rejected' && r.reason) {
-                errors.push(r.reason)
-            }
-            return acc
-        }, [])
-
-        if (errors.length > 0) {
-            const error = errors.find(e => e.constructor.name !== COMPILATION_ERROR)
-            if (error) {
-                // throw original error, including BuildErrors
-                // for BuildErrors we do not merge other build messages that might exist in order to keep the original error intact
-                throw error
-            }
-
-            // propagate existing CompilationErrors
-            // merge all existing compilation messages into a single CompilationError
-            // compiler warning and info messages are returned as handler messages
-            const compileErrors = errors.filter(e => e.constructor.name === COMPILATION_ERROR)
-            const compileMessages = handlerMessages.filter(message => message.constructor.name === COMPILE_MESSAGE)
-            if (compileErrors.length) {
-                throw new CompilationError(BuildTaskEngine._sortMessagesUnique(buildOptions, BuildTaskEngine._getErrorMessages(compileErrors), compileMessages))
-            }
-        }
-        return resolvedResults
-    }
-
-    _createHandler(task, buildOptions) {
-        try {
-            const providerFactory = new BuildTaskProviderFactory(this._logger, buildOptions)
-            const handler = providerFactory.createHandler(task)
-            handler.init()
-
-            if (!(handler instanceof BuildTaskHandlerInternal) && handler.priority !== 1) {
-                // Custom build handlers are executed before internal handlers to ensure
-                // that generated content cannot be overwriten by mistake
-                throw new Error(`Illegal priority for ${handler.consructor.name} encountered for custom handler - in this version only priority value '1' is allowed`)
-            }
-            this._logTaskHandler(handler, buildOptions)
-
-            return handler
-        } catch (error) {
-            log(error, { log: this.logger.log })
-            throw error
-        }
-    }
-
-    _logBuildOutput(handlers, buildOptions) {
-        // log all generated files
-        const files = BuildTaskEngine._getBuildOutput(handlers, buildOptions)
-        if (files.length > 0) {
-            this.logger.log(`done > wrote output to:\n   ${files.join("\n   ")}\n`)
-        }
-    }
-
-    async _writeGenerationLog(handlers, buildOptions) {
-        const outputFile = cds.env.build.outputfile || process.env.GENERATION_LOG
-        if (outputFile) {
-            const files = BuildTaskEngine._getBuildOutput(handlers, buildOptions)
-            this.logger.log(`writing generation log to [${outputFile}]\n`)
-            try {
-                await fs.promises.mkdir(path.dirname(outputFile), { recursive: true }).then(() => fs.promises.writeFile(outputFile, files.join('\n')))
-            } catch (error) {
-                this.logger.error(`failed to write generation log`)
-                this.logger.error(error.stack || error)
-            }
-        }
-    }
-
-    static _getBuildOutput(handlers, buildOptions) {
-        const files = handlers.reduce((acc, handler) => acc.concat(handler.files), []).sort()
-        return files.map(file => path.relative(buildOptions.root, file))
-    }
-
-    _logTimer(start, end) {
-        this.logger.log(`build completed in ${end - start} ms\n`)
-    }
-
-    _logTaskHandler(handler, buildOptions) {
-        this.logger._debug && this.logger.debug(`handler ${handler.constructor.name}`)
-        this.logger._debug && this.logger.debug(`details src [${relativePaths(buildOptions.root, handler.task.src)}], dest [${relativePaths(buildOptions.root, handler.task.dest)}], use [${handler.task.use}], options [${JSON.stringify(handler.task.options)}]`) //NOSONAR
-    }
-
-    _logMessages(buildOptions, messages) {
-        if (messages.length > 0) {
-            const options = {
-                log: this.logger.log,
-                "log-level": BuildTaskEngine._getLogLevel(buildOptions) // ensures that for tests the correct cds.env is used
-            }
-            deduplicateMessages(messages)
-            log(messages, options)
-        }
-    }
-
-    static _resolveRequiredSapServices(tasks) {
-        const taskModelPaths = tasks.reduce((acc, task) => {
-            const model = task.options?.model
-            if (model) {
-                if (Array.isArray(model)) {
-                    model.forEach(m => acc.add(m))
-                } else {
-                    acc.add(model)
-                }
-            }
-            return acc
-        }, new Set())
-
-        return resolveRequiredSapModels([...taskModelPaths])
-    }
-
-    /**
-     * Returns a sorted and flattened list of all messages extracted from the given errors.
-     * @param {Array<Error>} 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) {
-                messages = messages.concat(BuildTaskEngine._getErrorMessages(error.errors))
-            } else {
-                messages.push(error)
-            }
-        })
-        return messages
-    }
-
-    /**
-     * Returns compiler messages and validation messages issued by handlers.
-     * @param {Array<BuildTaskHandler>} handlers
-     */
-    static _getHandlerMessages(handlers) {
-        return handlers.reduce((acc, handler) => acc.concat(handler.messages), [])
-    }
-
-    /**
-     * 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 passed as 'buildOptions.log-level' or defined in 'cds.env' is used to filter the given messages.
-     * @param {object} buildOptions
-     * @param  {...Error} messages
-     */
-    static _sortMessagesUnique(buildOptions, ...messages) {
-        const logLevelIdx = LOG_LEVELS.indexOf(this._getLogLevel(buildOptions))
-        // flatten
-        messages = messages.reduce((acc, m) => acc.concat(m), [])
-        // filter according to log-level
-        const filteredMessages = messages.filter(message => !message.severity || logLevelIdx >= SEVERITIES.indexOf(message.severity))
-        // remove duplicates
-        deduplicateMessages(filteredMessages)
-        // sort
-        return sortMessagesSeverityAware(filteredMessages)
-    }
-
-    /**
-     * Return user defined log level or default value 'warn'
-     * @param {string} buildOptions
-     */
-    static _getLogLevel(buildOptions) {
-        return buildOptions["log-level"] || cds.env["log-level"]
-    }
-}
-module.exports = BuildTaskEngine