@sap/cds 5.4.3 → 5.5.0

package/CHANGELOG.md

@@ -4,13 +4,249 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 5.5.0 - 2021-09-23
+
+### Added
+
+- Support for minified models
+- Messaging: Webhooks use 'application/json' as the default content type
+- Messaging: If senders don't use `data` as a property of the payload, then the whole payload is interpreted as `data`
+- Messaging: Support for `$namespace` placeholer in queue name
+- Support for deletable singletons with `@odata.singleton.nullable`
+- Remote requests set the `accept-language` header according to the original request or the user's locale
+- Support for choosing data source names different from names of respective service definitions.
+  + Example:
+    ```json
+      {"cds":{"requires":{
+        "S4": {
+          "model": "...", "service": "API_BUSINESS_PARTNER"
+        }
+      }}}
+    ```
+- When calling `cds.tx()` to create new transactions, this now automatically inherits the current event context from `cds.context`. In case that creates issues set `cds.env.features.cds_tx_inheritance = false` to restore the former behaviour. You can still overwrite individual context settings, for example:
+    ```js
+    const tx = cds.tx() // inherits tenant and user
+    const tx = cds.tx({ // inherits tenant 
+      user: new cds.User.Privileged 
+    })
+    ```
+- Method `cds.tx()` now allows to pass a function which will be executed within a new managed transaction, with `tx.commit/rollback()` handled automatically. For example:
+    ```js
+    await cds.tx (tx => {
+      await tx.insert (...)
+      await tx.read (...)
+    })
+    ```
+    is equivalent to:
+    ```js
+    const tx = cds.tx ()
+    try {
+      await tx.insert (...)
+      await tx.read (...)
+      await tx.commit()
+    } catch {
+      await tx.rollback()
+    }
+    ```
+- Method `cds.tx({user})` now allows specifying a user as a plain string, for example:
+    ```js
+    cds.tx ({ user:'me' })
+    ```
+    is equivalent to:
+    ```js
+    cds.tx ({ user: new cds.User('me') })
+    ```
+- Newly introduced method `cds.spawn()` allows correctly and conveniently spawning background jobs from within event handlers. Thereby ensuring a detached fully-managed ACID transaction set as `cds.context` for each execution of the background job, inheriting the current event context from the outer `cds.context` by default. Usage options:
+    ```js
+    cds.spawn (async ()=>{
+      await INSERT.into ('Ticker') ...
+    }) 
+    ```
+    ```js
+    cds.spawn (async ()=>{
+      await INSERT.into ('Ticker') ...
+    },{ after: 111 /* ms */ }) 
+    ```
+    ```js
+    let n=0, handle = cds.spawn (async ()=>{
+      await INSERT.into ('Ticker') ...
+      if (++n>9) clearTimeout (handle)
+    },{ every: 111 /* ms */ }) 
+    ```
+    ```js
+    cds.spawn (async ()=>{
+      await INSERT.into ('Ticker') ...
+    },{ // inherits tenant 
+      every: 111 /* ms */,
+      user: new cds.User.Privileged 
+    }) 
+    ```
+- Default server is CORS-enabled for all origins if not in production
+- Default lock acquire timeout for `SELECT FOR UPDATE` via `cds.env.sql.lock_acquire_timeout`
+- Optimized search: Support `groupby` for localized data (when the environment variable `cds.env.features.optimized_search` is set to `true` on SAP HANA)
+- Out-of-the-box audit logging for deep structures without own association to data subject
+  + limited to one data subject per role per composition tree
+- Support for reading streams via `GET /<Entity>(<ID>)/$value`
+- Draft choreography: support of navigation with `SiblingEntity`
+- Support for where exists with infix filters in `@restrict`
+- Support annotation `@Capabilities.ExpandRestrictions.NonExpandableProperties` 
+- `@Core.ContentID` added to OData error responses if `content-id` header is specified
+- New OData URL to CQN parser (`cds.env.features.odata_new_parser`):
+  + support of navigation to primitive properties using `$value`
+  + support of `not` operator with string functions (`contains`, `startswith`, `endswith`)
+- Support for default values for virtual fields
+- Payload for non-writable navigation targets removed from `req.data`
+- `cds build` supports i18n message bundles for Java and Nodejs apps and a default CSN format option for Java
+- View resolving considers renaming of foreign keys and `excluding` names when `columns` are explicitly provided in CQN
+- Resilient acquire for HANA via `cds.env.requires.db.connection_attempts = <number>` (alpha; hard max of 3 enforced)
+
+### Changed
+
+- Messaging: Webhooks will always generate tokens
+- Messaging: In multitenancy mode, messaging artifacts are only deployed to subscribers (unless the service option `deployForProvider` is set to `true`)
+- Messaging: Incoming messages without corresponding handlers are not acknowledged
+- If a service executes a query targeting a projection on one of its entities, the query is resolved along with projections to an entity known by the executing service. The result is post-processed to reflect the expected result of the incoming query. The reason is that no handlers of the executing service were executed as they did not know the query target.
+  + Deactivate during two month grace period via compact feature flag `cds.env.features.resolve_views = false`
+- Use `@sap/cds-compiler`'s `smartId` function to determine whether a reference needs to be quoted.
+  + Allows the use of non-word characters in column names, for example `entity Foo { ![bar/bz]: String; }`.
+  + Support for columns with spaces with feature flag `cds.env.features.spaced_columns`.
+  + Note: Restrictions in other layers (example: OData's simple identifier schema) still apply.
+  + Note: Expressions in references (example: `ref: ['foo as bar']`) currently works but was never intended to and will be removed in future versions.
+- Clear draft data based on their draft UUID instead of via deep delete
+- Support `@sap/cds-compiler`'s changes for DB constraints: managed and unmanaged compositions of one behave like associations. This means that only `$self`-managed composition of one gets `DELETE CASCADE` constraint. Since all other "2one" cases require extra `DELETE` handled by the runtime, that constraint is ignored.
+- Value with regards to date and time functions are not converted to strings in the OData protocol adapter
+- No placeholders for `LIMIT` to enable statement caching during pagination
+- Arrayed elements stringified in DB layer
+- Return values of handlers will have precedence over database reads
+- Error of a failed request to a Remote Service contains now the response payload if available
+- Configuring ad-hoc destinations via `credentials.url` is now allowed in `NODE_ENV=production`
+- New OData URL to CQN parser (`cds.env.features.odata_new_parser`):
+  + CQN for `$select` and `$expand` columns
+
+### Fixed
+
+- `SELECT.from (Foo, f => f.bar('*').where(...))` resulted in a runtime exception
+- Preserved locales are now considered when accessing database tables
+- Integrity checks for compositions by draft enabled entities
+- Constant columns must not be quoted anymore, i.e. `{ val: "'myValue'", as: "myColumn"}` must be changed to `{ val: "myValue", as: "myColumn" }`
+- Accidental `tx.run()` after prior `tx.commit/rollback()` lead to acquired connections not returned to pool. This is detected and disallowed now. In case that creates issues set `cds.env.features.cds_tx_protection = false` to restore the former behaviour.
+- Structured keys are correctly resolved with pegjs-based parser
+- Template processing for columns with spaces in their name
+- Deep delete with recursions in composition tree (with limited recursion depth)
+- Draft edit with recursions in composition tree (with limited recursion depth)
+- `emit` for messaging services now also works in custom express middlewares
+- `req.query` is a CQN object (previously array with one entry) in case of batch insert in REST adapter
+- HasActiveEntity flag with expand
+- `compile.to.serviceinfo` now honors default Java endpoint paths if none are configured in `application.yaml`
+- `PATCH` request to a non-existent entity annotated with the `@PersonalData` annotation
+- `req.diff()` while deep updating via composition
+- Convert data type of elements in sub-entities (to one association) when forwarding responses to external services
+- Update children of a composition of many (`INSERT > DELETE`) with `PATCH/PUT` having at the same time another association to one composition child respects foreign key constraints.
+- Handling of virtual fields used in the `$filter` query option of navigation requests
+- Copy texts in default language from active to draft table on draft edit
+- Optimized search: Escape double quotation marks and backslashes (when the environment variable `cds.env.features.optimized_search` is set to `true`)
+- Update for multiple rows
+- Expand during draft union
+- Validate content type for `$batch` requests
+- Support for `SELECT` statements in `where` clauses when resolving views
+- `INSERT.rows()` does not silently fill in `INSERT.entries` anymore &rarr; use `INSERT.entries()` to do so instead.
+- `UPDATE(Foo).with({foo:{'=':'bar'})` erroneously produced:
+  ```js
+  {UPDATE:{..., with:{foo:{ref:['bar']}}}} //> wrong
+  ``` 
+  instead of:
+  ```js
+  {UPDATE:{..., data:{foo:'bar'}}} // correct
+  ``` 
+  &rarr; to produce the ref, use one of:
+  ```js
+  UPDATE(Foo).with ({foo:{ref:['bar']}}) 
+  UPDATE(Foo).with `foo=bar`
+  ```
+- `UPDATE.with` property stays undefined until actually filled with data
+- Differentiate between require and initialize error of audit logging client
+- The built-in model tree-shaking erroneously deleted explicitly modeled `.texts` entities
+- Actions and functions with `Integer` response type in REST services
+- Occasional drop of conditions in `WHERE` depending on the value when using structured types
+- `PATCH` fixed for singletons and when having a keyless, for example, managed to-one navigation path
+- Internal server error when forwarding a query to an external service whose target entity does not contain keys
+- Nested where exists in `@restrict` via navigation (CRUD-only; beta)
+- Expand to one in draft union
+- Patch to autoexposed entity through composition of aspect from Fiori Elements
+- Diff for delete in draft
+- Streaming requests on views with joins no longer crash the application
+
+### Removed
+
+- Direct usage of body-parser
+- Queries constructed from `cds.ql` do not have the _internal_ property `cqn` anymore
+- Inofficial variant `SELECT({'expand(foo)':['a','b']})` is not supported anymore 
+&rarr; use one of these official APIs for expands instead:
+  ```js
+  SELECT(x => { x.a, x.foo (f =>{ f.b, f.c }) })
+  SELECT(['a',{ref:['foo'], expand:['b','c']}])
+  ```
+- Inofficial variant `SELECT.orderBy('foo','desc')` is not supported anymore 
+&rarr; use one of these official APIs instead:
+  ```js
+  SELECT.from(Foo).orderBy({foo:'desc'})
+  SELECT.from(Foo).orderBy('foo desc')
+  ```
+- Inofficial variant `SELECT.orderBy('foo, bar desc')` is not supported anymore 
+&rarr; use one of these official APIs instead:
+  ```js
+  SELECT.from(Foo).orderBy({foo:1,bar:-1})
+  SELECT.from(Foo).orderBy('foo','bar desc')
+  SELECT.from(Foo).orderBy `foo, bar desc`
+  ```
+- Inofficial variant `SELECT.where({ or: [{ foo: 'bar' }, { foo: 'baz' }] })` is not supported anymore 
+&rarr; use one of these official APIs instead:
+  ```js
+  SELECT.from(Foo).where({ foo: 'bar', or: { foo: 'baz' } })
+  SELECT.from(Foo).where `foo='bar' or foo='baz'`
+  ```
+- Usage of SQL window functions during expand on HANA
+- Hidden symbol for where clause elements originating from `@restrict`
+- Error masking gate keeper for `cds.env.log.levels.cli`
+
+## Version 5.4.6 - 2021-09-18
+
+### Added
+
+- Support for nested where exists in `@restrict` (CRUD-only; beta)
+
+### Fixed
+
+- Inverse transition mapping calculation
+- Skip empty structures during deep update
+
+## Version 5.4.5 - 2021-09-15
+
+### Fixed
+
+- Processing of null elements during deep update
+- Performance issue during template processing
+
+## Version 5.4.4 - 2021-09-09
+
+### Fixed
+
+- For drafts, the query parameter `$top=0` in combination with `$count=true` now returns the correct `@odata.count` value
+- Deep delete with composition of one with structured key in target
+- Implicit delete of child with structured key
+- Update of deeply nested entity with structured key
+- Order by join column during draft union
+- Skip calculated properties while following projections
+- The `with parameters` clause is now correctly handled in sub selects if the locale parameter exceeds 3 characters
+- Statement already finalized error on SQLite
+
 ## Version 5.4.3 - 2021-08-16
 
 ### Fixed
 
 - Skip calculated properties while following projections
-- Safe access to `cds.env.log.levels.cli`
 - Unrestricted subclauses in `@restrict.where`
+- Safe access to `cds.env.log.levels.cli`
 
 ## Version 5.4.2 - 2021-08-11
 
@@ -50,6 +286,7 @@
 - Messaging: No more topic manipulation per default
 - For consistency reasons `cds build` now determines the default model path using cds resolve
 - Match XSUAA's user attribute value `$UNRESTRICTED` case insensitive
+- CDS build now uses new CDS logging facade to allow for consistent logging behaviour accross the different CDS modules
 
 ### Fixed
 
@@ -63,7 +300,7 @@
 - Expand to autoexposed association/composition in draft case
 - `cds.parse.xpr()` always returns an array
 - Allow boolean options in `cds build` CLI
-- Integrity check in case of bulk query execution  
+- Integrity check in case of bulk query execution
 
 ### Removed
 

package/apis/ql.d.ts

@@ -28,16 +28,9 @@ declare class QL {
 // (new QL).SELECT.from('Foo').byKey(11).a
 
 export class SELECT<T> extends ConstructedQuery {
+	static one : SELECT_one & { from: SELECT_one }
 	static distinct : typeof SELECT
-	static one : typeof SELECT_one
-  static from (entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) : SELECT<any>
-  static from <T> (entity:Constructable<T>, primaryKey : number | string | object, projection? : (e:T)=>void) : SELECT<T> & Promise<T>
-  static from <T> (entity:Constructable<T>, projection? : (e:T)=>void) : SELECT<T> & Promise<T[]>
-  static from <T> (entity:Constructable<T>, primaryKey : number | string | object, projection? : (e:T)=>void) : SELECT<T> & Promise<T>
-  static from <T> (entity:T[], projection? : (e:T)=>void) : SELECT<T> & Promise<T[]>
-  static from <T> (entity:T, projection? : (e:T)=>void) : SELECT<T> & Promise<T[]>
-  static from <T> (entity:T[], primaryKey : number | string | object, projection? : (e:T)=>void) : SELECT<T> & Promise<T>
-  static from <T> (entity:T, primaryKey : number | string | object, projection? : (e:T)=>void) : SELECT<T> & Promise<T>
+  static from : SELECT_from
 	from (entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) : this
 	byKey (primaryKey? : number | string | object) : this
 	columns (projection:(e:T)=>void) : this
@@ -54,12 +47,21 @@ export class SELECT<T> extends ConstructedQuery {
 	SELECT : CQN.SELECT
 }
 
-export class SELECT_one<T> extends SELECT<T> {
-	static from <T> (entity:Constructable<T>, projection? : (e:T)=>void) : SELECT<T> & Promise<T>
-	static from <T> (entity:Constructable<T>, primaryKey? : number | string | object, projection? : (e:T)=>void) : SELECT<T> & Promise<T>
-	static from (entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) : SELECT<any>
-	static from <T> (entity:T, primaryKey? : number | string | object, projection? : (e:T)=>void) : SELECT<T> & Promise<T>
-}
+type SELECT_one =
+((entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) => SELECT<any>)
+& (<T> (entity: T[], projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: T[], primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: {new():T}, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: {new():T}, primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+
+
+type SELECT_from =
+((entity: Definition | string, primaryKey? : number | string | object, projection? : (e:any)=>void) => SELECT<any>)
+& (<T> (entity: T[], projection? : (e:T)=>void) => SELECT<T> & Promise<T[]>)
+& (<T> (entity: T[], primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: {new():T}, projection? : (e:T)=>void) => SELECT<T> & Promise<T[]>)
+& (<T> (entity: {new():T}, primaryKey : number | string | object, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+
 
 export class INSERT<T> extends ConstructedQuery {
 	static into  (entity : Definition | string, entries? : object | object[]) : INSERT<any>

package/app/index.js

@@ -21,7 +21,7 @@ module.exports = { get html(){
     <ul>${_entities_in(srv).map (e => {
       return `
       <li>
-        <a href="${srv.path}/${e.replace(/\./g, '_')}?$top=11">${e}</a> ${_moreLinks(srv, e)}
+        <a href="${srv.path}/${e.replace(/\./g, '_')}">${e}</a> ${_moreLinks(srv, e)}
       </li>`}).join('')}
     </ul>
   `) .join(''))

package/bin/build/buildTaskEngine.js

@@ -4,17 +4,16 @@ const _cds = require('./cds'), { log } = _cds.exec
 const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
 const { sortMessagesSeverityAware, deduplicateMessages, CompilationError } = require('@sap/cds-compiler')
 const { allSettled, relativePaths, BuildError, BuildMessage } = require('./util')
-const { OUTPUT_MODE_DEFAULT, SEVERITIES, LOG_LEVELS } = require('./constants')
+const { OUTPUT_MODE_DEFAULT, SEVERITIES, LOG_LEVELS, LOG_MODULE_NAMES } = require('./constants')
 const BuildTaskHandlerInternal = require('./provider/buildTaskHandlerInternal')
 
-const DEBUG = process.env.DEBUG
 const COMPILATION_ERROR = 'CompilationError'
 const COMPILE_MESSAGE = 'CompileMessage'
 
 class BuildTaskEngine {
     constructor(logger, cds) {
-        this._logger = logger || global.console
         this._cds = cds ? cds : _cds
+        this._logger = logger || this._cds.log(LOG_MODULE_NAMES)
     }
 
     get cds() {
@@ -29,8 +28,7 @@ class BuildTaskEngine {
 
     async processTasks(tasks, buildOptions, clean = true) {
         const handlers = []
-        const timerKey = "[cds] - build completed in"
-        this.logger.time(timerKey)
+        const startTime = Date.now()
 
         if (buildOptions) {
             // clone as data may be stored as part of the buildOptions object
@@ -44,8 +42,8 @@ class BuildTaskEngine {
             buildOptions.outputMode = OUTPUT_MODE_DEFAULT
         }
 
-        this.logger.log(`[cds] - building project [${buildOptions.root}], clean [${clean}]`)
-        this.logger.log(`[cds] - cds [${_cds.version}], compiler [${require('@sap/cds-compiler/package.json').version}], home [${_cds.home}]\n`)
+        this.logger.log(`building project [${buildOptions.root}], clean [${clean}]`)
+        this.logger.log(`cds [${_cds.version}], compiler [${require('@sap/cds-compiler/package.json').version}], home [${_cds.home}]\n`)
 
         if (!buildOptions.target) {
             buildOptions.target = path.resolve(buildOptions.root, this.env.build.target)
@@ -62,12 +60,12 @@ class BuildTaskEngine {
         buildOptions.tasks = handlers.map(handler => handler.task)
 
         try {
-            await this._executePrepare(handlers)
+            await this._executePrepare(handlers, buildOptions)
             await this._executeCleanBuildTasks(handlers, buildOptions, clean)
             const buildResult = await this._executeBuildTasks(handlers, buildOptions)
             await this._logBuildOutput(handlers, buildOptions)
             this._logMessages(buildOptions, BuildTaskEngine._getHandlerMessages(handlers))
-            this._logTimer(timerKey)
+            this._logTimer(startTime, Date.now())
 
             return buildResult
         } catch (error) {
@@ -93,7 +91,7 @@ class BuildTaskEngine {
      * @param {*} handlers
      * @returns
      */
-    async _executePrepare(handlers) {
+    async _executePrepare(handlers, buildOptions) {
         const handlerGroups = new Map()
 
         // group handlers by type
@@ -103,7 +101,7 @@ class BuildTaskEngine {
 
         const promises = []
         for (let handlerGroup of handlerGroups.values()) {
-            promises.push(this._doPrepare(handlerGroup))
+            promises.push(this._doPrepare(handlerGroup, buildOptions))
         }
         return Promise.all(promises)
     }
@@ -112,13 +110,11 @@ class BuildTaskEngine {
      * @deprecated
      * @param {*} handlerGroup 
      */
-    async _doPrepare(handlerGroup) {
+    async _doPrepare(handlerGroup, buildOptions) {
         for (let handler of handlerGroup) {
             // prepare has been deprecated
             if (handler instanceof BuildTaskHandlerInternal) {
-                if (DEBUG) {
-                    this.logger.log(`[cds] - preparing, handler [${handler.constructor.name}], src [${relativePaths(handler.buildOptions.root, handler.task.src)}]`)
-                }
+                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
@@ -131,16 +127,12 @@ class BuildTaskEngine {
         if (clean) {
             // clean entire build staging folder once
             if (buildOptions.target !== buildOptions.root) {
-                if (DEBUG) {
-                    this.logger.log(`[cds] - cleaning staging folder ${buildOptions.target}`)
-                }
+                this.logger._debug && this.logger.debug(`cleaning staging folder ${buildOptions.target}`)
                 await fs.remove(buildOptions.target)
             }
 
             const results = await allSettled(handlers.map((handler) => {
-                if (DEBUG) {
-                    this.logger.log(`[cds] - cleaning, handler [${handler.constructor.name}], src [${relativePaths(handler.buildOptions.root, handler.task.src)}]`)
-                }
+                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
@@ -178,9 +170,7 @@ class BuildTaskEngine {
         let allResults = []
         for (const group of pipeline) {
             const results = await allSettled(group.map((handler) => {
-                if (DEBUG) {
-                    this.logger.log(`[cds] - building, handler [${handler.constructor.name}], src [${relativePaths(handler.buildOptions.root, handler.task.src)}]`)
-                }
+                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({
@@ -245,9 +235,8 @@ class BuildTaskEngine {
                 // 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`)
             }
-            if (DEBUG) {
-                this._logTaskHandler(handler)
-            }
+            this._logTaskHandler(handler, buildOptions)
+
             return handler
         } catch (error) {
             log(error, { log: this.logger.log })
@@ -263,38 +252,33 @@ class BuildTaskEngine {
     async _logBuildOutput(handlers, buildOptions, writeOutputFile = true) {
         // log all generated files
         const files = this._getBuildOutput(handlers, buildOptions)
-
         if (files.length > 0) {
-            this.logger.log('\n[cds] - done > wrote output to:')
-            files.forEach((file) => {
-                this.logger.log('  ' + file)
-            })
+            this.logger.log(`done > wrote output to:\n   ${files.join("\n   ")}\n`)
+        } else {
+            this.logger.log('done >')
         }
 
         if (writeOutputFile) {
             const outputFile = this.env.build.outputfile || process.env.GENERATION_LOG
             if (outputFile) {
-                this.logger.log(`[cds] - writing generation log to [${outputFile}]`)
+                this.logger.log(`writing generation log to [${outputFile}]\n`)
                 await fs.outputFile(outputFile, files.join('\n'))
                     .catch((error) => {
-                        this.logger.error(`[cds] - failed to write generation log`)
+                        this.logger.error(`failed to write generation log`)
                         this.logger.error(error.stack || error)
                         return Promise.resolve()
                     })
             }
         }
-        this.logger.log('')
     }
 
-    _logTimer(timerKey) {
-        this.logger.log('')
-        this.logger.timeEnd(timerKey)
-        this.logger.log('')
+    _logTimer(start, end) {
+        this.logger.log(`build completed in ${end - start} ms\n`)
     }
 
-    _logTaskHandler(handler) {
-        this.logger.log(`[cds] - handler ${handler.constructor.name}`)
-        this.logger.log(`[cds] - details src [${relativePaths(handler.buildOptions.root, handler.task.src)}], dest [${relativePaths(handler.buildOptions.root, handler.task.dest)}], for|use [${handler.for | handler.task.use}], options [${JSON.stringify(handler.task.options)}]`) //NOSONAR
+    _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) {

package/bin/build/buildTaskFactory.js

@@ -3,14 +3,12 @@ const path = require('path')
 const _cds = require('./cds'), { log } = _cds.exec
 const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
 const { hasJavaNature, getProperty, redactCredentials } = require('./util')
-const { FILE_EXT_CDS, BUILD_TASK_JAVA } = require("./constants")
-
-const DEBUG = process.env.DEBUG
+const { FILE_EXT_CDS, BUILD_TASK_JAVA, LOG_MODULE_NAMES } = require("./constants")
 
 class BuildTaskFactory {
     constructor(logger, cds) {
-        this._logger = logger || global.console
         this._cds = cds ? cds : _cds
+        this._logger = logger || this._cds.log(LOG_MODULE_NAMES)
     }
     get cds() {
         return this._cds
@@ -42,10 +40,8 @@ class BuildTaskFactory {
             this.logger.log(tasksOutput)
 
             // for testing purposes
-            if (process.env.DEBUG) {
-                this.logger.log("[cds] - cds.env used for build:")
-                this.logger.log(redactCredentials(this.env))
-            }
+            this.logger.debug("cds.env used for build:")
+            this.logger._debug && this.logger.debug(redactCredentials(this.env))
 
             // always resolve tasks for input validation
             if (buildOptions.resolve || buildOptions.cli) {
@@ -121,8 +117,8 @@ class BuildTaskFactory {
         const srv = task ? task.src : BuildTaskFactory._getModuleFolder(buildOptions.root, BuildTaskFactory._flatten([this.env.folders.srv])) || "srv"
 
         // Java projects use "." as the default build target folder
-        if (this._hasJavaNature(buildOptions.root, srv) && this._adaptBuildTargetSettingForJava(buildOptions.root) && DEBUG) {
-            this.logger.log("[cds] - using inplace build for java project instead of default staging build")
+        if (this._hasJavaNature(buildOptions.root, srv) && this._adaptBuildTargetSettingForJava(buildOptions.root)) {
+            this.logger.debug("[cds] - using inplace build for java project instead of default staging build")
         }
         buildOptions.target = path.resolve(buildOptions.root, this.env.build.target)
     }

package/bin/build/buildTaskHandler.js

@@ -179,12 +179,10 @@ class BuildTaskHandler {
     async model() {
         const files = this._resolveModel()
         if (!files || files.length === 0) {
-            this._logger.log("[cds] - no model found, skip build")
+            this._logger.log("no model found, skip build")
             return null
         }
-        if (process.env.DEBUG) {
-            this._logger.log(`[cds] - model: ${relativePaths(this._buildOptions.root, files).join(", ")}`)
-        }
+        this._logger._debug && this._logger.debug(`model: ${relativePaths(this._buildOptions.root, files).join(", ")}`)
         const options = { messages: this._messages }
         // $location paths are relative to current working dir by default - make sure a given project root folder is taken
         options.cwd = this._buildOptions.root

package/bin/build/buildTaskProvider.js

@@ -17,6 +17,8 @@ module.exports = class BuildTaskProvider {
         // task.for = task.for || this._getTaskId(task.use)
     }
     _getTaskId(use) {
-        return use.substring(this._plugin.id.length + 1)
+        if (this._plugin && this._plugin.id) {
+            return use.substring(this._plugin.id.length + 1)
+        }
     }
 }

package/bin/build/buildTaskProviderFactory.js

@@ -1,16 +1,14 @@
 const { fs } = require('@sap/cds-foss')
 const path = require('path')
 const _cds = require('./cds')
-const { OUTPUT_MODE_DEFAULT } = require("./constants")
+const { OUTPUT_MODE_DEFAULT, LOG_MODULE_NAMES } = require("./constants")
 const BuildTaskProviderInternal = require('./provider/buildTaskProviderInternal')
 const BuildTaskProvider = require('./buildTaskProvider')
 
-const DEBUG = process.env.DEBUG
-
 class BuildTaskProviderFactory {
     constructor(logger, cds, buildOptions) {
         this._cds = cds ? cds : _cds
-        this._logger = logger || global.console
+        this._logger = logger || this._cds.log(LOG_MODULE_NAMES)
         buildOptions.for = buildOptions.for || {}
         buildOptions.outputMode = buildOptions.outputMode || OUTPUT_MODE_DEFAULT
         this._buildOptions = buildOptions
@@ -50,14 +48,15 @@ class BuildTaskProviderFactory {
             if (!provider) {
                 throw new Error(`No provider found for build task '${task.for || task.use}'`)
             }
+            if (provider instanceof DefaultBuildTaskProvider) {
+                this.logger._debug && this.logger.debug(`No provider found for build task '${task.use}', using default provider`)
+            }
             await this._applyTaskDefaults(provider, [task])
         }))
     }
 
     async lookupTasks() {
-        if (DEBUG) {
-            this.logger.log("[cds] - Determining CDS build tasks from CDS configuration - applying defaults")
-        }
+        this.logger.debug("[cds] - Determining CDS build tasks from CDS configuration - applying defaults")
         let tasks = []
         await Promise.all(this.providers.map(async (provider) => {
             let pluginTasks = await this._lookupTasks(provider)
@@ -68,7 +67,7 @@ class BuildTaskProviderFactory {
             await this._applyTaskDefaults(provider, pluginTasks)
 
             tasks = tasks.concat(pluginTasks)
-            this.logger.debug(`Build task provider ${provider.constructor.name} returned build tasks ${JSON.stringify(pluginTasks)}`)
+            this.logger._debug && this.logger.debug(`Build task provider ${provider.constructor.name} returned build tasks ${JSON.stringify(pluginTasks)}`)
         }))
         return tasks
     }
@@ -82,19 +81,14 @@ class BuildTaskProviderFactory {
     createHandler(task) {
         const BuildTaskHandlerClass = this.loadHandler(task)
         const resolvedTask = this.resolveTask(task)
-        if (DEBUG) {
-            this.logger.log(`[cds] - loaded build task handler [${resolvedTask.use}]`)
-        }
+        this.logger._debug && this.logger.debug(`[cds] - loaded build task handler [${resolvedTask.use}]`)
 
         const handler = new BuildTaskHandlerClass()
         handler._task = resolvedTask
         handler._cds = this.cds
         handler._logger = this.logger
         handler._buildOptions = this.buildOptions
-
-        if (DEBUG) {
-            this.logger.log(`[cds] - created BuildTaskHandler [${resolvedTask.use}]`)
-        }
+        this.logger._debug && this.logger.debug(`[cds] - created BuildTaskHandler [${resolvedTask.use}]`)
         return handler
     }