@sap/cds 7.2.0 → 7.3.0

package/lib/utils/cds-test.js

@@ -1,47 +1,71 @@
-const { is_mocha, is_jest } = support_jest_and_mocha()
+// 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().
+ */
 class Test extends require('./axios') {
 
+  /**
+   * Allows: const { GET, expect, test } = cds.test()
+   */
+  test = this
+
+  get cds() { return require('../index') }
+  get sleep() { return super.sleep = require('util').promisify(setTimeout) }
+  get data() { return super.data = new (require('./data'))}
+
   /**
    * 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) {
-
-    const {cds} = this; this.cmd = cmd, this.args = args
-    if (!/^(serve|run)$/.test(cmd)) {
-      try {
-        const project = cds.utils.isdir(cmd) || require.resolve (cmd+'/package.json').slice(0,-13)
-        this.cmd = cmd = 'serve'; args.push ('--in-memory?')
-        this.in (project)
-      } catch(e) {
-        throw cds.error (`No such folder or package '${process.cwd()}' -> '${cmd}'`)
-      }
-    } else if ('run' === cmd && args.length > 0) { // `run <project>` -> `serve --project <project>`
-      if (!args.includes('--project')) args.unshift('--project')
+  run (folder_or_cmd, ...args) {
+
+    switch (folder_or_cmd) {
+      case 'serve': break // nothing to do as all arguments are given
+      case 'run': if (args.length > 0) args.unshift('--project'); break
+      default: this.in(folder_or_cmd); args.push('--in-memory?')
     }
+    const {cds} = this
 
     // launch cds server...
-    before (`launching ${cmd} ${args.join(' ')}...`, async () => {
-      // cds.plugins is filling cds.env before cds serve -> profile must be parsed here
-      const profile = args.indexOf('--profile')
-      if (profile !== -1) process.env.CDS_ENV = [...process.env.CDS_ENV?.split(',') ?? [], ...args[profile+1].split(',')]
-      await cds.plugins
-      cds.once ('listening', ({server,url}) => {
-        const axp = Reflect.getOwnPropertyDescriptor(this,'axios')
-        if (axp) axp.value.defaults.baseURL = url
-        this.server = server
-        this.url = url
-      })
-      try { return cds.exec (...args, ...(args.includes('--port') ? [] : ['--port', '0'])) }
-      catch (e) { if (is_mocha) console.error(e) } // eslint-disable-line no-console
+    before (async ()=>{
+      if (!args.includes('--port')) args.push('--port', '0')
+      let { server, url } = await cds.exec(...args)
+      this.server = server
+      this.url = url
     })
 
     // gracefully shutdown cds server...
-    after (() => this.server && cds.shutdown())
-
-    beforeEach (async () => {
-      if (this.data._autoReset)  await this.data.reset()
+    after (()=>{
+      this.server && cds.shutdown()
+      // cds.service.providers = []
+      // delete cds.services
+      // delete cds.plugins
+      // delete cds.env
     })
 
     return this
@@ -52,127 +76,110 @@ class Test extends require('./axios') {
    * 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 = require('path').resolve (cds.root, ...paths)
-    // const env = Reflect.getOwnPropertyDescriptor(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}
-
-    //   > throwing this as tests would likely behave erratically.
-    //   `)
-    // }
+  in (folder, ...paths) {
+    if (!folder) return this
+    const {cds} = this, { isdir, local } = cds.utils
+    // try to resolve folder relative to cds.root, or as a node module
+    try {
+      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) {
+      throw cds.error (`No such folder or package '${process.cwd()}' -> '${folder}'`)
+    }
+    // Check if cds.env was loaded before running cds.test in different folder
+    if (process.env.CDS_TEST_ENV_CHECK) {
+      const env = Reflect.getOwnPropertyDescriptor(cds,'env')?.value
+      if (env && env._home !== folder && env.stack) {
+        let filter = line => !line.match(/node_modules\/jest-|node:internal/)
+        let err = new Error; err.message =
+          `Detected cds.env loaded before running cds.test in different folder: \n` +
+          `1. cds.env loaded from:  ${local(cds.env._home)||'./'} \n` +
+          `2. cds.test running in:  ${local(folder)} \n\n` +
+          err.stack.split('\n').filter(filter).slice(1).join('\n')
+        err.stack = env.stack.split('\n').filter(filter).slice(1).join('\n')
+        throw err
+      }
+    }
+    cds.root = folder
     return this
   }
 
   /**
-   * Switch on/off console log output.
+   * Method to spy on a function in an object, similar to jest.spyOn().
    */
-  verbose (v) {
-    initLogging({ is_mocha, is_jest, verbose: v })
-    return this
+  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
   }
 
-  /**  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 }
-
-  then(r) {
-    const {cds} = this
+  /**
+   * For usage in repl, e.g. var test = await cds.test()
+   */
+  then (resolve) {
     if (this.server) {
-      r({ server: this.server, url: this.url })
+      resolve({ server: this.server, url: this.url })
     } else {
-      cds.once('listening', r)
+      this.cds.once('listening', resolve)
     }
   }
-}
 
-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] // REVISIT: Whay are we doing that?
+  /**
+   * Captures console.log output.
+   */
+  log (_capture, afterEach = global.afterEach) {
+    const {console} = global, {format} = require('util')
+    const log = { output: '' }
+    beforeAll(()=> global.console = { __proto__: console,
+      log: _capture ??= (..._)=> log.output += format(..._)+'\n',
+      info: _capture,
+      warn: _capture,
+      debug: _capture,
+      trace: _capture,
+      error: _capture,
+      timeEnd: _capture, time: ()=>{},
     })
-  } 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)
-    }
+    afterAll (log.release = ()=>{ log.output = ''; global.console = console })
+    afterEach (log.clear = ()=>{ log.output = '' })
+    return log
   }
-  initLogging ({ is_jest, is_mocha })
-  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')           // 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
-  return chai
-}
+  /**
+   * Silences all console log output, e.g.: CDS_TEST_SILENT=y jest/mocha ...
+   */
+  silent(){ this.log(()=>{},()=>{}); return this }
+  /** @deprecated */ verbose(){ return this }
 
-function initLogging ({ verbose }={}) {
-  if (verbose && global.console.logs) return global.console = global.console.__proto__
-  if (process.env.CDS_TEST_SILENT) {
-    const console = global.console, logs = []
-    const {format} = require('util')
-    global.console = { __proto__: console, logs,
-      time: ()=>{}, timeEnd: (...args)=> logs.push(args),
-      debug: (...args)=> logs.push(args),
-      info: (...args)=> logs.push(args),
-      log: (...args)=> logs.push(args),
-      warn: (...args)=> logs.push(args),
-      trace: (...args)=> logs.push(args),
-      error: (...args)=> logs.push(args),
-      dump(){ for (let each of logs) process.stdout.write (format(...each)+'\n') },
-    }
-    afterAll (()=> global.console = console)
-  }
-}
 
-const spy = (o,f) => {
-  const origin = o[f]
-  const fn = function (...args) {
-    ++fn.called
-    return origin.apply(this,args)
+  /**
+   * 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
+    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 chai-as-promised chai-subset
+    `)}}
   }
-  fn.called = 0
-  fn.restore = ()=> o[f] = origin
-  return o[f] = fn
+  get assert() { return this.chai.assert }
+  get expect() { return this.chai.expect }
+  get should() { return this.chai.should() }
 }
 
 
 /** @type Test & ()=>Test */
-module.exports = Object.assign (
-  Object.setPrototypeOf ((..._) => (new Test).run(..._), Test.prototype),
-  { Test }
-)
+const cds_test = module.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()

package/lib/utils/cds-utils.js

@@ -4,7 +4,7 @@ const cds = require('../index')
 const ux = module.exports = exports = new class {
   get inflect() { return super.inflect = require('./inflect') }
   get inspect() { return super.inspect = require('util').inspect }
-  get uuid() { return super.uuid = require('@sap/cds-foss').uuid }
+  get uuid() { return super.uuid = require('crypto').randomUUID }
   get yaml() { return super.yaml = require('@sap/cds-foss').yaml }
   get pool() { return super.pool = require('@sap/cds-foss').pool }
   get tar() { return super.tar = require('./tar') }

package/lib/utils/check-version.js

@@ -15,3 +15,9 @@ 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.
+  `)
+}

package/lib/utils/data.js

@@ -2,19 +2,34 @@ const cds = require('../index')
 
 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)
+    }
+  }
+
+  autoReset() {
+    global.beforeEach (() => this.reset())
+  }
+
+  async deploy(db) {
+    if (!db)  db = await cds.connect.to('db')
+    await cds.deploy.init(db)
+  }
+
   async delete(db) {
     if (!db)  db = await cds.connect.to('db')
     if (!this._deletes) {
       this._deletes = []
       for (const entity of db.model.each('entity')) {
         if (!entity.query && entity['@cds.persistence.skip'] !== true) {
-          this._deletes.push(cds.ql.DELETE.from(entity))
+          this._deletes.push(DELETE.from(entity))
         }
       }
     }
     if (this._deletes.length > 0) {
-      const LOG = cds.log('deploy')
-      if (!this._autoReset)  LOG.info('Deleting all data for', db.model.each('entity'))
       await db.run(this._deletes)
     }
   }
@@ -23,11 +38,9 @@ class DataUtil {
   async reset(db) {
     if (!db)  db = await cds.connect.to('db')
     await this.delete(db)
-    await cds.deploy.init(db)
+    await this.deploy(db)
   }
 
-  autoReset(enabled) { this._autoReset = enabled; return this }
-
 }
 
 module.exports = DataUtil

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

@@ -225,29 +225,30 @@ class OData {
    */
   // REVISIT: Remove this when we replaced Okra
   process(req, res) {
-    const headers = req.headers
-    const acceptHeader = headers && headers.accept
-
-    // default to combination [...];IEEE754Compatible=true;ExponentialDecimals=true if one is omitted
-    if (acceptHeader && acceptHeader.startsWith('application/json')) {
-      if (acceptHeader.includes('IEEE754Compatible=true') && !acceptHeader.includes('ExponentialDecimals')) {
-        req.headers.accept += ';ExponentialDecimals=true'
-      } else if (acceptHeader.includes('ExponentialDecimals=true') && !acceptHeader.includes('IEEE754Compatible')) {
+    // NOTE: do none of this header manipulation in okra successor!
+    // if ExponentialDecimals=true is set in accept header, ensure IEEE754Compatible=true (use case unclear, but don't introduce regression)
+    // if IEEE754Compatible=true is set in accept header, but ExponentialDecimals is not specified, set it based on cds.env.odata.defaultExponentialDecimals
+    const acceptHeader = req.headers.accept
+    if (acceptHeader?.startsWith('application/json')) {
+      if (acceptHeader.includes('ExponentialDecimals=true') && !acceptHeader.includes('IEEE754Compatible')) {
         req.headers.accept += ';IEEE754Compatible=true'
-      }
-
-      const contentType = headers['content-type']
-
-      // add IEEE754Compatible=true if !strict_numbers
-      if (
-        !cds.env.features.strict_numbers &&
-        contentType &&
-        contentType.includes('application/json') &&
-        !contentType.includes('IEEE754Compatible')
+      } else if (
+        'defaultExponentialDecimals' in cds.env.odata &&
+        acceptHeader.includes('IEEE754Compatible=true') &&
+        !acceptHeader.includes('ExponentialDecimals')
       ) {
-        req.headers['content-type'] = contentType.replace('application/json', 'application/json;IEEE754Compatible=true')
+        req.headers.accept += `;ExponentialDecimals=${cds.env.odata.defaultExponentialDecimals}`
       }
     }
+    // add IEEE754Compatible=true if !strict_numbers
+    const contentType = req.headers['content-type']
+    if (
+      !cds.env.features.strict_numbers &&
+      contentType?.includes('application/json') &&
+      !contentType.includes('IEEE754Compatible')
+    ) {
+      req.headers['content-type'] = contentType.replace('application/json', 'application/json;IEEE754Compatible=true')
+    }
 
     // this._startPerfMeasurementOData(req)
     this._odataService.process(req, res).catch(err => {

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

@@ -12,6 +12,7 @@ const { validateResourcePath } = require('../utils/request')
 const { toODataResult, postProcess } = require('../utils/result')
 const { DRAFT_EVENTS } = require('../../../../common/constants/events')
 const { readAfterWrite } = require('../utils/readAfterWrite')
+const { toBase64url } = require('../../../../common/utils/binary')
 
 const _postProcess = async (req, odataReq, odataRes, tx, result) => {
   const returnType = getActionOrFunctionReturnType(odataReq.getUriInfo().getPathSegments(), tx.model.definitions)
@@ -65,7 +66,15 @@ const action = service => {
         const keys = Object.keys(req.target.keys).filter(k => {
           return k !== 'IsActiveEntity' && !req.target.keys[k]._isAssociationStrict
         })
-        const keysString = keys.map(key => `${key}=${result[key]}`).join(',')
+        const keysString = keys
+          .map(key => {
+            let val = result[key]
+            if (Buffer.isBuffer(val)) {
+              val = toBase64url(result[key])
+            }
+            return `${key}=${val}`
+          })
+          .join(',')
         odataRes.setHeader(
           'location',
           `../${req.target.name.replace(`${service.name}.`, '')}(${keysString},IsActiveEntity=${

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

@@ -123,7 +123,7 @@ const getErrorHandler = (crashOnError = true, srv) => {
         // lost cds.context -> as we fixed that we don't get into this if branch anymore,
         // but then the ctx in the else branch below isn't the ODataRequest anymore
         // > error before req was dispatched
-        const creq = new cds.Request({ req, res: req.res, user: req.user || new cds.User.Anonymous() })
+        const creq = new cds.Request({ req, res: req.res, user: req.user || new cds.User.default() })
         for (const each of srv._handlers._error) each.handler.call(srv, err, creq)
       } else if (ctx._tx?._done !== 'rolled back') {
         // > error after req was dispatched, e.g., serialization error in okra

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

@@ -13,9 +13,8 @@ module.exports = srv => {
       ? odataReq.getBatchApplicationData().req
       : odataReq.getIncomingRequest()
 
-    // REVISIT: ensure there always is a user (should be the case with new middlewares -> remove with old middlewares)
-    // prettier-ignore
-    if (!req.user) req.user = new cds.User.default
+    // ensure there always is a user going forward (not always the case with old or custom auth)
+    if (!req.user) req.user = new cds.User.default()
 
     const { res, user, path, headers } = req
 

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-commons/utils/ValueConverter.js

@@ -346,20 +346,6 @@ class ValueConverter {
       return this._formatParams.getExponentialDecimalsSetting() ? bigValue.toExponential() : bigValue.toFixed()
     }
 
-    // If scale is not specified or is 0 then the value must be serialized as an integer.
-    if (scale === null || scale === undefined || scale === 0) {
-      // The value has to be a safe integer in javascript, to prevent rounding problems.
-      if (bigValue.lt(Number.MIN_SAFE_INTEGER) || bigValue.gt(Number.MAX_SAFE_INTEGER)) {
-        throw new IllegalArgumentError(
-          `The Edm.Decimal value ${value} cannot be correctly serialized as an ` +
-            'integer. IEEE754Compatible=true format parameter can be specified to serialize the ' +
-            'value as a string'
-        )
-      }
-
-      return Number.parseInt(bigValue.toFixed(0), 10)
-    }
-
     const absBigValue = bigValue.abs()
     // Because the value must be serialized as a number,
     // check whether the value can be correctly represented as a number in javascript.

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/core/OdataRequest.js

@@ -283,6 +283,7 @@ class OdataRequest {
    * @throws {PreconditionFailedError} if the validations failed
    */
   validateEtag (etag) {
+    throw new Error("etag validation not supported via okra")
     this._logger.debug('Provided etag:', etag)
 
     this._validateEtagHasBeenCalled = true

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/deserializer/BatchRequestListBuilder.js

@@ -8,6 +8,8 @@ const OdataRequestInBatch = require('../core/OdataRequestInBatch')
 const PlainHttpRequest = require('../core/PlainHttpRequest')
 const DeserializationError = require('../errors/DeserializationError')
 
+const { AsyncResource } = require('node:async_hooks')
+
 /**
  * Create a list of OdataRequestInBatch from an incoming batch request.
  */
@@ -86,13 +88,14 @@ class BatchRequestListBuilder {
     // create reader and start with ContentReader
     const reader = new ContentReader(parser, this._emitter)
 
+    // restore lost context via AsyncResource.bind()
     source
       .pipe(reader)
-      .on('finish', () => {
+      .on('finish', AsyncResource.bind(() => {
         //Revisit: if statement needed in node v12 and v14, not in v16.
         //Without it, finish callback reached in 12/14 after error handler was thrown
         if (!source.res || !source.res.headersSent) callback(null, this._requestInBatchList)
-      })
+      }))
       .on('error', callback)
   }
 

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/handler/MetadataHandler.js

@@ -12,7 +12,7 @@ class MetadataHandler {
    */
   static read (request, response, next) {
     const metadataETag = request.getService().getMetadataEtag()
-    if (metadataETag) request.validateEtag(metadataETag)
+    // if (metadataETag) request.validateEtag(metadataETag)
 
     next(null, { [MetaProperties.ETAG]: metadataETag })
   }

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/handler/ServiceHandler.js

@@ -16,7 +16,7 @@ class ServiceHandler {
    */
   static read (request, response, next) {
     const metadataETag = request.getService().getMetadataEtag()
-    if (metadataETag) request.validateEtag(metadataETag)
+    // if (metadataETag) request.validateEtag(metadataETag)
     next(null, { [MetaProperties.ETAG]: metadataETag })
     // TODO this method may be replaced by a custom service handler, so we need a scenario test that ensures that this method is called...
   }

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/invocation/DispatcherCommand.js

@@ -56,7 +56,7 @@ class DispatcherCommand extends Command {
 
     if (cachedMetadata) {
       this._response.setBody({ value: cachedMetadata.metadata, [MetaProperties.ETAG]: cachedMetadata.etag })
-      this._request.validateEtag(cachedMetadata.etag)
+      // this._request.validateEtag(cachedMetadata.etag)
       next()
     } else {
       this._dispatcher
@@ -79,7 +79,7 @@ class DispatcherCommand extends Command {
                 'Metadata size exceeds cache boundary. Use cds option odata.metadataCacheLimit to increase the cache size.'
               )
             }
-            this._request.validateEtag(metadataEtag)
+            // this._request.validateEtag(metadataEtag)
             let data = result.data
             data[MetaProperties.ETAG] = metadataEtag
           }

package/libx/_runtime/cds-services/adapter/odata-v4/okra/odata-server/utils/BufferedWriter.js

@@ -24,9 +24,7 @@ class BufferedWriter extends Transform {
       }
     })
 
-    // REVISIT: AsyncResource.bind()
-    // We AsyncResource.bind() here (also for non middleware case!) to ensure subsequent handlers have access to cds.context -> this test would break if not, and there's an async handler before ours in the route: cds/tests/_runtime/odata/__tests__/integration/crud-with-mtx.test.js
-    // Yet, if we do so this test breaks because the implementation of srv.on('error') is pretty screwed: cds/tests/runtime/req.test.js
+    // restore lost context via AsyncResource.bind()
     this.on('finish', AsyncResource.bind(() => {
       /**
        * Result event to emit the result data.

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

@@ -58,7 +58,7 @@ const _columnsFromQuery = (columns, target, options) => {
   // must use query.columns as it includes columns from $apply except of $apply=expand()
   // must use query options to get nested $selects inside $expand() as they are mixed into query columns
   // example: GET /Foo?$select=bar&$expand=bar => @odata.context: $metadata#Foo(bar,bar())
-  // REVISIT tbd if having expand column in $select could be integrated into query in grammar.pegjs
+  // REVISIT tbd if having expand column in $select could be integrated into query in grammar.peggy
   // REVISIT support $apply=expand()
   if (_ignoreColumns(columns, options)) return ''
   const context = []

package/libx/_runtime/common/composition/update.js

@@ -1,3 +1,5 @@
+const parentDataSymbol = Symbol('parentData')
+const cqnSymbol = Symbol('cqn')
 const cds = require('../../cds')
 const { getCompositionTree } = require('./tree')
 const { getDeepInsertCQNs } = require('./insert')
@@ -138,7 +140,13 @@ function _addSubDeepUpdateCQNForUpdateInsert({ entity, entityName, data, selectD
       const oldData = ctUtils.cleanDeepData(entity, selectEntry)
       const diff = _diffData(newData, oldData, entity, entry, selectEntry, model)
       // empty updates will be removed later
-      updateCQNs.push({ UPDATE: { entity: entityName, data: diff, where: ctUtils.whereKey(key) } })
+      updateCQNs.push({
+        UPDATE: { entity: entityName, data: Object.assign({}, key, diff), where: ctUtils.whereKey(key) },
+        // We take tree information from data and store
+        // it in the `updateCQN` array (which itself is just a flat list)
+        parent: entry[parentDataSymbol]?.[cqnSymbol]
+      })
+      entry[cqnSymbol] = updateCQNs[updateCQNs.length - 1]
     } else {
       insertCQN.INSERT.entries.push(entry)
       // inserts are handled deep so they must not be put into deepUpdateData
@@ -189,7 +197,15 @@ const _addToData = (subData, entity, element, entry) => {
   const value = ctUtils.val(entry[element.name])
   const subDataEntries = ctUtils.array(value)
   const unwrappedSubData = subDataEntries.map(entry => _unwrapIfNotArray(entry))
-  for (const val of unwrappedSubData) subData.push(val)
+  for (const val of unwrappedSubData) {
+    if (val != null) {
+      // We need to conserve the tree information which gets
+      // lost because we're creating flat arrays of layers.
+      Object.defineProperty(val, parentDataSymbol, { value: entry })
+    }
+
+    subData.push(val)
+  }
 }
 
 async function _addSubDeepUpdateCQNRecursion({ model, compositionTree, entity, data, selectData, cqns, draft, req }) {