@sap/cds 5.4.3 → 5.5.0

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

@@ -9,11 +9,11 @@ const { foreignKeyPropagations } = require('./foreignKeyPropagations')
 const search2cqn4sql = require('./search2cqn4sql')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 const getError = require('../../common/error')
-
-const SYMBOL_FROM_ANNOTATION = Symbol.for('sap.cds.FROM_ANNOTATION')
+const { getPathFromRef, getEntityFromPath } = require('../../common/utils/path')
 
 const PARENT_ALIAS = '_parent_'
-const FOREIGN_ALIAS = 'foreign'
+const PARENT_ALIAS_REGEX = new RegExp('^' + PARENT_ALIAS + '\\d*$')
+const FOREIGN_ALIAS = '_foreign_'
 const OPERATIONS = ['=', '>', '<', '!=', '<>', '>=', '<=', 'like', 'between', 'in', 'not in']
 
 const _addOnCondToWhere = (cqn, entity, navigation, tableAlias, identifier, csn, prefix) => {
@@ -39,7 +39,7 @@ const _addOnCondToWhere = (cqn, entity, navigation, tableAlias, identifier, csn,
 // special case in lambda functions
 const _addParentAlias = (where, alias) => {
   where.forEach(e => {
-    if (e.ref && e.ref[0] === PARENT_ALIAS) {
+    if (e.ref && e.ref[0].match(PARENT_ALIAS_REGEX)) {
       e.ref[0] = alias
     }
   })
@@ -47,9 +47,7 @@ const _addParentAlias = (where, alias) => {
 
 const _addAliasToElement = (e, alias) => {
   if (e.ref) {
-    const aliased = { ref: [alias, ...e.ref] }
-    if (e[SYMBOL_FROM_ANNOTATION]) aliased[SYMBOL_FROM_ANNOTATION] = true
-    return aliased
+    return { ref: [alias, ...e.ref] }
   }
 
   if (e.list) {
@@ -94,10 +92,10 @@ const _getTargetFromRef = ref => {
 
 const _getEntityName = (fromClause, entity, i) => {
   const targetName = _getTargetFromRef(fromClause.ref[i])
-  return i === 0 ? targetName : entity.elements[targetName].target
+  return i === 0 ? targetName : entity && entity.elements[targetName] && entity.elements[targetName].target
 }
 
-const convertPathExpressionToWhere = (fromClause, model) => {
+const convertPathExpressionToWhere = (fromClause, model, options) => {
   if (fromClause.ref.length === 1) {
     const target = _getTargetFromRef(fromClause.ref[0])
     const alias = fromClause.as
@@ -107,6 +105,7 @@ const convertPathExpressionToWhere = (fromClause, model) => {
 
   let previousSelect, previousEntityName, previousTableAlias, structParent
   let prefix = []
+  let columns
   for (let i = 0; i < fromClause.ref.length; i++) {
     const entity = structParent || model.definitions[previousEntityName]
     const element = _elementFromRef(fromClause.ref[i], entity)
@@ -115,14 +114,16 @@ const convertPathExpressionToWhere = (fromClause, model) => {
       prefix.push(element.name)
       structParent = element
       continue
-    }
-
-    if (element && element.isAssociation && fromClause.ref[i].where) {
-      const target = element._target
-      _modifyNavigationInWhere(fromClause.ref[i].where, target)
+    } else if (element && element.isAssociation) {
+      _modifyNavigationInWhere(fromClause.ref[i].where, element._target)
+    } else if (element && previousSelect && i === fromClause.ref.length - 1) {
+      columns = [{ ref: [...prefix, element.name] }]
+      fromClause.ref.splice(-1)
+      continue
     }
 
     const currentEntityName = _getEntityName(fromClause, entity, i)
+    if (!currentEntityName) continue
     const tableAlias = `T${i}`
     const currentSelect = SELECT.from(`${currentEntityName} as ${tableAlias}`)
 
@@ -144,7 +145,7 @@ const convertPathExpressionToWhere = (fromClause, model) => {
         model,
         prefix
       )
-
+      _convertSelect(previousSelect, model, options)
       currentSelect.where('exists', previousSelect)
     }
 
@@ -158,7 +159,8 @@ const convertPathExpressionToWhere = (fromClause, model) => {
   return {
     target: previousEntityName,
     alias: previousTableAlias,
-    where: previousSelect && previousSelect.SELECT && previousSelect.SELECT.where
+    where: previousSelect && previousSelect.SELECT && previousSelect.SELECT.where,
+    columns
   }
 }
 
@@ -258,23 +260,30 @@ const _isAll = element => {
   return last && last.id && last.where && last.where[0] === 'not' && last.where[1].xpr
 }
 
-const _getLambdaSubSelect = (cqn, index, lambdaOp, model) => {
+const _getLambdaSubSelect = (cqn, index, lambdaOp, model, options) => {
   const _unshiftRefsWithNavigation = nav => el => {
     if (el.ref) return { ref: [...nav, ...el.ref] }
     if (el.xpr) return { xpr: el.xpr.map(_unshiftRefsWithNavigation(nav)) }
     return el
   }
-  cqn.SELECT.from.as = PARENT_ALIAS
+
+  if (!options.lambdaIteration) options.lambdaIteration = 1
+
+  const outerAlias = cqn.SELECT.from.as || PARENT_ALIAS + options.lambdaIteration
+  const innerAlias = FOREIGN_ALIAS + options.lambdaIteration
+  cqn.SELECT.from.as = outerAlias
+
+  const queryTarget = getEntityFromPath(getPathFromRef(cqn.SELECT.from.ref), model)
+
   const nav = cqn.SELECT.where[index].ref.map(el => (el.id ? el.id : el))
-  const navName = nav[0]
   const last = cqn.SELECT.where[index].ref.slice(-1)[0]
-  // REVISIT: for some reason cqn._target is not the csn entity here
-  const queryTarget = model.definitions[cqn._target.name] || cqn._target
+  const navName = queryTarget.elements[nav[0]] ? nav[0] : nav[nav.length - 1]
   const navElement = queryTarget.elements[navName]
   const lastElement = nav.reduce((csn, segment) => {
     if (csn.items) return csn // arrayed not supported
     if (csn.elements) {
       const next = csn.elements[segment]
+      if (!next) return csn
       if (next.target) return model.definitions[next.target]
       return next
     }
@@ -286,38 +295,54 @@ const _getLambdaSubSelect = (cqn, index, lambdaOp, model) => {
     ? nav.length > 1
       ? last.where.map(_unshiftRefsWithNavigation(nav.slice(1)))
       : last.where
-    : [{ val: 1 }, '=', { val: 1 }]
+    : undefined
   const onConditionOptions = {
     associationNames: navName,
     csn: model,
     aliases: {
-      select: FOREIGN_ALIAS,
-      join: PARENT_ALIAS
+      select: innerAlias,
+      join: outerAlias
     }
   }
   const onCondition = getOnCond(navElement, onConditionOptions)
 
-  const subSelect = SELECT.from({ ref: [navElement.target], as: 'foreign' })
-  if (condition) subSelect.where(condition)
+  const subSelect = SELECT.from({ ref: [navElement.target], as: innerAlias })
+  if (condition) {
+    if (subSelect.SELECT.from.as) {
+      for (let i = 0; i < condition.length; i++) {
+        if (
+          condition[i].ref &&
+          condition[i].ref.length > 1 &&
+          condition[i].ref.every(r => typeof r === 'string') &&
+          condition[i].ref[0] === navName
+        ) {
+          condition[i].ref[0] = subSelect.SELECT.from.as
+        }
+      }
+    }
+    subSelect.where(condition)
+  }
   subSelect.where(onCondition)
   if (cds.env.effective.odata.structs) {
     flattenStructuredSelect(subSelect, model)
   }
   subSelect.columns([{ val: 1 }])
 
-  return subSelect
+  // nested where exists needs recursive conversion
+  options.lambdaIteration++
+  return _convertSelect(subSelect, model, options)
 }
 
-const _convertLambda = (cqn, model) => {
+const _convertLambda = (cqn, model, options) => {
   const where = cqn.SELECT.where
 
   if (where) {
     where.forEach((element, index) => {
       if (element === 'exists' && _isAny(where[index + 1])) {
-        where[index + 1] = _getLambdaSubSelect(cqn, index + 1, 'any', model)
+        where[index + 1] = _getLambdaSubSelect(cqn, index + 1, 'any', model, options)
       }
       if (element === 'not' && where[index + 1] === 'exists' && _isAll(where[index + 2])) {
-        where[index + 2] = _getLambdaSubSelect(cqn, index + 2, 'all', model)
+        where[index + 2] = _getLambdaSubSelect(cqn, index + 2, 'all', model, options)
       }
     })
   }
@@ -415,22 +440,24 @@ const _convertWhereIfSkip = (whereCQN, index) => {
   OPERATIONS.includes(whereCQN[index + 1]) ? whereCQN.splice(index + 1, 2) : whereCQN.splice(index - 2, 2)
 }
 
-const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, cqn, model, processFn) => {
-  const queryTarget = model.definitions[ensureNoDraftsSuffix(getEntityNameFromCQN(cqn))]
+const _convertOrderByOrWhereCQN = (orderByOrWhereCQN, target, model, processFn) => {
+  const queryTarget = model.definitions[ensureNoDraftsSuffix(target)]
+
   orderByOrWhereCQN.forEach((el, index) => {
     if (el.ref && _skip(queryTarget, el.ref, model)) processFn(orderByOrWhereCQN, index)
   })
 }
 
-const _convertOrderByOrWhereIfSkip = (cqn, model) => {
+const _convertOrderByOrWhereIfSkip = (cqn, target, model) => {
   if (cqn.SELECT.orderBy && cqn.SELECT.orderBy.length > 1) {
-    _convertOrderByOrWhereCQN(cqn.SELECT.orderBy, cqn, model, _convertOrderByIfSkip)
+    _convertOrderByOrWhereCQN(cqn.SELECT.orderBy, target, model, _convertOrderByIfSkip)
   }
 
   if (cqn.SELECT.where) {
-    _convertOrderByOrWhereCQN(cqn.SELECT.where, cqn, model, _convertWhereIfSkip)
+    _convertOrderByOrWhereCQN(cqn.SELECT.where, target, model, _convertWhereIfSkip)
   }
 }
+
 const _convertExpand = expand => {
   expand.forEach(expandElement => {
     if (expandElement.ref && expandElement.ref[0]) {
@@ -456,12 +483,42 @@ const _convertRefWhereInExpand = columns => {
   }
 }
 
+const _defaultColumns4 = entity => {
+  if (entity && entity.elements) {
+    const addAliasToColumns = []
+    for (const column in entity.elements) {
+      if (column === 'DraftAdministrativeData_DraftUUID') continue
+      const e = entity.elements[column]
+      if (e.isAssociation || e.virtual) continue
+      else if (entity._isDraftEnabled && column === 'IsActiveEntity') {
+        addAliasToColumns.push({ val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } })
+      } else if (entity._isDraftEnabled && column === 'HasActiveEntity') {
+        addAliasToColumns.push({ val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } })
+      } else if (entity._isDraftEnabled && column === 'HasDraftEntity') {
+        const draftName = `${entity.name}_drafts`
+        const subSelect = SELECT.from(draftName).columns([1])
+        for (const k in entity.keys) {
+          if (k !== 'IsActiveEntity') subSelect.where([{ ref: [entity.name, k] }, '=', { ref: [draftName, k] }])
+        }
+        addAliasToColumns.push({
+          xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
+          as: 'HasDraftEntity',
+          cast: { type: 'cds.Boolean' }
+        })
+      } else addAliasToColumns.push({ ref: [column], as: column })
+    }
+    return addAliasToColumns
+  }
+}
+
+// eslint-disable-next-line complexity
 const _convertSelect = (cqn, model, options) => {
-  // remove virtual and with skip annotated fields in orderby and where
-  _convertOrderByOrWhereIfSkip(cqn, model)
+  // REVISIT: still needed?
+  // Moved from old SELECT.from where this done much too eager, always for all queries
+  if (!cqn.SELECT.columns && cqn._target) cqn.SELECT.columns = _defaultColumns4(cqn._target)
 
   // lambda functions
-  _convertLambda(cqn, model)
+  _convertLambda(cqn, model, options)
 
   // add 'or is null' in case of '!='
   if (cqn.SELECT._4odata) _convertNotEqual(cqn.SELECT)
@@ -474,6 +531,9 @@ const _convertSelect = (cqn, model, options) => {
 
   // no path expression
   if (!cqnSelectFromRef || (cqnSelectFromRef.length === 1 && !cqnSelectFromRef[0].where)) {
+    // remove virtual and with skip annotated fields in orderby and where
+    _convertOrderByOrWhereIfSkip(cqn, getEntityNameFromCQN(cqn), model)
+
     if (cqnSelectFromRef && cqn.SELECT.search && !options.suppressSearch) {
       searchOptions = { ...searchOptions, ...{ targetName: cqnSelectFromRef[0] } }
       search2cqn4sql(cqn, model, searchOptions)
@@ -492,8 +552,12 @@ const _convertSelect = (cqn, model, options) => {
   }
 
   // path expression handling
-  const { target, alias, where, cardinality } = convertPathExpressionToWhere(cqn.SELECT.from, model)
-  const select = SELECT.from(target)
+  const { target, alias, where, cardinality, columns } = convertPathExpressionToWhere(cqn.SELECT.from, model, options)
+
+  // remove virtual and with skip annotated fields in orderby and where
+  _convertOrderByOrWhereIfSkip(cqn, target, model)
+
+  const select = SELECT.from(target, columns || cqn.SELECT.columns)
 
   if (alias) {
     select.SELECT.from.as = alias
@@ -519,7 +583,11 @@ const _convertSelect = (cqn, model, options) => {
 
   // We add all previous properties ot the newly created query.
   // Reason is to not lose the query API functionality
-  Object.assign(select.SELECT, cqn.SELECT, { from: select.SELECT.from, where: select.SELECT.where })
+  Object.assign(select.SELECT, cqn.SELECT, {
+    columns: select.SELECT.columns,
+    from: select.SELECT.from,
+    where: select.SELECT.where
+  })
 
   if (select.SELECT.columns && cds.env.effective.odata.structs) {
     flattenStructuredSelect(select, model)
@@ -528,35 +596,6 @@ const _convertSelect = (cqn, model, options) => {
   return select
 }
 
-const _getElement = (column, columns, target) => {
-  if (!target) return
-
-  if (columns) {
-    // if columns is defined, column is index and row[column] should contain value that belongs to name in columns with same index
-    return target.elements[columns[column]]
-  }
-
-  return target.elements[column]
-}
-
-const _handleArrayedElements = (rows, target, columns) => {
-  for (const row of rows) {
-    for (const column in row) {
-      const element = _getElement(column, columns, target)
-
-      if (element && element.is2one) {
-        _handleArrayedElements([row[column]], element._target, columns)
-      } else if (element && element.is2many) {
-        _handleArrayedElements(row[column], element._target, columns)
-      } else if (element && element._isStructured) {
-        _handleArrayedElements([row[column]], element, columns)
-      } else if (Array.isArray(row[column])) {
-        row[column] = JSON.stringify(row[column])
-      }
-    }
-  }
-}
-
 const _convertInsert = (cqn, model) => {
   // resolve path expression
   const resolvedIntoClause = _convertPathExpressionForInsertOrDelete(cqn.INSERT.into, model)
@@ -571,22 +610,11 @@ const _convertInsert = (cqn, model) => {
   Object.assign(insert.INSERT, cqn.INSERT, { into: resolvedIntoClause })
 
   const targetName = insert.INSERT.into.name || insert.INSERT.into
-  const queryTarget = model.definitions[ensureNoDraftsSuffix(targetName)]
-
-  if (cds.env.effective.odata.version !== 'v2') {
-    if (cqn.INSERT.entries) {
-      _handleArrayedElements(cqn.INSERT.entries, queryTarget)
-    } else if (cqn.INSERT.rows) {
-      _handleArrayedElements(cqn.INSERT.rows, queryTarget, cqn.INSERT.columns)
-    } else if (cqn.INSERT.values) {
-      _handleArrayedElements([cqn.INSERT.values], queryTarget, cqn.INSERT.columns)
-    }
-  }
 
   const target = model.definitions[targetName]
   if (!target) return insert
 
-  const resolvedView = resolveView(insert, model, 'db')
+  const resolvedView = resolveView(insert, model, cds.db)
 
   if (cqn.INSERT.into.ref && cqn.INSERT.into.ref.length > 1) {
     const copyFrom = [...cqn.INSERT.into.ref]
@@ -598,6 +626,7 @@ const _convertInsert = (cqn, model) => {
 }
 
 function _modifyNavigationInWhere(whereClause, target) {
+  if (!whereClause) return
   whereClause.forEach(e => {
     if (e.ref && e.ref.length > 1 && target.elements[e.ref[0]]) {
       const element = target.elements[e.ref[0]]
@@ -619,10 +648,10 @@ const _plainDelete = (cqn, model) => {
   const target = model.definitions[name]
   if (!target) return cqn
 
-  return resolveView(cqn, model, 'db')
+  return resolveView(cqn, model, cds.db)
 }
 
-const _convertDelete = (cqn, model) => {
+const _convertDelete = (cqn, model, options) => {
   // .from is plain string or csn entity
   if (
     typeof cqn.DELETE.from === 'string' ||
@@ -632,7 +661,7 @@ const _convertDelete = (cqn, model) => {
     return _plainDelete(cqn, model)
   }
 
-  const { target, alias, where } = convertPathExpressionToWhere(cqn.DELETE.from, model)
+  const { target, alias, where } = convertPathExpressionToWhere(cqn.DELETE.from, model, options)
   const deleet = DELETE('x')
   Object.assign(deleet.DELETE, cqn.DELETE, { from: target, where: undefined })
 
@@ -643,37 +672,30 @@ const _convertDelete = (cqn, model) => {
   const targetEntity = model.definitions[target]
   if (!targetEntity) return deleet
 
-  return resolveView(deleet, model, 'db')
+  return resolveView(deleet, model, cds.db)
 }
 
 function _plainUpdate(cqn, model) {
   const name = cqn.UPDATE.entity.name || (cqn.UPDATE.entity.ref && cqn.UPDATE.entity.ref[0]) || cqn.UPDATE.entity
-  const queryTarget = model.definitions[ensureNoDraftsSuffix(name)]
-
-  if (cds.env.effective.odata.version !== 'v2') {
-    cqn.UPDATE.data && _handleArrayedElements([cqn.UPDATE.data], queryTarget)
-    cqn.UPDATE.with && _handleArrayedElements([cqn.UPDATE.with], queryTarget)
-  }
-
   const target = model.definitions[name]
   if (!target) return cqn
 
-  return resolveView(cqn, model, 'db')
+  return resolveView(cqn, model, cds.db)
 }
 
-const _convertUpdate = (cqn, model) => {
+const _convertUpdate = (cqn, model, options) => {
   // REVISIT flatten structured types, currently its done in SQL builder
 
   // .into is plain string or csn entity
   if (
     typeof cqn.UPDATE.entity === 'string' ||
     cqn.UPDATE.entity.name ||
-    (cqn.UPDATE.entity.ref && typeof cqn.UPDATE.entity.ref[0] === 'string')
+    (cqn.UPDATE.entity.ref && typeof cqn.UPDATE.entity.ref[0] === 'string' && cqn.UPDATE.entity.ref.length === 1)
   ) {
     return _plainUpdate(cqn, model)
   }
 
-  const { target, alias, where } = convertPathExpressionToWhere(cqn.UPDATE.entity, model)
+  const { target, alias, where } = convertPathExpressionToWhere(cqn.UPDATE.entity, model, options)
 
   // link .with and .data and set query target and remove current where clause
   // REVISIT: update statement does not accept cqn partial as input
@@ -684,17 +706,10 @@ const _convertUpdate = (cqn, model) => {
   if (where) update.where(where)
   if (cqn.UPDATE.where) update.where(_addAliasToExpression(cqn.UPDATE.where, alias))
 
-  const queryTarget = model.definitions[target]
-
-  if (cds.env.effective.odata.version !== 'v2') {
-    cqn.UPDATE.data && _handleArrayedElements([cqn.UPDATE.data], queryTarget)
-    cqn.UPDATE.with && _handleArrayedElements([cqn.UPDATE.with], queryTarget)
-  }
-
   const targetEntity = model.definitions[target]
   if (!targetEntity) return update
 
-  return resolveView(update, model, 'db')
+  return resolveView(update, model, cds.db)
 }
 
 /**
@@ -715,15 +730,15 @@ const cqn2cqn4sql = (cqn, model, options = { suppressSearch: false }) => {
   }
 
   if (cqn.UPDATE) {
-    return _convertUpdate(cqn, model)
+    return _convertUpdate(cqn, model, options)
   }
 
   if (cqn.INSERT) {
-    return _convertInsert(cqn, model)
+    return _convertInsert(cqn, model, options)
   }
 
   if (cqn.DELETE) {
-    return _convertDelete(cqn, model)
+    return _convertDelete(cqn, model, options)
   }
 
   return cqn

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

@@ -1,6 +1,7 @@
 const cds = require('../../cds')
 
 const { ensureNoDraftsSuffix } = require('./draft')
+const { getFlatArray } = require('../../db/utils/deep')
 
 const getEtagElement = entity => {
   return Object.values(entity.elements).find(element => element['@odata.etag'])
@@ -41,7 +42,7 @@ const _isDependent = (assoc, parent, target) => {
  * doing as aspect is difficult due to no global definitons per tenant
  */
 const getDependents = (entity, model) => {
-  if (entity._dependents !== undefined) return entity._dependents
+  if (entity.own('__dependents')) return entity.__dependents
 
   /** @type {Array|boolean} */
   let dependents = []
@@ -61,8 +62,49 @@ const getDependents = (entity, model) => {
   }
 
   if (dependents.length === 0) dependents = false
-  Object.defineProperty(entity, '_dependents', { value: dependents })
-  return dependents
+  return entity.set('__dependents', dependents)
+}
+
+const _getUps = (entity, model, previous = []) => {
+  const ups = []
+  for (const def of Object.values(model.definitions)) {
+    if (def.kind !== 'entity') continue
+    if (!def.associations) continue
+    for (const assoc of Object.values(def.associations)) {
+      if (assoc.target !== entity.name) continue
+      ups.push({
+        entity: assoc.parent,
+        assoc: assoc,
+        previous
+      })
+    }
+  }
+  return ups
+}
+
+const _ifDataSubject = (entity, role) => {
+  return entity['@PersonalData.EntitySemantics'] === 'DataSubject' && entity['@PersonalData.DataSubjectRole'] === role
+}
+
+const getDataSubject = (entity, model, role) => {
+  const hash = '__dataSubject4' + role
+  if (entity.own(hash)) return entity[hash]
+
+  if (_ifDataSubject(entity, role)) return entity.set(hash, { entity: entity, assoc: [], previous: [] })
+
+  let dataSubject
+  let ups = _getUps(entity, model)
+  while (!dataSubject) {
+    for (const { entity, assoc, previous } of ups) {
+      if (_ifDataSubject(entity, role)) dataSubject = { entity, assoc, previous }
+    }
+    if (dataSubject) break
+    ups = getFlatArray([
+      ...ups.map(up => [..._getUps(up.entity, model, up.previous.concat({ entity: up.entity, assoc: up.assoc }))])
+    ])
+  }
+
+  return entity.set(hash, dataSubject)
 }
 
 const _findRootEntity = (entities, edmName) => {
@@ -128,6 +170,14 @@ const findCsnTargetFor = (edmName, model, namespace) => {
   return mapping[edmName]
 }
 
+const getElementDeep = (entity, ref) => {
+  let current = entity
+  for (const r of ref) {
+    current = current && current.elements && current.elements[r]
+  }
+  return current
+}
+
 const isRootEntity = (definitions, entityName) => {
   const entity = definitions[entityName]
   if (!entity) return false
@@ -156,6 +206,8 @@ const isRootEntity = (definitions, entityName) => {
 module.exports = {
   getEtagElement,
   findCsnTargetFor,
+  getElementDeep,
   getDependents,
-  isRootEntity
+  isRootEntity,
+  getDataSubject
 }

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

@@ -1,39 +1,3 @@
-// REVISIT: use follow projection
-
-const getError = require('../error')
-
-const _renameData = (query, data) => {
-  if (query.SELECT && query.SELECT.columns) {
-    for (const col of query.SELECT.columns) {
-      if (typeof col === 'object' && col.ref && col.as && col.ref[0] !== col.as) {
-        if (data[col.as]) {
-          data[col.ref[0]] = data[col.as]
-          delete data[col.as]
-        }
-      }
-    }
-  }
-}
-
-const getTargetData = (target, data = {}) => {
-  if (target.query) {
-    _renameData(target.query, data)
-
-    if (target.query._target) {
-      return getTargetData(target.query._target, data)
-    }
-
-    if (!target.query.from || target.query.from.length > 1 || target.query.where) {
-      // REVISIT: when is this the case?! getTargetData only used in deleteDraftUtils...
-      throw getError(501, 'Insert, Update or Delete on views with join|union|where is not supported')
-    }
-
-    return { target: target.query.from[0].absolute, data }
-  }
-
-  return { target, data }
-}
-
 // REVISIT: remove once not needed anymore
 const getDataFromCQN = query => (query.INSERT && query.INSERT.entries) || (query.UPDATE && query.UPDATE.data)
 
@@ -47,7 +11,6 @@ const setDataFromCQN = req => {
 }
 
 module.exports = {
-  getTargetData,
   getDataFromCQN,
   setDataFromCQN
 }

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

@@ -85,7 +85,7 @@ module.exports = (data, { query, target }, { model }) => {
   } else if (query.UPDATE) {
     const where = _getWhereFromUpdate(query, target, model)
     if (!where || !where.length) return
-
+    if (!data) data = query.UPDATE.data = {} // REVISIT: We should not expect data to be present always!
     _addKeysFromWhereToData(where, target, data)
   }
 }

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

@@ -1,38 +1,21 @@
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
-const _entityFromRef = ref => {
-  if (ref) return ref[0].id || ref[0]
-}
-
 const getEntityNameFromCQN = cqn => {
-  while (cqn.SELECT) {
-    cqn = cqn.SELECT.from
-  }
+  while (cqn.SELECT) cqn = cqn.SELECT.from
 
-  return _getEntityNameFromUnionCQN(cqn) || _entityFromRef(cqn.ref)
-}
+  // Do the most likely first -> {ref}
+  if (cqn.ref) {
+    return cqn.ref[0].id || cqn.ref[0]
+  }
 
-const _getEntityNameFromUnionCQN = cqn => {
   // TODO cleanup
   // REVISIT infer should do this for req.target
   // REVISIT2 No, req.target doesn't make sense for joins
   if (cqn.SET) {
-    return cqn.SET.args
-      .map(arg => {
-        return getEntityNameFromCQN(arg)
-      })
-      .filter(name => {
-        return name !== 'DRAFT.DraftAdministrativeData'
-      })[0]
+    return cqn.SET.args.map(getEntityNameFromCQN).find(n => n !== 'DRAFT.DraftAdministrativeData')
   }
   if (cqn.join) {
-    return cqn.args
-      .map(arg => {
-        return getEntityNameFromCQN(arg)
-      })
-      .filter(name => {
-        return name !== 'DRAFT.DraftAdministrativeData'
-      })[0]
+    return cqn.args.map(getEntityNameFromCQN).find(n => n !== 'DRAFT.DraftAdministrativeData')
   }
 }