@sap/cds 9.5.2 → 9.6.1

package/CHANGELOG.md

@@ -4,6 +4,51 @@
 - The format is based on [Keep a Changelog](https://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](https://semver.org/).
 
+## Version 9.6.1 - 2025-12-18
+
+### Fixed
+
+- Status check in case of non-existing subject
+- Gracefully handle bad value when calculating `@Core.OperationAvailable` from `@from`
+
+## Version 9.6.0 - 2025-12-16
+
+### Added
+
+- New config entry `cds.folders.apps = 'app/*'` to fetch and load all .cds files from subfolders of `./app` automatically. This eliminates the need for an `./app/index.cds` file with respective `using` directives. Can be disabled by setting `cds.folders.apps` to `false`.
+- Support for direct CRUD on draft-enabled entities (beta)
+  + Enable via `cds.fiori.direct_crud` (replacing `cds.features.new_draft_via_action`)
+  + In such requests, `IsActiveEntity` is defaulted to `true`
+- Columns `task` and `appid` to `cds.outbox.Messages`
+- `cds.env` getter for `appid`
+
+### Changed
+
+- Improved Event Queue Processing
+  + For db-only message processors, the guarantee is now "exactly once" instead of "at least once".
+  + Use default target `queue` unless specified (formerly it was the name of the service). In effect, all services with the default queue config are processed together.
+- Cleaned-up Model Reflection APIs
+  + `cds.entities` and `model.entities` provide access to all entities, not just the ones matching the first sources' namespace
+    + Function usage `cds.entities()` without passing a namespace no longer offers unqualified access to the entities of the first sources' namespace
+  + `srv.entities` returns `LinkedDefinitions` for that service
+  + Undocumented function usages `srv.entities()`, `srv.types()`, `srv.events()`, and `srv.actions()` are officially deprecated and will be removed with `cds^10`.
+    + For `srv.entities()`, use `cds.entities()` instead. The others have no replacement. Simply use `srv.types`, `srv.events`, and `srv.actions`.
+  + All `.entities` variants only provide `.texts` entities if `cds.features.compat_texts_entities = true` (default until `cds^10`). Use `.texts` property of the respective entity instead (i.e., `CatalogService.Books.texts` instead of `CatalogService['Books.texts']`).
+
+### Fixed
+
+- Actions rejected with `415` for requests with empty body
+- `cds.parse.expr` with template literals using "param" as parameter name
+- Kafka messaging won't listen for messages without registered on handlers
+- Single quote escaping in remote OData requests
+- Lambda prefix within function calls in remote OData requests
+- Hierarchy requests with `$top` in combination with `$filter`
+- Response format of `ASSERT_DATA_TYPE` errors with draft messages
+- Deletion of `@assert` draft messages on SAVE
+- Check for `process.env.VCAP_SERVICES_FILE_PATH` in logging aspects enterprise messaging tasks
+- Remove control data from deserialized task
+- Hierarchy draft requests with $filter
+
 ## Version 9.5.2 - 2025-12-09
 
 ### Fixed
@@ -44,7 +89,6 @@
 - Support for pseudo protocols
 - Support for Async UCL tenant mapping notification flow
 - `flush` on a queued service returns a Promise that resolves when immediate work (i.e., not scheduled for future) is processed
-- For draft-enabled entities, IsActiveEntity=true can be omitted from url
 - Support for `@Common.DraftRoot.NewAction` annotation with feature flag `cds.features.new_draft_via_action`
   + Generic collection bound action `draftNew` will be added to draft enabled entities
   + The action specified in the annotation will be rewritten into a draft `NEW` event
@@ -74,6 +118,7 @@
 - Read-after-write for create events during draft choreography will no longer include messages targeting siblings
 - `before` and `after` handlers now really run in parallel. If that causes trouble, you can restore the previous behavior with `cds.features.async_handler_compat=true` until `@sap/cds@10`.
 - Escaping of JSON escape sequences during localization
+- Persisted draft messages in case of on-commit errors
 
 ## Version 9.4.5 - 2025-11-07
 

package/bin/args.js

@@ -17,12 +17,12 @@ module.exports = function _args4 (task, argv) {
   }
   // consistent production setting for NODE_ENV and CDS_ENV
   if (process.env.NODE_ENV !== 'production') { if (process.env.CDS_ENV?.split(',').includes('production')) process.env.NODE_ENV = 'production' }
-  else process.env.CDS_ENV = Array.from(new Set([...process.env.CDS_ENV?.split(',') ?? [], 'production']))
+  else process.env.CDS_ENV = Array.from(new Set([...process.env.CDS_ENV?.split(',') ?? [], 'production'])).join(',')
 
   function add (k,v) { options[k.slice(2)] = v || true }
   function add_global (k,v='') {
-    if (k === '--production') return process.env.CDS_ENV = Array.from(new Set([...process.env.CDS_ENV?.split(',') ?? [], 'production']))
-    if (k === '--profile')    return process.env.CDS_ENV = Array.from(new Set([...process.env.CDS_ENV?.split(',') ?? [], ...v.split(',')]))
+    if (k === '--production') return process.env.CDS_ENV = Array.from(new Set([...process.env.CDS_ENV?.split(',') ?? [], 'production'])).join(',')
+    if (k === '--profile')    return process.env.CDS_ENV = Array.from(new Set([...process.env.CDS_ENV?.split(',') ?? [], ...v.split(',')])).join(',')
     if (k === '--odata') v = { flavor:v }
     let e=env || (env={}), path = k.slice(2).split('-')
     while (path.length > 1) { let p = path.shift(); e = e[p]||(e[p]={}) }

package/bin/serve.js

@@ -1,17 +1,21 @@
 #!/usr/bin/env node
-module.exports = exports = Object.assign ( serve, {
-    options: [
-        '--service', '--from', '--to', '--at', '--with',
-        '--port', '--workers',
-    ],
-    flags: [
-        '--project', '--projects',
-        '--in-memory', '--in-memory?',
-        '--mocked', '--with-mocks', '--with-bindings', '--resolve-bindings',
-        '--watch', '--with-mtx',
-    ],
-    shortcuts: [ '-s', undefined, '-2', '-a', '-w', undefined, undefined, '-p' ],
-    help: `
+module.exports = exports = serve
+
+exports.options = [
+  '--service', '--from', '--to', '--at', '--with',
+  '--port', '--workers',
+]
+
+exports.flags = [
+  '--project', '--projects',
+  '--in-memory', '--in-memory?',
+  '--mocked', '--with-mocks', '--with-bindings', '--resolve-bindings',
+  '--watch', '--with-mtx',
+]
+
+exports.shortcuts = [ '-s', undefined, '-2', '-a', '-w', undefined, undefined, '-p' ]
+
+exports.help = `
 # SYNOPSIS
 
     *cds serve* [ <filenames> ] [ <options> ]
@@ -136,7 +140,7 @@ module.exports = exports = Object.assign ( serve, {
     *cds watch* some/project
     *cds watch*
 
-`})
+`
 
 
 const cds = require('../lib'), { exists, isfile, local, redacted, path } = cds.utils

package/lib/compile/for/flows.js

@@ -13,12 +13,18 @@ const getFrom = action => {
 }
 
 function addOperationAvailableToActions(actions, statusEnum, statusElementName) {
-  for (const action of Object.values(actions)) {
+  action: for (const action of Object.values(actions)) {
     const fromList = getFrom(action)
-    const conditions = fromList.map(from => {
+    const conditions = []
+    for (const from of fromList) {
       const value = from['#'] ? statusEnum[from['#']]?.val ?? from['#'] : from
-      return `$self.${statusElementName} = ${typeof value === 'string' ? `'${value}'` : value}`
-    })
+      if (typeof value !== 'string') {
+        const msg = `Error while constructing @Core.OperationAvailable for action "${action.name}" of "${action.parent.name}". Value of @from must either be an enum symbol or a raw string.`
+        cds.log('cds|edmx').warn(msg)
+        continue action
+      }
+      conditions.push(`$self.${statusElementName} = '${value}'`)
+    }
     const condition = `(${conditions.join(' OR ')})`
     const parsedXpr = cds.parse.expr(condition)
     action['@Core.OperationAvailable'] ??= {
@@ -74,7 +80,7 @@ function addActionsToTarget(targetAnnotation, entity, actions) {
       identification.push({
         $Type: 'UI.DataFieldForAction',
         Action: `${entity._service.name}.${actionName}`,
-        Label: action["@Common.Label"] ?? action["@title"] ?? `{i18n>${actionName}}`,
+        Label: action['@Common.Label'] ?? action['@title'] ?? `{i18n>${actionName}}`,
         ...(entity['@odata.draft.enabled'] && {
           '@UI.Hidden': {
             '=': true,

package/lib/compile/for/lean_drafts.js

@@ -264,6 +264,6 @@ module.exports = function cds_compile_for_lean_drafts(csn) {
     // will insert drafts entities, so that others can use `.drafts` even without incoming draft requests
     addDraftEntity(def, csn)
 
-    if (cds.env.fiori.draft_new_action) addNewActionAnnotation(def)
+    if (cds.env.fiori.direct_crud) addNewActionAnnotation(def)
   }
 }

package/lib/compile/for/nodejs.js

@@ -46,6 +46,8 @@ function _compile_for_nodejs (csn, o) {
 
 module.exports = function cds_compile_for_nodejs (csn,o) {
   if ('_4nodejs' in csn) return csn._4nodejs
+  // REVISIT: remove _compat_texts_entities with cds^10
+  if (cds.env.features.compat_texts_entities) Object.defineProperty(csn, '_compat_texts_entities', { value: true, enumerable: true })
   TRACE?.time('cds.compile 4nodejs'.padEnd(22)); try {
     let result, next = ()=> result ??= _compile_for_nodejs (csn,o)
     cds.emit ('compile.for.runtime', csn, o, next)

package/lib/compile/parse.js

@@ -87,7 +87,7 @@ exports.ttl = (parse, strings, ...values) => {
     for (let k in o) {
       const x = o[k]
       if (!x) continue
-      if (x.param) {
+      if (x.param && x.ref) {
         let val = values[x.ref[0]]; if (val === undefined) continue
         let y = o[k] = cxn4(val) //; y.$ = x.ref[0]
         if (x.cast) y.cast = x.cast

package/lib/core/linked-csn.js

@@ -107,22 +107,32 @@ class LinkedCSN {
     return this
   }
 
-  childrenOf (x, filter = ()=>true, defs = this.definitions) {
-    const children = namespace => !namespace ? children : this.childrenOf (namespace,filter)
-    const prefix = !x ? '' : typeof x === 'string' ? x+'.' : ((x = x.namespace || x.name)) ? x+'.' : ''
-    for (let fqn in defs) if (fqn.startsWith(prefix)) {
-      const d = defs[fqn]; if (!filter(d)) continue
-      else children[fqn.slice(prefix.length)] = d
-    }
-    return _iterable (children)
+  childrenOf (x, include = ()=>true, defs = this.definitions, children = new LinkedDefinitions) {
+    const prefix = !x ? '' : typeof x === 'string' ? x+'.' : x.namespace ? x.namespace+'.' : x.name ? x.name+'.' : ''
+    for (let name in defs)
+      if (name.startsWith(prefix) && include (defs[name]))
+        children[name.slice(prefix.length)] = defs[name]
+    return children
+  }
+
+  get exports() {
+    const exports = this.childrenOf (this)
+    return this.set ('exports', exports)
+  }
+
+  get entities() {
+    // REVISIT: remove _compat_texts_entities with cds^10
+    const filter = this._compat_texts_entities ? d => d.is_entity : d => d.is_entity && !d.name.endsWith('.texts')
+    const entities = ns => this.childrenOf (ns, filter)
+    for (let d of this.definitions) if (d.is_entity) entities[d.name] = d // adds all entities
+    Object.setPrototypeOf (entities, entities (this.namespace))          // adds exported entities
+    return this.set ('entities', entities)
   }
 
-  get exports()  { return this.set ('exports',  this.childrenOf (this)) }
-  get entities() { return this.set ('entities', this.childrenOf (this, d => d.is_entity)) }
   get services() {
-    let srvs = this.all (d => d.is_service)
-    for (let s of srvs) Object.defineProperty (srvs, s.name, {value:s})
-    return this.set ('services', srvs)
+    const services = this.all (d => d.is_service)
+    for (let s of services) Object.defineProperty (services, s.name, {value:s})
+    return this.set ('services', services)
   }
 
   /** A common cache for all kinds of things -> keeps the models clean */

package/lib/env/cds-env.js

@@ -92,6 +92,12 @@ class Config {
     // Complete service configurations from cloud service bindings
     this._add_cloud_service_bindings(process.env)
 
+    this.appid ??= null
+    if (typeof this.appid === 'boolean') {
+      if (this.appid) this.#import(_home, 'package.json', { get: p => ({ appid: p.name }) })
+      else this.appid = null
+    }
+
     // Only if feature is enabled
     if (this.features && this.features.emulate_vcap_services) {
       this._emulate_vcap_services()

package/lib/env/defaults.js

@@ -47,6 +47,7 @@ module.exports = {
     precise_timestamps: false,
     ieee754compatible: undefined,
     consistent_params: true, //> remove with cds^10
+    compat_texts_entities: true, //> remove with cds^10
     annotate_for_flows: true,
     history_for_flows: true,
     compile_for_assert: undefined,
@@ -62,7 +63,7 @@ module.exports = {
     draft_lock_timeout: true,
     draft_deletion_timeout: true,
     draft_messages: true,
-    draft_new_action: false
+    direct_crud: false
   },
 
   ql: {
@@ -105,6 +106,7 @@ module.exports = {
     db: 'db/',
     srv: 'srv/',
     app: 'app/',
+    apps: 'app/*',
   },
 
   i18n: {

package/lib/index.js

@@ -53,7 +53,7 @@ const cds = exports = module.exports = global.cds = new class cds extends EventE
   get i18n()     { return super.i18n = require('./i18n/index.js') }
 
   // Model Reflection, Builtin types and classes
-  get entities()    { return this.db?.entities || this.model?.entities }
+  get entities()    { return (this.model||this.db?.model)?.entities }
   get reflect()     { return super.reflect = this.linked }
   get linked()      { return super.linked = require('./core/linked-csn.js') }
   get builtin()     { return super.builtin = require('./core/types.js') }
@@ -80,6 +80,7 @@ const cds = exports = module.exports = global.cds = new class cds extends EventE
   get unboxed() { return this.unqueued }
   get queued() { return super.queued = require('../libx/queue/index.js').queued }
   get unqueued() { return super.unqueued = require('../libx/queue/index.js').unqueued }
+  get flush() { return super.flush = require('../libx/queue/index.js').cdsFlush }
   get middlewares() { return super.middlewares = require('./srv/middlewares/index.js') }
   get odata() { return super.odata = require('../libx/odata/index.js') }
   get auth() { return super.auth = require('./srv/middlewares/auth/index.js') }

package/lib/log/format/aspects/als.js

@@ -20,4 +20,8 @@ function als_aspect(module, level, args, toLog) {
 
 als_aspect.cf = () => Object.keys({ ...cds.env.log.als_custom_fields })
 
-module.exports = process.env.VCAP_SERVICES?.match(/"label":\s*"application-logs"/) ? als_aspect : () => {}
+const vcap_services = process.env.VCAP_SERVICES_FILE_PATH
+  ? cds.utils.fs.readFileSync(process.env.VCAP_SERVICES_FILE_PATH, 'utf-8')
+  : process.env.VCAP_SERVICES
+
+module.exports = vcap_services?.match(/"label":\s*"application-logs"/) ? als_aspect : () => {}

package/lib/log/format/aspects/cls.js

@@ -6,10 +6,14 @@ function cls_aspect(/* module, level, args, toLog */) {
 
 cls_aspect.cf = () => [...cds.env.log.cls_custom_fields]
 
-const VCAP_SERVICES = process.env.VCAP_SERVICES ? JSON.parse(process.env.VCAP_SERVICES) : {}
+const vcap_services = JSON.parse(
+  process.env.VCAP_SERVICES_FILE_PATH
+    ? cds.utils.fs.readFileSync(process.env.VCAP_SERVICES_FILE_PATH, 'utf-8')
+    : process.env.VCAP_SERVICES || '{}'
+)
 
 module.exports =
-  VCAP_SERVICES['cloud-logging'] ||
-  VCAP_SERVICES['user-provided']?.find(e => e.tags.includes('cloud-logging') || e.tags.includes('Cloud Logging'))
+  vcap_services['cloud-logging'] ||
+  vcap_services['user-provided']?.find(e => e.tags.includes('cloud-logging') || e.tags.includes('Cloud Logging'))
     ? cls_aspect
     : () => {}

package/lib/log/service/index.js

@@ -7,7 +7,11 @@ module.exports = class LogService extends cds.Service {
 
     // Secure by basic auth from xsuaa in production
     if (process.env.NODE_ENV === 'production') {
-      const { xsuaa } = (process.env.VCAP_SERVICES && JSON.parse(process.env.VCAP_SERVICES)) || {}
+      const { xsuaa } = JSON.parse(
+        process.env.VCAP_SERVICES_FILE_PATH
+          ? cds.utils.fs.readFileSync(process.env.VCAP_SERVICES_FILE_PATH, 'utf-8')
+          : process.env.VCAP_SERVICES || '{}'
+      )
       if (xsuaa) {
         const { clientid, clientsecret } = xsuaa[0].credentials
         const secret = 'Basic ' + Buffer.from (clientid + ':' + clientsecret).toString('base64')

package/lib/req/validate.js

@@ -201,7 +201,7 @@ class struct extends $any {
   validate (data, path, /** @type {Validation} */ ctx, elements = this.elements, skip={}) {
     if (data == null) return
     const path_ = !path ? [] : [...path, this.name]; if (path?.row) path_.push({...path})
-    if (typeof data !== 'object') return ctx.error ('ASSERT_DATA_TYPE', path_, this.name, null, data, this.target)
+    if (typeof data !== 'object') return ctx.error ('ASSERT_DATA_TYPE', path_, null, null, data, this.target || this.type?.replace(/^cds\./,''))
     // check for required elements in case of inserts -- note: null values are handled in the payload loop below
     if (ctx.insert || data && path_.length && this._is_insert(data)) for (let each of this._required (elements)) {
       if (each.name in data) continue // got value for required element

package/lib/srv/cds.Service.js

@@ -97,13 +97,41 @@ class ReflectionAPI extends ConsumptionAPI {
     || !this.isDatabaseService && !/\W/.test(this.name) && this.name
     || undefined
   }
-  get entities()   { return super.entities = this.reflect (d => d.kind === 'entity') }
-  get events()     { return super.events   = this.reflect (d => d.kind === 'event') }
-  get types()      { return super.types    = this.reflect (d => !d.kind || d.kind === 'type') }
-  get actions()    { return super.actions  = this.reflect (d => d.kind === 'action' || d.kind === 'function') }
+  get entities()   {
+    if (!this.model) return super.entities = []
+    // REVISIT: remove _compat_texts_entities with cds^10
+    const filter = this.model._compat_texts_entities ? d => d.kind === 'entity' : d => d.kind === 'entity' && !d.name.endsWith('.texts')
+    const entities = this.reflect(filter)
+    return super.entities = deconstructable_and_iterable(entities, 'entities', this)
+  }
+  get events()     {
+    if (!this.model) return super.events = []
+    const events = this.reflect(d => d.kind === 'event')
+    return super.events = deconstructable_and_iterable(events, 'events', this)
+  }
+  get types()      {
+    if (!this.model) return super.types = []
+    const types = this.reflect(d => !d.kind || d.kind === 'type')
+    return super.types = deconstructable_and_iterable(types, 'types', this)
+  }
+  get actions()    {
+    if (!this.model) return super.actions = []
+    const actions = this.reflect(d => d.kind === 'action' || d.kind === 'function')
+    return super.actions = deconstructable_and_iterable(actions, 'actions', this)
+  }
   reflect (filter) { return this.model?.childrenOf (this.namespace, filter) || [] }
 }
 
+const deconstructable_and_iterable = (it, what, srv) => {
+  // REVISIT: remove deprecated function API with cds^10
+  const compat_function_api = Object.assign(compat_function_factory(what, srv, it), it)
+  // srv.* is both deconstructable and iterable
+  return Object.setPrototypeOf(compat_function_api, it)
+}
+const compat_function_factory = (api, srv, it) => cds.utils.deprecated (ns => {
+  return !ns || ns === srv.namespace ? it : srv.model[api]?.(ns) || {}
+}, { kind: 'API', old: `srv.${api}()`, use: api === 'entities' ? `cds.${api}()` : undefined })
+
 
 /**
  * This class provides the API used by service providers to add event handlers.
@@ -111,6 +139,10 @@ class ReflectionAPI extends ConsumptionAPI {
  */
 class Service extends ReflectionAPI {
 
+  /** 
+   * @param {string} name 
+   * @param {import('../core/linked-csn').LinkedCSN} model 
+   */
   constructor (name, model, options) { super()
     if (typeof name === 'object') [ model, options, name = _service_in(model) ] = [ name, model ]
     this.name = name || new.target.name // i.e. when called without any arguments
@@ -124,7 +156,7 @@ class Service extends ReflectionAPI {
 
   // Handler registration API
   prepend (fn) { return this.handlers.prepend.call (this,fn) }
-  /** @typedef {( entity?, path?, handler:(req:import('../req/request'))=>{})=> Service} boa */
+  /** @typedef {( event, entity?, handler:(req:import('../req/request'))=>{})=> Service} boa */
   /** @type boa */ before (...args) { return this.handlers.register (this, 'before', ...args) }
   /** @type boa */ on     (...args) { return this.handlers.register (this, 'on',     ...args) }
   /** @type boa */ after  (...args) { return this.handlers.register (this, 'after',  ...args) }

package/libx/_runtime/common/generic/assert.js

@@ -128,6 +128,7 @@ module.exports = cds.service.impl(async function () {
 
             const failedAsserts = failedColumns.map(([element, message]) => {
               const error = {
+                status: 400,
                 code: 'ASSERT',
                 target: element,
                 numericSeverity: 4,

package/libx/_runtime/common/generic/flows.js

@@ -9,24 +9,20 @@ const FLOW_PREVIOUS = '$flow.previous'
 
 const $transitions_ = Symbol.for('transitions_')
 
-function buildAllowedCondition(action, statusElementName, statusEnum) {
+function isCurrentStatusInFrom(result, action, statusElementName, statusEnum) {
   const fromList = getFrom(action)
-  const conditions = fromList.map(from => {
+  const allowed = fromList.filter(from => {
     const value = from['#'] ? (statusEnum[from['#']]?.val ?? statusEnum[from['#']]['$path'].at(-1)) : from
-    return `${statusElementName} = ${typeof value === 'string' ? `'${value}'` : value}`
+    return result[statusElementName] === value
   })
-  return `(${conditions.join(' OR ')})`
-}
-
-async function isCurrentStatusInFrom(subject, action, statusElementName, statusEnum) {
-  const cond = buildAllowedCondition(action, statusElementName, statusEnum)
-  const parsedXpr = cds.parse.expr(cond)
-  const dbEntity = await SELECT.one.from(subject).where(parsedXpr)
-  return dbEntity !== undefined
+  return allowed.length
 }
 
 async function checkStatus(subject, action, statusElementName, statusEnum) {
-  const allowed = await isCurrentStatusInFrom(subject, action, statusElementName, statusEnum)
+  const result = await SELECT.one.from(subject)
+  if (!result) cds.error(404)
+
+  const allowed = isCurrentStatusInFrom(result, action, statusElementName, statusEnum)
   if (!allowed) {
     const from = getFrom(action)
     const fromValues = JSON.stringify(from.flatMap(el => Object.values(el)))

package/libx/_runtime/common/generic/input.js

@@ -360,9 +360,15 @@ async function validate_input(req) {
 
   const errs = cds.validate(req.data, req.target, assertOptions)
   if (errs) {
+    if (errs.some(e => e.message in EARLY_REJECT_CODES)) {
+      // ensure to use the orginal req.error, not the one monkey patched for draft messages
+      // REVISIT: this is an ugly workaround -> fix in lean draft please!
+      const errorFn = cds.Request.prototype.error.bind(req)
+      errs.forEach(err => errorFn(err))
+      req.reject()
+    }
     errs.forEach(err => req.error(err))
-    if (errs.some(e => e.message in EARLY_REJECT_CODES)) req.reject()
-    else return
+    return
   }
 
   // -------------------------------------------------

package/libx/_runtime/fiori/lean-draft.js

@@ -705,7 +705,7 @@ const draftHandle = async function (req) {
   if (typeof rootEntityName === 'object') rootEntityName = rootEntityName.id
   const rootEntity = this.model.definitions[rootEntityName]
 
-  const isNewDraftViaActionEnabled = cds.env.fiori.draft_new_action ?? false
+  const isNewDraftViaActionEnabled = cds.env.fiori.direct_crud ?? false
   let newDraftAction = rootEntity['@Common.DraftRoot.NewAction']
   if (typeof newDraftAction != 'string' || !newDraftAction.length) newDraftAction = false
   else newDraftAction = newDraftAction.split('.').pop()
@@ -979,7 +979,7 @@ const draftHandle = async function (req) {
           if (error.code) errors.push({ ...error })
           if (error.details) errors.push(...error.details.map(e => ({ ...e })))
         }
-        const nextDraftMessages = compileUpdatedDraftMessages(errors, persistedDraftMessages, {}, draftRef)
+        const nextDraftMessages = compileUpdatedDraftMessages(errors, persistedDraftMessages, _req.data || {}, draftRef)
         await cds.tx(async () => {
           await UPDATE('DRAFT.DraftAdministrativeData')
             .set({ DraftMessages: nextDraftMessages })
@@ -1762,12 +1762,16 @@ function _cleansed(query, model) {
 
       // set the target to null to ensure cds.infer(...) correctly infer the
       // target after query modifications
-      draftsQuery._target = null
+      Object.defineProperty(draftsQuery, '_target', { value: null, configurable: true, writable: true })
       let draftSelect = draftsQuery.SELECT
       let querySelect = query.SELECT
 
       // in the $apply scenario, only the most inner nested SELECT data structure must be cleansed
       while (draftSelect.from.SELECT) {
+        // set the target to null to ensure cds.infer(...) correctly infer the
+        // target after query modifications
+        if (draftSelect.from._target)
+          Object.defineProperty(draftSelect.from, '_target', { value: null, configurable: true, writable: true })
         draftSelect = draftSelect.from.SELECT
         querySelect = querySelect.from.SELECT
       }

package/libx/_runtime/messaging/kafka.js

@@ -94,6 +94,7 @@ class KafkaService extends cds.MessagingService {
   }
 
   async startListening() {
+    if (!this._listenToAll.value && !this.subscribedTopics.size) return
     const consumer = this.client.consumer({ groupId: this.consumerGroup })
     await consumer.connect()
 

package/libx/odata/ODataAdapter.js

@@ -50,7 +50,8 @@ module.exports = class ODataAdapter extends HttpAdapter {
       const isJson = type.match(/^application\/json$/) && suffix !== ''
 
       // POST with empty body is allowed if no content-type header is set
-      if (req.method === 'POST' && (!contentLength || isJson)) return jsonBodyParser(req, res, next)
+      if (req.method === 'POST' && (!contentLength || contentLength === '0' || isJson))
+        return jsonBodyParser(req, res, next)
 
       if (req.method in { POST: 1, PUT: 1, PATCH: 1 }) {
         if (!isJson) {

package/libx/odata/middleware/service-document.js

@@ -42,7 +42,7 @@ module.exports = adapter => {
       }
     }
 
-    const srvEntities = model.entities(service.definition.name)
+    const srvEntities = service.entities
 
     const exposedEntities = []
     for (const e in srvEntities) {

package/libx/odata/parse/afterburner.js

@@ -11,6 +11,8 @@ const resolveStructured = require('../../_runtime/common/utils/resolveStructured
 // Same regex as peggy parser
 const RELAXED_UUID_REGEX = /^[0-9a-z]{8}-?[0-9a-z]{4}-?[0-9a-z]{4}-?[0-9a-z]{4}-?[0-9a-z]{12}$/i
 
+let _isRelevantKey
+
 function _getDefinition(definition, name, namespace) {
   return (
     definition?.definitions?.[name] ||
@@ -336,7 +338,7 @@ function _processSegments(from, model, namespace, cqn, protocol) {
 
       ref[i] = null
       ref[i - keyCount] = base
-      incompleteKeys = keyCount < keys.filter(k => k !== 'IsActiveEntity').length
+      incompleteKeys = keyCount < keys.filter(_isRelevantKey).length
     } else {
       // > entity or property (incl. nested) or navigation or action or function
       keys = null
@@ -746,7 +748,7 @@ const _checkAllKeysProvided = (params, entity) => {
 
   if (!keysOfEntity) return
   for (const keyOfEntity of keysOfEntity) {
-    if (keyOfEntity !== 'IsActiveEntity' && !(keyOfEntity in params)) {
+    if (_isRelevantKey(keyOfEntity) && !(keyOfEntity in params)) {
       if (isView && entity.params[keyOfEntity].default) {
         // will be added later?
         continue
@@ -876,6 +878,8 @@ function _validateQuery(SELECT, target, isOne, model) {
 module.exports = (cqn, model, namespace, protocol) => {
   if (!model) return cqn
 
+  _isRelevantKey ??= cds.env.fiori.direct_crud ? k => k !== 'IsActiveEntity' : () => true
+
   const from = resolveFromSelect(cqn)
   const { ref } = from
 

package/libx/odata/parse/cqn2odata.js

@@ -71,7 +71,7 @@ function hasValidProps(obj, ...names) {
   return true
 }
 
-function _args(args, func, navPrefix) {
+function _args(args, func = null, navPrefix = [], isLambda = false) {
   const res = []
 
   for (const cur of args) {
@@ -81,11 +81,11 @@ function _args(args, func, navPrefix) {
     }
 
     if (hasValidProps(cur, 'func', 'args')) {
-      res.push(`${cur.func}(${_args(cur.args, cur.func, navPrefix)})`)
+      res.push(`${cur.func}(${_args(cur.args, cur.func, navPrefix, isLambda)})`)
     } else if (hasValidProps(cur, 'ref')) {
-      res.push(_format(cur, null, null, null, null, null, navPrefix))
+      res.push(_format(cur, null, null, null, isLambda, func, navPrefix))
     } else if (hasValidProps(cur, 'val')) {
-      res.push(_format(cur, null, null, null, null, func))
+      res.push(_format(cur, null, null, null, isLambda, func))
     }
   }
 
@@ -105,13 +105,13 @@ const _in = (column, /* in */ collection, target, kind, isLambda, navPrefix) =>
   }
 }
 
-const _odataV2Func = (func, args, navPrefix) => {
+const _odataV2Func = (func, args, navPrefix, isLambda) => {
   switch (func) {
     case 'contains':
       // this doesn't support the contains signature with two collections as args, introduced in odata v4.01
-      return `substringof(${_args([args[1], args[0]], null, navPrefix)})`
+      return `substringof(${_args([args[1], args[0]], null, navPrefix, isLambda)})`
     default:
-      return `${func}(${_args(args, func, navPrefix)})`
+      return `${func}(${_args(args, func, navPrefix, isLambda)})`
   }
 }
 
@@ -128,8 +128,8 @@ const _format = (cur, elementName, target, kind, isLambda, func, navPrefix = [])
   if (hasValidProps(cur, 'func')) {
     if (cur.args?.length) {
       return kind === 'odata-v2'
-        ? _odataV2Func(cur.func, cur.args, navPrefix)
-        : `${cur.func}(${_args(cur.args, cur.func)})`
+        ? _odataV2Func(cur.func, cur.args, navPrefix, isLambda)
+        : `${cur.func}(${_args(cur.args, cur.func, navPrefix, isLambda)})`
     }
     return `${cur.func}()`
   }