@sap/cds 5.4.6 → 5.5.0

package/lib/ql/Whereable.js

@@ -1,112 +1,102 @@
+const { error } = require ('../index')
+const parse = require('./parse')
+
 class Whereable extends require('./Query') {
 
-  where(...x) {
-    const pred = _where(x)
-    if (pred.length > 0)
-      this._.where = !this._.where ? pred : ['(', ...this._.where, ')', 'and', ...pred]
-    return this
-  }
-  and(...x) {
-    this._.where = [...this._.where, 'and', ..._where(x)]
-    return this
-  }
-  or(...x) {
-    this._.where = [...this._.where, 'or', ..._where(x)]
+  where(...x) { return this._where (x,'and','where') }
+  and(...x) {  return this._where (x,'and') }
+  or(...x) { return this._where (x,'or') }
+  _where (args, and_or, _clause) {
+    let pred = predicate4(args, _clause)
+    if (pred && pred.length > 0) {
+      let _ = this[this.cmd]
+      if (!_clause) _clause = (
+        _.having ? 'having' :
+        _.where ? 'where' :
+        _.from && _.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,_)
+      if (!left) {
+        if (pred.includes('or')) Object.defineProperty(pred,'_includes_or__',{value:1})
+        _[_clause] = pred
+      } else {
+        if (and_or === 'and') {
+          if (left._includes_or__) left = [{xpr:left}]
+          if (pred.includes('or')) pred = [{xpr:pred}]
+        }
+        _[_clause] = [ ...left, and_or, ...pred ]
+      }
+    }
     return this
   }
-  byKey(ID) {
-    if (this.SELECT) this._.one = true
-    return this.where(typeof ID === 'object' ? ID : { ID })
-  }
-}
 
-const _where = (args) => {
-  if (is_array(args[0])) return args[0]
-  if (is_xpr(args)) return args
-  if (is_object(args)) return _where_object(args)
-  else return _where_fluid(args)
+  byKey(key) {
+    if (typeof key !== 'object') key = { [Object.keys(this._target.keys||{ID:1})[0]]: key }
+    if (this.SELECT) this.SELECT.one = true
+    return this.where(key)
+  }
 }
 
-// .where ('ID=',4711, 'and stock >=',1)
-const _where_fluid = (args) => {
-  // 1. construct a full expr string with ? for values collected in vals
-  let expr = args.filter((_, i) => i % 2 === 0).join(' ? ')
-  let vals = args.filter((_, i) => i % 2 === 1)
-  if (args.length % 2 === 0) expr += ' ?'
-  // 2. parse the expr string -> returns cxn ...
-  let {xpr} = parse.expr(expr), flat=[]
-  // 3. and replace {params} in there with collected vals
-  for (let x of xpr) {
-    const v = x.param ? val(vals.shift()) : x
-    is_array(v) ? flat.push(...v) : flat.push(v)
+const predicate4 = (args, _clause) => {
+  if (args.length === 0) return; const x = args[0]
+  if (x.raw) return parse.CXL(...args).xpr
+  if (args.length === 1 && typeof x === 'object') {
+    if (is_array(x)) return x
+    if (is_cqn(x)) return args
+    else return _object_predicate(args,_clause)
   }
-  return flat
+  else return _fluid_predicate(args)
 }
 
-// .where ({ID:4711, stock: {'>=':1})
-const _where_object = ([arg]) => {
+const _object_predicate = ([arg], _clause) => { // e.g. .where ({ID:4711, stock: {'>=':1})
   const pred = []
-  for (let k in arg) {
+  for (const k in arg) {
     const x = arg[k]
     if (k === 'and') {
-      let p2 = _where([x])
-      if (x.or) p2 = ['(',...p2,')']
-      pred.push('and', ...p2)
+      if (x.or) pred.push('and', {xpr:predicate4([x],_clause)})
+      else pred.push('and', ...predicate4([x],_clause))
       continue
     }
     if (k === 'or') {
-      pred.push('or', ..._where([x]))
+      pred.push('or', ...predicate4([x],_clause))
       continue
-    } else pred.push('and', parse.expr(k))
-    // if (x === null || x === undefined) pred.push('is null')
-    if (!x) pred.push('=', { val: x })
-    else if (is_array(x)) pred.push('in', { val: x })
-    else if (x.SELECT) pred.push('in', x)
-    else if (x.ref || x.val || x.xpr) pred.push('=', x)
-    else if (x instanceof RegExp) pred.push('like', { val: x })
-    else if (typeof x === 'object') for (let op in x) pred.push(op, { val: x[op] })
-    else pred.push('=', { val: x })
+    }
+    if (k === 'exists') {
+      pred.push(null, 'exists', ...predicate4([x],_clause))
+      continue
+    }
+    else pred.push('and', parse.expr(k))
+    if (!x || x==='*') pred.push('=', {val:x})
+    else if (x.SELECT || x.list) pred.push('in', x)
+    else if (is_array(x)) pred.push('in', {list:x.map(val)})
+    else if (is_cqn(x)) pred.push('=', x)
+    else if (x instanceof RegExp) pred.push('like', {val:x})
+    else if (typeof x === 'object') for (let op in x) pred.push(op, val(x[op]))
+    else if (_clause === 'on' && typeof x === 'string') pred.push('=', { ref: x.split('.') })
+    else pred.push('=', {val:x})
   }
   return pred.slice(1)
 }
 
-const parser = require('./parser')
-const parse = {
-  columns:(x) => simple(x) || parser.parse(x,{startRule:'columns'}),
-  column:(x) => simple(x) || parser.parse(x,{startRule:'column'}),
-  expr:(x) => simple(x) || parser.parse(x,{startRule:'expr'}),
-}
-
-const simple = (x) => {
-  if (typeof x !== 'string') return {val:x}
-  const t = /^\s*([\w.'?]+)(?:\s*([!?\\/:=\-+<~>]+|like)\s*([\w.'?]+))?\s*$/.exec(x); if (!t) return
-  const [,ref,op,rhs] = t
-  return op ? {xpr:[rv(ref),op,rv(rhs)]} : rv(ref)
-}
-
-const rv = (x) => {
-  if (x[0] === '?') return { param: true, ref: x }
-  if (x[0] === "'") return { val: x.slice(1, -1).replace(/''/g, "'") }
-  if (x === 'null') return { val: null }
-  if (x === 'true') return { val: true }
-  if (x === 'false') return { val: false }
-  if (!isNaN(x)) return { val: Number(x) }
-  else return { ref: x.split('.') }
-}
-
-const val = (x) => {
-  if (x === undefined || x.xpr || x.ref || x.val || x.func || x.SELECT) return x
-  if (is_array(x)) {
-    const xpr = []
-    for (let each of x) xpr.push(',',rv(each))
-    xpr[0]='('; xpr.push (')')
-    return xpr
-  }
-  return {val:x}
+const _fluid_predicate = (args) => { // e.g. .where ('ID=',4711, 'and stock >=',1)
+  if (args.length === 3 && args[1] in operators) return [ ref(args[0]), args[1], val(args[2]) ] // REVISIT: Legacy!
+  if (args.length % 2 === 0) args.push('')
+  const expr = args.filter((_, i) => i % 2 === 0).join(' ? ')
+  const vals = args.filter((_, i) => i % 2 === 1)
+  const {xpr} = parse.expr(expr)
+  ;(function _fill_in_vals_into (xpr) { xpr.forEach ((x,i) => {
+    if (x.xpr) _fill_in_vals_into (x.xpr)
+    if (x.param) xpr[i] = val(vals.shift())
+  })})(xpr)
+  return xpr
 }
 
-const is_object = (args) => args.length === 1 && typeof args[0] === 'object'
-const is_xpr = (x) => x.length === 1 && (is_array(x[0]) || x[0].xpr || x[0].ref || x[0].val || x[0].func || x[0].SELECT)
+const ref = x => is_cqn(x) ? x : {ref:x.split('.')}
+const val = x => !x ? {val:x} : is_array(x) ? {list:x.map(val)} : is_cqn(x) ? x : {val:x}
+const is_cqn = x => x.val !== undefined || x.xpr || x.ref || x.list || x.func || x.SELECT
 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, { _where, parse })
+module.exports = Object.assign (Whereable, { predicate4, parse })

package/lib/ql/index.js

@@ -1,28 +1,40 @@
-if (/\b(y|ql)\b/.test(process.env.cdr)) {
+const cds = require('../index')
+require = path => { // eslint-disable-line no-global-assign
+  const clazz = module.require (path); if (!clazz._api) return clazz
+  Object.defineProperty (clazz.prototype, 'cmd', { value: path.match(/\w+$/)[0] })
+  return clazz._api()
+}
+
+module.exports = Object.assign (_deprecated_srv_ql, { cdr: true,
+  SELECT: require('./SELECT'),
+  INSERT: require('./INSERT'),
+  UPDATE: require('./UPDATE'),
+  DELETE: require('./DELETE'),
+  CREATE: require('./CREATE'),
+  DROP: require('./DROP'),
+})
 
-  const SELECT = require('./SELECT')
-  const INSERT = require('./INSERT')
-  const UPDATE = require('./UPDATE')
-  const DELETE = require('./DELETE')
-  const CREATE = require('./CREATE')
-  const DROP   = require('./DROP')
+function _deprecated_srv_ql() { // eslint-disable-next-line no-console
+  console.trace(`
+    Method 'srv.ql(req)' is deprecated and superceded by 'cds.context'.
+    Please use global SELECT instead of 'const { SELECT } = srv.ql(req)'.
+  `)
+  return module.exports
+}
 
-  module.exports = {
-    SELECT: SELECT._,
-    INSERT: INSERT._,
-    UPDATE: UPDATE._,
-    DELETE: DELETE._,
-    CREATE: CREATE._,
-    DROP:  DROP._,
-    classes: {
-      SELECT, INSERT, UPDATE, DELETE,
-      CREATE, DROP,
-      Query: require('./Query'),
-      Whereable: require('./Whereable'),
-    },
-  }
+if (cds.env.features.cls && cds.env.features.debug_queries) {
+  const Query = module.exports, { then } = Query.prototype
+  const { AsyncResource } = require('async_hooks')
+  Object.defineProperty (Query,'then',{ get(){
+    const q = new AsyncResource('cds.Query')
+    return (r,e) => q.runInAsyncScope (then,this,r,e)
+  }})
+}
 
-} else {
-  // Using monkey-patched implementations from cds-runtime
-  Object.assign (module, {exports: require('./rt')})
+module.exports._reset = ()=>{ // for strange tests only
+  const _name = cds.env.sql.names === 'quoted' ? n =>`"${n}"` : n => n.replace(/[.:]/g,'_')
+  Object.defineProperty (require('./Query').prototype,'valueOf',{ configurable:1, value: function(cmd=this.cmd) {
+    return `${cmd} ${_name(this._target.name)} `
+  }})
+  return this
 }

package/lib/ql/parse.js

@@ -0,0 +1,35 @@
+// please keep all comments!
+
+const cds = require('../index')
+module.exports = {
+  column:(x) => _simple(x) /* || _parse('column',x) */ || cds.parse.column(x),
+  expr:(x) => _simple(x) /* || _parse('expr',x) */ || cds.parse.expr(x),
+  CQL: (..._) => cds.parse.CQL (..._),
+  CXL: (..._) => cds.parse.CXL (..._),
+  cql: (..._) => cds.parse.cql (..._),
+}
+
+const _simple = (x) => {
+  if (typeof x !== 'string') return {val:x}
+  const t = /^\s*([\w.'?]+)(?:\s*([!?\\/:=\-+<~>]+|like)\s*([\w.'?]+))?\s*$/.exec(x); if (!t) return
+  const [,lhs,op,rhs] = t
+  return op ? {xpr:[_rv(lhs),op,_rv(rhs)]} : _rv(lhs)
+}
+
+const _rv = (x) => {
+  if (x[0] === '?')  return { param: true, ref: x }
+  if (x[0] === "'")  return { val: x.slice(1,-1).replace(/''/g, "'") }
+  if (x === 'null')  return { val: null }
+  if (x === 'true')  return { val: true }
+  if (x === 'false') return { val: false }
+  if (!isNaN(x))     return { val: Number(x) }
+  else               return { ref: x.split('.') }
+}
+
+// const _parse = (startRule,x) => {
+//   try {
+//     return parser.parse(x,{startRule})
+//     // } catch (e) { e.message += ' in: \n' + x;  throw e }
+//   }  catch {/* ignored */}
+// }
+// const parser = require('./parser')

package/lib/req/context.js

@@ -1,8 +1,6 @@
+const cds = require ('../index'), { features } = cds.env, { uuid } = cds.utils
 const async_events = { succeeded:1, failed:1, done:1 }
-const { features } = require('../env')
 const { EventEmitter } = require('events')
-const { uuid } = require('../utils')
-const User = require ('./user')
 
 /**
  * This is the base class for `cds.Events` and `cds.Requests`,
@@ -14,6 +12,43 @@ class EventContext {
 
   toString() { return `${this.event} ${this.path}` }
 
+  static new (data) {
+    const base = cds.context
+    if (base && features.cds_tx_inheritance) {
+      const { tenant, user, locale, _ } = base
+      data = { user: user && Object.create(user), tenant, locale, _, ...data }
+      // REVISIT: Do we have to propagate hidden subdomain as well?
+      // let subdomain = _ && _.req && _.req && _.req.authInfo && _.req.authInfo.getSubdomain()
+      // if (subdomain) {
+      //   if (!data._) data._ = {}
+      //   if (!data._.req) data._.req = {}
+      //   if (!data._.req.authInfo) data._.req.authInfo = { setSubdomain(v){ this.subdomain = v } }
+      //   if (!data._.req.authInfo.getSubdomain()) data._.req.authInfo.setSubdomain (subdomain)
+      // }
+    } else if (data && 'user' in data) {
+      data = { user:1, ...data } // IMPORTANT: ensure user is first to be assigned to call setter
+    }
+    return new this (data)
+  }
+
+  static spawn (background_job,o) {
+    const fn = async ()=> {
+      // create a new transaction for each run of the background job
+      // which inherits from the current event context by default
+      const tx = cds.context = cds.tx({...o})
+      try {
+        await background_job(tx)
+        await tx.commit()
+      } catch(e) {
+        console.trace (`ERROR occured in background job:`, e) // eslint-disable-line no-console
+        await tx.rollback()
+      }
+    }
+    if (o && o.after) return setTimeout (fn, o.after)
+    if (o && o.every) return setInterval (fn, o.every)
+    else return setImmediate (fn)
+  }
+
   constructor(_={}) {
     Object.assign (this, this._set('_',_))
   }
@@ -76,12 +111,13 @@ class EventContext {
   }
 
   set user(u) {
-    if (!u) return; else super.user = u
-    // REVISIT: The following is to support user.locale
-    if (this._.req) Object.defineProperty(u,'_req',{value:this._.req})
+    if (!u) return
+    if (typeof u === 'string') u = new cds.User(u)
+    if (this._.req) Object.defineProperty(u,'_req',{value:this._.req}) // REVISIT: The following is to support req.user.locale
+    super.user = u
   }
   get user() {
-    return this.user = this._propagated('user') || new User
+    return this.user = this._propagated('user') || new cds.User
   }
 
   set locale(l) {
@@ -97,7 +133,7 @@ class EventContext {
 
   set headers(h) { if (h) super.headers = h }
   get headers() {
-    if (this._.req && this._.req.headers) {
+    if (this._ && this._.req && this._.req.headers) {
       return super.headers = this._.req.headers
     } else {
       const headers={}, outer = this._propagated('headers')

package/lib/req/locale.js

@@ -1,5 +1,5 @@
 
-const {i18n} = require('../env')
+const {i18n} = require('..').env
 const INCLUDE_LIST = i18n.preserved_locales.reduce((p,n)=>{
   p[n]=n; p[n.toUpperCase()]=n; return p
 },{
@@ -7,16 +7,16 @@ const INCLUDE_LIST = i18n.preserved_locales.reduce((p,n)=>{
   en_US_x_sappsd: 'en_US_sappsd'
 })
 
-module.exports = function req_locale (req) {
+const from_req = req => req.query['sap-language'] || req.headers['x-sap-request-language'] || req.headers['accept-language']
+
+function req_locale (req) {
   if (!req) return i18n.default_language
-  const locale = (
-    req.query['sap-language'] ||
-    req.headers['x-sap-request-language'] ||
-    req.headers['accept-language']
-  )
+  const locale = from_req(req)
   if (!locale) return i18n.default_language
   const loc = locale.replace(/-/g,'_')
   return INCLUDE_LIST[loc]
   || /([a-z]+)/i.test(loc) && RegExp.$1.toLowerCase()
   || i18n.default_language
 }
+
+module.exports = Object.assign(req_locale, { from_req })

package/lib/serve/Service-api.js

@@ -1,15 +1,13 @@
 const add_methods_to = require ('./Service-methods')
 const cds = require('..')
-const { is_array } = require('../ql/rt/_helpers')
 
 
 class Service extends require('./Service-handlers') {
 
-  constructor (name, model, options={}) {
-    super (name || new.target.name)
-    if (options.kind) this.kind = options.kind // shortcut
+  constructor (name, model, o={}) {
+    super (name || new.target.name) .options = o
+    if (o.kind) this.kind = o.kind // shortcut
     if (model) this.model = model
-    this.options = options
   }
 
   /**
@@ -71,15 +69,21 @@ class Service extends require('./Service-handlers') {
   /**
    * Model Reflection API...
    */
-  get definition() { return super.definition = this.model && this.model.definitions [this.name] }
+  get definition() {
+    const defs = this.model && this.model.definitions, o = this.options
+    return super.definition = defs && (o && defs[o.service] || defs[this.name] )
+  }
+
+  get namespace()  {
+    return super.namespace  = this.definition && this.definition.name
+    || this.model && this.model.namespace
+    || this.name !== 'db' && !/\W/.test(this.name) && this.name || undefined
+  }
+
   get operations() { return super.operations = _reflect (this, d => d.kind === 'action' || d.kind === 'function') }
   get entities()   { return super.entities   = _reflect (this, d => d.kind === 'entity') }
   get events()     { return super.events     = _reflect (this, d => d.kind === 'event') }
   get types()      { return super.types      = _reflect (this, d => !d.kind || d.kind === 'type') }
-  get namespace()  { return super.namespace  = this.definition && this.name
-    || this.model && this.model.namespace
-    || this.name !== 'db' && !/\W/.test(this.name) && this.name || undefined
-  }
 
   /**
    * Subclasses may override this to free private resources
@@ -90,15 +94,18 @@ class Service extends require('./Service-handlers') {
   }
 
 }
-module.exports = Service
+
+const { dispatch, handle } = require('./Service-dispatch')
+Service.prototype.dispatch = dispatch
+Service.prototype.handle = handle
 Service.prototype.transaction = Service.prototype.tx = require('./Transaction')
-Service.prototype.dispatch = require('./Service-dispatch')
 Service.prototype._compat_sync = require('./Service-compat')
 Service.prototype._implicit_next = cds.env.features.implicit_next
 Service.prototype._is_service_instance = Service._is_service_class = true //> for factory
-
+module.exports = Service
 
 // Helpers...
 const _reflect = (srv,filter) => !srv.model ? [] : srv.model.childrenOf (srv.namespace,filter)
 const is_rest = x => x && typeof x === 'string' && x[0] === '/'
-const is_query = x => x && x.bind || is_array(x) && !x.raw
+const is_query = x => x && x.bind || is_array(x) && !x.raw
+const is_array = (x) => Array.isArray(x) && !x.raw

package/lib/serve/Service-dispatch.js

@@ -1,17 +1,20 @@
 const cds = require ('../index')
 
 /**
- * This is the implementation of the `srv.dispatch(req)` method.
- * It dispatches the request through the registered event handlers.
- * @param {import('../req/event') & import('../req/impl')} req
+ * The default implementation of the `srv.dispatch(req)` ensures everything
+ * is prepared before calling `srv.handle(req)`
+ * @typedef {import('./Service-api')} Service
+ * @typedef {import('../req/impl')} Request
+ * @this {Service}
+ * @param {Request} req
  * @returns {Promise} resolving to the outcome/return value of last .on handler
  */
-module.exports = async function dispatch (req) { //NOSONAR
+exports.dispatch = async function dispatch (req) { //NOSONAR
 
   // Ensure we are in a proper transaction
   if (!this.context) {
     const txc = cds.context //> join an outer tx.context, if any, with a nested tx
-    if (txc) return this.tx(txc).dispatch(req)
+    if (txc && !txc._done) return this.tx(txc).dispatch(req)
     else try {    //>  start a new top-level tx, which we need to commit/rollback
       const tx = cds.context = this.tx(req)
       return tx.dispatch(req) .then (tx.commit, tx.rollback)
@@ -28,28 +31,41 @@ module.exports = async function dispatch (req) { //NOSONAR
     return Promise.all (req.query.map (q => this.dispatch ({query:q,__proto__:req})))
 
   // Ensure target and fqns
-  const srv = this; let handlers //...
-  if (!req.target) _ensure_target (srv,req)
+  if (!req.target) _ensure_target (this,req)
   if (req.query && typeof req.query === 'object' && !req.query._srv) Object.defineProperty (req.query,'_srv',{value:this})
 
+  return this.handle(req)
+}
+
+
+/**
+ * The default implementation of the `srv.handle(req)` method dispatches
+ * requests through registered event handlers.
+ * Subclasses should overload this method instead of `srv.dispatch`.
+ * @param {Request} req
+ * @this {Service}
+ */
+exports.handle = async function handle (req) {
+  const srv=this; let handlers //...
+
   // ._initial handlers run in sequence
   handlers = this._handlers._initial.filter (h => h.for(req))
   if (handlers.length) {
-    for (const each of handlers) await each.handler.call (srv,req)
+    for (const each of handlers) await each.handler.call (this,req)
     if (req.errors) throw req.errors.throwable()
   }
 
   // .before handlers run in parallel
   handlers = this._handlers.before.filter (h => h.for(req))
   if (handlers.length) {
-    await Promise.all (handlers.map (each => each.handler.call (srv,req)))
+    await Promise.all (handlers.map (each => each.handler.call (this,req)))
     if (req.errors) throw req.errors.throwable()
   }
 
   // .on handlers run in parallel for async events, and as interceptors stack for sync requests
   handlers = this._handlers.on.filter (h => h.for(req))
   if (handlers.length) {
-    if (!req.reply) await Promise.all (handlers.map (each => each.handler.call (srv,req,_dummy)))
+    if (!req.reply) await Promise.all (handlers.map (each => each.handler.call (this,req,_dummy)))
     else await async function next (r=req) { //> handlers may pass a new req object into next()
       const each = handlers.shift(); if (!each) return //> unhandled silently
       const x = await each.handler.call (srv,r,next)
@@ -59,13 +75,13 @@ module.exports = async function dispatch (req) { //NOSONAR
     }()
     if (req.errors) throw req.errors.throwable()
   }
-  else if (req.query) throw _unhandled (srv,req)
+  else if (req.query) throw _unhandled (this,req)
 
   // .after handlers run in parallel
   handlers = this._handlers.after.filter (h => h.for(req))
   if (handlers.length) {
     const results = cds.env.features.arrayed_after && req.event === 'READ' && !_is_array(req.results) ? [req.results] : req.results // REVISIT: remove this in a future release after some grace period
-    await Promise.all (handlers.map (each => each.handler.call (srv, results, req)))
+    await Promise.all (handlers.map (each => each.handler.call (this, results, req)))
     if (req.errors) throw req.errors.throwable()
   }
 

package/lib/serve/Transaction.js

@@ -1,4 +1,4 @@
-const cds = require('../index'), { Context } = cds.Request
+const cds = require('../index'), { Context } = cds.Request, { cds_tx_protection } = cds.env.features
 const _context = Symbol()
 
 /**
@@ -6,11 +6,11 @@ const _context = Symbol()
  * a new Transaction as a derivate of the `srv` (i.e. {__proto__:srv})
  * @returns { Transaction & import('./Service-api') }
  */
-module.exports = function tx (req) { const srv = this
+module.exports = function tx (req,o) { const srv = this
   if (srv.context) return srv
   if (!req) {
     // called as srv.tx() -> new root transaction
-    return RootTransaction.for (srv, new Context)
+    return RootTransaction.for (srv, Context.new())
   }
   if (req instanceof Context) {
     // called for a nested req -> nested tx
@@ -20,12 +20,17 @@ module.exports = function tx (req) { const srv = this
     // called for a top-level req -> root tx
     else return RootTransaction.for (srv, req)
   }
+  if (typeof req === 'function') {
+    // auto-committed transaction, i.e. cds.tx (tx => {...})
+    const tx = srv.tx(o)
+    return Promise.resolve().then (()=> req(tx)) .then (tx.commit,tx.rollback)
+  }
   if (req[_context]) {
     // called again for an arbitrary context object -> see below
     return NestedTransaction.for (srv, req[_context])
   } else {
     // called first time for an arbitrary context object
-    const root = new Context(req); Object.defineProperty (req, _context, {value:root})
+    const root = Context.new(req); Object.defineProperty (req, _context, {value:root})
     return RootTransaction.for (srv, root)
   }
 }
@@ -59,7 +64,7 @@ class Transaction {
   async commit (res) {
     if (this.ready) { //> nothing to do if no transaction started at all
       if (this.__proto__.commit) await this.__proto__.commit.call (this,res)
-      _init (this)
+      _init(this).ready = 'committed'
     }
     return res
   }
@@ -78,7 +83,7 @@ class Transaction {
 
     if (this.ready) { //> nothing to do if no transaction started at all
       if (this.__proto__.rollback) await this.__proto__.rollback.call (this,err)
-      _init (this)
+      _init(this).ready = 'rolled back'
     }
     if (err) throw err
   }
@@ -100,6 +105,7 @@ class RootTransaction extends Transaction {
    * are informed by emitting 'succeesed' event to them all.
    */
   async commit (res) {
+    if (cds_tx_protection) this.context._done = 'committed'
     try {
       await this.context.emit ('succeeded',res)
       await super.commit (res)
@@ -115,6 +121,7 @@ class RootTransaction extends Transaction {
    * are informed by emitting 'failed' event to them all.
    */
   async rollback (err) {
+    if (cds_tx_protection) this.context._done = 'rolled back'
     try {
       await this.context.emit ('failed',err)
       await super.rollback (err)
@@ -148,14 +155,19 @@ class NestedTransaction extends Transaction {
  * before any .dispatch.
  */
 const _init = (tx) => {
-  if ('begin' in tx) tx.dispatch = begin_and_dispatch
-  tx.ready = false
+  if ('begin' in tx) tx.dispatch = _begin
+  else tx.ready = true //> to allow subclasses w/o .begin
   return tx
 }
-async function begin_and_dispatch (req) {
+const _begin = async function (req) {
   if (!req.query && req.method === 'BEGIN') // IMPORTANT: !req.query is to exclude batch requests
     return this.ready = this.__proto__.dispatch.call (this,req)
-  if (!this.ready) this.ready = this.begin()
+  // Protection against unintended tx.run() after tx.commit/rollback()
+  if (typeof this.ready === 'string' || !this.ready && this.context._done) {
+    if (cds_tx_protection) throw Object.assign(new Error (`Transaction is ${this.ready || this.context._done}, no subsequent .run allowed, without prior .begin`), { code: 'TRANSACTION_CLOSED' })
+    else this.ready = this.begin() // compatibiliy to former behavior, which allowed tx.run() after commit/rollback
+  }
+  else if (!this.ready) this.ready = this.begin()
   await this.ready
   delete this.dispatch
   return this.dispatch (req)