@sap/cds 9.4.4 → 9.5.1

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

@@ -0,0 +1,220 @@
+const cds = require('@sap/cds')
+const getTemplate = require('../utils/template')
+const templatePathSerializer = require('../utils/templateProcessorPathSerializer')
+
+const $has_asserts = Symbol.for('has_asserts')
+
+const { compileUpdatedDraftMessages } = require('../../fiori/lean-draft')
+
+const _serialize = obj =>
+  JSON.stringify(
+    Object.keys(obj)
+      .sort()
+      .reduce((a, k) => ((a[k] = obj[k]), a), {})
+  )
+
+const _bufferReviver = (key, value) => {
+  if (value && typeof value === 'object' && value.type === 'Buffer' && Array.isArray(value.data)) {
+    return Buffer.from(value.data)
+  }
+  return value
+}
+
+module.exports = cds.service.impl(async function () {
+  this.after(['INSERT', 'UPSERT', 'UPDATE'], async (res, req) => {
+    if (!($has_asserts in req.target)) {
+      let has_asserts = false
+      for (const each in req.target.elements) {
+        const element = req.target.elements[each]
+        if (element['@assert']) {
+          has_asserts = true
+          break
+        }
+      }
+      req.target[$has_asserts] = has_asserts
+    }
+
+    if (!cds.context?.tx || !req.target[$has_asserts]) return
+
+    const IS_DRAFT_ENTITY = req.target.isDraft
+
+    if (req.event === 'CREATE' && IS_DRAFT_ENTITY) return
+
+    let touched
+    if (cds.env.features.assert_touched_only !== false && IS_DRAFT_ENTITY && req.event === 'UPDATE')
+      touched = Object.keys(res).filter(k => !(k in req.target.keys))
+
+    const template = getTemplate('assert', this, req.target, {
+      pick: element => element['@assert'],
+      ignore: element => element.isAssociation && !element.isComposition
+    })
+
+    if (!cds.context.tx.changes) {
+      cds.context.tx.changes = {}
+
+      req.before('commit', async function () {
+        const { changes } = cds.context.tx
+
+        const errors = []
+
+        for (const [entityName, serializedChanges] of Object.entries(changes)) {
+          if (!serializedChanges.size) continue
+
+          const deserializedChanges = Array.from(serializedChanges).map(([k, v]) => [JSON.parse(k, _bufferReviver), v])
+
+          const entity = cds.model.definitions[entityName]
+          const IS_DRAFT_ENTITY = entity.isDraft
+
+          // Cache assert query on entity
+          if (!Object.hasOwn(entity, 'assert')) {
+            const asserts = []
+
+            for (const element of Object.values(entity.elements)) {
+              if (element._foreignKey4) continue
+              if (element.isAssociation && !element.isComposition) continue
+
+              const assert = element['@assert']
+              if (!assert) continue
+
+              // replace $self with $main
+              const xpr = JSON.parse(JSON.stringify(assert.xpr).replace(/\$self/g, '$main'))
+
+              asserts.push({ xpr, as: '@assert:' + element.name })
+            }
+
+            entity.assert = cds.ql.SELECT([...Object.keys(entity.keys), ...asserts]).from(entity)
+          }
+
+          const query = cds.ql.clone(entity.assert)
+
+          // Select only rows with changes
+          const keyNames = Object.keys(entity.keys).filter(
+            k => !entity.keys[k].virtual && !entity.keys[k].isAssociation
+          )
+          const keyMap = Object.fromEntries(keyNames.map(k => [k, true]))
+
+          query.where([
+            { list: keyNames.map(k => ({ ref: [k] })) },
+            'in',
+            { list: deserializedChanges.map(([keyKV]) => ({ list: keyNames.map(k => ({ val: keyKV[k] })) })) }
+          ])
+
+          const results = await query
+
+          for (const row of results) {
+            const keyColumns = Object.fromEntries(Object.entries(row).filter(([k]) => k in keyMap))
+            const { touched, req, pathSegmentsInfo } = serializedChanges.get(_serialize(keyColumns))
+            const failedColumns = Object.entries(row)
+              .filter(([k, v]) => v !== null && !(k in keyMap))
+              .map(([k, v]) => [k.replace(/^@assert:/, ''), v])
+
+            if (failedColumns.length === 0) continue
+
+            const failedAsserts = failedColumns.map(([element, message]) => {
+              const error = {
+                code: 'ASSERT',
+                target: element,
+                numericSeverity: 4,
+                '@Common.numericSeverity': 4
+              }
+
+              // if error function was used in @assert expression -> use its output
+              try {
+                // Depending on DB, function result may be JavaScript Object or JSON String
+                const parsed = typeof message === 'string' ? JSON.parse(message) : message
+                Object.assign(error, parsed)
+                if (Array.isArray(error.targets)) {
+                  const target = error.targets.at(0)
+                  const additionalTargets = error.targets.slice(1)
+                  if (target) error.target = target
+                  if (additionalTargets.length) error.additionalTargets = additionalTargets
+                }
+                delete error.targets
+              } catch {
+                error.message = message
+              }
+
+              return error
+            })
+
+            if (IS_DRAFT_ENTITY) {
+              const draft = await SELECT.one
+                .from({ ref: [req.subject.ref[0]] })
+                .columns('DraftAdministrativeData_DraftUUID', 'DraftAdministrativeData.DraftMessages')
+              const persistedMessages = draft.DraftAdministrativeData_DraftMessages || []
+
+              // keep all messages that have targets that were touched in this change
+              const newMessages = touched
+                ? failedAsserts.filter(a => {
+                    const targets = [a.target].concat(a.additionalTargets || [])
+                    return touched.some(t => targets.includes(t))
+                  })
+                : failedAsserts
+
+              const nextDraftMessages = compileUpdatedDraftMessages(
+                newMessages,
+                persistedMessages,
+                req.data,
+                req.subject.ref
+              )
+
+              await UPDATE('DRAFT.DraftAdministrativeData')
+                .set({ DraftMessages: nextDraftMessages })
+                .where({ DraftUUID: draft.DraftAdministrativeData_DraftUUID })
+            } else {
+              const isDraftAction = req._.event?.startsWith('draft')
+              const prefix = templatePathSerializer('', pathSegmentsInfo)
+              failedAsserts.forEach(err => {
+                err.target = (isDraftAction ? 'in/' : '') + prefix + err.target
+              })
+
+              errors.push(...failedAsserts)
+            }
+          }
+        }
+
+        if (errors.length) {
+          if (errors.length === 1) throw errors[0]
+          const err = new cds.error('MULTIPLE_ERRORS', { details: errors })
+          delete err.stack
+          throw err
+        }
+      })
+    }
+
+    const templateProcessOptions = {
+      pathSegmentsInfo: [],
+      includeKeyValues: true
+    }
+    if (req._.event?.startsWith('draft')) {
+      const IsActiveEntity = req.data.IsActiveEntity || false
+      templateProcessOptions.draftKeys = { IsActiveEntity }
+    }
+    // Collect entity keys and their values of changed rows
+    template.process(
+      req.data,
+      elementInfo => {
+        const { row, target, pathSegmentsInfo } = elementInfo
+        const targetName = target.name
+
+        cds.context.tx.changes[targetName] ??= new Map()
+
+        const keys = {}
+        for (const key in target.keys) {
+          if (key === 'IsActiveEntity') continue
+          if (!(key in row)) continue
+          keys[key] = row[key]
+        }
+
+        if (!Object.keys(keys).length) return
+
+        const serialized = _serialize(keys)
+        const changes = cds.context.tx.changes[targetName]
+        if (changes.has(serialized)) return
+
+        changes.set(serialized, { touched, req, pathSegmentsInfo: [...pathSegmentsInfo] })
+      },
+      templateProcessOptions
+    )
+  })
+})

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

@@ -5,12 +5,10 @@ const { getFrom } = require('../../../../lib/compile/for/flows')
 const FLOW_STATUS = '@flow.status'
 const FROM = '@from'
 const TO = '@to'
-// backwards compat
-const FLOW_FROM = '@flow.from'
-const FLOW_TO = '@flow.to'
-
 const FLOW_PREVIOUS = '$flow.previous'
 
+const $transitions_ = Symbol.for('transitions_')
+
 function buildAllowedCondition(action, statusElementName, statusEnum) {
   const fromList = getFrom(action)
   const conditions = fromList.map(from => {
@@ -20,154 +18,216 @@ function buildAllowedCondition(action, statusElementName, statusEnum) {
   return `(${conditions.join(' OR ')})`
 }
 
-async function isCurrentStatusInFrom(req, action, statusElementName, statusEnum) {
+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(req.subject).where(parsedXpr)
+  const dbEntity = await SELECT.one.from(subject).where(parsedXpr)
   return dbEntity !== undefined
 }
 
-async function checkStatus(req, action, statusElementName, statusEnum) {
-  const allowed = await isCurrentStatusInFrom(req, action, statusElementName, statusEnum)
+async function checkStatus(subject, action, statusElementName, statusEnum) {
+  const allowed = await isCurrentStatusInFrom(subject, action, statusElementName, statusEnum)
   if (!allowed) {
     const from = getFrom(action)
     const fromValues = JSON.stringify(from.flatMap(el => Object.values(el)))
     cds.error({
-      code: 409,
+      status: 409,
       message: from.length > 1 ? 'INVALID_FLOW_TRANSITION_MULTI' : 'INVALID_FLOW_TRANSITION_SINGLE',
       args: [action.name, statusElementName, fromValues]
     })
   }
 }
 
-const buildUpKeys = parentKeys => {
+// REVISIT: what about renamed keys?
+const buildUpKeys = async (entity, data, subject) => {
+  const parentKeys = Object.keys(entity.keys).filter(k => k !== 'IsActiveEntity')
+  // REVISIT: when do we not hava all keys?
+  const keyValues =
+    data && parentKeys.every(key => key in data) ? data : await SELECT.one.from(subject).columns(parentKeys)
   const upKeys = {}
-  for (const key in parentKeys) {
-    upKeys[`up__${key}`] = parentKeys[key]
+  for (let i = 0; i < parentKeys.length; i++) {
+    upKeys[`up__${parentKeys[i]}`] = keyValues[parentKeys[i]]
   }
   return upKeys
 }
 
-const updateFlowHistory = async (req, toValue, upKeys, changes, isPrevious) => {
-  if (cds.env.features.flows_history_stack && isPrevious) {
-    await DELETE.from(req.target.compositions['transitions_'].target).where({
-      timestamp: changes[changes.length - 1].timestamp
-    })
+const resolveTo = (action, statusEnum) => {
+  let to = action[TO]
+  to = to['#'] ? (statusEnum[to['#']].val ?? statusEnum[to['#']]['$path'].at(-1)) : to
+  return to
+}
+
+const handleTransition = async (entity, data, subject, to) => {
+  const isPrevious = to['='] === FLOW_PREVIOUS
+  if (isPrevious) {
+    const upKeys = await buildUpKeys(entity, data, subject)
+    const previous = await SELECT.one
+      .from(entity[$transitions_].target)
+      .where({ ...upKeys })
+      .orderBy('timestamp desc')
+      .limit(1, 1)
+    if (!previous)
+      cds.error({ status: 409, message: 'No change has been made yet, cannot transition to previous status.' })
+    to = previous.status
+  }
+  return to
+}
+
+const getStatusInfo = statusElement => {
+  let statusEnum, statusElementName
+  if (statusElement.enum) {
+    statusEnum = statusElement.enum
+    statusElementName = statusElement.name
+  } else if (statusElement?._target?.elements['code']) {
+    statusEnum = statusElement._target.elements['code'].enum
+    statusElementName = statusElement.name + '_code'
   } else {
-    await INSERT.into(req.target.compositions['transitions_'].target).entries({
-      ...upKeys,
-      status: toValue
+    cds.error({
+      status: 409,
+      message: `Status element in ${statusElement.parent.name} must be an enum or target an entity with an enum named "code"`
     })
   }
+  return { statusEnum, statusElementName }
 }
 
-const buildToKey = (action, statusEnum) => {
-  const to = action[TO] ?? action[FLOW_TO]
-  const toKey = to['#'] ? (statusEnum[to['#']].val ?? statusEnum[to['#']]['$path'].at(-1)) : to
-  return toKey
+const from_factory = (entity, action, { statusElementName, statusEnum }) => {
+  async function handle_flow_from(req) {
+    const subject = cds.clone(req.subject)
+    if (entity.name.endsWith('.drafts')) subject.ref[0].id = entity.name
+
+    await checkStatus(subject, action, statusElementName, statusEnum)
+  }
+  handle_flow_from._initial = true
+  return handle_flow_from
 }
 
-const handleStatusTransitionWithHistory = async (req, statusElementName, toKey, service) => {
-  let upKeys, changes
-  upKeys = buildUpKeys(req.params[0])
-  changes = await SELECT.from(req.target.compositions['transitions_'].target)
-    .where({ ...upKeys })
-    .orderBy('timestamp asc')
-  const isPrevious = toKey['='] === FLOW_PREVIOUS
-  if (isPrevious) {
-    if (changes.length <= 1)
-      return cds.error({ code: 409, message: 'No change has been made yet, cannot transition to previous status.' })
-    toKey = changes[changes.length - 2].status
+const to___factory = (entity, action, { statusElementName, statusEnum }) => {
+  return async function handle_flow_to(req, next) {
+    const res = await next()
+
+    let subject = cds.clone(req.subject)
+    if (entity.name.endsWith('.drafts')) subject.ref[0].id = entity.name
+
+    // REVISIT: this only happens on CREATE, where req.subject is a collection
+    //          -> could be avoided if setting the status would be done via req.data
+    if (!subject.ref[0].id) {
+      const keys = Object.keys(entity.keys).reduce((acc, cur) => {
+        acc[cur] = res[cur]
+        return acc
+      }, {})
+      subject = SELECT.from(entity.name, keys).SELECT.from
+    }
+
+    let to = resolveTo(action, statusEnum)
+
+    if (Object.prototype.hasOwnProperty.call(entity, $transitions_)) {
+      to = await handleTransition(entity, req.data, subject, to)
+    }
+
+    await UPDATE(subject).with({ [statusElementName]: to })
+
+    // REVISIT: for stack, we now need to delete the last to transitions
+    if (cds.env.features.flows_history_stack && resolveTo(action, statusEnum)['='] === FLOW_PREVIOUS) {
+      const upKeys = await buildUpKeys(entity, req.data, req.subject)
+      const timestamps = SELECT('timestamp')
+        .from(entity[$transitions_].target)
+        .where({ ...upKeys })
+        .orderBy('timestamp desc')
+        .limit(2)
+      await DELETE.from(entity[$transitions_].target)
+        .where({ ...upKeys })
+        .where(`timestamp in`, timestamps)
+    }
+
+    return res
   }
-  await service.run(UPDATE(req.subject).with({ [statusElementName]: toKey }))
-  await updateFlowHistory(req, toKey, upKeys, changes, isPrevious)
 }
 
 /**
  * handler registration
  */
 module.exports = cds.service.impl(function () {
-  const entry = []
-  const exit = []
+  const b4 = []
+  const on = []
+  const after = []
 
   for (const entity of this.entities) {
     if (!entity.actions || !entity.elements) continue
 
-    const fromActions = []
-    const toActions = []
-    for (const action of entity.actions) {
-      if (action[FROM] || action[FLOW_FROM]) fromActions.push(action)
-      if (action[TO] || action[FLOW_TO]) toActions.push(action)
-    }
-    if (fromActions.length === 0 && toActions.length === 0) continue
-
-    let statusElement = Object.values(entity.elements).find(el => el[FLOW_STATUS])
-    if (!statusElement) {
-      cds.error({
-        code: 409,
-        message: `Entity ${entity.name} does not have a status element, but its actions have registered @flow annotations.`
+    const statusElement = Object.values(entity.elements).find(el => el[FLOW_STATUS])
+    if (!statusElement) continue
+
+    const statusInfo = getStatusInfo(statusElement)
+
+    // determine and cache target for transitions recording, if any
+    let base = entity
+    while (base.__proto__.kind === 'entity') base = base.__proto__
+    if (base.compositions?.transitions_) {
+      entity[$transitions_] = base.compositions.transitions_
+      // track changes on db level
+      cds.connect.to('db').then(db => {
+        db.after(['CREATE', 'UPDATE', 'UPSERT'], entity, async (res, req) => {
+          if ((res.affectedRows ?? res) !== 1) return
+          if (!(statusInfo.statusElementName in req.data)) return
+          const status = req.data[statusInfo.statusElementName]
+          const upKeys = await buildUpKeys(entity, req.data, req.subject)
+          const last = await SELECT.one.from(entity[$transitions_].target).orderBy('timestamp desc').where(upKeys)
+          if (last?.status !== status) await UPSERT.into(entity[$transitions_].target).entries({ ...upKeys, status })
+        })
       })
     }
 
-    let statusEnum, statusElementName
-    if (statusElement.enum) {
-      statusEnum = statusElement.enum
-      statusElementName = statusElement.name
-    } else if (statusElement?._target?.elements['code']) {
-      statusEnum = statusElement._target.elements['code'].enum
-      statusElementName = statusElement.name + '_code'
-    } else {
-      cds.error({
-        code: 409,
-        message: `Status element in entity ${entity.name} is not an enum and does not have a valid target with code enum.`
-      })
+    // register handlers
+    for (const action of entity.actions) {
+      const to__ = action[TO]
+      const from = action[FROM]
+
+      // REVISIT: for CRUD and Draft, we could set status in before handlers (on db level) to save roundtrips
+      switch (action.name) {
+        // CRUD
+        case 'CREATE':
+          if (to__) on.push([action.name, entity, to___factory(entity, action, statusInfo)])
+          break
+        case 'READ':
+          // nothing to do
+          break
+        case 'UPDATE':
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          if (to__) on.push([action.name, entity, to___factory(entity, action, statusInfo)])
+          break
+        case 'DELETE':
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          break
+        // Draft
+        case 'NEW':
+          if (to__) on.push(['CREATE', entity.drafts, to___factory(entity.drafts, action, statusInfo)])
+          break
+        case 'PATCH':
+          if (from) b4.push(['UPDATE', entity.drafts, from_factory(entity.drafts, action, statusInfo)])
+          if (to__) on.push(['UPDATE', entity.drafts, to___factory(entity.drafts, action, statusInfo)])
+          break
+        case 'SAVE':
+          if (from) b4.push([action.name, entity.drafts, from_factory(entity.drafts, action, statusInfo)])
+          if (to__) on.push([action.name, entity.drafts, to___factory(entity, action, statusInfo)])
+          break
+        case 'EDIT':
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          if (to__) on.push([action.name, entity, to___factory(entity.drafts, action, statusInfo)])
+          break
+        case 'DISCARD':
+          if (from) b4.push([action.name, entity.drafts, from_factory(entity.drafts, action, statusInfo)])
+          break
+        // custom actions
+        default:
+          if (from) b4.push([action.name, entity, from_factory(entity, action, statusInfo)])
+          if (to__) on.push([action.name, entity, to___factory(entity, action, statusInfo)])
+      }
     }
-
-    entry.push({ events: fromActions, entity, statusElementName, statusEnum })
-    exit.push({ events: toActions, entity, statusElementName, statusEnum })
   }
 
   this.prepend(function () {
-    for (const each of entry) {
-      this.before(
-        each.events,
-        each.entity,
-        Object.assign(
-          async function handle_entry_state(req) {
-            const action = req.target.actions[req.event]
-            await checkStatus(req, action, each.statusElementName, each.statusEnum)
-          },
-          { _initial: true }
-        )
-      )
-    }
-
-    for (const each of exit) {
-      async function handle_after_create(res, req) {
-        const parentKeys = Object.keys(req.target.keys)
-        const entry = {}
-        for (let i = 0; i < parentKeys.length; i++) {
-          entry[`up__${parentKeys[i]}`] = req.data[parentKeys[i]]
-        }
-        await INSERT.into(req.target.compositions['transitions_'].target).entries({
-          ...entry,
-          status: res[each.statusElementName]
-        })
-      }
-      if ('transitions_' in (each.entity.compositions ?? {})) this.after('CREATE', each.entity, handle_after_create)
-
-      async function handle_exit_state(req, next) {
-        const res = await next()
-        const action = req.target.actions[req.event]
-        let toKey = buildToKey(action, each.statusEnum)
-        if ('transitions_' in (req.target.compositions ?? {})) {
-          await handleStatusTransitionWithHistory(req, each.statusElementName, toKey, this)
-        } else {
-          await this.run(UPDATE(req.subject).with({ [each.statusElementName]: toKey }))
-        }
-        return res
-      }
-      this.on(each.events, each.entity, handle_exit_state)
-    }
+    for (const each of b4) this.before(...each)
+    for (const each of on) this.on(...each)
+    for (const each of after) this.after(...each)
   })
 })

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

@@ -327,6 +327,10 @@ const _pick = element => {
   if (categories.length) return { categories }
 }
 
+// List of validation error codes that should cause an early rejection of the request
+// > If one of these codes is found, the request will be rejected right after validation
+const EARLY_REJECT_CODES = { ASSERT_DATA_TYPE: 1, ASSERT_MANDATORY: 1, ASSERT_NOT_NULL: 1 }
+
 async function validate_input(req) {
   if (!req.target || req.target._unresolved) return // Validation requires resolved targets
   if (req.event === 'CREATE' && req.target.isDraft) return // already handled in `NEW`, no need in `EDIT`
@@ -357,8 +361,7 @@ async function validate_input(req) {
   const errs = cds.validate(req.data, req.target, assertOptions)
   if (errs) {
     errs.forEach(err => req.error(err))
-    // data types are incorrect -> stop further processing which could rely on data type
-    if (errs.some(e => e.message === 'ASSERT_DATA_TYPE')) req.reject()
+    if (errs.some(e => e.message in EARLY_REJECT_CODES)) req.reject()
     else return
   }
 
@@ -406,8 +409,7 @@ function validate_action(req) {
   let errs = cds.validate(data, operation, assertOptions)
   if (errs) {
     errs.forEach(err => req.error(err))
-    // data types are incorrect -> stop further processing which could rely on data type
-    if (errs.some(e => e.message === 'ASSERT_DATA_TYPE')) req.reject()
+    if (errs.some(e => e.message in EARLY_REJECT_CODES)) req.reject()
     else return
   }
 

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

@@ -2,28 +2,6 @@ const cds = require('../../cds')
 const { SELECT } = cds.ql
 const { setEntityContained } = require('./csn')
 
-const getEntityNameFromDeleteCQN = cqn => {
-  let from
-  if (cqn && cqn.DELETE && cqn.DELETE.from) {
-    if (typeof cqn.DELETE.from === 'string') {
-      from = cqn.DELETE.from
-    } else if (cqn.DELETE.from.name) {
-      from = cqn.DELETE.from.name
-    } else if (cqn.DELETE.from.ref && cqn.DELETE.from.ref.length === 1) {
-      from = cqn.DELETE.from.ref[0]
-    }
-  }
-  return from
-}
-
-const getEntityNameFromUpdateCQN = cqn => {
-  return (
-    (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0] && (cqn.UPDATE.entity.ref[0].id || cqn.UPDATE.entity.ref[0])) ||
-    cqn.UPDATE.entity.name ||
-    cqn.UPDATE.entity
-  )
-}
-
 // scope: simple wheres à la "[{ ref: ['foo'] }, '=', { val: 'bar' }, 'and', ... ]"
 function where2obj(where, target = null, data = {}) {
   for (let i = 0; i < where.length; ) {
@@ -89,8 +67,6 @@ const resolveFromSelect = query => {
 }
 
 module.exports = {
-  getEntityNameFromDeleteCQN,
-  getEntityNameFromUpdateCQN,
   where2obj,
   targetFromPath,
   resolveFromSelect

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

@@ -11,7 +11,7 @@ module.exports = value => {
   if (typeof value === 'number') value = new Date(value).toISOString()
   if (typeof value !== 'string') {
     const msg = `Value "${value}" is not a valid Timestamp`
-    throw Object.assign(new Error(msg), { statusCode: 400 })
+    cds.error({ status: 400, message: msg })
   }
 
   const decimalPointIndex = _lengthIfNotFoundIndex(value.lastIndexOf('.'), value.length)
@@ -22,7 +22,7 @@ module.exports = value => {
   let dt = new Date(value.slice(0, dateEndIndex) + tz)
   if (isNaN(dt)) {
     const msg = `Value "${value}" is not a valid Timestamp`
-    throw Object.assign(new Error(msg), { statusCode: 400 })
+    cds.error({ status: 400, message: msg })
   }
   const dateNoMillisNoTZ = dt.toISOString().slice(0, 19)
   const normalizedFractionalDigits = value

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

@@ -473,8 +473,14 @@ const _newDelete = (query, transitions, options) => {
     : targetName
 
   if (newDelete.where) {
-    const from = typeof query.DELETE.from === 'string' ? query.DELETE.from : query.DELETE.from.ref[0]
-    newDelete.where = _newWhere(newDelete.where, targetTransition, from, query.DELETE.from.as, undefined, options)
+    newDelete.where = _newWhere(
+      newDelete.where,
+      targetTransition,
+      query.DELETE.from.ref[0],
+      query.DELETE.from.as,
+      undefined,
+      options
+    )
   }
 
   return newDelete