@sap/cds 5.8.2 → 5.9.0

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

@@ -1,4 +1,5 @@
 const cds = require('../../cds')
+const resolveStructured = require('../../common/utils/resolveStructured')
 
 const { ensureNoDraftsSuffix } = require('./draft')
 
@@ -140,6 +141,7 @@ const findCsnTargetFor = (edmName, model, namespace) => {
     // probably, a combination of '_' and '.', resolving
     const finding = _findRootEntity(model, edmName, namespace)
     target = finding.target
+
     // something left in navigation path => x4 navigation
     // resolving within found entity
     if (target && finding.left > 0) {
@@ -151,10 +153,12 @@ const findCsnTargetFor = (edmName, model, namespace) => {
       }
     }
   }
+
   // remember edm <-> csn
   if (target) {
     mapping[edmName] = target
   }
+
   return mapping[edmName]
 }
 
@@ -191,7 +195,40 @@ const isRootEntity = (definitions, entityName) => {
   return true
 }
 
+function _alias2RefRest(service) {
+  for (const each of Object.values(service.entities)) {
+    each._alias2ref = {}
+    const keys = each.keys
+    for (const key in keys) {
+      if (keys[key].elements) {
+        const structKeys = resolveStructured({ structName: key, structProperties: [] }, keys[key].elements, false, true)
+        for (const structKey of structKeys) {
+          if (each._alias2ref[structKey.key] != null) {
+            // key clash, aliasing not possible
+            each._alias2ref = {}
+            return
+          }
+          each._alias2ref[structKey.key] = structKey.resolved
+        }
+      }
+    }
+  }
+}
+
+const prefixForStruct = element => {
+  const prefixes = []
+  let parent = element.parent
+  while (parent && parent.kind !== 'entity') {
+    prefixes.push(parent.name)
+    parent = parent.parent
+  }
+  return prefixes.length ? prefixes.reverse().join('_') + '_' : ''
+}
+
 function alias2ref(service, edm) {
+  if (!edm) {
+    return _alias2RefRest(service)
+  }
   const defs = edm[service.definition.name]
   for (const each of Object.values(service.entities)) {
     const def = defs[each.name.replace(service.definition.name + '.', '').replace(/\./g, '_')]
@@ -205,6 +242,29 @@ function alias2ref(service, edm) {
   }
 }
 
+function getDraftTreeRoot(entity, model) {
+  if (entity.own('__draftTreeRoot')) return entity.__draftTreeRoot
+
+  let parent
+  let current = entity
+  while (current && !current['@Common.DraftRoot.ActivationAction']) {
+    const parents = []
+    for (const k in model.definitions) {
+      const e = model.definitions[k]
+      if (e.kind !== 'entity' || !e.compositions) continue
+      for (const c in e.compositions) if (e.compositions[c].target === current.name) parents.push(e)
+    }
+    if (parents.length > 1 && parents.some(p => p !== parents[0])) {
+      // > unable to determine single parent
+      parent = undefined
+      break
+    }
+    current = parent = parents[0]
+  }
+
+  return entity.set('__draftTreeRoot', parent)
+}
+
 module.exports = {
   getEtagElement,
   findCsnTargetFor,
@@ -212,5 +272,7 @@ module.exports = {
   isRootEntity,
   getDataSubject,
   alias2ref,
-  getComp2oneParents
+  getComp2oneParents,
+  prefixForStruct,
+  getDraftTreeRoot
 }

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

@@ -11,7 +11,16 @@ module.exports = (entryOrRow, keyOrIndex, user, timestamp) => {
   else if (entryOrRow[keyOrIndex] === '$now') entryOrRow[keyOrIndex] = timestamp
   else if (entryOrRow[keyOrIndex] === '$uuid') entryOrRow[keyOrIndex] = cds.utils.uuid()
   else if (typeof entryOrRow[keyOrIndex] === 'string') {
+    // NOTE: with xsuaa, user attributes are always arrays
     const attr = entryOrRow[keyOrIndex].match(/^\$user\.(.*)/)
-    if (attr && attr.length > 1) entryOrRow[keyOrIndex] = (user.attr && user.attr[attr[1]]) || null
+    if (attr && attr.length > 1) {
+      const val = (user.attr && user.attr[attr[1]]) || null
+      if (Array.isArray(val)) {
+        if (val.length > 1) entryOrRow[keyOrIndex] = JSON.stringify(val)
+        else entryOrRow[keyOrIndex] = val.length > 0 ? val[0] : null
+      } else {
+        entryOrRow[keyOrIndex] = val
+      }
+    }
   }
 }

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

@@ -18,18 +18,57 @@ const ensureUnlocalized = table => {
   return _table
 }
 
-const ensureDraftsSuffix = name => {
-  if (name.endsWith('_drafts')) {
-    return name
-  }
+const ensureDraftsSuffix = name => (name.endsWith('_drafts') ? name : `${ensureUnlocalized(name)}_drafts`)
+
+const ensureNoDraftsSuffix = name => name.replace(/_drafts$/g, '')
 
-  return `${ensureUnlocalized(name)}_drafts`
+const getDraftColumnsCQNForActive = target => {
+  const draftName = ensureDraftsSuffix(target.name)
+  const subSelect = SELECT.from(draftName).columns([1])
+  for (const key in target.keys) {
+    if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [draftName, key] }])
+  }
+  return [
+    { val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+    { val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } },
+    {
+      xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
+      as: 'HasDraftEntity',
+      cast: { type: 'cds.Boolean' }
+    }
+  ]
 }
 
-const ensureNoDraftsSuffix = name => name.replace(/_drafts$/g, '')
+const getDraftColumnsCQNForDraft = target => {
+  /*
+   * NOTE: the following with xpr could be used to detect if there really is an active or not, but that breaks tests
+   */
+  // const activeName = ensureNoDraftsSuffix(target.name)
+  // const subSelect = SELECT.from(activeName).columns([1])
+  // for (const key in target.keys) {
+  //   if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [activeName, key] }])
+  // }
+  // return [
+  //   { val: false, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+  //   {
+  //     xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
+  //     as: 'HasActiveEntity',
+  //     cast: { type: 'cds.Boolean' }
+  //   },
+  //   { val: false, as: 'HasDraftEntity', cast: { type: 'cds.Boolean' } }
+  // ]
+
+  return [
+    { val: false, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
+    { ref: ['HasActiveEntity'], cast: { type: 'cds.Boolean' } },
+    { val: false, as: 'HasDraftEntity', cast: { type: 'cds.Boolean' } }
+  ]
+}
 
 module.exports = {
   ensureUnlocalized,
   ensureDraftsSuffix,
-  ensureNoDraftsSuffix
+  ensureNoDraftsSuffix,
+  getDraftColumnsCQNForActive,
+  getDraftColumnsCQNForDraft
 }

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

@@ -1,23 +1,26 @@
 const { ensureNoDraftsSuffix } = require('../../common/utils/draft')
 
-const getEntityNameFromCQN = cqn => {
+const traverseFroms = (cqn, cb) => {
   while (cqn.SELECT) cqn = cqn.SELECT.from
 
   // Do the most likely first -> {ref}
   if (cqn.ref) {
-    return { entityName: cqn.ref[0].id || cqn.ref[0], alias: cqn.as }
+    return cb(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(getEntityNameFromCQN).find(n => n.entityName !== 'DRAFT.DraftAdministrativeData')
+    return cqn.SET.args.map(a => traverseFroms(a, cb))
   }
+
   if (cqn.join) {
-    return cqn.args.map(getEntityNameFromCQN).find(n => n.entityName !== 'DRAFT.DraftAdministrativeData')
+    return cqn.args.map(a => traverseFroms(a, cb))
   }
-  return {}
+}
+
+const getEntityNameFromCQN = cqn => {
+  const res = []
+  traverseFroms(cqn, from => res.push({ entityName: from.ref[0].id || from.ref[0], alias: from.as }))
+  return res.length === 1 ? res[0] : res.find(n => n.entityName !== 'DRAFT.DraftAdministrativeData') || {}
 }
 
 // Note: This also works for the common draft scenarios
@@ -31,5 +34,6 @@ const getEntityFromCQN = (req, service) => {
 
 module.exports = {
   getEntityFromCQN,
-  getEntityNameFromCQN
+  getEntityNameFromCQN,
+  traverseFroms
 }

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

@@ -0,0 +1,18 @@
+const optionsApp = require('./vcap.js')
+
+const BASE_TENANT = 'anonymous'
+
+const channelName = () => {
+  // REVISIT: Why so complicated?
+
+  const appName = optionsApp.appName || 'CAP'
+  const appID = optionsApp.appID || '00000000'
+  const shrunkAppID = appID.substring(0, 4)
+
+  return `${appName}/${shrunkAppID}`
+}
+
+module.exports = {
+  BASE_TENANT,
+  channelName
+}

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

@@ -60,8 +60,7 @@ const _foreignKeyPropagationsFromToManyOn = (element, childFieldName) => {
   const foreignKeys = _foreignKeysForTarget(element, childFieldName)
   // REVISIT foreignKeys is empty if we have deep operations where a sub element is annotated with persistence skip
   if (foreignKeys && foreignKeys.length) {
-    const parentKeys = _parentKeys(element)
-    return _resolvedKeys(parentKeys, foreignKeys, true)
+    return _resolvedKeys(foreignKeys, true)
   }
   return []
 }
@@ -118,62 +117,11 @@ const _foreignKeyPropagationsFromOn = element => {
   return foreignKeyPropagations
 }
 
-/*
- * recursive resolvedKeys for a structured element
- * returns how many indexes can be skipped in the outer loop
- * example:
- *   foo: {
- *     bar: {
- *       moo: Integer;
- *       shu: Integer;
- *     };
- *     baz: Integer;
- *   };
- *   -> foo_bar_moo, foo_bar_shu, foo_baz
- *   -> processed three instead of one from outer loop perspective
- */
-const _resolve4struct = (others, struct, fkps, fillChild, childIsStruct, i) => {
-  let j = 0
-
-  for (const k in struct.elements) {
-    const other = others[i + j]
-    const current = struct.elements[k]
-
-    if (current._isStructured) {
-      // call recursive and increment skip
-      j += _resolve4struct(others, current, fkps, fillChild, childIsStruct, i + j)
-    } else if (current.isAssociation) {
-      continue
-    } else {
-      // calc prefix
-      let prefix = struct.name
-      let cur = struct.parent
-      while (cur._isStructured) {
-        prefix = cur.name + '_' + prefix
-        cur = cur.parent
-      }
-
-      // push propagation
-      fkps.push({
-        childElement: childIsStruct ? current : other,
-        parentElement: childIsStruct ? other : current,
-        fillChild,
-        prefix,
-        deep: !fillChild && _resolveTargetForeignKey(childIsStruct ? current : other)
-      })
-
-      // increment skip
-      j++
-    }
-  }
-
-  return j
-}
-
 const _resolveTargetForeignKey = targetKey => {
-  const targetName = targetKey['@odata.foreignKey4']
+  const targetName = targetKey._foreignKey4
   if (!targetName) return
-  const _foreignKeyProps = foreignKeyPropagations(targetKey.parent.elements[targetName])
+  const parentElements = targetKey.parent.elements
+  const _foreignKeyProps = foreignKeyPropagations(parentElements[targetName])
   const propagation = _foreignKeyProps.find(_fkp => _fkp.parentElement && targetKey.name === _fkp.parentElement.name)
   return { targetName, propagation }
 }
@@ -184,39 +132,22 @@ const _resolveColumnsFromQuery = query => {
   return []
 }
 
-const _resolvedKeys = (foreignKeys, targetKeys, fillChild) => {
-  const foreignKeyPropagations = []
+const _resolvedKeys = (keys, fillChild) => {
+  const foreignKeys = fillChild ? keys.map(fk => Object.getPrototypeOf(fk)) : keys
+  const targetKeys = fillChild ? keys : keys.map(fk => Object.getPrototypeOf(fk))
 
+  const foreignKeyPropagations = []
   for (let i = 0; i < foreignKeys.length; i++) {
     const fk = foreignKeys[i]
-    let tk
-
-    /*
-     * REVISIT: poor man's look-up of target key with fallback to targetKeys[i]
-     * Look at elements, then try to find it in query and resolve recursively until you have the full path.
-     * Once you have the full path, you can find it in the target entity.
-     * NOTE: There can be projections upon projections and renamings in every projection. -> not yet covered!!!
-     */
-    const tkCol = _resolveColumnsFromQuery(targetKeys[i].parent.query).find(
-      c => c.ref && `${fk['@odata.foreignKey4']}_${c.ref.join('_')}` === fk.name
-    )
-    tk = tkCol && targetKeys.find(tk => tk.name === (tkCol.as ? tkCol.as : tkCol.ref.join('_')))
-    // with composition of aspects, the lookup fails -> we need this final fallback
-    if (!tk) tk = targetKeys[i]
-
-    if (fk._isStructured) {
-      i += _resolve4struct(targetKeys, fk, foreignKeyPropagations, fillChild, false, i)
-    } else if (tk._isStructured) {
-      i += _resolve4struct(foreignKeys, tk, foreignKeyPropagations, fillChild, true, i)
-    } else {
-      foreignKeyPropagations.push({
-        fillChild,
-        parentElement: fk,
-        childElement: tk,
-        // needed only for child -> parent propagation since template loops in other direction
-        deep: !fillChild && _resolveTargetForeignKey(tk)
-      })
+    const tk = targetKeys[i]
+    const propagation = {
+      fillChild,
+      parentElement: fk,
+      childElement: tk,
+      // needed only for child -> parent propagation since template loops in other direction
+      deep: !fillChild && _resolveTargetForeignKey(tk)
     }
+    foreignKeyPropagations.push(propagation)
   }
 
   return foreignKeyPropagations
@@ -229,10 +160,7 @@ const foreignKeyPropagations = element => {
   if (element.is2one) {
     if (!element.on) {
       const foreignKeys = _foreignKeys(element)
-      if (foreignKeys) {
-        const targetKeys = _targetKeys(element)
-        return _resolvedKeys(foreignKeys, targetKeys)
-      }
+      if (foreignKeys) return _resolvedKeys(foreignKeys, false)
     } else {
       // It's a link through a backlink
       return _foreignKeyPropagationsFromOn(element)
@@ -241,29 +169,85 @@ const foreignKeyPropagations = element => {
   return []
 }
 
-const _foreignKeys = csnElement => {
-  return Object.values(csnElement.parent.elements).filter(element => element['@odata.foreignKey4'] === csnElement.name)
+// REVISIT: Flattening shouldn't be necessary in the future.
+//          It's better to deal with structures instead, but
+//          that would require changing a lot of code.
+const _foreignKeys = element => {
+  const foreignKeys = element.foreignKeys
+  const path = [element.name]
+  const parent = element.parent
+  const result = []
+  _addToForeignKeysRec(foreignKeys, path, parent, result)
+  return result
 }
 
-const _foreignKeysForTarget = (csnElement, name) => {
-  return Object.values(csnElement._target.elements).filter(
-    element =>
-      !element.isAssociation && !element.isComposition && element['@odata.foreignKey4'] === (name || csnElement.name)
+/*
+ * REVISIT: poor man's look-up of target key
+ * Look at elements, then try to find it in query and resolve recursively until you have the full path.
+ * Once you have the full path, you can find it in the target entity.
+ * NOTE: There can be projections upon projections and renamings in every projection. -> not yet covered!!!
+ */
+const _poorMansLookup = (el, name, foreignKeySource) => {
+  // REVISIT: Dirty hack
+  const tkCol = _resolveColumnsFromQuery(el.parent.query).find(
+    c => c.ref && `${foreignKeySource}_${c.ref.join('_')}` === name
   )
+  return tkCol && Object.values(el.parent.elements).find(tk => tk.name === (tkCol.as ? tkCol.as : tkCol.ref.join('_')))
 }
 
-const _targetKeys = csnElement => {
-  return Object.values(csnElement._target.keys).filter(
-    element => !element.isAssociation && !element.isComposition && element.name !== 'IsActiveEntity'
-  )
+const _createForeignKey = (name, el, parent, foreignKeySource) => {
+  const tk = _poorMansLookup(el, name, foreignKeySource)
+  const navigationCsn = parent.elements[foreignKeySource]
+  const foreignKeyCsn = Object.assign(Object.create(tk || el), { parent, name, foreignKeySource })
+  // annotation propagation is not possible via prototyping
+  for (const key of Object.keys(navigationCsn).filter(key => key.startsWith('@')))
+    foreignKeyCsn[key] = navigationCsn[key]
+  return foreignKeyCsn
 }
 
-const _parentKeys = csnElement => {
-  return Object.values(csnElement.parent.keys).filter(
-    element => !element.isAssociation && !element.isComposition && element.name !== 'IsActiveEntity'
-  )
+const _addToForeignKeysRec = (elements, path, parent, result) => {
+  for (const elName in elements) {
+    const el = elements[elName]
+    const foreignKeySource = path[0]
+    const newPath = [...path, elName]
+    if (el.isAssociation) {
+      const foreignKeysOftarget = _foreignKeys(el)
+      for (const fk of foreignKeysOftarget) {
+        const name = [...path, fk.name].join('_')
+        if (result.some(x => x.name === name)) return
+        const foreignKeyCsn = _createForeignKey(name, fk, parent, foreignKeySource)
+        result.push(foreignKeyCsn)
+      }
+    } else if (!el.elements) {
+      const name = newPath.join('_')
+      if (result.some(x => x.name === name)) return
+      const foreignKeyCsn = _createForeignKey(name, el, parent, foreignKeySource)
+      result.push(foreignKeyCsn)
+    } else _addToForeignKeysRec(el.elements, newPath, parent, result)
+  }
+}
+
+const _foreignKeysForTarget = (csnElement, name) => {
+  const target = csnElement._target.elements[name || csnElement.name]
+  return _foreignKeys(target)
+}
+
+const foreignKey4 = element => {
+  if (!element || !element.parent) return
+  const parentElements = element.parent.elements
+  for (const assoc of Object.keys(parentElements)
+    .map(n => parentElements[n])
+    .filter(e => e.isAssociation)) {
+    const foreignKeys = _foreignKeys(assoc)
+    if (!foreignKeys.length) continue
+    const target = foreignKeys.find(fk => fk.name === element.name)
+    if (target) {
+      return target && target.foreignKeySource
+    }
+  }
 }
 
 module.exports = {
-  foreignKeyPropagations
+  foreignKeyPropagations,
+  foreignKey4
 }

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

@@ -1,12 +1,13 @@
+const { prefixForStruct } = require('./csn')
+
 const _toRef = (alias, column) => {
   if (Array.isArray(column)) column = column.join('_')
   return { ref: alias ? [alias, column] : [column] }
 }
 
 const _adaptRefs = (onCond, path, { select, join }) => {
-  const adaptedOnCondition = onCond.map(el => {
+  const _adaptEl = el => {
     const ref = el.ref
-
     if (ref) {
       if (ref[0] === path.join('_') && ref[1]) {
         return _toRef(select, ref.slice(1))
@@ -18,12 +19,13 @@ const _adaptRefs = (onCond, path, { select, join }) => {
       }
 
       return _toRef(join, ref.slice(0))
+    } else if (el.xpr) {
+      return { xpr: el.xpr.map(_adaptEl) }
     }
 
     return el
-  })
-
-  return adaptedOnCondition
+  }
+  return onCond.map(_adaptEl)
 }
 
 const _args = (csnElement, path, aliases) => {
@@ -73,7 +75,8 @@ const _foreignToOn = (csnElement, path, { select, join }) => {
     if (on.length !== 0) {
       on.push('and')
     }
-    const ref1 = _toRef(select, key.prefix ? `${key.prefix}_${key.childElement.name}` : key.childElement.name)
+    const prefixChild = prefixForStruct(key.childElement)
+    const ref1 = _toRef(select, prefixChild + key.childElement.name)
     const structPrefix = path.length > 1 ? path.slice(0, -1) : []
     const ref2 = _toRef(join, [...structPrefix, key.parentElement.name])
     on.push(ref1, '=', ref2)

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

@@ -32,6 +32,8 @@ module.exports = {
       _reserved = _COMPILER_RESERVED[_dialect] || _DEFAULT_RESERVED
     }
 
+    if (typeof s !== 'string') throw new Error(`string expected but ${typeof s} received`)
+
     // * or already quoted?
     if (s === '*' || _isQuoted(s)) return s
 

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

@@ -1,4 +1,4 @@
-const _flattenProps = (subElement, structName, structProperties, structElement, asRef) => {
+const _flattenProps = (subElement, structName, structProperties, structElement, asRef, withKey) => {
   if (subElement.elements) {
     return _resolveStructured(
       {
@@ -6,34 +6,50 @@ const _flattenProps = (subElement, structName, structProperties, structElement,
         structProperties: structProperties.slice(1)
       },
       subElement.elements,
-      asRef
+      asRef,
+      withKey
     )
   } else if (subElement.isAssociation) {
     if (structProperties.length && subElement.is2one && !subElement.on) {
-      return asRef
-        ? [{ ref: [`${structName}_${structProperties.join('_')}`] }]
-        : [`${structName}_${structProperties.join('_')}`]
+      const flattenedName = `${structName}_${structProperties.join('_')}`
+      if (withKey) {
+        return [{ key: structElement, resolved: [flattenedName] }]
+      }
+
+      return asRef ? [{ ref: [flattenedName] }] : [flattenedName]
     }
 
     return []
   }
-  return asRef ? [{ ref: [`${structName}_${structElement}`] }] : [`${structName}_${structElement}`]
+  const flattenedName = `${structName}_${structElement}`
+  if (withKey) {
+    return [{ key: structElement, resolved: [flattenedName] }]
+  }
+
+  return asRef ? [{ ref: [flattenedName] }] : [flattenedName]
 }
 
-const _resolveStructured = ({ structName, structProperties }, subElements, asRef = true) => {
+const _resolveStructured = ({ structName, structProperties }, subElements, asRef = true, withKey = false) => {
   if (!subElements) {
     return []
   }
 
   // only add from structProperties
   if (structProperties.length) {
-    return _flattenProps(subElements[structProperties[0]], structName, structProperties, structProperties[0], asRef)
+    return _flattenProps(
+      subElements[structProperties[0]],
+      structName,
+      structProperties,
+      structProperties[0],
+      asRef,
+      withKey
+    )
   }
 
   const flattenedElements = []
   for (const structElement in subElements) {
     flattenedElements.push(
-      ..._flattenProps(subElements[structElement], structName, structProperties, structElement, asRef)
+      ..._flattenProps(subElements[structElement], structName, structProperties, structElement, asRef, withKey)
     )
   }
   return flattenedElements

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

@@ -346,7 +346,10 @@ const _newSelect = (query, transitions, service) => {
   }
   if (!newSelect.columns && targetTransition.mapping.size) newSelect.columns = _initialColumns(targetTransition)
   if (newSelect.columns) {
-    rewriteAsterisks({ SELECT: query.SELECT }, service.model, { _4db: service instanceof cds.DatabaseService })
+    rewriteAsterisks({ SELECT: query.SELECT }, service.model, {
+      _4db: service instanceof cds.DatabaseService,
+      target: targetTransition.queryTarget
+    })
     newSelect.columns = _newColumns(newSelect.columns, targetTransition, service, service.kind !== 'app-service')
   }
   if (newSelect.having) newSelect.having = _newColumns(newSelect.having, targetTransition)

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

@@ -1,6 +1,6 @@
 const { getNavigationIfStruct } = require('./structured')
 const getColumns = require('../../db/utils/columns')
-const { ensureDraftsSuffix, ensureNoDraftsSuffix } = require('./draft')
+const { ensureNoDraftsSuffix, getDraftColumnsCQNForActive } = require('./draft')
 const { getEntityNameFromCQN } = require('./entityFromCqn')
 
 const isAsteriskColumn = col => col === '*' || (col.ref && col.ref[0] === '*' && !col.expand)
@@ -14,20 +14,7 @@ const _isDuplicate = newColumn => column => {
 
 const _cqlDraftColumns = target => {
   if (target.name.endsWith('DraftAdministrativeData')) return []
-  const draftName = ensureDraftsSuffix(target.name)
-  const subSelect = SELECT.from(draftName).columns([1])
-  for (const key in target.keys) {
-    if (key !== 'IsActiveEntity') subSelect.where([{ ref: [target.name, key] }, '=', { ref: [draftName, key] }])
-  }
-  return [
-    { val: true, as: 'IsActiveEntity', cast: { type: 'cds.Boolean' } },
-    { val: false, as: 'HasActiveEntity', cast: { type: 'cds.Boolean' } },
-    {
-      xpr: ['case', 'when', 'exists', subSelect, 'then', 'true', 'else', 'false', 'end'],
-      as: 'HasDraftEntity',
-      cast: { type: 'cds.Boolean' }
-    }
-  ]
+  return getDraftColumnsCQNForActive(target)
 }
 
 const _expandColumn = (column, target, _4db) => {
@@ -135,7 +122,7 @@ const rewriteAsterisks = (query, model, options) => {
     return
   }
 
-  const target = _targetOfQueryIfNotDraft(query, model)
+  const target = options.target || _targetOfQueryIfNotDraft(query, model)
   if (!target) return
 
   // REVISIT: Also support JOINs/SETs here