@sap/cds-dk 10.1.1 → 10.2.0

package/node_modules/@sap/cds/libx/_runtime/remote/utils/query.js

@@ -66,9 +66,11 @@ const _createODataRequestConfig = (query, data, target, srvKind) => {
     url: encodeURI(_formatPath(cleanQuery.substring(blankIndex, cleanQuery.length).trim()))
   }
 
-  if (data && requestConfig.method !== 'GET' && requestConfig.method !== 'HEAD') {
-    requestConfig.data = srvKind === 'odata-v2' ? Object.assign({}, convertV2PayloadData(data, target)) : data
-  }
+  if (!data || requestConfig.method === 'GET' || requestConfig.method === 'HEAD') return requestConfig
+
+  if (srvKind === 'odata-v2' && !(data instanceof Readable) && !(data instanceof Buffer))
+    requestConfig.data = convertV2PayloadData(data, target)
+  else requestConfig.data = data
 
   return requestConfig
 }
@@ -88,9 +90,12 @@ const _pathToRequestConfig = (method, path, data, target, srvName, srvKind) => {
   }
 
   const requestConfig = { method, url }
-  if (data && requestConfig.method !== 'GET' && requestConfig.method !== 'HEAD') {
-    requestConfig.data = srvKind === 'odata-v2' ? Object.assign({}, convertV2PayloadData(data, target)) : data
-  }
+
+  if (!data || requestConfig.method === 'GET' || requestConfig.method === 'HEAD') return requestConfig
+
+  if (srvKind === 'odata-v2' && !(data instanceof Readable) && !(data instanceof Buffer))
+    requestConfig.data = convertV2PayloadData(data, target)
+  else requestConfig.data = data
 
   return requestConfig
 }

package/node_modules/@sap/cds/libx/http/location.js

@@ -8,14 +8,16 @@ module.exports = (target, srv, result, keys_as_segments) => {
 
   const keyValuePairs = filteredKeys.reduce((acc, key) => {
     const value = result[key]
-    if (result[key] === undefined) return acc
 
     if (Buffer.isBuffer(value)) {
-      acc[key] = value.toString('base64')
+      const base64 = value.toString('base64')
+      acc[key] = keys_as_segments ? base64 : `binary'${base64}'`
+    } else if (keys_as_segments) {
+      acc[key] = value
     } else {
-      const _type = target.elements[key]._type
-      if (!keys_as_segments && typeof value === 'string' && _type !== 'cds.UUID') acc[key] = `'${value}'`
-      else acc[key] = value
+      const el = target.elements[key]
+      const needsQuotes = typeof value === 'string' && (el._type !== 'cds.UUID' || el['@odata.Type'] === 'Edm.String')
+      acc[key] = needsQuotes ? `'${value}'` : value
     }
 
     return acc
@@ -24,19 +26,16 @@ module.exports = (target, srv, result, keys_as_segments) => {
   if (keys_as_segments) {
     let location = targetName
     for (const k in keyValuePairs) location += `/${keyValuePairs[k]}`
-    return location
+    return encodeURI(location)
   }
 
   let keys
   const entries = Object.entries(keyValuePairs)
   if (entries.length === 1) {
     keys = entries[0][1]
-    if (target.elements[entries[0][0]]['@odata.Type'] === 'Edm.String') keys = `'${keys}'`
   } else {
-    keys = entries
-      .map(([key, value]) => `${key}=${target.elements[key]['@odata.Type'] === 'Edm.String' ? `'${value}'` : value}`)
-      .join(',')
+    keys = entries.map(([key, value]) => `${key}=${value}`).join(',')
   }
 
-  return `${targetName}(${keys})`
+  return encodeURI(`${targetName}(${keys})`)
 }

package/node_modules/@sap/cds/libx/odata/middleware/create.js

@@ -2,6 +2,7 @@ const cds = require('../../../')
 const { INSERT } = cds.ql
 
 const { getPreferReturnHeader } = require('../utils')
+const handle_ieee754 = require('../utils/ieee754')
 const getODataMetadata = require('../utils/metadata')
 const postProcess = require('../utils/postProcess')
 const readAfterWrite4 = require('../utils/readAfterWrite')
@@ -102,6 +103,9 @@ module.exports = (adapter, isUpsert) => {
 
         const metadata = getODataMetadata(query, { result })
         result = getODataResult(result, metadata)
+
+        handle_ieee754(req, result)
+
         res.status(201).send(result)
       })
       .catch(err => {

package/node_modules/@sap/cds/libx/odata/middleware/metadata.js

@@ -102,7 +102,7 @@ module.exports = adapter => {
           edmx = await mps.getEdmx({ tenant, model, service: service.definition.name })
           metadataCache.edm = edmx
         }
-        const extBundle = await mps.getI18n({ tenant, locale })
+        const extBundle = cds.requires.extensibility && (await mps.getI18n({ tenant, locale }))
         edmx = cds.localize(service.model, locale, edmx, extBundle)
         metadataCache.xmlEtag[locale] = generateEtag(edmx)
         res.set('ETag', metadataCache.xmlEtag[locale])

package/node_modules/@sap/cds/libx/odata/middleware/operation.js

@@ -2,6 +2,7 @@ const cds = require('../../../')
 
 const { pipeline } = require('node:stream/promises')
 
+const handle_ieee754 = require('../utils/ieee754')
 const getODataMetadata = require('../utils/metadata')
 const postProcess = require('../utils/postProcess')
 const getODataResult = require('../utils/result')
@@ -181,6 +182,8 @@ module.exports = adapter => {
         const metadata = getODataMetadata({ SELECT, _target }, options)
         result = getODataResult(result, metadata, { isCollection })
 
+        handle_ieee754(req, result)
+
         res.send(result)
       })
       .catch(err => {

package/node_modules/@sap/cds/libx/odata/middleware/parse.js

@@ -3,6 +3,12 @@ const odata = require('../index')
 const bodyParser4 = require('../../http/body-parser')
 const { isStream } = require('../utils')
 
+let reject_ieee754_false = req => {
+  if (/IEEE754Compatible\s*=\s*false/i.test(req.headers?.accept || ''))
+    cds.error({ status: 406, message: 'IEEE754Compatible=false is not supported' })
+}
+if (cds.env.odata.ieee754compatible === false) reject_ieee754_false = () => {}
+
 /**
  * @param {import('../ODataAdapter')} adapter
  * the adapter instance in which this middleware is used
@@ -44,6 +50,9 @@ module.exports = adapter => {
           else break
         else throw cds.error(415)
     }
+
+    reject_ieee754_false(req)
+
     return bodyParser(req, res, next)
   }
 }

package/node_modules/@sap/cds/libx/odata/middleware/read.js

@@ -3,6 +3,7 @@ const cds = require('../../../')
 const querystring = require('node:querystring')
 
 const { validateIfNoneMatch, getPreferReturnHeader } = require('../utils')
+const handle_ieee754 = require('../utils/ieee754')
 const getODataMetadata = require('../utils/metadata')
 const postProcess = require('../utils/postProcess')
 const getODataResult = require('../utils/result')
@@ -126,7 +127,7 @@ const _isNullableSingleton = query => query._target._isSingleton && query._targe
 const _isToOneAssoc = query =>
   query.SELECT.from.ref.length > 1 && typeof query.SELECT.from.ref.slice(-1)[0] === 'string'
 
-const _getCountFromResult = result => (Array.isArray(result) ? (result[0].$count ?? 0) : (result.$count ?? 0))
+const _getCountFromResult = result => (Array.isArray(result) ? (result[0]?.$count ?? 0) : (result?.$count ?? 0))
 
 const _getCountFromResultForArrayOfQueries = result => {
   if (!Array.isArray(result)) return result.$count ?? 0
@@ -190,6 +191,9 @@ const _handleArrayOfQueriesFactory = adapter => {
           { context: mainOdataContext },
           { isCollection: !req._query[0].SELECT.one, property: req._query[0]._propertyAccess }
         )
+
+        handle_ieee754(req, result)
+
         res.send(result)
       })
       .catch(err => {
@@ -300,6 +304,8 @@ module.exports = adapter => {
 
         if (!result) cds.error(404)
 
+        handle_ieee754(req, result)
+
         res.send(result)
       })
       .catch(err => {

package/node_modules/@sap/cds/libx/odata/middleware/update.js

@@ -2,6 +2,7 @@ const cds = require('../../../')
 const { UPDATE } = cds.ql
 
 const { getPreferReturnHeader, isStream } = require('../utils')
+const handle_ieee754 = require('../utils/ieee754')
 const getODataMetadata = require('../utils/metadata')
 const postProcess = require('../utils/postProcess')
 const readAfterWrite4 = require('../utils/readAfterWrite')
@@ -101,7 +102,7 @@ module.exports = adapter => {
     }
 
     // query
-    const query = UPDATE.entity(from).with(data)
+    const query = UPDATE.entity(from).data(data)
 
     // cdsReq.headers should contain merged headers of envelope and subreq
     // REVISIT: this overrides the merging mechanism in cds.Request which is meant to handle this centrally !!
@@ -149,6 +150,9 @@ module.exports = adapter => {
 
         const metadata = getODataMetadata(_propertyAccess ? req._query : query, { result })
         result = getODataResult(result, metadata, { property: _propertyAccess })
+
+        handle_ieee754(req, result)
+
         res.send(result)
       })
       .catch(err => {

package/node_modules/@sap/cds/libx/odata/parse/afterburner.js

@@ -1037,13 +1037,13 @@ module.exports = (cqn, model, namespace, protocol) => {
   // target <=> endpoint entity, all navigation refs must be resolvable accordingly
   if (cds.env.effective.odata.structs) _resolveAliasesInNavigation(cqn, target)
 
-  // Add default aggregation function (and alias)
-  _processColumns(cqn, current, protocol)
-
   if (target && !returns_target) {
     // validate whether only known properties are used in query options
     _validateQuery(cqn.SELECT, target, model)
   }
 
+  // Add default aggregation function (and alias)
+  _processColumns(cqn, current, protocol)
+
   return cqn
 }

package/node_modules/@sap/cds/libx/odata/parse/multipartToJson.js

@@ -117,7 +117,7 @@ const _parseStream = async function* (body, boundary) {
         .toString()
         .replace(/^--(.*)$/gm, (_, g) => `HEAD /${g} HTTP/1.1${g.slice(-2) === '--' ? CRLF : ''}`)
         // correct content-length for non-HEAD requests is inserted below
-        .replace(/content-length: \d+\r\n/gim, '') // if content-length is given it should be taken
+        .replace(/content-length:[ \t]*\d+\r\n/gim, '') // if content-length is given it should be taken
         .replaceAll(/^(?:(GET|PUT|POST|PATCH|DELETE)).*(?:\r?\n(?!\r?\n).*)*/gim, block => {
           return block.replaceAll(/ \$/g, ' /$')
         })

package/node_modules/@sap/cds/libx/odata/utils/ieee754.js

@@ -0,0 +1,20 @@
+const cds = require('../../../lib')
+
+// Does the bound db serialize Int64/Decimal as strings? sqlite/postgres only under
+// features.ieee754compatible; HANA and 3rd-party adapters always. Fixed after bootstrap.
+let _asStrings
+function providedAsStrings() {
+  _asStrings ??= cds.db?.kind in { sqlite: 1, postgres: 1 } ? !!cds.env.features.ieee754compatible : true
+  return _asStrings
+}
+
+// Label every JSON response IEEE754Compatible=true (OData JSON Format §4.1); call right before
+// res.send so non-JSON/204 exits ($count, $value, return=minimal) stay bare. A custom handler
+// that already set Content-Type wins — force means force, but an explicit handler is more explicit.
+module.exports = function handle_ieee754(req, result) {
+  if (cds.env.odata.ieee754compatible === false) return //> opt-out
+  if (req.res.get('Content-Type')) return //> set by custom handler
+  if (result == null || !providedAsStrings()) return
+
+  req.res.set('Content-Type', 'application/json; charset=utf-8; IEEE754Compatible=true')
+}

package/node_modules/@sap/cds/libx/queue/SchedulingService.js

@@ -24,6 +24,8 @@ const _setLongTimeout = (cb, delay) => {
 }
 
 let T0
+const MISSING_T0 =
+  'Skipping periodic message processing: no provider tenant is configured via `cds.requires.multitenancy.t0`. This is unexpected outside the `mtx-sidecar` profile.'
 
 module.exports = class SchedulingService extends cds.Service {
   constructor(...args) {
@@ -101,6 +103,8 @@ module.exports = class SchedulingService extends cds.Service {
 
       // NOTE: in the future, we also need to trigger task processing in sidecar for mtx
       if (cds.env.profile !== 'mtx-sidecar') {
+        if (!T0) return LOG.warn(MISSING_T0)
+
         const periodic_flush = setInterval(() => _flush(T0), flush_interval_ms).unref()
         cds.on('shutdown', () => clearInterval(periodic_flush))
         _flush(T0)

package/node_modules/@sap/cds/libx/queue/api.js

@@ -4,7 +4,7 @@ const LOG = cds.log('queue')
 let impl
 const _getImpl = () => {
   if (!impl) {
-    if (cds.env.requires.scheduling) {
+    if (cds.requires.scheduling) {
       LOG._debug && LOG.debug('Using scheduling-based event queue processing')
       impl = require('./processing')
     } else {

package/node_modules/@sap/cds/libx/queue/index.js

@@ -132,7 +132,7 @@ const _processTasks = (target, tenant, _opts = {}) => {
 
       if (opts.maxAttempts) tasksQuery.where({ attempts: { '<': opts.maxAttempts } })
       if (opts.parallel) {
-        tasksQuery.SELECT.forUpdate.ignoreLocked = true
+        tasksQuery.forUpdate({ ignoreLocked: true })
         const shifted = new Date(Math.max(0, currTime - _timeout)).toISOString()
         tasksQuery.where({ status: null, or: { lastAttemptTimestamp: { '<': shifted } } })
         // Note: If there are messages which are not yet timed out, but will hang eventually,
@@ -215,8 +215,14 @@ const _processTasks = (target, tenant, _opts = {}) => {
           const user = new cds.User.Privileged(userId)
           context.user = user
 
-          // The latter is for backwards compatibility where `service` was not stored and `target` was the service name
-          const srvName = _msg.service || _task.target
+          // older messages have no `service`; the name is encoded in `target` as
+          // `<targetPrefix><serviceName>` (see utils.targetName)
+          let srvName = _msg.service
+          if (!srvName) {
+            srvName = _task.target
+            if (opts.targetPrefix && srvName.startsWith(opts.targetPrefix))
+              srvName = srvName.slice(opts.targetPrefix.length)
+          }
           delete _msg.service
 
           const fromSend = _msg._fromSend
@@ -227,6 +233,7 @@ const _processTasks = (target, tenant, _opts = {}) => {
 
           const task = {
             ID: _task.ID,
+            timestamp: _task.timestamp,
             msg,
             context,
             srvName,
@@ -246,6 +253,19 @@ const _processTasks = (target, tenant, _opts = {}) => {
       let minAttemptFailed
       try {
         const _handleWithErr = async task => {
+          if (!cds.services[task.srvName]) {
+            // service not served/registered: unrecoverable, so dead-letter it (attempts -> maxAttempts)
+            // instead of crashing the app or blocking the queue
+            LOG.error(`No service '${task.srvName}' found for a queued message; treating as unrecoverable.`)
+            if (!minAttemptFailed) minAttemptFailed = task.attempts
+            else minAttemptFailed = Math.min(minAttemptFailed, task.attempts)
+            task[$error] = new Error(`No service '${task.srvName}' found`)
+            if (opts.maxAttempts) {
+              task.updateData = { attempts: opts.maxAttempts }
+              toBeUpdated.push(task)
+            } else toBeDeleted.push(task)
+            return
+          }
           const service = cds.unqueued(await cds.connect.to(task.srvName))
           try {
             if (task.msg.query) {
@@ -264,9 +284,23 @@ const _processTasks = (target, tenant, _opts = {}) => {
               // we can only delete in the current tx if legacyLocking (i.e., long-lasting db locks) is false
               if (!opts.legacyLocking) {
                 const _delete = DELETE.from(tasksEntity).where({ ID: task.ID })
-                // only delete singleton task if not modified in the meantime
-                if (task.msg.queue?.task) _delete.where({ timestamp: { '<': _timestampPlusOneMS(task.msg.timestamp) } })
-                await _delete
+                // guard on the selected row's timestamp (not `task.msg.timestamp`: `timestamp` is in
+                // `_ignoredContext`, absent from the msg, and reads back as `now`)
+                if (task.msg.queue?.task)
+                  _delete.where({ timestamp: { '<': _timestampPlusOneMS(new Date(task.timestamp)) } })
+                const _deleted = await _delete
+                const _cnt = typeof _deleted === 'number' ? _deleted : (_deleted?.affected ?? 0)
+                // recreate the next occurrence in the same tx; skip if the guarded delete removed nothing
+                // (the singleton was unscheduled/rescheduled concurrently)
+                if (task.msg.queue?.every && (!task.msg.queue?.task || _cnt > 0)) {
+                  const _m = { ...task.msg }
+                  _m._fromSend = task.msg instanceof cds.Request
+                  await INSERT.into(tasksEntity).entries(
+                    create_task(target, _m, task.context, task.srvName, opts, true)
+                  )
+                  // re-trigger the drain to schedule the new occurrence
+                  _setWaitingTime(0)
+                }
               }
               return result
             })
@@ -353,7 +387,7 @@ const _processTasks = (target, tenant, _opts = {}) => {
         if (each.updateData.lastError && typeof each.updateData.lastError !== 'string') {
           each.updateData.lastError = inspect(each.updateData.lastError)
         }
-        each.updateData.lastAttemptTimestamp = cds.context.timestamp
+        each.updateData.lastAttemptTimestamp = cds.context?.timestamp ?? new Date()
         queries.push(UPDATE(tasksEntity).where({ ID: each.ID }).set(each.updateData))
       }
 
@@ -409,11 +443,11 @@ const _processTasks = (target, tenant, _opts = {}) => {
           }
         }
 
-        // handle `every`
-        if (task.msg.queue?.every) {
+        // handle `every` — !legacyLocking recreates in the success tx above; the legacyLocking path
+        // (deferred delete) recreates here, using a read-back to detect a concurrent unschedule/reschedule
+        if (task.msg.queue?.every && opts.legacyLocking) {
           const _m = { ...task.msg }
           if (task.msg.queue.task) {
-            // Read from database as the singleton task might have been modified/deleted in the meantime
             const dbTask = await SELECT.one(tasksEntity).where({ ID: task.ID })
             if (!dbTask) continue //> was unscheduled -> no next occurrence
             Object.assign(_m, JSON.parse(dbTask.msg))
@@ -425,6 +459,8 @@ const _processTasks = (target, tenant, _opts = {}) => {
       }
       // invoke failed handlers (only if max attempts is reached)
       for (const task of toBeUpdated) {
+        // skip dead-lettered messages whose service is not served/registered (see above)
+        if (!cds.services[task.srvName]) continue
         if (
           !task.msg.event.endsWith('/#succeeded') &&
           !task.msg.event.endsWith('/#failed') &&

package/node_modules/@sap/cds/libx/queue/processing.js

@@ -25,10 +25,15 @@ const $service = Symbol('service')
 const MAX_WAITING_TIME = 1480000
 const CAPATTEMPTS = Math.ceil(Math.log(MAX_WAITING_TIME / 1000 + 1) / Math.log(1.5))
 
+const _timestampPlusOneMS = ts => new Date(ts.getTime() + 1).toISOString()
+
 let _processableTasksQuery = {}
 
-const _addParamFalse = w => {
-  if (w.xpr) return w.xpr.map(xpr => _addParamFalse(xpr))
+const _inlineLiterals = w => {
+  if (w.xpr) return w.xpr.map(xpr => _inlineLiterals(xpr))
+  // also recurse into function args (e.g. `startswith(target, '<appid>')`) so a literal arg isn't
+  // bound as a `?` and shift the positional binding of the query's real params
+  if (w.args) return (Array.isArray(w.args) ? w.args : Object.values(w.args)).map(a => _inlineLiterals(a))
   if (w.val === undefined) return w
   w.param = false
   return w
@@ -50,9 +55,14 @@ const _getProcessableTasksQuery = ({ maxAttempts, chunkSize }, queueName) => {
 
   const appid = cds.env.appid
 
+  // also match pre-`appid` rows: `appid IS NULL` with `target` starting with `appid` (the former app prefix)
+  const targetCondition = appid
+    ? `(appid = '${appid}' AND target = '${queueName}') OR (appid IS NULL AND startswith(target, '${appid}') = true)`
+    : `target = '${queueName}'`
+
   const sql = `
     SELECT ID FROM ${entity.name}
-    WHERE ${appid ? `appid = '${appid}' AND ` : ''}target = '${queueName}'
+    WHERE (${targetCondition})
       AND attempts < ${maxAttempts}
       AND (status is NULL OR lastAttemptTimestamp < ?)
       AND (${attemptConditions.join(' OR ')})
@@ -61,10 +71,9 @@ const _getProcessableTasksQuery = ({ maxAttempts, chunkSize }, queueName) => {
 
   _processableTasksQuery[queueName] = cds.ql(sql)
   _processableTasksQuery[queueName].SELECT.limit.rows.param = false
-  _processableTasksQuery[queueName].SELECT.where.map(w => _addParamFalse(w))
+  _processableTasksQuery[queueName].SELECT.where.map(w => _inlineLiterals(w))
   _processableTasksQuery[queueName].SELECT.columns = Object.keys(entity.elements).map(k => ({ ref: [k] }))
-  _processableTasksQuery[queueName].forUpdate()
-  _processableTasksQuery[queueName].SELECT.forUpdate.ignoreLocked = true
+  _processableTasksQuery[queueName].forUpdate({ ignoreLocked: true })
 
   return _processableTasksQuery[queueName]
 }
@@ -101,10 +110,9 @@ const _getFlushTasksQuery = ({ maxAttempts, chunkSize }, queueName) => {
       ORDER BY timestamp ASC, ID ASC
       LIMIT ${chunkSize}`)
     _flushTasksQuery[queueName].SELECT.limit.rows.param = false
-    _flushTasksQuery[queueName].SELECT.where.map(w => _addParamFalse(w))
+    _flushTasksQuery[queueName].SELECT.where.map(w => _inlineLiterals(w))
     _flushTasksQuery[queueName].SELECT.columns = Object.keys(entity.elements).map(k => ({ ref: [k] }))
-    _flushTasksQuery[queueName].forUpdate()
-    _flushTasksQuery[queueName].SELECT.forUpdate.ignoreLocked = true
+    _flushTasksQuery[queueName].forUpdate({ ignoreLocked: true })
   }
   return _flushTasksQuery[queueName]
 }
@@ -257,8 +265,13 @@ const _processTasks = (queueName, tenant, _opts = {}) => {
           const user = new cds.User.Privileged(userId)
           context.user = user
 
-          // The latter is for backwards compatibility where `service` was not stored and `target` was the service name
-          const srvName = _msg.service || _task.target
+          // older messages have no `service`; the name is encoded in `target` as `<appid><serviceName>`
+          let srvName = _msg.service
+          if (!srvName) {
+            srvName = _task.target
+            const appid = cds.env.appid
+            if (appid && srvName.startsWith(appid)) srvName = srvName.slice(appid.length)
+          }
           delete _msg.service
 
           const fromSend = _msg._fromSend
@@ -301,6 +314,15 @@ const _processTasks = (queueName, tenant, _opts = {}) => {
 
       try {
         const _handleWithErr = async task => {
+          if (!cds.services[task.srvName]) {
+            // service not served/registered: unrecoverable, so dead-letter it (attempts -> maxAttempts)
+            // instead of crashing the app or blocking the queue
+            LOG.error(`No service '${task.srvName}' found for a queued message; treating as unrecoverable.`)
+            task[$error] = new Error(`No service '${task.srvName}' found`)
+            task.updateData = { attempts: opts.maxAttempts }
+            toBeUpdated.push(task)
+            return
+          }
           const service = cds.unqueued(await cds.connect.to(task.srvName))
           try {
             if (task.msg.query) {
@@ -330,12 +352,18 @@ const _processTasks = (queueName, tenant, _opts = {}) => {
                   .where({ msg: { like: `%"tenant":"${task.msg.data.tenant}"%` } })
                   .where({ msg: { like: `%"target":"${task.msg.data.target}"%` } })
               } else {
-                await DELETE.from(OUTBOX).where({ ID: task.ID })
+                const _delete = DELETE.from(OUTBOX).where({ ID: task.ID })
+                // guard on the selected row's timestamp so a concurrent unschedule/reschedule is
+                // serialized against the recurrence recreated below
+                if (task.msg.queue?.task)
+                  _delete.where({ timestamp: { '<': _timestampPlusOneMS(new Date(task._task.timestamp)) } })
+                const _deleted = await _delete
+                const _cnt = typeof _deleted === 'number' ? _deleted : (_deleted?.affected ?? 0)
 
                 // For atomicity: create follow-up tasks in same transaction as delete
                 const follow_ups = []
 
-                // #succeeded callback (only if not already a callback event)
+                // #succeeded callback — always owed once the in-flight execution completed
                 if (!task.msg.event.endsWith('/#succeeded') && !task.msg.event.endsWith('/#failed')) {
                   const succeededMsg = _newMsgForCallbackFrom(task.msg)
                   succeededMsg.event = succeededMsg.event + '/#succeeded'
@@ -352,8 +380,9 @@ const _processTasks = (queueName, tenant, _opts = {}) => {
                   }
                 }
 
-                // Next recurrence for .every() tasks
-                if (task.msg.queue?.every) {
+                // next occurrence — only if the guarded delete removed the row (else it was unscheduled/
+                // rescheduled concurrently); non-singletons always recreate
+                if (task.msg.queue?.every && (!task.msg.queue?.task || _cnt > 0)) {
                   const _m = { ...task.msg }
                   _m._fromSend = task.msg instanceof cds.Request
                   const next_iteration_task = create_task(queueName, _m, task.context, task.srvName, opts, true)
@@ -423,7 +452,7 @@ const _processTasks = (queueName, tenant, _opts = {}) => {
             if (each.updateData.lastError && typeof each.updateData.lastError !== 'string') {
               each.updateData.lastError = inspect(each.updateData.lastError)
             }
-            each.updateData.lastAttemptTimestamp = cds.context.timestamp
+            each.updateData.lastAttemptTimestamp = cds.context?.timestamp ?? new Date().toISOString()
             follow_up_tasks.push(Object.assign({}, each._task, each.updateData))
             afters.add(waitingTime(each.updateData.attempts))
           }
@@ -441,6 +470,8 @@ const _processTasks = (queueName, tenant, _opts = {}) => {
 
           // Create #failed callbacks (only if max attempts is reached)
           for (const task of toBeUpdated) {
+            // skip dead-lettered messages whose service is not served/registered (see above)
+            if (!cds.services[task.srvName]) continue
             if (
               !is_t0 &&
               !task.msg.event.endsWith('/#succeeded') &&
@@ -548,6 +579,11 @@ exports.queued = function queued(srv, opts) {
     // REVISIT: why is req.context preferred and when would they differ?
     const context = req.context || cds.context
 
+    // In MT apps, scheduling without a tenant is ambiguous — require explicit tenant context
+    if (cds.requires.multitenancy && !context.tenant) {
+      throw new Error(`Cannot schedule task without tenant context in multitenant app`)
+    }
+
     // persistent queue
     if (queueOpts.kind === 'persistent-queue' && _hasPersistentQueue(context.tenant)) {
       const scheduler = await cds.connect.to(SCHEDULER_SERVICE)

package/node_modules/@sap/cds/libx/queue/utils.js

@@ -51,6 +51,9 @@ const create_task = (queueName, msg, context, serviceName, queueOpts, reoccurren
     appid: cds.env.appid,
     target: cds.env.appid ? queueName : targetName(queueName, queueOpts),
     timestamp,
+    // reset status so re-submitting a task that is currently being processed (UPSERT over its
+    // 'processing' row) yields a processable row again instead of a stuck one
+    status: null,
     msg: JSON.stringify(_msg)
   }
 

package/node_modules/@sap/cds/libx/rest/RestAdapter.js

@@ -74,6 +74,7 @@ class RestAdapter extends HttpAdapter {
           let def = req._operation || cds.infer.target(req._query)
           const defs = srv.model.definitions
           if (typeof def === 'string') def = defs[def] || defs[def.split(':$:')[0]].actions[def.split(':$:')[1]]
+          if (req._operation) def = def?.returns?.items ?? def?.returns
           if (def) postProcessData(result, srv, def)
         }
 

package/node_modules/@sap/cds/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sap/cds",
-  "version": "10.1.0",
+  "version": "10.2.1",
   "description": "SAP Cloud Application Programming Model - CDS for Node.js",
   "homepage": "https://cap.cloud.sap/",
   "keywords": [
@@ -29,7 +29,7 @@
     "CHANGELOG.md"
   ],
   "engines": {
-    "node": ">=22"
+    "node": ">=22.12"
   },
   "dependencies": {
     "@sap/cds-compiler": "^7",

package/node_modules/@sap/cds/server.js

@@ -46,6 +46,7 @@ module.exports = async function cds_server (options) {
   if (o.static)    app.use (express.static (o.static))  //> defaults to ./app
   if (o.favicon)   app.use ('/favicon.ico', o.favicon)  //> if none in ./app
   if (o.index)     app.get ('/',o.index)                //> if none in ./app
+  if (o.index)     app.use ('/.cap', express.static (__dirname+'/app'))
 
   // load and prepare models
   const csn = await cds.load(o.from||'*',o); o.from = false

package/node_modules/@sap/cds/srv/ucl-service.cds

@@ -9,6 +9,7 @@ type State : String enum {
 @path    : '/ucl/spii/v1'
 @requires: 'any'
 @impl    : '@sap/cds/srv/ucl-service.js'
+@ORD.Extensions: { visibility : 'private' }
 service UCLService {
   @open
   @cds.persistence.skip

package/node_modules/@sap/cds/tasks/enterprise-messaging-deploy.js

@@ -19,11 +19,19 @@ const xsuaaSrv = Object.keys(vcap_services)
 if (!xsuaaSrv)
   throw new Error('You need to provide credentials of service `XSUAA` in environment variable `VCAP_SERVICES`')
 const tokenStore = {}
-const oa2 = {
-  client: xsuaaSrv.credentials.clientid,
-  secret: xsuaaSrv.credentials.clientsecret,
-  endpoint: xsuaaSrv.credentials.url
-}
+const xsuaaCreds = xsuaaSrv.credentials
+const oa2 =
+  xsuaaCreds['credential-type'] === 'x509'
+    ? {
+        client: xsuaaCreds.clientid,
+        endpoint: xsuaaCreds.certurl,
+        mTLS: { cert: xsuaaCreds.certificate, key: xsuaaCreds.key }
+      }
+    : {
+        client: xsuaaCreds.clientid,
+        secret: xsuaaCreds.clientsecret,
+        endpoint: xsuaaCreds.url
+      }
 
 const main = async () => {
   // use authorizedRequest to fire against deploy endpoint