@sap/cds 8.9.3 → 9.0.2

package/lib/srv/middlewares/errors.js

@@ -1,55 +1,47 @@
-const { isStandardError } = require('../../../libx/_runtime/common/error/standardError')
-
-const production = process.env.NODE_ENV === 'production'
-const cds = require('../..')
+const cds = require('../..'), {i18n} = cds
 const LOG = cds.log('error')
-const { inspect } = cds.utils
+const internals = /\n +at .*(?:node_modules\/express|node:).*/gm
+const is_test = typeof global.it === 'function'
 
 module.exports = () => {
-  // eslint-disable-next-line no-unused-vars
-  return async function http_error(error, req, res, next) {
-    if (isStandardError(error) && cds.env.server.shutdown_on_uncaught_errors) {
-      cds.log().error('❗️Uncaught', error)
-      await cds.shutdown(error)
-      return
-    }
+  /** @param {import('express').Response} res */
+  return function http_error (err, req, res, next) { // eslint-disable-line no-unused-vars
 
     // In case of 401 require login if available by auth strategy
-    if (typeof error === 'number') error = { code: error }
-    if (error.code == 401 && req._login) return req._login()
-
-    // Prepare and log the error object
-    const status = error.statusCode || error.status || Number(error.code) || 500
-    delete error.statusCode
-    delete error.status
-    if (!production && error.stack)
-      error.stack = error.stack.replace(/\n {4}at .*(?:node_modules\/express|node:internal).*/g, '')
-
-    if (400 <= status && status < 500) {
-      LOG.warn(status, '>', inspect(error))
-    } else {
-      LOG.error(status, '>', inspect(error))
-    }
+    if (typeof err === 'number') err = { code: err }
+    if (err.code == 401 && req._login) return req._login()
+
+    // Shutdown on uncaught errors, which could be critical programming errors
+    if (!is_test && cds.env.server.shutdown_on_uncaught_errors)
+      if (cds.error.isSystemError(err))
+        return cds.shutdown(err)
+
+    // Prepare status and a serializable error object
+    let { statusCode:sc, status = sc || Number(err.code) || 500, message, toJSON, ...rest } = err // eslint-disable-line no-unused-vars
+    let error = { message, ...rest, __proto__:err } // toJSON is inherited from __proto__:err
+    res.status(status)
+
+    // Log the error, with cleansed stack trace
+    if (err.stack) Object.defineProperty (err, 'stack', { value: err.stack.replace (internals,'') })
+    const log = status < 500 ? LOG.warn : LOG.error
+    log (status, '-', error) // TODO: don't log validation errors as errors
 
+    // Already sent a response? => done
     if (res.headersSent) return
 
-    // Expose as little information as possible in production, and as much as possible in development
-    if (production) {
-      Object.defineProperties(error, {
-        message: { enumerable: true },
-        user: { enumerable: false }
-      })
-    } else {
-      Object.defineProperties(error, {
-        message: { enumerable: true },
-        stack: { enumerable: true }
-      })
+    // In case of 5xx errors in production don't reveal details to clients
+    let PROD = process.env.NODE_ENV === 'production' || process.env.CDS_ENV === 'prod'
+    if (PROD && status >= 500 && error.$sanitize !== false) error = {
+      message: i18n.messages.at(status, cds.context.locale) || 'Internal Server Error',
+      code: String(status), // toJSON is intentionally gone
     }
 
-    // Send the error response
-    return res.status(status).json({ error })
+    // Errors can come with a custom $response() method to control how the
+    // error response shall be structured; default: { error: { ... } }
+    // E.g., SCIM doesn't wrap the error => err.$response = err => err
+    let response = err.$response?.call(error,error) || { error }
 
-    // Note: express returns errors as XML, we prefer JSON
-    // next(error)
+    // Finally send the error response
+    return res.json (response)
   }
 }

package/lib/srv/protocols/hcql.js

@@ -1,12 +1,12 @@
 const cds = require('../../index'), {inspect} = cds.utils
 const express = require('express')
 const LOG = cds.log('hcql')
+const PROD = process.env.NODE_ENV === 'production'
 
 class HCQLAdapter extends require('./http') {
 
   get router() {
 
-    const srv = this.service
     const router = super.router
     .get ('/\\$csn', this.schema.bind(this))      //> return the CSN as schema
     .use (express.json(this.body_parser_options)) //> for application/json -> cqn
@@ -14,29 +14,27 @@ class HCQLAdapter extends require('./http') {
 
     // Route for custom actions and functions ...
     const action = this.action.bind(this)
-    router.param('action', (req,_,next,a) => { (req.action = a) in srv.actions ? next() : next('route') })
+    router.param('action', (r,_,next,a) => a in this.service.actions ? next() : next('route'))
     router.route('/:action')
     .post (action)
     .get (action)
     .all ((req,res,next) => next(501))
 
     // Route for REST-style convenience shortcuts with queries in URL + body ...
-    if (process.env.NODE_ENV !== 'production') {
-      const $ = cb => (req,_,next) => { req.body = cb(req.params,req); next() }
-      router.param('entity', (req,_,next,a) => { a in srv.entities ? next() : next(404) })
-      router.route('/:entity/:id?(%20?:tail)?')
-      .get ($(({entity,id,tail}, req) => {
-        const body = typeof req.body === 'string' ? req.body : ''
-        return tail || body ? {SELECT:{
-          ...SELECT (`from _ ${body} ${tail||''}`).SELECT,
-          ...SELECT.from (entity,id).SELECT
-        }} : SELECT.from (entity,id)
-      }))
-      .post   ($(({entity}, {query,body}) => INSERT.into (entity) .entries ({...query,...body})))
-      .put    ($(({entity,id}, {query,body}) => UPDATE (entity,id) .with ({...query,...body})))
-      .patch  ($(({entity,id}, {query,body}) => UPDATE (entity,id) .with ({...query,...body})))
-      .delete ($(({entity,id}) => DELETE.from (entity, id)))
-    }
+    const $ = cb => (req,_,next) => { req.body = cb(req.params,req); next() }
+    PROD || router.route('/:entity/:id?')
+    .get ($(({entity,id,tail}, req) => {
+      if (entity.includes(' ')) [,entity,tail] = /^(\w+)( .*)?/.exec(entity)
+      if (id?.includes(' ')) [,id,tail] = /^(\w+)( .*)/.exec(id)
+      let q = SELECT.from (entity,id), body = req.body
+      if (body) Object.assign (q.SELECT, ql_fragment(body))
+      if (tail) Object.assign (q.SELECT, ql_fragment(tail))
+      return q
+    }))
+    .post   ($(({entity}, {query,body}) => INSERT.into (entity) .entries ({...query,...body})))
+    .put    ($(({entity,id}, {query,body}) => UPDATE (entity,id) .with ({...query,...body})))
+    .patch  ($(({entity,id}, {query,body}) => UPDATE (entity,id) .with ({...query,...body})))
+    .delete ($(({entity,id}) => DELETE.from (entity, id)))
 
     // The ultimate handler for CRUD requests
     router.use (this.crud.bind(this))
@@ -48,7 +46,7 @@ class HCQLAdapter extends require('./http') {
    * Handle requests to custom actions and functions.
    */
   action (req, res, next) {
-    return this.service.send (req.action, { ...req.query, ...req.body })
+    return this.service.send (req.params.action, { ...req.query, ...req.body })
     .then (results => this.reply (results, res))
     .catch (next)
   }
@@ -71,11 +69,6 @@ class HCQLAdapter extends require('./http') {
    */
   query4 (/** @type express.Request */ req) {
     let q = req.body = cds.ql(req.body) || this.error (400, 'Invalid query', { query: req.body })
-    // assert valid target entity
-    if (q.target?._unresolved && this.service.definition) {
-      q.target = q._target = this.service.entities [q.target.name]
-      || this.error (404, `'${q.target.name}' is not an entity served by '${this.service.name}'.`, { query:q })
-    }
     // handle request headers
     if (q.SELECT) {
       if (req.get('Accept-Language')) q.SELECT.localized = true
@@ -83,7 +76,17 @@ class HCQLAdapter extends require('./http') {
     }
     // got a valid query
     if (LOG._debug) LOG.debug (inspect(q))
-    return q
+    return this.valid(q)
+  }
+
+  /**
+   * Checks whether the service actually serves the target entity.
+   */
+  valid (query) {
+    if (!this.service.definition) return query
+    let target = cds.infer.target (query, this.service)
+    if (target._unresolved) throw this.error (400, `${target.name} is not an entity served by '${this.service.name}'.`, { query })
+    return query
   }
 
   /**
@@ -116,4 +119,11 @@ class HCQLAdapter extends require('./http') {
   }
 }
 
+const ql_fragment = x => {
+  if (x.length) {
+    x = SELECT (`from x ${x}`).SELECT
+    delete x.from
+  }
+  return x
+}
 module.exports = HCQLAdapter

package/lib/srv/protocols/index.js

@@ -127,15 +127,6 @@ class Protocols {
     return endpoints //.length ? endpoints : null
   }
 
-
-  /**
-   * For compatibility with old @sap/cds-dk versions <= 7.4.0
-   * @deprecated Use def.protocols instead
-   */
-  protocol4 (def) {
-    return def.protocols?.odata ? ['odata'] : []
-  }
-
   /**
    * Rarely used, e.g., by compile.to.openapi:
    * NOT PUBLIC API, hence not documented.

package/lib/srv/protocols/odata-v4.js

@@ -1,6 +1 @@
-const cds = require('../../index')
-if (cds.env.features.odata_new_adapter) {
-  module.exports = require('../../../libx/odata/ODataAdapter')
-} else {
-  module.exports = require('./okra')
-}
+module.exports = require('../../../libx/odata/ODataAdapter')

package/lib/srv/srv-dispatch.js

@@ -20,14 +20,11 @@ exports.dispatch = async function dispatch (req) { //NOSONAR
     q => this.dispatch ({ query:q, context: req.context, __proto__:req })
   ))
 
-  // Ensure target and fqns
-  if (!req.target) _ensure_target (this,req)
-  if (typeof req.query === 'object') {
-    if (req.query._target !== req.target) Object.defineProperty (req.query,'_target',{ value:req.target, configurable:true, writable:true })
-    if (!req.query._srv) Object.defineProperty (req.query,'_srv',{ value:this, configurable:true, writable:true })
-  }
+  // Ensure inferred target and fqns
+  _ensure_target (this,req)
 
-  return this.handle(req)
+  // Actually handle the request
+  return this.handle (req)
 }
 
 
@@ -64,7 +61,6 @@ exports.handle = async function handle (req) {
       const x = await each.handler.call (srv,r,next)
       if (x !== undefined)      return r.reply(x)
       if (r.results)            return r.results
-      if (srv._implicit_next)   return next()
     }()
     if (req.errors) throw req.reject()
   }
@@ -86,33 +82,35 @@ const _is_array = Array.isArray
 const _dummy = ()=>{} // REVISIT: required for some messaging tests which obviously still expect and call next()
 
 const _ensure_target = (srv,req) => {
-  const q = req.query, p = req._.path || req._.entity; if (!q && !p) return
-  if (srv.namespace) { // ensure fully-qualified names
-    if (p) _ensure_fqn (req,'path',srv, p.startsWith('/') ? p.slice(1) : p)
-    else if (q.SELECT) _ensure_fqn (q.SELECT,'from',srv)
-    else if (q.INSERT) _ensure_fqn (q.INSERT,'into',srv)
-    else if (q.UPSERT) _ensure_fqn (q.UPSERT,'into',srv)
-    else if (q.UPDATE) _ensure_fqn (q.UPDATE,'entity',srv)
-    else if (q.DELETE) _ensure_fqn (q.DELETE,'from',srv)
+
+  // Requests with query
+  if (typeof req.query === 'object') {
+    const q = req.query = cds.ql(req.query)
+    if (!q._subject) return // REVISIT: this is for attic code which sends strange req.query = {}
+    if (!q._srv) q.bind (srv) // ensure req.query to be an instance of cds.ql.Query
+    if (!req.target) {
+      if (srv.namespace && q._subject.ref) _ensure_fqn (q._subject.ref,0, srv)
+      req.target = cds.infer.target(q)
+    }
+    if (q._target !== req.target) q._target = req.target
+  }
+
+  // Requests without query
+  else if (!req.target && srv.namespace) {
+    let p = req._.path || req._.entity
+    if (p) _ensure_fqn (req,'path', srv, p[0] === '/' ? p.slice(1) : p)
+    if (srv.model?.definitions[req.path]) req.target = srv.model.definitions[req.path]
   }
-  const defs = srv.model?.definitions || {}
-  req.target = typeof q === 'object' ? cds.infer(q,defs) : defs[req.path]
 }
 
-const _ensure_fqn = (x,p,srv, from = x[p]) => {
-  if (!from) return
-  if (typeof from === 'string') {
-    if (from in srv.entities) return x[p] = srv.entities[from].name
-    if (srv.isDatabaseService) return
-    if (srv.model && from in srv.model.definitions) return
-    if (from.startsWith(srv.namespace)) return
-    if (from.endsWith('_drafts')) return // REVISIT: rather fix test/fiori/localized-draft.test.js ?
-    else x[p] = `${srv.namespace}.${from}`
-  } else if (from.ref) {
-    const [head] = from.ref
-    head.id ? _ensure_fqn(head,'id',srv) : _ensure_fqn(from.ref,0,srv)
-    if (x.where) for (let y of x.where) if (y.SELECT) _ensure_fqn(y.SELECT,'from',srv)
+const _ensure_fqn = (x,p,srv, name = x[p]) => {
+  if (name.id) return _ensure_fqn (name,'id', srv, name.id)
+  if (srv.model) {
+    if (name in srv.model.definitions) return // already an fqn
+    if (name in srv.entities) return x[p] = srv.entities[name].name
   }
+  if (srv.isDatabaseService) return // db services allow unknown entities, e.g. 'sqlite.schema'
+  if (!name.startsWith(srv.namespace+'.')) x[p] = `${srv.namespace}.${name}`
 }
 
 const _unhandled = (srv,req) => {

package/lib/srv/srv-handlers.js

@@ -1,7 +1,4 @@
-/** @typedef {import('./cds.Service')} Service } */
-
-const cds = require('..'), {expected} = cds.error
-const LOG = cds.log()
+const cds = require('..')
 
 class EventHandlers {
 
@@ -24,19 +21,21 @@ class EventHandlers {
   //--------------------------------------------------------------------------
   /** Registers event handlers. This is the central method to register handlers,
    * used by all respective public API methods, i.e. .on/before/after/reject.
+   * @import Service from './cds.Service'
+   * @import Request from '../req/request'
    * @param {Service} srv
    * @param {'on'|'before'|'after'} phase
    * @param {string|string[]} event
    * @param {string|string[]} path
-   * @param {(req)=>{}} handler
+   * @param {(req:Request)=>{}} handler
    */
   register (srv, phase, event, path, handler) {
 
     if (!handler) [ handler, path ] = [ path, '*' ] // argument path is optional
-    else if (path === undefined) expected `${{path}} to be a string or csn definition`
-    if (typeof handler !== 'function') expected `${{handler}} to be a function`
+    else if (path === undefined) cds.error.expected `${{path}} to be a string or csn definition`
+    if (typeof handler !== 'function') cds.error.expected `${{handler}} to be a function`
     if (handler._is_stub) {
-      LOG.warn (`\n
+      cds.log().warn (`\n
         WARNING: You are trying to register a frameworks-generated stub method for
         custom action/function '${event}' in implementation of service '${srv.name}'.
         We're ignoring that as we already registered the according handler.
@@ -64,9 +63,9 @@ class EventHandlers {
     }
     else if (typeof event === 'object') {
       // extract action name from an action definition's fqn
-      event = event.name && /[^.]+$/.exec(event.name)[0] || expected `${{event}} to be a string or an action's CSN definition`
+      event = event.name && /[^.]+$/.exec(event.name)[0] || cds.error.expected `${{event}} to be a string or an action's CSN definition`
     }
-    else event = AlternativeEvents[event] || event
+    else event = events[event] || event
 
     // Canonicalize path argument
     if (!path || path === '*') path = undefined
@@ -75,25 +74,12 @@ class EventHandlers {
       return srv
     }
     else if (typeof path === 'object') {
-      path = path.name || expected `${{path}} to be a string or an entity's CSN definition`
+      path = path.name || cds.error.expected `${{path}} to be a string or an entity's CSN definition`
     }
     else if (typeof path === 'string') {
       if (!path.startsWith(srv.name+'.')) path = `${srv.name}.${path}`
     }
 
-    if (cds.env.fiori.draft_compat) {
-      const entity = path && srv.model?.definitions[path.name || path]
-      if (['PATCH', 'CANCEL', 'NEW'].includes(event)) {
-        // delegate to drafts
-        path = typeof path === 'string' && path !== '*' && !path.endsWith('.drafts') ? path + '.drafts' : typeof path === 'object' && path.drafts || path
-        if (event === 'PATCH') event = 'UPDATE'
-      }
-      else if (entity && (event === 'READ' || entity.actions?.[event]) && (entity.drafts && !entity.name.endsWith('.drafts'))) {
-        // additionally add drafts for READ and bound actions/functions
-        this.register (srv, phase, event, entity.name + '.drafts', handler)
-      }
-    }
-
     // Finally register with a filter function to match requests to be handled
     const handlers = event === 'error' ? this._error : handler._initial ? this._initial : this[phase] // REVISIT: remove _initial handlers
     handlers.push (new EventHandler (phase, event, path, handler))
@@ -101,22 +87,7 @@ class EventHandlers {
     if (phase === 'on') cds.emit('subscribe',srv,event) //> inform messaging service
     return srv
   }
-
-
-  //--------------------------------------------------------------------------
-  // EXPERIMENTAL: It is not decided yet, whether we should keep the stuff below
-  // => Please do not use anywhere!
-  onSucceeded (...args) { return _req_on (this, 'succeeded', ...args) }
-  onFailed (...args) { return _req_on (this, 'failed', ...args) }
-  for (event, path) { //> fetch all handlers for the given event and path
-    const filtered = {}
-    for (let each in this) {
-      filtered[each] = this[each].filter (h => h.for({event,path}))
-    }
-    return filtered
-  }
 }
-module.exports = EventHandlers
 
 
 class EventHandler {
@@ -132,22 +103,19 @@ class EventHandler {
     if (event && path) return req => event === req.event && (path === req.path || path === req.entity)
     if (event) return req => event === req.event
     if (path) return req => path === req.path || path === req.entity
-    else return () => true
+    else return req => !req.event?.includes('/#')
   }
 }
 
 
 const is_array = Array.isArray
-const AlternativeEvents = {
+const events = {
   SELECT: 'READ',
   GET: 'READ',
   PUT: 'UPDATE',
   POST: 'CREATE',
+  PATCH: 'UPDATE',
   INSERT: 'CREATE',
 }
 
-
-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))
-}
+module.exports = EventHandlers

package/lib/srv/srv-methods.js

@@ -1,24 +1,19 @@
-/** @typedef {import('./cds.ServiceClient')} Service } */
-
 const cds = require('..')
 const LOG = cds.log('cds.serve',{label:'cds'})
 
-
+/** @import Service from './cds.Service' */
 /** @param {Service} srv */
-module.exports = function (srv=this) {
-  if (!srv.definition) return //> can only add shortcuts for actions declared in service models
-  if (!srv.isAppService && !srv.isExternal && !srv._add_stub_methods) return
-  for (const each of srv.actions) {
-    add_handler_for (srv, each)
-  }
-  for (const each of srv.entities) {
-    for (const a in each.actions) {
-      add_handler_for (srv, each.actions[a])
-    }
+module.exports = function (srv = this) {
+  if ( !srv.definition ) return //> can only add shortcuts for actions declared in service models
+  if ( srv.isAppService || srv.isExternal || srv._add_stub_methods ) {
+    for (const each of srv.actions)
+      add_handler_for (srv, each)
+    for (const each of srv.entities)
+      for (const a in each.actions)
+        add_handler_for (srv, each.actions[a])
   }
 }
 
-
 /** @param {Service} srv */
 const add_handler_for = (srv, def) => {
   const event = def.name.match(/\w*$/)[0]
@@ -32,7 +27,7 @@ const add_handler_for = (srv, def) => {
       srv.__proto__ === cds.RemoteService.prototype ? srv.__proto__ :
       srv.__proto__.__proto__ // in case of class-based impls
     )
-    if (method.name in baseclass) return LOG.warn(`WARNING: custom ${def.kind} '${event}()' conflicts with method in base class.
+    if (event in baseclass) return LOG.warn(`WARNING: custom ${def.kind} '${event}()' conflicts with method in base class.
 
       Cannot add typed method for custom ${def.kind} '${event}' to service impl of '${srv.name}',
       as this would shadow equally named method in service base class '${baseclass.constructor.name}'.
@@ -62,41 +57,24 @@ const add_handler_for = (srv, def) => {
       this.model.definitions[ $.name ]
       || this.entities[ $.name?.replace(`${this.name}.`,'') || $ ]
     )
-    if (target) {                        //> bound action/function?
+    if (target) {                       //> bound action/function?
       req.target = target; args.shift() // first argument is the target entity name
-      req.params = [ args.shift() ]    // second argument is the target's primary key
+      req.params = [ args.shift() ]     // second argument is the target's primary key
+      if (_consistent_params && typeof req.params[0] !== 'object')
+        req.params = [{ [Object.keys(target.keys)[0]]: req.params[0] }]
     }
     const {params} = target ? target.actions[event] : def
     if (params) req.data = _named(args,params) || _positional(args,params)
 
-    // ensure legacy compat, keys in req.data
-    if(cds.env.features.keys_in_data_compat && target) {
-      cds.utils.deprecated({ old: 'flag cds.env.features.keys_in_data_compat'})
-      // named/positional variant of keys
-      const named = req.params.length === 1 && typeof req.params[0] === 'object'
-
-      let pos = 0 //> counter for key in positional variant
-      for (const k in target.keys) {
-        if (req.data[k]) {
-          LOG._warn && LOG.warn(`
-          ${target.name} has defined ${k} as key and action parameter.
-          Key will be used in req.data.
-          `)
-        }
-        req.data[k] = named ? req.params[0][k] : req.params[pos++]
-      }
-
-    }
-
     return this.send (req)
   }
   Object.defineProperties(stub,{
     name: {value: /[^.]+$/.exec(srv.name)[0] +'.'+ event},
     _is_stub: {value:true},
   })
+  const _consistent_params = cds.env.features.consistent_params //> remove with cds^10
 }
 
-
 const _named = (args, declared) => {
   if (args.length > 1) return
   const a = args[0]

package/lib/srv/srv-tx.js

@@ -1,19 +1,9 @@
 /** @typedef {import('./cds.Service')} Service } */
 
-const cds = require('../index')
+const cds = require('../index'), { srv_tx_compat_for_afc = true } = cds.env.features
 const EventContext = require('../req/context')
-class RootContext extends EventContext {
-  static for(_) {
-    if (_ instanceof EventContext) return _
-    else return super.for(_,'as root')
-  }
-}
-class NestedContext extends EventContext {
-  static for(_) {
-    if (_ instanceof EventContext) return _
-    else return super.for(_)
-  }
-}
+class RootContext extends EventContext { static for(_) { return _ instanceof EventContext ? _ : super.for(_,'as root') } }
+class NestedContext extends EventContext { static for(_) { return _ instanceof EventContext ? _ : super.for(_) } }
 
 
 /**
@@ -24,25 +14,30 @@ class NestedContext extends EventContext {
  */
 module.exports = exports = function srv_tx (ctx,fn) { const srv = this
 
-  if (srv.context) return srv // srv.tx().tx() -> idempotent
+  // srv.tx().tx() -> idempotent no-op (questionable: ignoring all futher arguments)
+  if (srv.context) return srv
+
+  // Usage variant 1: srv.tx() -> get root tx for a service
   if (!ctx) return RootTransaction.for (srv)
 
-  // Creating root or nested txes for existing contexts
+  // Usage variant 2: srv.tx (fn) -> run fn in a new root tx
   if (typeof ctx === 'function') [ ctx, fn ] = [ undefined, ctx ]
-  else if (ctx instanceof EventContext) {
+  if (typeof fn === 'function') {
+    const tx = RootTransaction.for (srv, ctx)
+    return cds._with (tx, ()=> Promise.resolve(fn(tx)) .then (tx.commit, tx.rollback))
+  }
+
+  // Usage variant 3: srv.tx (req) -> LEGACY way of propagating tx before cds.context
+  if (ctx instanceof EventContext) {
     if (ctx.tx) return NestedTransaction.for (srv, ctx)
     else return RootTransaction.for (srv, ctx)
   }
 
-  // Last arg may be a function -> srv.tx (tx => { ... })
-  if (typeof fn === 'function') {
-    const tx = RootTransaction.for (srv, ctx)
-    return cds._context.run (tx, ()=> Promise.resolve(fn(tx)) .then (tx.commit, tx.rollback))
+  // Usage variant 4: srv.tx ({...}) -> get a new root tx for a service
+  if (srv_tx_compat_for_afc) { // REVISIT: compatibility for AFC only -> we should get rid of that
+    if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
+    else Object.defineProperty (ctx, '_txed_before', { value: ctx = RootContext.for(ctx) })
   }
-
-  // REVISIT: following is for compatibility with AFC only -> we should get rid of that
-  if (ctx._txed_before) return NestedTransaction.for (srv, ctx._txed_before)
-  else Object.defineProperty (ctx, '_txed_before', { value: ctx = RootContext.for(ctx) })
   return RootTransaction.for (srv, ctx)
 }
 
@@ -54,7 +49,6 @@ class Transaction {
    */
   static for (srv, ctx) {
     const txs = ctx.context.transactions || ctx.context._set ('transactions', new Map)
-    if (srv._real_srv) srv = srv._real_srv // REVISIT: srv._real_srv is a dirty hack for current Okra Adapters
     let tx = txs.get (srv)
     if (!tx) txs.set (srv, tx = new this (srv,ctx))
     return tx