@sap/cds 7.2.0 → 7.3.0

package/libx/_runtime/common/error/frontend.js

@@ -39,42 +39,48 @@ const _getFiltered = err => {
 }
 
 const _rewriteDBError = error => {
+  let { code, message } = error
+  code = String(code || 'null')
+
   // REVISIT: db stuff probably shouldn't be here
-  if (error.code === 'SQLITE_ERROR') {
+  if (code === 'SQLITE_ERROR') {
     error.code = 'null'
-  } else if (
-    (error.code.startsWith('SQLITE_CONSTRAINT') && error.message.match(/COMMIT/)) ||
-    (error.code.startsWith('SQLITE_CONSTRAINT') && error.message.match(/FOREIGN KEY/)) ||
-    (error.code === '155' && error.message.match(/fk constraint violation/))
+    return
+  }
+
+  if (
+    (code.startsWith('SQLITE_CONSTRAINT') && (message.match(/COMMIT/) || message.match(/FOREIGN KEY/))) ||
+    (code === '155' && message.match(/fk constraint violation/))
   ) {
     // > foreign key constaint violation no sqlite/ hana
     error.code = '400'
-    error.message = i18n('FK_CONSTRAINT_VIOLATION')
-  } else if (error.code.startsWith('ASSERT_')) {
+    error.message = 'FK_CONSTRAINT_VIOLATION'
+    return
+  }
+
+  if (code.startsWith('ASSERT_')) {
     error.code = '400'
+    return
   }
 }
 
-const _normalize = (err, locale, inner = false) => {
+const _normalize = (err, locale, formatterFn = _getFiltered) => {
+  // REVISIT: code and message rewriting
+  _rewriteDBError(err)
+
   // message (i18n)
   err.message = getErrorMessage(err, locale)
 
-  // only allowed properties
-  const error = _getFiltered(err)
-
   // ensure code is set and a string
-  error.code = String(error.code || 'null')
-
-  // REVISIT: code and message rewriting
-  _rewriteDBError(error)
+  err.code = String(err.code || 'null')
 
-  let statusCode = err.status || err.statusCode || (_isAllowedError(error.code) && error.code)
+  let statusCode = err.status || err.statusCode || (_isAllowedError(err.code) && err.code)
 
   // details
-  if (!inner && err.details) {
+  if (err.details) {
     const childErrorCodes = new Set()
-    error.details = err.details.map(ele => {
-      const { error: childError, statusCode: childStatusCode } = _normalize(ele, locale, true)
+    err.details = err.details.map(ele => {
+      const { error: childError, statusCode: childStatusCode } = _normalize(ele, locale, formatterFn)
       childErrorCodes.add(childStatusCode)
       return childError
     })
@@ -84,12 +90,13 @@ const _normalize = (err, locale, inner = false) => {
   // make sure it's a number if set, otherwise will be assigned as 500 in normalizeError
   statusCode = statusCode ? Number(statusCode) : undefined
 
+  // only allowed properties
+  const error = formatterFn(err)
+
   return { error, statusCode }
 }
 
-const _isAllowedError = errorCode => {
-  return errorCode >= 300 && errorCode < 505
-}
+const _isAllowedError = errorCode => errorCode >= 300 && errorCode < 505
 
 // - for one unique value, we use it
 // - if at least one 5xx exists, we use 500
@@ -100,32 +107,37 @@ const _statusCodeFromDetails = uniqueStatusCodes => {
   if ([...uniqueStatusCodes].some(s => s >= 400)) return 400
 }
 
-const normalizeError = (err, req) => {
+const _getSanitizedError = (statusCode, locale) => ({
+  error: { code: String(statusCode), message: i18n(statusCode, locale) },
+  statusCode
+})
+
+const normalizeError = (err, req, formatterFn) => {
   const locale = req.locale || (req.locale = localeFrom(req))
-  let { error, statusCode } = _normalize(err, locale)
+  let { error, statusCode } = _normalize(err, locale, formatterFn)
 
-  if ((!statusCode || (statusCode >= 500 && err._thrownByFramework)) && process.env.NODE_ENV === 'production') {
+  if (process.env.NODE_ENV === 'production') {
     // > return sanitized error to client
-    return {
-      error: { code: statusCode ? `${statusCode}` : '500', message: i18n(statusCode || 500, locale) },
-      statusCode: Number(statusCode) || 500
+
+    if (!statusCode) return _getSanitizedError(500, locale)
+
+    if (statusCode >= 500 && err._thrownByFramework) {
+      return _getSanitizedError(statusCode, locale)
     }
   }
 
   if (!statusCode) statusCode = 500
 
   // no top level null codes
-  if (error.code === 'null') {
-    error.code = String(statusCode)
-  }
+  if (error.code === 'null') error.code = String(statusCode)
 
   return { error, statusCode }
 }
 
 const _ensureSeverity = arg => {
-  if (typeof arg === 'number' && arg >= MIN_SEVERITY && arg <= MAX_SEVERITY) {
-    return arg
-  }
+  if (typeof arg !== 'number') return DEFAULT_SEVERITY
+
+  if (arg >= MIN_SEVERITY && arg <= MAX_SEVERITY) return arg
 
   return DEFAULT_SEVERITY
 }

package/libx/_runtime/common/generic/auth/capabilities.js

@@ -1,14 +1,14 @@
 const { cqnFrom } = require('./utils')
 const { RESTRICTIONS } = require('./constants')
 
-const _isRestricted = (req, capability, capabilityReadByKey) => {
-  if (capabilityReadByKey !== undefined && req.query.SELECT && req.query.SELECT.one) {
-    return capabilityReadByKey === false
+const _getRestriction = (req, capability, capabilityReadByKey) => {
+  if (capabilityReadByKey !== undefined && req.query.SELECT?.one) {
+    return capabilityReadByKey
   }
-  return capability === false
+  return capability
 }
 
-const _isNavigationRestricted = (target, path, annotation, req) => {
+const _getNavigationRestriction = (target, path, annotation, req) => {
   if (!target) return
   if (!Array.isArray(target['@Capabilities.NavigationRestrictions.RestrictedProperties'])) return
 
@@ -17,7 +17,7 @@ const _isNavigationRestricted = (target, path, annotation, req) => {
     // prefix check to support both notations: { InsertRestrictions: { Insertable: false } } and { InsertRestrictions.Insertable: false }
     if (r.NavigationProperty['='] === path && Object.keys(r).some(k => k.startsWith(restriction))) {
       const capability = r[annotation] ?? r[restriction]?.[operation]
-      return _isRestricted(req, capability, r.ReadRestrictions?.['ReadByKeyRestrictions.Readable'])
+      return _getRestriction(req, capability, r.ReadRestrictions?.['ReadByKeyRestrictions.Readable'])
     }
   }
 }
@@ -32,22 +32,41 @@ function handler(req) {
 
   const action = annotation.split('.').pop().toUpperCase()
   const from = cqnFrom(req)
-  const nav = (from && from.ref && from.ref.map(el => el.id || el)) || []
+  const nav = (from?.ref && from.ref.map(el => el.id || el)) || []
 
+  let navRestriction
   if (nav.length > 1) {
-    const path = nav.slice(1).join('.')
-    const target = this.model.definitions[nav[0]]
-    if (_isNavigationRestricted(target, path, annotation, req)) {
+    const navs = nav.slice(1)
+    let lastTarget, target, element, navigation, path
+    target = this.model.definitions[nav[0]]
+    for (let i = 0; i < navs.length && target; i++) {
+      element = !element || element.isAssociation ? target.elements[navs[i]] : element.elements[navs[i]]
+      if (element.isAssociation) {
+        navigation = path ? `${path}.${navs[i]}` : navs[i]
+        path = undefined
+        lastTarget = target
+        target = this.model.definitions[element.target]
+      } else {
+        path = path ? `${path}.${navs[i]}` : navs[i]
+      }
+    }
+    if (lastTarget && navigation) {
+      navRestriction = _getNavigationRestriction(lastTarget, navigation, annotation, req)
+    }
+    if (navRestriction === false) {
       // REVISIT: rework exception with using target
-      const trgt = `${_localName(target)}.${path}`
+      const trgt = `${_localName(lastTarget)}.${navs.join('.')}`
       req.reject(405, 'ENTITY_IS_NOT_CRUD_VIA_NAVIGATION', [_localName(req.target), action, trgt])
     }
-  } else if (
-    _isRestricted(
+  }
+
+  if (
+    !navRestriction &&
+    _getRestriction(
       req,
       req.target['@Capabilities.' + annotation],
       req.target['@Capabilities.' + RESTRICTIONS.READABLE_BY_KEY]
-    )
+    ) === false
   ) {
     req.reject(405, 'ENTITY_IS_NOT_CRUD', [_localName(req.target), action])
   }

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

@@ -246,7 +246,7 @@ async function commonGenericInput(req) {
   if (boundAction) {
     const pathSegment = _getBoundActionBindingParameter(boundAction)
     if (pathSegment) pathOptions.pathSegmentsInfo.push(pathSegment)
-    const keys = req._?.params?.[0]
+    const keys = req.params?.[0]
     if (keys && 'IsActiveEntity' in keys) {
       pathOptions.draftKeys = { IsActiveEntity: keys.IsActiveEntity }
     }

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

@@ -35,6 +35,7 @@ const commonGenericPaging = function (req) {
 }
 
 const _addPaging = function ({ SELECT }, target) {
+  if (SELECT.limit === false) return
   const { rows } = SELECT.limit || (SELECT.limit = {})
   const conf = getPageSize(target)
   SELECT.limit.rows = {

package/libx/_runtime/common/i18n/messages.properties

@@ -83,6 +83,7 @@ CRUD_VIA_NAVIGATION_NOT_SUPPORTED=CRUD via navigations is not yet supported
 
 # draft
 DRAFT_ALREADY_EXISTS=A draft for this entity already exists
+DRAFT_NOT_EXISTING=No draft for this entity exists
 DRAFT_LOCKED_BY_ANOTHER_USER=The entity is locked by user "{0}"
 DRAFT_MODIFICATION_ONLY_VIA_ROOT=A draft can only be modified via its root entity
 

package/libx/_runtime/common/utils/cqn2cqn4sql.js

@@ -729,9 +729,6 @@ const _convertSelect = (query, model, _options) => {
     }
   }
 
-  // lambda functions
-  convertWhereExists(query.SELECT, model, options)
-
   // add 'or is null' in case of not equal: '!=' or '<>'
   if (query.SELECT._4odata) {
     _convertNotEqual(query.SELECT, 'where')
@@ -739,6 +736,9 @@ const _convertSelect = (query, model, _options) => {
   }
 
   _convertPathExpression(query, model, options)
+
+  convertWhereExists(query.SELECT, model, options)
+
   rewriteAsterisks(query, model, options)
   const entity =
     (query.SELECT.from.ref && (query.SELECT.from.ref[0].id || query.SELECT.from.ref[0])) || query.SELECT.from

package/libx/_runtime/db/query/update.js

@@ -1,48 +1,64 @@
 const cds = require('../../cds')
-
+const preservedSymbol = Symbol('preserved')
 const { hasDeepUpdate, getDeepUpdateCQNs, selectDeepUpdateData } = require('../../common/composition')
 const { getFlatArray, processCQNs } = require('../utils/deep')
 const normalizeTimestamp = require('../../common/utils/normalizeTimestamp')
+const onlyKeysRemain = require('../../common/utils/onlyKeysRemain')
+
+const isMoreThanManaged = (cqn, entity) => {
+  return (
+    cqn[preservedSymbol] ||
+    Object.keys(cqn.UPDATE.data).some(
+      key =>
+        !(key in entity.keys) &&
+        (entity.elements[key]['@cds.on.update'] === undefined || !cqn.UPDATE.data[key]?.startsWith('$'))
+    )
+  )
+}
 
-const _includesCompositionTarget = (cqns, target) => {
-  return cqns.find(cqn => {
-    return (cqn.UPDATE && cqn.UPDATE.entity === target) || (cqn.DELETE && cqn.DELETE.from === target)
-  })
+const isManaged = (cqn, entity) => {
+  return Object.keys(cqn.UPDATE.data).some(
+    key => entity.elements[key]['@cds.on.update'] && cqn.UPDATE.data[key] !== undefined
+  )
 }
 
 const _getFilteredCqns = (cqns, model) => {
   // right to left processing necessary!
-  // no need to process first (= root)
   for (let i = cqns.length - 1; i > 0; i--) {
     const cqn = cqns[i]
 
     const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
-    if (!entity) continue
-
-    // do not filter if:
-    // - there is a property that is not managed or managed but filled by custom handler (i.e., its value doesn't start
-    // with $) a composition target is updated as well
-    let moreThanManaged = Object.keys(cqn.UPDATE.data).some(
-      key => entity.elements[key]['@cds.on.update'] === undefined || !cqn.UPDATE.data[key]?.startsWith('$')
-    )
+    if (!entity) {
+      Object.defineProperty(cqn, preservedSymbol, { value: true })
+      continue
+    }
 
-    if (moreThanManaged) continue
+    // do not filter if there is a property that is not a key or managed by us (its value starts with $)
+    let moreThanManaged = isMoreThanManaged(cqn, entity)
 
-    const comps = Object.values(entity.associations || {}).filter(assoc => assoc.isComposition)
-    for (const comp of comps) {
-      if (_includesCompositionTarget(cqns, comp.target)) {
-        moreThanManaged = true
-        break
+    if (moreThanManaged) {
+      Object.defineProperty(cqn, preservedSymbol, { value: true })
+      const parentEntity = cqn.parent?.UPDATE && model.definitions[cqn.parent.UPDATE.entity]
+      if (parentEntity && isManaged(cqn.parent, parentEntity)) {
+        Object.defineProperty(cqn.parent, preservedSymbol, { value: true })
       }
+      continue
     }
+  }
 
-    if (moreThanManaged) continue
-
-    // remove current cqn
-    cqns.splice(i, 1)
+  const rootCqn = cqns[0]
+  if (rootCqn) {
+    // no need to process first (= root)
+    Object.defineProperty(rootCqn, preservedSymbol, { value: true })
   }
 
-  return cqns
+  return cqns.filter(cqn => {
+    const entity = model && cqn.UPDATE && model.definitions[cqn.UPDATE.entity]
+    if (entity && onlyKeysRemain({ query: cqn, target: entity, data: cqn.UPDATE.data })) {
+      return false
+    }
+    return cqn[preservedSymbol]
+  })
 }
 
 const update = executeUpdateCQN => async (model, dbc, req) => {
@@ -52,20 +68,22 @@ const update = executeUpdateCQN => async (model, dbc, req) => {
   if (model && hasDeepUpdate(model, query)) {
     // REVISIT: avoid additional read
     const selectData = await selectDeepUpdateData(cds.db, model, req)
-    let cqns = await getDeepUpdateCQNs(model, req, selectData)
+    const cqns = await getDeepUpdateCQNs(model, req, selectData)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []
     for (const each of cqns) chunks.push(each.filter(e => e.DELETE).length)
 
     // remove child queries that only want to update @cds.on.update properties
-    cqns = _getFilteredCqns(getFlatArray(cqns), model)
+    let _cqns = Array.from(cqns)
+    _cqns = getFlatArray(_cqns)
+    _cqns = _getFilteredCqns(_cqns, model)
 
-    if (cqns.length === 0) return 0
-    const results = await processCQNs(executeUpdateCQN, cqns, model, dbc, user, locale, isoTs, chunks)
+    if (_cqns.length === 0) return 0
+    const results = await processCQNs(executeUpdateCQN, _cqns, model, dbc, user, locale, isoTs, chunks)
 
     // return number of affected rows of "root cqn", if an update, 1 otherwise (as not update of root but its children)
-    if (cqns[0].UPDATE) return results[0]
+    if (_cqns[0].UPDATE) return results[0]
     return 1
   }
 

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

@@ -48,6 +48,10 @@ const _promiseAll = async array => {
 
 const _isCount = query => query.SELECT.columns?.length === 1 && query.SELECT.columns[0].func === 'count'
 
+const entity_keys = e => {
+  return Object_keys(e.keys).filter(k => k !== 'IsActiveEntity' && !e.keys[k].isAssociation)
+}
+
 const _inProcessByUserXpr = lockShiftedNow => ({
   xpr: [
     'case',
@@ -257,7 +261,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
           { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
         ])
     )
-    if (!res) req.reject(_etagValidationType ? 412 : 404)
+    if (!res) req.reject(_etagValidationType ? 412 : { code: 'DRAFT_NOT_EXISTING', status: 404 })
     if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id)
       req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [res.DraftAdministrativeData?.InProcessByUser])
     const DraftAdministrativeData_DraftUUID = res.DraftAdministrativeData_DraftUUID
@@ -265,11 +269,10 @@ cds.ApplicationService.prototype.handle = async function (req) {
     delete res.DraftAdministrativeData
     const HasActiveEntity = res.HasActiveEntity
     delete res.HasActiveEntity
-    delete res.IsActiveEntity
     // First run the handlers as they might need access to DraftAdministrativeData or the draft entities
     const result = await run(
       HasActiveEntity ? UPDATE(req.target).data(res).where(targetWhere) : INSERT.into(req.target).entries(res),
-      { headers: { 'if-match': '*' } }
+      { headers: Object.assign({}, req.headers, { 'if-match': '*' }) }
     )
     await _promiseAll([
       DELETE.from(targetDraft).where(targetWhere),
@@ -287,9 +290,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
   if (req.target.actions?.[req.event] && draftParams.IsActiveEntity === false) {
     if (query.SELECT?.from?.ref) query.SELECT.from.ref = _redirectRefToDrafts(query.SELECT.from.ref, this.model)
     const rootQuery = query.clone()
-    const columns = Object_keys(query._target.keys)
-      .filter(k => k !== 'IsActiveEntity')
-      .map(k => ({ ref: [k] }))
+    const columns = entity_keys(query._target).map(k => ({ ref: [k] }))
     columns.push({ ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] })
     rootQuery.SELECT.columns = columns
     rootQuery.SELECT.one = true
@@ -377,7 +378,7 @@ const Read = {
     if (query._target.name.endsWith('.DraftAdministrativeData')) return run(query._drafts)
     if (!query._target._isDraftEnabled) return run(query)
     if (!query.SELECT.groupBy && query.SELECT.columns && !query.SELECT.columns.some(c => c === '*')) {
-      const keys = Object_keys(query._target.keys).filter(k => k !== 'IsActiveEntity')
+      const keys = entity_keys(query._target)
       for (const key of keys) {
         if (!query.SELECT.columns.some(c => c.ref?.[0] === key)) query.SELECT.columns.push({ ref: [key] })
       }
@@ -409,11 +410,10 @@ const Read = {
   unchanged: async function (run, query) {
     LOG.debug('List Editing Status: Unchanged')
     const draftsQuery = query._drafts
-    const keys = Object_keys(query._target.keys).filter(k => k !== 'IsActiveEntity')
     draftsQuery.SELECT.count = undefined
-    draftsQuery.SELECT.limit = undefined
     draftsQuery.SELECT.orderBy = undefined
-    draftsQuery.SELECT.columns = keys.map(k => ({ ref: [k] }))
+    draftsQuery.SELECT.limit = false
+    draftsQuery.SELECT.columns = entity_keys(query._target).map(k => ({ ref: [k] }))
 
     const drafts = await draftsQuery.where({ HasActiveEntity: true })
     const res = await Read.onlyActives(run, query.where(Read.whereNotIn(query._target, drafts)), {
@@ -457,11 +457,10 @@ const Read = {
     LOG.debug('List Editing Status: All')
     if (!query._drafts) return []
     query._drafts.SELECT.count = false
-    query._drafts.SELECT.limit = undefined // We need all entries for the keys to properly select actives (count)
+    query._drafts.SELECT.limit = false // We need all entries for the keys to properly select actives (count)
     const isCount = _isCount(query._drafts)
     if (isCount) {
-      const keys = Object_keys(query._target.keys).filter(k => k !== 'IsActiveEntity')
-      query._drafts.SELECT.columns = keys.map(k => ({ ref: [k] }))
+      query._drafts.SELECT.columns = entity_keys(query._target).map(k => ({ ref: [k] }))
     }
     if (!query._drafts.SELECT.columns) query._drafts.SELECT.columns = ['*']
     if (!query._drafts.SELECT.columns.some(c => c.ref?.[0] === 'HasActiveEntity'))
@@ -525,13 +524,14 @@ const Read = {
   },
   activesFromDrafts: async function (run, query, { isLocked = true }) {
     const draftsQuery = query._drafts
-    const keys = Object_keys(query._target.keys).filter(k => k !== 'IsActiveEntity')
     const additionalCols = draftsQuery.SELECT.columns
       ? draftsQuery.SELECT.columns.filter(
           c => c.ref && ['DraftAdministrativeData', 'DraftAdministrativeData_DraftUUID'].includes(c.ref[0])
         )
       : [{ ref: ['DraftAdministrativeData_DraftUUID'] }]
-    draftsQuery.SELECT.columns = keys.map(k => ({ ref: [k] })).concat(additionalCols)
+    draftsQuery.SELECT.columns = entity_keys(query._target)
+      .map(k => ({ ref: [k] }))
+      .concat(additionalCols)
     draftsQuery.where({
       HasActiveEntity: true,
       'DraftAdministrativeData.InProcessByUser': { '!=': cds.context.user.id },
@@ -560,7 +560,7 @@ const Read = {
   },
   whereNotIn: (target, data) => Read.whereIn(target, data, true),
   whereIn: (target, data, not = false) => {
-    const keys = Object_keys(target.keys).filter(k => k !== 'IsActiveEntity')
+    const keys = entity_keys(target)
     const dataArray = data ? (Array.isArray(data) ? data : [data]) : []
     if (not && !dataArray.length) return []
     const left = { list: keys.map(k => ({ ref: [k] })) }
@@ -573,9 +573,7 @@ const Read = {
     if (!actives.length) return []
     const drafts = cds.ql.clone(query._drafts)
     drafts.SELECT.where = Read.whereIn(query._target, actives)
-    const newColumns = Object_keys(query._target.keys)
-      .filter(k => k !== 'IsActiveEntity')
-      .map(k => ({ ref: [k] }))
+    const newColumns = entity_keys(query._target).map(k => ({ ref: [k] }))
     if (
       !drafts.SELECT.columns ||
       drafts.SELECT.columns.some(c => c === '*' || c.ref?.[0] === 'DraftAdministrativeData_DraftUUID')
@@ -594,8 +592,10 @@ const Read = {
     // Indexes the data for fast key access
     const dataArray = Read._makeArray(data)
     if (!dataArray.length) return
-    const _keys = Object_keys(target.keys).filter(k => k !== 'IsActiveEntity')
-    const hash = row => _keys.map(k => row[k]).reduce((res, curr) => res + '|$|' + curr, '')
+    const hash = row =>
+      entity_keys(target)
+        .map(k => row[k])
+        .reduce((res, curr) => res + '|$|' + curr, '')
     const hashMap = new Map()
     for (const row of dataArray) hashMap.set(hash(row), row)
     return { hashMap, hash }
@@ -1053,7 +1053,7 @@ async function onCancel(req) {
     )
   else
     queries.push(
-      UPDATE('Draft.DraftAdministrativeData')
+      UPDATE('DRAFT.DraftAdministrativeData')
         .data({
           InProcessByUser: cds.context.user.id,
           LastChangedByUser: cds.context.user.id,
@@ -1074,12 +1074,11 @@ async function onPrepare(req) {
   }
   const where = req.query.SELECT.from.ref[0].where
 
-  const keys = Object_keys(req.target.keys).filter(k => k !== 'IsActiveEntity')
   const draftQuery = SELECT.one
     .from(req.target, d => {
       d.DraftAdministrativeData(a => a.InProcessByUser)
     })
-    .columns(keys)
+    .columns(entity_keys(req.target))
     .where(where)
   draftQuery[DRAFT_PARAMS] = draftParams
   const data = await draftQuery

package/libx/_runtime/hana/conversion.js

@@ -21,15 +21,16 @@ const convertInt64ToString = int64 => {
 const convertToISO = element => {
   if (!element) return null
 
+  let dateTime = element.replace(' ', 'T')
   if (cds.env.features.precise_timestamps) {
-    const dateTime = element.slice(0, 19).replace(' ', 'T')
+    dateTime = dateTime.slice(0, 19)
     let millis = element.slice(20)
     if (millis.at(-1) === 'Z') millis = millis.slice(0, -1)
     millis = millis.slice(0, 7).padEnd(7, '0')
     return dateTime + '.' + millis + 'Z'
   }
 
-  return new Date(element + 'Z').toISOString()
+  return new Date(dateTime + 'Z').toISOString()
 }
 
 const convertToISONoMillis = element => {

package/libx/_runtime/messaging/enterprise-messaging-utils/getTenantInfo.js

@@ -4,7 +4,7 @@ const _transform = o => ({ subdomain: o.subscribedSubdomain, tenant: o.subscribe
 // REVISIT: Looks ugly -> can we simplify that?
 const getTenantInfo = async tenant => {
   const provisioning = await cds.connect.to('cds.xt.SaasProvisioningService')
-  const tx = provisioning.tx({ user: new cds.User.Privileged() })
+  const tx = provisioning.tx({ user: cds.User.privileged })
   try {
     const result = tenant
       ? _transform(await tx.get('/tenant', { ['subscribedTenantId']: tenant }))

package/libx/_runtime/messaging/outbox/utils.js

@@ -99,7 +99,7 @@ const processMessages = async (service, tenant, _opts = {}) => {
 
   outboxRunner.run({ name, tenant }, () => {
     let letAppCrash = false
-    const config = tenant ? { tenant, user: new cds.User.Privileged() } : { user: new cds.User.Privileged() }
+    const config = tenant ? { tenant, user: cds.User.privileged } : { user: cds.User.privileged }
     const spawn = cds.spawn(async () => {
       let messages
       try {