@sap/cds 8.9.4 → 9.0.2

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

@@ -1,370 +0,0 @@
-const { getCompositionTree } = require('./tree')
-const ctUtils = require('./utils')
-const { getEntityNameFromUpdateCQN } = require('../utils/cqn')
-const { ensureNoDraftsSuffix } = require('../utils/draft')
-const { cqn2cqn4sql } = require('../utils/cqn2cqn4sql')
-const cds = require('../../cds')
-const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
-const { SELECT } = cds.ql
-
-const CHUNK_SIZE = cds.env.features.chunk_deep ?? Number.MAX_VALUE
-
-/*
- * own utils
- */
-
-const _isSameEntityInWhere = (where, target, persistentObj) => {
-  for (let i = 0; i < where.length; i++) {
-    if (where[i].xpr) {
-      const res = _isSameEntityInWhere(where[i].xpr, target, persistentObj)
-      if (!res) return res
-      continue
-    }
-
-    if (!where[i] || !where[i].ref || !target.elements[where[i].ref]) {
-      continue
-    }
-
-    const key = where[i].ref
-    const val = where[i + 2].val
-    const sign = where[i + 1]
-
-    if (target.elements[key].key && key in persistentObj && sign === '=' && val !== persistentObj[key]) {
-      return false
-    }
-  }
-
-  return true
-}
-
-const _isSameEntity = (cqn, req) => {
-  const where = cqn.UPDATE.where || []
-  const persistentObj = Array.isArray(req._.partialPersistentState)
-    ? req._.partialPersistentState[0]
-    : req._.partialPersistentState
-
-  if (!persistentObj) {
-    // If no data was found we don't know if it is the same entity
-    return false
-  }
-
-  const target = cds.ql.resolve.table(req.target)
-  if (target.name !== (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) && target.name !== cqn.UPDATE.entity) {
-    return false
-  }
-
-  return _isSameEntityInWhere(where, target, persistentObj)
-}
-
-const _getLinksOfCompTree = compositionTree => {
-  const links = []
-
-  for (const link of [...compositionTree.backLinks, ...compositionTree.customBackLinks]) {
-    links.push(link.entityKey)
-  }
-
-  for (const compElement of compositionTree.compositionElements || []) {
-    for (const link of [...compElement.backLinks, ...compElement.customBackLinks]) {
-      links.push(link.targetKey)
-    }
-  }
-
-  return links
-}
-
-const _whereKeys = keySet => {
-  if (!keySet.length || !Object.keys(keySet[0]).length) return []
-
-  const keys0 = Object.keys(keySet[0])
-  const keys = { list: keys0.map(pk => ({ ref: [pk] })) }
-  const values = {
-    list: keySet.map(row => ({
-      list: keys0.map(k => ({ val: row[k] }))
-    }))
-  }
-
-  return [keys, 'in', values]
-}
-
-const _parentKey = (element, key) => {
-  let links = [...element.customBackLinks, ...element.backLinks]
-  if (element.is2one && links.some(l => l.for2one)) links = links.filter(l => l.for2one)
-
-  return links.reduce((parentKey, customBackLink) => {
-    // TODO: why Object.prototype.hasOwnProperty?
-    parentKey[customBackLink.entityKey] = Object.prototype.hasOwnProperty.call(key, customBackLink.targetKey)
-      ? key[customBackLink.targetKey]
-      : customBackLink.targetVal
-
-    // nested
-    if (!parentKey[customBackLink.entityKey]) {
-      const splitted = customBackLink.targetKey.split('_')
-      let current
-      let joined = ''
-      while (splitted.length > 1) {
-        if (joined) joined += '_'
-        joined += splitted.shift()
-        if (Object.prototype.hasOwnProperty.call(key, joined)) current = key[joined]
-      }
-      if (current) parentKey[customBackLink.entityKey] = current[splitted[0]]
-    }
-
-    return parentKey
-  }, {})
-}
-
-const _findWhere = (data, where) => {
-  return data.filter(entry => {
-    return Object.keys(where).every(key => {
-      if (Buffer.isBuffer(entry[key]) && Buffer.isBuffer(where[key])) {
-        return Buffer.compare(entry[key], where[key]) === 0
-      }
-      return where[key] === entry[key]
-    })
-  })
-}
-
-const _keys = (entity, data) => data.map(entry => ctUtils.key(entity, entry))
-
-const _parentKeys = (element, keys) => {
-  return keys.map(key => _parentKey(element, key)).filter(ele => Object.keys(ele).length)
-}
-
-const _subData = (data, prop) =>
-  data &&
-  data.reduce((result, entry) => {
-    if (prop in entry) {
-      const elementValue = ctUtils.val(entry[prop])
-      for (const val of ctUtils.array(elementValue)) result.push(val)
-    }
-    return result
-  }, [])
-
-const _getWhereObj = (row, links) => {
-  return links.reduce((res, currentLink) => {
-    if (Object.prototype.hasOwnProperty.call(row, currentLink.targetKey) && row[currentLink.targetKey] !== null)
-      res[currentLink.entityKey] = row[currentLink.targetKey]
-    else if (currentLink.targetVal !== undefined) res[currentLink.entityKey] = currentLink.targetVal
-    return res
-  }, {})
-}
-
-const _subWhere = (result, element) => {
-  let where
-  let links = [...element.backLinks, ...element.customBackLinks]
-
-  if (element.is2one && links.some(l => l.for2one)) links = links.filter(l => l.for2one)
-
-  if (result.length && links && links.length > 0) {
-    where = {}
-    const keys0 = Object.keys(_getWhereObj(result[0], links))
-
-    if (keys0.length) {
-      const keys = { list: keys0.map(pk => ({ ref: [pk] })) }
-
-      for (let i = 0; i < result.length; i += CHUNK_SIZE) {
-        const values = {
-          list: result.slice(i, i + CHUNK_SIZE).map(row => ({
-            list: keys0.map(k => {
-              return { val: _getWhereObj(row, links)[k] }
-            })
-          }))
-        }
-        where[i] = [keys, 'in', values]
-      }
-    }
-  }
-
-  return where
-}
-
-const _mergeResults = (result, selectData, root, model, compositionTree, entityName) => {
-  if (root) {
-    return [...selectData, ...result]
-  }
-
-  const parent = model.definitions[compositionTree.target] || model.definitions[entityName]
-  const assoc = (parent && parent.elements[compositionTree.name]) || {}
-
-  return selectData.map(selectEntry => {
-    if (assoc.is2one) {
-      selectEntry[compositionTree.name] = selectEntry[compositionTree.name] || {}
-    } else if (assoc.is2many) {
-      selectEntry[compositionTree.name] = selectEntry[compositionTree.name] || []
-    }
-
-    const newData = _findWhere(result, _parentKey(compositionTree, selectEntry))
-    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) {
-      const entry = selectEntry[compositionTree.name]
-      for (const val of newData) entry.push(val)
-    }
-
-    return selectEntry
-  })
-}
-
-const _columns = (entity, data, compositionTree, selectAllColumns, draft) => {
-  const backLinkKeys = _getLinksOfCompTree(compositionTree)
-  const columns = []
-
-  for (const elementName in entity.elements) {
-    const element = entity.elements[elementName]
-    if (element.virtual || element.isAssociation) continue
-    if (!draft && elementName in DRAFT_COLUMNS_MAP) continue
-
-    if (
-      selectAllColumns ||
-      element.key ||
-      backLinkKeys.includes(element.name) ||
-      (Array.isArray(data) && data.find(entry => element.name in entry))
-    ) {
-      columns.push({ ref: [element.name] })
-    }
-  }
-
-  return columns
-}
-
-const _select = ({
-  model,
-  entityName,
-  draft,
-  alias,
-  compositionTree,
-  data,
-  selectAllColumns,
-  where,
-  parentKeys,
-  orderBy,
-  singleton
-}) => {
-  const entity = model.definitions[entityName]
-  const from = ctUtils.addDraftSuffix(draft, entity.name)
-  const selectCQN = SELECT.from(from)
-  if (alias) selectCQN.SELECT.from.as = alias
-  selectCQN.SELECT.columns = _columns(entity, data, compositionTree, selectAllColumns, draft)
-  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, model)
-}
-
-const _selectDeepUpdateData = async args => {
-  const { model, compositionTree, entityName, data, root, selectData, tx, selectAllColumns, where, parentKeys } = args
-  let result = []
-
-  if (!where && parentKeys && parentKeys.length && Object.keys(parentKeys[0]).length) {
-    const keys0 = Object.keys(parentKeys[0])
-    const keys = { list: keys0.map(pk => ({ ref: [pk] })) }
-    for (let i = 0; i < parentKeys.length; i += CHUNK_SIZE) {
-      const values = {
-        list: parentKeys.slice(i, i + CHUNK_SIZE).map(row => ({ list: keys0.map(k => ({ val: row[k] })) }))
-      }
-      const _args = { ...args, where: [keys, 'in', values], parentKeys: undefined }
-      const selectCQN = _select(_args)
-      result = result.concat(await tx.run(selectCQN))
-    }
-  } else if (where && !Array.isArray(where)) {
-    for (let w of Object.values(where)) {
-      const _args = { ...args, where: w }
-      const selectCQN = _select(_args)
-      result = result.concat(await tx.run(selectCQN))
-    }
-  } else {
-    const selectCQN = _select(args)
-    result = await tx.run(selectCQN)
-  }
-
-  if (!result.length) return Promise.resolve(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) && !(selectAllColumns && result.length))
-        return Promise.resolve()
-      const subs = {
-        compositionTree: element,
-        entityName: element.source,
-        data: _subData(data, element.name),
-        where: _subWhere(result, element),
-        selectData: result,
-        parentKeys: _parentKeys(element, keys),
-        orderBy: false,
-        root: false
-      }
-
-      subs.data = subs.data.filter(d => d) // REVISIT: remove null elements
-      return _selectDeepUpdateData({ ...args, ...subs })
-    })
-  )
-
-  return _mergeResults(result, selectData || [], root, model, compositionTree, entityName)
-}
-
-// if a view has an orderBy with renamed field, we need to resolve it
-const _resolveOrderBy = (orderBy, transitions) => {
-  // no resolved entity found
-  if (!transitions?.length) return
-
-  // if there are no renamed fields, no need to resolve
-  if (!transitions[0].mapping.size) return
-  if (orderBy) orderBy.map(el => (el.ref[0] = transitions[0].mapping.get(el.ref[0]).ref[0]))
-}
-
-/*
- * exports
- */
-
-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
-  // REVISIT: this is done (better) in the new db-services
-  const sqlQuery = cqn2cqn4sql(query, model)
-
-  if (req && _isSameEntity(sqlQuery, req)) {
-    return Promise.resolve(req._.partialPersistentState)
-  }
-
-  const from = getEntityNameFromUpdateCQN(sqlQuery)
-  const alias = sqlQuery.UPDATE.entity.as
-  // if parts of (another) query are re-used make sure to get your own copy
-  const where = cds.clone(sqlQuery.UPDATE.where) || []
-  const entityName = ensureNoDraftsSuffix(from)
-  const draft = entityName !== from
-  const orderBy = req?.target?.query?.SELECT?.orderBy ? cds.clone(req?.target?.query?.SELECT?.orderBy) : null
-  _resolveOrderBy(orderBy, sqlQuery.UPDATE._transitions)
-  const data = Object.assign({}, sqlQuery.UPDATE.data || {}, query.UPDATE.with || {})
-  const compositionTree = getCompositionTree({
-    definitions: model.definitions,
-    rootEntityName: entityName, // REVISIT: drafts are resolved too eagerly
-    resolveViews: !draft,
-    service
-  })
-
-  return _selectDeepUpdateData({
-    tx: cds.tx(req),
-    model,
-    compositionTree,
-    entityName,
-    data: [data],
-    where,
-    orderBy,
-    draft,
-    singleton: req?.target?._isSingleton,
-    alias,
-    selectAllColumns,
-    root: true,
-    service
-  })
-}
-
-module.exports = {
-  selectDeepUpdateData
-}

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

@@ -1,313 +0,0 @@
-const cds = require('../../cds')
-
-const { getCompositionTree } = require('./tree')
-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
- */
-
-// 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)) 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' || 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 = {}) {
-  const allBackLinks = [...element.backLinks, ...element.customBackLinks]
-  let entity1, entity2
-  const linksForWhere = allBackLinks.length ? allBackLinks : element.links
-
-  const subWhere = linksForWhere.reduce((result, backLink) => {
-    // exclude static values from subwhere
-    if (backLink.entityKey && !backLink.targetKey && backLink.targetVal !== undefined) {
-      return result
-    }
-    if (result.length > 0) {
-      result.push('and')
-    }
-
-    entity1 = {
-      alias: `ALIAS${level + 1}`,
-      entityName: ctUtils.addDraftSuffix(draft, element.source),
-      propertyName: backLink.entityKey
-    }
-
-    const res1 = backLink.entityKey ? { ref: [entity1.alias, entity1.propertyName] } : { val: backLink.entityVal }
-
-    entity2 = {
-      alias: `ALIAS${level}`,
-      entityName: ctUtils.addDraftSuffix(draft, element.target || element.source),
-      propertyName: backLink.targetKey
-    }
-
-    const res2 = backLink.targetKey ? { ref: [entity2.alias, entity2.propertyName] } : { val: backLink.targetVal }
-
-    result.push(res1, '=', res2)
-    return result
-  }, [])
-
-  const where = []
-  if (!subWhere.length) return { where, entity1, entity2 }
-
-  let whereKeys = _getWhereKeys(allBackLinks, entity1)
-  const staticWhereValues = _getStaticWhere(allBackLinks, entity1)
-  if (whereKeys.length === 0 && element.links.length === 1) {
-    // add is null check for each unused backlink
-    for (const ce of compositionTree.compositionElements || []) {
-      if (ce.source !== element.source) continue
-      if (ce.name === element.name) continue
-      const wk = _getWhereKeys([...ce.backLinks, ...ce.customBackLinks], entity1, 'null')
-      if (whereKeys.length === 0) whereKeys = wk
-      else whereKeys.push('and', ...wk)
-    }
-  }
-
-  if (whereKeys.length > 0) {
-    where.push({ xpr: [...whereKeys] }, 'and')
-  }
-  if (staticWhereValues.length > 0) {
-    where.push({ xpr: [...staticWhereValues] }, 'and')
-  }
-  where.push('exists', {
-    SELECT: {
-      columns: [{ val: 1, as: '_exists' }],
-      from: { ref: [entity2.entityName], as: entity2.alias },
-      where: parentWhere && parentWhere.length ? [{ xpr: [...parentWhere] }, 'and', { xpr: [...subWhere] }] : subWhere
-    }
-  })
-
-  return {
-    where,
-    entity1,
-    entity2
-  }
-}
-
-function _getWhereKeys(allBackLinks, entity1, is) {
-  return allBackLinks.reduce((result, backLink) => {
-    // exclude static keys
-    if (backLink.entityKey && !backLink.targetKey && backLink.targetVal !== undefined) {
-      return result
-    }
-    if (result.length > 0) {
-      result.push('or')
-    }
-    if (backLink.entityKey && is) {
-      result.push({ ref: [entity1.alias, backLink.entityKey] }, 'is ' + is)
-    } else if (backLink.entityVal !== undefined) {
-      // static values should not be included
-      result.pop()
-    }
-    return result
-  }, [])
-}
-
-function _getStaticWhere(allBackLinks, entity1) {
-  return allBackLinks.reduce((result, backLink) => {
-    if (result.length > 0) {
-      result.push('and')
-    }
-    if (backLink.entityKey && !backLink.targetKey && backLink.targetVal !== undefined) {
-      result.push({ ref: [entity1.alias, backLink.entityKey] }, '=', { val: backLink.targetVal })
-    }
-    return result
-  }, [])
-}
-
-const _addToCQNs = (cqns, subCQN, element, model, level) => {
-  // REVISIT:
-  // The compiler generates foreign-key constraints (if features.assert_integrity === 'db')
-  // and enables DELETE CASCADE. For these cases, the runtime doesn't need to delete compositions
-  // manually, it's done by the database itself.
-  // However, there are cases (unmanaged compositions), where this doesn't happen.
-  // As a first step, the runtime will delete _all_ compositions regardless of the database.
-  // In the future, the runtime can enable the deletion of only those compositions
-  // which wouldn't be deleted by the database.
-  cqns[level] = cqns[level] || []
-  cqns[level].push(subCQN)
-}
-
-// unofficial config!
-const DEEP_DELETE_MAX_RECURSION_DEPTH =
-  (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 2
-
-const _addSubCascadeDeleteCQN = (model, compositionTree, parentWhere, level, cqns, draft, elementMap = new Map()) => {
-  for (const element of compositionTree.compositionElements) {
-    if (element.skipPersistence) continue
-
-    const fqn = compositionTree.source + ':' + element.name
-    const seen = elementMap.get(fqn)
-    if (seen && seen >= DEEP_DELETE_MAX_RECURSION_DEPTH) {
-      // recursion -> abort
-      continue
-    }
-
-    // REVISIT: sometimes element.target is undefined which leads to self join
-    if (!element.target) element.target = compositionTree.source
-
-    const { entity1, where } = _getSubWhereAndEntities(element, parentWhere, draft, level, compositionTree)
-    if (where.length) {
-      const subCQN = { DELETE: { from: { ref: [entity1.entityName], as: entity1.alias }, where: where } }
-
-      _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(model, element, subCQN.DELETE.where, level + 1, cqns, draft, newElementMap)
-    }
-  }
-
-  return cqns
-}
-
-/*
- * exports
- */
-
-const hasDeepDelete = (model, cqn) => {
-  const from = getEntityNameFromDeleteCQN(cqn)
-  if (!from) return false
-
-  // hidden flag for DELETEs on draft root, we have a separate mechanism that deletes the rows using the DraftUUID
-  // Hence, we do not need a deep delete in that case.
-  if (cqn._suppressDeepDelete) return false
-
-  const entity = model.definitions[ensureNoDraftsSuffix(from)]
-
-  if (entity) return !!Object.keys(entity.elements || {}).find(k => entity.elements[k].isComposition)
-
-  return false
-}
-
-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 }
-}
-
-const _getDataFromOncond = (onCond, parent) => {
-  return onCond.reduce((res, e) => {
-    if (e.xpr) {
-      return Object.assign(res, _getDataFromOncond(e.xpr, parent))
-    }
-    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 getSetNullParentForeignKeyCQNs = async (model, req, dbQuery) => {
-  const cqns = []
-  const query = dbQuery || req.query
-  // REVISIT: req._tx should not be used like that!
-  const origQuery = (req.tx.isDatabaseService && 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.isComposition && element.is2one) {
-      const onCond = element && parent._relations[element.name].join('$$whatever', '$$parent')
-      const data = _getDataFromOncond(onCond, parent)
-      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 = _getDataFromOncond(onCond, parent)
-      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 cqns
-}
-
-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: model.definitions,
-    rootEntityName: entityName,
-    resolveViews: !draft,
-    service: cds.db
-  })
-  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,
-  getSetNullParentForeignKeyCQNs
-}

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

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