@sap/cds 8.9.4 → 9.0.2

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

@@ -1,26 +1,120 @@
 const cds = require('../../cds')
 const { SELECT } = cds.ql
 
-const { selectDeepUpdateData } = require('../composition')
-const { ensureDraftsSuffix } = require('./draft')
-
 const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
-const { cqn2cqn4sql, convertPathExpressionToWhere } = require('./cqn2cqn4sql')
-const { revertData } = require('./resolveView')
 const { enrichDataWithKeysFromWhere } = require('./keys')
 
-let compareJson
+// unofficial config!
+const DEEP_EXPAND_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
+
+const columnRefs = (data, target) => {
+  // select all columns if removed
+  if (data == null || (Array.isArray(data) && data.length === 0)) {
+    return Object.keys(target.elements)
+      .filter(e => !target.elements[e].isAssociation && !target.elements[e].virtual)
+      .map(c => ({ ref: [c] }))
+  }
+  const columns = new Set()
+  // ensure keys are selected
+  Object.values(target.keys)
+    .filter(k => !k.isAssociation && !k.virtual)
+    .forEach(k => columns.add(k.name))
+
+  if (!Array.isArray(data)) data = [data]
+  // loop and get all columns from current level
+  for (const row of data) {
+    for (const e in row) {
+      if (target.elements[e] && !target.elements[e].isAssociation) {
+        columns.add(e)
+      }
+    }
+  }
+
+  return Array.from(columns).map(c => ({ ref: [c] }))
+}
+
+const expandColumns = (target, data, columns = [], elementMap = new Map()) => {
+  const compositions = target.compositions || {}
+
+  if (columns.length === 0) {
+    // REVISIT: ensure that all keys are included in the expand columns
+    columns.push(...columnRefs(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_EXPAND_MAX_RECURSION_DEPTH) {
+      // recursion -> abort
+      return columns
+    }
+
+    let expandColumn = columns.find(expandColumn => expandColumn.ref[0] === composition.name)
+    if (!expandColumn) {
+      expandColumn = {
+        ref: [composition.name],
+        expand: columnRefs(compositionData, composition._target)
+      }
+
+      columns.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
+        expandColumns(composition._target, null, expandColumn.expand, newElementMap)
+        continue
+      }
+
+      for (const row of compositionData) {
+        expandColumns(composition._target, row, expandColumn.expand, newElementMap)
+      }
+    } else {
+      // to one
+      expandColumns(composition._target, compositionData, expandColumn.expand, newElementMap)
+    }
+  }
+  return columns
+}
+
+/**
+ * @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 = expandColumns(target, data)
+  return SELECT.one(columns).from(entity).where(where)
+}
+
+const { compareJson } = require('./compareJson')
 
 module.exports = class Differ {
   constructor(srv) {
     this._srv = srv
-
-    // REVISIT: remove with cds^9
-    // use old compareJson if not using a @cap-js db
-    compareJson ??=
-      cds.env.requires.db?.impl && !cds.env.requires.db.impl.startsWith('@cap-js')
-        ? require('./compareJsonOLD').compareJson
-        : require('./compareJson').compareJson
   }
 
   _createSelectColumnsForDelete(entity) {
@@ -46,45 +140,29 @@ module.exports = class Differ {
 
   async _diffDelete(req) {
     const { DELETE } = req.query
-    const target = DELETE._transitions?.[DELETE._transitions.length - 1]?.target || req.target
+    const target = req.target
     const query = SELECT.from(DELETE.from).columns(this._createSelectColumnsForDelete(target))
     if (DELETE.where) query.where(DELETE.where)
-    const dbState = await cds.tx(req).run(query)
-    const diff = compareJson(undefined, dbState, req.target, { ignoreDraftColumns: true })
+    const dbState = await cds.run(query)
+    const diff = compareJson(undefined, dbState, target, { ignoreDraftColumns: true })
     return diff
   }
 
-  async _addPartialPersistentState(req) {
-    // REVISIT: cds.context.model?
-    const deepUpdateData = await selectDeepUpdateData(this._srv, this._srv.model, req, true)
-    req._.partialPersistentState = deepUpdateData
-  }
-
   async _diffUpdate(req, providedData) {
-    if (cds.db) await this._addPartialPersistentState(req)
-    // REVISIT: this is done (better) in the new db services
-    const newQuery = cqn2cqn4sql(req.query, this._srv.model)
-    const combinedData = providedData || Object.assign({}, req.query.UPDATE.data || {}, req.query.UPDATE.with || {})
-    enrichDataWithKeysFromWhere(combinedData, req, this._srv)
-    const lastTransition = newQuery.UPDATE._transitions[newQuery.UPDATE._transitions.length - 1]
-    const revertedPersistent = revertData(req._.partialPersistentState, lastTransition, cds.db)
-    const diff = compareJson(combinedData, revertedPersistent, req.target, { ignoreDraftColumns: true })
-    return diff
-  }
-
-  async _diffPatch(req, providedData) {
+    // prepare before data
+    let dbState
     if (cds.db) {
-      const { target, alias, where = [] } = convertPathExpressionToWhere(req.query.UPDATE.entity, this._srv.model, {})
-
-      const draftRef = { ref: [ensureDraftsSuffix(target)], as: alias }
+      // does the code below ever work without partialPersistentState?
+      const q = getExpandForDeep(req.query, req.target) // REVISIT: cds.context.model?
+      dbState = await cds.run(q)
+    }
 
-      // SELECT because req.query in custom handler does not have access to _drafts
-      req._.partialPersistentState = await cds.tx(req).run(SELECT.from(draftRef).where(where).limit(1))
+    // prepare after data
+    const combinedData = providedData || Object.assign({}, req.query.UPDATE.data, req.query.UPDATE.with) // REVISIT: .with contains expressions -> does that make sense?
+    enrichDataWithKeysFromWhere(combinedData, req, this._srv)
 
-      return compareJson(providedData || req.data, req._.partialPersistentState, req.target, {
-        ignoreDraftColumns: true
-      })
-    }
+    const diff = compareJson(combinedData, dbState, req.target, { ignoreDraftColumns: true })
+    return diff
   }
 
   _diffCreate(req, providedData) {
@@ -102,7 +180,6 @@ module.exports = class Differ {
     if (req.target._hasPersistenceSkip) return
     if (req.event === 'DELETE') return this._diffDelete(req)
     if (req.event === 'UPDATE') return this._diffUpdate(req, providedData)
-    if (req.event === 'PATCH') return this._diffPatch(req, providedData)
   }
 
   // is used as a req instance method

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

@@ -86,17 +86,16 @@ function _getWhereFromUpdate(query, model) {
 
 // params: data, req, service/tx
 function enrichDataWithKeysFromWhere(data, { query, target }, { model }) {
+  if (!query) return
   if (query.INSERT) {
     const where = _getWhereFromInsert(query, model)
-    if (!where || !where.length) return
+    if (!where?.length) return
     if (!Array.isArray(data)) data = [data]
     for (const d of data) Object.assign(d, where2obj(where, target))
   } else if (query.UPDATE) {
     const where = _getWhereFromUpdate(query, model)
-    if (!where || !where.length) return
-    // REVISIT: We should not expect data to be present always!
-    if (!data) data = query.UPDATE.data = {}
-    Object.assign(data, where2obj(where, target))
+    if (!where?.length) return
+    where2obj(where, target, data)
   }
 }
 

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

@@ -83,8 +83,8 @@ const postProcess = (query, result, service, onlySelectAliases = false) => {
     if (onlySelectAliases) return result
   }
 
-  const transitions = query.SELECT?._transitions || query.INSERT?._transitions || query.UPDATE?._transitions
-  if (transitions) return revertData(result, transitions[transitions.length - 1], service)
+  const transitions = query._transitions
+  if (transitions) return revertData(result, transitions.at(-1), service)
 
   return result
 }

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

@@ -4,38 +4,23 @@ const { prefixForStruct } = require('../../common/utils/csn')
 
 const _autoGenerate = e => e && e.isUUID && e.key
 
-const _set = (row, value, element, enumerable) => {
+const _set = (row, value, element) => {
   if (value === undefined) return // only if properly propagated/generated
   if (!element.parent.elements[element.name]) return // only when in model
-  if (!enumerable && element.foreignKeySource) {
-    // only for foreign keys
-    Object.defineProperty(row, element.name, {
-      get() {
-        return value
-      },
-      set(v) {
-        // Make sure that it becomes enumerable again if set manually afterwards
-        Object.defineProperty(row, element.name, { value: v, configurable: true, enumerable: true })
-      },
-      enumerable: false,
-      configurable: true
-    })
-  } else {
-    row[element.name] = value
-  }
+  row[element.name] = value
 }
 
-const _generateParentField = ({ parentElement }, row, enumerable) => {
+const _generateParentField = ({ parentElement }, row) => {
   if (_autoGenerate(parentElement) && !row[parentElement.name]) {
-    _set(row, cds.utils.uuid(), parentElement, enumerable)
+    _set(row, cds.utils.uuid(), parentElement)
   }
 }
 
-const _generateChildField = ({ deep, childElement }, childRow, enumerable) => {
+const _generateChildField = ({ deep, childElement }, childRow) => {
   if (deep) {
-    _generateChildField(deep.propagation, childRow[deep.targetName], enumerable)
+    _generateChildField(deep.propagation, childRow[deep.targetName])
   } else if (_autoGenerate(childElement) && childRow && !childRow[childElement.name]) {
-    _set(childRow, cds.utils.uuid(), childElement, enumerable)
+    _set(childRow, cds.utils.uuid(), childElement)
   }
 }
 
@@ -58,27 +43,27 @@ const _getNestedVal = (row, prefix) => {
   return val
 }
 
-const _propagateToChild = ({ parentElement, childElement, parentFieldValue }, row, childRow, enumerable) => {
+const _propagateToChild = ({ parentElement, childElement, parentFieldValue }, row, childRow) => {
   if (!childElement || !childElement.parent.elements[childElement.name]) return
   if (parentElement) {
     const prefix = prefixForStruct(parentElement)
     if (prefix) {
       const nested = _getNestedVal(row, prefix)
-      _set(childRow, nested[parentElement.name], childElement, enumerable)
+      _set(childRow, nested[parentElement.name], childElement)
     } else {
-      _set(childRow, row[parentElement.name], childElement, enumerable)
+      _set(childRow, row[parentElement.name], childElement)
     }
   } else if (parentFieldValue !== undefined) {
-    _set(childRow, parentFieldValue, childElement, enumerable)
+    _set(childRow, parentFieldValue, childElement)
   }
 }
 
-const _propagateToParent = ({ parentElement, childElement, deep }, childRow, row, enumerable) => {
+const _propagateToParent = ({ parentElement, childElement, deep }, childRow, row) => {
   if (deep) {
-    _propagateToParent(deep.propagation, childRow[deep.targetName], childRow, enumerable)
+    _propagateToParent(deep.propagation, childRow[deep.targetName], childRow)
   }
   if (parentElement && childElement && childRow && childElement.name in childRow) {
-    _set(row, childRow[childElement.name], parentElement, enumerable)
+    _set(row, childRow[childElement.name], parentElement)
   }
 }
 
@@ -87,13 +72,13 @@ module.exports = (
   row,
   foreignKeyPropagations,
   isCompositionEffective,
-  { deleteAssocs = false, enumerable = true, generateKeys = true } = {}
+  { deleteAssocs = false, generateKeys = true } = {}
 ) => {
   if (!row || !(tKey in row)) return
   if (row[tKey] === null) {
     for (const foreignKeyPropagation of foreignKeyPropagations) {
       if (!foreignKeyPropagation.fillChild) {
-        _set(row, null, foreignKeyPropagation.parentElement, enumerable)
+        _set(row, null, foreignKeyPropagation.parentElement)
       }
     }
     if (deleteAssocs && !isCompositionEffective) delete row[tKey]
@@ -109,13 +94,13 @@ module.exports = (
       if (foreignKeyPropagation.fillChild) {
         // propagate or generate in parent
         const pk = foreignKeyPropagation.parentElement && foreignKeyPropagation.parentElement.name
-        if (pk && !(pk in row)) _propagateToParent(foreignKeyPropagation, childRow, row, enumerable)
-        if (!(pk in row) && generateKeys) _generateParentField(foreignKeyPropagation, row, enumerable, generateKeys)
+        if (pk && !(pk in row)) _propagateToParent(foreignKeyPropagation, childRow, row)
+        if (!(pk in row) && generateKeys) _generateParentField(foreignKeyPropagation, row)
 
-        if (isCompositionEffective) _propagateToChild(foreignKeyPropagation, row, childRow, enumerable)
+        if (isCompositionEffective) _propagateToChild(foreignKeyPropagation, row, childRow)
       } else {
-        if (isCompositionEffective && generateKeys) _generateChildField(foreignKeyPropagation, childRow, enumerable)
-        _propagateToParent(foreignKeyPropagation, childRow, row, enumerable)
+        if (isCompositionEffective && generateKeys) _generateChildField(foreignKeyPropagation, childRow)
+        _propagateToParent(foreignKeyPropagation, childRow, row)
       }
     }
   }