@sap/cds 5.4.6 → 5.5.0

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

@@ -1,8 +1,10 @@
 const cds = require('../../cds')
 let LOG = cds.log('app')
 let _event
+const PERSISTENCE_TABLE = '@cds.persistence.table'
 
 const getError = require('../error')
+const { getEntityNameFromDeleteCQN, getEntityNameFromUpdateCQN } = require('../utils/cqn')
 
 const _setInverseTransition = (mapping, ref, mapped) => {
   const existing = mapping.get(ref)
@@ -50,15 +52,15 @@ const _inverseTransition = transition => {
   return inverseTransition
 }
 
-const revertData = (data, transition) => {
+const revertData = (data, transition, service) => {
   if (!transition || !transition.mapping.size) return data
   const inverseTransition = _inverseTransition(transition)
   return Array.isArray(data)
-    ? data.map(entry => _newData(entry, inverseTransition, true))
-    : _newData(data, inverseTransition, true)
+    ? data.map(entry => _newData(entry, inverseTransition, true, service))
+    : _newData(data, inverseTransition, true, service)
 }
 
-const _newSubData = (newData, key, transition, el, inverse) => {
+const _newSubData = (newData, key, transition, el, inverse, service) => {
   const val = newData[key]
   if ((!Array.isArray(val) && typeof val === 'object') || (Array.isArray(val) && val.length !== 0)) {
     let mapped = transition.mapping.get(key)
@@ -67,13 +69,13 @@ const _newSubData = (newData, key, transition, el, inverse) => {
       transition.mapping.set(key, mapped)
     }
     if (!mapped.transition) {
-      const subTransition = getTransition(el._target)
+      const subTransition = getTransition(el._target, service)
       mapped.transition = inverse ? _inverseTransition(subTransition) : subTransition
     }
     if (Array.isArray(val)) {
-      newData[key] = val.map(singleVal => _newData(singleVal, mapped.transition, inverse))
+      newData[key] = val.map(singleVal => _newData(singleVal, mapped.transition, inverse, service))
     } else {
-      newData[key] = _newData(val, mapped.transition, inverse)
+      newData[key] = _newData(val, mapped.transition, inverse, service)
     }
   }
 }
@@ -95,7 +97,7 @@ const _newNestedData = (queryTarget, newData, ref, value) => {
   }
 }
 
-const _newData = (data, transition, inverse) => {
+const _newData = (data, transition, inverse, service) => {
   // no transition -> nothing to do
   if (transition.target && transition.target.name === transition.queryTarget.name) return data
 
@@ -109,7 +111,11 @@ const _newData = (data, transition, inverse) => {
   for (const key in newData) {
     const el = queryTarget && queryTarget.elements && queryTarget.elements[key]
     const isAssoc = el && el.isAssociation
-    if (isAssoc) _newSubData(newData, key, transition, el, inverse)
+    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) {
@@ -142,7 +148,7 @@ const _newData = (data, transition, inverse) => {
   return newData
 }
 
-const _newColumns = (columns = [], transition, force = false, withAlias = false) => {
+const _newColumns = (columns = [], transition, service, withAlias = false) => {
   const newColumns = []
 
   columns.forEach(column => {
@@ -167,11 +173,21 @@ const _newColumns = (columns = [], transition, force = false, withAlias = false)
 
     // ensure that renaming of a redirected assoc are also respected
     if (column.expand) {
+      // column.ref might be structured elements
+      let def
+      column.ref.forEach((ref, i) => {
+        if (i === 0) {
+          def = transition.queryTarget.elements[ref]
+        } else {
+          def = def.elements[ref]
+        }
+      })
+
       // reuse _newColumns with new transition
-      const expandTarget = transition.queryTarget.elements[column.ref[column.ref.length - 1]]._target
-      const subtransition = getTransition(expandTarget, force)
+      const expandTarget = def._target
+      const subtransition = getTransition(expandTarget, service)
 
-      newColumn.expand = _newColumns(column.expand, subtransition, force, withAlias)
+      newColumn.expand = _newColumns(column.expand, subtransition, service, withAlias)
     }
     newColumns.push(newColumn)
   })
@@ -194,19 +210,44 @@ const _newInsertColumns = (columns = [], transition) => {
   return newColumns
 }
 
-const _newEntries = (entries = [], transition) => entries.map(entry => _newData(entry, transition))
+const _newWhereRef = (newWhereElement, transition, alias, tableName, isSubSelect) => {
+  const newRef = Array.isArray(newWhereElement.ref) ? [...newWhereElement.ref] : [newWhereElement.ref]
+  if (newRef[0] === alias) {
+    const mapped = transition.mapping.get(newRef[1])
+    if (mapped) newRef[1] = mapped.ref[0]
+  } else if (newRef[0] === tableName) {
+    newRef[0] = transition.target.name
+    const mapped = transition.mapping.get(newRef[1])
+    if (mapped) newRef[1] = mapped.ref[0]
+  } else {
+    const mapped = transition.mapping.get(newRef[0])
+    if (isSubSelect && mapped) {
+      newRef.unshift(transition.target.name)
+      newRef[1] = mapped.ref[0]
+    } else {
+      if (mapped) newRef[0] = mapped.ref[0]
+    }
+  }
+  newWhereElement.ref = newRef
+}
 
-const _newWhere = (where = [], transition) => {
-  const newWhere = []
+const _newEntries = (entries = [], transition, service) =>
+  entries.map(entry => _newData(entry, transition, false, service))
 
-  where.forEach(whereElement => {
-    const mapped = whereElement.ref && transition.mapping.get(whereElement.ref[0])
-    if (mapped && mapped.ref) {
-      const newWhereElement = { ...whereElement }
-      newWhereElement.ref = [...mapped.ref, ...newWhereElement.ref.slice(mapped.ref.length)]
-      newWhere.push(newWhereElement)
-    } else if (!mapped) {
-      newWhere.push(whereElement)
+const _newWhere = (where = [], transition, tableName, alias, isSubselect = false) => {
+  const newWhere = where.map(whereElement => {
+    const newWhereElement = { ...whereElement }
+    if (!whereElement.ref && !whereElement.SELECT) return whereElement
+    if (whereElement.SELECT && whereElement.SELECT.where) {
+      newWhereElement.SELECT.where = _newWhere(whereElement.SELECT.where, transition, tableName, alias, true)
+      return newWhereElement
+    } else {
+      if (newWhereElement.ref) {
+        _newWhereRef(newWhereElement, transition, alias, tableName, isSubselect)
+        return newWhereElement
+      } else {
+        return whereElement
+      }
     }
   })
 
@@ -239,7 +280,7 @@ const _rewriteQueryPath = (path, transitions) => {
       if (f.id) {
         return {
           id: target.name,
-          where: _newWhere(f.where, transitions[0])
+          where: _newWhere(f.where, transitions[0], f.id)
         }
       }
     } else {
@@ -252,14 +293,14 @@ const _rewriteQueryPath = (path, transitions) => {
         const transitionMapping = transitions[i - 1].mapping.get(f.id)
         return {
           id: (transitionMapping && transitionMapping.ref && transitionMapping.ref[0]) || f.id,
-          where: _newWhere(f.where, transitions[i])
+          where: _newWhere(f.where, transitions[i], f.id)
         }
       }
     }
   })
 }
 
-const _newUpdate = (query, transitions) => {
+const _newUpdate = (query, transitions, service) => {
   const targetTransition = transitions[transitions.length - 1]
   const targetName = targetTransition.target.name
   const newUpdate = { ...query.UPDATE }
@@ -269,9 +310,16 @@ const _newUpdate = (query, transitions) => {
         ref: _rewriteQueryPath(query.UPDATE.entity, transitions)
       }
     : targetName
-  if (newUpdate.data) newUpdate.data = _newData(newUpdate.data, targetTransition)
-  if (newUpdate.with) newUpdate.with = _newData(newUpdate.with, targetTransition)
-  if (newUpdate.where) newUpdate.where = _newWhere(newUpdate.where, targetTransition)
+  if (newUpdate.data) newUpdate.data = _newData(newUpdate.data, targetTransition, false, service)
+  if (newUpdate.with) newUpdate.with = _newData(newUpdate.with, targetTransition, false, service)
+  if (newUpdate.where) {
+    newUpdate.where = _newWhere(
+      newUpdate.where,
+      targetTransition,
+      getEntityNameFromUpdateCQN(query),
+      query.UPDATE.entity.as
+    )
+  }
   Object.defineProperty(newUpdate, '_transitions', {
     enumerable: false,
     value: transitions
@@ -279,7 +327,7 @@ const _newUpdate = (query, transitions) => {
   return newUpdate
 }
 
-const _newSelect = (query, transitions, force) => {
+const _newSelect = (query, transitions, service) => {
   const targetTransition = transitions[transitions.length - 1]
   const newSelect = { ...query.SELECT }
   newSelect.from = {
@@ -287,11 +335,19 @@ const _newSelect = (query, transitions, force) => {
     ref: _rewriteQueryPath(query.SELECT.from, transitions)
   }
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
-  if (newSelect.columns) newSelect.columns = _newColumns(newSelect.columns, targetTransition, force, true)
+  if (newSelect.columns)
+    newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)
   if (newSelect.groupBy) newSelect.groupBy = _newColumns(newSelect.groupBy, targetTransition)
   if (newSelect.orderBy) newSelect.orderBy = _newColumns(newSelect.orderBy, targetTransition)
-  if (newSelect.where) newSelect.where = _newWhere(newSelect.where, targetTransition)
+  if (newSelect.where) {
+    newSelect.where = _newWhere(
+      newSelect.where,
+      targetTransition,
+      query.SELECT.from && query.SELECT.from.ref[0],
+      query.SELECT.from && query.SELECT.from.as
+    )
+  }
   Object.defineProperty(newSelect, '_transitions', {
     enumerable: false,
     value: transitions
@@ -299,7 +355,7 @@ const _newSelect = (query, transitions, force) => {
   return newSelect
 }
 
-const _newInsert = (query, transitions) => {
+const _newInsert = (query, transitions, service) => {
   const targetTransition = transitions[transitions.length - 1]
   const targetName = targetTransition.target.name
   const newInsert = { ...query.INSERT }
@@ -310,7 +366,7 @@ const _newInsert = (query, transitions) => {
       }
     : targetName
   if (newInsert.columns) newInsert.columns = _newInsertColumns(newInsert.columns, targetTransition)
-  if (newInsert.entries) newInsert.entries = _newEntries(newInsert.entries, targetTransition)
+  if (newInsert.entries) newInsert.entries = _newEntries(newInsert.entries, targetTransition, service)
   Object.defineProperty(newInsert, '_transitions', {
     enumerable: false,
     value: transitions
@@ -328,7 +384,14 @@ const _newDelete = (query, transitions) => {
         ref: _rewriteQueryPath(query.DELETE.from, transitions)
       }
     : targetName
-  if (newDelete.where) newDelete.where = _newWhere(newDelete.where, targetTransition)
+  if (newDelete.where) {
+    newDelete.where = _newWhere(
+      newDelete.where,
+      targetTransition,
+      getEntityNameFromDeleteCQN(query),
+      query.DELETE.from.as
+    )
+  }
   Object.defineProperty(newDelete, '_transitions', {
     enumerable: false,
     value: transitions
@@ -336,73 +399,41 @@ const _newDelete = (query, transitions) => {
   return newDelete
 }
 
-const _isPersistenceTable = target => {
-  const persistenceTableTerm = '@cds.persistence.table'
-  const hasOwnProperty = Object.prototype.hasOwnProperty
-  const isPersistenceTable = hasOwnProperty.call(target, persistenceTableTerm) && target[persistenceTableTerm]
-  return isPersistenceTable
-}
-
-const _queryColumns = (target, force = false) => {
-  const columns = (target && target.query && target.query.SELECT && target.query.SELECT.columns) || []
-  if (force) return columns
-
-  // If the entity is annotated with the annotation `@cds.persistence.table`
-  // and elements aliases exist, the aliases must be used as column references.
-  // The reason is that in this scenario, the cds compiler generate a table
-  // instead of a view.
-  if (_isPersistenceTable(target)) {
-    return columns.map(column => {
-      return { ref: [column.as || column.ref[0]] }
-    })
-  }
+const _isPersistenceTable = target =>
+  Object.prototype.hasOwnProperty.call(target, PERSISTENCE_TABLE) && target[PERSISTENCE_TABLE]
 
-  return columns
-}
+const _findRenamed = (cqnColumns, column) =>
+  cqnColumns.find(
+    cqnColumn =>
+      cqnColumn.as &&
+      ((column.ref && column.ref[column.ref.length - 1] === cqnColumn.as) ||
+        (column.as === cqnColumn.as && Object.prototype.hasOwnProperty.call(cqnColumn, 'val')))
+  )
 
-// Find aliased column from the projection and set it as ref
-const _renameColumns = (target, columns, force = false) => {
-  const queryColumns = _queryColumns(target, force)
-
-  const renamedColumns = columns.map(column => {
-    const queryColumn =
-      column.ref &&
-      queryColumns.find(
-        queryColumn =>
-          ((queryColumn.ref && queryColumn.as && queryColumn.ref[queryColumn.ref.length - 1] !== queryColumn.as) ||
-            queryColumn.val) &&
-          column.ref[0] === queryColumn.as
-      )
-
-    if (queryColumn) {
-      const renamedColumn = { as: column.ref[0] }
-      if (column.as) renamedColumn.as = column.as
-      if (queryColumn.ref) {
-        const aliasOfTargetEntity = target.query.SELECT && target.query.SELECT.from && target.query.SELECT.from.as
-        renamedColumn.ref =
-          aliasOfTargetEntity && queryColumn.ref[0] === aliasOfTargetEntity ? queryColumn.ref.slice(1) : queryColumn.ref
-      }
-      if (queryColumn.val) renamedColumn.val = queryColumn.val
-      return renamedColumn
+const _queryColumns = (target, columns = [], persistenceTable = false, force = false) => {
+  if (!(target && target.query && target.query.SELECT)) return columns
+  const cqnColumns = target.query.SELECT.columns || []
+  const from = target.query.SELECT.from
+  const isTargetAliased = from.as && !target.query._target.query && cqnColumns.some(c => c.ref && c.ref[0] === from.as)
+  if (!columns.length) columns = Object.keys(target.elements).map(e => ({ ref: [e], as: e }))
+  return columns.reduce((res, column) => {
+    const renamed = _findRenamed(cqnColumns, column)
+    if (renamed) {
+      if (renamed.val) return res.concat({ as: renamed.as, val: renamed.val })
+      // There could be some `where` clause inside `ref` which we don't support yet
+      if (!renamed.ref || renamed.ref.some(e => typeof e !== 'string') || renamed.xpr) return res
+      if (isTargetAliased) renamed.ref.shift()
+      // If the entity is annotated with the annotation `@cds.persistence.table`
+      // and elements aliases exist, the aliases must be used as column references.
+      // The reason is that in this scenario, the cds compiler generate a table
+      // instead of a view. If forced, skip this.
+      column.ref = !force && persistenceTable ? [renamed.as] : [...renamed.ref]
     }
-
-    return column
-  })
-
-  return renamedColumns
+    res.push(column)
+    return _appendForeignKeys(res, target, columns, column)
+  }, [])
 }
 
-const _merge = (aliased, inherited) =>
-  inherited.reduce(
-    (res, el1) =>
-      (!aliased.some(el2 => el2.ref && ((el1.as && el2.ref[0] === el1.as) || (el1.ref && el2.ref[0] === el1.ref[0]))) &&
-        res.concat(el1)) ||
-      res,
-    []
-  )
-
-const _starColumns = elements => Object.keys(elements).map(element => ({ ref: [element] }))
-
 const _mappedValue = (col, alias) => {
   const key = col.as || col.ref[0]
 
@@ -414,35 +445,33 @@ const _mappedValue = (col, alias) => {
   return [key, { val: col.val }]
 }
 
-// Don't check for table in case of external services (-> force)
-// Reason for hasOwnProperty: All projections have target in their prototype
-// Revisit: Check if this is really intended
-const _isProjection = (target, force) => target.query && target.query._target && (force || !_isPersistenceTable(target))
-
-const getDBTable = (target, force) => {
-  if (_isProjection(target, force)) {
-    return getDBTable(target.query._target, force)
+const getDBTable = target => {
+  if (target.query && target.query._target && !_isPersistenceTable(target)) {
+    return getDBTable(target.query._target)
   }
   return target
 }
 
-const _includeForeignKeys = (columns, target, force) => {
-  for (const column of _queryColumns(target, force)) {
-    const columnName = column.ref && column.ref[0]
-    const el = column.as && target.elements && target.elements[column.as]
-    if (columnName && el && el.name && el.type === 'cds.Association' && el.keys) {
-      for (const rootKeys of el.keys) {
-        // REVISIT: Check if this also works for deeply nested ones
-        // .as and .ref has a different meaning here
-        // .as means the original property name, if the foreign key is renamed
-        const rootKeyName = rootKeys.as || (rootKeys.ref && rootKeys.ref[0])
-        columns.push({
-          ref: [`${columnName}_${rootKeyName}`],
-          as: `${el.name}_${rootKeyName}`
+const _appendForeignKeys = (newColumns, target, columns, { as, ref = [] }) => {
+  const el = target.elements[as] || target.query._target.elements[ref[ref.length - 1]]
+  if (el && el.isAssociation && el.keys) {
+    for (const key of el.keys) {
+      // .as and .ref has a different meaning here
+      // .as means the original property name, if the foreign key is renamed
+      const keyName = key.as || key.ref[0]
+      const keyAlias = key.ref[0]
+      const found = columns.find(col => col.as === `${as}_${keyAlias}`)
+      if (found) {
+        found.ref = [`${ref.join('_')}_${keyName}`]
+      } else {
+        newColumns.push({
+          ref: [`${ref.join('_')}_${keyName}`],
+          as: `${as}_${keyAlias}`
         })
       }
     }
   }
+  return newColumns
 }
 
 const _checkForForbiddenViews = queryTarget => {
@@ -463,43 +492,24 @@ const _checkForForbiddenViews = queryTarget => {
   }
 }
 
-const _filterColumnsOnce = (target, columns = [], force) => {
-  if (columns.length > 0) return columns
-
-  const cqnColumns = _queryColumns(target, force)
-
-  const plainColumns = cqnColumns
-    // There could be some `where` clause inside `ref` which we don't support yet
-    .filter(c => c !== '*' && !(c.ref && c.ref.some(ele => typeof ele !== 'string')) && !c.xpr)
-    .map(c => ({ ref: (c.as && [c.as]) || c.ref }))
-  _includeForeignKeys(columns, target, force)
-
-  const _target = target.query && target.query._target
-  if (_target && cqnColumns.some(c => c === '*')) {
-    // 'alias' is required to properly perform mapping
-    const starColumns = _starColumns(_target.elements).map(c => (c.as && c) || { as: c.ref[0], ref: c.ref })
-    columns.push(..._merge(plainColumns, starColumns))
-  }
-
-  columns.push(...plainColumns)
-
-  return columns
-}
-
-const _getTransitionData = (target, columns, force, skipForbiddenViewCheck) => {
+const _getTransitionData = (target, columns, service, skipForbiddenViewCheck) => {
   // REVISIT: Find less param polluting way to skip forbidden view check for reads
   if (!skipForbiddenViewCheck) _checkForForbiddenViews(target)
-
-  if (!columns.length) {
-    columns = _filterColumnsOnce(target, columns, force)
+  const targetStartsWithSrvName = service.namespace && target.name.startsWith(`${service.namespace}.`)
+  const persistenceTable = _isPersistenceTable(target)
+  columns = _queryColumns(target, columns, persistenceTable, service.name !== 'db' && !targetStartsWithSrvName)
+  if (persistenceTable && service.name === 'db') {
+    return { target, transitionColumns: columns }
   }
-
-  if (_isProjection(target, force)) {
-    columns = _renameColumns(target, columns, force)
+  // stop projection resolving if it starts with the service name prefix or if there is nothing to resolve anymore
+  if ((service.name !== 'db' && targetStartsWithSrvName) || !(target.query && target.query._target)) {
+    return { target, transitionColumns: columns }
+  }
+  // continue projection resolving if the target is a projection
+  if (target.query && target.query._target) {
     const newTarget = target.query._target
-    return _getTransitionData(newTarget, columns, force, skipForbiddenViewCheck)
+    return _getTransitionData(newTarget, columns, service, skipForbiddenViewCheck)
   }
-
   return { target, transitionColumns: columns }
 }
 
@@ -507,16 +517,16 @@ const _getTransitionData = (target, columns, force, skipForbiddenViewCheck) => {
  * If no entity definition is found, no transition is done.
  *
  * @param queryTarget
- * @param force
+ * @param service
  * @param skipForbiddenViewCheck
  */
-const getTransition = (queryTarget, force, skipForbiddenViewCheck) => {
+const getTransition = (queryTarget, service, skipForbiddenViewCheck) => {
   // Never resolve unknown targets (e.g. for drafts)
-  if (!queryTarget || (_isPersistenceTable(queryTarget) && !force)) {
+  if (!queryTarget) {
     return { target: queryTarget, queryTarget, mapping: new Map() }
   }
 
-  const { target: _target, transitionColumns } = _getTransitionData(queryTarget, [], force, skipForbiddenViewCheck)
+  const { target: _target, transitionColumns } = _getTransitionData(queryTarget, [], service, skipForbiddenViewCheck)
   const query = queryTarget.query
   const alias = query && query.SELECT && query.SELECT.from && query.SELECT.from.as
   const mappedColumns = transitionColumns.map(column => _mappedValue(column, alias))
@@ -524,11 +534,11 @@ const getTransition = (queryTarget, force, skipForbiddenViewCheck) => {
   return { target: _target, queryTarget, mapping }
 }
 
-const _entityTransitionsForTarget = (from, model, force) => {
+const _entityTransitionsForTarget = (from, model, service) => {
   let previousEntity
 
   if (typeof from === 'string') {
-    return model.definitions[from] && [getTransition(model.definitions[from], force)]
+    return model.definitions[from] && [getTransition(model.definitions[from], service)]
   }
 
   return from.ref.map((f, i) => {
@@ -538,22 +548,30 @@ const _entityTransitionsForTarget = (from, model, force) => {
       const entity = model.definitions[element]
       if (entity) {
         previousEntity = entity
-        return getTransition(entity, force)
+        return getTransition(entity, service)
       }
     }
 
     if (previousEntity) {
       const entity = previousEntity.elements[element] && previousEntity.elements[element]._target
-
       if (entity) {
+        // > assoc
         previousEntity = entity
-        return getTransition(entity, force)
+        return getTransition(entity, service)
+      } else {
+        // > struct
+        previousEntity = previousEntity.elements[element]
+        return {
+          target: previousEntity,
+          queryTarget: previousEntity,
+          mapping: new Map()
+        }
       }
     }
   })
 }
 
-const _newQuery = (query, event, model, force) => {
+const _newQuery = (query, event, model, service) => {
   const [_prop, _func] = {
     SELECT: ['from', _newSelect],
     INSERT: ['into', _newInsert],
@@ -561,25 +579,25 @@ const _newQuery = (query, event, model, force) => {
     DELETE: ['from', _newDelete]
   }[event]
   const newQuery = Object.create(query)
-  const transitions = _entityTransitionsForTarget(query[event][_prop], model, force)
-  newQuery[event] = (transitions[0] && _func(newQuery, transitions, force)) || { ...query[event] }
+  const transitions = _entityTransitionsForTarget(query[event][_prop], model, service)
+  newQuery[event] = (transitions[0] && _func(newQuery, transitions, service)) || { ...query[event] }
   return newQuery
 }
 
-const resolveView = (query, model, component, force) => {
+const resolveView = (query, model, service) => {
   // swap logger
   const _LOG = LOG
-  LOG = cds.log(component)
+  LOG = cds.log(service.kind) // REVISIT: Avoid obtaining loggers per request!
 
   // If the query is a projection, one must follow it
   // to let the underlying service know its true entity.
+  if (query.cmd) _event = query.cmd
+  else if (query.SELECT) _event = 'SELECT'
+  else if (query.INSERT) _event = 'INSERT'
+  else if (query.UPDATE) _event = 'UPDATE'
+  else if (query.DELETE) _event = 'DELETE'
 
-  if (query.SELECT) _event = 'SELECT'
-  if (query.INSERT) _event = 'INSERT'
-  if (query.UPDATE) _event = 'UPDATE'
-  if (query.DELETE) _event = 'DELETE'
-
-  const newQuery = _newQuery(query, _event, model, force)
+  const newQuery = _newQuery(query, _event, model, service)
 
   // restore logger and clear _event
   LOG = _LOG
@@ -588,9 +606,43 @@ const resolveView = (query, model, component, force) => {
   return newQuery
 }
 
+/**
+ * Restores the link of req.data and req.query in case req.query was overwritten.
+ * Only applicable for UPDATEs and INSERTs.
+ *
+ * @param {*} req
+ */
+const restoreLink = req => {
+  if (req.query.INSERT && req.query.INSERT.entries) {
+    if (Array.isArray(req.query.INSERT.entries)) req.data = req.query.INSERT.entries[0]
+    else req.data = req.query.INSERT.entries
+  } else if (req.query.UPDATE && req.query.UPDATE.data) {
+    req.data = req.query.UPDATE.data
+  }
+}
+
+/**
+ * Retrieves the actual query target by evaluating the created transitions.
+ * @param {*} q - the resolved query
+ * @returns {*} csn entity or undefined
+ */
+const findQueryTarget = q => {
+  return q.SELECT
+    ? q.SELECT._transitions[q.SELECT._transitions.length - 1].target
+    : q.INSERT
+    ? q.INSERT._transitions[q.INSERT._transitions.length - 1].target
+    : q.UPDATE
+    ? q.UPDATE._transitions[q.UPDATE._transitions.length - 1].target
+    : q.DELETE
+    ? q.DELETE._transitions[q.DELETE._transitions.length - 1].target
+    : undefined
+}
+
 module.exports = {
+  findQueryTarget,
   getDBTable,
   resolveView,
   getTransition,
+  restoreLink,
   revertData
 }