@sap/cds 8.9.0 → 8.9.2

package/CHANGELOG.md

@@ -4,6 +4,21 @@
 - The format is based on [Keep a Changelog](https://keepachangelog.com/).
 - This project adheres to [Semantic Versioning](https://semver.org/).
 
+## Version 8.9.2 - 2025-04-14
+
+### Fixed
+
+- `forUpdate` will not consider `wait` if `ignoreLocked` is set
+- Do not crash in case of custom `DraftAdministrativeData` table
+
+## Version 8.9.1 - 2025-04-03
+
+### Fixed
+
+- `cds.env` merging for `null` values
+- Best-effort mechanisms for lambda support on OData V2 remote services (usage of functions in lambda expressions)
+- Use extended model in `enterprise-messaging` inbound handlers
+
 ## Version 8.9.0 - 2025-03-31
 
 ### Added

package/lib/compile/for/lean_drafts.js

@@ -144,7 +144,7 @@ module.exports = function cds_compile_for_lean_drafts(csn) {
       }
       if (e.name === 'DraftAdministrativeData') {
         // redirect to DraftAdministrativeData service entity
-        _redirect(newEl, active._service.entities.DraftAdministrativeData)
+        if (active._service?.entities.DraftAdministrativeData) _redirect(newEl, active._service.entities.DraftAdministrativeData)
       }
       Object.defineProperty (newEl,'parent',{value:draft,enumerable:false, configurable: true, writable: true})
 

package/lib/env/cds-env.js

@@ -470,7 +470,7 @@ function _merge (dst, src, _profiles) {
       else _merge (dst[p], v, _profiles)
       continue
     }
-    else if (typeof v === 'string' && typeof dst[p] === 'object' && dst[p].kind) {
+    else if (typeof v === 'string' && typeof dst[p] === 'object' && dst[p]?.kind) {
       dst[p].kind = v  // requires.db = 'foo' -> requires.db.kind = 'foo'
     }
     else if (v !== undefined) dst[p] = v

package/lib/ql/SELECT.js

@@ -152,8 +152,8 @@ class SELECT extends Whereable {
   forUpdate ({ of, wait = cds.env.sql.lock_acquire_timeout || -1, ignoreLocked } = {}) {
     const sfu = this.SELECT.forUpdate = {}
     if (of) sfu.of = of.map (c => ({ref:c.split('.')}))
-    if (wait >= 0) sfu.wait = wait
     if (ignoreLocked) sfu.ignoreLocked = true
+    else if (wait >= 0) sfu.wait = wait
     return this
   }
 

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -51,7 +51,7 @@ class AMQPWebhookMessaging extends MessagingService {
       if (!msg._) msg._ = {}
       msg._.topic = _topic
       try {
-        await this.tx({ user: cds.User.privileged, tenant: msg.tenant, _: msg._ }, tx => tx.emit(msg))
+        await this.processInboundMsg({ tenant: msg.tenant, _: msg._ }, msg)
         done()
       } catch (e) {
         // In case of AMQP and Solace, the `failed` callback must be called

package/libx/_runtime/messaging/common-utils/normalizeIncomingMessage.js

@@ -22,8 +22,7 @@ const normalizeIncomingMessage = message => {
 
   return {
     data,
-    headers,
-    inbound: true
+    headers
   }
 }
 

package/libx/_runtime/messaging/file-based.js

@@ -54,12 +54,12 @@ class FileBasedMessaging extends MessagingService {
               if (this.subscribedTopics.has(topic)) {
                 const event = this.subscribedTopics.get(topic)
                 if (!event) return
-                this.tx(tx =>
-                  tx.emit({ event, ...json, inbound: true }).catch(e => {
-                    e.message = 'ERROR occurred in asynchronous event processing: ' + e.message
-                    this.LOG.error(e)
-                  })
-                )
+                try {
+                  await this.processInboundMsg({}, { event, ...json })
+                } catch (e) {
+                  e.message = 'ERROR occurred in asynchronous event processing: ' + e.message
+                  this.LOG.error(e)
+                }
               } else other.push(each + '\n')
             }
           } catch {

package/libx/_runtime/messaging/kafka.js

@@ -131,7 +131,7 @@ class KafkaService extends cds.MessagingService {
           msg.tenant = raw.message.headers['x-sap-cap-tenant-id']
           if (!msg.event) return
 
-          await this.tx({ user: cds.User.privileged, tenant: msg.tenant }, tx => tx.emit(msg))
+          await this.processInboundMsg({ tenant: msg.tenant }, msg)
         } catch (e) {
           if (e.code === 'NO_HANDLER_FOUND') return // consume
           this.LOG.error('ERROR occured in asynchronous event processing:', e)
@@ -169,8 +169,7 @@ function _normalizeIncomingMessage(message) {
 
   return {
     data,
-    headers,
-    inbound: true
+    headers
   }
 }
 

package/libx/_runtime/messaging/redis-messaging.js

@@ -77,7 +77,7 @@ class RedisMessaging extends cds.MessagingService {
         const msg = normalizeIncomingMessage(message)
         msg.event = topic
         try {
-          await this.tx({ user: cds.User.privileged }, tx => tx.emit(msg))
+          await this.processInboundMsg({}, msg)
         } catch (e) {
           e.message = 'ERROR occurred in asynchronous event processing: ' + e.message
           this.LOG.error(e)

package/libx/_runtime/messaging/service.js

@@ -78,15 +78,22 @@ class MessagingService extends cds.Service {
 
   async handle(msg) {
     if (msg.inbound) {
-      if (cds.model) {
-        const ctx = cds.context
-        ctx.model = await ExtendedModels.model4(ctx.tenant, ctx.features)
-      }
       return super.handle(this.message4(msg))
     }
     return super.handle(msg)
   }
 
+  async processInboundMsg(ctx, msg) {
+    msg.inbound = true
+    if (!cds.context) cds.context = {}
+    if (ctx.tenant) cds.context.tenant = ctx.tenant
+    if (!ctx.user) ctx.user = cds.User.privileged
+    // this.tx expects cds.context.model
+    if (cds.model && (cds.env.requires.extensibility || cds.env.requires.toggles))
+      cds.context.model = await ExtendedModels.model4(ctx.tenant, ctx.features || {})
+    return await this.tx(ctx, tx => tx.emit(msg))
+  }
+
   on(event, cb) {
     const _event = _warnAndStripTopicPrefix(event)
     // save all subscribed topics (not needed for local-messaging)

package/libx/odata/parse/cqn2odata.js

@@ -74,7 +74,7 @@ function hasValidProps(obj, ...names) {
   return true
 }
 
-function _args(args, func) {
+function _args(args, func, navPrefix) {
   const res = []
 
   for (const cur of args) {
@@ -84,9 +84,9 @@ function _args(args, func) {
     }
 
     if (hasValidProps(cur, 'func', 'args')) {
-      res.push(`${cur.func}(${_args(cur.args, cur.func)})`)
+      res.push(`${cur.func}(${_args(cur.args, cur.func, navPrefix)})`)
     } else if (hasValidProps(cur, 'ref')) {
-      res.push(_format(cur))
+      res.push(_format(cur, null, null, null, null, null, navPrefix))
     } else if (hasValidProps(cur, 'val')) {
       res.push(_format(cur, null, null, null, null, func))
     }
@@ -95,38 +95,44 @@ function _args(args, func) {
   return res.join(',')
 }
 
-const _in = (column, /* in */ collection, target, kind, isLambda) => {
-  const ref = _format(column, null, target, kind, isLambda)
+const _in = (column, /* in */ collection, target, kind, isLambda, navPrefix) => {
+  const ref = _format(column, null, target, kind, isLambda, null, navPrefix)
   // { list: [ { val: 1}, { val: 2}, { val: 3} ] }
   const values = collection.list
   if (values && values.length) {
     // REVISIT: what about OData `in` operator?
-    const expressions = values.map(value => `${ref}%20eq%20${_format(value, ref, target, kind, isLambda)}`)
+    const expressions = values.map(
+      value => `${ref}%20eq%20${_format(value, ref, target, kind, isLambda, null, navPrefix)}`
+    )
     return expressions.join('%20or%20')
   }
 }
 
-const _odataV2Func = (func, args) => {
+const _odataV2Func = (func, args, navPrefix) => {
   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]])})`
+      return `substringof(${_args([args[1], args[0]], null, navPrefix)})`
     default:
-      return `${func}(${_args(args, func)})`
+      return `${func}(${_args(args, func, navPrefix)})`
   }
 }
 
-const _format = (cur, elementName, target, kind, isLambda, func) => {
+const _format = (cur, elementName, target, kind, isLambda, func, navPrefix = []) => {
   if (typeof cur !== 'object') return encodeURIComponent(formatVal(cur, elementName, target, kind))
   if (hasValidProps(cur, 'ref'))
-    return encodeURIComponent(isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref[0].id || cur.ref.join('/'))
+    return encodeURIComponent(
+      isLambda ? [LAMBDA_VARIABLE, ...cur.ref].join('/') : cur.ref[0].id || [...navPrefix, ...cur.ref].join('/')
+    )
   if (hasValidProps(cur, 'val'))
     return encodeURIComponent(formatVal(cur.val, elementName, target, kind, func, cur.literal))
-  if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda)})`
+  if (hasValidProps(cur, 'xpr')) return `(${_xpr(cur.xpr, target, kind, isLambda, navPrefix)})`
   // REVISIT: How to detect the types for all functions?
   if (hasValidProps(cur, 'func')) {
     if (cur.args?.length) {
-      return kind === 'odata-v2' ? _odataV2Func(cur.func, cur.args) : `${cur.func}(${_args(cur.args, cur.func)})`
+      return kind === 'odata-v2'
+        ? _odataV2Func(cur.func, cur.args, navPrefix)
+        : `${cur.func}(${_args(cur.args, cur.func)})`
     }
     return `${cur.func}()`
   }
@@ -138,7 +144,7 @@ const _isLambda = (cur, next) => {
   return last && hasValidProps(last, 'id')
 }
 
-function _xpr(expr, target, kind, isLambda) {
+function _xpr(expr, target, kind, isLambda, navPrefix = []) {
   const res = []
   const openBrackets = []
 
@@ -165,10 +171,10 @@ function _xpr(expr, target, kind, isLambda) {
         const between = [expr[i - 1], 'gt', expr[i + 1], 'and', expr[i - 1], 'lt', expr[i + 3]]
         // cleanup previous ref
         res.pop()
-        res.push(`(${_xpr(between, target, kind, isLambda)})`)
+        res.push(`(${_xpr(between, target, kind, isLambda, navPrefix)})`)
         i += 3
       } else if (cur === 'in') {
-        const inExpr = _in(expr[i - 1], expr[i + 1], target, kind, isLambda)
+        const inExpr = _in(expr[i - 1], expr[i + 1], target, kind, isLambda, navPrefix)
         // cleanup previous ref
         res.pop()
         // when sending a where clause with "col in []" we currently ignore the where clause
@@ -179,20 +185,33 @@ function _xpr(expr, target, kind, isLambda) {
       } else if (_isLambda(cur, expr[i + 1])) {
         const { where } = expr[i + 1].ref.at(-1)
         const nav = expr[i + 1].ref.map(ref => ref?.id ?? ref).join('/')
-        // odata-v2 does not support lambda expressions but successfactors allows filter like for to-one assocs
+
         if (kind === 'odata-v2') {
+          // odata-v2 does not support lambda expressions but successfactors allows filter like for to-one assocs
           cds.log('remote').info(`OData V2 does not support lambda expressions. Using path expression as best effort.`)
           isLambda = false
-          res.push(`${nav}%2F${_xpr(where, target, kind)}`)
-        } else if (!where) res.push(`${nav}/any()`)
-        else res.push(`${nav}/any(${LAMBDA_VARIABLE}:${_xpr(where, target, kind, true)})`)
+          res.push(_xpr(where, target, kind, isLambda, [...navPrefix, nav]))
+        } else if (!where) {
+          res.push(`${nav}/any()`)
+        } else {
+          res.push(`${nav}/any(${LAMBDA_VARIABLE}:${_xpr(where, target, kind, true, navPrefix)})`)
+        }
+
         i++
       } else {
         res.push(OPERATORS[cur] || cur.toLowerCase())
       }
     } else {
       const ref = expr[i - 2]
-      const formatted = _format(cur, ref?.ref && (ref.ref.length ? ref.ref : ref.ref[0]), target, kind, isLambda)
+      const formatted = _format(
+        cur,
+        ref?.ref && (ref.ref.length ? ref.ref : ref.ref[0]),
+        target,
+        kind,
+        isLambda,
+        null,
+        navPrefix
+      )
       if (formatted !== undefined) res.push(formatted)
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "8.9.0",
+  "version": "8.9.2",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [