@sap/cds 7.9.2 → 8.0.3

package/lib/test/reporter.js

@@ -0,0 +1,176 @@
+const { BRIGHT, BOLD, INVERT, GRAY, GREEN, RESET, LF='\n', DIMMED } = require('../utils/colors')
+const YELLOW = '\x1b[38;5;220m'
+const RED = '\x1b[38;5;160m'
+const PASS = '\x1b[38;5;244m'
+const FAIL = '\x1b[38;5;244m' // '\x1b[38;5;124m'
+const SKIP = RESET+DIMMED // '\x1b[38;5;244m' // '\x1b[38;5;124m'
+const { inspect } = require('node:util')
+/* eslint-disable no-console */
+
+module.exports = function report_on (test,o) {
+
+  const files = o.files
+  const suites = { passed:[], failed:[] }
+  const tests = { passed:0, failed:0, todo:0, skipped:0, recent:null }
+
+  // monkey-patch test.on to support filter functions like root, leaf, any
+  const {on} = test; test.on = (eve,filter,fn) => on.call (test, 'test:'+eve, !fn ? fn = filter : x => filter(x) && fn(x))
+  const root = x => !x.nesting && x.name.endsWith('.js')
+  const leaf = x => x.name[0] !== '<' && x.details?.type !== 'suite'
+  const any = x => x.name[0] !== '<'
+  const _indent4 = x => '  '.repeat (x.nesting + root(x))
+
+  // add handlers according to options
+  if (o.debug ??= process.env.debug) return debug(o.debug) // eslint-disable-line no-cond-assign
+  if (o.verbose || !o.silent && files.length < 2) verbose(); else silent()
+  if (o.unmute) unmute()
+  common()
+  return test
+
+
+  /**
+   * Adds common handlers to report test results.
+   * Used in silent mode as well as verbose mode.
+   */
+  function common() {
+
+    test.on ('pass', leaf, x => {
+      x.skip ? tests.skipped++ : x.todo ? tests.todo++ : tests.passed++
+    })
+
+    test.on ('fail', x => {
+      if (x.details.error.failureType in { subtestsFailed:1, cancelledByParent: 2 }) return
+      tests.failed++
+      if (o.silent) console.log(_indent4(x), BOLD + RED, 'X' + RESET+GRAY, x.name, RESET)
+      if (o.quiet) return
+      let err = x.details.error.cause || x.details.error
+      let msg = typeof err === 'string' ? err : inspect (err, { colors:true, depth:11 })
+      console.log(RESET)
+      console.log(msg
+        .replace(/\n.*cds\/lib\/test\/expect.js:.*\)/g,'')
+        .replace(/\n.*\(node:.*/g,'')
+        .replace(/^/gm, _indent4(x)+'  ')
+      )
+      if (!err.message && !o.unmute)
+        console.log('   ', INVERT+YELLOW, 'NOTE', RESET+YELLOW, '--unmute app log output to see error details.', RESET )
+      console.log(RESET)
+    })
+
+    test.on ('complete', root, x => {
+      (x.details.passed ? suites.passed : suites.failed) .push (x.file)
+    })
+
+    test.once ('fail', ()=> process.exitCode = 1)
+    process.on('exit', summary)
+  }
+
+
+  /**
+   * Adds handlers to report test results on root-level only,
+   * i.e., on test file level.
+   */
+  function silent() {
+    console.log() // start with an initial blank line
+    test.on ('complete', root, x => {
+      if (x.details.passed) console.log (GREEN,' ✔', RESET+PASS, x.name)
+      else console.log (BRIGHT+RED,' X', RESET+RED, x.name, RESET)
+    })
+  }
+
+
+  /**
+   * Adds handlers to report test results in detail,
+   * i.e., on nested tests level.
+   */
+  function verbose() {
+
+    // report tests on file level
+    let i=0
+    if (files.length > 1 || files[0] !== process.argv[2] && files[0] !== process.argv[3]) // if not only one completely specified test file
+      test.on ('dequeue', x => x.name === '<next>' && console.log (LF+GRAY+'—'.repeat(77)+BRIGHT, LF+ files[i++], RESET))
+
+    // report test suites (i.e, describe/suite/test with subtests)
+    let _recent = null, _recent_nesting = 0 // to add newlines before outer leaf tests following a suite
+    test.on ('start', any, x => {
+      if (_recent) {
+        console.log(LF+_indent4(_recent), '', _recent.name)
+        _recent_nesting = x.nesting
+      }
+      _recent = x
+    })
+
+    // report passed tests on leaf level
+    test.on ('pass', leaf, x => {
+      if (_recent_nesting > x.nesting && leaf(x)) console.log()
+      x.skip ? console.log(_indent4(x), YELLOW, '○' + SKIP, x.name, RESET) :
+      x.todo ? console.log(_indent4(x), YELLOW, '+' + SKIP, x.name, RESET) :
+      /*pass*/ console.log(_indent4(x), GREEN,  '✔' + PASS, x.name, RESET)
+      _recent_nesting = _recent?.nesting
+      _recent = null
+    })
+
+    // report failed tests on leaf level
+    test.on ('fail', leaf, x => {
+      if (_recent_nesting > x.nesting && leaf(x)) console.log()
+      console.log(_indent4(x), BOLD+RED, 'X' + RESET+FAIL, x.name, RESET)
+      _recent_nesting = _recent?.nesting
+      _recent = null
+    })
+  }
+
+
+  /**
+   * Adds handlers to pipe stdout and stderr of the tests themselves
+   * or the app servers started in there.
+   */
+  function unmute() {
+    test.on ('stdout', x => process.stdout.write(x.message))
+    test.on ('stderr', x => process.stderr.write(x.message))
+  }
+
+
+  /**
+   * Adds handlers to debug test stream events.
+   */
+  function debug (events) {
+    inspect.defaultOptions.depth = 11
+    if (events === 'all') events = 'enqueue,dequeue,start,pass,fail,complete,error'
+    for (let eve of events.split(',')) test.on (eve, x => {
+      if (x.details) x.details = { ...x.details }
+      // delete x.testNumber
+      // delete x.details
+      // delete x.file
+      // delete x.line
+      // delete x.column
+      console.log(INVERT + YELLOW, eve, RESET, { ...x })
+    })
+  }
+
+
+  /**
+   * Prints the summary of passed, skipped, failed tests.
+   */
+  function summary () {
+    const time = (performance.now() / 1000).toFixed(3)
+    console.log(
+      report ('passed', BOLD+GREEN) +
+      report ('failed', BOLD+RED) +
+      report ('skipped', YELLOW) +
+      report ('todo', YELLOW) +
+      `\n${PASS} ${time}s ${RESET}\n`
+    )
+    function report (kind, color) {
+      const t = tests[kind], s = suites[kind]?.length || 0
+      if (t == 0) return ''
+      if (s == 0 || files.length == 1) return LF+`${color} ${t} ${kind} ${RESET}`
+      else return LF+`${color} ${t} in ${s} suite${s==1?'':'s'} ${kind} ${RESET}`
+    }
+    const _recent = require('os').userInfo().homedir + '/.cds-test-recent.json'
+    const recent = require('fs').existsSync(_recent) ? require(_recent) : {}
+    if (!o.recent && !o.passed && !o.failed) recent.options = {...o, argv:process.argv.slice(2) }
+    if (!o.failed) recent.passed = suites.passed // only update recent.passed if not called w/ --failed
+    if (!o.passed) recent.failed = suites.failed // only update recent.failed if not called w/ --passed
+    require('fs').writeFileSync(_recent, JSON.stringify(recent,null,2))
+  }
+
+}

package/lib/utils/axios.js

@@ -1,7 +1,6 @@
 const http = require('http')
 class Axios {
   get axios() {
-    // eslint-disable-next-line cds/no-missing-dependencies
     const axios = require('axios').create ({
       headers: { 'Content-Type': 'application/json' },
       httpAgent: new http.Agent({ keepAlive: false}),
@@ -44,18 +43,20 @@ const _args = (args) => {
 }
 
 const _error = (e) => {
-  Error.captureStackTrace (e,_error) //> adds the stack trace from caller code
-  if (e.errors) e = e.errors[0] // Node 20 sends AggregationErros
+  if (e.errors) e = e.errors[0] // Node 20 sends AggregationErrors
   if (e.code && e.port === 80 /* default port */) throw Object.assign (e, {
     message:  e.message + '\nIt seems that the server was not started. Make sure to call \'cds.test(...)\' or \'cds.test.run(...)\'.',
     stack: null // stack is just clutter here
   })
-  const { code, message } = e.response && e.response.data && e.response.data.error || {}
-  if (message) e.message = code && code !== 'null' ? `${code} - ${message}` : message
-  // Promote toJSON from prototype to own property to make it iterable
-  // eslint-disable-next-line no-self-assign
-  if (typeof jest !== 'undefined') e.toJSON = e.toJSON // REVISIT: what is this for?
-  throw e
+  // Create new instance of Error to overcome AxiosError's inferior and cluttered output
+  const err = new Error (e.message); err.code = e.code
+  Object.defineProperty (err, 'response', { value: e.response, enumerable:false })
+  // Add original error thrown by the service, if exists
+  const o = err.response?.data?.error ; if (!o) throw err
+  err.message = !o.code || o.code == 'null' ? o.message : `${o.code} - ${o.message}`
+  err.cause = o instanceof Error ? o : Object.assign (new Error, o)
+  // Object.defineProperty (o, 'stack', { enumerable:false }) //> allow strict equal checks against {code,message}
+  throw err
 }
 
 const _ = Axios.prototype // eslint-disable-line no-unused-vars

package/lib/utils/cds-test.js

@@ -1,29 +1,3 @@
-// Provide same global functions for jest and mocha
-;(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
-    // Adding test.each() and describe.each() to mocha
-    const { format } = require('util')
-    for (let td of [ 'test', 'describe' ]) global[td].each = function(table) {
-      return (msg,fn) => Promise.all (table.map (each => {
-        if (!Array.isArray(each))  each = [each]
-        return this (format(msg,...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.beforeAll  = global.before    = (msg,fn) => (fn||msg)()
-    global.afterAll   = global.after     = (msg,fn) => global.cds?.repl?.on('exit',fn||msg)
-    global.beforeEach = global.afterEach = ()=>{}
-  }
-})()
-
 /**
  * Instances of this class are constructed and returned by cds.test().
  */
@@ -86,7 +60,7 @@ class Test extends require('./axios') {
       const path = require('path')
       folder = isdir (path.resolve (cds.root, folder, ...paths))
       || path.join (require.resolve (folder+'/package.json').slice(0,-13), ...paths)
-    } catch(e) {
+    } catch {
       throw cds.error (`No such folder or package '${process.cwd()}' -> '${folder}'`)
     }
     // Check if cds.env was loaded before running cds.test in different folder
@@ -135,7 +109,7 @@ class Test extends require('./axios') {
   /**
    * Captures console.log output.
    */
-  log (_capture, afterEach = global.afterEach) {
+  log (_capture) {
     const {console} = global, {format} = require('util')
     const log = { output: '' }
     beforeAll(()=> global.console = { __proto__: console,
@@ -155,7 +129,19 @@ class Test extends require('./axios') {
   /**
    * Silences all console log output, e.g.: CDS_TEST_SILENT=y jest/mocha ...
    */
-  silent(){ this.log(()=>{},()=>{}); return this }
+  silent(){
+    global.console = { __proto__: console,
+      log: ()=>{},
+      info: ()=>{},
+      warn: ()=>{},
+      debug: ()=>{},
+      trace: ()=>{},
+      error: ()=>{},
+      time: ()=>{},
+      timeEnd: ()=>{},
+    }
+    return this
+  }
   /** @deprecated */ verbose(){ return this }
 
 
@@ -163,25 +149,88 @@ class Test extends require('./axios') {
    * Lazily loads and returns an instance of chai
    */
   get chai() {
-    let chai = require('chai')             // eslint-disable-line cds/no-missing-dependencies
-    chai.use (require('chai-subset'))      // eslint-disable-line cds/no-missing-dependencies
-    chai.use (require('chai-as-promised')) // eslint-disable-line cds/no-missing-dependencies
+    let chai = require('chai')
+    chai.use (require('chai-subset'))
+    chai.use (require('chai-as-promised'))
     return chai
     function 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@4 chai-as-promised chai-subset
+      npm add -D chai@4 chai-as-promised@7 chai-subset
     `)}}
   }
-  get assert() { return this.chai.assert }
+  set expect(x) { super.expect = x }
   get expect() { return this.chai.expect }
+  get assert() { return this.chai.assert }
   get should() { return this.chai.should() }
 }
 
 
 /** @type Test & ()=>Test */
-const cds_test = module.exports = Object.assign ((..._) => (new Test).run(..._), { Test })
+module.exports = exports = Object.assign ((..._) => (new Test).run(..._), { Test })
 
 // Set prototype to allow usages like cds.test.in(), cds.test.log(), ...
-Object.setPrototypeOf (cds_test, Test.prototype)
-if (process.env.CDS_TEST_SILENT) cds_test.silent()
+Object.setPrototypeOf (exports, Test.prototype)
+
+
+// Provide same global functions for jest and mocha
+;(function _support_jest_and_mocha() {
+  const _global = p => Object.getOwnPropertyDescriptor(global,p)?.value
+  const is_jest = _global('beforeAll')
+  const is_mocha = _global('before')
+  const repl = global.cds?.repl || process.env.CDS_TEST_FAKE // for crazy forks in some cds-dk and mtxs tests ;)
+  if (repl) { // it's cds repl
+
+    global.beforeAll  = global.before    = (msg,fn) => (fn||msg)()
+    global.afterAll   = global.after     = (msg,fn) => repl.on?.('exit',fn||msg)
+    global.beforeEach = global.afterEach = ()=>{}
+    global.describe   = ()=>{}
+    exports.expect = global.expect = require('../test/expect')
+
+  } else if (is_mocha) { // it's mocha
+
+    global.describe.each = global.it.each = each
+    global.beforeAll = before
+    global.afterAll = after
+    global.test = it
+    global.xtest = test.skip
+    global.xdescribe = describe.skip
+    process.env.CDS_TEST_SILENT == 'false' || exports.silent()
+
+  } 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 node --test
+
+    const { describe, suite, test, before, after, beforeEach, afterEach } = require('node:test')
+    describe.each = test.each = describe.skip.each = test.skip.each = each
+    global.describe = describe; global.xdescribe = describe.skip
+    global.test = global.it = test; global.xtest = test.skip
+    global.beforeAll = global.before = (msg,fn=msg) => {
+      if (fn.length > 0) { const f = fn; fn = (_,done)=>f(done) }
+      return before(fn) // doesn't work for some reason
+    }
+    // global.beforeAll = global.before = (msg,fn) => {
+    //   if (!fn) [msg,fn] = ['',msg]
+    //   return test('<before> '+ msg, (_,done) => fn(done))
+    // }
+    global.afterAll = global.after = (msg,fn) => after(fn||msg)
+    global.beforeEach = beforeEach
+    global.afterEach = afterEach
+    global.expect = require('../test/expect')
+    exports.expect = global.expect
+    suite ('<next>', ()=>{}) //> to signal the start of a test file
+
+  }
+
+  // required for test.each in mocha and node --test
+  function each (table) {
+    const {format} = require('util')
+    return (msg,fn) => Promise.all (table.map (each => {
+      if (!Array.isArray(each))  each = [each]
+      return this (format(msg,...each), ()=> fn(...each))
+    }))
+  }
+})()

package/lib/utils/cds-utils.js

@@ -56,7 +56,54 @@ const chimera = Object.getOwnPropertyDescriptors (class Chimera {
 exports.decodeURIComponent = s => { try { return decodeURIComponent(s) } catch { return s } }
 exports.decodeURI = s => { try { return decodeURI(s) } catch { return s } }
 
-exports.local = (file) => relative(cwd,file)
+exports.local = (file) => file && relative(cwd,file)
+
+const { prepareStackTrace, stackTraceLimit } = Error
+
+/**
+ * Use this utility to get a stack trace from the current position in the code.
+ * For example, try this in your code, or in cds repl:
+ *
+ *     cds.utils.stack(22) .forEach (each => console.log (
+ *       each.getTypeName()||'<anonymous>',
+ *       each.getMethodName()||'—',
+ *       each.getFunctionName(),
+ *       '(' + cds.utils.local (each.getFileName())
+ *        + ':' + each.getLineNumber()
+ *        + ':' + each.getColumnNumber()
+ *        + ')'
+ *     ))
+ *
+ * **WARNING:** This is an **expensive** function → handle with care!
+ * @param {number} [depth] - the number of stack frames to return (default: 11)
+ * @returns {NodeJS.CallSite[]} - an array of CallSite objects, as returned by [`Error.prepareStackTrace`](https://v8.dev/docs/stack-trace-api)
+ */
+exports.stack = (depth=11) => {
+  Error.prepareStackTrace = (_,stack) => stack
+  Error.stackTraceLimit = depth
+  const stack = (new Error).stack
+  Error.stackTraceLimit = stackTraceLimit
+  Error.prepareStackTrace = prepareStackTrace
+  return stack
+}
+
+/**
+ * Use this utility to get the location of the caller in the code.
+ * For example:
+ *
+ *     let [file,line,col] = cds.utils.location()
+ *
+ * Basically a shortcut for `cds.utils.stack(3)[2]`,
+ * with filename, line number, and column number returned in an array.
+ *
+ * **WARNING:** This is an **expensive** function → handle with care!
+ * @returns {[ filename:string, line:number, column:number ]}
+ */
+exports.location = function (){
+  const l = this.stack(3)[2]
+  return [ l.getFileName(), l.getLineNumber(), l.getColumnNumber() ]
+}
+
 
 exports.exists = function exists (x) {
   if (x) {
@@ -72,7 +119,7 @@ exports.isdir = function isdir (...args) {
     const ls = fs.lstatSync(y)
     if (ls.isDirectory()) return y
     if (ls.isSymbolicLink()) return isdir (join (dirname(y), fs.readlinkSync(y)))
-  } catch(e){/* ignore */}
+  } catch {/* ignore */}
 }
 
 // REVISIT naming: doesn't return boolean
@@ -82,7 +129,7 @@ exports.isfile = function isfile (...args) {
     const ls = fs.lstatSync(y)
     if (ls.isFile()) return y
     if (ls.isSymbolicLink()) return isfile (join (dirname(y), fs.readlinkSync(y)))
-  } catch(e){/* ignore */}
+  } catch {/* ignore */}
 }
 
 exports.stat = async function (x) {
@@ -176,7 +223,7 @@ exports.find = function find (base, patterns='*', filter=()=>true) {
           if (tail)  for (let _files of paths.map (e=>find (e,tail,filter)))  files.push (..._files)
           else  files.push (...paths)
         }
-      } catch(e) {/* ignore */}
+      } catch {/* ignore */}
     } else {
       const file = join (base, pattern)
       if (fs.existsSync(file))  files.push (file)
@@ -189,11 +236,11 @@ exports.deprecated = (fn, { kind = 'Method', old = fn.name+'()', use } = {}) =>
   const yellow = '\x1b[33m'
   const reset = '\x1b[0m'
   // use cds.log in production for custom logger
-  const log = cds.env.production ? cds.log().warn: console.log
+  const {warn} = cds.env.production ? cds.log() : console
   if(typeof fn !== 'function') {
     if (cds.env.features.deprecated === 'off') return
     [kind,old,use] = [fn.kind || 'Configuration',fn.old,fn.use]
-    log (
+    warn (
       yellow,
       '\n------------------------------------------------------------------------------',
       '\nDEPRECATED:', old, '\n',
@@ -205,7 +252,7 @@ exports.deprecated = (fn, { kind = 'Method', old = fn.name+'()', use } = {}) =>
   } else return function() {
     if (cds.env.features.deprecated !== 'off' && !fn.warned) {
       let o={}; Error.captureStackTrace(o)
-      log (
+      warn (
         yellow,
         '\n------------------------------------------------------------------------------',
         '\nDEPRECATED:', old, '\n',

package/lib/utils/check-version.js

@@ -10,10 +10,6 @@ if (given.major < required.major || given.major === required.major && given.mino
   Current v${given.version} does not satisfy this.
   \n`) || 1)
 
-if (given.major < 18) process.stderr.write (`WARNING: \n
-  Node.js v${given.major} has reached end of life. Please upgrade to v18 or higher.
-  \n`)
-
 function _major_minor (version) {
   let [ major, minor ] = version.split('.').map(x => +x)
   return { version, major, minor }

package/lib/utils/colors.js

@@ -0,0 +1,49 @@
+const none = process.stdout.isTTY && !process.env.NO_COLOR || process.env.FORCE_COLOR ? null : ''
+const colors = {
+  RESET:        none ?? '\x1b[0m',
+  BOLD:         none ?? '\x1b[1m',
+  BRIGHT:       none ?? '\x1b[1m',
+  DIMMED:       none ?? '\x1b[2m',
+  ITALIC:       none ?? '\x1b[3m',
+  UNDER:        none ?? '\x1b[4m',
+  BLINK:        none ?? '\x1b[5m',
+  FLASH:        none ?? '\x1b[6m',
+  INVERT:       none ?? '\x1b[7m',
+  BLACK:        none ?? '\x1b[30m',
+  RED:          none ?? '\x1b[31m',
+  GREEN:        none ?? '\x1b[32m',
+  YELLOW:       none ?? '\x1b[33m',
+  BLUE:         none ?? '\x1b[34m',
+  PINK:         none ?? '\x1b[35m',
+  CYAN:         none ?? '\x1b[36m',
+  LIGHT_GRAY:   none ?? '\x1b[37m',
+  DEFAULT:      none ?? '\x1b[39m',
+  GRAY:         none ?? '\x1b[90m',
+  LIGHT_RED:    none ?? '\x1b[91m',
+  LIGHT_GREEN:  none ?? '\x1b[92m',
+  LIGHT_YELLOW: none ?? '\x1b[93m',
+  LIGHT_BLUE:   none ?? '\x1b[94m',
+  LIGHT_PINK:   none ?? '\x1b[95m',
+  LIGHT_CYAN:   none ?? '\x1b[96m',
+  WHITE:        none ?? '\x1b[97m',
+  bg: {
+    BLACK: none ?? '\x1b[40m',
+    RED: none ?? '\x1b[41m',
+    GREEN: none ?? '\x1b[42m',
+    YELLOW: none ?? '\x1b[43m',
+    BLUE: none ?? '\x1b[44m',
+    PINK: none ?? '\x1b[45m',
+    CYAN: none ?? '\x1b[46m',
+    WHITE: none ?? '\x1b[47m',
+    DEFAULT: none ?? '\x1b[49m',
+    LIGHT_GRAY: none ?? '\x1b[100m',
+    LIGHT_RED: none ?? '\x1b[101m',
+    LIGHT_GREEN: none ?? '\x1b[102m',
+    LIGHT_YELLOW: none ?? '\x1b[103m',
+    LIGHT_BLUE: none ?? '\x1b[104m',
+    LIGHT_PINK: none ?? '\x1b[105m',
+    LIGHT_CYAN: none ?? '\x1b[106m',
+    LIGHT_WHITE: none ?? '\x1b[107m',
+  },
+}
+module.exports = colors

package/lib/utils/data.js

@@ -4,9 +4,10 @@ class DataUtil {
 
   constructor() {
     // This is to support simplified usage like that: beforeEach(test.data.reset)
-    this.reset = (fn) => {
-      if (typeof fn === 'function') this.__proto__.reset().then(fn)
-      else return this.__proto__.reset(fn)
+    const {reset} = this; this.reset = (x) => {
+      if (typeof x === 'function') reset.call(this).then(x) // x is the done callback of jest -> no return
+      else if (x?.assert) return reset.call(this) // x is a node --test TestContext object -> ignore
+      else return reset.call(this,x) // x is a db service instance
     }
   }
 
@@ -39,7 +40,7 @@ class DataUtil {
 
   /* delete + new deploy from csv */
   async reset(db) {
-    if (!db)  db = await cds.connect.to('db')
+    if (!db) db = await cds.connect.to('db')
     await this.delete(db)
     await this.deploy(db)
   }

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

@@ -29,7 +29,6 @@ const _action = require('./handlers/action')
 const { normalizeError, isClientError } = require('../../../common/error/frontend')
 const { getErrorMessage } = require('../../../common/error/utils')
 
-// eslint-disable-next-line complexity
 function _log(level, arg) {
   const { params } = arg
 
@@ -169,12 +168,8 @@ class OData {
 
       // start tx
       const txs = (data.txs = data.txs || {})
-      const {
-        req: { user },
-        req,
-        res
-      } = data
-      const tx = (txs[odataContext.id] = cdsService.tx({ user, req, res }))
+      const { req, res } = data
+      const tx = (txs[odataContext.id] = cdsService.tx({ req, res }))
       cds.context = tx.context
       // for collecting results and errors
       data.results = data.results || {}

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

@@ -1,4 +1,3 @@
-/* eslint-disable complexity */
 const cds = require('../../../cds')
 
 const {
@@ -17,15 +16,6 @@ const { isCustomOperation } = require('./utils/request')
 const { isStreaming } = require('./utils/stream')
 const { handleStreamProperties } = require('../../../common/utils/streamProp')
 
-// getter functions extracted to show deprecation warning only once
-const _getAttr = attr => attr
-const _getShared = (oReq, req, res) => {
-  if (oReq.context) oReq._shared = oReq.context._shared = oReq.context._shared || { req, res }
-  else oReq._shared = oReq._shared || { req, res }
-
-  return oReq._shared
-}
-
 function _isCorrectCallToViewWithParams(csdlStructuredType) {
   return (
     csdlStructuredType.navigationProperties &&
@@ -116,8 +106,7 @@ class ODataRequest extends cds.Request {
       const headers = Object.assign({}, req.headers, odataReq.getHeaders())
       // REVISIT needed in case of $batch, replace after removing okra
       const method = odataReq.getIncomingRequest().method
-      const { user } = req
-      const tenant = req.tenant || user?.tenant
+      const { user, tenant } = cds.context
       const info = metaInfo(query, type, service, data, req, upsert)
       const { event, unbound } = info
       if (event === 'READ') {
@@ -196,8 +185,7 @@ class ODataRequest extends cds.Request {
       /*
        * super
        */
-      const { user } = req
-      const tenant = req.tenant || user?.tenant
+      const { user, tenant } = cds.context
       // REVISIT: public API for query options (express style req.query already in use)?
       const _queryOptions = odataReq.getQueryOptions()
       super({ event, target, data, query, user, method, headers, req, res, _queryOptions, tenant })
@@ -220,23 +208,8 @@ class ODataRequest extends cds.Request {
     // odataReq and odataRes
     this._.odataReq = odataReq
     this._.odataRes = odataRes
-    // req._.shared
-    const that = this
-    Object.defineProperty(this._, 'shared', {
-      get() {
-        return cds.utils.deprecated(_getShared, { kind: 'Property', old: 'req._.shared' })(that, req, res)
-      }
-    })
-
-    // req.attr
-    const attr = { identityZone: this.tenant }
-    Object.defineProperty(this, 'attr', {
-      get() {
-        return cds.utils.deprecated(_getAttr, { kind: 'Property', old: 'req.attr' })(attr)
-      }
-    })
 
-    Object.defineProperty(this, 'protocol', { value: 'odata-v4' })
+    Object.defineProperty(this, 'protocol', { value: 'odata' })
   }
 }