@sap/cds 8.3.1 → 8.4.1

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

@@ -1,3 +1,4 @@
+const cds = require('../../cds')
 const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
 
 const _deepEqual = (val1, val2) => {
@@ -18,12 +19,7 @@ const _getCorrespondingEntryWithSameKeys = (source, entry, keys) => {
 const _getIdxCorrespondingEntryWithSameKeys = (source, entry, keys) =>
   source.findIndex(sourceEntry => keys.every(key => _deepEqual(sourceEntry[key], entry[key])))
 
-const _getKeysOfEntity = entity =>
-  Object.keys(entity.keys).filter(key => !(key in DRAFT_COLUMNS_MAP) && !entity.elements[key].isAssociation)
-
-const _getCompositionsOfEntity = entity => Object.keys(entity.elements).filter(e => entity.elements[e].isComposition)
-
-const _createToBeDeletedEntries = (oldEntry, entity, keys, compositions) => {
+const _createToBeDeletedEntries = (oldEntry, entity, keys, compositions, metaCache) => {
   const toBeDeletedEntry = {
     _op: 'delete'
   }
@@ -35,20 +31,18 @@ const _createToBeDeletedEntries = (oldEntry, entity, keys, compositions) => {
     if (keys.includes(prop)) {
       toBeDeletedEntry[prop] = oldEntry[prop]
     } else if (compositions.includes(prop) && oldEntry[prop]) {
+      const target = entity.elements[prop]._target
+      const cache = metaCache.get(target)
       toBeDeletedEntry[prop] = entity.elements[prop].is2one
         ? _createToBeDeletedEntries(
             oldEntry[prop],
             entity.elements[prop]._target,
-            _getKeysOfEntity(entity.elements[prop]._target),
-            _getCompositionsOfEntity(entity.elements[prop]._target)
+            cache.keys,
+            cache.compositions,
+            metaCache
           )
         : oldEntry[prop].map(entry =>
-            _createToBeDeletedEntries(
-              entry,
-              entity.elements[prop]._target,
-              _getKeysOfEntity(entity.elements[prop]._target),
-              _getCompositionsOfEntity(entity.elements[prop]._target)
-            )
+            _createToBeDeletedEntries(entry, target, cache.keys, cache.compositions, metaCache)
           )
     } else {
       toBeDeletedEntry._old = toBeDeletedEntry._old || {}
@@ -77,7 +71,7 @@ const _hasOpDeep = (entry, element) => {
   return false
 }
 
-const _addCompositionsToResult = (result, entity, prop, newValue, oldValue, opts) => {
+const _addCompositionsToResult = (result, entity, prop, newValue, oldValue, opts, buckets, metaCache) => {
   /*
    * REVISIT: the current impl results in {} instead of keeping null for compo to one.
    *          unfortunately, many follow-up errors occur (e.g., prop in null checks) if changed.
@@ -89,9 +83,23 @@ const _addCompositionsToResult = (result, entity, prop, newValue, oldValue, opts
     !Array.isArray(newValue[prop]) &&
     Object.keys(newValue[prop]).length === 0
   ) {
-    composition = compareJsonDeep(entity.elements[prop]._target, undefined, oldValue && oldValue[prop], opts)
+    composition = compareJsonDeep(
+      entity.elements[prop]._target,
+      undefined,
+      oldValue && oldValue[prop],
+      opts,
+      buckets,
+      metaCache
+    )
   } else {
-    composition = compareJsonDeep(entity.elements[prop]._target, newValue[prop], oldValue && oldValue[prop], opts)
+    composition = compareJsonDeep(
+      entity.elements[prop]._target,
+      newValue[prop],
+      oldValue && oldValue[prop],
+      opts,
+      buckets,
+      metaCache
+    )
   }
   if (composition.some(c => _hasOpDeep(c, entity.elements[prop]))) {
     result[prop] = entity.elements[prop].is2one ? composition[0] : composition
@@ -118,14 +126,17 @@ const _addKeysToResult = (result, prop, newValue, oldValue) => {
   }
 }
 
-const _addToBeDeletedEntriesToResult = (results, entity, keys, newValues, oldValues) => {
+const _addToBeDeletedEntriesToResult = (results, entity, keys, newValues, oldValues, newBucketMap, metaCache) => {
+  const cache = metaCache.get(entity)
   // add to be deleted entries
   for (const oldEntry of oldValues) {
-    const entry = _getCorrespondingEntryWithSameKeys(newValues, oldEntry, keys)
+    const entry = cds.env.features.diff_optimization
+      ? _getCorrespondingEntryWithSameKeysFromBucket(newBucketMap, oldEntry, entity, keys, cache)
+      : _getCorrespondingEntryWithSameKeys(newValues, oldEntry, keys)
 
     if (!entry) {
       // prepare to be deleted (deep) entry without manipulating oldData
-      const toBeDeletedEntry = _createToBeDeletedEntries(oldEntry, entity, keys, _getCompositionsOfEntity(entity))
+      const toBeDeletedEntry = _createToBeDeletedEntries(oldEntry, entity, keys, cache.compositions, metaCache)
       results.push(toBeDeletedEntry)
     }
   }
@@ -149,54 +160,115 @@ const _skipToMany = (entity, prop) => {
   return entity.elements[prop] && entity.elements[prop].is2many && _skip(entity, prop)
 }
 
-// Returns all property names from the new entry and add missing managed elements
-const _propertiesAndManaged = (newEntry, entity) => {
-  return [
-    ...Object.getOwnPropertyNames(newEntry),
-    ...Object.keys(entity.elements).filter(
-      elementName => newEntry[elementName] === undefined && entity.elements[elementName]['@cds.on.update']
-    )
-  ]
-}
+const _iteratePropsInNewEntry = (newEntry, keys, result, oldEntry, entity, opts, buckets, metaCache) => {
+  const cache = metaCache.get(entity)
 
-const _iteratePropsInNewEntry = (newEntry, keys, result, oldEntry, entity, opts) => {
   // On app-service layer, generated foreign keys are not enumerable,
   // include them here too.
-  for (const prop of _propertiesAndManaged(newEntry, entity)) {
-    if (keys.includes(prop)) {
+  for (const prop of cache.props) {
+    if (cache.keys.includes(prop)) {
       _addKeysToResult(result, prop, newEntry, oldEntry)
       continue
     }
 
-    // if value did not change --> ignored
-    if (
-      newEntry[prop] === (oldEntry && oldEntry[prop]) ||
-      (oldEntry && entity.elements[prop]?.['@Core.Immutable']) ||
-      (opts.ignoreDraftColumns && prop in DRAFT_COLUMNS_MAP)
-    ) {
+    if (newEntry[prop] === undefined && !cache.onUpdate.includes(prop)) continue
+
+    if (cache.compositions.includes(prop)) {
+      _addCompositionsToResult(result, entity, prop, newEntry, oldEntry, opts, buckets, metaCache)
       continue
     }
 
-    if (_skipToMany(entity, prop)) {
-      continue
+    // if value did not change --> ignored
+    if (newEntry[prop] === (oldEntry && oldEntry[prop])) continue
+
+    // existing immutable --> ignored
+    if (oldEntry && cache.immutables.includes(prop)) continue
+
+    _addPrimitiveValuesAndOperatorToResult(result, prop, newEntry, oldEntry)
+  }
+}
+
+const _isSimpleKey = element => !element._isStructured && element.type != 'cds.Binary'
+
+const _getMetaCache = (entity, metaCache, opts) => {
+  if (metaCache.get(entity)) return
+
+  const cache = { keys: [], props: [], compositions: [], immutables: [], onUpdate: [] }
+  metaCache.set(entity, cache)
+  for (let prop in entity.elements) {
+    const element = entity.elements[prop] || {}
+    if (prop in entity.keys && !(prop in DRAFT_COLUMNS_MAP) && !element.isAssociation) cache.keys.push(prop)
+    if (_skipToMany(entity, prop) || _skipToOne(entity, prop)) continue
+    if (opts.ignoreDraftColumns && prop in DRAFT_COLUMNS_MAP) continue
+
+    if (element?.isComposition) {
+      cache.compositions.push(prop)
+      _getMetaCache(element._target, metaCache, opts)
     }
 
-    if (_skipToOne(entity, prop)) {
-      continue
+    if (element?.['@Core.Immutable']) cache.immutables.push(prop)
+    if (element?.['@cds.on.update']) cache.onUpdate.push(prop)
+
+    cache.props.push(prop)
+  }
+
+  let getKeyHash
+  if (cache.keys.length === 1 && _isSimpleKey(entity.elements[cache.keys[0]])) {
+    getKeyHash = (entry, keys) => entry[keys[0]].toString()
+  } else if (cache.keys.map(key => entity.elements[key]).every(key => _isSimpleKey(key))) {
+    getKeyHash = (entry, keys) => keys.reduce((hash, key) => `${hash},${key}=${entry[key].toString()}`, '')
+  } else {
+    getKeyHash = (entry, keys) => {
+      const keyObj = keys.reduce((hash, key) => {
+        hash[key] = entry[key]
+        return hash
+      }, {})
+
+      return JSON.stringify(keyObj)
     }
+  }
+  cache.getKeyHash = getKeyHash
+}
 
-    if (entity.elements[prop] && entity.elements[prop].isComposition) {
-      _addCompositionsToResult(result, entity, prop, newEntry, oldEntry, opts)
-      continue
+const _addBucket = (entity, entry, bucketMap, metaCache) => {
+  if (!entry) return
+  const entries = _normalizeToArray(entry)
+  const cache = metaCache.get(entity)
+
+  entries.forEach(e => {
+    const keyHash = cache.getKeyHash(e, cache.keys)
+    let entityMap = bucketMap.get(entity)
+    if (!entityMap) {
+      entityMap = new Map()
+      bucketMap.set(entity, entityMap)
     }
+    entityMap.set(keyHash, e)
 
-    _addPrimitiveValuesAndOperatorToResult(result, prop, newEntry, oldEntry)
-  }
+    for (const prop of cache.props) {
+      if (cache.compositions.includes(prop)) _addBucket(entity.elements[prop]._target, e[prop], bucketMap, metaCache)
+    }
+  })
+}
+
+const _getBucketMap = (value, entity, metaCache) => {
+  const bucketMap = new Map()
+  _addBucket(entity, value, bucketMap, metaCache)
+
+  return bucketMap
+}
+
+const _getCorrespondingEntryWithSameKeysFromBucket = (bucketMap, entry, entity, keys, cache) => {
+  const bucket = bucketMap.get(entity)
+  if (!bucket) return
+
+  const keyHash = cache.getKeyHash(entry, keys)
+  return bucket.get(keyHash)
 }
 
-const compareJsonDeep = (entity, newValue = [], oldValue = [], opts) => {
+const compareJsonDeep = (entity, newValue = [], oldValue = [], opts, buckets, metaCache) => {
   const resultsArray = []
-  const keys = _getKeysOfEntity(entity)
+  const cache = metaCache.get(entity)
+  const keys = cache.keys
 
   // normalize input
   const newValues = _normalizeToArray(newValue)
@@ -205,12 +277,17 @@ const compareJsonDeep = (entity, newValue = [], oldValue = [], opts) => {
   // add to be created and to be updated entries
   for (const newEntry of newValues) {
     const result = {}
-    const oldEntry = _getCorrespondingEntryWithSameKeys(oldValues, newEntry, keys)
-    _iteratePropsInNewEntry(newEntry, keys, result, oldEntry, entity, opts)
+    let oldEntry
+    if (oldValues.length) {
+      oldEntry = cds.env.features.diff_optimization
+        ? _getCorrespondingEntryWithSameKeysFromBucket(buckets.oldBucketMap, newEntry, entity, keys, cache)
+        : _getCorrespondingEntryWithSameKeys(oldValues, newEntry, keys)
+    }
+    _iteratePropsInNewEntry(newEntry, keys, result, oldEntry, entity, opts, buckets, metaCache)
     resultsArray.push(result)
   }
 
-  _addToBeDeletedEntriesToResult(resultsArray, entity, keys, newValues, oldValues)
+  _addToBeDeletedEntriesToResult(resultsArray, entity, keys, newValues, oldValues, buckets.newBucketMap, metaCache)
 
   return resultsArray
 }
@@ -266,7 +343,16 @@ const compareJsonDeep = (entity, newValue = [], oldValue = [], opts) => {
  */
 const compareJson = (newValue, oldValue, entity, opts = {}) => {
   const options = Object.assign({ ignoreDraftColumns: false }, opts)
-  const result = compareJsonDeep(entity, newValue, oldValue, options)
+
+  let newBucketMap,
+    oldBucketMap,
+    metaCache = new Map()
+  _getMetaCache(entity, metaCache, opts)
+  if (oldValue && (!Array.isArray(oldValue) || oldValue.length) && cds.env.features.diff_optimization) {
+    newBucketMap = _getBucketMap(newValue, entity, metaCache)
+    oldBucketMap = _getBucketMap(oldValue, entity, metaCache)
+  }
+  const result = compareJsonDeep(entity, newValue, oldValue, options, { newBucketMap, oldBucketMap }, metaCache)
 
   // in case of batch insert, result is an array
   // in all other cases it is an array with just one entry

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

@@ -0,0 +1,280 @@
+// copied from @sap/cds@8.3.1
+
+const { DRAFT_COLUMNS_MAP } = require('../constants/draft')
+
+const _deepEqual = (val1, val2) => {
+  if (val1 && typeof val1 === 'object' && val2 && typeof val2 === 'object') {
+    for (const key in val1) {
+      if (!_deepEqual(val1[key], val2[key])) return false
+    }
+    return true
+  }
+  return val1 === val2
+}
+
+const _getCorrespondingEntryWithSameKeys = (source, entry, keys) => {
+  const idx = _getIdxCorrespondingEntryWithSameKeys(source, entry, keys)
+  return idx !== -1 ? source[idx] : undefined
+}
+
+const _getIdxCorrespondingEntryWithSameKeys = (source, entry, keys) =>
+  source.findIndex(sourceEntry => keys.every(key => _deepEqual(sourceEntry[key], entry[key])))
+
+const _getKeysOfEntity = entity =>
+  Object.keys(entity.keys).filter(key => !(key in DRAFT_COLUMNS_MAP) && !entity.elements[key].isAssociation)
+
+const _getCompositionsOfEntity = entity => Object.keys(entity.elements).filter(e => entity.elements[e].isComposition)
+
+const _createToBeDeletedEntries = (oldEntry, entity, keys, compositions) => {
+  const toBeDeletedEntry = {
+    _op: 'delete'
+  }
+
+  for (const prop in oldEntry) {
+    if (prop in DRAFT_COLUMNS_MAP) {
+      continue
+    }
+    if (keys.includes(prop)) {
+      toBeDeletedEntry[prop] = oldEntry[prop]
+    } else if (compositions.includes(prop) && oldEntry[prop]) {
+      toBeDeletedEntry[prop] = entity.elements[prop].is2one
+        ? _createToBeDeletedEntries(
+            oldEntry[prop],
+            entity.elements[prop]._target,
+            _getKeysOfEntity(entity.elements[prop]._target),
+            _getCompositionsOfEntity(entity.elements[prop]._target)
+          )
+        : oldEntry[prop].map(entry =>
+            _createToBeDeletedEntries(
+              entry,
+              entity.elements[prop]._target,
+              _getKeysOfEntity(entity.elements[prop]._target),
+              _getCompositionsOfEntity(entity.elements[prop]._target)
+            )
+          )
+    } else {
+      toBeDeletedEntry._old = toBeDeletedEntry._old || {}
+      toBeDeletedEntry._old[prop] = oldEntry[prop]
+    }
+  }
+
+  return toBeDeletedEntry
+}
+
+const _hasOpDeep = (entry, element) => {
+  const entryArray = Array.isArray(entry) ? entry : [entry]
+  for (const entry_ of entryArray) {
+    if (entry_._op) return true
+
+    if (element && element.isComposition) {
+      const target = element._target
+      for (const prop in entry_) {
+        if (_hasOpDeep(entry_[prop], target.elements[prop])) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+const _addCompositionsToResult = (result, entity, prop, newValue, oldValue, opts) => {
+  /*
+   * REVISIT: the current impl results in {} instead of keeping null for compo to one.
+   *          unfortunately, many follow-up errors occur (e.g., prop in null checks) if changed.
+   */
+  let composition
+  if (
+    newValue[prop] &&
+    typeof newValue[prop] === 'object' &&
+    !Array.isArray(newValue[prop]) &&
+    Object.keys(newValue[prop]).length === 0
+  ) {
+    composition = compareJsonDeep(entity.elements[prop]._target, undefined, oldValue && oldValue[prop], opts)
+  } else {
+    composition = compareJsonDeep(entity.elements[prop]._target, newValue[prop], oldValue && oldValue[prop], opts)
+  }
+  if (composition.some(c => _hasOpDeep(c, entity.elements[prop]))) {
+    result[prop] = entity.elements[prop].is2one ? composition[0] : composition
+  }
+}
+
+const _addPrimitiveValuesAndOperatorToResult = (result, prop, newValue, oldValue) => {
+  result[prop] = newValue[prop]
+
+  if (!result._op) {
+    result._op = oldValue ? 'update' : 'create'
+  }
+
+  if (result._op === 'update') {
+    result._old = result._old || {}
+    result._old[prop] = oldValue[prop]
+  }
+}
+
+const _addKeysToResult = (result, prop, newValue, oldValue) => {
+  result[prop] = newValue[prop]
+  if (!oldValue) {
+    result._op = 'create'
+  }
+}
+
+const _addToBeDeletedEntriesToResult = (results, entity, keys, newValues, oldValues) => {
+  // add to be deleted entries
+  for (const oldEntry of oldValues) {
+    const entry = _getCorrespondingEntryWithSameKeys(newValues, oldEntry, keys)
+
+    if (!entry) {
+      // prepare to be deleted (deep) entry without manipulating oldData
+      const toBeDeletedEntry = _createToBeDeletedEntries(oldEntry, entity, keys, _getCompositionsOfEntity(entity))
+      results.push(toBeDeletedEntry)
+    }
+  }
+}
+
+const _normalizeToArray = value => (Array.isArray(value) ? value : value === null ? [] : [value])
+
+const _isUnManaged = element => {
+  return element.on && !element._isSelfManaged
+}
+
+const _skip = (entity, prop) => entity.elements[prop]._target._hasPersistenceSkip
+
+const _skipToOne = (entity, prop) => {
+  return (
+    entity.elements[prop] && entity.elements[prop].is2one && _skip(entity, prop) && _isUnManaged(entity.elements[prop])
+  )
+}
+
+const _skipToMany = (entity, prop) => {
+  return entity.elements[prop] && entity.elements[prop].is2many && _skip(entity, prop)
+}
+
+// Returns all property names from the new entry and add missing managed elements
+const _propertiesAndManaged = (newEntry, entity) => {
+  return [
+    ...Object.getOwnPropertyNames(newEntry),
+    ...Object.keys(entity.elements).filter(
+      elementName => newEntry[elementName] === undefined && entity.elements[elementName]['@cds.on.update']
+    )
+  ]
+}
+
+const _iteratePropsInNewEntry = (newEntry, keys, result, oldEntry, entity, opts) => {
+  // On app-service layer, generated foreign keys are not enumerable,
+  // include them here too.
+  for (const prop of _propertiesAndManaged(newEntry, entity)) {
+    if (keys.includes(prop)) {
+      _addKeysToResult(result, prop, newEntry, oldEntry)
+      continue
+    }
+
+    // if value did not change --> ignored
+    if (
+      newEntry[prop] === (oldEntry && oldEntry[prop]) ||
+      (oldEntry && entity.elements[prop]?.['@Core.Immutable']) ||
+      (opts.ignoreDraftColumns && prop in DRAFT_COLUMNS_MAP)
+    ) {
+      continue
+    }
+
+    if (_skipToMany(entity, prop)) {
+      continue
+    }
+
+    if (_skipToOne(entity, prop)) {
+      continue
+    }
+
+    if (entity.elements[prop] && entity.elements[prop].isComposition) {
+      _addCompositionsToResult(result, entity, prop, newEntry, oldEntry, opts)
+      continue
+    }
+
+    _addPrimitiveValuesAndOperatorToResult(result, prop, newEntry, oldEntry)
+  }
+}
+
+const compareJsonDeep = (entity, newValue = [], oldValue = [], opts) => {
+  const resultsArray = []
+  const keys = _getKeysOfEntity(entity)
+
+  // normalize input
+  const newValues = _normalizeToArray(newValue)
+  const oldValues = _normalizeToArray(oldValue)
+
+  // add to be created and to be updated entries
+  for (const newEntry of newValues) {
+    const result = {}
+    const oldEntry = _getCorrespondingEntryWithSameKeys(oldValues, newEntry, keys)
+    _iteratePropsInNewEntry(newEntry, keys, result, oldEntry, entity, opts)
+    resultsArray.push(result)
+  }
+
+  _addToBeDeletedEntriesToResult(resultsArray, entity, keys, newValues, oldValues)
+
+  return resultsArray
+}
+
+/**
+ * Compares newValue with oldValues in a deep fashion.
+ * Output format is newValue with additional administrative properties.
+ * - "_op" provides info about the CRUD action to perform
+ * - "_old" provides info about the current DB state
+ *
+ * Unchanged values are not part of the result.
+ *
+ * Output format is:
+ * {
+ *   _op: 'update',
+ *   _old: { orderedAt: 'DE' },
+ *   ID: 1,
+ *   orderedAt: 'EN',
+ *   items: [
+ *     {
+ *       _op: 'update',
+ *       _old: { amount: 7 },
+ *       ID: 7,
+ *       amount: 8
+ *     },
+ *     {
+ *       _op: 'create',
+ *       ID: 8,
+ *       amount: 8
+ *     },
+ *     {
+ *       _op: 'delete',
+ *       _old: {
+ *         amount: 6
+ *       },
+ *       ID: 6
+ *     }
+ *   ]
+ * }
+ *
+ *
+ * If there is no change in an UPDATE, result is an object containing only the keys of the entity.
+ *
+ * @example
+ * compareJson(csnEntity, [{ID: 1, col1: 'A'}], [{ID: 1, col1: 'B'}])
+ *
+ * @param oldValue
+ * @param {object} entity
+ * @param {Array | object} newValue
+ * @param {Array} oldValues
+ *
+ * @returns {Array}
+ */
+const compareJson = (newValue, oldValue, entity, opts = {}) => {
+  const options = Object.assign({ ignoreDraftColumns: false }, opts)
+  const result = compareJsonDeep(entity, newValue, oldValue, options)
+
+  // in case of batch insert, result is an array
+  // in all other cases it is an array with just one entry
+  return Array.isArray(newValue) ? result : result[0]
+}
+
+module.exports = {
+  compareJson
+}

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

@@ -1,7 +1,6 @@
 const cds = require('../../cds')
 const { SELECT } = cds.ql
 
-const { compareJson } = require('./compareJson')
 const { selectDeepUpdateData } = require('../composition')
 const { ensureDraftsSuffix } = require('./draft')
 
@@ -10,9 +9,18 @@ const { cqn2cqn4sql, convertPathExpressionToWhere } = require('./cqn2cqn4sql')
 const { revertData } = require('./resolveView')
 const { enrichDataWithKeysFromWhere } = require('./keys')
 
+let 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) {

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

@@ -65,9 +65,7 @@ const revertData = (data, transition, service) => {
     : _newData(data, inverseTransition, true, service)
 }
 
-const _newSubData = (newData, key, transition, el, inverse, service) => {
-  const val = newData[key]
-
+const _newSubData = (val, key, transition, el, inverse, service) => {
   if ((!Array.isArray(val) && typeof val === 'object') || (Array.isArray(val) && val.length !== 0)) {
     let mapped = transition.mapping.get(key)
     if (!mapped) {
@@ -81,11 +79,12 @@ const _newSubData = (newData, key, transition, el, inverse, service) => {
     }
 
     if (Array.isArray(val)) {
-      newData[key] = val.map(singleVal => _newData(singleVal, mapped.transition, inverse, service))
+      return val.map(singleVal => _newData(singleVal, mapped.transition, inverse, service))
     } else {
-      newData[key] = _newData(val, mapped.transition, inverse, service)
+      return _newData(val, mapped.transition, inverse, service)
     }
   }
+  return val //Case of empty array
 }
 
 const _newNestedData = (queryTarget, newData, ref, value) => {
@@ -112,40 +111,37 @@ const _newData = (data, transition, inverse, service) => {
   // no transition -> nothing to do
   if (transition.target && transition.target.name === transition.queryTarget.name) return data
 
-  // REVISIT this does not copy deep
-  const newData = { ...data }
+  const newData = {}
   const queryTarget = transition.queryTarget
 
-  for (const key in newData) {
+  for (const key in data) {
     const el = queryTarget && queryTarget?.elements[key]
     const isAssoc = el && el.isAssociation
 
-    if (isAssoc) {
-      if (newData[key] || (newData[key] === null && service.name === 'db')) {
-        _newSubData(newData, key, transition, el, inverse, service)
-      }
-    }
-
     const mapped = transition.mapping.get(key)
     if (!mapped) {
-      // if there is no mapping and no element with the same name in the target, then we don't need the data
-      if ((typeof newData[key] !== 'object' || newData[key] === null) && !transition.target.elements[key])
-        delete newData[key]
+      //In this condition the data is needed
+      if (
+        ((typeof data[key] === 'object' && data[key] !== null) || transition.target.elements[key]) &&
+        newData[key] === undefined
+      )
+        newData[key] = data[key]
       continue
     }
+    let value = data[key]
+    if (isAssoc) {
+      if (value || (value === null && service.name === 'db')) {
+        value = _newSubData(value, key, transition, el, inverse, service)
+      }
+    }
 
     if (!isAssoc && mapped.transition) {
-      _newSubData(newData, key, transition, el, inverse)
-      const value = newData[key]
-      delete newData[key]
+      value = _newSubData(value, key, transition, el, inverse)
       Object.assign(newData, value)
     }
 
     if (mapped.ref) {
-      const value = newData[key]
-      delete newData[key]
       const { ref } = mapped
-
       if (ref.length === 1) {
         newData[ref[0]] = value
         if (mapped.alternatives) mapped.alternatives.forEach(({ ref }) => (newData[ref[0]] = value))

package/libx/_runtime/fiori/lean-draft.js

@@ -389,7 +389,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
         return req._messages
       }
     })
-    if (req.tx) _req.tx = req.tx
+    if (req.tx && !_req.tx) _req.tx = req.tx
 
     return _req
   }
@@ -1209,7 +1209,7 @@ function _cleanseParams(params, target) {
       if (key === 'IsActiveEntity') {
         const value = params[key]
         delete params[key]
-        Object.defineProperty(params, key, { value, enumerable: false })
+        Object.defineProperty(params, key, { value, enumerable: false, writeable: true })
       }
     }
   }