@sap/cds 5.7.5 → 5.8.2

package/libx/_runtime/common/composition/delete.js

@@ -5,6 +5,9 @@ const ctUtils = require('./utils')
 
 const { ensureNoDraftsSuffix } = require('../utils/draft')
 const { getEntityNameFromDeleteCQN } = require('../utils/cqn')
+const { cqn2cqn4sql } = require('../utils/cqn2cqn4sql')
+const { getComp2oneParents } = require('../utils/csn')
+const getColumns = require('../../db/utils/columns')
 
 /*
  * own utils
@@ -13,19 +16,21 @@ const { getEntityNameFromDeleteCQN } = require('../utils/cqn')
 // Poor man's alias algorithm
 // REVISIT: Extract and adapt the alias functionality from `expandCQNToJoin.js`: _adaptWhereOrderBy
 const _recursivelyAliasRefs = (something, newAlias, oldAlias, subselect = false) => {
-  if (Array.isArray(something)) {
-    for (const s of something) _recursivelyAliasRefs(s, newAlias, oldAlias, subselect)
-  } else if (typeof something === 'object') {
-    if (Array.isArray(something.ref)) {
+  if (Array.isArray(something)) return something.map(s => _recursivelyAliasRefs(s, newAlias, oldAlias, subselect))
+  if (typeof something === 'object') {
+    if (something.ref) {
+      something = { ref: [...something.ref] }
       if (oldAlias && something.ref[0] === oldAlias) something.ref[0] = newAlias
       else if (!subselect) something.ref.unshift(newAlias)
     } else {
+      something = Object.assign({}, something)
       for (const key in something) {
-        if (key === 'from') continue // Workaround: Deep delete to be rewritten
-        _recursivelyAliasRefs(something[key], newAlias, oldAlias, subselect || key === 'SELECT')
+        if (key === 'from' || key === 'val') continue // Workaround: Deep delete to be rewritten
+        something[key] = _recursivelyAliasRefs(something[key], newAlias, oldAlias, subselect || key === 'SELECT')
       }
     }
   }
+  return something
 }
 
 function _getSubWhereAndEntities(element, parentWhere, draft, level = 0, compositionTree = {}) {
@@ -88,7 +93,7 @@ function _getSubWhereAndEntities(element, parentWhere, draft, level = 0, composi
     SELECT: {
       columns: [{ val: 1, as: '_exists' }],
       from: { ref: [entity2.entityName], as: entity2.alias },
-      where: parentWhere ? ['(', ...parentWhere, ')', 'and', '(', ...subWhere, ')'] : subWhere
+      where: parentWhere && parentWhere.length ? ['(', ...parentWhere, ')', 'and', '(', ...subWhere, ')'] : subWhere
     }
   })
 
@@ -130,18 +135,18 @@ function _getStaticWhere(allBackLinks, entity1) {
   }, [])
 }
 
-const _is2oneComposition = (element, definitions) => {
-  const csnElement = element.target && definitions[element.target].elements[element.name]
+const _is2oneComposition = (element, model) => {
+  const csnElement = element.target && model.definitions[element.target].elements[element.name]
   return csnElement && csnElement.is2one && csnElement._isCompositionEffective
 }
 
-const _addToCQNs = (cqns, subCQN, element, definitions, level) => {
+const _addToCQNs = (cqns, subCQN, element, model, level) => {
   cqns[level] = cqns[level] || []
   // Since `>2.5.2` compiler generates constraints for compositions of one like for annotations
   // Thus only single 2one case (`$self`-managed composition) has DELETE CASCADE
   // Here it's ignored to simplify i.e. handle all "2ones" in a same manner
   // REVISIT: why is _db_foreign_key_constraints necessary?
-  if (!cds.env.features._db_foreign_key_constraints || _is2oneComposition(element, definitions)) {
+  if (!cds.env.features._db_foreign_key_constraints || _is2oneComposition(element, model)) {
     cqns[level].push(subCQN)
   }
 }
@@ -150,15 +155,7 @@ const _addToCQNs = (cqns, subCQN, element, definitions, level) => {
 const DEEP_DELETE_MAX_RECURSION_DEPTH =
   (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 2
 
-const _addSubCascadeDeleteCQN = (
-  definitions,
-  compositionTree,
-  parentWhere,
-  level,
-  cqns,
-  draft,
-  elementMap = new Map()
-) => {
+const _addSubCascadeDeleteCQN = (model, compositionTree, parentWhere, level, cqns, draft, elementMap = new Map()) => {
   for (const element of compositionTree.compositionElements) {
     if (element.skipPersistence) continue
 
@@ -176,13 +173,13 @@ const _addSubCascadeDeleteCQN = (
     if (where.length) {
       const subCQN = { DELETE: { from: { ref: [entity1.entityName], as: entity1.alias }, where: where } }
 
-      _addToCQNs(cqns, subCQN, element, definitions, level)
+      _addToCQNs(cqns, subCQN, element, model, level)
 
       // Make a copy and do not share the same map among brother compositions
       // as we're only interested in deep recursions, not wide recursions.
       const newElementMap = new Map(elementMap)
       newElementMap.set(fqn, (seen && seen + 1) || 1)
-      _addSubCascadeDeleteCQN(definitions, element, subCQN.DELETE.where, level + 1, cqns, draft, newElementMap)
+      _addSubCascadeDeleteCQN(model, element, subCQN.DELETE.where, level + 1, cqns, draft, newElementMap)
     }
   }
 
@@ -193,7 +190,7 @@ const _addSubCascadeDeleteCQN = (
  * exports
  */
 
-const hasDeepDelete = (definitions, cqn) => {
+const hasDeepDelete = (model, cqn) => {
   const from = getEntityNameFromDeleteCQN(cqn)
   if (!from) return false
 
@@ -201,66 +198,118 @@ const hasDeepDelete = (definitions, cqn) => {
   // Hence, we do not need a deep delete in that case.
   if (cqn._suppressDeepDelete) return false
 
-  const entity = definitions && definitions[ensureNoDraftsSuffix(from)]
+  const entity = model.definitions[ensureNoDraftsSuffix(from)]
 
   if (entity) return !!Object.keys(entity.elements || {}).find(k => entity.elements[k]._isCompositionEffective)
 
   return false
 }
 
-const _getSetNullParentForeignKeyCQNs = (definitions, entityName, parentWhere, draft) => {
-  const setNullCQNs = []
-  for (const { elements } of definitions[entityName].__oneCompositionParents.values()) {
-    for (const element of elements.values()) {
-      const data = element.links.reduce((d, fk) => {
-        d[fk.entityKey] = null
-        return d
+const resolveNavigationTarget = (cqn, ref, model) => {
+  const lastTransition = cqn.UPDATE._transitions && cqn.UPDATE._transitions[cqn.UPDATE._transitions.length - 1]
+  const target = lastTransition
+    ? lastTransition.target
+    : model.definitions[(cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) || cqn.UPDATE.entity]
+  let elementName = ref[ref.length - 1].id || ref[ref.length - 1]
+  const resolved = lastTransition && lastTransition.mapping && lastTransition.mapping.get(elementName)
+  if (resolved) elementName = resolved.ref[0]
+  return { target, elementName }
+}
+
+// eslint-disable-next-line complexity
+const getSetNullParentForeignKeyCQNs = async (model, req, dbQuery) => {
+  const cqns = []
+  const query = dbQuery || req.query
+  const origQuery = (req._tx instanceof cds.DatabaseService && req._ && req._.query) || req.query
+  if (!dbQuery && origQuery && origQuery.DELETE && origQuery.DELETE.from.ref && origQuery.DELETE.from.ref.length > 1) {
+    // delete via 2one navigation => parent is known => no need to SELECT
+    const ref = origQuery.DELETE.from.ref
+    const cqn = cqn2cqn4sql(UPDATE.entity({ ref: ref.slice(0, ref.length - 1) }), model)
+    const { target: parent, elementName } = resolveNavigationTarget(cqn, ref, model)
+    const element = parent.elements[elementName]
+    if (element && element._isCompositionEffective && element.is2one) {
+      const onCond = element && parent._relations[element.name].join('$$whatever', '$$parent')
+      const data = onCond.reduce((res, e) => {
+        if (!e.ref || e.ref[0] !== '$$parent') return res
+        const fk = e.ref.slice(1).join('_')
+        if (!parent.keys[fk]) res[fk] = null
+        return res
       }, {})
-      const { entity1, where } = _getSubWhereAndEntities(element, parentWhere, draft)
-      if (where.length) {
-        setNullCQNs.push({
-          UPDATE: {
-            entity: { ref: [entity1.entityName], as: entity1.alias },
-            data,
-            where,
-            _beforeDelete: true
+      cqn.data(data)
+      cqn.__4delete = true
+      if (Object.keys(data).length) cqns.push(cqn)
+    }
+  } else if (query.DELETE.where && query.DELETE.where.length) {
+    // direct or internal request => parent is uknown => need to SELECT
+    const entityName = getEntityNameFromDeleteCQN(query)
+    const target = model.definitions[entityName]
+    const comp2oneParents = getComp2oneParents(target, model)
+    for (const element of comp2oneParents) {
+      const parent = element.parent
+      const onCond = parent._relations[element.name].join('$$child', '$$parent')
+      const data = onCond.reduce((res, e) => {
+        if (!e.ref || e.ref[0] !== '$$parent') return res
+        const fk = e.ref.slice(1).join('_')
+        if (!parent.keys[fk]) res[fk] = null
+        return res
+      }, {})
+      const columns = getColumns(parent, { _4db: true, onlyKeys: true }).map(c => ({ ref: ['$$parent', c.name] }))
+      const as = query.DELETE.from.as || (query.DELETE.from.ref && query.DELETE.from.ref[0]) || query.DELETE.from
+      const selectCQN = SELECT.from(`${parent.name} as $$parent`)
+        .join(`${element.target} as $$child`)
+        .on(onCond)
+        .columns(columns)
+        .where(_recursivelyAliasRefs(query.DELETE.where, '$$child', as))
+      const results = await cds.tx(req).run(selectCQN)
+      if (results.length && Object.keys(data).length) {
+        const cqn = UPDATE.entity(parent).data(data)
+        for (const result of results) {
+          const where = []
+          for (const col of columns) {
+            if (where.length) where.push('and')
+            const ref = col.ref.slice(1)
+            where.push({ ref }, '=', { val: result[ref[0]] })
           }
-        })
+          cqn.UPDATE.where = where
+          cqn.__4delete = true
+          cqns.push(cqn)
+        }
       }
     }
   }
-  return setNullCQNs
+  return cqns
 }
 
-const getDeepDeleteCQNs = (definitions, cqn) => {
-  const from = getEntityNameFromDeleteCQN(cqn)
-  if (!from) return [[cqn]]
+const getDeepDeleteCQNs = async (model, req, dbQuery) => {
+  const query = dbQuery || req.query
+  const from = getEntityNameFromDeleteCQN(query)
+  if (!from) return [[query]]
 
   const entityName = ensureNoDraftsSuffix(from)
   // REVISIT: baaad check!
   const draft = entityName !== from
   const compositionTree = getCompositionTree({
-    definitions,
+    definitions: model.definitions,
     rootEntityName: entityName,
     checkRoot: false,
     resolveViews: !draft,
     service: cds.db
   })
-  const parentWhere = cqn.DELETE.where && JSON.parse(JSON.stringify(cqn.DELETE.where))
-  if (parentWhere) {
-    const parentAlias = cqn.DELETE.from.as || (cqn.DELETE.from.ref && cqn.DELETE.from.ref[0]) || cqn.DELETE.from // or however we get the table name...
-    _recursivelyAliasRefs(parentWhere, 'ALIAS0', parentAlias)
-  }
-  const setNullUpdates = []
-  // REVISIT: why is _db_foreign_key_constraints necessary?
-  if (cds.env.features._db_foreign_key_constraints && definitions[entityName].own('__oneCompositionParents')) {
-    setNullUpdates.push(..._getSetNullParentForeignKeyCQNs(definitions, entityName, parentWhere, draft))
-  }
-  const subCascadeDeletes = _addSubCascadeDeleteCQN(definitions, compositionTree, parentWhere, 0, [], draft)
-  return [[cqn], ...subCascadeDeletes, ...setNullUpdates].reverse()
+  const parentWhere = _recursivelyAliasRefs(
+    query.DELETE.where,
+    'ALIAS0',
+    query.DELETE.from.as || (query.DELETE.from.ref && query.DELETE.from.ref[0]) || query.DELETE.from
+  )
+  const setNullUpdates =
+    (model.definitions[entityName].own('__oneCompositionParents') &&
+      (await getSetNullParentForeignKeyCQNs(model, req, dbQuery))) ||
+    []
+  const subCascadeDeletes = _addSubCascadeDeleteCQN(model, compositionTree, parentWhere, 0, [], draft)
+  return [[query], ...subCascadeDeletes, setNullUpdates].reverse()
 }
 
 module.exports = {
   hasDeepDelete,
-  getDeepDeleteCQNs
+  getDeepDeleteCQNs,
+  getSetNullParentForeignKeyCQNs
 }

package/libx/_runtime/common/composition/index.js

@@ -1,7 +1,7 @@
 const { getCompositionTree, getCompositionRoot } = require('./tree')
-const { hasDeepInsert, getDeepInsertCQNs, cleanEmptyCompositionsOfMany } = require('./insert')
+const { hasDeepInsert, getDeepInsertCQNs } = require('./insert')
 const { hasDeepUpdate, getDeepUpdateCQNs } = require('./update')
-const { hasDeepDelete, getDeepDeleteCQNs } = require('./delete')
+const { hasDeepDelete, getDeepDeleteCQNs, getSetNullParentForeignKeyCQNs } = require('./delete')
 const { selectDeepUpdateData } = require('./data')
 
 module.exports = {
@@ -11,13 +11,13 @@ module.exports = {
   // insert
   hasDeepInsert,
   getDeepInsertCQNs,
-  cleanEmptyCompositionsOfMany,
   // update
   hasDeepUpdate,
   getDeepUpdateCQNs,
   // delete
   hasDeepDelete,
   getDeepDeleteCQNs,
+  getSetNullParentForeignKeyCQNs,
   // data
   selectDeepUpdateData
 }

package/libx/_runtime/common/composition/insert.js

@@ -10,18 +10,18 @@ const { deepCopyArray } = require('../utils/copy')
  * own utils
  */
 
-function _hasCompOrAssocIgnoreEmptyToMany(entity, k, data) {
+function _hasCompOrAssoc(entity, k) {
   // TODO once REST also uses same logic as odata structured check if we can omit 'entity.elements[k] &&'
-  return entity.elements[k] && (entity.elements[k].is2one || (entity.elements[k].is2many && data[k] && data[k].length))
+  return entity.elements[k] && (entity.elements[k].is2one || entity.elements[k].is2many)
 }
 
-const _addSubDeepInsertCQN = (definitions, compositionTree, data, cqns, draft) => {
+const _addSubDeepInsertCQN = (model, compositionTree, data, cqns, draft) => {
   compositionTree.compositionElements.forEach(element => {
     if (element.skipPersistence) {
       return
     }
     // element source must be changed in comp tree
-    const subEntity = definitions[element.source]
+    const subEntity = model.definitions[element.source]
     const into = ctUtils.addDraftSuffix(draft, subEntity.name)
     const insertCQN = { INSERT: { into: into, entries: [] } }
     const subData = data.reduce((result, entry) => {
@@ -43,7 +43,7 @@ const _addSubDeepInsertCQN = (definitions, compositionTree, data, cqns, draft) =
       cqns.push(insertCQN)
     }
     if (subData.length > 0) {
-      _addSubDeepInsertCQN(definitions, element, subData, cqns, draft)
+      _addSubDeepInsertCQN(model, element, subData, cqns, draft)
     }
   })
   return cqns
@@ -53,32 +53,20 @@ const _addSubDeepInsertCQN = (definitions, compositionTree, data, cqns, draft) =
  * exports
  */
 
-const _entityFromINSERT = (definitions, INSERT) => {
+const _entityFromINSERT = (model, INSERT) => {
   if (INSERT && INSERT.into) {
     const entityName = ensureNoDraftsSuffix(INSERT.into.name || INSERT.into)
-    return definitions && definitions[entityName]
+    return model.definitions[entityName]
   }
 }
 
-const cleanEmptyCompositionsOfMany = (definitions, cqn) => {
-  const entity = _entityFromINSERT(definitions, cqn.INSERT)
-  if (!entity) return
-  for (const entry of cqn.INSERT.entries || []) {
-    for (const elName in entry || {}) {
-      const el = entity.elements[elName]
-      if (!el) continue
-      if (el.is2many && !entry[elName].length) delete entry[elName]
-    }
-  }
-}
-
-const hasDeepInsert = (definitions, cqn) => {
+const hasDeepInsert = (model, cqn) => {
   if (cqn.INSERT.entries) {
-    const entity = _entityFromINSERT(definitions, cqn.INSERT)
+    const entity = _entityFromINSERT(model, cqn.INSERT)
     if (entity) {
       return !!cqn.INSERT.entries.find(entry => {
         return !!Object.keys(entry || {}).find(k => {
-          return _hasCompOrAssocIgnoreEmptyToMany(entity, k, entry)
+          return _hasCompOrAssoc(entity, k)
         })
       })
     }
@@ -86,14 +74,14 @@ const hasDeepInsert = (definitions, cqn) => {
   return false
 }
 
-const getDeepInsertCQNs = (definitions, cqn) => {
+const getDeepInsertCQNs = (model, cqn) => {
   const into = cqn.INSERT.into.name || cqn.INSERT.into
   const entityName = ensureNoDraftsSuffix(into)
   const draft = entityName !== into
   const dataEntries = cqn.INSERT.entries ? deepCopyArray(cqn.INSERT.entries) : []
-  const entity = definitions && definitions[entityName]
+  const entity = model.definitions[entityName]
   const compositionTree = getCompositionTree({
-    definitions,
+    definitions: model.definitions,
     rootEntityName: entityName,
     checkRoot: false,
     resolveViews: !draft,
@@ -107,11 +95,10 @@ const getDeepInsertCQNs = (definitions, cqn) => {
     flattenedCqn.INSERT.entries.push(ctUtils.cleanDeepData(entity, Object.assign({}, dataEntry)))
   )
 
-  return [flattenedCqn, ..._addSubDeepInsertCQN(definitions, compositionTree, dataEntries, [], draft)]
+  return [flattenedCqn, ..._addSubDeepInsertCQN(model, compositionTree, dataEntries, [], draft)]
 }
 
 module.exports = {
-  cleanEmptyCompositionsOfMany,
   hasDeepInsert,
   getDeepInsertCQNs
 }

package/libx/_runtime/common/composition/tree.js

@@ -38,7 +38,7 @@ const _foreignKeysToLinks = (element, inverse) =>
 const _resolvedElement = (element, service) => {
   if (!element.target) return element
   // skip forbidden view check if association to view with foreign key in target
-  const skipForbiddenViewCheck = element._isAssociationStrict && element.on && !element['@odata.contained']
+  const skipForbiddenViewCheck = element._isAssociationStrict && !element['@odata.contained']
   const { target, mapping } = getTransition(element._target, service, skipForbiddenViewCheck)
   const newElement = { target: target.name, _target: target }
   Object.setPrototypeOf(newElement, element)

package/libx/_runtime/common/composition/update.js

@@ -37,6 +37,7 @@ const _dataByKey = (entity, data) => {
 function _addSubDeepUpdateCQNForDelete({ entity, data, selectData, deleteCQN }) {
   const dataByKey = _dataByKey(entity, data)
   for (const selectEntry of selectData) {
+    if (!selectEntry) continue
     const dataEntry = dataByKey.get(_serializedKey(entity, selectEntry))
     if (!dataEntry) {
       if (deleteCQN.DELETE.where.length > 0) {
@@ -67,7 +68,7 @@ function _fillLinkFromStructuredData(entity, entry) {
   }
 }
 
-const _diffData = (newData, oldData, entity, newEntry, oldEntry, definitions) => {
+const _diffData = (newData, oldData, entity, newEntry, oldEntry, model) => {
   const result = {}
 
   const keysSet = new Set(Object.keys(newData).concat(Object.keys(oldData)))
@@ -96,7 +97,7 @@ const _diffData = (newData, oldData, entity, newEntry, oldEntry, definitions) =>
         nav.isComposition &&
         nav.is2one &&
         newEntry[nav.name] !== undefined &&
-        !definitions[nav.target]._hasPersistenceSkip
+        !model.definitions[nav.target]._hasPersistenceSkip
       ) {
         result[key] = null
       }
@@ -106,15 +107,7 @@ const _diffData = (newData, oldData, entity, newEntry, oldEntry, definitions) =>
   return result
 }
 
-function _addSubDeepUpdateCQNForUpdateInsert({
-  entity,
-  entityName,
-  data,
-  selectData,
-  updateCQNs,
-  insertCQN,
-  definitions
-}) {
+function _addSubDeepUpdateCQNForUpdateInsert({ entity, entityName, data, selectData, updateCQNs, insertCQN, model }) {
   const selectDataByKey = _dataByKey(entity, selectData)
   const deepUpdateData = []
   for (const entry of data) {
@@ -127,7 +120,7 @@ function _addSubDeepUpdateCQNForUpdateInsert({
       deepUpdateData.push(entry)
       const newData = ctUtils.cleanDeepData(entity, entry)
       const oldData = ctUtils.cleanDeepData(entity, selectEntry)
-      const diff = _diffData(newData, oldData, entity, entry, selectEntry, definitions)
+      const diff = _diffData(newData, oldData, entity, entry, selectEntry, model)
       // empty updates will be removed later
       updateCQNs.push({ UPDATE: { entity: entityName, data: diff, where: ctUtils.whereKey(key) } })
     } else {
@@ -138,7 +131,7 @@ function _addSubDeepUpdateCQNForUpdateInsert({
   return deepUpdateData
 }
 
-function _addSubDeepUpdateCQNCollect(definitions, cqns, updateCQNs, insertCQN, deleteCQN) {
+async function _addSubDeepUpdateCQNCollect(model, cqns, updateCQNs, insertCQN, deleteCQN, req) {
   if (updateCQNs.length > 0) {
     cqns[0] = cqns[0] || []
     cqns[0].push(...updateCQNs)
@@ -146,7 +139,7 @@ function _addSubDeepUpdateCQNCollect(definitions, cqns, updateCQNs, insertCQN, d
 
   if (insertCQN.INSERT.entries.length > 0) {
     cqns[0] = cqns[0] || []
-    const deepInsertCQNs = getDeepInsertCQNs(definitions, insertCQN)
+    const deepInsertCQNs = getDeepInsertCQNs(model, insertCQN)
     deepInsertCQNs.forEach(insertCQN => {
       const intoCQN = cqns[0].find(cqn => {
         return cqn.INSERT && cqn.INSERT.into === insertCQN.INSERT.into
@@ -161,7 +154,7 @@ function _addSubDeepUpdateCQNCollect(definitions, cqns, updateCQNs, insertCQN, d
 
   if (deleteCQN.DELETE.where.length > 0) {
     cqns[0] = cqns[0] || []
-    const deepDeleteCQNs = getDeepDeleteCQNs(definitions, deleteCQN)
+    const deepDeleteCQNs = await getDeepDeleteCQNs(model, req, deleteCQN)
     deepDeleteCQNs.forEach((deleteCQNs, index) => {
       deleteCQNs.forEach(el => {
         cqns[index] = cqns[index] || []
@@ -180,7 +173,7 @@ const _addToData = (subData, entity, element, entry) => {
   subData.push(...unwrappedSubData)
 }
 
-function _addSubDeepUpdateCQNRecursion({ definitions, compositionTree, entity, data, selectData, cqns, draft }) {
+async function _addSubDeepUpdateCQNRecursion({ model, compositionTree, entity, data, selectData, cqns, draft, req }) {
   const selectDataByKey = _dataByKey(entity, selectData)
 
   for (const element of compositionTree.compositionElements) {
@@ -202,23 +195,24 @@ function _addSubDeepUpdateCQNRecursion({ definitions, compositionTree, entity, d
       }
     }
 
-    _addSubDeepUpdateCQN({
-      definitions,
+    await _addSubDeepUpdateCQN({
+      model,
       compositionTree: element,
       data: subData,
       selectData: selectSubData,
       cqns,
-      draft
+      draft,
+      req
     })
   }
 
   return cqns
 }
 
-const _addSubDeepUpdateCQN = ({ definitions, compositionTree, data, selectData, cqns, draft }) => {
+const _addSubDeepUpdateCQN = async ({ model, compositionTree, data, selectData, cqns, draft, req }) => {
   // We handle each level for deepUpdate, the moment we see that there will be an INSERT,
   // it'll be removed from our deepUpdateData (and handled deep separately).
-  const entity = definitions && definitions[compositionTree.source]
+  const entity = model.definitions[compositionTree.source]
 
   if (entity._hasPersistenceSkip) return Promise.resolve()
 
@@ -234,21 +228,22 @@ const _addSubDeepUpdateCQN = ({ definitions, compositionTree, data, selectData,
     selectData,
     updateCQNs,
     insertCQN,
-    definitions
+    model
   })
 
-  _addSubDeepUpdateCQNCollect(definitions, cqns, updateCQNs, insertCQN, deleteCQN)
+  await _addSubDeepUpdateCQNCollect(model, cqns, updateCQNs, insertCQN, deleteCQN, req)
 
   if (deepUpdateData.length === 0) return Promise.resolve()
 
   return _addSubDeepUpdateCQNRecursion({
-    definitions,
+    model,
     compositionTree,
     entity,
     data: deepUpdateData,
     selectData,
     cqns,
-    draft
+    draft,
+    req
   })
 }
 
@@ -256,11 +251,11 @@ const _addSubDeepUpdateCQN = ({ definitions, compositionTree, data, selectData,
  * exports
  */
 
-const hasDeepUpdate = (definitions, cqn) => {
+const hasDeepUpdate = (model, cqn) => {
   if (cqn && cqn.UPDATE && cqn.UPDATE.entity && (cqn.UPDATE.data || cqn.UPDATE.with)) {
     const updateEntity = cqn.UPDATE.entity
     const entityName = (updateEntity.ref && updateEntity.ref[0]) || updateEntity.name || updateEntity
-    const entity = definitions && definitions[ensureNoDraftsSuffix(entityName)]
+    const entity = model.definitions[ensureNoDraftsSuffix(entityName)]
 
     if (entity) {
       const keys = Object.keys(Object.assign({}, cqn.UPDATE.data || {}, cqn.UPDATE.with || {}))
@@ -271,7 +266,8 @@ const hasDeepUpdate = (definitions, cqn) => {
   return false
 }
 
-const getDeepUpdateCQNs = (definitions, cqn, selectData) => {
+const getDeepUpdateCQNs = async (model, req, selectData) => {
+  const { query } = req
   if (!Array.isArray(selectData)) selectData = [selectData]
 
   if (selectData.length === 0) return []
@@ -279,22 +275,31 @@ const getDeepUpdateCQNs = (definitions, cqn, selectData) => {
   if (selectData.length > 1) throw getError('Deep update can only be performed on a single instance')
 
   const cqns = []
-  const from = (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) || cqn.UPDATE.entity.name || cqn.UPDATE.entity
+  const from =
+    (query.UPDATE.entity.ref && query.UPDATE.entity.ref[0]) || query.UPDATE.entity.name || query.UPDATE.entity
   const entityName = ensureNoDraftsSuffix(from)
   const draft = entityName !== from
-  const data = cqn.UPDATE.data ? deepCopyObject(cqn.UPDATE.data) : {}
-  const withObj = cqn.UPDATE.with ? deepCopyObject(cqn.UPDATE.with) : {}
-  const entity = definitions && definitions[entityName]
+  const data = query.UPDATE.data ? deepCopyObject(query.UPDATE.data) : {}
+  const withObj = query.UPDATE.with ? deepCopyObject(query.UPDATE.with) : {}
+  const entity = model.definitions[entityName]
   const entry = Object.assign({}, data, withObj, ctUtils.key(entity, selectData[0]))
   const compositionTree = getCompositionTree({
-    definitions,
+    definitions: model.definitions,
     rootEntityName: entityName,
     checkRoot: false,
     resolveViews: !draft,
     service: cds.db
   })
 
-  const subCQNs = _addSubDeepUpdateCQN({ definitions, compositionTree, data: [entry], selectData, cqns: [], draft })
+  const subCQNs = await _addSubDeepUpdateCQN({
+    model,
+    compositionTree,
+    data: [entry],
+    selectData,
+    cqns: [],
+    draft,
+    req
+  })
   subCQNs.forEach((subCQNs, index) => {
     cqns[index] = cqns[index] || []
     cqns[index].push(...subCQNs)

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

@@ -30,9 +30,8 @@ const _getFiltered = err => {
   Object.keys(err)
     .concat(['message'])
     .forEach(k => {
-      if (k === 'innererror' && process.env.NODE_ENV === 'production') {
-        return
-      }
+      // REVISIT: do not remove innererror with cds^6
+      if (k === 'innererror' && process.env.NODE_ENV === 'production' && !err[SKIP_SANITIZATION]) return
       if (ALLOWED_PROPERTIES.includes(k) || k.startsWith('@')) {
         error[k] = err[k]
       } else if (k === 'numericSeverity') {
@@ -90,6 +89,20 @@ const _anonymousUser = req => {
   return Object.defineProperty(new cds.User(), '_req', { enumerable: false, value: req })
 }
 
+// - for one unique value, we use it
+// - if at least one 5xx exists, we use 500
+// - else if at least one 4xx exists, we use 400
+// - else we use 500
+const _statusCodeFromDetails = details => {
+  const uniqueStatusCodes = new Set(
+    details.map(d => d.status || d.statusCode || d.code).map(c => (!isNaN(c) && Number(c)) || c)
+  )
+  if (uniqueStatusCodes.size === 1) return uniqueStatusCodes.values().next().value
+  if ([...uniqueStatusCodes].some(s => s >= 500)) return 500
+  if ([...uniqueStatusCodes].some(s => s >= 400)) return 400
+  return 500
+}
+
 const normalizeError = (err, req) => {
   const user = (req && req.user) || _anonymousUser(req)
   const locale = user.locale
@@ -98,8 +111,9 @@ const normalizeError = (err, req) => {
 
   // derive status code from err status OR root code OR matching detail codes
   let statusCode = err.status || err.statusCode || (_isAllowedError(error.code) && error.code)
-  if (!statusCode && error.details && error.details.every(ele => ele.code === error.details[0].code)) {
-    statusCode = _isAllowedError(error.details[0].code) < 505 && error.details[0].code
+  if (!statusCode && error.details) {
+    const detailsCode = _statusCodeFromDetails(error.details)
+    if (_isAllowedError(detailsCode)) statusCode = detailsCode
   }
 
   // make sure it's a number