@sap/cds-dk 10.0.3 → 10.0.5

package/node_modules/@cap-js/db-service/lib/deep-queries.js

@@ -0,0 +1,290 @@
+const cds = require('@sap/cds')
+const { _target_name4 } = require('./SQLService')
+
+const ROOT = Symbol('root')
+
+const compareJson = require('@sap/cds/libx/_runtime/common/utils/compareJson').compareJson
+
+const handledDeep = Symbol('handledDeep')
+
+/**
+ * @callback nextCallback
+ * @param {Error|undefined} error
+ * @returns {Promise<unknown>}
+ */
+
+/**
+ * @param {import('@sap/cds/apis/services').Request} req
+ * @param {nextCallback} next
+ * @returns {Promise<number>}
+ */
+async function onDeep(req, next) {
+  const { query } = req
+  if (handledDeep in query) return next()
+
+  // 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()
+
+  if (!hasDeep(query)) return next()
+
+  const target = this.infer(query)._target
+  const beforeData = query.INSERT ? [] : await this.run(getExpandForDeep(query, target, true))
+  if (query.UPDATE && !beforeData.length) return 0
+
+  const queries = getDeepQueries(query, beforeData, target)
+
+  // first delete, then update, then insert because of potential unique constraints:
+  // - deletes never trigger unique constraints, but can prevent them -> execute first
+  // - updates can trigger and prevent unique constraints -> execute second
+  // - inserts can only trigger unique constraints -> execute last
+  await Promise.all(Array.from(queries.deletes.values()).map(query => this.onDELETE({ query, target: query._target })))
+  await Promise.all(queries.updates.map(query => this.onUPDATE({ query })))
+
+  const rootQuery = queries.inserts.get(ROOT)
+  queries.inserts.delete(ROOT)
+  const [rootResult] = await Promise.all([
+    rootQuery && this.onINSERT({ query: rootQuery }),
+    ...Array.from(queries.inserts.values()).map(query => this.onINSERT({ query })),
+  ])
+
+  return rootResult ?? beforeData.length
+}
+
+const hasDeep = (q) => {
+  const data = q.INSERT?.entries || (q.UPDATE?.data && [q.UPDATE.data]) || (q.UPDATE?.with && [q.UPDATE.with])
+  if (data)
+    for (const c in q._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 expandColumns
+    }
+
+    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)
+    }
+  }
+  return expandColumns
+}
+
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ */
+const getExpandForDeep = (query, target) => {
+  const { entity, data = null, where } = query.UPDATE
+  const columns = _calculateExpandColumns(target, data)
+  return SELECT(columns).from(entity).where(where)
+}
+
+/**
+ * @param {import('@sap/cds/apis/cqn').Query} query
+ * @param {unknown[]} dbData
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ * @returns
+ */
+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
+}
+
+/**
+ * @param {unknown[]} diff
+ * @param {import('@sap/cds/apis/csn').Definition} target
+ * @param {Map<String, Object>} deletes
+ * @param {Map<String, Object>} inserts
+ * @param {Object[]} updates
+ * @param {boolean} [root=true]
+ * @returns {Object|Boolean}
+ */
+const _getDeepQueries = (diff, target, deletes = new Map(), inserts = new Map(), updates = [], root = true) => {
+  // flag to determine if queries were created
+  let dirty = false
+  for (const diffEntry of diff) {
+    if (diffEntry === undefined) continue
+
+    let childrenDirty = false
+    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]
+        childrenDirty =
+          arrayed
+            .map(subEntry =>
+              _getDeepQueries([subEntry], target.elements[prop]._target, deletes, inserts, updates, false),
+            )
+            .some(a => a) || childrenDirty
+        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
+    }
+
+    if (op === 'create') {
+      dirty = true
+      const id = root ? ROOT : target.name
+      const insert = inserts.get(id)
+      if (insert) {
+        insert.INSERT.entries.push(diffEntry)
+      } else {
+        const q = INSERT.into(target).entries(diffEntry)
+        inserts.set(id, q)
+      }
+    } else if (op === 'delete') {
+      dirty = true
+      const keys = cds.utils
+        .Object_keys(target.keys)
+        .filter(key => !target.keys[key].virtual && !target.keys[key].isAssociation)
+
+      const keyVals = keys.map(k => ({ val: diffEntry[k] }))
+      const currDelete = deletes.get(target.name)
+      if (currDelete) currDelete.DELETE.where[2].list.push({ list: keyVals })
+      else {
+        const left = { list: keys.map(k => ({ ref: [k] })) }
+        const right = { list: [{ list: keyVals }] }
+        deletes.set(target.name, DELETE.from(target).where([left, 'in', right]))
+      }
+    } else if (op === 'update' || (op === undefined && (root || childrenDirty) && _hasManagedElements(target))) {
+      dirty = true
+      // 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)
+      updates.push(cqn)
+    }
+  }
+
+  return root ? { updates, inserts, deletes } : dirty
+}
+
+module.exports = {
+  onDeep,
+  hasDeep,
+  getDeepQueries, // only for testing
+  getExpandForDeep, // only for testing
+}

package/node_modules/@cap-js/db-service/lib/fill-in-keys.js

@@ -0,0 +1,75 @@
+const cds = require('@sap/cds')
+const { hasDeep } = require('./deep-queries')
+
+// 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 assoc4 = (e) => e.own('$fk4', ()=> {
+  const old = e['@odata.foreignKey4']; if (old) return old
+  if (!e.parent || !e.name || !e.name.includes('_')) return
+  if (e.name === 'ID_texts') return
+  if (e.name === 'DraftAdministrativeData_DraftUUID') return 'DraftAdministrativeData'
+  if (e.name.startsWith('up__')) return 'up_' // assumes up_ is a reserved name
+  const {elements} = e.parent, path = e.name.split('_')
+  for (let [p]=path, a, i=1; i < path.length; p += '_'+path[i++]) {
+    if ((a = elements[p])) {
+      if (a.keys) {
+        const tail = path.slice(i)
+        if (a.keys.some (k => k.ref.every((r,i) => r === tail[i]))) {
+          // process.stdout.write('> resolved assoc: ' + a.name + ' for: ' + this.name + '\n')
+          return a.name
+        }
+      }
+      return // not an assoc, or not the one we're looking for
+    }
+  }
+})
+
+const fkeys4 = (e) => {
+  let fkeys = e._foreignKeys
+  return typeof fkeys === 'function' ? fkeys.call(e) : fkeys
+}
+
+const generateUUIDandPropagateKeys = (entity, data, event) => {
+  if (event === 'CREATE') {
+    const keys = entity.keys
+    for (const k in keys)
+      if (keys[k].isUUID && !data[k] && !assoc4(keys[k]) && !keys[k].default) //> skip key assocs, and foreign keys thereof
+        data[k] = cds.utils.uuid()
+  }
+  for (const each in entity.elements) {
+    const e = entity.elements[each]
+    // if assoc keys are structured, do not ignore them, as they need to be flattened in propagateForeignKeys
+    if (!e.isAssociation || e.key && (e.isComposition || e.is2many || !(each in data))) continue
+    // propagate own foreign keys to propagate further to sub data
+    propagateForeignKeys (each, data, fkeys4(e), e.isComposition, { deleteAssocs: true, })
+
+    let subData = data[each]; if (!subData) continue
+    if (!Array.isArray(subData)) subData = [subData]
+    for (const sub of subData) {
+      // For subData the event is set to 'CREATE' as require UUID generation
+      generateUUIDandPropagateKeys (e._target, sub, 'CREATE')
+    }
+  }
+}
+
+
+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()
+  // only for deep update
+  if (req.event === 'UPDATE' && hasDeep(req.query)) {
+    // 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.query.INSERT?.rows || req.query.INSERT?.values)) {
+    let {data} = req; if (!Array.isArray(data)) data = [data]
+    for (const d of data) {
+      generateUUIDandPropagateKeys (req.target, d, req.event)
+    }
+  }
+  return next()
+}

package/node_modules/@cap-js/db-service/lib/infer/cqn.d.ts

@@ -0,0 +1,42 @@
+import * as cqn from '@sap/cds/apis/cqn'
+import * as csn from '@sap/cds/apis/csn'
+
+type linkedQuery = {
+  target: csn.Definition
+  elements: elements
+}
+export type SELECT = cqn.SELECT & linkedQuery
+export type INSERT = cqn.INSERT & linkedQuery
+export type UPSERT = cqn.UPSERT & linkedQuery
+export type UPDATE = cqn.UPDATE & linkedQuery
+export type DELETE = cqn.DELETE & linkedQuery
+export type CREATE = cqn.CREATE & linkedQuery
+export type DROP = cqn.DROP & linkedQuery
+
+export type Query = SELECT | INSERT | UPSERT | UPDATE | DELETE | CREATE | DROP
+
+export type element = csn.Element & {
+  key?: boolean
+  virtual?: boolean
+  unique?: boolean
+  notNull?: boolean
+}
+export type elements = {
+  [name: string]: element
+}
+
+export type col = cqn.column_expr & { element: element }
+
+export type list = {
+  list: cqn.expr[]
+}
+// Passthrough
+export type source = cqn.source
+export type ref = cqn.ref
+export type val = cqn.val
+export type xpr = cqn.xpr
+export type expr = cqn.expr
+export type func = cqn.function_call
+export type predicate = cqn.predicate
+export type ordering_term = cqn.ordering_term
+export type limit = { rows: val; offset: val }