@sap/cds 5.7.5 → 5.8.0

package/libx/_runtime/cds-services/services/utils/columns.js

@@ -17,7 +17,10 @@ const { DRAFT_COLUMNS_UNION } = require('../../../common/constants/draft')
  * @param [options.filterVirtual=false]
  * @returns {Array<object>} - array of columns
  */
-const getColumns = (entity, { onlyNames = false, removeIgnore = false, filterDraft = true, filterVirtual = false }) => {
+const getColumns = (
+  entity,
+  { onlyNames = false, removeIgnore = false, filterDraft = true, filterVirtual = false, keysOnly = false }
+) => {
   const skipDraft = filterDraft && entity._isDraftEnabled
   const columns = []
   const elements = entity.elements
@@ -28,6 +31,7 @@ const getColumns = (entity, { onlyNames = false, removeIgnore = false, filterDra
     if (filterVirtual && element.virtual) continue
     if (removeIgnore && element['@cds.api.ignore']) continue
     if (skipDraft && DRAFT_COLUMNS_UNION.includes(each)) continue
+    if (keysOnly && !element.key) continue
     columns.push(onlyNames ? each : element)
   }
 

package/libx/_runtime/cds-services/services/utils/compareJson.js

@@ -285,30 +285,29 @@ const _mergeArrays = (entity, oldValue, newValue) => {
   return merged
 }
 
-const mergeJsonDeep = (entity, oldValue, newValue) => {
+const mergeJsonDeep = (entity, oldValue, value) => {
+  // REVISIT readAfterWrite -> commit -> postProcessing
+  // Detach result from req.data
+  const newValue = value ? Object.assign({}, value) : oldValue // if newValue === undefined
   if (_isObject(oldValue) && _isObject(newValue)) {
-    Object.keys(newValue).forEach(key => {
-      if (_isObject(newValue[key])) {
-        if (!(key in oldValue)) Object.assign(oldValue, { [key]: newValue[key] })
-        else {
-          const target = entity && entity.elements[key] && entity.elements[key]._target
-          oldValue[key] = mergeJsonDeep(target, oldValue[key], newValue[key])
-        }
-      } else if (Array.isArray(newValue[key])) {
-        if (!(key in oldValue)) Object.assign(oldValue, { [key]: newValue[key] })
-        else {
-          const target = entity && entity.elements[key] && entity.elements[key]._target
+    // append to newValue to keep an order of attributes as might be defined in custom handler
+    Object.keys(oldValue).forEach(key => {
+      if (!(key in newValue)) {
+        Object.assign(newValue, { [key]: oldValue[key] })
+      } else {
+        const target = entity && entity.elements[key] && entity.elements[key]._target
+        if (_isObject(newValue[key])) {
+          newValue[key] = mergeJsonDeep(target, oldValue[key], newValue[key])
+        } else if (Array.isArray(newValue[key])) {
           if (target) {
-            oldValue[key] = _mergeArrays(target, oldValue[key], newValue[key])
+            newValue[key] = _mergeArrays(target, oldValue[key], newValue[key])
           }
           // Can't merge items without target
         }
-      } else {
-        Object.assign(oldValue, { [key]: newValue[key] })
       }
     })
   }
-  return oldValue
+  return newValue
 }
 
 // Signature similar to Object.assign(oldValue, newValue)

package/libx/_runtime/cds-services/services/utils/differ.js

@@ -45,14 +45,8 @@ module.exports = class {
   }
 
   async _addPartialPersistentState(req) {
-    const deepUpdateData = await selectDeepUpdateData(
-      this._srv.model.definitions,
-      req.query,
-      req,
-      true,
-      true,
-      this._srv
-    )
+    // REVISIT: cds.context.model?
+    const deepUpdateData = await selectDeepUpdateData(this._srv, this._srv.model, req, true)
     req._.partialPersistentState = deepUpdateData
   }
 

package/libx/_runtime/common/aspects/Association.js

@@ -1,11 +1,24 @@
 // global.cds is used on purpose here!
 const cds = global.cds
 
+// requesting logger without module on purpose!
+const LOG = cds.log()
+
 const ODATA_CONTAINED = '@odata.contained'
 
 const { isSelfManaged, isBacklink, getAnchor, getBacklink } = require('./utils')
 const { foreignKeyPropagations } = require('../utils/foreignKeyPropagations')
 
+const _logDeprecationForODataContained = () => {
+  if (!cds._deprecationWarningForODataContained) {
+    LOG._warn &&
+      LOG.warn(
+        'Annotation "@odata.contained" is deprecated and will be removed in an upcoming release. Use compositions instead of associations.'
+      )
+    cds._deprecationWarningForODataContained = true
+  }
+}
+
 module.exports = class {
   get _isAssociationStrict() {
     return (
@@ -15,6 +28,7 @@ module.exports = class {
   }
 
   get _isAssociationEffective() {
+    this[ODATA_CONTAINED] && _logDeprecationForODataContained()
     return (
       this.own('__isAssociationEffective') ||
       this.set(
@@ -25,6 +39,7 @@ module.exports = class {
   }
 
   get _isCompositionEffective() {
+    this[ODATA_CONTAINED] && _logDeprecationForODataContained()
     return (
       this.own('__isCompositionEffective') ||
       this.set(
@@ -36,6 +51,7 @@ module.exports = class {
   }
 
   get _isContained() {
+    this[ODATA_CONTAINED] && _logDeprecationForODataContained()
     return (
       this.own('__isContained') ||
       this.set(

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

@@ -120,26 +120,26 @@ const _subWhere = (result, element) => {
   if (links && links.length > 0) {
     where = []
     for (const row of result) {
-      if (where.length > 0) {
-        where.push('or')
-      }
       const whereObj = links.reduce((res, currentLink) => {
-        if (Object.prototype.hasOwnProperty.call(row, currentLink.targetKey))
+        if (Object.prototype.hasOwnProperty.call(row, currentLink.targetKey) && row[currentLink.targetKey] !== null)
           res[currentLink.entityKey] = row[currentLink.targetKey]
         return res
       }, {})
       const whereCQN = ctUtils.whereKey(whereObj)
-      if (whereCQN.length) where.push('(', ...whereCQN, ')')
+      if (whereCQN.length) {
+        if (where.length > 0) where.push('or')
+        where.push('(', ...whereCQN, ')')
+      }
     }
   }
   return where
 }
 
-const _mergeResults = (result, selectData, root, definitions, compositionTree, entityName) => {
+const _mergeResults = (result, selectData, root, model, compositionTree, entityName) => {
   if (root) {
     return [...selectData, ...result]
   } else {
-    const parent = definitions[compositionTree.target] || definitions[entityName]
+    const parent = model.definitions[compositionTree.target] || model.definitions[entityName]
     const assoc = (parent && parent.elements[compositionTree.name]) || {}
     return selectData.map(selectEntry => {
       if (assoc.is2one) {
@@ -148,8 +148,9 @@ const _mergeResults = (result, selectData, root, definitions, compositionTree, e
         selectEntry[compositionTree.name] = selectEntry[compositionTree.name] || []
       }
       const newData = _findWhere(result, _parentKey(compositionTree, selectEntry))
-      if (assoc.is2one && newData[0]) {
-        selectEntry[compositionTree.name] = Object.assign(selectEntry[compositionTree.name], newData[0])
+      if (assoc.is2one) {
+        if (newData[0]) selectEntry[compositionTree.name] = Object.assign(selectEntry[compositionTree.name], newData[0])
+        else selectEntry[compositionTree.name] = null
       } else if (assoc.is2many) {
         selectEntry[compositionTree.name].push(...newData)
       }
@@ -158,14 +159,14 @@ const _mergeResults = (result, selectData, root, definitions, compositionTree, e
   }
 }
 
-const _columns = (entity, data, compositionTree, selectAll) => {
+const _columns = (entity, data, compositionTree, selectAllColumns) => {
   const backLinkKeys = _getLinksOfCompTree(compositionTree)
   const columns = []
   for (const elementName in entity.elements) {
     const element = entity.elements[elementName]
     if (element.virtual || element.isAssociation) continue
     if (
-      selectAll ||
+      selectAllColumns ||
       element.key ||
       backLinkKeys.includes(element.name) ||
       (Array.isArray(data) && data.find(entry => element.name in entry))
@@ -177,45 +178,42 @@ const _columns = (entity, data, compositionTree, selectAll) => {
 }
 
 const _select = ({
-  definitions,
+  model,
   entityName,
   draft,
   alias,
   compositionTree,
   data,
-  root,
-  includeAllRootColumns,
-  includeAllColumns,
+  selectAllColumns,
   where,
   parentKeys,
   orderBy,
   singleton
 }) => {
-  const entity = definitions && definitions[entityName]
+  const entity = model.definitions[entityName]
   const from = ctUtils.addDraftSuffix(draft, entity.name)
   const selectCQN = SELECT.from(from)
   if (alias) selectCQN.SELECT.from.as = alias
-  const selectAll = includeAllColumns || (includeAllRootColumns && root)
-  selectCQN.SELECT.columns = _columns(entity, data, compositionTree, selectAll)
+  selectCQN.SELECT.columns = _columns(entity, data, compositionTree, selectAllColumns)
   if (where) selectCQN.SELECT.where = where
   else if (parentKeys) selectCQN.SELECT.where = _whereKeys(parentKeys)
   if (orderBy) selectCQN.SELECT.orderBy = orderBy
   if (singleton) selectCQN.SELECT.limit = { rows: { val: 1 } }
   // REVISIT: remove once SELECT builder does flattening!
-  return cqn2cqn4sql(selectCQN, { definitions })
+  return cqn2cqn4sql(selectCQN, model)
 }
 
 const _selectDeepUpdateData = async args => {
-  const { definitions, compositionTree, entityName, data, includeAllColumns, root, selectData, tx } = args
+  const { model, compositionTree, entityName, data, root, selectData, tx, selectAllColumns } = args
   const selectCQN = _select(args)
   const result = await tx.run(selectCQN)
   if (!result.length) return Promise.resolve(result)
 
-  const keys = _keys(definitions[entityName], result)
+  const keys = _keys(model.definitions[entityName], result)
   await Promise.all(
     compositionTree.compositionElements.map(element => {
       if (element.skipPersistence) return Promise.resolve()
-      if (data !== undefined && !data.find(entry => element.name in entry) && !(includeAllColumns && result.length))
+      if (data !== undefined && !data.find(entry => element.name in entry) && !(selectAllColumns && result.length))
         return Promise.resolve()
       const subs = {
         compositionTree: element,
@@ -235,23 +233,17 @@ const _selectDeepUpdateData = async args => {
     })
   )
 
-  return _mergeResults(result, selectData || [], root, definitions, compositionTree, entityName)
+  return _mergeResults(result, selectData || [], root, model, compositionTree, entityName)
 }
 
 /*
  * exports
  */
 
-const selectDeepUpdateData = (
-  definitions,
-  cqn,
-  req,
-  includeAllRootColumns = false,
-  includeAllColumns = false,
-  service
-) => {
+const selectDeepUpdateData = (service, model, req, selectAllColumns = false) => {
+  const query = req.query
   // REVISIT this should be done somewhere before, so it is not done twice for deep updates
-  const sqlQuery = cqn2cqn4sql(cqn, { definitions })
+  const sqlQuery = cqn2cqn4sql(query, model)
 
   if (req && _isSameEntity(sqlQuery, req)) {
     return Promise.resolve(req._.partialPersistentState)
@@ -263,9 +255,9 @@ const selectDeepUpdateData = (
   const entityName = ensureNoDraftsSuffix(from)
   const draft = entityName !== from
   const orderBy = req && req.target && req.target.query && req.target.query.SELECT && req.target.query.SELECT.orderBy
-  const data = Object.assign({}, sqlQuery.UPDATE.data || {}, cqn.UPDATE.with || {})
+  const data = Object.assign({}, sqlQuery.UPDATE.data || {}, query.UPDATE.with || {})
   const compositionTree = getCompositionTree({
-    definitions,
+    definitions: model.definitions,
     rootEntityName: entityName, // REVISIT: drafts are resolved too eagerly
     checkRoot: false,
     resolveViews: !draft,
@@ -274,17 +266,16 @@ const selectDeepUpdateData = (
 
   return _selectDeepUpdateData({
     tx: cds.tx(req),
-    definitions,
+    model,
     compositionTree,
     entityName,
     data: [data],
     where,
     orderBy,
     draft,
-    includeAllRootColumns,
     singleton: req && req.target && req.target._isSingleton,
     alias,
-    includeAllColumns: cqn._selectAll || includeAllColumns,
+    selectAllColumns,
     root: true,
     service
   })

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 { hasDeepUpdate, getDeepUpdateCQNs } = require('./update')
-const { hasDeepDelete, getDeepDeleteCQNs } = require('./delete')
+const { hasDeepDelete, getDeepDeleteCQNs, getSetNullParentForeignKeyCQNs } = require('./delete')
 const { selectDeepUpdateData } = require('./data')
 
 module.exports = {
@@ -18,6 +18,7 @@ module.exports = {
   // delete
   hasDeepDelete,
   getDeepDeleteCQNs,
+  getSetNullParentForeignKeyCQNs,
   // data
   selectDeepUpdateData
 }