@sap/cds 6.6.2 → 6.7.1

package/CHANGELOG.md

@@ -4,6 +4,77 @@
 - The format is based on [Keep a Changelog](http://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](http://semver.org/).
 
+## Version 6.7.1 - 2023-04-14
+
+### Changed
+
+- Calling a parameterized view without params error now results in the status code 400 with an improved error message.
+
+### Fixed
+
+- cds build error CreateListFromArrayLike
+- Disabling of arbitrary user config in mock auth config using `"users": { "*": false }`
+- Various fixes for `cds.fiori.lean_draft`
+- User attributes that look like numbers are quoted in SQL clause for `@restrict`
+
+## Version 6.7.0 - 2023-03-28
+
+### Added
+
+- Config `cds.ql.quirks_mode` as a compatibility flag to still support behaviours which are undocumented, or even against the specifications, for example CQN:
+   ```js
+   let q = INSERT.into('Books') 
+   //> According to CQN spec should return:
+   {SELECT:{from:{ref:['Books']}}}
+   //> But today returns:
+   {SELECT:{from:'Books'}}
+   ```
+   The default in cds6 is `true` → to be changed to `false` with cds7.
+- `cds build` now checks extension point restrictions defined by the SaaS app provider. `cds build` fails if any restrictions are violated.
+- Typings for `cds.spawn()`
+- Typings for `entity.drafts`
+- Typings for winston logger
+- Typings for `service.on`, `service.before`, and `service.after` for actions and CRUD events
+- CLI command `cds env` now allows property paths with `/` instead of `.`, which allows usages like that:
+```sh
+cds env requires/cds.xt.ModelProviderService
+```
+- `cds.env` now allows to statically set/add profiles via `cds.profile` and `cds.profiles` in package.json.
+- `cds.env` now also supports using profiles in definitions of presets, i.e., in `cds.requires.kinds`.
+- `cds deploy` prints a warning when using Cloud Foundry client version less than 8.
+- `req.subject` to conveniently operate on the subjects targeted by the request. Example usage:
+  SELECT.one.from(req.subject)   //> returns single
+  SELECT.from(req.subject)      //> returns array
+  UPDATE(req.subject)          //> updates one or many
+  DELETE(req.subject)         //> deletes one or many
+- `cds-serve` as a future replacement for `cds serve` in npm scripts. Applications can adopt this now to ease the transition to the next major version.
+
+### Changed
+
+- `cds.log().trace()` now logs stack traces in `DEBUG` level, before that was on `TRACE`/`SILLY` level only
+- Plain SQL queries now have `req.event === undefined`, formerly this had non-deterministic values.
+- Plain SQL queries don't allow to register custom handlers, other than for event `'*'`.
+- Plain SQL queries are only supported on database services, not on application services.
+- CQN representation of `columns=*` is not allowed anymore, instead `columns=['*']` should be used. This also applies to expand.
+- Only draft roots can be created via direct, non-navigation OData `POST` requests.
+- Flag `cds.features.fiori_preview` changed to `cds.fiori.preview`. The old flag still works as well.
+- Flag `cds.features.fiori_routes` changed to `cds.fiori.routes`. The old flag still works as well.
+
+### Fixed
+
+- Proper handling of `IsActiveEntity` in error paths
+- For cloudevents using AMQP, the type is set to `application/cloudevents+json`
+- Use `message` property in typings.
+- Typings for `cds.on('bootstrap', app => {app.use(...)`
+- Return types for `User` and `delete` in typescript
+- Typings for connect options
+- Typings for `req.error`
+- Deployment in sidecar
+- Error with restricting an entity and request it with $apply in combination with aggregate
+- Combined usage of `$skiptoken` and `$skip`
+- Error `package.json file is missing` in mtx extension builds
+- CLI commands w/ unknown arguments (`cds --foo`) clearly fail again with a proper error message
+
 ## Version 6.6.2 - 2023-03-17
 
 ### Fixed
@@ -29,15 +100,14 @@
 ## Version 6.6.0 - 2023-02-27
 
 ### Added
-
 - Improved error handling for `cds build` if the SaaS base model is missing in an extension project.
 - Support for reliable paging using `$skiptoken`. Can be activated via `cds.query.limit.reliablePaging = true`
+- Built-in models are now added to existing model options of custom build tasks.
 
 ### Changed
 
 - `cds.serve(ServiceName)` (and `cds serve -s ServiceName`) now exactly serve services with the given names. Previously, all services that ended with the given name were served as well, e.g. `MyServiceName` and `ServiceName`, which might be problematic for applications that bootstrap services one by one.
 - Optimize `@cds.persistence.journal` filtering for `last-dev` CSN file.
-- `process.exit()` is no longer called during server shutdown, so that other/custom exit handlers get a chance to execute.
 
 ### Fixed
 

package/README.md

@@ -4,7 +4,7 @@ The API package for the [SAP Cloud Application Programming Model (CAP)](https://
 
 See the [API documentation](https://cap.cloud.sap/docs/node.js/api) for more details.
 
-## How to Obtain Support**
+## How to Obtain Support
 
 In case you find a bug, please report an [incident](https://cap.cloud.sap/docs/resources/#reporting-incidents) on SAP Support Portal.
 

package/apis/connect.d.ts

@@ -7,9 +7,15 @@ declare class cds {
 	connect : {
 		/**
 		 * Connects to a specific datasource.
-		 * @see [capire](https://cap.cloud.sap/docs/node.js/api#cds-connect)
+		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
 		 */
-		to (datasource?: string, options?: ConnectOptions) : Promise<Service>
+		to (datasource: string, options?: ConnectOptions) : Promise<Service>
+
+		/**
+		 * Connects to a specific datasource via options.
+		 * @see [capire](https://cap.cloud.sap/docs/node.js/cds-connect#cds-connect-to)
+		 */
+		to (options: ConnectOptions) : Promise<Service>
 
 		/**
 		 * Connects the primary datasource.
@@ -25,9 +31,10 @@ declare class cds {
 
 }
 
-
 type ConnectOptions = {
+    impl?: string,
+	service?: string,
 	kind?:string,
 	model?:string,
-	credentials: object,
+	credentials?: object
 }

package/apis/core.d.ts

@@ -4,7 +4,7 @@ import { CSN as csn, Definition } from './csn'
 
 type UserInput = string | { id: string; attr: Record<string, string>; roles: Record<string, string> } | User
 
-declare class User {
+export class User {
   constructor(obj?: UserInput)
   id: string
   /**

package/apis/csn.d.ts

@@ -66,6 +66,7 @@ export interface entity extends struct {
     keys : {
         [name:string]: Definition
     }
+    drafts: entity
 }
 
 export interface Association extends type {

package/apis/internal/inference.d.ts

@@ -3,7 +3,7 @@
 // in several places within the API.
 
 
-export interface Constructable<T> {
+export interface Constructable<T = any> {
 	new(...args: any[]): T
 }
 
@@ -16,4 +16,17 @@ export interface ArrayConstructable<T = any> {
 
 // concrete singular type.
 // `SingularType<typeof Books>` == `Book`.
-export type SingularType<T extends ArrayConstructable<T>> = InstanceType<T>[number]
+export type SingularType<T extends ArrayConstructable<T>> = InstanceType<T>[number]
+
+// Convenient way of unwrapping the inner type from array-typed values, as well as the value type itself
+// `class MyArray<T> extends Array<T>``
+// The latter is used heavily in the CDS typer, but its behaviour depends based on how the types are imported:
+// If they are imported on a value based (`require('path/to/type')`) they will be considered `ArrayConstructable`.
+// But if they are being used on type level (JSDOC: `/* @type {import('path/to/type')} */`) they are considered an `Array` .
+// This type introduces an indirection that streamlines their behaviour for both cases.
+// For any scalar type `Unwrap` behaves idempotent.
+export type Unwrap<T> = T extends ArrayConstructable
+  ? SingularType<T>
+  : T extends Array<infer U>
+  ? U
+  : T

package/apis/log.d.ts

@@ -55,6 +55,16 @@ declare type LogFactory = {
      * The formatter shall return an array of arguments, which are passed to the logger (for example, `console.log()`)
      */
     format: Formatter
+    
+    /**
+     * Set a custom logger.
+     * ```
+     *   cds.log.Logger = ...
+     * ```
+     */
+    Logger: Logger
+
+    winstonLogger (LoggerOptions?: {level?: string, levels?: any, format?: any, transports?: any, exitOnError?: boolean | Function, silent?: boolean})
 }
 
 declare class Logger {

package/apis/serve.d.ts

@@ -1,12 +1,7 @@
 import { Service, ServiceImpl } from "./services"
 import { LinkedDefinition } from "./reflect"
 import { csn } from "./csn"
-import * as http from "http";
-
-// stub to avoid hard dependencies for typescript projects
-declare namespace express {
-	interface Application {}
-}
+import * as http from "http"
 
 // export const Service : _Service
 
@@ -14,7 +9,7 @@ interface _fluent {
 	from (model : string | csn) : this
 	to (protocol: string) : this
 	at (path: string) : this
-	in (app: express.Application) : this
+	in <T = any> (app: T) : this
 	with (impl: ServiceImpl | string) : this
 	// (req,res) : void
 }
@@ -45,8 +40,8 @@ declare class cds_serve {
 	 * express application has been constructed but no middlewares or routes
 	 * added yet.
 	 */
-	on   (event : 'bootstrap', listener : (app : express.Application) => void) : this
-	once (event : 'bootstrap', listener : (app : express.Application) => void) : this
+	on <T = any> (event : 'bootstrap', listener : (app : T) => void) : this
+	once <T = any>(event : 'bootstrap', listener : (app : T) => void) : this
 
 	/**
 	 * Emitted for each service served by cds.serve().

package/apis/services.d.ts

@@ -1,8 +1,10 @@
 import { SELECT, INSERT, UPDATE, DELETE, Query, ConstructedQuery, UPSERT } from './ql'
 import { Projection, Proxy, Awaitable } from './ql'
-import { ArrayConstructable } from './internal/inference'
+import { ArrayConstructable, Unwrap, SingularType, Constructable } from './internal/inference'
 import { LinkedModel, Definition, Definitions } from './reflect'
 import { csn, type } from './csn'
+import { User } from './core'
+import { ref } from './cqn'
 // import { Service } from './cds'
 
 export class QueryAPI {
@@ -83,6 +85,11 @@ export class QueryAPI {
    */
   tx(context?: object): Transaction
   transaction(context?: object): Transaction
+  
+  /**
+   * @see [docs](https://pages.github.tools.sap/cap/docs/node.js/cds-context-tx?q=spawn#cds-spawn)
+   */
+  spawn(options: Options, fn: (tx: Transaction) => {}): SpawnEventEmitter
 }
 
 /**
@@ -186,7 +193,7 @@ export class Service extends QueryAPI {
    * Constructs and sends a DELETE request.
    */
   delete: {
-    (entityOrPath: Target, data?: object): DELETE<T>
+    <T = any>(entityOrPath: Target, data?: object): DELETE<T>
     <T extends ArrayConstructable<any>>(entity: T, key?: any): DELETE<T>
     <T>(entity: Definition | string, key?: any): DELETE<T>
   }
@@ -196,14 +203,21 @@ export class Service extends QueryAPI {
 
   // Provider API
   prepend(fn: ServiceImpl): Promise<this>
+  on<T extends Constructable>(eve: Events, entity: T, handler: CRUDEventHandler.On<InstanceType<T>, InstanceType<T> | void | Error>): this
+  on<P,R>(boundAction: (args: P) => R, service: string, handler: ActionEventHandler<P, void | Error | R>): this
+  on<P,R>(action: (args: P) => R, handler: ActionEventHandler<P, void | Error | R>): this
   on(eve: Events, entity: Target, handler: OnEventHandler): this
   on(eve: Events, handler: OnEventHandler): this
+
+
   // onSucceeded (eve: Events, entity: Target, handler: EventHandler): this
   // onSucceeded (eve: Events, handler: EventHandler): this
   // onFailed (eve: Events, entity: Target, handler: EventHandler): this
   // onFailed (eve: Events, handler: EventHandler): this
+  before<T extends Constructable>(eve: Events, entity: T, handler: CRUDEventHandler.Before<InstanceType<T>, InstanceType<T> | void | Error>): this
   before(eve: Events, entity: Target, handler: EventHandler): this
   before(eve: Events, handler: EventHandler): this
+  after<T extends Constructable>(eve: Events, entity: T, handler: CRUDEventHandler.After<InstanceType<T>, InstanceType<T> | void | Error>): this
   after(eve: Events, entity: Target, handler: ResultsHandler): this
   after(eve: Events, handler: ResultsHandler): this
   reject(eves: Events, ...entity: Target[]): this
@@ -263,6 +277,35 @@ export interface OnEventHandler {
   (req: Request, next: Function): Promise<any> | any | void
 }
 
+// `Partial` wraps any type and allows all properties to be undefined
+// in addition to their actual type.
+// This is important in the context of CRUD events, where
+// entities could be lacking any properties, like a non-existing ID
+// or when DB fields are corrupted, etc.
+type Partial<T> = { [Key in keyof T]: undefined | T[Key] }
+
+// Naming the first parameter in a handler `each` has special voodoo
+// semantic which makes it impossible for us to infer the exact behaviour on a type level.
+// So we always have to expect scalars as well as arrays in some callbacks.
+type OneOrMany<T> = T | T[];
+
+type TypedRequest<T> = Omit<Request, 'data'> & { data: T }
+
+// https://cap.cloud.sap/docs/node.js/services#event-handlers
+export namespace CRUDEventHandler {
+  type Before<P,R> = (req: TypedRequest<P>) => Promise<R> | R
+  type On<P,R> = (req: TypedRequest<P>, next: (...args: any) => Promise<R> | R) => Promise<R> | R
+  type After<P,R> = (data: undefined | P, req: TypedRequest<P>) => Promise<R> | R
+}
+
+// Handlers for actions try to infer the passed .data property
+// as strictly as possible and therefore have to remove
+// { data: any } (inherited EventMessage} with a more restricted
+// type, based on the parameters of the action.
+export interface ActionEventHandler<P,R> {
+  (req: Omit<Request, 'data'> & { data: P }, next: Function): Promise<R> | R
+}
+
 // Note: the behaviour of ResultsHandler changes based on the name of the parameter.
 // If the parameter in the hook is called "each", it is called once for each row in the result,
 // otherwise it gets called exactly one time with the entire result.
@@ -296,6 +339,29 @@ interface EventMessage extends EventContext {
   headers: {}
 }
 
+interface SpawnEvents {
+  'succeeded': (res: any) => void
+  'failed': (error: any) => void
+  'done': () => void
+}
+
+class SpawnEventEmitter {
+  on<U extends keyof SpawnEvents>(
+    event: U, listener: SpawnEvents[U]
+  ): this;
+
+  emit<U extends keyof SpawnEvents>(
+    event: U, ...args: Parameters<SpawnEvents[U]>
+  ): boolean;
+  timer: any
+}
+
+interface Options {
+  [key: string]: any
+  every?: number
+  after?: number
+}
+
 /**
  * @see [capire docs](https://cap.cloud.sap/docs/node.js/requests)
  */
@@ -311,26 +377,27 @@ interface Request extends EventMessage {
    */
   entity: string
   query: Query
+  subject: ref
 
   reply(results: any): void
 
-  notify(code: number, msg: string, target?: string, args?: {}): Error
-  info(code: number, msg: string, target?: string, args?: {}): Error
-  warn(code: number, msg: string, target?: string, args?: {}): Error
-  error(code: number, msg: string, target?: string, args?: {}): Error
-  reject(code: number, msg: string, target?: string, args?: {}): Error
-
-  notify(msg: string, target?: string, args?: {}): Error
-  info(msg: string, target?: string, args?: {}): Error
-  warn(msg: string, target?: string, args?: {}): Error
-  error(msg: string, target?: string, args?: {}): Error
-  reject(msg: string, target?: string, args?: {}): Error
-
-  notify(msg: { code?: number | string; msg: string; target?: string; args?: {} }): Error
-  info(msg: { code?: number | string; msg: string; target?: string; args?: {} }): Error
-  warn(msg: { code?: number | string; msg: string; target?: string; args?: {} }): Error
-  error(msg: { code?: number | string; msg: string; target?: string; args?: {} }): Error
-  reject(msg: { code?: number | string; msg: string; target?: string; args?: {} }): Error
+  notify(code: number, message: string, target?: string, args?: {}): Error
+  info(code: number, message: string, target?: string, args?: {}): Error
+  warn(code: number, message: string, target?: string, args?: {}): Error
+  error(code: number, message: string, target?: string, args?: {}): Error
+  reject(code: number, message: string, target?: string, args?: {}): Error
+
+  notify(message: string, target?: string, args?: {}): Error
+  info(message: string, target?: string, args?: {}): Error
+  warn(message: string, target?: string, args?: {}): Error
+  error(message: string, target?: string, args?: {}): Error
+  reject(message: string, target?: string, args?: {}): Error
+
+  notify(message: { code?: number | string; message: string; target?: string; args?: {} }): Error
+  info(message: { code?: number | string; message: string; target?: string; args?: {} }): Error
+  warn(message: { code?: number | string; message: string; target?: string; args?: {} }): Error
+  error(message: { code?: number | string; message: string; target?: string; args?: {}, status?: number }): Error
+  reject(message: { code?: number | string; message: string; target?: string; args?: {}, status?: number }): Error
 }
 
 type Events = Event | Event[]

package/bin/build/buildTaskEngine.js

@@ -3,7 +3,7 @@ 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, CDS_MODEL_EXCLUDE_LIST } = require('./constants')
+const { OUTPUT_MODE_DEFAULT, SEVERITIES, LOG_LEVELS, LOG_MODULE_NAMES } = require('./constants')
 const BuildTaskProviderFactory = require('./buildTaskProviderFactory')
 const BuildTaskHandlerInternal = require('./provider/buildTaskHandlerInternal')
 
@@ -42,13 +42,10 @@ class BuildTaskEngine {
         }
 
         // validate required @sap namespace models - log only
-        const { unresolved, missing } = BuildTaskEngine._resolveRequiredSapServices(tasks)
+        const unresolved = BuildTaskEngine._resolveRequiredSapServices(tasks)
         if (unresolved.length > 0) {
             messages.push(new BuildMessage(`Required CDS service models [${unresolved.join(', ')}] cannot be resolved. Make sure to install the missing npm modules.`))
         }
-        if (missing.length > 0) {
-            messages.push(new BuildMessage(`Required CDS service models [${missing.join(', ')}] are missing in custom build tasks. Make sure to add the missing models.`))
-        }
 
         // create build task handlers
         const handlers = []
@@ -184,7 +181,7 @@ class BuildTaskEngine {
                         return Promise.resolve({
                             task: handler.task,
                             result: handlerResult,
-                            messages: BuildTaskEngine._sortCompilationErrorsUnique(buildOptions, handler.messages)
+                            messages: BuildTaskEngine._sortMessagesUnique(buildOptions, handler.messages)
                         })
                     })
             }))
@@ -206,28 +203,21 @@ class BuildTaskEngine {
         }, [])
 
         if (errors.length > 0) {
-            const internalError = errors.find(e => e.constructor.name !== COMPILATION_ERROR && e.name !== BuildError.name)
-            if (internalError) {
-                throw internalError
+            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)
-            let buildErrors = []
-            // NOTE: The order is important for now as for compatibility reasons the origin CompilationError
-            // is thrown in processTasks method.
-            // 1. compiler warnings are returned as handler messages
             const compileMessages = handlerMessages.filter(message => message.constructor.name === COMPILE_MESSAGE)
-            if (compileErrors.length > 0) {
-                const compileError = new CompilationError(BuildTaskEngine._sortCompilationErrorsUnique(buildOptions, BuildTaskEngine._getErrorMessages(compileErrors), compileMessages))
-                buildErrors.push(compileError)
+            if (compileErrors.length) {
+                throw new CompilationError(BuildTaskEngine._sortMessagesUnique(buildOptions, BuildTaskEngine._getErrorMessages(compileErrors), compileMessages))
             }
-
-            // 2. add other build errors
-            buildErrors = buildErrors.concat(errors.filter(e => e.name === BuildError.name))
-
-            // 3. add messages from build tasks
-            buildErrors = buildErrors.concat(handlerMessages.filter(message => message.name === BuildMessage.name))
-
-            throw new BuildError(`CDS build failed for [${buildOptions.root}]`, buildErrors)
         }
         return resolvedResults
     }
@@ -312,23 +302,7 @@ class BuildTaskEngine {
             return acc
         }, new Set())
 
-        const srvModelPaths = [...Object.keys(cds.env.requires || {}).reduce((acc, srvName) => {
-            const model = cds.env.requires[srvName]?.model;
-            if (model) {
-                if (Array.isArray(model)) {
-                    model.forEach(m => acc.add(m))
-                } else {
-                    acc.add(model)
-                }
-            }
-            return acc
-        }, new Set())]
-
-        const unresolved = resolveRequiredSapModels([...taskModelPaths])
-        // are the required service models contained in the task's options.model
-        const missing = srvModelPaths.filter(m => m.startsWith('@sap/') && !CDS_MODEL_EXCLUDE_LIST.includes(m) && !taskModelPaths.has(m) && !unresolved.find(u => u === m))
-
-        return { unresolved, missing }
+        return resolveRequiredSapModels([...taskModelPaths])
     }
 
     /**
@@ -363,7 +337,7 @@ class BuildTaskEngine {
      * @param {object} buildOptions
      * @param  {...Error} messages
      */
-    static _sortCompilationErrorsUnique(buildOptions, ...messages) {
+    static _sortMessagesUnique(buildOptions, ...messages) {
         const logLevelIdx = LOG_LEVELS.indexOf(this._getLogLevel(buildOptions))
         // flatten
         messages = messages.reduce((acc, m) => acc.concat(m), [])

package/bin/build/constants.js

@@ -20,7 +20,7 @@ exports.BUILD_TASKS = [this.BUILD_TASK_JAVA, this.BUILD_TASK_JAVA_CF, this.BUILD
 exports.ODATA_VERSION_V2 = "v2"
 exports.ODATA_VERSION_V4 = "v4"
 
-exports.BUILD_NODEJS_EDMX_GENERAION = "build.nodejs.edmxgeneration" // WebIDE Fullstack
+exports.BUILD_NODEJS_EDMX_GENERATION = "build.nodejs.edmxgeneration" // WebIDE Fullstack
 exports.EDMX_GENERATION = "edmxGeneration"
 
 exports.SKIP_MANIFEST_GENERATION = "skipManifestGeneration"
@@ -40,13 +40,15 @@ exports.CONTENT_NODE_MODULES = "contentNodeModules"         // copy node_modules
 exports.CONTENT_ENV = "contentEnv"                          // copy .env file if existing into deployment folder
 exports.CONTENT_DEFAULT_ENV_JSON = "contentDefaultEnvJson"  // copy default-env.json file if existing into deployment folder
 exports.CSV_FILE_DETECTION = "csvFileDetection"             // detect CSV files based on CDS model location
+exports.EXTENSION_POINT_VALIDATION = "extensionPointValidation" // validate extension point restrictions defined by the extended SaaS app
+exports.DEFAULT_BUILT_IN_MODELS = "defaultBuiltInModels"    // add @sap/cds* built-in models to build tasks
 
 exports.FOLDER_GEN = "gen"
 exports.FILE_EXT_CDS = ".cds"
 exports.MTX_SIDECAR_FOLDER = "mtx/sidecar"                  // default name of the mtx sidecar folder
 exports.DEFAULT_CSN_FILE_NAME = "csn.json"
 // REVISIT: the models are not required if a custom server.js file is used for MTX bootstrap
-exports.CDS_MODEL_EXCLUDE_LIST = ['@sap/cds/srv/mtx', '@sap/cds-mtxs/srv/bootstrap']
+exports.NODEJS_MODEL_EXCLUDE_LIST = ['@sap/cds/srv/mtx', '@sap/cds-mtxs/srv/bootstrap']
 
 exports.CDS_CONFIG_PATH_SEP = "/"
 exports.SKIP_ASSERT_COMPILER_V2 = "skip-assert-compiler-v2"