@cap-js/db-service 1.0.0

package/lib/deep-queries.js

@@ -0,0 +1,244 @@
+const cds = require('@sap/cds')
+const { compareJson } = require('@sap/cds/libx/_runtime/cds-services/services/utils/compareJson')
+const { _target_name4 } = require('./SQLService')
+
+const handledDeep = Symbol('handledDeep')
+
+async function onDeep(req, next) {
+  const { query } = req
+  // REVISIT: req.target does not match the query.INSERT target for path insert
+  // const target = query.sources[Object.keys(query.sources)[0]]
+  if (!this.model?.definitions[_target_name4(req.query)]) {
+    return next()
+  }
+  const { target } = this.infer(query)
+  if (!hasDeep(query, target)) return next()
+  const beforeData = query.INSERT ? [] : await this.run(getExpandForDeep(query, target, true))
+
+  if (query.UPDATE && !beforeData.length) {
+    return 0
+  }
+
+  const queries = getDeepQueries(query, beforeData, target)
+  const res = await Promise.all(
+    queries.map(query => {
+      if (query.INSERT) return this.onINSERT({ query })
+      if (query.UPDATE) return this.onUPDATE({ query })
+      if (query.DELETE) return this.onSIMPLE({ query })
+    }),
+  )
+  return res[0] ?? 0 // TODO what todo with multiple result responses?
+}
+
+const hasDeep = (query, target) => {
+  if (handledDeep in query) return
+  if (query.DELETE) {
+    for (let c in target?.compositions) return true
+    return false
+  }
+  const data =
+    query.INSERT?.entries || (query.UPDATE?.data && [query.UPDATE.data]) || (query.UPDATE?.with && [query.UPDATE.with])
+  if (data)
+    for (const c in target.compositions) {
+      for (const row of data) if (row[c] !== undefined) return true
+    }
+}
+
+// unofficial config!
+const DEEP_DELETE_MAX_RECURSION_DEPTH =
+  (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 4 // we use 4 here as our test data has a max depth of 3
+
+// IMPORTANT: Skip only if @cds.persistence.skip is `true` → e.g. this skips skipping targets marked with @cds.persistence.skip: 'if-unused'
+const _hasPersistenceSkip = target => target?.['@cds.persistence.skip'] === true
+
+const getColumnsFromDataOrKeys = (data, target) => {
+  if (Array.isArray(data)) {
+    // loop and get all columns from current level
+    const columns = new Set()
+    data.forEach(row =>
+      Object.keys(row || target.keys)
+        .filter(propName => !target.elements[propName]?.isAssociation)
+        .forEach(entry => {
+          columns.add(entry)
+        }),
+    )
+    return Array.from(columns).map(c => ({ ref: [c] }))
+  } else {
+    // get all columns from current level
+    return Object.keys(data || target.keys)
+      .filter(propName => target.elements[propName] && !target.elements[propName].isAssociation)
+      .map(c => ({ ref: [c] }))
+  }
+}
+
+const _calculateExpandColumns = (target, data, expandColumns = [], elementMap = new Map()) => {
+  const compositions = target.compositions || {}
+
+  if (expandColumns.length === 0) {
+    // REVISIT: ensure that all keys are included in the expand columns
+    expandColumns.push(...getColumnsFromDataOrKeys(data, target))
+  }
+
+  for (const compName in compositions) {
+    let compositionData
+    if (data === null || (Array.isArray(data) && !data.length)) {
+      compositionData = null
+    } else {
+      compositionData = data[compName]
+    }
+
+    // ignore not provided compositions as nothing happens with them (expect deep delete)
+    if (compositionData === undefined) {
+      // fill columns in case
+      continue
+    }
+
+    const composition = compositions[compName]
+
+    const fqn = composition.parent.name + ':' + composition.name
+    const seen = elementMap.get(fqn)
+    if (seen && seen >= DEEP_DELETE_MAX_RECURSION_DEPTH) {
+      // recursion -> abort
+      return
+    }
+
+    let expandColumn = expandColumns.find(expandColumn => expandColumn.ref[0] === composition.name)
+    if (!expandColumn) {
+      expandColumn = {
+        ref: [composition.name],
+        expand: getColumnsFromDataOrKeys(compositionData, composition._target),
+      }
+
+      expandColumns.push(expandColumn)
+    }
+
+    // expand deep
+    // 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)
+
+    if (composition.is2many) {
+      // expandColumn.expand = getColumnsFromDataOrKeys(compositionData, composition._target)
+      if (compositionData === null || compositionData.length === 0) {
+        // deep delete, get all subitems until recursion depth
+        _calculateExpandColumns(composition._target, null, expandColumn.expand, newElementMap)
+        continue
+      }
+
+      for (const row of compositionData) {
+        _calculateExpandColumns(composition._target, row, expandColumn.expand, newElementMap)
+      }
+    } else {
+      // to one
+      _calculateExpandColumns(composition._target, compositionData, expandColumn.expand, newElementMap)
+    }
+  }
+}
+
+const getExpandForDeep = (query, target) => {
+  const from = query.DELETE?.from || query.UPDATE?.entity
+  const data = query.UPDATE?.data || null
+  const where = query.DELETE?.where || query.UPDATE?.where
+
+  const cqn = SELECT.from(from)
+  if (where) cqn.SELECT.where = where
+
+  const columns = []
+  _calculateExpandColumns(target, data, columns)
+  cqn.columns(columns)
+  return cqn
+}
+
+const getDeepQueries = (query, dbData, target) => {
+  let queryData
+  if (query.INSERT) {
+    queryData = query.INSERT.entries
+  }
+  if (query.DELETE) {
+    queryData = []
+  }
+  if (query.UPDATE) {
+    queryData = [query.UPDATE.data]
+  }
+
+  let diff = compareJson(queryData, dbData, target)
+  if (!Array.isArray(diff)) {
+    diff = [diff]
+  }
+
+  return _getDeepQueries(diff, target)
+}
+
+const _hasManagedElements = target => {
+  return Object.keys(target.elements).filter(elementName => target.elements[elementName]['@cds.on.update']).length > 0
+}
+
+const _getDeepQueries = (diff, target) => {
+  const queries = []
+
+  for (const diffEntry of diff) {
+    if (diffEntry === undefined) continue
+    const subQueries = []
+
+    for (const prop in diffEntry) {
+      // handle deep operations
+
+      const propData = diffEntry[prop]
+
+      if (target.elements[prop] && _hasPersistenceSkip(target.elements[prop]._target)) {
+        delete diffEntry[prop]
+      } else if (target.compositions?.[prop]) {
+        const arrayed = Array.isArray(propData) ? propData : [propData]
+        arrayed.forEach(subEntry => {
+          subQueries.push(..._getDeepQueries([subEntry], target.elements[prop]._target))
+        })
+        delete diffEntry[prop]
+      } else if (diffEntry[prop] === undefined) {
+        // restore current behavior, if property is undefined, not part of payload
+        delete diffEntry[prop]
+      }
+    }
+
+    // handle current entity level
+    const op = diffEntry._op
+    delete diffEntry._op
+
+    if (diffEntry._old != null) {
+      delete diffEntry._old
+    }
+
+    // first calculate subqueries and rm their properties, then build root query
+    if (op === 'create') {
+      queries.push(INSERT.into(target).entries(diffEntry))
+    } else if (op === 'delete') {
+      queries.push(DELETE.from(target).where(diffEntry))
+    } else if (op === 'update' || (op === undefined && subQueries.length && _hasManagedElements(target))) {
+      // TODO do we need the where here?
+      const keys = target.keys
+      const cqn = UPDATE(target).with(diffEntry)
+      for (const key in keys) {
+        if (keys[key].virtual) continue
+        if (!keys[key].isAssociation) {
+          cqn.where(key + '=', diffEntry[key])
+        }
+        delete diffEntry[key]
+      }
+      cqn.with(diffEntry)
+      queries.push(cqn)
+    }
+
+    queries.push(...subQueries)
+  }
+
+  queries.forEach(q => {
+    Object.defineProperty(q, handledDeep, { value: true })
+  })
+  return queries
+}
+
+module.exports = {
+  onDeep,
+  getDeepQueries,
+  getExpandForDeep,
+}

package/lib/fill-in-keys.js

@@ -0,0 +1,65 @@
+const cds = require('@sap/cds')
+
+// REVISIT: very deep & fragile dependencies to internal modules -> copy these into here
+const propagateForeignKeys = require('@sap/cds/libx/_runtime/common/utils/propagateForeignKeys')
+const { enrichDataWithKeysFromWhere } = require('@sap/cds/libx/_runtime/common/utils/keys')
+
+const generateUUIDandPropagateKeys = (target, data, event) => {
+  if (!data) return
+  const keys = target.keys
+  for (const key in keys) {
+    if (keys[key].type === 'cds.UUID' && !data[key] && event === 'CREATE') {
+      data[key] = cds.utils.uuid()
+    }
+  }
+  const elements = target.elements
+  for (const element in elements) {
+    // if assoc keys are structured, do not ignore them, as they need to be flattened in propagateForeignKeys
+    if (
+      elements[element].key &&
+      !(elements[element]._isAssociationStrict && elements[element].is2one && element in data)
+    ) {
+      continue
+    }
+
+    if (elements[element].is2one || elements[element].is2many) {
+      let subData = data[element]
+      if (subData) {
+        if (!Array.isArray(subData)) {
+          subData = [subData]
+        }
+        for (const sub of subData) {
+          // For subData the event is set to 'CREATE' as require UUID generation
+          generateUUIDandPropagateKeys(elements[element]._target, sub, 'CREATE')
+        }
+      }
+
+      propagateForeignKeys(element, data, elements[element]._foreignKeys, elements[element].isComposition, {
+        deleteAssocs: true,
+      })
+    }
+  }
+}
+
+module.exports = async function fill_in_keys(req, next) {
+  // REVISIT dummy handler until we have input processing
+  if (!req.target || !this.model || req.target._unresolved) return next()
+
+  if (req.event === 'UPDATE') {
+    // REVISIT for deep update we need to inject the keys first
+    enrichDataWithKeysFromWhere(req.data, req, this)
+  }
+
+  // REVISIT no input processing for INPUT with rows/values
+  if (req.event !== 'DELETE' && !(req.query.INSERT?.rows || req.query.INSERT?.values)) {
+    if (Array.isArray(req.data)) {
+      for (const d of req.data) {
+        generateUUIDandPropagateKeys(req.target, d, req.event)
+      }
+    } else {
+      generateUUIDandPropagateKeys(req.target, req.data, req.event)
+    }
+  }
+
+  return next()
+}