@sap/cds 6.4.1 → 6.6.0

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

@@ -1,5 +1,5 @@
 const cds = require('../cds'),
-  { Object_keys, results } = cds.utils
+  { Object_keys } = cds.utils
 const LOG = cds.log('fiori|drafts')
 
 const DRAFT_ELEMENTS = new Set([
@@ -16,47 +16,255 @@ const REDUCED_DRAFT_ELEMENTS = new Set(['IsActiveEntity', 'HasDraftEntity', 'Sib
 const DRAFT_ADMIN_ELEMENTS = [
   'DraftUUID',
   'LastChangedByUser',
+  'LastChangeDateTime',
   'CreatedByUser',
+  'CreationDateTime',
   'InProcessByUser',
   'DraftIsCreatedByMe',
   'DraftIsProcessedByMe'
 ]
 
+const _inProcessByUserXpr = lockShiftedNow => ({
+  xpr: [
+    'case',
+    'when',
+    { ref: ['LastChangeDateTime'] },
+    '<',
+    { val: lockShiftedNow },
+    'then',
+    { val: '' },
+    'else',
+    { ref: ['InProcessByUser'] },
+    'end'
+  ],
+  as: 'InProcessByUser',
+  cast: { type: 'cds.String' }
+})
+
+const _lock = {
+  get shiftedNow() {
+    return new Date(Math.max(0, Date.now() - DRAFT_CANCEL_TIMEOUT_IN_MIN() * 60 * 1000)).toISOString()
+  }
+}
+
 const DRAFT_CANCEL_TIMEOUT_IN_MIN = () =>
   (cds.env.drafts?.cancellationTimeout && Number(cds.env.drafts?.cancellationTimeout)) || 15
 
+const _redirectRefToDrafts = (ref, model) => {
+  const [root, ...tail] = ref
+  const draft = model.definitions[root.id || root].drafts
+  return [root.id ? { ...root, id: draft.name } : draft.name, ...tail]
+}
+
+const _redirectRefToActives = (ref, model) => {
+  const [root, ...tail] = ref
+  const active = model.definitions[root.id || root].actives
+  return [root.id ? { ...root, id: active.name } : active.name, ...tail]
+}
+
 const h = cds.ApplicationService.prototype.handle
-cds.ApplicationService.prototype.handle = function (req) {
+/* eslint-disable complexity */
+cds.ApplicationService.prototype.handle = async function (req) {
   const handle = h.bind(this)
 
-  const _newReq = (req, query) => {
+  if (
+    !req.query ||
+    (!req.query.SELECT && !req.query.INSERT && !req.query.UPDATE && !req.query.DELETE) ||
+    req.query._draftParams
+  )
+    return handle(req)
+  const query = _cleansed(req.query, this.model)
+  _cleanseParams(req.params)
+  const draftParams = query._draftParams
+
+  const _newReq = (req, query, draftParams, event) => {
     // REVISIT: This is a bit hacky -> better way?
     query._target = undefined
+    query._draftParams = draftParams
     cds.infer(query, this.model.definitions)
-    const _req = cds.Request.for(req._)
+    const _req = cds.Request.for(req._) // REVISIT: this causes req._.data of WRITE reqs copied to READ reqs
+    if (query.SELECT) delete _req.data // which we fix here -> but this is an ugly workaround
     _req.query = query
-    _req.event = req.event
+    _req.event =
+      event ||
+      (query.SELECT && 'READ') ||
+      (query.INSERT && 'CREATE') ||
+      (query.UPDATE && 'UPDATE') ||
+      (query.DELETE && 'DELETE') ||
+      req.event
     _req.target = query._target
     _req._.params = req.params
+    _req.params = req.params
     _req._.query = query
     _req._ = req._
+    _req.data = _req.query.UPDATE?.data || _req.query.INSERT?.entries?.[0]
+
+    // Dirty hack: delegate messages to original request by binding the getter _messages to req
+    let proto = req
+    let _messagesDescr
+    while (proto && !(_messagesDescr = Object.getOwnPropertyDescriptor(proto, '_messages')))
+      proto = Object.getPrototypeOf(proto)
+    Object.defineProperty(_req, '_messages', { ..._messagesDescr, get: _messagesDescr.get.bind(req) })
+
     return _req
   }
 
-  if (!req.query || req.query._draftParams) return handle(req)
-  const query = _cleansed(req.query, this.model)
-  const draftParams = query._draftParams
-  if (req.event !== 'READ') {
-    const _req = _newReq(req, query)
+  const run = async query => {
+    const _req = _newReq(req, query, draftParams)
     return handle(_req)
   }
 
-  const read =
-    draftParams.IsActiveEntity === false && draftParams.SiblingEntity_IsActiveEntity === null
+  if (req.event === 'NEW' || req.event === 'CANCEL' || req.event === 'draftPrepare') {
+    if (draftParams.IsActiveEntity) req.reject(501)
+    req.target = req.target.drafts
+
+    if (query.INSERT?.into) {
+      if (typeof query.INSERT.into === 'string') query.INSERT.into = req.target.name
+      else if (query.INSERT.into.ref) query.INSERT.into.ref = _redirectRefToDrafts(query.INSERT.into.ref, this.model)
+    } else if (query.DELETE?.from?.ref) query.DELETE.from.ref = _redirectRefToDrafts(query.DELETE.from.ref, this.model)
+    else if (query.SELECT?.from?.ref) query.SELECT.from.ref = _redirectRefToDrafts(query.SELECT.from.ref, this.model)
+    const _req = _newReq(req, query, draftParams, req.event)
+    const result = await handle(_req)
+    return result
+  }
+
+  if (req.event === 'DELETE' && draftParams.IsActiveEntity) {
+    const draftsRef = _redirectRefToDrafts(query.DELETE.from.ref, this.model)
+    // NOTE: Check if draft is locked!
+    const draft = await run(
+      SELECT.one.from({ ref: draftsRef }).columns([
+        { ref: ['DraftAdministrativeData_DraftUUID'] },
+        {
+          ref: ['DraftAdministrativeData'],
+          expand: [_inProcessByUserXpr(_lock.shiftedNow)]
+        }
+      ])
+    )
+    const inProcessByUser = draft?.DraftAdministrativeData?.InProcessByUser
+    if (inProcessByUser && inProcessByUser !== cds.context.user.id) req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
+    const deletes = [run(DELETE.from({ ref: query.DELETE.from.ref }))]
+    if (draft)
+      deletes.push(
+        run(
+          DELETE.from(req.target.drafts).where({
+            DraftAdministrativeData_DraftUUID: draft.DraftAdministrativeData_DraftUUID
+          })
+        )
+      )
+    if (draft && req.target['@Common.DraftRoot.ActivationAction'])
+      deletes.push(
+        DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: draft.DraftAdministrativeData_DraftUUID })
+      )
+    await Promise.all(deletes)
+    return req.data
+  }
+
+  if (req.event === 'draftActivate') {
+    LOG.debug('activate draft')
+    // It would be great if we'd have a SELECT ** to deeply expand the entity (along compositions), that should
+    // be implemented in expand implementation.
+    if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== false) {
+      req.reject(400, 'Action "draftActivate" can only be called on the root draft entity')
+    }
+    const targetDraft = req.target.drafts
+    const targetWhere = query.SELECT.from.ref[0].where
+    const cols = expandStarStar(targetDraft)
+    const res = await run(
+      SELECT.one
+        .from(targetDraft)
+        .columns(cols)
+        .columns([
+          'HasActiveEntity',
+          'DraftAdministrativeData_DraftUUID',
+          { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
+        ])
+        .where(targetWhere)
+    )
+    if (!res) req.reject(404)
+    if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id)
+      req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
+    const DraftAdministrativeData_DraftUUID = res.DraftAdministrativeData_DraftUUID
+    delete res.DraftAdministrativeData_DraftUUID
+    delete res.DraftAdministrativeData
+    const HasActiveEntity = res.HasActiveEntity
+    delete res.HasActiveEntity
+    await Promise.all([
+      run(DELETE.from(targetDraft).where(targetWhere)),
+      DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: DraftAdministrativeData_DraftUUID })
+    ])
+
+    const result = await run(
+      HasActiveEntity ? UPDATE(req.target).data(res).where(targetWhere) : INSERT.into(req.target).entries(res)
+    )
+    req?._?.odataRes.setStatusCode(201)
+
+    return Object.assign(result, { IsActiveEntity: true })
+
+    // REVISIT: we need to use okra API here because it must be set in the batched request
+    // status code must be set in handler to allow overriding for FE V2
+  }
+
+  if (req.target.actions?.[req.event] && draftParams.IsActiveEntity === false) {
+    if (query.SELECT?.from?.ref) query.SELECT.from.ref = _redirectRefToDrafts(query.SELECT.from.ref, this.model)
+    const rootQuery = query.clone()
+    rootQuery.SELECT.columns = [{ ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }]
+    rootQuery.SELECT.one = true
+    const root = await run(rootQuery)
+    if (!root) req.reject(404)
+    if (root.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) req.reject(403)
+    const _req = _newReq(req, query, draftParams, req.event)
+    const result = await handle(_req)
+    return result
+  }
+
+  if (req.event === 'PATCH') {
+    if (draftParams.IsActiveEntity) req.reject(501)
+    if (req.event === 'PATCH' && !('IsActiveEntity' in draftParams)) {
+      const res = await run(
+        SELECT.one.from({ ref: req.UPDATE.entity.ref }).columns('DraftAdministrativeData_DraftUUID')
+      )
+      if (res) req.reject(403, 'DRAFT_ALREADY_EXISTS')
+      const _req = _newReq(req, query, draftParams, 'UPDATE')
+      const result = await handle(_req)
+      return result
+    }
+    if (req.event === 'PATCH' && draftParams.IsActiveEntity === false) {
+      LOG.debug('patch draft')
+      if (req.target?.name.endsWith('DraftAdministrativeData')) req.reject(405)
+      const draftsRef = _redirectRefToDrafts(query.UPDATE.entity.ref, this.model)
+      const res = await run(
+        SELECT.one.from({ ref: draftsRef }).columns('DraftAdministrativeData_DraftUUID', {
+          ref: ['DraftAdministrativeData'],
+          expand: [{ ref: ['InProcessByUser'] }]
+        })
+      )
+      if (!res) req.reject(404)
+      if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id)
+        req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
+      await UPDATE('DRAFT.DraftAdministrativeData')
+        .data({
+          InProcessByUser: req.user.id,
+          LastChangedByUser: req.user.id,
+          LastChangeDateTime: new Date()
+        })
+        .where({ DraftUUID: res.DraftAdministrativeData_DraftUUID })
+
+      const updateData = { ...req.data }
+      delete updateData.IsActiveEntity
+      await run(UPDATE({ ref: draftsRef }).data(updateData))
+      return Object.assign(req.data, { IsActiveEntity: false })
+    }
+  }
+
+  if (req.event === 'READ') {
+    const read = req.query._target.name.endsWith('.drafts')
+      ? Read.ownDrafts
+      : draftParams.IsActiveEntity === false && draftParams.SiblingEntity_IsActiveEntity === null
       ? Read.all
       : draftParams.IsActiveEntity === true &&
         draftParams.SiblingEntity_IsActiveEntity === null &&
-        draftParams.DraftAdministrativeData_InProcessByUser === 'not null'
+        (draftParams.DraftAdministrativeData_InProcessByUser === 'not null' ||
+          draftParams.DraftAdministrativeData_InProcessByUser === 'not ')
       ? Read.lockedByAnotherUser
       : draftParams.IsActiveEntity === true &&
         draftParams.SiblingEntity_IsActiveEntity === null &&
@@ -69,15 +277,18 @@ cds.ApplicationService.prototype.handle = function (req) {
       : draftParams.IsActiveEntity === false
       ? Read.ownDrafts
       : Read.onlyActives
-  const run = async query => {
-    const _req = _newReq(req, query)
-    return handle(_req)
+    const result = await read(run, query)
+    return result
   }
-  return read(run, query)
+
+  const _req = _newReq(req, query, draftParams, req.event)
+  const result = await handle(_req)
+  return result
 }
 
 const Read = {
   onlyActives: async function (run, query, { ignoreDrafts } = {}) {
+    LOG.debug('List Editing Status: Only Active')
     // DraftAdministrativeData is only accessible via drafts
     if (query._target.name.endsWith('.DraftAdministrativeData')) return run(query._drafts)
     const actives = await run(query)
@@ -105,6 +316,7 @@ const Read = {
     return actives
   },
   unchanged: async function (run, query) {
+    LOG.debug('List Editing Status: Unchanged')
     const draftsQuery = query._drafts
     const keys = Object_keys(query._target.keys).filter(k => k !== 'IsActiveEntity')
     draftsQuery.SELECT.count = undefined
@@ -119,10 +331,29 @@ const Read = {
     return res
   },
   ownDrafts: async function (run, query) {
-    if (!query._target.drafts) return run(query._drafts)
-    const drafts = await run(
-      query._drafts.where({ ref: ['DraftAdministrativeData', 'InProcessByUser'] }, '=', cds.context.user.id)
+    LOG.debug('List Editing Status: Own Draft')
+
+    // read active from draft
+    if (!query._drafts._target?.name.endsWith('.drafts')) {
+      const result = await run(query._drafts)
+
+      // active entity is draft enabled, draft columns have to be removed
+      if (query._drafts._target?.drafts) {
+        Read.merge(query._drafts._target, result, [], row => {
+          delete row.IsActiveEntity
+          delete row.HasDraftEntity
+          delete row.HasActiveEntity
+          delete row.DraftAdministrativeData_DraftUUID
+        })
+      }
+      return result
+    }
+    const draftsQuery = query._drafts.where(
+      { ref: ['DraftAdministrativeData', 'InProcessByUser'] },
+      '=',
+      cds.context.user.id
     )
+    const drafts = await run(draftsQuery)
     Read.merge(query._target, drafts, [], row =>
       Object.assign(row, {
         IsActiveEntity: false,
@@ -132,52 +363,67 @@ const Read = {
     return drafts
   },
   all: async function (run, query) {
-    query._drafts.SELECT.count = true
-    const drafts = await run(
-      query._drafts.where({ ref: ['DraftAdministrativeData', 'InProcessByUser'] }, '=', cds.context.user.id)
-    )
-
-    const skip = query.SELECT.limit?.offset?.val
-    const top = query.SELECT.limit?.rows?.val
+    LOG.debug('List Editing Status: All')
+    query._drafts.SELECT.count = false
+    query._drafts.SELECT.limit = undefined // We need all entries for the keys to properly select actives (count)
+    const isCount = query._drafts.SELECT.columns?.[0]?.func === 'count'
+    if (isCount) {
+      const keys = Object_keys(query._target.keys).filter(k => k !== 'IsActiveEntity')
+      query._drafts.SELECT.columns = keys.map(k => ({ ref: [k] }))
+    }
+    if (!query._drafts.SELECT.columns) query._drafts.SELECT.columns = ['*']
+    if (!query._drafts.SELECT.columns.some(c => c.ref?.[0] === 'HasActiveEntity'))
+      query._drafts.SELECT.columns.push({ ref: ['HasActiveEntity'] })
+
+    const isFirstPage = !query.SELECT.limit?.offset?.val
+
+    const [ownDrafts, actives] = await Promise.all([
+      isFirstPage
+        ? run(query._drafts.where({ ref: ['DraftAdministrativeData', 'InProcessByUser'] }, '=', cds.context.user.id))
+        : [], // we only show drafts on the first page
+      run(query)
+    ])
+
+    const ownNewDrafts = []
+    const ownEditDrafts = []
+    for (const draft of ownDrafts) {
+      if (draft.HasActiveEntity) ownEditDrafts.push(draft)
+      else ownNewDrafts.push(draft)
+    }
 
-    const appliedSkip = drafts.length ? skip : drafts.$count
+    const count = isFirstPage ? ownNewDrafts.length + (isCount ? actives[0]?.$count : actives.$count) : actives.$count
+    if (isCount) return { $count: count }
 
-    const topActives = top && Math.max(0, top - drafts.length)
-    let actives
-    if (topActives === 0) {
-      actives = []
-    } else {
-      const skipActives = skip && skip - appliedSkip
-      query.SELECT.count = true
-      actives = await run(query.limit(topActives, skipActives).where(Read.whereNotIn(query._target, drafts)))
-      const draftsFromActives = await Read.complementaryDrafts(run, query, actives)
-      Read.merge(query._target, actives, draftsFromActives, (row, other) => {
-        if (other) {
-          Object.assign(row, other, {
-            IsActiveEntity: true,
-            HasDraftEntity: true,
-            HasActiveEntity: false
-          })
-        } else {
-          Object.assign(row, {
-            IsActiveEntity: true,
-            HasDraftEntity: false,
-            HasActiveEntity: false,
-            DraftAdministrativeData_DraftUUID: null,
-            DraftAdministrativeData: null
-          })
-        }
-      })
-    }
-    Read.merge(query._target, drafts, [], row =>
+    Read.merge(query._target, ownDrafts, [], row =>
       Object.assign(row, {
         IsActiveEntity: false,
         HasDraftEntity: false
       })
     )
-    const totalCount = actives.$count + drafts.$count
-    const result = Object.assign([...drafts, ...actives], { $count: totalCount })
-    return result
+    Read.delete(query._target, actives, ownEditDrafts)
+    const otherEditDrafts = await Read.complementaryDrafts(run, query, actives)
+    Read.merge(query._target, actives, otherEditDrafts, (row, other) => {
+      if (other) {
+        Object.assign(row, {
+          IsActiveEntity: true,
+          HasDraftEntity: true,
+          HasActiveEntity: false,
+          DraftAdministrativeData_DraftUUID: other.DraftAdministrativeData_DraftUUID,
+          DraftAdministrativeData: other.DraftAdministrativeData
+        })
+      } else {
+        Object.assign(row, {
+          IsActiveEntity: true,
+          HasDraftEntity: false,
+          HasActiveEntity: false,
+          DraftAdministrativeData_DraftUUID: null,
+          DraftAdministrativeData: null
+        })
+      }
+    })
+    const res = isFirstPage ? [...ownNewDrafts, ...ownEditDrafts, ...actives] : actives
+    if (query.SELECT.count) res.$count = count
+    return res
   },
   activesFromDrafts: async function (run, query, { isLocked = true }) {
     const draftsQuery = query._drafts
@@ -192,7 +438,7 @@ const Read = {
       HasActiveEntity: true,
       'DraftAdministrativeData.InProcessByUser': { '!=': cds.context.user.id },
       'DraftAdministrativeData.LastChangeDateTime': {
-        [isLocked ? '>' : '<']: Read.lockshiftedNow
+        [isLocked ? '>' : '<']: _lock.shiftedNow
       }
     })
     const drafts = await run(draftsQuery)
@@ -207,14 +453,13 @@ const Read = {
     return actives
   },
   unsavedChangesByAnotherUser: async function (run, query) {
+    LOG.debug('List Editing Status: Unsaved Changes by Another User')
     return Read.activesFromDrafts(run, query, { isLocked: false })
   },
   lockedByAnotherUser: async function (run, query) {
+    LOG.debug('List Editing Status: Locked by Another User')
     return Read.activesFromDrafts(run, query, { isLocked: true })
   },
-  get lockshiftedNow() {
-    return new Date(Date.now() - DRAFT_CANCEL_TIMEOUT_IN_MIN() * 60 * 1000).toISOString()
-  },
   whereNotIn: (target, data) => Read.whereIn(target, data, true),
   whereIn: (target, data, not = false) => {
     const keys = Object_keys(target.keys).filter(k => k !== 'IsActiveEntity')
@@ -230,6 +475,12 @@ const Read = {
     if (!actives.length) return []
     const drafts = cds.ql.clone(query._drafts)
     drafts.SELECT.where = Read.whereIn(query._target, actives)
+    if (drafts.SELECT.columns?.some(c => c === '*')) {
+      drafts.SELECT.columns = drafts.SELECT.columns.filter(c => c !== '*')
+      if (!drafts.SELECT.columns.some(c => c.ref?.[0] === 'DraftAdministrativeData_DraftUUID')) {
+        drafts.SELECT.columns.push({ ref: ['DraftAdministrativeData_DraftUUID'] })
+      }
+    }
     const relevantColumns = ['DraftAdministrativeData', 'DraftAdministrativeData_DraftUUID']
     drafts.SELECT.columns = (
       drafts.SELECT.columns?.filter(c => c.ref && relevantColumns.includes(c.ref[0])) ||
@@ -240,60 +491,100 @@ const Read = {
         .map(k => ({ ref: [k] }))
     )
     drafts.SELECT.count = undefined
+    drafts.SELECT.search = undefined
     drafts.SELECT.one = undefined
     return run(drafts)
   },
+  _makeArray: data => (Array.isArray(data) ? data : data ? [data] : []),
+  _index: (target, data) => {
+    // Indexes the data for fast key access
+    const dataArray = Read._makeArray(data)
+    if (!dataArray.length) return
+    const _keys = Object_keys(target.keys).filter(k => k !== 'IsActiveEntity')
+    const hash = row => _keys.map(k => row[k]).reduce((res, curr) => res + '|$|' + curr, '')
+    const hashMap = new Map()
+    for (const row of dataArray) hashMap.set(hash(row), row)
+    return { hashMap, hash }
+  },
+  // Calls `cb` for each entry of data with a potential counterpart in otherData
   merge: (target, data, otherData, cb) => {
-    if (!data) return
-    const dataArray = Array.isArray(data) ? data : [data]
+    const dataArray = Read._makeArray(data)
     if (!dataArray.length) return
-    const otherDataArray = Array.isArray(otherData) ? otherData : otherData ? [otherData] : []
-    if (otherDataArray.length) {
-      const _keys = Object_keys(target.keys).filter(k => k !== 'IsActiveEntity')
-      const _hash = row => _keys.map(k => row[k]).reduce((res, curr) => res + '|$|' + curr, '')
-      const d2hash = new Map()
-      for (const row of otherDataArray) d2hash.set(_hash(row), row)
-      for (const row of dataArray) {
-        const other = d2hash.get(_hash(row))
-        cb(row, other)
-      }
-    } else {
-      for (const row of dataArray) {
-        cb(row, undefined)
-      }
+
+    const index = Read._index(target, otherData)
+    for (const row of dataArray) {
+      const other = index?.hashMap.get(index.hash(row))
+      cb(row, other)
+    }
+  },
+  // Deletes entries of data with a counterpart in otherData
+  delete: (target, data, otherData) => {
+    if (!Array.isArray(data) || !data.length) return
+
+    const index = Read._index(target, otherData)
+    let i = data.length
+    while (i--) {
+      if (index?.hashMap.get(index.hash(data[i]))) data.splice(i, 1)
     }
   }
 }
 
+function _cleanseParams(params) {
+  if (Array.isArray(params)) {
+    for (const param of params) _cleanseParams(param)
+    return
+  }
+  if (typeof params === 'object') {
+    for (const key in params) {
+      if (key === 'IsActiveEntity') delete params[key]
+    }
+  }
+}
+
+function _cleanseCols(columns, elements) {
+  if (typeof columns?.filter !== 'function') return columns
+  return (
+    columns &&
+    columns
+      .filter(c => !elements.has(c.ref?.[0]))
+      .map(c => {
+        if (c.expand) return { ...c, expand: _cleanseCols(c.expand, elements) }
+        return c
+      })
+  )
+}
+
 /**
  * Creates a clone of the query, cleanses and collects all draft parameters into ._draftParams.
  */
-function _cleansed(query, model, target) {
+function _cleansed(query, model) {
   const draftParams = {} //> used to collect draft filter criteria
   const q = _cleanseQuery(query, draftParams)
   if (query.SELECT) {
-    let cache
     const getDrafts = () => {
-      if (cache) return cache
       const draftsQuery = _cleanseQuery(query, {}) // could just clone `q` but the latter is ruined by database layer
+      draftsQuery._target = undefined
       const [root, ...tail] = draftsQuery.SELECT.from.ref
       const draft = model.definitions[root.id || root].drafts
       draftsQuery.SELECT.from = {
         ref: [root.id ? { ...root, id: draft.name } : draft.name, ...tail]
       }
+      cds.infer(draftsQuery, model.definitions)
+      // draftsQuery._target = draftsQuery._target?.drafts || draftsQuery._target
       if (query.SELECT.columns && query._target.drafts)
-        draftsQuery.SELECT.columns = query.SELECT.columns.filter(c => !REDUCED_DRAFT_ELEMENTS.has(c.ref?.[0]))
+        draftsQuery.SELECT.columns = _cleanseCols(query.SELECT.columns, REDUCED_DRAFT_ELEMENTS)
 
       if (draftsQuery._target.name.endsWith('.DraftAdministrativeData')) {
         draftsQuery.SELECT.columns = _tweakAdminCols(draftsQuery.SELECT.columns)
-      } else if (q._target.drafts) {
+      } else if (draftsQuery._target?.name.endsWith('.drafts')) {
         draftsQuery.SELECT.columns = _tweakAdminExpand(draftsQuery.SELECT.columns)
       }
       Object.defineProperty(draftsQuery, '_draftParams', { value: draftParams, enumerable: false })
-      cache = draftsQuery
+      Object.defineProperty(q, '_drafts', { value: draftsQuery })
       return draftsQuery
     }
     Object.defineProperty(q, '_drafts', {
+      configurable: true,
       get() {
         return getDrafts()
       }
@@ -324,7 +615,7 @@ function _cleansed(query, model, target) {
     }
 
     if (cqn.where) cqn.where = _cleanseWhere(cqn.where, draftParams)
-    if (cqn.columns) cqn.columns = q.SELECT.columns.filter(c => !DRAFT_ELEMENTS.has(c.ref?.[0]))
+    if (cqn.columns) cqn.columns = _cleanseCols(q.SELECT.columns, DRAFT_ELEMENTS)
     if (cqn.orderBy) cqn.orderBy = _cleanseWhere(cqn.orderBy, {})
 
     return q
@@ -341,7 +632,7 @@ function _cleansed(query, model, target) {
   }
 
   function _tweakAdminCols(columns) {
-    if (!columns) columns = DRAFT_ADMIN_ELEMENTS.map(k => ({ ref: [k] }))
+    if (!columns || columns.some(c => c === '*')) columns = DRAFT_ADMIN_ELEMENTS.map(k => ({ ref: [k] }))
     return columns.map(col => {
       const name = col.ref?.[0]
       if (!name) return col
@@ -366,22 +657,7 @@ function _cleansed(query, model, target) {
             cast: { type: 'cds.Boolean' }
           }
         case 'InProcessByUser':
-          return {
-            xpr: [
-              'case',
-              'when',
-              { ref: ['LastChangeDateTime'] },
-              '<',
-              { val: Read.lockshiftedNow },
-              'then',
-              { val: '' },
-              'else',
-              { ref: ['InProcessByUser'] },
-              'end'
-            ],
-            as: 'InProcessByUser',
-            cast: { type: 'cds.String' }
-          }
+          return _inProcessByUserXpr(_lock.shiftedNow)
         case 'DraftIsProcessedByMe':
           return {
             xpr: [
@@ -390,6 +666,10 @@ function _cleansed(query, model, target) {
               { ref: ['InProcessByUser'] },
               '=',
               { val: cds.context.user.id },
+              'and',
+              { ref: ['LastChangeDateTime'] },
+              '>',
+              { val: _lock.shiftedNow },
               'then',
               { val: true },
               'else',
@@ -410,9 +690,12 @@ function _cleansed(query, model, target) {
     for (let i = 0; i < xpr.length; ++i) {
       let x = xpr[i],
         e = x.ref?.[0]
-      if (DRAFT_ELEMENTS.has(e)) {
+      if (DRAFT_ELEMENTS.has(e) && !xpr[i + 2]) {
+        continue
+      }
+      if (DRAFT_ELEMENTS.has(e) && xpr[i + 2]) {
         let { val } = xpr[i + 2]
-        draftParams[x.ref.join('_')] = xpr[i + 1] === '!=' ? 'not ' + val : val
+        draftParams[x.ref.join('_')] = xpr[i + 1] === '!=' ? (typeof val === 'boolean' ? !val : 'not ' + val) : val
         i += 3
         continue
       }
@@ -431,27 +714,46 @@ function _cleansed(query, model, target) {
   }
 }
 
-function _draftIsLocked(LastChangeDateTime) {
-  return DRAFT_CANCEL_TIMEOUT_IN_MIN() * 60 * 1000 > Date.now() - Date.parse(LastChangeDateTime)
+// This function is better defined on DB layer
+function expandStarStar(target, recursion = new Map()) {
+  const MAX_RECURSION_DEPTH = (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 4
+  const columns = []
+  for (const el in target.elements) {
+    const element = target.elements[el]
+    if (!element.isAssociation && !DRAFT_ELEMENTS.has(el)) columns.push({ ref: [el] })
+    if (!element.isComposition || element._target['@odata.draft.enabled'] === false) continue // happens for texts if not @fiori.draft.enabled
+    const _key = target.name + ':' + el
+    let cache = recursion.get(_key)
+    if (!cache) {
+      cache = 1
+      recursion.set(_key, cache)
+    } else {
+      cache++
+      recursion.set(_key, cache)
+    }
+    if (cache >= MAX_RECURSION_DEPTH) return
+    const expand = expandStarStar(element._target, recursion)
+    if (expand) columns.push({ ref: [el], expand })
+  }
+  return columns
 }
 
-async function onNewDraft(req) {
+async function onNew(req) {
   LOG.debug('new draft')
   const isRoot = typeof req.query.INSERT.into === 'string'
   let DraftUUID
   if (isRoot) DraftUUID = cds.utils.uuid()
   else {
-    const rootData = await SELECT.one(req.query.INSERT.into.ref[0].id + '.drafts', d => {
-      d.DraftAdministrativeData_DraftUUID,
-        d.DraftAdministrativeData(a => {
-          a.LastChangeDateTime, a.InProcessByUser
-        })
-    }).where(req.query.INSERT.into.ref[0].where)
-    if (!rootData) req.reject(404)
-    if (
-      !rootData.DraftAdministrativeData.InProcessByUser === req.user.id &&
-      _draftIsLocked(rootData.DraftAdministrativeData.LastChangeDateTime)
+    const rootData = await this.run(
+      SELECT.one(req.query.INSERT.into.ref[0].id)
+        .columns([
+          { ref: ['DraftAdministrativeData_DraftUUID'] },
+          { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
+        ])
+        .where(req.query.INSERT.into.ref[0].where)
     )
+    if (!rootData) req.reject(404)
+    if (rootData.DraftAdministrativeData?.InProcessByUser !== req.user.id)
       req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
     DraftUUID = rootData.DraftAdministrativeData_DraftUUID
   }
@@ -479,60 +781,21 @@ async function onNewDraft(req) {
     { DraftAdministrativeData_DraftUUID: DraftUUID, HasActiveEntity: false },
     req.query.INSERT.entries[0]
   )
+
   delete draftData.IsActiveEntity
-  const draftCQN = INSERT.into(req.target.drafts).entries(draftData)
+  const draftCQN = INSERT.into(req.target).entries(draftData)
 
-  // TODO: do this? req.query._draftParams.IsActiveEntity = false
-  await Promise.all([adminDataCQN, draftCQN].map(cqn => cds.run(cqn)))
+  await Promise.all([cds.run(adminDataCQN), this.run(draftCQN)])
   req._.readAfterWrite = true
   return { ...draftData, IsActiveEntity: false }
 }
-exports.onNewDraft = onNewDraft
-
-async function onDraftPrepare(req) {
-  LOG.debug('prepare draft')
-
-  const draftParams = req.query._draftParams
-  const where = req.query.SELECT.from.ref[0].where
-  if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== false) {
-    req.reject(400, 'Action "draftPrepare" can only be called on the root draft entity')
-  }
-
-  const keys = Object_keys(req.target.keys).filter(k => k !== 'IsActiveEntity')
-  const data = await SELECT.one
-    .from(req.target.drafts, d => {
-      d.DraftAdministrativeData(a => a.InProcessByUser)
-    })
-    .columns(keys)
-    .where(where)
-  if (!data) req.reject(404)
-  if (data.DraftAdministrativeData.InProcessByUser !== req.user.id) req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
-  delete data.DraftAdministrativeData
-  return { ...data, IsActiveEntity: false }
-}
-exports.onDraftPrepare = onDraftPrepare
-
-// This function is better defined on DB layer
-function expandStarStar(target, recursion = new Map()) {
-  const MAX_RECURSION_DEPTH = (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 4
-  // TODO: Remove draftcolumns from payload
-  const columns = []
-  for (const el in target.elements) {
-    const element = target.elements[el]
-    if (!element.isAssociation && !DRAFT_ELEMENTS.has(el)) columns.push({ ref: [el] })
-    if (!element.isComposition) continue
-    const _key = target.name + ':' + el
-    let cache = recursion.get(_key)
-    if (!cache) cache = 1 && recursion.set(_key, cache)
-    if (cache >= MAX_RECURSION_DEPTH) return
-    columns.push({ ref: [el], expand: expandStarStar(element._target, recursion) })
-  }
-  return columns
-}
 
-async function onDraftEdit(req) {
+async function onEdit(req) {
   LOG.debug('edit active')
   const draftParams = req.query._draftParams
+  if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== true) {
+    req.reject(400, 'Action "draftEdit" can only be called on the root entity')
+  }
   const targetWhere = req.query.SELECT.from.ref[0].where
 
   if (draftParams.IsActiveEntity !== true) req.reject(400)
@@ -553,13 +816,30 @@ async function onDraftEdit(req) {
     }
   }
   _addDraftColumns(req.target, cols)
-
-  const [res, draftExists] = await Promise.all([
-    SELECT.one.from(req.target).columns(cols).where(targetWhere),
-    SELECT.one(req.target.drafts).columns('1 as _exists').where(targetWhere)
+  const draftsCheck = SELECT.one(req.target.drafts)
+    .columns({ ref: ['DraftAdministrativeData'], expand: [_inProcessByUserXpr(_lock.shiftedNow)] })
+    .where(targetWhere)
+    .forUpdate({ wait: 0 })
+  // prevent service to check for own user
+  Object.defineProperty(draftsCheck, '_draftParams', { value: draftParams, enumerable: false })
+
+  const [res, draft] = await Promise.all([
+    this.run(SELECT.one.from(req.target).columns(cols).where(targetWhere).forUpdate({ wait: 0 })),
+    // no user check must be done here...
+    this.run(draftsCheck)
   ])
   if (!res) req.reject(404)
-  if (draftExists) req.reject(409, 'DRAFT_ALREADY_EXISTS')
+  const preserveChanges = req.context?.data?.PreserveChanges
+  const inProcessByUser = draft?.DraftAdministrativeData?.InProcessByUser
+  if (draft) {
+    if (inProcessByUser || preserveChanges) req.reject(409, 'DRAFT_ALREADY_EXISTS')
+    const keys = {}
+    for (const key in req.target.drafts.keys) keys[key] = res[key]
+    await Promise.all([
+      DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID }),
+      this.run(DELETE.from(req.target.drafts).where(keys))
+    ])
+  }
 
   const timestamp = cds.context.timestamp.toISOString() // REVISIT: toISOString should be done on db layer
   await INSERT.into('DRAFT.DraftAdministrativeData').entries({
@@ -574,84 +854,68 @@ async function onDraftEdit(req) {
   })
 
   const targetDraft = req.target.drafts
-  await INSERT.into(targetDraft).entries(res)
-  return { ...res, IsActiveEntity: false } // REVISIT: Flatten?
-}
-exports.onDraftEdit = onDraftEdit
+  // is set to `null` on srv layer
+  res.DraftAdministrativeData_DraftUUID = DraftUUID
+  res.HasActiveEntity = true
+  delete res.DraftAdministrativeData
+  await this.run(INSERT.into(targetDraft).entries(res))
 
-async function onDraftActivate(req) {
-  LOG.debug('activate draft')
-  // TODO: Read all drafts, send deep update/insert (based on HasActiveEntity, which should be fille with new!)
-  // It would be great if we'd have a SELECT ** to deeply expand the entity (along compositions), that should
-  // be implemented in expand implementation.
-  const targetDraft = req.target.drafts
-  const targetWhere = req.query.SELECT.from.ref[0].where
-  const res = await SELECT.one
-    .from(targetDraft)
-    .columns(expandStarStar(targetDraft))
-    .columns(['HasActiveEntity', 'DraftAdministrativeData_DraftUUID'])
-    .where(targetWhere)
-  const DraftAdministrativeData_DraftUUID = res.DraftAdministrativeData_DraftUUID
-  delete res.DraftAdministrativeData_DraftUUID
-  const HasActiveEntity = res.HasActiveEntity
-  delete res.HasActiveEntity
-  // TODO: Deep delete!
-  await Promise.all([
-    DELETE.from(targetDraft).where(targetWhere),
-    DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: DraftAdministrativeData_DraftUUID })
-  ])
-  // TODO: Check for InProcessByUser
-
-  let event, query
-  if (HasActiveEntity) {
-    query = UPDATE(req.target).data(res).where(targetWhere)
-    event = 'UPDATE'
-  } else {
-    query = INSERT.into(req.target).entries(res)
-    event = 'CREATE'
-  }
-  const r = new cds.Request({ event, query, data: res })
-  const result = await this.dispatch(r)
-  return Object.assign(result, { IsActiveEntity: true })
+  // REVISIT: we need to use okra API here because it must be set in the batched request
+  // status code must be set in handler to allow overriding for FE V2
+  req?._?.odataRes.setStatusCode(201)
+
+  return { ...res, IsActiveEntity: false } // REVISIT: Flatten?
 }
-exports.onDraftActivate = onDraftActivate
 
-async function onPatch(req) {
-  LOG.debug('patch draft')
-  const targetDraft = req.target.drafts
-  const targetWhere = req.query.UPDATE.entity.ref[0].where
-  const res = await SELECT.one.from(targetDraft).columns('DraftAdministrativeData_DraftUUID').where(targetWhere)
-  if (!res) req.reject(404)
-  await UPDATE('DRAFT.DraftAdministrativeData')
-    .data({
-      InProcessByUser: req.user.id,
-      LastChangedByUser: req.user.id,
-      LastChangeDateTime: new Date()
-    })
-    .where({ DraftUUID: res.DraftAdministrativeData_DraftUUID })
+async function onCancel(req) {
+  LOG.debug('delete draft')
+  const activeRef = _redirectRefToActives(req.query.DELETE.from.ref, this.model)
+  const draftParams = req.query._draftParams
 
-  const updateData = { ...req.data }
-  delete updateData.IsActiveEntity
-  await UPDATE(targetDraft).data(updateData).where(targetWhere)
+  const draftDelete = SELECT.one
+    .from({ ref: req.query.DELETE.from.ref })
+    .columns([
+      'DraftAdministrativeData_DraftUUID',
+      { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
+    ])
+  // do not add InProcessByUser restriction
+  Object.defineProperty(draftDelete, '_draftParams', { value: draftParams, enumerable: false })
+  const draft = await this.run(draftDelete)
+  if (draftParams.IsActiveEntity === false && !draft) req.reject(404)
+  if (draft && draft.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id)
+    req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
+  const deletes = !draft ? [] : [this.run(DELETE.from({ ref: req.query.DELETE.from.ref }))]
+  if (draft && req.target['@Common.DraftRoot.ActivationAction'])
+    // only for draft root
+    deletes.push(
+      DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: draft.DraftAdministrativeData_DraftUUID })
+    )
+  if (draftParams.IsActiveEntity) deletes.push(this.run(DELETE.from({ ref: activeRef })))
+  await Promise.all(deletes)
   return req.data
 }
-exports.onPatch = onPatch
 
-async function onDelete(req) {
-  LOG.debug('delete')
-  const targetDraft = req.target.drafts
+async function onPrepare(req) {
+  LOG.debug('prepare draft')
   const draftParams = req.query._draftParams
-  const targetWhere = req.query.DELETE.from.ref[0].where
-  const res = await SELECT.one.from(targetDraft).columns('DraftAdministrativeData_DraftUUID').where(targetWhere)
-  if (!res && draftParams.IsActiveEntity === false) req.reject(404)
-  const deletes = !res
-    ? []
-    : [
-        DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: res.DraftAdministrativeData_DraftUUID }),
-        DELETE.from(targetDraft).where(targetWhere)
-      ]
-  if (draftParams.IsActiveEntity) deletes.push(DELETE.from(req.target).where(targetWhere))
-  await Promise.all(deletes)
-  return req.data
+  if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== false) {
+    req.reject(400, 'Action "draftPrepare" can only be called on the root draft entity')
+  }
+  const where = req.query.SELECT.from.ref[0].where
+
+  const keys = Object_keys(req.target.keys).filter(k => k !== 'IsActiveEntity')
+  const draftQuery = SELECT.one
+    .from(req.target, d => {
+      d.DraftAdministrativeData(a => a.InProcessByUser)
+    })
+    .columns(keys)
+    .where(where)
+  Object.defineProperty(draftQuery, '_draftParams', { value: draftParams, enumerable: false })
+  const data = await this.run(draftQuery)
+  if (!data) req.reject(404)
+  if (data.DraftAdministrativeData?.InProcessByUser !== req.user.id) req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
+  delete data.DraftAdministrativeData
+  return { ...data, IsActiveEntity: false }
 }
-exports.onDelete = onDelete
+
+module.exports = { onNew, onEdit, onCancel, onPrepare }