@sap/cds 8.9.3 → 9.0.2

package/lib/srv/cds.Service.js

@@ -1,131 +1,191 @@
-//////////////////////////////////////////////////////////////
-//
-//  PLEASE DO NOT RUN prettier ON THIS FILE
-//
-//////////////////////////////////////////////////////////////
-
-const cds = require('../index')
 const EventHandlers = require('./srv-handlers')
+const Request = require('../req/request')
+const Event = require('../req/event')
+const cds = require('../index')
 
 
 /**
- * Private base class which contains all model & reflection-related APIs.
+ * This class constitutes the API used by service consumers to send requests, and emit events.
+ *
+ * - `dispatch()` - is the central method ultimately called by all the other methods below.
+ * - `emit()` - is the central method of the **Messaging API** to emit asynchronous event messages.
+ * - `send()` - is the central method of the **Request API** to send synchronous requests.
+ * - `run()` - is the central method of the **Querying API** to execute queries.
+ *
+ * The other methods, like `read`, `create`, `update`, `delete`, are **CRUD-style** syntactical
+ * sugar variants provided for convenience, or **REST-style** like `get`, `put`, `post`, `patch`.
  */
-class ModeledService {
+class ConsumptionAPI {
+
+  async dispatch() {}
+
+  emit (event, data, headers) {
+    if (is_object(event)) return this.dispatch (event instanceof Event ? event : new Event(event))
+    else return this.dispatch (new Event ({ event, data, headers }))
+  }
+
+  send (req, path, data, headers) {
+    if (is_object(req)) return this.dispatch (req instanceof Request ? req : new Request(req))
+    if (is_object(path)) return this.dispatch (new Request (path.is_linked //...
+      ? { method:req, entity:path, data, headers }
+      : { method:req, data:path, headers:data }))
+    else return this.dispatch (new Request({ method:req, path, data, headers }))
+  }
+  schedule (method, path, data, headers) {
+    // not great to normalize args... better way? need to 'merge' with after/every
+    const req = method instanceof cds.Request ? method : new cds.Request(_nrm4skd(method, path, data, headers))
+    return {
+      after (ms) {
+        req.queue ??= {}
+        req.queue.after = ms
+        return this
+      },
+      every (ms) {
+        req.queue ??= {}
+        req.queue.every = ms
+        return this
+      },
+      then: (r, e) => {
+        return cds.queued(this).send(req).then(r, e)
+      }
+    }
+  }
+  get    (...args) { return is_rest(args[0]) ? this.send('GET',   ...args) : this.read   (...args) }
+  put    (...args) { return is_rest(args[0]) ? this.send('PUT',   ...args) : this.update (...args) }
+  post   (...args) { return is_rest(args[0]) ? this.send('POST',  ...args) : this.create (...args) }
+  patch  (...args) { return is_rest(args[0]) ? this.send('PATCH', ...args) : this.update (...args) }
+  delete (...args) { return is_rest(args[0]) ? this.send('DELETE',...args) : DELETE.from (...args).bind(this) }
 
   /**
-   * Constructs a new instance. Argument name can be omitted if the model contains only one service.
-   * @param {string} [name] - the name of the service
-   * @param {object} [model] - the CSN model
-   * @param {object} [options] - additional options
-   * @param {string} [options.kind] - the kind of the service
-   * @param {function} [options.impl] - the implementation function
+   * Queries can be passed as one of the following:
+   * - a CQL tagged template string, which is converted into an instance of `cds.ql.Query`
+   * - a CQN object, or an array of such
+   * - a native SQL string, with binging parameters in the second argument `data`
    */
-  constructor (model, name, options={}) {
-    this.name = name || new.target.name
-    this.options = options
-    if (options.kind) this.kind = options.kind // shortcut
-    if (model) this.model = model
+  run (query, data) {
+    if (query.raw) [ query, data ] = [ cds.ql (...arguments) ]
+    const req = new Request ({ query, data })
+    return this.dispatch (req)
   }
+  read   (...args) { return is_query(args[0]) ? this.run(...args) : SELECT.read(...args).bind(this) }
+  insert (...args) { return INSERT(...args).bind(this) }
+  create (...args) { return INSERT.into(...args).bind(this) }
+  update (...args) { return UPDATE.entity(...args).bind(this) }
+  upsert (...args) { return UPSERT(...args).bind(this) }
+  exists (...args) { return SELECT.one([1]).from(...args).bind(this) }
+
+  /**
+   * Streaming API variant of .run(). Subclasses should override this to support real streaming.
+   */
+  foreach (query, data, callback) {
+    if (!callback)  [ data, callback ] = [ undefined, data ]
+    return this.run (query, data) .then (rows => rows.forEach(callback) || rows)
+  }
+
+  // Internal-only API to free resources when tenants offboard
+  /** @protected */ disconnect(tenant) {} // eslint-disable-line no-unused-vars
+}
+
+
+/**
+ * This class provides API used by service providers to reflect
+ * their service definitions from a given model.
+ */
+class ReflectionAPI extends ConsumptionAPI {
 
   /** @param {import('../core/linked-csn').LinkedCSN} csn */
   set model (csn) {
     super.model = csn ? cds.compile.for.nodejs(csn) : undefined
   }
 
-  /**
-   * Lazy get the service definition from this.model
-   * @type import('../core/classes').service
-   */
+  /** @type import('../core/classes').service */
   get definition() {
     const defs = this.model?.definitions; if (!defs) return super.definition = undefined
     return super.definition = defs[this.options.service] || defs[this.name]
   }
-
-  /** The namespace always is the service definition name */
   get namespace()  {
     return super.namespace  = this.definition?.name
     || this.model?.namespace
     || !this.isDatabaseService && !/\W/.test(this.name) && this.name
     || undefined
   }
-
-  // Reflection methods
   get entities()   { return super.entities = this.reflect (d => d.kind === 'entity') }
   get events()     { return super.events   = this.reflect (d => d.kind === 'event') }
   get types()      { return super.types    = this.reflect (d => !d.kind || d.kind === 'type') }
   get actions()    { return super.actions  = this.reflect (d => d.kind === 'action' || d.kind === 'function') }
-  /** @deprecated */ get operations() { return this.actions } // compatibility
-  reflect(filter) { return this.model?.childrenOf (this.namespace, filter) || [] }
+  reflect (filter) { return this.model?.childrenOf (this.namespace, filter) || [] }
 }
 
 
-class Service extends ModeledService {
+/**
+ * This class provides the API used by service providers to add event handlers.
+ * It inherits the ConsumptionAPI and ReflectionAPI.
+ */
+class Service extends ReflectionAPI {
 
-  constructor (name, model, options) {
-    if (typeof name === 'object') {
-      [ model, options ] = [ name, model ]
-      let srv = cds.linked(model).services[0] || cds.error.expected `${{model}} passed as first argument to be a CSN with a single service definition`
-      name = srv.name
-    }
-    super (model, name, options)
+  constructor (name, model, options) { super()
+    if (typeof name === 'object') [ model, options, name = _service_in(model) ] = [ name, model ]
+    this.name = name || new.target.name // i.e. when called without any arguments
+    this.options = options ??= {}
+    if (options.kind) this.kind = options.kind // shortcut, e.g. for 'sqlite', ...
+    if (model) this.model = model
+    this.handlers = new EventHandlers(this)
+    this.decorate()
   }
-
-  /**
-   * Empty init() function to allow custom code to always call super.init()
-   * without having to care for if .init() exists.
-  */
- init(){ return this }
-
- // Event Handlers Registration API
-  handlers = new EventHandlers
-  prepend (fn)      { return this.handlers.prepend.call (this,fn) }
-  before  (...args) { return this.handlers.register (this, 'before', ...args) }
-  on      (...args) { return this.handlers.register (this, 'on',     ...args) }
-  after   (...args) { return this.handlers.register (this, 'after',  ...args) }
-  reject  (e, path) { return this.handlers.register (this, '_initial', e, path,
+  init(){ return this } //> essentially a constructor without arguments
+
+  // Handler registration API
+  prepend (fn) { return this.handlers.prepend.call (this,fn) }
+  /** @typedef {( entity?, path?, handler:(req:import('../req/request'))=>{})=> Service} boa */
+  /** @type boa */ before (...args) { return this.handlers.register (this, 'before', ...args) }
+  /** @type boa */ on     (...args) { return this.handlers.register (this, 'on',     ...args) }
+  /** @type boa */ after  (...args) { return this.handlers.register (this, 'after',  ...args) }
+  reject (e, path) { return this.handlers.register (this, '_initial', e, path,
     r => r.reject (405, `Event "${r.event}" not allowed for entity "${r.path}".`)
   )}
 
-  // Event Dispatching API
-  dispatch (req) {
-    const { dispatch } = require('./srv-dispatch')
-    return (Service.prototype.dispatch = dispatch) .call (this,req)
+   // Overrriding `srv.run()` to additionally allow running a function in a managed transaction.
+  run (fn) {
+    if (typeof fn !== 'function') return super.run (...arguments)
+    if (this.context) return fn(this)                       // if this is already a tx -> run fn with this
+    const ctx = cds.context, tx = ctx?.tx                   // is there an (open) outer tx? ...
+    if (!tx || tx._done === 'committed') return this.tx(fn) // no -> run fn with root tx
+    if (tx._done !== 'rolled back') return fn(this.tx(ctx)) // yes -> run fn with nested tx
+    else throw this.tx._is_done (tx._done)                  // throw if outer tx was rolled back
   }
 
-  handle (req) {
-    const { handle } = require('./srv-dispatch')
-    return (Service.prototype.handle = handle) .call (this,req)
-  }
-
-  tx (...args) {
-    return (Service.prototype.tx = require('./srv-tx')) .call (this,...args)
-  }
-
-  /**
-   * @deprecated Flag to control whether this service is extensible.
-   * Can be overridden by subclasses.
-   */
-  get isExtensible() { // REVISIT: can we eliminate this?
-    return this.model === cds.model && !this.name?.startsWith('cds.xt.')
-  }
+  // Inofficial APIs - for internal use only
+  /** @protected */ static _is_service_class = true //> for factory
+  /** @protected */ get endpoints() { return super.endpoints = cds.service.protocols.endpoints4(this) }
+  /** @protected */ set endpoints(p) { super.endpoints = p }
+  /** @protected */ get path() { return super.path = cds.service.protocols.path4(this) }
+  /** @protected */ set path(p) { super.path = p }
 
+  // Deprecated APIs - kept for backwards compatibility
   /** @deprecated */ get _handlers() { return this.handlers }
+  /** @deprecated */ get operations() { return this.actions }
+  /** @deprecated */ get transaction() { return this.tx }
+  /** @deprecated */ get isExtensible() { return this.model === cds.model && !this.name?.startsWith('cds.xt.') }
 }
 
-/** @deprecated */ Service.prototype.transaction = function(...args) { return this.tx(...args) }
-/** @deprecated */ Service.prototype._implicit_next = cds.env.features.implicit_next
-
-Service._is_service_class = true              //> for factory
-
-//--------------------------------------------------------------------------
-// EXPERIMENTAL: It is not decided yet, whether we should keep the stuff below
-// => Please do not use anywhere!
-Service.prototype.onSucceeded = function (...args) { return _req_on (this, 'succeeded', ...args) }
-Service.prototype.onFailed = function (...args) { return _req_on (this, 'failed', ...args) }
-const _req_on = (srv, succeeded_or_failed, event, path, handler) => {
-  if (!handler) [path,handler] = [undefined,path]
-  return srv.before (event,path, req => req.on(succeeded_or_failed,handler))
+const { dispatch, handle } = require('./srv-dispatch')
+Service.prototype.dispatch = dispatch
+Service.prototype.handle = handle
+Service.prototype.tx = require('./srv-tx')
+Service.prototype.decorate = require('./srv-methods')
+
+const is_object = x => typeof x === 'object'
+const is_query = x => x?.bind || Array.isArray(x) && !x.raw
+const is_rest = x => typeof x === 'string' && x[0] === '/'
+const _service_in = m => cds.linked(m).services?.[0]?.name
+|| cds.error.expected `${{model:m}} to be a CSN with a single service definition`
+const _nrm4skd = (method, path, data, headers) => {
+  if (typeof method === 'object') return method
+  if (typeof path !== 'object') return { method, path, data, headers }
+  if (path.is_linked) return { method, entity: path, data, headers }
+  return { method, data: path, headers: data }
 }
 
-module.exports = Service
+
+exports = module.exports = Service
+exports.Service = Service

package/lib/srv/middlewares/auth/ias-auth.js

@@ -1,8 +1,106 @@
 const cds = require('../../../index.js')
 const LOG = cds.log('auth')
 
-let xssec = require('./xssec')
+const {
+  createSecurityContext,
+  IdentityService,
+  errors: { ValidationError }
+} = require('./xssec')
 
+module.exports = function ias_auth(config) {
+  // cds.env.requires.auth.known_claims is not an official config!
+  const { kind, credentials, config: serviceConfig = {}, known_claims = KNOWN_CLAIMS } = config
+  const skipped_attrs = known_claims.reduce((a, x) => ((a[x] = 1), a), {})
+
+  if (!credentials)
+    throw new Error(
+      `Authentication kind "${kind}" configured, but no IAS instance bound to application. ` +
+        'Either bind an IAS instance, or switch to an authentication kind that does not require a binding.'
+    )
+
+  const auth_service = new IdentityService(credentials, serviceConfig)
+  const user_factory = get_user_factory(credentials, skipped_attrs)
+
+  /*
+   * re validation:
+   *   if the request goes to the cert url, then we should validate the token.
+   *   however, this requires header "x-forwarded-client-cert" which requires additional configuration in the approuter ("forwardAuthCertificates: true").
+   *   also, we currently get the non-cert route attached to the application as well (-> adjust "cds add mta"?), for which validation would always fail.
+   *   by default, the approuter is configured to use the non-cert route ("url: ~{srv-url}" instead of "url: ~{srv-cert-url}").
+   *   if the developer explicitely changes to the cert route, then we can expect him/her to also configure cert forwarding.
+   *   hence, if there is no explicit validation configuration by the app, we can and should create a service with validation enabled and use if for the cert route.
+   *   this way, we validate if possible with the least amount of custom configuration.
+   */
+
+  const should_validate =
+    process.env.VCAP_APPLICATION &&
+    JSON.parse(process.env.VCAP_APPLICATION).application_uris?.some(uri => uri.match(/\.cert\./))
+  const validation_enabled = serviceConfig.validation?.x5t?.enabled || serviceConfig.validation?.proofToken?.enabled
+
+  let validating_auth_service
+  if (should_validate && !validation_enabled) {
+    const _serviceConfig = { ...serviceConfig }
+    _serviceConfig.validation = { x5t: { enabled: true }, proofToken: { enabled: true } }
+    validating_auth_service = new IdentityService(credentials, _serviceConfig)
+  }
+
+  return async function ias_auth(req, _, next) {
+    if (!req.headers.authorization) return next()
+
+    try {
+      const _auth_service =
+        validating_auth_service && req.host.match(/\.cert\./) ? validating_auth_service : auth_service
+      const securityContext = await createSecurityContext(_auth_service, { req })
+      const tokenInfo = securityContext.token
+      const ctx = cds.context
+      ctx.user = user_factory(tokenInfo)
+      ctx.tenant = tokenInfo.getZoneId()
+      req.authInfo = securityContext //> compat req.authInfo
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        LOG.warn('Unauthenticated request: ', e)
+        return next(401)
+      }
+      LOG.error('Error while authenticating user: ', e)
+      return next(500)
+    }
+
+    next()
+  }
+}
+
+function get_user_factory(credentials, skipped_attrs) {
+  return function user_factory(tokenInfo) {
+    const payload = tokenInfo.getPayload()
+
+    const clientid = tokenInfo.getClientId()
+    if (clientid === payload.sub) {
+      //> grant_type === client_credentials or x509
+      const roles = { 'system-user': 1 }
+      if (Array.isArray(payload.ias_apis)) payload.ias_apis.forEach(r => (roles[r] = 1))
+      if (clientid === credentials.clientid) roles['internal-user'] = 1
+      else delete roles['internal-user']
+      return new cds.User({ id: 'system', roles, tokenInfo })
+    }
+
+    // add all unknown attributes to req.user.attr in order to keep public API small
+    const attr = {}
+    for (const key in payload) {
+      if (key in skipped_attrs)
+        continue // REVISIT: Why do we need to do that?
+      else attr[key] = payload[key]
+    }
+
+    // REVISIT: just don't such things, please! -> We're just piling up tech dept through tons of unoficcial long tail APIs like that!
+    // REVISIT: looks like wrong direction to me, btw
+    // same api as xsuaa-auth for easier migration
+    if (attr.user_name) attr.logonName = attr.user_name
+    if (attr.given_name) attr.givenName = attr.given_name
+    if (attr.family_name) attr.familyName = attr.family_name
+
+    return new cds.User({ id: payload.sub, attr, tokenInfo })
+  }
+}
 
 // REVISIT: Why do we need to know and do that?
 const KNOWN_CLAIMS = Object.values({
@@ -39,90 +137,3 @@ const KNOWN_CLAIMS = Object.values({
   // own
   APP_TENANT_ID: 'app_tid'
 })
-
-
-module.exports = function ias_auth(config) {
-  // cds.env.requires.auth.known_claims is not an official config!
-  const { kind, credentials, known_claims = KNOWN_CLAIMS } = config
-  const skipped_attrs = known_claims.reduce((a,x) => { a[x] = 1; return a }, {})
-
-  if (!credentials) throw new Error(
-    `Authentication kind "${kind}" configured, but no IAS instance bound to application. ` +
-    'Either bind an IAS instance, or switch to an authentication kind that does not require a binding.'
-  )
-
-  function getUser(tokenInfo) {
-    const payload = tokenInfo.getPayload()
-
-    const clientid = tokenInfo.getClientId()
-    if (clientid === payload.sub) { //> grant_type === client_credentials or x509
-      const roles = { 'system-user': 1 }
-      if (Array.isArray(payload.ias_apis)) payload.ias_apis.forEach(r => (roles[r] = 1))
-      if (clientid === credentials.clientid) roles['internal-user'] = 1
-      else delete roles['internal-user']
-      return new cds.User({ id: 'system', roles, tokenInfo })
-    }
-
-    // add all unknown attributes to req.user.attr in order to keep public API small
-    const attr = {}
-    for (const key in payload) {
-      if (key in skipped_attrs) continue // REVISIT: Why do we need to do that?
-      else attr[key] = payload[key]
-    }
-
-    // REVISIT: just don't such things, please! -> We're just piling up tech dept through tons of unoficcial long tail APIs like that!
-    // REVISIT: looks like wrong direction to me, btw
-    // same api as xsuaa-auth for easier migration
-    if (attr.user_name) attr.logonName = attr.user_name
-    if (attr.given_name) attr.givenName = attr.given_name
-    if (attr.family_name) attr.familyName = attr.family_name
-
-    return new cds.User({ id: payload.sub, attr, tokenInfo })
-  }
-
-  // NOTE: Use named function for better stack traces... for the actual middleware, of course, not that much for the factory!
-
-  if (xssec.v3 && cds.env.features.xssec_compat !== true) { // no official flag!
-    let { createSecurityContext, IdentityService, errors: { ValidationError } } = xssec
-    const authService = new IdentityService(credentials)
-
-    return async function ias_auth (req, _, next) {
-      if (!req.headers.authorization) return next()
-      try {
-        const secContext = await createSecurityContext(authService, { req })
-        const tokenInfo = secContext.token
-        const ctx = cds.context
-        ctx.user = getUser(tokenInfo)
-        ctx.tenant = tokenInfo.getZoneId()
-        req.authInfo = secContext //> compat req.authInfo
-      } catch(e) {
-        if (e instanceof ValidationError) {
-          LOG.warn("Unauthenticated request: ", e);
-          return next(401)
-        }
-        LOG.error("Error while authenticating user: ", e);
-        return next(500)
-      }
-      next()
-    }
-  } else { // TODO: Remove with cds 9
-    xssec = xssec.v3 || xssec
-    return function ias_auth (req, _, next) {
-      if (!req.headers.authorization) return next()
-      const token = req.headers.authorization.slice(7) // skip /^bearer /
-        xssec.createSecurityContext(token, credentials, 'IAS', function (err, securityContext, tokenInfo) {
-
-          if (err) LOG.warn('User could not be authenticated due to error:', err)
-          if (!securityContext) {
-            return next(401)
-          }
-          else req.authInfo = securityContext //> compat req.authInfo
-
-          const ctx = cds.context
-          ctx.user = getUser(tokenInfo)
-          ctx.tenant = tokenInfo.getZoneId()
-          next()
-        })
-    }
-  }
-}

package/lib/srv/middlewares/auth/jwt-auth.js

@@ -1,27 +1,60 @@
 const cds = require('../../../index.js')
 const LOG = cds.log('auth')
 
-let xssec = require('./xssec')
+const {
+  createSecurityContext,
+  XsuaaService,
+  errors: { ValidationError }
+} = require('./xssec')
 
 module.exports = function jwt_auth(config) {
-  const { kind, credentials } = config
+  const { kind, credentials, config: serviceConfig = {} } = config
+
+  if (!credentials)
+    throw new Error(
+      `Authentication kind "${kind}" configured, but no XSUAA instance bound to application. ` +
+        'Either bind an XSUAA instance, or switch to an authentication kind that does not require a binding.'
+    )
+
+  const auth_service = new XsuaaService(credentials, serviceConfig)
+  const user_factory = get_user_factory(credentials, credentials.xsappname, kind)
+
+  return async function jwt_auth(req, _, next) {
+    if (!req.headers.authorization) return next()
+
+    try {
+      const securityContext = await createSecurityContext(auth_service, { req })
+      const tokenInfo = securityContext.token
+      const ctx = cds.context
+      ctx.user = user_factory(tokenInfo)
+      ctx.tenant = tokenInfo.getZoneId()
+      req.authInfo = securityContext //> compat req.authInfo
+    } catch (e) {
+      if (e instanceof ValidationError) {
+        LOG.warn('Unauthenticated request: ', e)
+        return next(401)
+      }
+      LOG.error('Error while authenticating user: ', e)
+      return next(500)
+    }
 
-  if (!credentials) throw new Error(
-    `Authentication kind "${kind}" configured, but no XSUAA instance bound to application. ` +
-    'Either bind an XSUAA instance, or switch to an authentication kind that does not require a binding.'
-  )
+    next()
+  }
+}
 
-  const xsappname = credentials.xsappname.length + 1
+function get_user_factory(credentials, xsappname, kind) {
+  xsappname = xsappname + '.'
 
-  function getUser(tokenInfo) {
+  return function user_factory(tokenInfo) {
     const payload = tokenInfo.getPayload()
 
     let id = payload.user_name
 
     const roles = {}
     for (let scope of payload.scope) {
-      let role = scope.slice(xsappname) // Roles = scope names w/o xsappname...
-      if (role in { 'internal-user': 1, 'system-user': 1 }) continue  // Disallow setting system roles from external
+      let role = scope.replace(xsappname, '') // Roles = scope names w/o xsappname...
+      if (role in { 'internal-user': 1, 'system-user': 1 })
+        continue // Disallow setting system roles from external
       else roles[role] = 1
     }
 
@@ -32,7 +65,7 @@ module.exports = function jwt_auth(config) {
       if (tokenInfo.getClientId() === credentials.clientid) roles['internal-user'] = 1
     }
 
-    const attr = { ... payload['xs.user.attributes'] }
+    const attr = { ...payload['xs.user.attributes'] }
     if (kind === 'xsuaa') {
       attr.logonName = payload.user_name
       attr.givenName = payload.given_name
@@ -42,50 +75,4 @@ module.exports = function jwt_auth(config) {
 
     return new cds.User({ id, roles, attr, tokenInfo })
   }
-  if (xssec.v3 && cds.env.features.xssec_compat !== true) { // no official flag!
-    const { createSecurityContext, XsuaaService, errors: { ValidationError } } = xssec
-    const authService = new XsuaaService(credentials)
-
-      return async function jwt_auth(req, _, next) {
-        if (!req.headers.authorization) return next()
-
-        try {
-          const secContext = await createSecurityContext(authService, { req })
-          const tokenInfo = secContext.token
-          const ctx = cds.context
-          ctx.user = getUser(tokenInfo)
-          ctx.tenant = tokenInfo.getZoneId()
-          req.authInfo = secContext //> compat req.authInfo
-        } catch(e) {
-          if(e instanceof ValidationError) {
-            LOG.warn("Unauthenticated request: ", e);
-            return next(401)
-          }
-          LOG.error("Error while authenticating user: ", e);
-          return next(500)
-        }
-
-        next()
-      }
-
-  } else {
-    xssec = xssec.v3 || xssec
-
-    // NOTE: Use named function for better stack traces... for the actual middleware, of course, not that much for the factory!
-      return function jwt_auth (req, _, next) {
-        if (!req.headers.authorization) return next()
-        const token = req.headers.authorization.slice(7) // skip /^bearer /
-          xssec.createSecurityContext(token, credentials, function (err, securityContext, tokenInfo) {
-
-            if (err) LOG.warn('User could not be authenticated due to error:', err)
-            if (!securityContext) return next(401)
-            else req.authInfo = securityContext //> compat req.authInfo
-
-            const ctx = cds.context
-            ctx.user = getUser(tokenInfo)
-            ctx.tenant = tokenInfo.getZoneId()
-            next()
-          })
-      }
-  }
 }

package/lib/srv/middlewares/cds-context.js

@@ -12,6 +12,6 @@ module.exports = () => {
     const id = req.headers[corr_id] ??= req.headers[crippled_corr_id] || req.headers[req_id] || req.headers[vr_id] || uuid()
     const ctx = EventContext.for ({ id, http: { req, res } })
     res.set ('X-Correlation-ID', id) // Note: we use capitalized style here as that's common standard in HTTP world
-    cds._context.run (ctx, next)
+    cds._with (ctx, next)
   }
 }

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

@@ -9,7 +9,7 @@ module.exports = ()=> {
     if (req.baseUrl.startsWith('/-/')) return next() //> our own tech services cannot be extended
     const ctx = cds.context
     if (ctx.tenant || ctx.features?.given) try {
-      ctx.model = req.__model = await model4 (ctx.tenant, ctx.features) // REVISIT: req.__model is because of Okra
+      ctx.model = await model4 (ctx.tenant, ctx.features)
     } catch (e) {
       LOG.error(e)
       return res.status(503) .json ({ // REVISIT: we should throw a simple error, nothing else! -> this is overly OData-specific!