@sap/cds 6.1.2 → 6.2.1

package/lib/index.js

@@ -23,10 +23,9 @@ 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 {{ [path:string] : Service }} */ paths: {},
   /** @type Service[] */ providers: [],
   factory: require ('./srv/factory'),
-  adapters: require ('./srv/adapters'),
+  protocols: require ('./srv/protocols'),
   bindings: require ('./srv/bindings'),
 })
 
@@ -66,6 +65,8 @@ const cds = module.exports = extend (new facade) .with ({
     *[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'),
@@ -73,7 +74,7 @@ const cds = module.exports = extend (new facade) .with ({
   Request: require ('./req/request'),
   Event: require ('./req/event'),
   User: require ('./req/user'),
-  ql: require ('./ql/cds-ql'),
+  ql: lazy => require ('./ql/cds-ql'),
   tx: (..._) => (cds.db || cds.Service.prototype) .tx (..._),
   /** @type Service */ db: undefined,
 
@@ -124,7 +125,7 @@ extend (cds.__proto__) .with ({
 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'),
+  build: lazy => require('../bin/build')
 }))
 
 // Add global forwards to cds.ql and cds.parse
@@ -147,6 +148,10 @@ if (process.env.CDS_STRICT_NODE_VERSION !== 'false') {
 // restore require for subsequent uses in lazy getters
 require = _require  // eslint-disable-line
 
+// 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

package/lib/log/cds-error.js

@@ -17,12 +17,10 @@ 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) {
-  let e; if (msg.raw) e = new error (error.message(...arguments))
-  else {
-    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)
-  }
+  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)
   if (new.target) return e; else throw e
 }
 

package/lib/log/cds-log.js

@@ -1,14 +1,10 @@
-const cds = require ('../index'), { log } = cds.env
-
-// Use configured logger in case of cds serve
-if (log.Logger || log.service) {
-  if (log.Logger) exports.Logger = require (log.Logger)
-  if (log.service) {
-    const {app} = cds, serveIn = app => require('./service').serveIn(app)
-    app ? setImmediate(() => serveIn(app)) : cds.on('bootstrap', app => serveIn(app))
-  }
-}
+const cds = require ('../index'), conf = cds.env.log
+const log = module.exports = exports = cds_log
 
+/**
+ * Cache used for all constructed loggers.
+ */
+exports.loggers = {}
 
 /**
  * Returns a trace logger for the given module if trace is switched on for it,
@@ -42,27 +38,26 @@ if (log.Logger || log.service) {
  * @param {string} [module] the module for which a logger is requested
  * @param {string|number|{ level, prefix }} [options] the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
  */
-module.exports = exports = function cds_log (module, options) { // NOSONAR
-  let id = module ? module.match(/^[^|]+/)[0] : 'cds'
-  let logger = cached[id]; if (logger && !options) return logger
+function cds_log (module, options) { // NOSONAR
+  const id = module?.match(/^[^|]+/)[0] || 'cds', cache = log.loggers
+  const cached = cache[id]
+  if (cached && !options) return cached
 
-  let { level, prefix } = typeof options === 'object' ? options : {level:options}
-  if (!prefix) prefix = logger && logger.prefix || id
-  if (!level) level = (
-    process.env.DEBUG && process.env.DEBUG.match(RegExp(`\\b(y|all|${module||'any'})\\b`)) ? DEBUG :
-    log.levels[id] || INFO
-  )
-  if (typeof level === 'string') {
-    level = exports.levels [level.toUpperCase()]
-  }
+  let label = options?.label || options?.prefix || cached?.label || id
+  let level = typeof options === 'object' ? options.level : options
+  if (!level) level = DEBUG_matches(module) ? DEBUG : conf.levels[id] || INFO
+  if (typeof level === 'string') level = log.levels [level.toUpperCase()]
+  if (cached && cached.level === level) return cached
 
-  // IMPORTANT: cds.log() can be called again to change the log level
-  // of formerly constructed loggers!!
-  if (logger && logger.level === level) return logger
-  else logger = exports.Logger (prefix, level)
-  return cached[id] = Object.assign (cached[id] || logger.log, logger, {
-    id, level, prefix, setFormat(fn){ logger.format = fn }
-  })
+  const logger = new Logger (label, level)
+  return cache[id] = Object.assign (cached || logger.log, {
+    id, label, level, setFormat(fn){ logger.format = fn; return this },
+    _trace: level >= TRACE,
+    _debug: level >= DEBUG,
+    _info:  level >= INFO,
+    _warn:  level >= WARN,
+    _error: level >= ERROR,
+  }, logger)
 }
 
 
@@ -72,7 +67,7 @@ module.exports = exports = function cds_log (module, options) { // NOSONAR
  */
 exports.debug = function cds_debug (module) {
   const L = this.log (module)
-  return L._debug && L.debug
+  if (L._debug) return L.debug
 }
 
 
@@ -84,53 +79,94 @@ exports.debug = function cds_debug (module) {
  *
  *    cds.log.Logger = () => winston.createLogger (...)
  *
- * @param {string} [module] the module for which a logger is requested
+ * @param {string} [label] the module for which a logger is requested
  * @param {number} [level]  the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
  */
 /* eslint-disable no-console */
-exports.Logger = (module, level) => {
-  const fmt = (level,args) => logger.format (module,level,...args)
-  const logger = Object.assign ({
-    format: exports.format,
+exports.Logger = (label, level) => {
+  const fmt = (level,args) => logger.format (label,level,...args)
+  const logger = {
+    format: exports.format, // use logger.format as this could be changed dynamically
     trace:  level < TRACE ? ()=>{} : (...args) => console.trace (...fmt(TRACE,args)),
     debug:  level < DEBUG ? ()=>{} : (...args) => console.debug (...fmt(DEBUG,args)),
     log:    level < INFO  ? ()=>{} : (...args) => console.log (...fmt(INFO,args)),
     info:   level < INFO  ? ()=>{} : (...args) => console.info (...fmt(INFO,args)),
     warn:   level < WARN  ? ()=>{} : (...args) => console.warn (...fmt(WARN,args)),
     error:  level < ERROR ? ()=>{} : (...args) => console.error (...fmt(ERROR,args)),
-    _trace: level >= TRACE,
-    _debug: level >= DEBUG,
-    _info:  level >= INFO,
-    _warn:  level >= WARN,
-    _error: level >= ERROR,
-  })
-  // deleted stdout -> stderr redirection for cds compile as bin/utils/log.js is used
+  }
   return logger
 }
+function Logger (label, level) { return exports.Logger (label, level) }
+
+
+/**
+ * Convenience method to construct winston loggers, very similar to `winston.createLogger()`.
+ * @param {object} options - as in `winston.createLogger()`
+ * @returns The winston logger, decorated with the standard cds.log methods
+ * .debug(), .info(), .warn(), .error(), etc.
+ */
+exports.winstonLogger = (options) => (label, level) => {
+  const winston = require("winston") // eslint-disable-line cds/no-missing-dependencies
+  const logger = winston.createLogger({
+    levels: log.levels, level: Object.keys(log.levels)[level],
+    transports: [new winston.transports.Console()],
+    ...options
+  })
+  const { formatWithOptions } = require('util')
+  const _fmt = ([...args]) => formatWithOptions(
+    { colors: false }, `[${label}] -`, ...args
+  )
+  return Object.assign (logger, {
+    trace: (...args) => logger.TRACE (_fmt(args)),
+    debug: (...args) => logger.DEBUG (_fmt(args)),
+    log:   (...args) => logger.INFO  (_fmt(args)),
+    info:  (...args) => logger.INFO  (_fmt(args)),
+    warn:  (...args) => logger.WARN  (_fmt(args)),
+    error: (...args) => logger.ERROR (_fmt(args)),
+  })
+}
 
+/**
+ * Built-in formatters
+ */
+ const { simple } = exports.formatters = {
+  simple: (label, level, ...args) => [ `[${label}] -`, ...args ],
+  mt: (label, level, ...args) => {
+    const t = cds.context?.tenant; if (t) label += '|'+t
+    return simple (label, level, ...args)
+  },
+  get json() {
+    return this._json || (this._json = require('./format/kibana'))
+  }
+}
 
 /**
- * Formats a log outputs by returning an array of arguments which are passed to
+ * Formats log outputs by returning an array of arguments which are passed to
  * console.log() et al.
  * You can assign custom formatters like that:
  *
- *    cds.log.format = (module, level, ...args) => [ '[', module, ']', ...args ]
+ *    cds.log.format = (label, level, ...args) => [ '[', label, ']', ...args ]
  *
- * @param {string} module the module for which a logger is requested
- * @param {number} level  the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
+ * @param {string} label the label to prefix to log output
+ * @param {number} level the log level to enable -> 0=off, 1=error, 2=warn, 3=info, 4=debug, 5=trace
  * @param {any[]} args  the arguments passed to Logger.debug|log|info|wanr|error()
  */
 exports.format = (
-  process.env.NODE_ENV === 'production' && cds.env.features.kibana_formatter ? require('./format/kibana')
-  : cds.requires.multitenancy ? (module, level, ...args) => {
-    const t = cds.context?.tenant
-    return [ t ? `[${module}|${t}]` : `[${module}]`, '-', ...args ]
-  }
-  : (module, level, ...args) => [ `[${module}] -`, ...args ]
+  process.env.NODE_ENV === 'production' && cds.env.features.kibana_formatter ? log.formatters.json :
+  cds.requires.multitenancy ? log.formatters.mt : simple
 )
 
 
+const DEBUG_matches = (m) => process.env.DEBUG?.match(RegExp(`\\b(y|all|${m||'any'})\\b`))
 const { ERROR, WARN, INFO, DEBUG, TRACE } = exports.levels = {
   SILENT:0, ERROR:1, WARN:2, INFO:3, DEBUG:4, TRACE:5, SILLY:5, VERBOSE:5
 }
-const cached = exports.loggers = {}
+
+;(function _init() {
+  const conf = cds.env.log
+  if (conf.Logger) exports.Logger = require (conf.Logger) // Use configured logger in case of cds serve
+  if (conf.service) {
+    const {app} = cds, serveIn = app => require('./service').serveIn(app)
+    app ? setImmediate(() => serveIn(app)) : cds.on('bootstrap', app => serveIn(app))
+  }
+})()

package/lib/log/service/index.js

@@ -23,6 +23,7 @@ module.exports = class LogService extends cds.Service {
     }
 
     // serve embedded UI
+    // eslint-disable-next-line cds/no-missing-dependencies
     const express = require('express')
     app.use (path+'/ui', express.static(__dirname+'/vue.html'))
 

package/lib/ql/CREATE.js

@@ -1,10 +1,7 @@
-const Query = require('./Query')
-const $ = Object.assign
-
-module.exports = class CREATE extends Query {
+module.exports = class Query extends require('./Query') {
 
   static _api() {
-    return $((..._) => (new this).entity(..._), {
+    return Object.assign((..._) => (new this).entity(..._), {
       entity: (..._) => (new this).entity(..._),
     })
   }

package/lib/ql/DELETE.js

@@ -1,6 +1,6 @@
 const Whereable = require('./Whereable')
 
-module.exports = class DELETE extends Whereable {
+module.exports = class Query extends Whereable {
 
   static _api() {
     return Object.assign ((..._) => (new this).from(..._), {

package/lib/ql/DROP.js

@@ -1,6 +1,4 @@
-const Query = require('./Query')
-
-module.exports = class DROP extends Query {
+module.exports = class Query extends require('./Query') {
   static _api() {
     return Object.assign ((e)  => (new this).entity(e), {
       entity: (e) => (new this).entity(e),

package/lib/ql/INSERT.js

@@ -1,7 +1,5 @@
-const Query = require('./Query')
-const is_array = Array.isArray
+module.exports = class Query extends require('./Query') {
 
-module.exports = class INSERT extends Query {
   static _api() {
     return Object.assign ((..._) => (new this).entries(..._), {
       into: (..._) => (new this).into(..._),
@@ -63,3 +61,5 @@ module.exports = class INSERT extends Query {
     return super.valueOf('INSERT INTO')
   }
 }
+
+const is_array = Array.isArray

package/lib/ql/Query.js

@@ -1,5 +1,4 @@
 const { AsyncResource } = require('async_hooks')
-const { inspect } = require('util')
 const cds = require('../index')
 
 class Query {
@@ -8,7 +7,14 @@ class Query {
 
   /** Creates a derived instance that initially inherits all properties. */
   clone(){
-    return { __proto__:this, [this.cmd]: {__proto__: this[this.cmd]} }
+    const inherited = Object.create (this[this.cmd])
+    return {__proto__:this, [this.cmd]: inherited }
+  }
+
+  flat(){
+    const flat = this[this.cmd]
+    for (let x=flat; x.__proto__;) Object.assign(flat, x = x.__proto__)
+    return new this.constructor (flat)
   }
 
   /** Binds this query to be executed with the given service */
@@ -23,20 +29,6 @@ class Query {
     return (r,e) => q.runInAsyncScope (srv.run, srv, this) .then (r,e)
   }
 
-  /** Beautifies output in REPL */
-  [inspect.custom]() {
-    const {cmd} = this, colors = process.env.CDS_TERM_COLORS !== false
-    return `{ ${cmd}: `+ inspect(this[cmd], { colors, depth: 22 })
-      .replace(/^\w*\s/, '')
-      .replace(
-        /{ ref: \[([^\]]*)\] }/g,
-        (_,ref) => '{ref:[' + ref.slice(1, -1) + ']}'
-      )
-      .replace(/{ val: ([^ ]*) }/g, '{val:$1}')
-      .replace(/{ (xpr|ref|val): /g, '{$1:') +
-    '}'
-  }
-
   _target_ref4 (target, arg2) {
 
     // Resolving this._target --> REVISIT: this is not reliable !!!
@@ -55,19 +47,14 @@ class Query {
 
   //> REVISIT: should we rather have consistent .from/.entity/.into in CQN?
   _target_name4 (...args) {
-    const {ref} = this._target_ref4 (...args)
-    return ref.length === 1 && typeof ref[0] === 'string' ? ref[0] : {ref}
+    const {ref, as} = this._target_ref4 (...args)
+    return ref.length === 1 && typeof ref[0] === 'string' && !as ? ref[0] : as ? {ref, as} : {ref}
   }
 
   _expected (...args) {
     return cds.error.expected (...args)
   }
 
-  _own (property, _ = this[this.cmd]) {
-    const pd = Reflect.getOwnPropertyDescriptor (_, property)
-    return pd && pd.value
-  }
-
   _add (property, values) {
     const _ = this[this.cmd], pd = Reflect.getOwnPropertyDescriptor (_,property)
     _[property] = !pd || !pd.value ? values : [ ...pd.value, ...values ]

package/lib/ql/SELECT.js

@@ -1,8 +1,7 @@
 const Whereable = require('./Whereable'), { parse, predicate4 } = Whereable
 const cds = require('../index')
 
-
-module.exports = class SELECT extends Whereable {
+module.exports = class Query extends Whereable {
 
   static _api() {
     const $ = Object.assign

package/lib/ql/UPDATE.js

@@ -1,7 +1,7 @@
 const Whereable = require('./Whereable')
 const { parse } = require('../index')
 
-module.exports = class UPDATE extends Whereable {
+module.exports = class Query extends Whereable {
 
   static _api() {
     return Object.assign ((..._) => (new this).entity(..._), {
@@ -94,4 +94,4 @@ const _comma_separated_exprs = (s) => {
   return all
 }
 
-const operators = { '=':1, '-=':2, '+=':2, '*=':2, '/=':2, '%=':2 }
+const operators = { '=':1, '-=':2, '+=':2, '*=':2, '/=':2, '%=':2 }

package/lib/ql/Whereable.js

@@ -2,12 +2,7 @@ const { error } = require ('../index')
 const cds = require('../index')
 const parse = require('./parse')
 
-const _setIncludesOr = where => {
-  if (where.includes('or')) Object.defineProperty(where,'_includes_or__',{value:1}) 
-  else Object.defineProperty(where,'_includes_or__',{value:0})
-}
-
-class Whereable extends require('./Query') {
+class Query extends require('./Query') {
 
   where(...x) { return this._where (x,'and','where') }
   and(...x) {  return this._where (x,'and') }
@@ -19,20 +14,17 @@ class Whereable extends require('./Query') {
       if (!_clause) _clause = (
         _.having ? 'having' :
         _.where ? 'where' :
-        _.from && _.from.on ? 'on' :
+        _.from?.on ? 'on' :
         error (`Invalid attempt to call '${this.cmd}.${and_or}()' before a prior call to '${this.cmd}.where()'`)
       )
       if (_clause === 'on') _ = _.from
-      let left = this._own(_clause,_)
+      let left = Reflect.getOwnPropertyDescriptor(_,_clause)?.value
       if (!left) {
-        _setIncludesOr(pred)
+        if (pred.includes('or')) this._left_has_or = true
         _[_clause] = pred
       } else {
-        if (and_or === 'and') {
-          if (left._includes_or__ === undefined) _setIncludesOr(left) // information might be lost while copying
-          if (left._includes_or__ === 1) left = [{xpr:left}]
-          if (pred.includes('or')) pred = [{xpr:pred}]
-        }
+        if (this._left_has_or && and_or === 'and') { left = [{xpr:left}]; delete this._left_has_or }
+        if (pred.includes('or')) pred = [{xpr:pred}]
         _[_clause] = [ ...left, and_or, ...pred ]
       }
     }
@@ -111,4 +103,4 @@ const is_cqn = x => x.val !== undefined || x.xpr || x.ref || x.list || x.func ||
 const is_array = Array.isArray
 const operators = { '=':1, '<':2, '<=':2, '>':2, '>=':2, '!=':3, '<>':3, in:4, like:4, IN:4, LIKE:4 }
 
-module.exports = Object.assign (Whereable, { predicate4, parse })
+module.exports = Object.assign (Query, { predicate4, parse })

package/lib/ql/cds-ql.js

@@ -2,19 +2,25 @@ const cds = require('../index')
 const Query = require('./Query')
 require = path => { // eslint-disable-line no-global-assign
   const clazz = module.require (path); if (!clazz._api) return clazz
+  const api = clazz._api()
   Object.defineProperty (clazz.prototype, 'cmd', { value: path.match(/\w+$/)[0] })
-  return clazz._api()
+  return Object.assign (function (...args) {
+    if (new.target) return new clazz (...args) // allows: new SELECT
+    return api (...args)                      // allows: SELECT(...).from()
+  }, api)
 }
 
 module.exports = Object.assign (_deprecated_srv_ql, { cdr: true,
-  Query,
+  Query, clone(q) {
+    const cmd = q.cmd || Object.keys(q)[0]
+    return {__proto__:q, [cmd]: {__proto__:q[cmd] }}
+  },
   SELECT: require('./SELECT'),
   INSERT: require('./INSERT'),
   UPDATE: require('./UPDATE'),
   DELETE: require('./DELETE'),
   CREATE: require('./CREATE'),
   DROP: require('./DROP'),
-  clone(q) { return Query.prototype.clone.call(q) }
 })
 
 function _deprecated_srv_ql() { // eslint-disable-next-line no-console

package/lib/req/cds-context.js

@@ -10,7 +10,6 @@ module.exports = new class extends AsyncLocalStorage {
   _context4(v) {
     if (v instanceof EventContext || typeof v !== 'object') return v
     if (v.context) return v.context
-    if (v.req) v = v.res ? {http:v} : {http:{ ...v, res: v.req.res }}
     return EventContext.for(v)
   }
 
@@ -31,12 +30,21 @@ module.exports = new class extends AsyncLocalStorage {
     if (o instanceof EventContext) throw cds.error `The passed options must not be an instance of cds.EventContext.`
     const fx = ()=>{
       const tx = cds.tx({...o}) // create a new detached transaction for each run of the background job
-      return cds._context.run (tx, ()=> Promise.resolve(fn(tx))
+      return cds._context.run (tx, async ()=> {
+        // REVISIT: The model must be set _after_ run to make sure that cds.context.tenant is correctly set.
+        //          Otherwise, `model4` could query the wrong database to check for extensions.
+        if (cds.model && (cds.env.requires.extensibility || cds.env.requires.toggles)) {
+          const ctx = cds.context
+          const ExtendedModels = require('../srv/srv-models') // the sentinel is automatically started when required
+          cds.context.model = await ExtendedModels.model4(ctx.tenant, ctx.features)
+          tx.model = cds.context.model
+        }
+        return Promise.resolve(fn(tx))
         .then (tx.commit, e => tx.rollback(_error(e, cds)))
         .then (res => Promise.all(em.listeners('succeeded').map(each => each(res))))
         .catch (err => Promise.all(em.listeners('failed').map(each => each(err))))
         .finally (() => Promise.all(em.listeners('done').map(each => each())))
-      )
+      })
     }
     const em = new EventEmitter; em.timer = (
       (o && o.after) ? setTimeout(fx, o.after) :

package/lib/req/context.js

@@ -88,9 +88,18 @@ class EventContext {
   }
 
   set user(u) {
-    const user = u instanceof cds.User ? u : new cds.User(u)
-    if (u && typeof u === 'object') for (let p in _TENANT_LOCALE) if (p in u && u[p]) this[p] = u[p]
-    super.user = new Proxy (user,{ get:(t,p) => p in _TENANT_LOCALE ? this[p] : t[p] })
+    if (u && typeof u === 'object') for (let p of ['tenant','locale']) {
+      let pd = Reflect.getOwnPropertyDescriptor(u,p)
+      if (pd?.value) this[p] = pd.value
+    }
+    let user = u instanceof cds.User ? Object.create(u,{
+      tenant: {get:()=> this.tenant},
+      locale: {get:()=> this.locale},
+    }) : Object.defineProperties (new cds.User(u), {
+      tenant: {get:()=> this.tenant},
+      locale: {get:()=> this.locale},
+    })
+    super.user = user
   }
   get user() {
     this.user = this._propagated.user || _anonymous
@@ -109,13 +118,13 @@ class EventContext {
   }
 
   get _features() {
-    return super._features = this._propagated._features || _features4 (this.http?.req?.features || this.user?.features || this.http?.req?.user?.features)
+    return super._features = this._propagated._features || Features.for (this.http?.req?.features || this.user?.features || this.http?.req?.user?.features)
   }
   get features() {
-    return super.features = this._features || noFeatures
+    return super.features = this._features || Features.none
   }
   set features(v) {
-    super.features = _features4(v)
+    super.features = Features.for(v)
   }
 
   get model() {
@@ -174,26 +183,23 @@ class EventContext {
   get _tx() { return this.tx } // REVISIT: for compatibility to bade usages of req._tx
 }
 
-const _TENANT_LOCALE = { tenant:1, locale:2 }
 const _anonymous = new cds.User.default
 
-const _features4 = features => { // normalizes features to an object
-  if (!features) return
-  if (features === '*') return allFeatures
-  const o = (
-    Array.isArray(features) ? features.reduce((fts,f)=>{ fts[f] = true; return fts },{}) :
-    typeof features === 'object' ? Object.fromEntries (Object.entries(features).filter(([,v])=>v)) :
-    (''+features).split(',').reduce((fts,f)=>{ fts[f] = true; return fts },{})
-  )
-  return Object.defineProperty (o,'$hash',$hash)
-}
-const $hash = {
-  get() { return this.$hash = Object.keys(this).join(',') },
-  set(v){ Object.defineProperty(this,'$hash',{value:v}) },
-  configurable:true
+
+class Features {
+  static for (x) { // normalizes features to an object
+    if (!x) return
+    if (x === '*') return this.all
+    const fts = new this
+    if (Array.isArray(x))           { for (let f of x)            fts[f] = true }
+    else if (typeof x === 'object') { for (let f in x) if (x[f])  fts[f] = true }
+    else if (typeof x === 'string') { for (let f of x.split(',')) fts[f] = true }
+    return fts
+  }
+  get $hash() { return super.$hash = Object.keys(this).join(',') }
+  static all = new Proxy ({'*':true},{ has:() => true, get:(_,p) => p === '$hash' ? '*' : true })
+  static none = new class none extends Features {}
 }
-const allFeatures = new Proxy ({'*':true},{ has:() => true, get:(_,p) => p === '$hash' ? '*' : true })
-const noFeatures = {__proto__:{ $hash:'' }}
 
 EventContext.prototype._set('_propagated', Object.seal({}))
 EventContext.propagateHeaders = [ 'x-correlation-id' ]

package/lib/req/locale.js

@@ -5,14 +5,18 @@ const INCLUDE_LIST = i18n.preserved_locales.reduce((p,n)=>{
 },{
   en_US_x_saptrc: 'en_US_saptrc',
   en_US_x_sappsd: 'en_US_sappsd',
-  en_US_x_saprigi: 'en_US_saprigi',
-  '1Q': 'en_US_saptrc',
-  '2Q': 'en_US_sappsd',
-  '3Q': 'en_US_saprigi'
+  en_US_x_saprigi: 'en_US_saprigi'
 })
 
+const SAP_LANGUAGES = {
+  '1Q': 'en_US_x_saptrc',
+  '2Q': 'en_US_x_sappsd',
+  '3Q': 'en_US_x_saprigi'
+}
+
+// normalizes to BCP47
 const from_req = req => req && (
-  req.query && req.query['sap-language'] ||
+  req.query && (req.query['sap-locale'] || SAP_LANGUAGES[req.query['sap-language']]) ||
   req.headers && (req.headers['x-sap-request-language'] || req.headers['accept-language'])
 )
 

package/lib/req/request.js

@@ -61,6 +61,7 @@ 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) return 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/user.js

@@ -8,7 +8,8 @@ class User {
     }
     if (typeof _ === 'string') { this.id = _; return }
     for (let each in _) super[each === '_roles' ? 'roles' : each] = _[each] // overrides getters
-    if (Array.isArray(this.roles)) this.roles = this.roles.reduce ((p,n)=>{p[n]=1; return p},{})
+    const roles = this.hasOwnProperty('roles') && this.roles // eslint-disable-line no-prototype-builtins
+    if (Array.isArray(roles)) this.roles = roles.reduce ((p,n)=>{p[n]=1; return p},{})
   }
 
   get attr() { return super.attr = {} }

package/lib/srv/cds-connect.js

@@ -6,7 +6,7 @@ const _pending = cds.services._pending || {} // used below to chain parallel con
  */
 const connect = module.exports = async function cds_connect (options) {
   if (typeof options === 'object' && cds.db) throw cds.error (
-    `You need to disconnect before creating a new primary connection with different options!`
+    `Re-connect to primary db with potentially different options is not allowed!`
   )
   if (typeof options === 'string') cds.db = await connect.to (options)
   else await connect.to ('db',options)