@sap/cds 6.1.2 → 6.2.1

package/CHANGELOG.md

@@ -4,6 +4,91 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 6.2.1 - 2022-10-05
+
+### Fixed
+
+- In the CDS configuration, custom profiles now have precedence over the (implicit) default `[development]` profile, irrespective of insertion order.
+- `cds test` is now compatible with new `axios` 1.x
+
+## Version 6.2.0 - 2022-10-04
+
+### Added
+
+- Types for using tagged template variants of several CQL constructs
+- Types for calling shortcut versions of CQL constructs (`SELECT(...)` in addition to `SELECT.from(...)`, etc.)
+- Types for `cds.test`
+- Types for `cds.log().setFormat()`
+- Support for `redis-messaging` (beta)
+- Log the cds version when starting the server
+- Support for non-root entities as the main draft entity
+- Support for IAS authentication using kind `ias-auth`
+- Warning if multiple installations of `@sap/cds` were found when serving requests
+- Wildcard expansion `('*')` of properties in QL is now typed
+- Support for extended models in custom transactions and background processes
+- `cds build` logs detailed error messages if required service models cannot be resolved or aren't defined in custom build tasks.
+- Support for additional data types `cds.UInt8`, `cds.Int16`, `cds.Int32`, `cds.Int64`
+- Typings for `cds.utils`, `req.entity`
+- Optimized server startup for projects with large models and high numbers of services.
+  Can be switched off by setting config `cds.features.precompile_edms = false` in case of problems.
+- Set default header to `application/octet-stream` while sending binary to remote
+- OData temporal query params `$at`, `$from`, `$to`, `$toInclusive` can be used in custom handlers
+- Reserved keywords from compiler api available at `cds.compile.to.[cdl, sql.sqlite]`
+- Improved `winston` integration in `cds.log`
+
+### Changed
+
+- `cds.debug()` now returns undefined instead of falsy if debug is switched off. This allows usages like that:
+  ```js
+  const DEBUG = cds.debug('whatever')
+  DEBUG?.(...)
+  ```
+- All MTX-related modules have been refactored and moved to `@sap/cds-mtxs`.
+  Ensure to also upgrade to latest version of `@sap/cds-mtxs` when upgrading `@sap/cds` to avoid any breaking change effects.
+- SQLite database file endings have been changed to `.sqlite`, so third-party tools (e.g. VS Code extensions) can deduce the file type.
+- Method `disconnect()` in db services empties db pool w/o removing db services. In special cases (like tests) cleaning-up db service should be done manually while deleting `cds.services.db` and `cds.db`.
+- Prefer HANA driver that is required in package.json of project root
+
+### Fixed
+
+- Queries like `SELECT.from(Foo).where({a:1}).or({b:2}).and({c:3})` erroneously resulted in `SELECT from Foo where (a=1 or b=2) and c=3`
+- Signatures for QN `order_by` expressions are now in line with the capire doc
+- Signatures for QL operations are now more specific
+- `basic-auth` does not inherit users of `mocked-auth`
+- `cds.localize` now ignores i18n files defined outside project scope.
+- Allow `@Capabilities.NavigationRestrictions.RestrictedProperties` to be specified in the format `{ InsertRestrictions.Insertable: false }`
+- Bound actions/functions while calling remote service
+- `$search`: Search on localized projections/views does not always return the localized data
+- `cds push` now shows better output for failed extension validations
+- Aliased parameters in REST parser
+- `cds.deploy` now logs the correct filename for multitenant SQLite
+- HDI configuration data (e.g. `./cfg`, `.hdiignore`) and HANA native artifacts have not always been copied into the `sdc` folder of a MTX sidecar module
+- OData URL to CQN parser (`cds.env.features.odata_new_parser`) now supports functions with no arguments
+- Runtime exception for `PATCH` HTTP request with an empty payload body and read-only field
+- Streams in draft caused SQL error
+- Better response state handling during `cds deploy` to Cloud Foundry.
+- Draft: patch on draft enabled entity with a composition of one
+- Maximum stack trace exceeded in generic audit logging implementation
+- The protocol adapter logs the decoded URI or the original one, if it is invalid
+- REST: reject action calls with round brackets (parentheses). For example, the request `/Books(1)/bookShelf.CatalogService.rate()` is now rejected.
+- `cds deploy` and `cds run/serve/watch` no longer print terminal escape sequences (`x1b...`) if they run non-interactively.
+- Some fields in entities like `path` generated invalid sql
+
+## Version 6.1.3 - 2022-09-13
+
+### Added
+
+- Configuration to change maximum body size in bytes for remote requests: `cds.env.remote.max_body_length: 1000` sets it to 1 MB
+
+### Changed
+
+- For structured input, foreign keys are generated as non-enumerable properties on application-service layer
+
+### Fixed
+
+- Deep insert/update/upsert requests where the key of an association is provided in a structured format will not be rejected anymore if the target has default or mandatory fields
+- For some configurations, mtxs services were bootstrapped twice
+
 ## Version 6.1.2 - 2022-09-05
 
 ### Fixed
@@ -23,13 +108,12 @@
 - `UPDATE` statement accepts empty objects: `UPDATE('Foo').with({ bar: {} })`
 - URI encoding of parameters in remote service calls
 
-### Removed
-
 ## Version 6.1.1 - 2022-08-24
 
 ### Added
-
 - The configuration schema now includes `cds.extends` and `new-fields` (in `cds.xt.ExtensibilityService`)
+- Ability to run extension validations as part of `cds lint`
+- The `/-/cds/login` endpoint now also supports client credentials authentication
 - `srv.run(fn)` now accepts a function as first argument, which will be run in an active outer transaction, if any, or in a newly created one. This is in contrast to `srv.tx(fn)` which always creates a new tx.
   ```js
   cds.run (tx => { // nested operations are guaranteed to run in a tx
@@ -45,7 +129,7 @@
 - View resolving without model information doesn't crash
 - Unable to upload large attachments. Uploading a large attachment (base64 encoded) caused a runtime exception.
 - `cds.Query.then()` is using `AsyncResource.runInAsyncScope` from now on. → this avoids callstacks being cut off, e.g. in debuggers.
-- `cds.tx()` and `cds.context` have been fixed to avoid accidential fallbacks to auto-commit mode.
+- `cds.tx()` and `cds.context` have been fixed to avoid accidental fallbacks to auto-commit mode.
 - HDI configuration data (e.g. `./cfg`, `.hdiignore`) is now included in the `resources.tgz` file which is required for Streamlined MTX.
 - `cds deploy` accepts in addition to `VCAP_SERVICES` also `TARGET_CONTAINER` and `SERVICE_REPLACEMENTS` from vcap file when using `--vcap-file` parameter.
 - `cds build` doesn't duplicate CSV files that are contained in `db/src/**`.
@@ -54,12 +138,12 @@
 - Unhandled promise rejection in `expand` handling
 - `cds.context.model` middleware is not mounted for not extensible services
 - `cds.context` continuation was sometimes not reset in REST adapter
-- Requests don't fail with `RangeError: Unable to get service from service map due to error: Invalid time value` anymore
 
 ## Version 6.1.0 - 2022-08-10
 
 ### Added
 
+- Support for `@sap/cds-mtxs` in `enterprise-messaging`
 - Detailed information about pool state: `borrowed`, `pending`, `size`, `available`, `max` to the timeout error
 - Odata v2 payloads for `cds.Time` are converted from hh:mm:ss to PThhHmmMssS e.g. 12:34:56 to PT12H34M56S if provided in hh:mm:ss format
 - Odata v2 payloads for `cds.Integer` are converted to String if not provided as String
@@ -69,7 +153,7 @@
 - New OData parser supports $filter with "in" operator, e.g. `$filter=ID in (1,2,3)`
 - `cds build` copies `package.json` and `.cdsrc.json` into _main folder of MTX sidecar app.
 - New OData parser supports null parameter in function/action, e.g `/findBooks(author=1,title=null)`
-- New enviroment variable `schemas` contains locations for json schemas validating `package.json`, `.cdsrc.json` and `.cdsrc-private.json` in VS Code
+- New environment variable `schemas` contains locations for json schemas validating `package.json`, `.cdsrc.json` and `.cdsrc-private.json` in VS Code
 - `cds.test` can now listen on a fixed port by way of additional arguments '--port', '<PORT_NUMBER>
 - `cds.requires.db.kind = 'sql-mt'` is introduced as a shorthand for
   ```js
@@ -357,7 +441,7 @@ Note that this is a breaking change for appliations that rely on error sanitizat
 
 - We don't rely on `global.cds` anymore -> allows to load and correctly work with multiple versions of `cds`
 - Improved shutdown for AMQP connections and file listeners
-- Using `CQL` with a tagged template string `SELECT from Foo { null as boo }` throwed an exception.
+- Using `CQL` with a tagged template string `SELECT from Foo { null as boo }` threw an exception.
 - In case of `MULTIPLE_ERRORS` throw an `Error` instead of an object
 - `cds build` ensures correct precedence of feature annotations. Fixes `Duplicate assignment` compilation errors.
 - Compatibility with former support to find service `@impl: 'relative/to/cdw'`.
@@ -739,7 +823,7 @@ In such scenarios, now the HTTP `404 Not Found` status code is returned rather t
 - `cds version` now always prints the version of `@sap/cds-dk`, especially if `cds version` was called from within an npm script, i.e. not from `cds-dk`'s CLI.
 - Better error message in case destination of Remote Service isn’t found
 - Differentiate between draft already exists and entity locked
-- OData adapter: roll back transaction before rethrowing standard error in case of atomicity group
+- OData adapter: roll back transaction before re-throwing standard error in case of atomicity group
 - Results of actions/functions do not ignore custom data when using `$expand` query option
 - `req.data` is available in custom error handler in case of deserialization error thrown by legacy OData server
 - Joining entities with renamed foreign keys (limited to single-level projections)

package/apis/cds.d.ts

@@ -1,3 +1,4 @@
+import * as ql from './ql'
 
 type cds_facade = import('./core')
 & import('./models')
@@ -7,15 +8,26 @@ type cds_facade = import('./core')
 & import('./services').cds
 & import('./services').QueryAPI
 & import('./log')
+& import('./utils')
+& import('./test')
 
 declare global {
 	const cds : cds_facade
-	class SELECT<T> extends cds.ql.SELECT<T>{}
-	class INSERT<T> extends cds.ql.INSERT<T>{}
-	class UPDATE<T> extends cds.ql.UPDATE<T>{}
-	class DELETE<T> extends cds.ql.DELETE<T>{}
-	class CREATE<T> extends cds.ql.CREATE<T>{}
-	class DROP<T> extends cds.ql.DROP<T>{}
+	// these provide the functionality from SELECT, INSERT, etc in the global facade
+	const SELECT: typeof cds.ql.SELECT
+	const INSERT: typeof cds.ql.INSERT
+	const UPDATE: typeof cds.ql.UPDATE
+	const DELETE: typeof cds.ql.DELETE
+	const CREATE: typeof cds.ql.CREATE
+	const DROP: typeof cds.ql.DROP
+
+	// and these allow us to use them as type too, i.e. `const q: SELECT<Book> = ...`
+	type SELECT<T> = ql.SELECT<T>	
+	type INSERT<T> = ql.INSERT<T>
+	type UPDATE<T> = ql.UPDATE<T>
+	type DELETE<T> = ql.DELETE<T>
+	type CREATE<T> = ql.CREATE<T>
+	type DROP<T>   = ql.DROP<T>
 }
 
 export = cds

package/apis/connect.d.ts

@@ -9,7 +9,7 @@ declare class cds {
 		 * Connects to a specific datasource.
 		 * @see [capire](https://cap.cloud.sap/docs/node.js/api#cds-connect)
 		 */
-		to (datasource?: string, options?: ConnectOptions) : Service & Promise<Service>
+		to (datasource?: string, options?: ConnectOptions) : Promise<Service>
 
 		/**
 		 * Connects the primary datasource.

package/apis/cqn.d.ts

@@ -45,7 +45,7 @@ type name = string
 type source = ( ref | SELECT ) & { as?: name, join?:name, on?:xpr }
 export type column_expr = expr & { as?: name, cast?:any, expand?: column_expr[], inline?: column_expr[] }
 export type predicate = _xpr
-type ordering_term = expr & { asc?:true, desc?:true }
+type ordering_term = expr & { sort?: "asc"|"desc", nulls?: "first"|"last" }
 
 export type expr = ref | val | xpr | SELECT
 type ref = {ref:( name & { id?:string, where?:expr, args?:expr[] } )[]}

package/apis/log.d.ts

@@ -53,12 +53,8 @@ declare type LogFactory = {
      * ```
      *
      * The formatter shall return an array of arguments, which are passed to the logger (for example, `console.log()`)
-     *
-     * @param module logger name
-     * @param level log level
-     * @param args additional arguments
      */
-    format(module: string, level: number, args: any[]): any[]
+    format: Formatter
 }
 
 declare class Logger {
@@ -107,6 +103,28 @@ declare class Logger {
      * @returns whether 'error' level is active
      */
      _error: boolean
+
+    /**
+     * Change the format for this logger instance:
+     * ```
+     *   cds.log('foo').setFormat((module, level, ...args) => [ '[', module, ']', ...args ])
+     * ```
+     *
+     * The formatter shall return an array of arguments, which are passed to the logger (for example, `console.log()`)
+     */
+     setFormat(formatter: Formatter)
+}
+
+declare type Formatter = {
+    /**
+     * Custom format function
+     *
+     * @param module logger name
+     * @param level log level
+     * @param args additional arguments
+     * @returns an array of arguments, which are passed to the logger (for example, `console.log()`)
+     */
+    (module: string, level: number, args: any[]): any[]
 }
 
 declare type Log = {

package/apis/ql.d.ts

@@ -17,10 +17,26 @@ export class cds_ql {
 
 export type PK = number | string | object
 
+interface QLExtensions {
+	as: (alias: string) => void
+}
+
 // to support path expressions: https://pages.github.tools.sap/cap/docs/java/query-api#path-expressions
 // `Book.title` == `Proxy<Book>.title()`
-type Proxy<T> = {
-	[Key in keyof T]: () => Proxy<T[Key]>
+
+/**
+ * This is a marker interface to determine if a property supports subselecting. That is:
+ * 
+ * [1] SELECT.from(Books, b => b.author)
+ * means: "select all books and project each book's author"
+ * [2] SELECT.from(Books, b => b.author(a => a.ID))
+ * means: "select all books, subselect each book's author's ID
+ * 
+ */ 
+type Subqueryable <T> = ((fn:((a:T)=>any)|"*") => T)
+
+type Proxy_<T> =  {
+	[Key in keyof T]: Proxy<T[Key]> //& QLExtensions
 } & {
 	/**
 	 * Accesses any nested attribute based on a path:
@@ -29,100 +45,146 @@ type Proxy<T> = {
 	 * To still have access to typed results, use
 	 * `X.a().b().c().d()` instead.
 	 */
-	get: (path: string) => Proxy<unknown>
-}
+	get: (path: string) => any // Proxy<unknown>
+} & QLExtensions
+
+type Proxy<T> = (T extends Subqueryable<infer U>
+		? (Omit<T, ""> & Subqueryable<Proxy<U>>) // drop ((x: T) => T) in favour of (x: Proxy<T>) => Proxy<T>)
+		: (Proxy_<T>))
+	& QLExtensions
 
 // any class (not value) of array to represent plural types used in cds-typer.
 // Mainly used as pattern match for SingularType
-type ArrayClass = {new():Array<unknown>}
+//type ArrayConstructable = Constructable<Array<unknown>>
+interface ArrayConstructable<T> {
+	new(...args: any[]): T
+}
 
 // concrete singular type.
-// `SingularType<typeof Books>` == `Book`.
-type SingularType<T extends ArrayClass> = InstanceType<T>[number]
+// `SingularType<Books>` == `Book`.
+type SingularType<T extends ArrayConstructable<T>> = InstanceType<T>[number]
+
+// Alias for projections
+// https://cap.cloud.sap/docs/node.js/cds-ql?q=projection#projection-functions
+type Projection<T> = (e:T)=>void
+
+// Type for query pieces that can either be chained to build more complex queries or
+// awaited to materialise the result:
+// `Awaitable<SELECT<Book>, Book> = SELECT<Book> & Promise<Book>`
+//
+// While the benefit is probably not immediately obvious as we don't exactly 
+// save a lot of typing over explicitly writing `SELECT<Book> & Promise<Book>`,
+// it makes the semantics more explicit. Also sets us up for when TypeScript ever
+// improves their generics to support:
+//
+// `Awaitable<T> = T extends unknown<infer I> ? (T & Promise<I>) : never`
+// (at the time of writing, infering the first generic parameter of ANY type
+// does not seem to be possible.)
+type Awaitable<T, I> = T & Promise<I>
+
+// all the functionality of an instance of SELECT, but directly callable:
+// new SELECT(...).(...) == SELECT(...)
+export type StaticSELECT<T> = typeof SELECT
+	& ((...columns:string[]) => SELECT<T>) 
+	& ((columns:string[]) => SELECT<T>)
+	& (TaggedTemplateQueryPart<SELECT<T>>)
+	& SELECT_one // as it is not directly quantified, ...
+	& SELECT_from // ...we should expect both a scalar and a list
 
 declare class QL {
-	SELECT : typeof SELECT & ((...columns:string[]) => SELECT<any>) & ((columns:string[]) => SELECT<any>)
-	INSERT : typeof INSERT & ((...entries:object[]) => INSERT<any>) & ((entries:object[]) => INSERT<any>)
-	UPDATE : typeof UPDATE & typeof UPDATE.entity
+	SELECT : StaticSELECT<T>
+	INSERT : typeof INSERT 
+		& ((...entries:object[]) => INSERT<any>) & ((entries:object[]) => INSERT<any>)
+	UPDATE : typeof UPDATE 
+		& typeof UPDATE.entity
 	DELETE : typeof DELETE
 	CREATE : typeof CREATE
 	DROP : typeof DROP
 }
 
-// (new QL).SELECT.from('Foo').byKey(11).a
-
-
+// used as a catch-all type for using tagged template strings: SELECT `foo`. from `bar` etc.
+// the resulting signatures are actually not very strongly typed, but they at least accept template strings
+// when run in strict mode.
+// This signature has to be added to a method as intersection type.
+// Defining overloads with it will override preceding signatures and the other way around.
+type TaggedTemplateQueryPart<T> = (strings: TemplateStringsArray, ...params?: unknown[]) => T
 
 export class SELECT<T> extends ConstructedQuery {
 	static one : SELECT_one & { from: SELECT_one }
 	static distinct : typeof SELECT
-  static from : SELECT_from
-	from (entity: Definition | string, primaryKey? : PK, projection? : (e:any)=>void) : this
+    static from : SELECT_from
+	from: TaggedTemplateQueryPart<this> 
+		& ((entity: Definition | string, primaryKey? : PK, projection? : Projection<unknown>) => this)
 	byKey (primaryKey? : PK) : this
-	columns (projection:(e:T)=>void) : this
-	columns (...col:string[]) : this
-	where (predicate:object) : this
-	where (...expr : any[]) : this
-	and (predicate:object) : this
-	and (...expr : any[]) : this
-	having (...expr : string[]) : this
-	having (predicate:object) : this
-	groupBy (...expr : string[]) : this
-	orderBy (...expr : string[]) : this
-	limit (rows : number, offset? : number) : this
+	columns: TaggedTemplateQueryPart<this>
+		& ((projection: Projection<T>) => this)
+		& ((...col:string[]) => this)
+	where: TaggedTemplateQueryPart<this>
+		& ((predicate:object) => this)
+		& ((...expr : any[]) => this)
+	and: TaggedTemplateQueryPart<this>
+		& ((predicate:object) => this)
+		& ((...expr : any[]) => this)
+	having: TaggedTemplateQueryPart<this>
+		& ((...expr : string[]) => this)
+		& ((predicate:object) => this)
+	groupBy: TaggedTemplateQueryPart<this>
+		& ((...expr : string[]) => this)
+	orderBy: TaggedTemplateQueryPart<this>
+		& ((...expr : string[]) => this)
+	limit: TaggedTemplateQueryPart<this>
+		& ((rows : number, offset? : number) => this)
 	forSharedLock () : this
 	forUpdate () : this
 	SELECT : CQN.SELECT
 }
 
-type SELECT_one =
-((entity: Definition | string, primaryKey? : PK, projection? : (e:any)=>void) => SELECT<any>)
 
+type SELECT_one =
 // calling with class
-&   (<T extends ArrayClass>
-	(entityType: T)
-	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+	(<T extends ArrayConstructable>
+	(entityType: T, projection?: Projection<Proxy<SingularType<T>>>)
+	=> Awaitable<SELECT<SingularType<T>>, SingularType<T>>)
 &
-	(<T extends ArrayClass>
-	(entityType: T, projection: (e: Proxy<SingularType<T>>) => void)
-	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
-&
-	(<T extends ArrayClass>
-	(entityType: T, primaryKey : PK, projection: (e: Proxy<SingularType<T>>) => void)
-	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
-
-
-& (<T> (entity: T[], projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
-& (<T> (entity: T[], primaryKey : PK, 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 : PK, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
-
+	(<T extends ArrayConstructable>
+	(entityType: T, primaryKey : PK, projection?: Projection<Proxy<SingularType<T>>>)
+	=> Awaitable<SELECT<SingularType<T>>, SingularType<T>>)
 
+& ((entity: Definition | string, primaryKey? : PK, projection? : Projection<unknown>) => SELECT<any>)
+& (<T> (entity: T[], projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
+& (<T> (entity: T[], primaryKey : PK, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
+& (<T> (entity: {new():T}, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
+& (<T> (entity: {new():T}, primaryKey : PK, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
 
 type SELECT_from =
-// calling with class
-	(<T extends ArrayClass>
-	(entityType: T)
-	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+// tagged template
+	TaggedTemplateQueryPart<Awaitable<SELECT<unknown>, InstanceType<unknown>>>
 &
-	(<T extends ArrayClass>
-	(entityType: T, projection: (e: Proxy<SingularType<T>>) => void)
-	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+// calling with class
+	(<T extends ArrayConstructable>
+	(entityType: T, projection?: Projection<Proxy<SingularType<T>>>)
+	=> Awaitable<SELECT<T>, InstanceType<T>>)
 &
-	(<T extends ArrayClass>
-	(entityType: T, primaryKey : PK, projection: (e: Proxy<SingularType<T>>) => void)
-	=> SELECT<SingularType<T>> & Promise<SingularType<T>>)
+	(<T extends ArrayConstructable>
+	(entityType: T, primaryKey : PK, projection?: Projection<SingularType<T>>)
+	=> Awaitable<SELECT<T>, InstanceType<T>>)
 // calling with definition
-& ((entity: Definition | string, primaryKey? : PK, projection? : (e:any)=>void) => SELECT<any>)
+& ((entity: Definition | string, primaryKey? : PK, projection? : Projection<unknown>) => SELECT<any>)
 // calling with concrete list
-& (<T> (entity: T[], projection? : (e:T)=>void) => SELECT<T> & Promise<T[]>)
-& (<T> (entity: T[], primaryKey : PK, projection? : (e:T)=>void) => SELECT<T> & Promise<T>)
+& (<T> (entity: T[], projection? : Projection<T>) => SELECT<T> & Promise<T[]>)
+& (<T> (entity: T[], primaryKey : PK, projection? : Projection<T>) => Awaitable<SELECT<T>, T>)
 
 
 export class INSERT<T> extends ConstructedQuery {
+	// cds-typer plural
+	static into <T extends ArrayConstructable> (entity:T, entries? : object | object[]) : INSERT<SingularType<T>>
+	into <T extends ArrayConstructable> (entity:T) : this
+
+	static into: TaggedTemplateQueryPart<INSERT<T>>
 	static into  (entity : Definition | string, entries? : object | object[]) : INSERT<any>
 	static into <T> (entity:Constructable<T>, entries? : object | object[]) : INSERT<T>
 	static into <T> (entity:T, entries? : T | object | object[]) : INSERT<T>
+	into: TaggedTemplateQueryPart<this>
 	into  (entity : Definition | string) : this
 	data (block : (e:T)=>void) : this
 	entries (...entries : object[]) : this
@@ -133,7 +195,7 @@ export class INSERT<T> extends ConstructedQuery {
 }
 
 export class DELETE<T> extends ConstructedQuery {
-	static from (entity : Definition | string, primaryKey? : PK) : DELETE<any>
+	static from (entity : Definition | string | ArrayConstructable, primaryKey? : PK) : DELETE<any>
 	byKey (primaryKey? : PK) : this
 	where (predicate:object) : this
 	where (...expr : any[]) : this
@@ -143,14 +205,19 @@ export class DELETE<T> extends ConstructedQuery {
 }
 
 export class UPDATE<T> extends ConstructedQuery {
+	// cds-typer plural
+	static entity <T extends ArrayConstructable> (entity:T, primaryKey? : PK) : UPDATE<SingularType<T>>
+
 	static entity (entity : Definition | string, primaryKey? : PK) : UPDATE<any>
 	static entity <T> (entity:Constructable<T>, primaryKey? : PK) : UPDATE<T>
 	static entity <T> (entity:T, primaryKey? : PK) : UPDATE<T>
 	byKey (primaryKey? : PK) : this
 	// with (block: (e:T)=>void) : this
 	// set (block: (e:T)=>void) : this
-	set (data:object) : this
-	with (data:object) : this
+	set: TaggedTemplateQueryPart<this>
+		& ((data:object) => this)
+	with: TaggedTemplateQueryPart<this> 
+		& ((data:object) => this)
 	where (predicate:object) : this
 	where (...expr : any[]) : this
 	and (predicate:object) : this

package/apis/services.d.ts

@@ -84,6 +84,11 @@ export class Service extends QueryAPI {
 		impl: String | ServiceImpl
 	})
 
+	/**
+	 * The name of the service
+	 */
+	name: string
+
 	/**
 	 * The model from which the service's definition was loaded
 	 * @see [capire docs](https://cap.cloud.sap/docs/node.js/services#srv-reflect)
@@ -304,6 +309,12 @@ interface EventContext {
 	method : string
 	path : string
 	target : Definition
+	/**
+	 * Shortcut to {@link target.name}
+	 *
+	 * @see https://cap.cloud.sap/docs/node.js/events#req-entity
+	 */
+	entity: string
 	query : Query
 
 	reply (results) : void

package/apis/test.d.ts

@@ -0,0 +1,61 @@
+import { AxiosInstance } from 'axios';
+import chai from 'chai';
+import * as main_cds from './cds';
+import * as http from 'http';
+import { Service } from './services';
+
+declare class Axios {
+  get axios(): AxiosInstance;
+
+  get     : AxiosInstance['get'];
+  put     : AxiosInstance['put'];
+  post    : AxiosInstance['post'];
+  patch   : AxiosInstance['patch'];
+  delete  : AxiosInstance['delete'];
+  options : AxiosInstance['options'];
+
+  get GET()     : Axios['get'];
+  get PUT()     : Axios['put'];
+  get POST()    : Axios['post'];
+  get PATCH()   : Axios['patch'];
+  get DELETE()  : Axios['delete'];
+  get OPTIONS() : Axios['options'];
+}
+
+declare class DataUtil {
+  delete(db?: Service): Promise<void>;
+  reset(db?: Service): Promise<void>;
+  autoReset(enabled: boolean): this;
+}
+
+declare class Test extends Axios {
+  run(cmd: string, ...args: string[]): this;
+  in(...paths: string[]): this;
+  verbose(v: boolean): this;
+
+  get chai(): typeof chai;
+  get expect(): typeof chai.expect;
+  get assert(): typeof chai.assert;
+  get data(): DataUtil;
+  get cds(): typeof main_cds;
+
+  then(r: (args: { server: http.Server, url: string }) => void): void;
+
+  // get sleep(): (ms: number) => Promise<void>;
+  // get spy(): <T, K extends keyof T>(o: T, f: K) => T[K] extends (...args: infer TArgs) => infer TReturnValue
+  //   ? Spy<TArgs, TReturnValue>
+  //   : Spy;
+}
+
+// typings for spy inspired by @types/sinon
+// interface Spy<TArgs extends any[] = any[], TReturnValue = any> {
+//   (...args: TArgs): TReturnValue;
+//   called: number;
+//   restore(): (...args: TArgs) => TReturnValue;
+// }
+
+export = cds
+
+declare class cds {
+  test(projectDir: string): Test;
+}

package/apis/utils.d.ts

@@ -0,0 +1,15 @@
+export = cds
+
+declare class cds {
+
+	/**
+	 * Provides a set of utility functionss
+	 */
+	utils : {
+		/**
+		 * Generates a new v4 UUID
+		 * @see https://cap.cloud.sap/docs/node.js/cds-facade#cds-utils
+		 */
+		uuid () : string
+	}
+}

package/app/fiori/preview.js

@@ -246,6 +246,7 @@ cds.on('served', ()=>{
 
   // 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)))