@sap/cds 5.7.3 → 5.8.1

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

@@ -1,11 +1,28 @@
-const vcapApplication = process.env.VCAP_APPLICATION && JSON.parse(process.env.VCAP_APPLICATION)
-
-module.exports = {
-  appName: vcapApplication && vcapApplication.application_name,
-  appID: vcapApplication && vcapApplication.application_id,
-  appURL:
-    vcapApplication &&
-    vcapApplication.application_uris &&
-    vcapApplication.application_uris[0] &&
-    `https://${vcapApplication.application_uris[0].replace(/^https?:\/\//, '')}`
+const cds = require('../../../../libx/_runtime/cds')
+
+const getAppMetadata = () => {
+  const appMetadata = cds.env.app
+
+  if (appMetadata) {
+    return {
+      appID: appMetadata.id,
+      appName: appMetadata.name,
+      appURL: appMetadata.url
+    }
+  }
+
+  // fallback: if the app metadata is undefined, then extract the metadata from the underlying environment (CF/Kyma/...)
+  const vcapApplication = process.env.VCAP_APPLICATION && JSON.parse(process.env.VCAP_APPLICATION)
+
+  return {
+    appID: vcapApplication && vcapApplication.application_id,
+    appName: vcapApplication && vcapApplication.application_name,
+    appURL:
+      vcapApplication &&
+      vcapApplication.application_uris &&
+      vcapApplication.application_uris[0] &&
+      `https://${vcapApplication.application_uris[0].replace(/^https?:\/\//, '')}`
+  }
 }
+
+module.exports = getAppMetadata()

package/libx/_runtime/db/data-conversion/post-processing.js

@@ -1,6 +1,6 @@
 const cds = require('../../cds')
 
-const { ensureUnlocalized } = require('../../common/utils/draft')
+const { ensureUnlocalized, ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
 /**
  * Check if the value is a function or reference to private function.
@@ -48,49 +48,50 @@ const _getEntityName = (csn, from) => {
 
 const _refs = (refs, as) => {
   const arr = []
-  const hasOwnProperty = Object.prototype.hasOwnProperty
-
   for (const element of refs) {
     // multiple join are nested, so we need to find all the table names in there as well
-    if (hasOwnProperty.call(element, 'join')) {
+    if (Object.prototype.hasOwnProperty.call(element, 'join')) {
       arr.push(..._extractRefs(element))
       // Likely a union
-    } else if (hasOwnProperty.call(element, 'SELECT')) {
-      arr.push(..._extractRefs(element.SELECT.from, as))
+    } else if (Object.prototype.hasOwnProperty.call(element, 'SELECT')) {
+      arr.push(..._extractRefs(element.SELECT.from, element.as))
     } else {
-      arr.push(element)
+      arr.push(..._extractRefs(element, as))
     }
   }
 
   return arr
 }
 
+const _getActiveFromUnion = refs => {
+  if (refs.length !== 2) return
+  const [maybeDraft, maybeActive] = refs
+  if (ensureNoDraftsSuffix(maybeDraft.ref[0]) === maybeActive.ref[0]) return maybeActive
+  if (ensureNoDraftsSuffix(maybeActive.ref[0]) === maybeDraft.ref[0]) return maybeDraft
+}
+
 const _extractRefs = (from, as) => {
   if (from.SELECT) {
-    return _extractRefs(from.SELECT.from, from.SELECT.as)
+    return _extractRefs(from.SELECT.from, as || from.SELECT.as)
   }
-
-  const hasOwnProperty = Object.prototype.hasOwnProperty
-
-  if (hasOwnProperty.call(from, 'join')) {
+  if (Object.prototype.hasOwnProperty.call(from, 'join')) {
     // cqn with join in from
     return _refs(from.args)
   }
-
-  if (hasOwnProperty.call(from, 'SET')) {
-    return _refs(from.SET.args, from.SET.as || from.as)
+  if (Object.prototype.hasOwnProperty.call(from, 'SET')) {
+    let refs = _refs(from.SET.args).filter(a => !a.as || a.as !== 'filterAdmin')
+    refs = _getActiveFromUnion(refs) ? [_getActiveFromUnion(refs)] : refs
+    if (as) return refs.map(({ ref }) => ({ as, ref }))
+    return refs
   }
-
-  const ref = { ref: from.ref, as: from.as }
-
-  if (as) {
-    ref.as = as
-  }
-
+  if (!from.ref) return []
+  const ref = { ref: [...from.ref] }
+  if (as || from.as) ref.as = as || from.as
   return [ref]
 }
 
-const _addMapperFunction = (elements, toService, key, type, from, includeAlias) => {
+// REVISIT: check why we need includeAlias for some draft cases (check AFC tests)
+const _addMapperFunction = (elements, toService, key, type, alias, includeAlias) => {
   if (!toService.has(type)) {
     return
   }
@@ -99,9 +100,8 @@ const _addMapperFunction = (elements, toService, key, type, from, includeAlias)
 
   // ambiguous cases will lead to SQL syntax errors anyway, so no need for a check
   elements.set(key, convertFunction)
-
-  if (includeAlias) {
-    elements.set(`${from.as}_${key}`, convertFunction)
+  if (includeAlias && alias) {
+    elements.set(`${alias}_${key}`, convertFunction)
   }
 }
 
@@ -109,13 +109,13 @@ const _filterUnique = (value, index, arr) => {
   return arr.indexOf(value) === index
 }
 
-const _addMapperFunction4struct = (elements, toService, parent, struct, from, includeAlias) => {
+const _addMapperFunction4struct = (elements, toService, parent, struct, alias, includeAlias) => {
   for (const k in struct.elements) {
     const current = struct.elements[k]
     if (current._isStructured) {
-      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, from, includeAlias)
+      _addMapperFunction4struct(elements, toService, `${parent}_${k}`, current, alias, includeAlias)
     } else {
-      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, from, includeAlias)
+      _addMapperFunction(elements, toService, `${parent}_${k}`, current.type, alias, includeAlias)
     }
   }
 }
@@ -126,7 +126,6 @@ const _addMapperFunction4struct = (elements, toService, parent, struct, from, in
  * @param {Map} toService - Mapping instructions for data conversions based on CDS data types
  * @param {object} csn - Reflected CSN
  * @param {object} cqn - CQN that is used to query the DB.
- * @param {boolean} [includeAlias] - Include mapping for aliases. Defaults to false.
  * @returns {Map<any, any>}
  * @private
  */
@@ -142,13 +141,16 @@ const _getElementCombinations = (toService, csn, cqn, includeAlias = false) => {
     }
 
     const entity = csn.definitions[ensureUnlocalized(entityName)]
-
     for (const key in entity.elements) {
       const element = entity.elements[key]
       if (element._isStructured) {
-        _addMapperFunction4struct(elements, toService, key, element, from, includeAlias)
+        _addMapperFunction4struct(elements, toService, key, element, from.as, includeAlias)
       } else {
-        _addMapperFunction(elements, toService, key, element.type, from, includeAlias)
+        if ('SET' in cqn.SELECT.from) {
+          _addMapperFunction(elements, toService, key, element.type, cqn.SELECT.from.as, includeAlias)
+        } else {
+          _addMapperFunction(elements, toService, key, element.type, from.as, includeAlias)
+        }
       }
     }
   }
@@ -182,15 +184,17 @@ const _getMapperForListedElements = (toService, csn, cqn) => {
 
   for (const element of cqn.SELECT.columns) {
     if (element.ref) {
-      const identifier = element.ref[element.ref.length - 1]
+      const identifier = element.ref.length === 1 ? element.ref[0] : undefined
       const name = element.as ? element.as : identifier
 
       if (element.cast) {
         mapper.set(name, _getCastFunction(element.cast))
       } else if (elements.has(name)) {
         mapper.set(name, elements.get(name))
-      } else if (elements.has(identifier) && !cqn.SELECT.from.args) {
+      } else if (elements.has(identifier)) {
         mapper.set(name, elements.get(identifier))
+      } else if (elements.has(element.ref.join('_'))) {
+        mapper.set(name || element.ref[element.ref.length - 1], elements.get(element.ref.join('_')))
       }
     } else if (element.as && element.cast) {
       mapper.set(element.as, _getCastFunction(element.cast))
@@ -514,6 +518,9 @@ const getPropertyMapper = (csn, cqn) => {
   return new Map()
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   getPropertyMapper,
   getPostProcessMapper,

package/libx/_runtime/db/expand/expand-v2.js

@@ -11,9 +11,10 @@ const _removeParentKeysFromRow = (row, prefix, keys) => {
   }
 }
 
-const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) => {
+const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth, options) => {
   for (const nav in entity._associations) {
     const navigation = entity._associations[nav]
+    if (options.onlyCompositions && navigation._isAssociationEffective) continue
 
     // do not expand backlinks
     if (navigation._isBacklink) continue
@@ -26,7 +27,9 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
       .on(entity._relations[navigation.name].join(childAlias, parentAlias))
 
     // set alias for expanded columns already
-    const childColumns = getColumns(navigation._target).map(c => ({ ref: [childAlias, c.name] }))
+    const childColumns = getColumns(navigation._target, { _4db: true, onlyKeys: options.onlyKeys }).map(c => ({
+      ref: [childAlias, c.name]
+    }))
     const parentKeys = Object.keys(entity.keys).filter(k => !entity.keys[k].isAssociation)
     // mark parent key with prefix in alias
     const parentKeysWithAlias = parentKeys.map(pk => ({ ref: [parentAlias, pk], as: `$$pk_${pk}` }))
@@ -69,16 +72,17 @@ const _autoExpandNavsAndAttachToResult = async (entity, previousResult, depth) =
 
     // expand next level if needed
     if (depth - 1 !== 0 && result.length && navigation._target._associations) {
-      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1)
+      await _autoExpandNavsAndAttachToResult(navigation._target, result, depth - 1, options)
     }
   }
 
   return previousResult
 }
 
-const _foreignKeysOfTopLevelNavs = entity => {
+const _foreignKeysOfTopLevelNavs = (entity, options) => {
   const requiredFks = new Set()
   for (const nav in entity._associations) {
+    if (options.onlyCompositions && entity._associations[nav]._isAssociationEffective) continue
     const onCond = entity._relations[nav].join('child', 'parent')
     for (const ele of onCond) {
       if (ele.ref && ele.ref[0] === 'parent') {
@@ -89,6 +93,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
   return [...requiredFks]
 }
 
+const _addForeignKeys = (columns, entity, options) => {
+  const fks = _foreignKeysOfTopLevelNavs(entity, options)
+  fks.forEach(fk => {
+    if (!columns.some(c => c.ref[0] === fk)) {
+      columns.push({ ref: [fk] })
+    }
+  })
+}
+
 /**
  * 1. Creates flattened SQL statements for each expand layer
  * 2. Mixes in foreign keys if needed
@@ -98,18 +111,15 @@ const _foreignKeysOfTopLevelNavs = entity => {
  * @returns object
  */
 const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSelectCQN) => {
+  const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
+  const options = Object.assign({ onlyKeys: false, onlyCompositions: false }, expandColumn._options)
   // remove expand columns from query without modifying
   const topLevelSelect = query.clone().columns(query.SELECT.columns.filter(c => !c.expand))
 
   const entity = model.definitions[topLevelSelect.SELECT.from.ref[0]]
 
   // ensure foreign keys are selected if needed
-  const fks = _foreignKeysOfTopLevelNavs(entity)
-  fks.forEach(fk => {
-    if (!topLevelSelect.SELECT.columns.some(c => c.ref[0] === fk)) {
-      topLevelSelect.SELECT.columns.push({ ref: [fk] })
-    }
-  })
+  _addForeignKeys(topLevelSelect.SELECT.columns, entity, options)
 
   const result = await executeSelectCQN(model, dbc, topLevelSelect, user, locale, txTimestamp)
 
@@ -119,9 +129,8 @@ const expandV2 = async (model, dbc, query, user, locale, txTimestamp, executeSel
 
   // _associations contains compositions and associations
   if (entity._associations) {
-    const expandColumn = query.SELECT.columns.find(c => c.expand && typeof c.expand === 'string')
     const depth = expandColumn.expand === '**' ? -1 : Number(expandColumn.expand.replace('*', ''))
-    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth)
+    await _autoExpandNavsAndAttachToResult(entity, Array.isArray(result) ? result : [result], depth, options)
   }
 
   return result

package/libx/_runtime/db/expand/expandCQNToJoin.js

@@ -2,10 +2,15 @@ const cds = require('../../cds')
 
 const { getAllKeys } = require('../../cds-services/adapter/odata-v4/odata-to-cqn/utils')
 
+const { deepCopyObject } = require('../../common/utils/copy')
 const { getNavigationIfStruct } = require('../../common/utils/structured')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
-const { filterKeys } = require('../../fiori/utils/handler')
 const { isAsteriskColumn } = require('../../common/utils/rewriteAsterisks')
+const { getCQNUnionFrom } = require('../../common/utils/union')
+
+const { DRAFT_COLUMNS } = require('../../common/constants/draft')
+
+const { filterKeys } = require('../../fiori/utils/handler')
 
 // Symbols are used to add extra information in response structure
 const GET_KEY_VALUE = Symbol.for('sap.cds.getKeyValue')
@@ -16,12 +21,9 @@ const IDENTIFIER = Symbol.for('sap.cds.identifier')
 const IS_ACTIVE = Symbol.for('sap.cds.isActive')
 const IS_UNION_DRAFT = Symbol.for('sap.cds.isUnionDraft')
 
-const { DRAFT_COLUMNS } = require('../../common/constants/draft')
-
-const { getCQNUnionFrom } = require('../../common/utils/union')
-
 function getCqnCopy(readToOneCQN) {
-  const readToOneCQNCopy = JSON.parse(JSON.stringify(readToOneCQN))
+  // REVISIT: Use query.clone() instead
+  const readToOneCQNCopy = deepCopyObject(readToOneCQN)
   if (readToOneCQN[GET_KEY_VALUE] !== undefined) readToOneCQNCopy[GET_KEY_VALUE] = readToOneCQN[GET_KEY_VALUE]
   if (readToOneCQN[TO_MANY] !== undefined) readToOneCQNCopy[TO_MANY] = readToOneCQN[TO_MANY]
   if (readToOneCQN[TO_ACTIVE] !== undefined) readToOneCQNCopy[TO_ACTIVE] = readToOneCQN[TO_ACTIVE]
@@ -518,6 +520,17 @@ class JoinCQNFromExpanded {
 
         // REVISIT required for other cqn properties as well?
         this.adjustOrderBy(readToOneCQN.orderBy, mappings, column, tableAlias)
+
+        // In case active parent entity has orderBy with draft specific columns we need to add them to parent CQN
+        if (
+          readToOneCQN[IS_ACTIVE] &&
+          readToOneCQN.orderBy &&
+          column.as &&
+          (column.as === 'IsActiveEntity' || column.as === 'HasActiveEntity' || column.as === 'HasDraftEntity')
+        ) {
+          readToOneCQNCopy.orderBy = readToOneCQN.orderBy
+          this._addColumnsInCaseOrderByHasDraft(readToOneCQNCopy, readToOneCQN.columns[readToOneCQN.columns.length - 1])
+        }
       }
     }
 
@@ -549,6 +562,14 @@ class JoinCQNFromExpanded {
     }
   }
 
+  _addColumnsInCaseOrderByHasDraft(readToOneCQNCopy, column) {
+    readToOneCQNCopy.orderBy.forEach(order => {
+      if (order.as === column.as) {
+        readToOneCQNCopy.columns.push(column)
+      }
+    })
+  }
+
   /**
    * Follow the tree to get to the relevant config object.
    *
@@ -626,7 +647,7 @@ class JoinCQNFromExpanded {
     // if union always only expand with active, otherwise evaluate flag
     // if flag shows false, we check entity for associations to non draft
     const activeTableRequired =
-      readToOneCQN[IS_UNION_DRAFT] ||
+      readToOneCQN[IS_UNION_DRAFT] || // > REVISIT: blocks expanding comp2one
       readToOneCQN[IS_ACTIVE] ||
       (element && element.type === 'cds.Association' && !element['@odata.draft.enclosed']) ||
       !this._csn.definitions[target]._isDraftEnabled
@@ -665,9 +686,9 @@ class JoinCQNFromExpanded {
       readToOneCQN.from.args[1] = {
         SELECT: {
           columns: cols,
-          from: unionFrom,
-          as: tableAlias
-        }
+          from: unionFrom
+        },
+        as: tableAlias
       }
     }
 
@@ -755,9 +776,9 @@ class JoinCQNFromExpanded {
     return {
       SELECT: {
         columns: Array.from(readToOneCQN.columns),
-        from: readToOneCQN.from,
-        as: readToOneCQN.from.as
-      }
+        from: readToOneCQN.from
+      },
+      as: readToOneCQN.from.as
     }
   }
 
@@ -858,18 +879,18 @@ class JoinCQNFromExpanded {
 
       if (arg.args) {
         this._addJoinKeyColumnsToUnion(arg.args, on, parentAlias)
-      } else if (arg.SELECT.from.SET && arg.SELECT.as === parentAlias) {
-        this._addColumns(arg.SELECT.from.SET.args, on, parentAlias)
+      } else if (arg.SELECT.from.SET && (arg.as === parentAlias || arg.SELECT.from.as === parentAlias)) {
+        for (const _arg of arg.SELECT.from.SET.args) {
+          this._addColumns(_arg.SELECT.columns, on, parentAlias)
+        }
+        if (arg.SELECT.columns) {
+          this._addColumns(arg.SELECT.columns, on, parentAlias, true)
+        }
       }
     }
   }
 
-  _addColumns(args, on, parentAlias) {
-    const [
-      {
-        SELECT: { columns }
-      }
-    ] = args
+  _addColumns(columns, on, parentAlias, withAlias = false) {
     const keyColumns = on
       .filter(entry => {
         return (
@@ -878,15 +899,11 @@ class JoinCQNFromExpanded {
           !columns.some(column => column.ref && column.ref[column.ref.length - 1] === entry.ref[1])
         )
       })
-      .map(entry => ({ ref: [entry.ref[1]] }))
-
+      .map(entry =>
+        withAlias ? { ref: [parentAlias, entry.ref[1]], as: `${parentAlias}_${entry.ref[1]}` } : { ref: [entry.ref[1]] }
+      )
     if (keyColumns.length === 0) return
-
-    for (const {
-      SELECT: { columns }
-    } of args) {
-      columns.push(...keyColumns)
-    }
+    columns.push(...keyColumns)
   }
 
   /**
@@ -1328,6 +1345,17 @@ class JoinCQNFromExpanded {
       }
     }
 
+    if (readToOneCQN[IS_ACTIVE] && readToOneCQN.columns.length > 0) {
+      readToOneCQN.columns.forEach(column => {
+        if (
+          column.as === `${parentAlias}_IsActiveEntity` ||
+          column.as === `${parentAlias}_HasActiveEntity` ||
+          column.as === `${parentAlias}_HasDraftEntity`
+        )
+          columns.push(column)
+      })
+    }
+
     const subSelect = Object.assign({}, readToOneCQN, { columns })
 
     const SELECT = { from: { SELECT: subSelect }, columns: outerColumns, distinct: true }

package/libx/_runtime/db/expand/index.js

@@ -2,6 +2,9 @@ const { hasExpand, createJoinCQNFromExpanded } = require('./expandCQNToJoin')
 const rawToExpanded = require('./rawToExpanded')
 const expandV2 = require('./expand-v2')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   hasExpand,
   createJoinCQNFromExpanded,

package/libx/_runtime/db/generic/create.js

@@ -15,16 +15,6 @@ module.exports = async function (req) {
   }
 
   try {
-    // REVISIT: should be handled in protocol adapter
-    // execute validation query first to fail early
-    if (req.query._validationQuery) {
-      const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-      if (validationResult.length === 0) {
-        // > validation target (e.g., root of navigation) doesn't exist
-        req.reject(404)
-      }
-    }
     const results = await this._insert(this.model, this.dbc, req.query, req)
     return new InsertResult(req, results)
   } catch (err) {

package/libx/_runtime/db/generic/index.js

@@ -12,6 +12,9 @@ const DELETE = require('./delete')
 const structured = require('./structured')
 const arrayed = require('./arrayed')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   rewrite,
   virtual,

package/libx/_runtime/db/generic/read.js

@@ -7,32 +7,10 @@
  *
  * @param req - cds.Request
  */
-module.exports = async function (req) {
+module.exports = function (req) {
   if (typeof req.query === 'string') {
     return this._execute.sql(this.dbc, req.query, req.data)
   }
 
-  // REVISIT: should be handled in protocol adapter
-  // execute validation query first to fail early
-  if (req.query._validationQuery) {
-    const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-    if (validationResult.length === 0) {
-      // > validation target (e.g., root of navigation) doesn't exist
-      req.reject(404)
-    }
-  }
-
-  const result = await this._read(this.model, this.dbc, req.query, req)
-
-  if (
-    req.query._validationQuery &&
-    req.query._validationQuery.__navToManyWithKeys &&
-    (!result || result.length === 0)
-  ) {
-    // > navigation to collection with key specified without result -> 404
-    req.reject(404)
-  }
-
-  return result
+  return this._read(this.model, this.dbc, req.query, req)
 }

package/libx/_runtime/db/generic/rewrite.js

@@ -1,5 +1,5 @@
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
-const generateAliases = require('../utils/generateAliases')
+const { generateAliases } = require('../utils/generateAliases')
 const { restoreLink } = require('../../common/utils/resolveView')
 
 const _isLinked = req => {
@@ -18,7 +18,6 @@ function handler(req) {
   }
 
   const streaming = req.query._streaming
-  const validationQuery = req.query._validationQuery
 
   // for restore link to req.data
   const linked = _isLinked(req)
@@ -31,7 +30,6 @@ function handler(req) {
   if (linked) restoreLink(req)
 
   if (streaming) req.query._streaming = streaming
-  if (validationQuery) req.query._validationQuery = validationQuery
 
   generateAliases(req.query)
 }

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

@@ -70,7 +70,7 @@ module.exports = async function (req) {
   if (onlyKeysRemain(req)) return
 
   try {
-    const result = await this._update(this.model, this.dbc, req.query, req)
+    const result = await this._update(this.model, this.dbc, req)
     return result
   } catch (err) {
     // REVISIT: db specifics

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

@@ -1,14 +1,14 @@
 const { getFlatArray, processCQNs } = require('../utils/deep')
 const { timestampToISO } = require('../data-conversion/timestamp')
-const { hasDeepDelete, getDeepDeleteCQNs } = require('../../common/composition')
+const { hasDeepDelete, getDeepDeleteCQNs, getSetNullParentForeignKeyCQNs } = require('../../common/composition')
 
-const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
+const deleteFn = (executeDeleteCQN, executeUpdateCQN) => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
   let result
-  if (hasDeepDelete(model && model.definitions, query)) {
-    let cqns = getDeepDeleteCQNs(model && model.definitions, query)
+  if (hasDeepDelete(model, query)) {
+    let cqns = await getDeepDeleteCQNs(model, req)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []
@@ -25,6 +25,12 @@ const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
     result = results[results.length - 1]
   } else {
     result = await executeDeleteCQN(model, dbc, query, user, locale, isoTs)
+    if (result) {
+      const updateCQNs = await getSetNullParentForeignKeyCQNs(model, req)
+      for (const cqn of updateCQNs) {
+        await executeUpdateCQN(model, dbc, cqn, user, locale, isoTs)
+      }
+    }
   }
 
   return result

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

@@ -1,4 +1,4 @@
-const { hasDeepInsert, getDeepInsertCQNs, cleanEmptyCompositionsOfMany } = require('../../common/composition')
+const { hasDeepInsert, getDeepInsertCQNs } = require('../../common/composition')
 const { getFlatArray, processCQNs } = require('../utils/deep')
 const { timestampToISO } = require('../data-conversion/timestamp')
 
@@ -6,8 +6,8 @@ const insert = executeInsertCQN => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepInsert(model && model.definitions, query)) {
-    const cqns = getFlatArray(getDeepInsertCQNs(model && model.definitions, query))
+  if (hasDeepInsert(model, query)) {
+    const cqns = getFlatArray(getDeepInsertCQNs(model, query))
 
     // return array of individual results
     if (cqns.length === 0) return []
@@ -15,7 +15,6 @@ const insert = executeInsertCQN => async (model, dbc, query, req) => {
     return getFlatArray(results)
   }
 
-  cleanEmptyCompositionsOfMany(model && model.definitions, query)
   return executeInsertCQN(model, dbc, query, user, locale, isoTs)
 }
 

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

@@ -1,5 +1,7 @@
 const { timestampToISO } = require('../data-conversion/timestamp')
 
+const { deepCopyObject } = require('../../common/utils/copy')
+
 function _arrayWithCount(a, count) {
   const _map = a.map
   const map = (..._) => _arrayWithCount(_map.call(a, ..._), count)
@@ -10,7 +12,8 @@ function _arrayWithCount(a, count) {
 }
 
 function _createCountQuery(query) {
-  let _query = JSON.parse(JSON.stringify(query)) // REVISIT: Use query.clone() instead
+  // REVISIT: Use query.clone() instead
+  let _query = { SELECT: deepCopyObject(query.SELECT) }
   delete _query.SELECT.orderBy // not necessary to keep that
   delete _query.SELECT.limit
   // Also change columns in sub queries

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

@@ -50,11 +50,11 @@ const _getFilteredCqns = (cqns, model) => {
   return cqns
 }
 
-const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query, req) => {
-  const { user, locale, timestamp } = req
+const update = executeUpdateCQN => async (model, dbc, req) => {
+  const { query, user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepUpdate(model && model.definitions, query)) {
+  if (hasDeepUpdate(model, query)) {
     // REVISIT: _activeData gets set in case of draftActivate for performance, but this is a layer violation
     let selectData = req._ && req._.query && req._.query._activeData
 
@@ -62,10 +62,10 @@ const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query,
       selectData = [selectData]
     } else {
       // REVISIT: avoid additional read
-      selectData = await selectDeepUpdateData(model && model.definitions, query, req, false, false, cds.db)
+      selectData = await selectDeepUpdateData(cds.db, model, req)
     }
 
-    let cqns = getDeepUpdateCQNs(model && model.definitions, query, selectData)
+    let cqns = await getDeepUpdateCQNs(model, req, selectData)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []