@sap/cds 6.8.4 → 7.0.1

package/lib/index.js

@@ -1,167 +1,141 @@
-/** @typedef {import './serve/Service-api'} Service */
+if (process.env.CDS_STRICT_NODE_VERSION !== 'false') require('./utils/check-version')
 
-const facade = class cds extends require('events') {
+const { extend, lazify, lazified } = require('./lazy')
+const { EventEmitter } = require('node:events')
 
-  get env()      { return super.env = require('./env/cds-env').for('cds',cds.root) }
+const cds = module.exports = new class cds extends EventEmitter {
+
+  // Configuration & Information
   get requires() { return super.requires = this.env.requires._resolved() }
+  get plugins()  { return super.plugins = require('./plugins') }
   get version()  { return super.version = require('../package.json').version }
-  get builtin()  { return super.builtin = require('./core') }
-  get service()  { return super.service = extend(this.builtin.classes.service) .with (_service) }
-  get _context() { return super._context = require('./req/cds-context') }
-  get context() { return this._context._for(this) }
-  set context(_){ this._context._for(this,_) }
-  get spawn() { return super.spawn = this._context.spawn }
+  get env()      { return super.env = require('./env/cds-env').for('cds',this.root) }
+  get home()     { return super.home = __dirname.slice(0,-4) }
+  cli = { command:'', options:{}, argv:[] }
+  root = process.cwd()
 
+  // Loading and Compiling Models
+  get compiler() { return super.compiler = require('./compile/cdsc') }
+  get compile()  { return super.compile = require('./compile/cds-compile') }
+  get resolve()  { return super.resolve = require('./compile/resolve') }
+  get load()     { return super.load = require('./compile/load') }
+  get get()      { return super.get = this.load.parsed }
+  get parse()    { return super.parse = require('./compile/parse') }
+  get minify()   { return super.minify = require('./compile/minify') }
+  get extend()   { return super.extend = require('./compile/extend') }
+  get deploy()   { return super.deploy = require('./dbs/cds-deploy') }
+  get localize() { return super.localize = require('./i18n/localize') }
+  get build()    { return () => { throw new Error('This application uses @sap/cds version >= 7, which is not compatible with the installed @sap/cds-dk version 6. Either update @sap/cds-dk to version 7 or downgrade @sap/cds to version 6 instead.') } }
+  /** @type {{definitions:{},extensions:[]}} */ model = undefined
+  /** @type Service */ db = undefined
+
+  // Model Reflection, Builtin types and classes
+  get reflect()     { return super.reflect = this.linked }
+  get linked()      { return super.linked = require('./linked/models') }
+  get infer()       { return super.infer = require('./linked/queries') }
+  get builtin()     { return super.builtin = require('./linked/types') }
+  get Association() { return super.Association = this.builtin.classes.Association }
+  get Composition() { return super.Composition = this.builtin.classes.Composition }
+  get entity()      { return super.entity = this.builtin.classes.entity }
+  get event()       { return super.event = this.builtin.classes.event }
+  get type()        { return super.type = this.builtin.classes.type }
+  get array()       { return super.array = this.builtin.classes.array }
+  get struct()      { return super.struct = this.builtin.classes.struct }
+  get service()     { return super.service = extend (this.builtin.classes.service) .with (lazified({
+    impl: (/** @type {(this:Service, srv:Service, ...etc) => any} */ srv) => srv,
+    protocols: lazy => require('./srv/protocols'),
+    bindings: lazy => require('./srv/bindings'),
+    factory: lazy => require('./srv/factory'),
+    /** @type Service[] */ providers: []
+  }))}
+
+  // Providing and Consuming Services
+  /** @type {{ [name:string]: Service }} */
+  services = Object.defineProperties (new class { *[Symbol.iterator](){ for (let e in this) yield this[e] } },{
+    _pending: {value:{}}
+  })
+  get server() { return super.server = require('../server') }
+  get serve() { return super.serve = require('./srv/cds-serve') }
+  get connect() { return super.connect = require('./srv/cds-connect') }
+  get middlewares() { return super.middlewares = require('./srv/middlewares') }
+  get odata() { return super.odata = require('../libx/odata') }
+  get auth() { return super.auth = require('./auth') }
+
+  // awaiting async functions for some events
   async emit (eve, ...args) {
-    // if (eve === 'served') return Promise.all (this.listeners(eve).map (l => l.call(this,...args)))
     if (eve === 'served') for (let l of this.listeners(eve)) await l.call(this,...args)
     else return super.emit (eve, ...args)
   }
-}
-
-const { extend, lazify, lazified } = require ('./lazy')
-const _class = lazy => cds.builtin.classes [lazy]
-const _require = require; require = lazified (module)  // eslint-disable-line
-const _service = lazified ({ // nested facade for service-related modules
-  /** @param x {(this:Service, srv:Service, ...etc) => any} */ impl: x=>x,
-  /** @type Service[] */ providers: [],
-  factory: require ('./srv/factory'),
-  protocols: require ('./srv/protocols'),
-  bindings: require ('./srv/bindings'),
-})
-
-/** cds is the central facade to all cds functions */
-const cds = module.exports = extend (new facade) .with ({
-
-  // Builtin types and classes
-  Association:_class,
-  Composition:_class,
-  entity:_class,
-  event:_class,
-  type:_class,
-  array:_class,
-  struct:_class,
-
-  // Model Reflection
-  reflect: require ('./core/reflect'),
-  linked: require ('./core/reflect'),
-  infer: require ('./core/infer'),
-
-  // Loading and Compiling Models
-  model: undefined,
-  compiler: require ('./compile/cdsc'),
-  compile: require ('./compile/cds-compile'),
-  resolve: require ('./compile/resolve'),
-  load: require ('./compile/load'), get: lazy => cds.load.parsed,
-  parse: require ('./compile/parse'),
-  minify: require ('./compile/minify'),
-  extend: require ('./compile/extend'),
-  deploy: require ('./dbs/cds-deploy'),
-
-  // Providing and Consuming Services
-  connect: require ('./srv/cds-connect'),
-  serve: require ('./srv/cds-serve'),
-  server: require ('../server'),
-  services: new class IterableServices {
-    *[Symbol.iterator]() {for (let e in this) yield this[e]}
-    get _pending(){ let p={}; Object.defineProperty(this,'_pending',{value:p}); return p  }
-  },
-  middlewares: require('./srv/middlewares'),
-  auth: require ('./auth'),
 
   // Core Services API
-  Service: require ('./srv/srv-api'),
-  EventContext: require ('./req/context'),
-  Request: require ('./req/request'),
-  Event: require ('./req/event'),
-  User: require ('./req/user'),
-  ql: lazy => require ('./ql/cds-ql'),
-  tx: (..._) => (cds.db || cds.Service.prototype) .tx (..._),
-  inferred: lazy => require('@cap-js/sqlite/lib/ql/cds.infer'), // eslint-disable-line cds/no-missing-dependencies
-  cqn2sql: lazy => require('@cap-js/sqlite/lib/db/sql/cqn2sql'), // eslint-disable-line cds/no-missing-dependencies
-  cqn4sql: lazy => require('@cap-js/sqlite/lib/db/sql/cqn4sql'), // eslint-disable-line cds/no-missing-dependencies
-  /** @type Service */ db: undefined,
-
-  // Protocols and Periphery
-  ApplicationService: lazy => require('../libx/_runtime/cds-services/services/Service.js'),
-  MessagingService: lazy => require('../libx/_runtime/messaging/service.js'),
-  DatabaseService: lazy => require('../libx/_runtime/db/Service.js'),
-  RemoteService: lazy => require('../libx/_runtime/remote/Service.js'),
-  AuditLogService: lazy => require('../libx/_runtime/audit/Service.js'),
-  odata: require('../libx/odata'),
+  /** @typedef {import './srv/srv-api'} Service */
+  get Service() { return super.Service = require('./srv/srv-api') }
+  get EventContext() { return super.EventContext = require('./req/context') }
+  get Request() { return super.Request = require('./req/request') }
+  get Event() { return super.Event = require('./req/event') }
+  get User() { return super.User = require('./req/user') }
+
+  // Services, Protocols and Periphery
+  get ApplicationService() { return super.ApplicationService = require('../libx/_runtime/cds-services/services/Service.js') }
+  get MessagingService() { return super.MessagingService = require('../libx/_runtime/messaging/service.js') }
+  get DatabaseService() { return super.DatabaseService = require('../libx/_runtime/db/Service.js') }
+  get RemoteService() { return super.RemoteService = require('../libx/_runtime/remote/Service.js') }
+
+  // Contexts and Transactions
+  get _context() { return super._context = require('./req/cds-context') }
+  get context()  { return this._context._for(this) }
+  set context(_) { this._context._for(this,_) }
+  get spawn()    { return super.spawn = this._context.spawn }
+  tx(..._) { return (this.db || this.Service.prototype) .tx (..._) }
 
   // Helpers
-  localize: require ('./i18n/localize'),
-  error: require ('./log/cds-error'),
-  utils: require ('./utils/cds-utils'),
-  test: require ('./utils/cds-test'),
-  log: require ('./log/cds-log'), debug: lazy => cds.log.debug,
-  exec: require ('../bin/cds'),
-  exit: (code) => cds.shutdown ? cds.shutdown() : process.exit(code),
-  clone: m => JSON.parse (JSON.stringify(m)),
-  lazified, lazify,
-
-  // Configuration & Information
-  home: __dirname.slice(0,-4),
-  root: lazy => process.cwd(),
-
-})
-
-
-// cds as shortcut to cds.db -> for compatibility only
-extend (cds.__proto__) .with ({
-  get entities(){ return (cds.db||_missing).entities },
-  transaction: (..._) => (cds.db||_missing).transaction(..._),
-  run:         (..._) => (cds.db||_missing).run(..._),
-  foreach:     (..._) => (cds.db||_missing).foreach(..._),
-  stream:      (..._) => (cds.db||_missing).stream(..._),
-  read:        (..._) => (cds.db||_missing).read(..._),
-  create:      (..._) => (cds.db||_missing).create(..._),
-  insert:      (..._) => (cds.db||_missing).insert(..._),
-  update:      (..._) => (cds.db||_missing).update(..._),
-  delete:      (..._) => (cds.db||_missing).delete(..._),
-  disconnect:  (..._) => (cds.db||_missing).disconnect(..._),
-})
-/** @type Service */ const _missing = new Proxy ({},{
-  get:function fn(_,p){ cds.error._no_primary_db(p,fn) }
-})
-
-// legacy and to be moved stuff -> hidden for tools in cds.__proto__
-extend (cds.__proto__) .with (lazified ({
-  /** @deprecated */ in: (cwd) => !cwd ? cds : {__proto__:cds, cwd, env: cds.env.for('cds',cwd) },
-  mtx: lazy => require('../bin/mtx/in-cds'),
-  build: lazy => require('../bin/build')
-}))
-
-// Add global forwards to cds.ql and cds.parse
-const odp = Object.defineProperty, _global = (_,...pp) => pp.forEach (p => odp(global,p,{
-  configurable:true, get:()=>{ let v=cds[_][p]; odp(this,p,{value:v}); return v }
-}))
-_global ('ql','SELECT','INSERT','UPSERT','UPDATE','DELETE','CREATE','DROP','STREAM')
-_global ('parse','CDL','CQL','CXL')
-
-// Check Node.js version
-if (process.env.CDS_STRICT_NODE_VERSION !== 'false') {
-  const v = version => { let vv = version.split('.'); return { version, major: +vv[0], minor: +vv[1] }}
-  const required = v(_require('../package.json').engines.node.match(/>=(.*)/)[1])
-  const given = v(process.version.match(/^v(\d+\.\d+)/)[1])
-  if (given.major < required.major || given.major === required.major && given.minor < required.minor) process.exit (process.stderr.write (`
-  Node.js v${required.version} or higher is required for @sap/cds.
-  Current v${given.version} does not satisfy this.
-  \n`) || 1)
+  get utils() { return super.utils = require('./utils/cds-utils') }
+  get error() { return super.error = require('./log/cds-error') }
+  get exec() { return super.exec = require('../bin/cds-serve') }
+  get test() { return super.test = require('./utils/cds-test') }
+  get log() { return super.log = require('./log/cds-log') }
+  get debug() { return super.debug = this.log.debug }
+  get lazify(){ return lazify }
+  get lazified(){ return lazify }
+  clone(m) { return JSON.parse (JSON.stringify(m)) }
+  exit(code){ return cds.shutdown ? cds.shutdown() : process.exit(code) }
+
+  // Querying and Databases
+  get ql() { return super.ql = require('./ql/cds-ql') }
+  get entities()     { return this.db?.entities || this.model?.entities }
+  run         (..._) { return (this.db||this.error._no_primary_db).run(..._) }
+  foreach     (..._) { return (this.db||this.error._no_primary_db).foreach(..._) }
+  stream      (..._) { return (this.db||this.error._no_primary_db).stream(..._) }
+  read        (..._) { return (this.db||this.error._no_primary_db).read(..._) }
+  create      (..._) { return (this.db||this.error._no_primary_db).create(..._) }
+  insert      (..._) { return (this.db||this.error._no_primary_db).insert(..._) }
+  update      (..._) { return (this.db||this.error._no_primary_db).update(..._) }
+  delete      (..._) { return (this.db||this.error._no_primary_db).delete(..._) }
+  disconnect  (..._) { return (this.db||this.error._no_primary_db).disconnect(..._) }
+  transaction (..._) { return (this.db||this.error._no_primary_db).transaction(..._) }
+
+  // legacy and to be moved stuff -> hidden for tools in cds.__proto__
+  /** @deprecated */ in (cwd) { return !cwd ? this : {__proto__:this, cwd, env: this.env.for('cds',cwd) } }
 }
 
-// restore require for subsequent uses in lazy getters
-require = _require  // eslint-disable-line
+// add global cds.ql commands
+extend (global) .with (class {
+  static get SELECT() { return cds.ql.SELECT }
+  static get INSERT() { return cds.ql.INSERT }
+  static get UPSERT() { return cds.ql.UPSERT }
+  static get UPDATE() { return cds.ql.UPDATE }
+  static get DELETE() { return cds.ql.DELETE }
+  static get STREAM() { return cds.ql.STREAM }
+  static get CREATE() { return cds.ql.CREATE }
+  static get DROP() { return cds.ql.DROP }
+  static get CDL() { return cds.parse.CDL }
+  static get CQL() { return cds.parse.CQL }
+  static get CXL() { return cds.parse.CXL }
+})
 
 // can be used to later check that one has only one cds object
-if (!global.__cds_loaded_from) global.__cds_loaded_from = new Set
-global.__cds_loaded_from.add(__filename)
-
-if (process.env.CDS_GLOBAL) // TODO for stakeholder-tests only. Remove after cds 6.
-  Object.assign(module,{ exports: global.cds || (global.cds = cds)})
-else
-  global.cds = cds
+;(global.__cds_loaded_from ??= new Set).add(__filename)
+global.cds = cds // REVISIT: using global.cds seems wrong
 
 // install jest util if jest is defined
 if (process.env.CDS_JEST_MEM_FIX && typeof jest !== 'undefined') require('./utils/jest.js')

package/lib/{core/reflect.js → linked/models.js}

@@ -1,4 +1,4 @@
-const { types, classes:{ service, entity, action, event, any, struct, array, context, annotation } } = require('.')
+const { types, classes:{ service, entity, action, event, any, struct, array, context, annotation } } = require('./types')
 const _kinds = { annotation, context, service, action, event, entity, view:entity }
 
 class LinkedCSN extends any {
@@ -98,7 +98,7 @@ class LinkedCSN extends any {
 
 const _unresolved = (x,unknown=any) => ({ name:x, __proto__:unknown.prototype, _unresolved:true })
 const _builtin = x => types[x] || typeof x === 'string' && x.startsWith('cds.hana.') && any.prototype
-const _infer = require('./infer'), _not_inferred = _unresolved('<query>',entity)
+const _infer = require('./queries'), _not_inferred = _unresolved('<query>',entity)
 const _set = (o,p,v) => Object.defineProperty (o,p,{value:v,enumerable:false,configurable:1,writable:1})
 const _own = (o,p) => { const pd = Reflect.getOwnPropertyDescriptor(o,p); return pd && pd.value }
 const _is = x => {

package/lib/{core/infer.js → linked/queries.js}

@@ -8,6 +8,8 @@ module.exports = (q,defs) => {
     q.UPSERT ? _resolve (q.UPSERT.into, defs) :
     q.UPDATE ? _resolve (q.UPDATE.entity, defs) :
     q.DELETE ? _resolve (q.DELETE.from, defs) :
+    q.STREAM?.from ? _resolve (q.STREAM.from, defs) :
+    q.STREAM?.into ? _resolve (q.STREAM.into, defs) :
     _resolve (undefined)
   ), configurable:true, writable:true })
   return q._target

package/lib/{core/index.js → linked/types.js}

@@ -11,7 +11,7 @@ const classes = Object.assign (
 
 /** Type system roots -> can be used with instanceof */
 const roots = _roots ({
-	context: {},
+	any: classes.any.prototype,
 	type: {},
 		scalar: {type:'type'},
 			string: {type:'scalar'},
@@ -25,6 +25,7 @@ const roots = _roots ({
 			event: {type:'struct'},
 	Association: {type:'type'},
 	Composition: {type:'Association'},
+	context: {},
 	service: {type:'context'},
 	$self: {}, //> to support polymorphic self links like in: action foo( self: [many] $self, ...)
 })

package/lib/log/cds-error.js

@@ -16,11 +16,17 @@ const { format } = require('util'), _formatted = v => format(v)
  *
  *     let x = y || cds.error `Argument 'y' must not be null`
  */
-const error = exports = module.exports = function cds_error (msg, _details, _base) {
-  if (msg.raw) [ msg, _details, _base ] = [ error.message(...arguments) ]
-  const e = msg.stack ? msg : typeof msg === 'string' ? new Error(msg) : Object.assign(new Error,msg)
-  Error.captureStackTrace (e,_base||error)
-  if (_details) Object.assign (e,_details)
+const error = exports = module.exports = function cds_error ( message, details, caller ) {
+  let e
+  if (message.raw) [ message, details, caller ] = [ error.message(...arguments) ]
+  if (typeof message === 'string') {
+    e = new Error(message)
+  } else {
+    e = message.stack ? message : Object.assign(new Error,message)
+    ;[ caller, details ] = [ details ]
+  }
+  Error.captureStackTrace (e,caller||error)
+  if (details) Object.assign (e,details)
   if (new.target) return e; else throw e
 }
 
@@ -70,7 +76,7 @@ exports._duplicate_cds = (...locations) => {
   `
 }
 
-exports._no_primary_db = (p,_base) => error (`Not connected to primary datasource!
+exports._no_primary_db = new Proxy ({},{ get: function fn(_,p) { error (`Not connected to primary datasource!
 
   Attempt to use 'cds.${p}' without prior connect to primary datasource,
   i.e. cds.connect.to('db').
@@ -78,4 +84,4 @@ exports._no_primary_db = (p,_base) => error (`Not connected to primary datasourc
   Please configure one thru 'cds.requires.db' or use in-memory db:
   cds ${process.argv[2]} --in-memory` : ''}`
 
-,{},_base)
+,{},fn) }})

package/lib/log/format/cf.js

@@ -10,7 +10,7 @@ module.exports = (module, level, ...args) => {
   toLog.layer = 'cds'
 
   // cds.context._ instead of cds.context.http because of messaging
-  toLog.tenant_subdomain = cds.context?._?.req?.authInfo?.getSubdomain()
+  toLog.tenant_subdomain = cds.context?._?.req?.authInfo?.getSubdomain?.()
 
   return kibana.format(toLog)
 }

package/lib/plugins.js

@@ -0,0 +1,49 @@
+// IMPORTANT We must not use cds.debug/log/env here to allow plugins to change env.defaults
+const DEBUG = /\by|all|plugins\b/.test(process.env.DEBUG)
+const cds = require('.'), { local } = cds.utils
+
+module.exports = (async function load_plugins (log = console.log) {
+
+  if (DEBUG) console.time('[cds] - loaded plugins in')
+  const plugins = {}
+
+  load_from(cds.home) // load well-known plugins from our dependencies
+  load_from(cds.root)
+
+  global._plugins = Object.keys(plugins) // used in cds.env
+  await Promise.all(Object.values(plugins).map(load => load()))
+  if (DEBUG) console.timeEnd('[cds] - loaded plugins in')
+
+  return plugins
+
+  function load_from(pkg_path) {
+    let pkg; try { pkg = require(pkg_path + '/package.json') } catch { return }
+
+    if (pkg.cds?.plugins) {
+      for (let each of pkg.cds.plugins) {
+        let plugin = typeof each === 'string' ? each : each.impl
+        if (plugin.startsWith('.'))
+          plugin = require.resolve(pkg_path + '/' + plugin)
+        _load_plugin(plugin, plugin, each)
+      }
+    } else {
+      const deps = { ...pkg.dependencies, ...(process.env.NODE_ENV !== 'production' && pkg.devDependencies) }
+      const plugins = []
+      for (let each in deps) try {
+        let plugin = require.resolve(each + '/cds-plugin', {paths:[pkg_path]})
+        plugins.push (()=>_load_plugin(each, plugin))
+      } catch { /* no plugin */ }
+      for (let each of plugins) each()
+    }
+
+    function _load_plugin (name, impl, conf) {
+      plugins[name] = async() => {
+        // TODO support ESM plugins.  But see cap/cds/pull/1838#issuecomment-1177200 !
+        const plugin = plugins[name] = require(impl)
+        if (DEBUG) log('[cds] - loaded plugin:', { impl: local(impl) })
+        if (plugin.activate) await plugin.activate(conf)
+      }
+    }
+  }
+
+})()

package/lib/ql/Query.js

@@ -65,17 +65,8 @@ class Query {
   valueOf (cmd=this.cmd) {
     return `${cmd} ${_name(this._target.name)} `
   }
-
-  forSQL (db = cds.db || cds) { return _flat(db.cqn4sql(this)) }
-  toSQL  (db = cds.db || cds) { return _2sql(db.cqn2sql(this)) }
-  toSql  (db = cds.db || cds) { return this.toSQL(db).sql }
-
 }
 
-// skip .cqn property when in repl
-const _2sql = cds.repl ? ({sql,values}) => ({sql,values}) : (x => x)
-const _flat = Query.prototype.flat
-
 const _target4 = (target, arg2) =>  target && (
   typeof target === 'string' ? { name: target } :
   target.name ? target : //> assumed to be a linked csn definition

package/lib/ql/STREAM.js

@@ -35,7 +35,6 @@ module.exports = class Query extends Whereable {
 
     // return a proxy assuming it's a from and switching to
     // column on a subsequent call of .from, if any.
-    const {STREAM:_} = this
     return Object.defineProperties (this.from (col, ...more), {
       from: { configurable:true, value:(...args) => { delete this.from
         return this.from (...args) .column (col, ...more)

package/lib/req/context.js

@@ -1,4 +1,4 @@
-const cds = require ('../index'), { features } = cds.env, { uuid } = cds.utils
+const cds = require ('../index'), { uuid } = cds.utils
 const async_events = { succeeded:1, failed:1, done:1, commit:1 }
 const req_locale = require('./locale')
 const { EventEmitter } = require('events')
@@ -158,7 +158,7 @@ class EventContext {
     super.http = rr
   }
   get http() {
-    return this._propagated.http || this._.req && this._.res && { req:this._.req, res:this._.res }
+    return super.http = this._propagated.http || this._.req && this._.res && { req:this._.req, res:this._.res }
   }
 
 
@@ -173,11 +173,6 @@ class EventContext {
     const root = tx.context?.context
     if (root && root !== this) {
       if (!this.hasOwnProperty('context')) this.context = root // eslint-disable-line no-prototype-builtins
-      if (features.assert_integrity && features.assert_integrity_type == 'RT') {
-        const reqs = root._children || root._set('_children', {})
-        const all = reqs[tx.name] || (reqs[tx.name] = [])
-        all.push(this)
-      }
     }
   }
   get _tx() { return this.tx } // REVISIT: for compatibility to bade usages of req._tx

package/lib/req/request.js

@@ -53,7 +53,7 @@ class Request extends require('./event') {
   set data(d) { if (d) super.data = d }
   get data() {
     const q = this.query; if (!q) return this._set ('data', undefined)
-    const I = q.INSERT; if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) ||{})
+    const I = q.INSERT || q.UPSERT; if (I) return this._set ('data', I.rows || I.values || I.entries && (I.entries.length > 1 ? I.entries : I.entries[0]) ||{})
     const U = q.UPDATE; if (U) return this._set ('data', U.data ||{})
     return this._set ('data', {})
   }
@@ -127,7 +127,11 @@ class Request extends require('./event') {
   warn   (...args) { return this._messages.add (3, ...args) }
   error  (...args) { return this._errors.add (4, ...args) }
   reject (...args) {
-    if (args[0] === 401 && this._.req?.login && !this._.req?.logIn) return this._.req.login()
+    if (args.length === 0 && this.errors) {
+      let errs = this.errors
+      throw errs.length === 1 ? errs[0] : new cds.error ('MULTIPLE_ERRORS', { details: errs }, this.reject)
+    }
+    if (args[0] === 401 && this._.req?._login) this._.req._login()
     let e = this.error(...args)
     if (!e.stack) Error.captureStackTrace (e = Object.assign(new Error,e), this.reject)
     throw e

package/lib/req/response.js

@@ -1,19 +1,33 @@
 const cds = require ('../index')
+const placeholders = [...'x'.repeat(9)].map((x,i) => `{${i+1}}`)
 
 /**
  * Messages Collector, used for `req.errors` and `req.messages`
  */
 class Responses extends Array {
-  static get (severity, code, message, target, args, ...more) {
-    if (code?.raw) [ message, code ] = [ String.raw (code, message, target, args, ...more) ]
+  static get (severity, code, message, target, args) {
     let e // be filled in below...
-    if (typeof code === 'object') e = code; else {
-      if (typeof code === 'number') e = { code }; else [ code, message, target, args, e ] = [ undefined, code, message, target, {} ]
-      if (typeof message === 'object') e = Object.assign(message,e); else {
-        if (typeof target === 'object') [ target, args ] = [ undefined, target ]
-        if (message) e.message = message //; else if (code) e.message = String(code)
-        if (target) e.target = target
-        if (args) e.args = args
+    if (code?.raw) {
+      if (typeof message === 'object') {
+        target = Object.keys(message)[0]
+        args = [ ...arguments ].slice(3)
+        e = {
+          message: String.raw (code, target, ...args),
+          target, text: '{0} '+ String.raw (code,'', ...placeholders.slice(0,args.length)).trim(),
+          args,
+        }
+      } else e = {
+        message: String.raw (code, ...[...arguments].slice(2))
+      }
+    } else {
+      if (typeof code === 'object') e = code; else {
+        if (typeof code === 'number') e = { code }; else [ code, message, target, args, e ] = [ undefined, code, message, target, {} ]
+        if (typeof message === 'object') e = Object.assign(message,e); else {
+          if (typeof target === 'object') [ target, args ] = [ undefined, target ]
+          if (message) e.message = message //; else if (code) e.message = String(code)
+          if (target) e.target = target
+          if (args) e.args = args
+        }
       }
     }
     if (!e.numericSeverity) e.numericSeverity = severity
@@ -32,7 +46,6 @@ class Errors extends Responses {
     'stack' in e || Error.captureStackTrace (e = Object.assign(new Error,e), cds.Request.prototype.error)
     return super.push(e)
   }
-  throwable() { return this.length > 1 ? Object.assign(new Error('MULTIPLE_ERRORS'), { details: this }) : this[0] }
 }
 
 module.exports = { Responses, Errors }

package/lib/srv/middlewares/ctx-model.js

@@ -1,14 +1,14 @@
 module.exports = ()=> {
 
   const cds = require ('../../index')
-  const context_model_required = cds.requires.extensibility || cds.requires.toggles || cds.mtx
+  const context_model_required = cds.requires.extensibility || cds.requires.toggles
   if (!context_model_required) return []
 
   const { model4 } = require('../srv-models')
   return async function cds_context_model (req,res, next) {
     if (req.baseUrl.startsWith('/-/')) return next() //> our own tech services cannot be extended
     const ctx = cds.context
-    if (ctx.tenant) try {
+    if (ctx.tenant || ctx.features) try {
       // if (req.headers.features) ctx.user.features = req.headers.features //> currently done in basic-auth only
       ctx.model = req.__model = await model4 (ctx.tenant, ctx.features) // REVISIT: req.__model is because of Okra
     } catch (e) {

package/lib/srv/middlewares/errors.js

@@ -4,6 +4,6 @@ module.exports = ()=> function cds_error_handler (err, req, res, next) {
   // res.status (n >= 400 && n < 600 ? n : 500)
   // err.status = 400
   // res.json ({ ...err, message: err.message, stack: err.stack })
-  // if (err.status === 401 && req.login) return req.login()
+  // if (err.status === 401 && req._login) return req._login()
   next (err)
 }

package/lib/srv/protocols/_legacy.js

@@ -8,6 +8,7 @@ class LegacyProtocolAdapter extends ProtocolAdapter {
 
   static init() {
     return this.protocols = {
+      "odata-v4": { get impl() { return libx.to.odata_v4 } },
       "odata": { get impl() { return libx.to.odata_v4 } },
       "rest":  { get impl() { return libx.to.rest } },
     }