@sap/cds 5.7.5 → 5.8.2

package/lib/i18n/localize.js

@@ -33,19 +33,16 @@ function localize (model, /*with:*/ locale, aString) {
 }
 
 const TEXT_KEY_MARKER = 'i18n>'
-const TEXT_KEYS = /"([^"{]+)?{b?i18n>([^"}]+)}([^"]+)?"/g
+const TEXT_KEYS = /{b?i18n>([^"}]+)}/g
 function localizeString (aString, bundle) {
   if (!bundle || !aString)  return aString
   if (typeof aString === 'object')  aString = JSON.stringify(aString, null, 2)
   // quick check for presence of any text key, to avoid expensive operation below
   if (aString.indexOf(TEXT_KEY_MARKER) < 0)  return aString
-  const isXml = aString.startsWith('<?xml')
-  const isJson = /^[{[]/.test(aString)
-  return aString.replace (TEXT_KEYS, (_, left='', key, right='') => {
-    let val = bundle[key] || key
-    if      (val && isXml)   val = escapeXmlAttr(val)
-    else if (val && isJson)  val = escapeJson(val)
-    return `"${left}${val}${right}"`
+  const escape = aString.startsWith('<?xml') ? escapeXmlAttr : /^[{[]/.test(aString) ? escapeJson : v=>v
+  return aString.replace (TEXT_KEYS, (_, key) => {
+    const val = bundle[key]
+    return val ? escape(val) : key
   })
 }
 

package/lib/index.js

@@ -9,6 +9,7 @@ if (global.cds) Object.assign(module,{exports:global.cds}) ; else {
     get builtin()  { return super.builtin = require ('./core') }
     get service()  { return super.service = extend (this.builtin.classes.service) .with ({
       /** @param x {(this:Service, srv:Service) => any} */ impl: x=>x,
+      /** @type {{ [path:string] : Service }} */ paths: {},
       /** @type Service[] */ providers: [],
       factory: require ('./serve/factory'),
       bindings: require ('./connect/bindings'),

package/lib/log/errors.js

@@ -2,7 +2,7 @@ const error = exports = module.exports = (..._) => { throw _error(..._) }
 const _error = (msg, _details, _base = error, ...etc) => {
   if (msg.raw) return _error (String.raw (msg,_details,_base,...etc))
   const e = msg instanceof Error ? msg : new Error (msg)
-  Error.captureStackTrace(e,_base)
+  if (_base) Error.captureStackTrace (e,_base)
   if (_details) Object.assign (e,_details)
   return e
 }

package/lib/log/format/kibana.js

@@ -1,4 +1,4 @@
-const cds = require ('../../')
+const cds = require('../../')
 const util = require('util')
 
 const _l2l = { 1: 'error', 2: 'warn', 3: 'info', 4: 'debug', 5: 'trace' }
@@ -8,7 +8,7 @@ const _l2l = { 1: 'error', 2: 'warn', 3: 'info', 4: 'debug', 5: 'trace' }
  */
 module.exports = (module, level, ...args) => {
   // config
-  const { user: log_user , kibana_custom_fields } = cds.env.log
+  const { user: log_user, kibana_custom_fields } = cds.env.log
 
   // build the object to log
   const toLog = {
@@ -36,7 +36,7 @@ module.exports = (module, level, ...args) => {
   if (args.length && typeof args[0] === 'object' && args[0].message) {
     const err = args.shift()
     toLog.msg = err.message
-    if (err instanceof Error) toLog.stacktrace = err.stack.split(/\s*\r?\n\s*/)
+    if (typeof err.stack === 'string') toLog.stacktrace = err.stack.split(/\s*\r?\n\s*/)
     Object.assign(toLog, err, { level: toLog.level })
   }
 

package/lib/ql/SELECT.js

@@ -130,8 +130,8 @@ module.exports = class SELECT extends Whereable {
 const _columns = (args) => {
   const x = args[0]
   if (x.raw) {
-    if (x[0] === '{') return SELECT_('from X ',args).columns
-    else              return SELECT_('from X {',args,'}').columns
+    if (x[0][0] === '{') return SELECT_('from X ',args).columns
+    else                 return SELECT_('from X {',args,'}').columns
   } else {
     if (typeof x === 'string' && x[0] === '{') return parse.cql('SELECT from X '+ x).SELECT.columns
     else return _columns_or_not(x) || args.map(_column_expr)

package/lib/req/cds-context.js

@@ -61,7 +61,7 @@ exports.spawn = function cds_spawn (o,fn) {
       for (const handler of em.listeners('succeeded')) await handler(res)
       for (const handler of em.listeners('done')) await handler()
     }
-    fn(tx).then(commit, tx.rollback) .catch (async e => {
+    Promise.resolve().then(() => fn(tx)).then(commit, tx.rollback) .catch (async e => {
       // tx.rollback throws passed error -> we will arrive here for any error
       cds.log().error(`ERROR occured in background job:`, e)
       for (const handler of em.listeners('failed')) await handler(e)

package/lib/req/context.js

@@ -75,7 +75,7 @@ class EventContext {
   // The following properties are inherited from root contexts, if exist...
   //
 
-  set context(c) { if (c) super.context = c }
+  set context(c) { if (c) this._set('context',c) }
   get context() { return this }
 
   set id(c) { if (c) super.id = c }

package/lib/serve/Transaction.js

@@ -1,4 +1,5 @@
-const cds = require('../index'), { EventContext } = cds, { cds_tx_protection } = cds.env.features
+const cds = require('../index'), { cds_tx_protection } = cds.env.features
+const EventContext = require('../req/context')
 
 /**
  * This is the implementation of the `srv.tx(req)` method. It constructs
@@ -74,8 +75,8 @@ class Transaction {
    * in order to prevent continuous use without explicit reopen (i.e., begin).
    */
   async rollback (err) {
-    // nothing to do if transaction already rolled back or committed (committed occurs if error thrown in on succeeded handler)
-    if (this.ready === 'rolled back' || this.ready === 'committed') return
+    // nothing to do if transaction already rolled back
+    if (this.ready === 'rolled back') return
 
     /*
      * srv.on('error', function (err, req) { ... })
@@ -85,7 +86,8 @@ class Transaction {
     if (err) for (const each of this._handlers._error) each.handler.call(this, err, this.context)
 
     if (this.ready) { //> nothing to do if no transaction started at all
-      if (this.__proto__.rollback) await this.__proto__.rollback.call (this,err)
+      // don't actually roll back if already committed (e.g., error thrown in on succeeded or on done)
+      if (this.ready !== 'committed' && this.__proto__.rollback) await this.__proto__.rollback.call (this,err)
       _init(this).ready = 'rolled back'
     }
     if (err) throw err
@@ -98,6 +100,7 @@ class RootTransaction extends Transaction {
 
   /**
    * Register the new transaction with the root context.
+   * @param {EventContext} root
    */
   static for (srv,root) {
     return root._tx = super.for (srv,root)
@@ -110,8 +113,9 @@ class RootTransaction extends Transaction {
   async commit (res) {
     if (cds_tx_protection) this.context._done = 'committed'
     try {
-      await this.context.emit ('succeeded',res)
+      await this.context.emit ('commit',res) //> allow custom handlers req.before('commit')
       await super.commit (res)
+      await this.context.emit ('succeeded',res)
       await this.context.emit ('done')
     } catch (err) {
       await this.rollback (err)

package/lib/serve/index.js

@@ -75,7 +75,9 @@ function cds_serve (som, _options) { // NOSONAR
   let ready = provided.then (()=> Promise.all (all.map (async srv => {
     srv.init && await srv.prepend (srv.init)
     srv.options.impl && await srv.prepend (srv.options.impl)
-    srv[_ready](cds.services[srv.name] = srv)
+    cds.services[srv.name] = cds.service.paths[srv.path] = srv
+    cds.service.providers.push (srv)
+    srv[_ready](srv)
     return srv
   })))
 
@@ -83,7 +85,14 @@ function cds_serve (som, _options) { // NOSONAR
   // 6) Fluent method to serve constructed providers to express app
   fluent.in = (app) => {
     ready = ready.then (()=>{
+      const edms = {}
+      if (cds.env.features.precompile_edms) { // > unofficial config for eval
+        const all = cds.compile.to.edm(cds.model, { service: 'all' })
+        for (let [edm,{ file }] of all) edms[file] = edm
+      }
+
       for (let each of all) {
+        each._edm = edms[each.name]
         ProtocolAdapter.serve(each).in(app)
         if (!o.silent) cds.emit ('serving',each)
       }
@@ -116,8 +125,7 @@ function _new (Service, d,m,o) {
     if (required.name) srv.name = required.name
     if (o.mocked) srv.mocked = true
   }
-  if (!srv.path) srv.path = path4(srv,o.at)
-  cds.service.providers.push (srv)
+  if (!srv.path) srv.path = cds.service.path4(srv,o.at)
   _pending[srv.name] = new Promise (r => srv[_ready]=r).finally(()=>{
     delete _pending[srv.name]
     delete srv[_ready]
@@ -126,25 +134,9 @@ function _new (Service, d,m,o) {
 }
 
 
-/**
- * Resolve a service endpoint path to mount it to as follows...
- * Use _path or def[@path] if given with leading '/' prepended if necessary.
- * Otherwise, use the service definition name with stripped 'Service'
- */
-function path4 (srv, _path = (srv.definition || srv)['@path']) {
-	if (_path)  return _path.replace(/^[^/]/, c => '/'+c)
-	else  return '/' + ( // generate one from the service's name
-		/[^.]+$/.exec(srv.name)[0]  //> my.very.CatalogService --> CatalogService
-		.replace(/Service$/,'')     //> CatalogService --> Catalog
-		.replace(/([a-z0-9])([A-Z])/g, (_,c,C) => c+'-'+C.toLowerCase())  //> ODataFooBarX9 --> odata-foo-bar-x9
-		.replace(/_/g,'-')  //> foo_bar_baz --> foo-bar-baz
-		.toLowerCase()      //> FOO --> foo
-	)
-}
-
-
 const is_csn = x => x && x.definitions
 const is_file = x => typeof x === 'string' && !/^[\w$]*$/.test(x)
 const is_class = x => typeof x === 'function' && x.prototype && /^class\b/.test(x)
 
-module.exports = Object.assign (cds_serve, { path4 })
+Object.defineProperty (cds_serve, 'path4', { get(){ return cds.service.path4 } })
+module.exports = cds_serve

package/lib/utils/tests.js

@@ -1,25 +1,22 @@
-const { resolve, dirname } = require('path')
+const { is_mocha } = support_jest_and_mocha()
 
 class Test extends require('./axios') {
 
-  static run(..._) { return (new Test).run(..._) }
-  get cds() { return require('../index') }
-  get Test() { return Test }
-
   /**
    * Launches a cds server with arbitrary port and returns a subclass which
    * also acts as an axios lookalike, providing methods to send requests.
    */
   run (cmd='.', ...args) {
-    initLogging()
+
+    this.cmd = cmd, this.args = args
 
     // launch cds server...
-    global.before (`launching ${cmd} ${args.join(' ')}...`, () => { // NOSONAR
+    before (`launching ${cmd} ${args.join(' ')}...`, () => { // NOSONAR
 
       const {cds} = this
       if (!/^(serve|run)$/.test(cmd)) try {
-        const project = cds.utils.isdir (cmd) || dirname (require.resolve (cmd+'/package.json'))
-        cmd='serve'; args.push ('--project', project, '--in-memory?')
+        const project = cds.utils.isdir (cmd) || require.resolve (cmd+'/package.json').slice(0,-13)
+        cmd='serve'; args.push ('--in-memory?', '--project', project)
       } catch(e) {
         throw cds.error (`No such folder or package '${process.cwd()}' -> '${cmd}'`)
       }
@@ -32,16 +29,16 @@ class Test extends require('./axios') {
       })
 
       try { return cds.exec (cmd, ...args, '--port','0') }
-      catch (e) { if (is_mocha) console.error(e) }
+      catch (e) { if (is_mocha) console.error(e) } // eslint-disable-line no-console
     })
 
-    global.beforeEach (async () => {
-      if (this.data._autoReset)  await this.data.reset()
+    // shutdown cds server...
+    after (done => {
+      this.server ? this.server.close (done) : done && done()
     })
 
-    // shutdown cds server...
-    global.after (done => {
-      this.server ? this.server.close (done) : done()
+    beforeEach (async () => {
+      if (this.data._autoReset)  await this.data.reset()
     })
 
     return this
@@ -50,18 +47,20 @@ class Test extends require('./axios') {
   /**
    * Serving projects from subfolders under the root specified by a sequence
    * of path components which are concatenated with path.resolve().
+   * Checks conflicts with cds.env loaded in other folder before.
    */
   in (...paths) {
-    const {cds} = this; cds.root = resolve (cds.root, ...paths)
-    // Checking conflicts with global.cds loaded in other folder before
-    const ep = Reflect.getOwnPropertyDescriptor(global.cds,'env')
-    if (ep && ep.value && ep.value._home !== cds.root) throw new Error (`[cds.test] - 'cds.env' was invoked before 'cds.test.in' from a different home:
+    const {cds} = this; cds.root = require('path').resolve (cds.root, ...paths)
+    // const env = Reflect.getOwnPropertyDescriptor(global.cds,'env')
+    // if (env && env.value && env.value._home !== cds.root) {
+    //   throw new Error (`[cds.test] - 'cds.env' was invoked before 'cds.test.in' from a different home:
 
-      cds.env._home: ${cds.env._home}
-      cds.test.in:   ${cds.root}
+    //   cds.env._home: ${cds.env._home}
+    //   cds.test.in:   ${cds.root}
 
-    > throwing this as tests would likely behave erratically.
-    `)
+    //   > throwing this as tests would likely behave erratically.
+    //   `)
+    // }
     return this
   }
 
@@ -74,64 +73,89 @@ class Test extends require('./axios') {
     return this
   }
 
-  /**
-   * Lazily loads and returns an instance of chai
-   */
-  get chai() {
-    const require = (mod) => { try { return module.require(mod) } catch(e) {
-      if (e.code === 'MODULE_NOT_FOUND') throw new Error (`
-      Failed to load required package '${mod}'. Please add it thru:
-      npm add -D chai chai-as-promised chai-subset
-    `)}}
-    const chai = require('chai')
-    chai.use (require('chai-subset'))
-    chai.use (require('chai-as-promised'))
-    return super.chai = chai
-  }
-  get expect(){ return this.chai.expect }
-  get assert(){ return this.chai.assert }
-  get sleep(){ return require('util').promisify(setTimeout) }
-  get data() { return this._data || (this._data = new (require('./data')))}
+  /**  Lazily loads and returns an instance of chai */
+  get chai() { return super.chai = load_chai() }
+  get expect() { global.describe.each || support_jest_and_mocha(); return this.chai.expect }
+  get assert() { global.describe.each || support_jest_and_mocha(); return this.chai.assert }
+  get sleep() { return super.sleep = require('util').promisify(setTimeout) }
+  get data() { return super.data = new (require('./data'))}
+  get cds() { return require('../index') }
+  get spy() { return spy }
 
 }
 
-// harmonizing jest and mocha
-const is_jest = !!global.beforeAll
-const is_mocha = !!global.before
-if (is_mocha) {
-  const { format } = require('util')
-  global.beforeAll = global.before
-  global.afterAll = global.after
-  global.test = global.it
-  global.it.each = (table) => (title,fn) => Promise.all (table.map(each => {
-      if (!Array.isArray(each)) each = [each]
-      return it (format(title,...each), ()=> fn(...each))
-  }))
-} else if (is_jest) { // it's jest
-  global.before = (msg,fn) => global.beforeAll(fn||msg)
-  global.after = (msg,fn) => global.afterAll(fn||msg)
-} else { // it's none of both
-  global.before = global.beforeAll = (_,fn) => fn()
-  global.beforeEach = ()=>{}
-  global.afterEach = ()=>{}
-  global.after = global.afterAll = ()=>{}
+function support_jest_and_mocha() {
+  const is_jest = !!global.beforeAll
+  const is_mocha = !!global.before
+  if (is_mocha) {
+    global.beforeAll = global.before
+    global.afterAll = global.after
+    global.test = global.it
+    const { format } = require('util')
+    for (let td of [ 'test', 'describe' ]) global[td].each = function(table) {
+      return (title,fn) => Promise.all (table.map (each => {
+        if (!Array.isArray(each))  each = [each]
+        return this (format(title,...each), ()=> fn(...each))
+      }))
+    }
+    after(()=>{
+      delete global.cds
+      for (let k in require.cache) delete require.cache[k]
+    })
+  } else if (is_jest) { // it's jest
+    global.before = (msg,fn) => global.beforeAll(fn||msg)
+    global.after = (msg,fn) => global.afterAll(fn||msg)
+  } else { // it's none of both
+    global.before = global.beforeAll = (_,fn) => fn()
+    global.beforeEach = ()=>{}
+    global.afterEach = ()=>{}
+    global.after = global.afterAll = (fn) => {
+      const repl = global.cds.repl
+      repl && repl.on('exit',fn)
+    }
+    process.env.CDS_TEST_VERBOSE = true
+  }
+  initLogging()
+  return { is_jest, is_mocha }
+}
+
+function load_chai() {
+  const require = (mod) => { try { return module.require(mod) } catch(e) {
+    if (e.code === 'MODULE_NOT_FOUND') throw new Error (`
+    Failed to load required package '${mod}'. Please add it thru:
+    npm add -D chai chai-as-promised chai-subset
+  `)}}
+  const chai = require('chai')
+  chai.use (require('chai-subset'))
+  chai.use (require('chai-as-promised'))
+  return chai
 }
 
 function initLogging() {
   const levels = process.env.CDS_TEST_VERBOSE
     ? { deploy:'info', serve:'info', server:'info',cds:'info' }
-    : { deploy:'warn', serve:'warn', server:'warn',cds:'silent'/*silences provoked request errors */ }
+    : { deploy:'warn', serve:'warn', server:'warn',cds:'silent' /* silences provoked request errors */ }
 
   const env = Reflect.getOwnPropertyDescriptor(global.cds,'env')
   for (const id of Object.keys(levels)) {
     if (env && env.value)
       global.cds.log(id, { level:levels[id] })
     else // uninitialized cds.env -> set env variables to avoid initializing cds.env eagerly
-      process.env['CDS_LOG_LEVELS_'+id.toUpperCase()] = levels[id]
+      process.env['cds_log_levels_'+id] = levels[id]
+  }
+}
+
+const spy = (o,f) => {
+  const origin = o[f]
+  const fn = function (...args) {
+    ++fn.called
+    return origin.apply(this,args)
   }
+  fn.called = 0
+  fn.restore = ()=> o[f] = origin
+  return o[f] = fn
 }
 
-/** @type Test.run & Test */
-module.exports = Object.setPrototypeOf (Test.run, Test.prototype)
 
-/* eslint no-console: off */
+/** @type Test & ()=>Test */
+module.exports = Object.setPrototypeOf ((..._) => (new Test).run(..._), Test.prototype)

package/libx/_runtime/audit/generic/personal/modification.js

@@ -17,14 +17,6 @@ const {
 let als
 
 const attachDiffToContextHandler = async function (req) {
-  // REVISIT: what does this do?
-  Object.defineProperty(req.query, '_selectAll', {
-    enumerable: false,
-    writable: false,
-    configurable: true,
-    value: true
-  })
-
   // store diff in audit data structure at context
   if (!req.context._audit.diffs) req.context._audit.diffs = new Map()
   req.context._audit.diffs.set(req._.query, await req.diff())

package/libx/_runtime/auth/index.js

@@ -2,7 +2,7 @@ const cds = require('../cds')
 const LOG = cds.log('app')
 
 const _require = require('../common/utils/require')
-const { UNAUTHORIZED } = require('../common/utils/auth')
+const { UNAUTHORIZED } = require('./utils')
 
 let passport
 
@@ -17,6 +17,10 @@ const _initializers = {
     const DummyStrategy = require('./strategies/dummy')
     passport.use(new DummyStrategy())
   },
+  dwc: () => {
+    const DwcStrategy = require('./strategies/dwc')
+    passport.use(new DwcStrategy())
+  },
   JWT: ({ uaa }) => {
     const JWTStrategy = require('./strategies/JWT')
     passport.use(new JWTStrategy(uaa))
@@ -89,14 +93,11 @@ const _callback = (req, res, next, err, user, info) => {
 module.exports = (srv, app, options) => {
   let config = options.auth
 
-  const isRestricted = _isRestricted(srv)
+  const isRestricted = _isRestricted(srv) || (cds.env.requires.auth && cds.env.requires.auth.restrict_all_services)
   const isMultiTenant = !!(cds.env.requires && cds.env.requires.db && cds.env.requires.db.multiTenant)
 
   if (!config && !isRestricted && (!isMultiTenant || process.env.NODE_ENV !== 'production')) {
-    if (isMultiTenant) {
-      LOG._warn && LOG.warn(`[${srv.name}] - Authentication needed for multitenancy in production.`)
-    }
-
+    if (isMultiTenant) LOG._warn && LOG.warn(`[${srv.name}] - Authentication needed for multitenancy in production.`)
     return
   }
 

package/libx/_runtime/auth/strategies/dwc.js

@@ -0,0 +1,43 @@
+const cds = require('../../cds')
+const LOG = cds.log()
+
+function decode(req, header, parsed) {
+  if (!req.headers[header]) return
+  return parsed
+    ? JSON.parse(Buffer.from(req.headers[header], 'base64').toString('utf-8'))
+    : Buffer.from(req.headers[header], 'base64').toString('utf-8')
+}
+
+class DwcStrategy {
+  constructor() {
+    this.name = 'dwc'
+  }
+
+  authenticate(req) {
+    let tenant, usr, scopes, attr
+    try {
+      tenant = decode(req, 'dwc-tenant')
+      usr = decode(req, 'dwc-user', true)
+      scopes = decode(req, 'dwc-scopes', true) || []
+      attr = decode(req, 'dwc-xsuaa-attributes', true) || {}
+    } catch (e) {
+      LOG._warn && LOG.warn('Error while parsing headers for dwc-auth:', e)
+      return this.fail()
+    }
+    if (!tenant || !usr) return this.fail()
+
+    const user = new cds.User({
+      id: usr.logonName,
+      tenant,
+      _roles: ['any', 'authenticated-user', ...scopes],
+      attr: Object.assign(attr, usr)
+    })
+
+    // set _req for locale getter
+    Object.defineProperty(user, '_req', { enumerable: false, value: req })
+
+    this.success(user)
+  }
+}
+
+module.exports = DwcStrategy

package/libx/_runtime/auth/utils.js

@@ -0,0 +1,24 @@
+const cds = require('../cds')
+
+const UNAUTHORIZED = { statusCode: 401, code: '401', message: 'Unauthorized' }
+const FORBIDDEN = { statusCode: 403, code: '403', message: 'Forbidden' }
+
+const getRequiresAsArray = definition => {
+  const requires = []
+
+  if (definition['@requires']) {
+    if (Array.isArray(definition['@requires'])) requires.push(...definition['@requires'])
+    else requires.push(definition['@requires'])
+  }
+
+  const { restrict_all_services: restrictAllServices } = cds.env.requires.auth || {}
+  if (!requires.length && definition.kind === 'service' && restrictAllServices) requires.push('authenticated-user')
+
+  return requires
+}
+
+module.exports = {
+  UNAUTHORIZED,
+  FORBIDDEN,
+  getRequiresAsArray
+}

package/libx/_runtime/cds-services/adapter/odata-v4/ODataRequest.js

@@ -45,9 +45,7 @@ function _getTarget(service, segments) {
       : last.getEdmType().csdlStructuredType.name
 
     // autoexposed entities now used . in csn and _ in edm
-    const target =
-      findCsnTargetFor(name, service.model, namespace) ||
-      (name.endsWith('Parameters') && service.model.definitions[namespace + '.' + name.replace(/Parameters$/, '')])
+    const target = findCsnTargetFor(name, service.model, namespace)
 
     if (target && target.kind === 'entity') {
       return target

package/libx/_runtime/cds-services/adapter/odata-v4/handlers/action.js

@@ -14,31 +14,6 @@ const { setStatusCodeAndHeader, getKeyProperty } = require('../../../../fiori/ut
 const { toODataResult, postProcess } = require('../utils/result')
 const { mergeJson } = require('../../../services/utils/compareJson')
 
-/*
- * Get the returns object for the (un)bound action from CSN.
- */
-const _getTypeReturns = (definitions, req, service) => {
-  if (req.event === 'draftPrepare' || req.event === 'EDIT' || req.event === 'draftActivate') {
-    return 'Other'
-  }
-
-  if (req.target && req._.odataReq.getUriInfo().getLastSegment().getKind() === 'BOUND.ACTION') {
-    return definitions[req.target.name].actions[req.event].returns
-  }
-
-  // Also support correct req.event without service prefix
-  return (definitions[req.event] || definitions[`${service.name}.${req.event}`]).returns
-}
-
-/*
- * Check if the return is an array or any other.
- */
-const _getActionReturnType = (service, req) => {
-  const returns = _getTypeReturns(service.model.definitions, req, service)
-
-  return returns && returns.items ? 'Array' : 'Other'
-}
-
 const _postProcessDraftActivate = async (req, result, service) => {
   // update req.data (keys needed in readAfterWrite)
   req.data = result
@@ -59,8 +34,9 @@ const _postProcess = async (req, odataReq, odataRes, tx, result) => {
   // REVISIT: harmonize getactionreturntype functions
   const actionReturnType = getActionOrFunctionReturnType(odataReq.getUriInfo().getPathSegments(), tx.model.definitions)
   if (actionReturnType && actionReturnType.kind === 'entity' && odataReq.getQueryOptions()) {
-    await actionAndFunctionQueries(req, odataReq, result, tx, actionReturnType)
+    result = await actionAndFunctionQueries(req, odataReq, result, tx, actionReturnType)
   }
+  return result
 }
 
 /**
@@ -72,6 +48,7 @@ const _postProcess = async (req, odataReq, odataRes, tx, result) => {
 const action = service => {
   return async (odataReq, odataRes, next) => {
     let req
+
     try {
       validateResourcePath(odataReq, service)
       req = new ODataRequest(ACTION_EXECUTE_HANDLER, service, odataReq, odataRes)
@@ -84,6 +61,7 @@ const action = service => {
     cds.context = tx
 
     let result, err
+
     try {
       result = await tx.dispatch(req)
 
@@ -95,7 +73,7 @@ const action = service => {
         setStatusCodeAndHeader(odataRes, { [k]: result[k] }, req.target.name.replace(`${service.name}.`, ''), true)
       }
 
-      await _postProcess(req, odataReq, odataRes, tx, result)
+      result = await _postProcess(req, odataReq, odataRes, tx, result)
 
       if (changeset) {
         // for passing into commit
@@ -105,18 +83,19 @@ const action = service => {
       }
     } catch (e) {
       err = e
-      if (!changeset) {
-        // REVISIT: rollback needed if error occured before commit attempted -> how to distinguish?
-        await tx.rollback(e).catch(() => {})
-      } else if (changeset) {
+
+      if (changeset) {
         // for passing into rollback
         odataReq.getBatchApplicationData().errors[changeset].push({ error: e, req })
+      } else {
+        // REVISIT: rollback needed if an error occurred before commit attempted -> how to distinguish?
+        await tx.rollback(e).catch(() => {})
       }
     } finally {
       req.messages && odataRes.setHeader('sap-messages', getSapMessages(req.messages, req._.req))
 
       if (err) next(err)
-      else next(null, toODataResult(result, _getActionReturnType(service, req)))
+      else next(null, toODataResult(result, req))
     }
   }
 }