@sap/cds 6.8.4 → 7.0.0

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

@@ -2,6 +2,7 @@ const cds = require('../cds'),
   { Object_keys } = cds.utils
 const LOG = cds.log('fiori|drafts')
 const original = Symbol('original')
+const DRAFT_PARAMS = Symbol('draftParams')
 
 const DRAFT_ELEMENTS = new Set([
   'IsActiveEntity',
@@ -32,23 +33,11 @@ const _fillIsActiveEntity = (row, IsActiveEntity, target) => {
     if (!prop) continue
     const el = target.elements[key]
     const childIsActiveEntity = el._target.isDraft ? IsActiveEntity : true
-    if (Array.isArray(prop)) prop.map(r => _fillIsActiveEntity(r, childIsActiveEntity, el._target))
-    else if (typeof prop === 'object') _fillIsActiveEntity(prop, childIsActiveEntity, el._target)
+    const propArray = Array.isArray(prop) ? prop : [prop]
+    propArray.forEach(r => _fillIsActiveEntity(r, childIsActiveEntity, el._target))
   }
 }
 
-// REVISIT: should not be necessary
-const _runWithContext = (srv, req, obj) => {
-  const r = new cds.Request(obj)
-  r.event // invoke getter
-  r._ = Object.assign(r._, req._)
-  if (req.getUriInfo) r.getUriInfo = () => req.getUriInfo()
-  if (req.getUrlObject) r.getUrlObject = () => req.getUrlObject()
-  r._.params = req.params
-  r._.query = req.query
-  return srv.dispatch(r)
-}
-
 /// It's important to wait for the completion of all promises, otherwise a rollback might happen too soon
 const _promiseAll = async array => {
   const results = await Promise.allSettled(array)
@@ -105,25 +94,40 @@ cds.ApplicationService.prototype.handle = async function (req) {
   if (
     !req.query ||
     req.query.UPSERT || // skip UPSERTs (might have an additional INSERT)
-    (!req.query.SELECT && !req.query.INSERT && !req.query.UPDATE && !req.query.DELETE) ||
-    req.query._draftParams
-  )
+    (!req.query.SELECT && !req.query.INSERT && !req.query.UPDATE && !req.query.DELETE && !req.query.STREAM) ||
+    req.query[DRAFT_PARAMS]
+  ) {
     return handle(req)
+  }
+
+  const _etagValidationType = req.headers['if-match']
+    ? 'if-match'
+    : req.headers['if-none-match']
+    ? 'if-none-match'
+    : undefined
+
   const query = _cleansed(req.query, this.model)
   _cleanseParams(req.params, req.target)
   if (req.data) _cleanseParams(req.data, req.target)
-  const draftParams = query._draftParams
+  const draftParams = query[DRAFT_PARAMS]
 
-  const _newReq = (req, query, draftParams, event) => {
+  const _newReq = (req, query, draftParams, { event, headers }) => {
     // REVISIT: This is a bit hacky -> better way?
     query._target = undefined
-    query._draftParams = draftParams
+    query[DRAFT_PARAMS] = draftParams
     cds.infer(query, this.model.definitions)
 
     // REVISIT: This is extremely bad. We should be able to just create a copy without such hacks.
     const _req = cds.Request.for(req._) // REVISIT: this causes req._.data of WRITE reqs copied to READ reqs
+
+    if (headers) {
+      _req.headers = Object.create(req.headers)
+      Object.assign(_req.headers, headers)
+    }
+
     // If we create a `READ` event based on a modifying request, we delete data
     if (event === 'READ' && req.event !== 'READ') delete _req.data // which we fix here -> but this is an ugly workaround
+
     _req.query = query
     _req.event =
       event ||
@@ -137,10 +141,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
     _req._ = Object.assign({}, req._ || {})
     _req._.params = req.params
     _req._.query = query
-    const props = ['_isRest', '_isOData', 'isConcurrentResource', 'isConditional', 'validateEtag']
-    props.forEach(p => {
-      if (req[p]) _req.p = req[p]
-    })
+    if (req.protocol) _req.protocol = req.protocol
     _req._ = req._
     const cqnData = _req.query.UPDATE?.data || _req.query.INSERT?.entries?.[0]
     if (cqnData) _req.data = cqnData // must point to the same object
@@ -150,14 +151,48 @@ cds.ApplicationService.prototype.handle = async function (req) {
       }
     })
     if (req.tx) _req.tx = req.tx
+
     return _req
   }
 
-  const run = async query => {
-    const _req = _newReq(req, query, draftParams)
+  const run = (query, options = {}) => {
+    const _req = _newReq(req, query, draftParams, options)
     return handle(_req)
   }
 
+  if (req.event === 'READ') {
+    if (
+      !Object.keys(draftParams).length &&
+      !req.query._target.name?.endsWith('DraftAdministrativeData') &&
+      !req.query._target.drafts
+    ) {
+      req.query = query
+      return handle(req)
+    }
+    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 ')
+      ? Read.lockedByAnotherUser
+      : draftParams.IsActiveEntity === true &&
+        draftParams.SiblingEntity_IsActiveEntity === null &&
+        draftParams.DraftAdministrativeData_InProcessByUser === ''
+      ? Read.unsavedChangesByAnotherUser
+      : draftParams.IsActiveEntity === true && draftParams.HasDraftEntity === false
+      ? Read.unchanged
+      : draftParams.IsActiveEntity === true
+      ? Read.onlyActives
+      : draftParams.IsActiveEntity === false
+      ? Read.ownDrafts
+      : Read.onlyActives
+    const result = await read(run, query)
+    return result
+  }
+
   if (req.event === 'NEW' || req.event === 'CANCEL' || req.event === 'draftPrepare') {
     if (draftParams.IsActiveEntity) req.reject(501)
     req.target = req.target.drafts
@@ -167,34 +202,29 @@ cds.ApplicationService.prototype.handle = async function (req) {
       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 _req = _newReq(req, query, draftParams, { event: 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 draft = await 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', [inProcessByUser])
     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
-          })
-        )
+        DELETE.from(req.target.drafts).where({
+          DraftAdministrativeData_DraftUUID: draft.DraftAdministrativeData_DraftUUID
+        })
       )
     if (draft && req.target['@Common.DraftRoot.ActivationAction'])
       deletes.push(
@@ -214,18 +244,19 @@ cds.ApplicationService.prototype.handle = async function (req) {
     const targetDraft = req.target.drafts
     const targetWhere = query.SELECT.from.ref[0].where
     const cols = expandStarStar(targetDraft)
+    // Use `run` (since also etags might need to be checked)
+    // REVISIT: Find a better approach (`etag` as part of CQN?)
     const res = await run(
       SELECT.one
-        .from(targetDraft)
+        .from({ ref: _redirectRefToDrafts(query.SELECT.from.ref, this.model) })
         .columns(cols)
         .columns([
           'HasActiveEntity',
           'DraftAdministrativeData_DraftUUID',
           { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
         ])
-        .where(targetWhere)
     )
-    if (!res) req.reject(404)
+    if (!res) req.reject(_etagValidationType ? 412 : 404)
     if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id)
       req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [res.DraftAdministrativeData?.InProcessByUser])
     const DraftAdministrativeData_DraftUUID = res.DraftAdministrativeData_DraftUUID
@@ -236,14 +267,15 @@ cds.ApplicationService.prototype.handle = async function (req) {
     delete res.IsActiveEntity
     // First run the handlers as they might need access to DraftAdministrativeData or the draft entities
     const result = await run(
-      HasActiveEntity ? UPDATE(req.target).data(res).where(targetWhere) : INSERT.into(req.target).entries(res)
+      HasActiveEntity ? UPDATE(req.target).data(res).where(targetWhere) : INSERT.into(req.target).entries(res),
+      { headers: { 'if-match': '*' } }
     )
     await _promiseAll([
-      run(DELETE.from(targetDraft).where(targetWhere)),
+      DELETE.from(targetDraft).where(targetWhere),
       DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: DraftAdministrativeData_DraftUUID })
     ])
 
-    req?._?.odataRes?.setStatusCode(201)
+    if (!HasActiveEntity) req?._?.odataRes?.setStatusCode(201, { overwrite: true })
 
     return Object.assign(result, { IsActiveEntity: true })
 
@@ -256,35 +288,24 @@ cds.ApplicationService.prototype.handle = async function (req) {
     const rootQuery = query.clone()
     rootQuery.SELECT.columns = [{ ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }]
     rootQuery.SELECT.one = true
-    const root = await run(rootQuery)
+    const root = await 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 _req = _newReq(req, query, draftParams, { event: req.event })
     const result = await handle(_req)
     return result
   }
 
   if (req.event === 'PATCH') {
-    if (draftParams.IsActiveEntity) req.reject(501)
-    if (!('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 (draftParams.IsActiveEntity || !('IsActiveEntity' in draftParams)) req.reject(501)
     if (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'] }]
-        })
-      )
+      const res = await 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', [res.DraftAdministrativeData?.InProcessByUser])
@@ -304,36 +325,11 @@ cds.ApplicationService.prototype.handle = async function (req) {
     }
   }
 
-  if (req.event === 'READ') {
-    if (
-      !Object.keys(draftParams).length &&
-      !req.query._target.name?.endsWith('DraftAdministrativeData') &&
-      !req.query._target.drafts
-    ) {
-      req.query = query
-      return handle(req)
-    }
-    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 ')
-      ? Read.lockedByAnotherUser
-      : draftParams.IsActiveEntity === true &&
-        draftParams.SiblingEntity_IsActiveEntity === null &&
-        draftParams.DraftAdministrativeData_InProcessByUser === ''
-      ? Read.unsavedChangesByAnotherUser
-      : draftParams.IsActiveEntity === true && draftParams.HasDraftEntity === false
-      ? Read.unchanged
-      : draftParams.IsActiveEntity === true
-      ? Read.onlyActives
-      : draftParams.IsActiveEntity === false
-      ? Read.ownDrafts
-      : Read.onlyActives
-    const result = await read(run, query)
+  if (req.event === 'STREAM' && draftParams.IsActiveEntity === false) {
+    if (query.STREAM.into?.ref) query.STREAM.into.ref = _redirectRefToDrafts(query.STREAM.into.ref, this.model)
+    else if (query.STREAM.from?.ref) query.STREAM.from.ref = _redirectRefToDrafts(query.STREAM.from.ref, this.model)
+    const _req = _newReq(req, query, draftParams, { event: req.event })
+    const result = await handle(_req)
     return result
   }
 
@@ -387,7 +383,7 @@ const Read = {
     if (ignoreDrafts) drafts = []
     else {
       try {
-        drafts = await Read.complementaryDrafts(run, query, actives)
+        drafts = await Read.complementaryDrafts(query, actives)
       } catch (e) {
         drafts = []
       }
@@ -414,7 +410,7 @@ const Read = {
     draftsQuery.SELECT.orderBy = undefined
     draftsQuery.SELECT.columns = keys.map(k => ({ ref: [k] }))
 
-    const drafts = await run(draftsQuery)
+    const drafts = await draftsQuery
     const res = await Read.onlyActives(run, query.where(Read.whereNotIn(query._target, drafts)), {
       ignoreDrafts: true
     })
@@ -498,7 +494,7 @@ const Read = {
       _fillIsActiveEntity(row, false, query._drafts._target)
     })
     Read.delete(query._target, actives, ownEditDrafts)
-    const otherEditDrafts = await Read.complementaryDrafts(run, query, actives)
+    const otherEditDrafts = await Read.complementaryDrafts(query, actives)
     Read.merge(query._target, actives, otherEditDrafts, (row, other) => {
       if (other) {
         Object.assign(row, {
@@ -537,7 +533,7 @@ const Read = {
         [isLocked ? '>' : '<']: _lock.shiftedNow
       }
     })
-    const drafts = await run(draftsQuery)
+    const drafts = await draftsQuery
     const actives = drafts.length
       ? await run(query.where(Read.whereIn(query._target, drafts)))
       : Object.assign([], { $count: 0 })
@@ -561,13 +557,12 @@ const Read = {
     const keys = Object_keys(target.keys).filter(k => k !== 'IsActiveEntity')
     const dataArray = data ? (Array.isArray(data) ? data : [data]) : []
     if (not && !dataArray.length) return []
-    return [
-      { list: keys.map(k => ({ ref: [k] })) },
-      not ? 'not in' : 'in',
-      { list: dataArray.map(r => ({ list: keys.map(k => ({ val: r[k] })) })) }
-    ]
+    const left = { list: keys.map(k => ({ ref: [k] })) }
+    const op = not ? ['not', 'in'] : ['in']
+    const right = { list: dataArray.map(r => ({ list: keys.map(k => ({ val: r[k] })) })) }
+    return [left, ...op, right]
   },
-  complementaryDrafts: (run, query, _actives) => {
+  complementaryDrafts: (query, _actives) => {
     const actives = Array.isArray(_actives) ? _actives : [_actives]
     if (!actives.length) return []
     const drafts = cds.ql.clone(query._drafts)
@@ -590,7 +585,7 @@ const Read = {
     drafts.SELECT.count = undefined
     drafts.SELECT.search = undefined
     drafts.SELECT.one = undefined
-    return run(drafts)
+    return drafts
   },
   _makeArray: data => (Array.isArray(data) ? data : data ? [data] : []),
   _index: (target, data) => {
@@ -656,7 +651,7 @@ function _cleanseCols(columns, elements, target) {
 }
 
 /**
- * Creates a clone of the query, cleanses and collects all draft parameters into ._draftParams.
+ * Creates a clone of the query, cleanses and collects all draft parameters into DRAFT_PARAMS.
  */
 function _cleansed(query, model) {
   const draftParams = {} //> used to collect draft filter criteria
@@ -680,7 +675,7 @@ function _cleansed(query, model) {
       } else if (draftsQuery._target?.name.endsWith('.drafts')) {
         draftsQuery.SELECT.columns = _tweakAdminExpand(draftsQuery.SELECT.columns)
       }
-      Object.defineProperty(draftsQuery, '_draftParams', { value: draftParams, enumerable: false })
+      draftsQuery[DRAFT_PARAMS] = draftParams
       Object.defineProperty(q, '_drafts', { value: draftsQuery })
       return draftsQuery
     }
@@ -692,7 +687,7 @@ function _cleansed(query, model) {
     })
   }
 
-  Object.defineProperty(q, '_draftParams', { value: draftParams, enumerable: false })
+  q[DRAFT_PARAMS] = draftParams
   q[original] = query
   return q
 
@@ -700,8 +695,14 @@ function _cleansed(query, model) {
     const target = query._target
     const q = cds.ql.clone(query)
 
-    const ref = q.SELECT?.from.ref || q.UPDATE?.entity.ref || q.INSERT?.into.ref || q.DELETE?.from.ref
-    const cqn = q.SELECT || q.UPDATE || q.INSERT || q.DELETE
+    const ref =
+      q.SELECT?.from.ref ||
+      q.UPDATE?.entity.ref ||
+      q.INSERT?.into.ref ||
+      q.DELETE?.from.ref ||
+      q.STREAM?.into?.ref ||
+      q.STREAM?.from?.ref
+    const cqn = q.SELECT || q.UPDATE || q.INSERT || q.DELETE || q.STREAM
 
     if (ref) {
       let entity
@@ -714,6 +715,8 @@ function _cleansed(query, model) {
       else if (q.DELETE) q.DELETE.from = { ...q.DELETE.from, ref: cleansedRef }
       else if (q.UPDATE) q.UPDATE.entity = { ...q.UPDATE.entity, ref: cleansedRef }
       else if (q.INSERT) q.INSERT.into = { ...q.INSERT.into, ref: cleansedRef }
+      else if (q.STREAM?.from) q.STREAM.from = { ...q.STREAM.from, ref: cleansedRef }
+      else if (q.STREAM?.into) q.STREAM.into = { ...q.STREAM.into, ref: cleansedRef }
 
       // This only works for simple cases of `SiblingEntity`, e.g. `root(ID=1,IsActiveEntity=false)/SiblingEntity`
       // , check if there are more complicated use cases
@@ -797,15 +800,17 @@ function _cleansed(query, model) {
   function _cleanseWhere(xpr, draftParams) {
     const cleansed = []
     for (let i = 0; i < xpr.length; ++i) {
-      let x = xpr[i],
-        e = x.ref?.[0]
+      let x = xpr[i]
+      const e = x.ref?.[0]
       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] === '!=' ? (typeof val === 'boolean' ? !val : 'not ' + val) : val
-        i += 3
+        i += 2
+        const last = cleansed[cleansed.length - 1]
+        if (last === 'and' || last === 'or') cleansed.pop()
         continue
       }
       if (x.xpr) {
@@ -817,6 +822,8 @@ function _cleansed(query, model) {
       }
       cleansed.push(x)
     }
+    const first = cleansed[0]
+    if (first === 'and' || first === 'or') cleansed.shift()
     const last = cleansed[cleansed.length - 1]
     if (last === 'and' || last === 'or') cleansed.pop()
     if (cleansed.length) return cleansed
@@ -849,28 +856,26 @@ function expandStarStar(target, recursion = new Map()) {
 
 async function onNew(req) {
   LOG.debug('new draft')
-  const isRoot = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
+  const isDirectAccess = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
   // Only allowed for pseudo draft roots (entities with this action)
-  if (isRoot && !req.target.actives['@Common.DraftRoot.ActivationAction'])
+  if (isDirectAccess && !req.target.actives['@Common.DraftRoot.ActivationAction'])
     req.reject(403, 'DRAFT_MODIFICATION_ONLY_VIA_ROOT')
   let DraftUUID
-  if (isRoot) DraftUUID = cds.utils.uuid()
+  if (isDirectAccess) DraftUUID = cds.utils.uuid()
   else {
-    const rootData = await _runWithContext(this, req, {
-      query: 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)
-    })
+    const rootData = await 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', [rootData.DraftAdministrativeData.InProcessByUser])
     DraftUUID = rootData.DraftAdministrativeData_DraftUUID
   }
   const timestamp = cds.context.timestamp.toISOString() // REVISIT: toISOString should be done on db layer
-  const adminDataCQN = isRoot
+  const adminDataCQN = isDirectAccess
     ? INSERT.into('DRAFT.DraftAdministrativeData').entries({
         DraftUUID,
         CreationDateTime: timestamp,
@@ -889,36 +894,38 @@ async function onNew(req) {
         })
         .where({ DraftUUID })
 
-  const _assignDraftData = (obj, target) => {
+  const _setDraftUUIDandHasActiveEntity = (obj, target) => {
     const newObj = Object.assign({}, obj, { DraftAdministrativeData_DraftUUID: DraftUUID, HasActiveEntity: false })
     if (!target) return newObj
 
     // Also support deep insertions
     for (const key in newObj) {
       if (!target.elements[key]?.isComposition) continue
+      // do array trick
       if (Array.isArray(newObj[key]))
-        newObj[key] = newObj[key].map(v => _assignDraftData(v, target.elements[key]._target))
+        newObj[key] = newObj[key].map(v => _setDraftUUIDandHasActiveEntity(v, target.elements[key]._target))
       else if (typeof newObj[key] === 'object') {
-        newObj[key] = _assignDraftData(newObj[key], target.elements[key]._target)
+        newObj[key] = _setDraftUUIDandHasActiveEntity(newObj[key], target.elements[key]._target)
       }
     }
 
     return newObj
   }
 
-  const draftData = _assignDraftData(req.query.INSERT.entries[0], req.target)
+  const draftData = _setDraftUUIDandHasActiveEntity(req.query.INSERT.entries[0], req.target)
 
   delete draftData.IsActiveEntity
   const draftCQN = INSERT.into(req.target).entries(draftData)
 
-  await _promiseAll([cds.run(adminDataCQN), _runWithContext(this, req, { query: draftCQN })])
+  await _promiseAll([adminDataCQN, this.run(draftCQN)])
   req._.readAfterWrite = true
   return { ...draftData, IsActiveEntity: false }
 }
 
 async function onEdit(req) {
   LOG.debug('edit active')
-  const draftParams = req.query._draftParams
+  // use symbol for _draftParams
+  const draftParams = req.query[DRAFT_PARAMS]
   if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== true) {
     req.reject(400, 'Action "draftEdit" can only be called on the root active entity')
   }
@@ -928,6 +935,7 @@ async function onEdit(req) {
 
   const DraftUUID = cds.utils.uuid()
 
+  // REVISIT: Later optimization if datasource === db: INSERT FROM SELECT
   const cols = expandStarStar(req.target)
   const _addDraftColumns = (target, columns) => {
     if (target.drafts) {
@@ -947,22 +955,24 @@ async function onEdit(req) {
     .columns({ ref: ['DraftAdministrativeData'], expand: [_inProcessByUserXpr(_lock.shiftedNow)] })
     .where(targetWhere)
   // prevent service to check for own user
-  Object.defineProperty(existingDraft, '_draftParams', { value: draftParams, enumerable: false })
+  existingDraft[DRAFT_PARAMS] = draftParams
 
   const activeCQN = SELECT.one.from(req.target).columns(cols).where(targetWhere)
   activeCQN._suppressLocalization = true // in the future we should be able to just set activeCQN.SELECT.localized = false
 
   const activeCheck = SELECT.one(req.target).columns([1]).where(targetWhere).forUpdate()
-  Object.defineProperty(activeCheck, '_draftParams', { value: draftParams, enumerable: false })
+  activeCheck[DRAFT_PARAMS] = draftParams
   // It's not possible to use `FOR UPDATE` in HANA if the view contains joins/unions. Unfortunately, we can't resolve the table entity
   // because we must trigger the app-service request on the target entity (which could be delegated to a remote service).
   // The best we can do is to catch a potential error
-  await _runWithContext(this, req, { query: activeCheck }).catch(_ => {})
+  try {
+    await activeCheck
+  } catch {} // eslint-disable-line no-empty
 
   const [res, draft] = await _promiseAll([
-    _runWithContext(this, req, { query: activeCQN }),
+    this._datasource.run(activeCQN),
     // no user check must be done here...
-    _runWithContext(this, req, { query: existingDraft })
+    existingDraft
   ])
 
   if (!res) req.reject(404)
@@ -974,7 +984,7 @@ async function onEdit(req) {
     for (const key in req.target.drafts.keys) keys[key] = res[key]
     await _promiseAll([
       DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID }),
-      _runWithContext(this, req, { query: DELETE.from(req.target.drafts).where(keys) })
+      DELETE.from(req.target.drafts).where(keys)
     ])
   }
 
@@ -995,11 +1005,12 @@ async function onEdit(req) {
   res.DraftAdministrativeData_DraftUUID = DraftUUID
   res.HasActiveEntity = true
   delete res.DraftAdministrativeData
-  await _runWithContext(this, req, { query: INSERT.into(targetDraft).entries(res) })
+  // change to db run
+  await INSERT.into(targetDraft).entries(res)
 
   // 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)
+  req?._?.odataRes?.setStatusCode(201, { overwrite: true })
 
   return { ...res, IsActiveEntity: false } // REVISIT: Flatten?
 }
@@ -1007,21 +1018,21 @@ async function onEdit(req) {
 async function onCancel(req) {
   LOG.debug('delete draft')
   const activeRef = _redirectRefToActives(req.query.DELETE.from.ref, this.model)
-  const draftParams = req.query._draftParams
+  const draftParams = req.query[DRAFT_PARAMS]
 
-  const draftDelete = SELECT.one
+  const draftQuery = SELECT.one
     .from({ ref: req.query.DELETE.from.ref })
     .columns([
       'DraftAdministrativeData_DraftUUID',
       { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
     ])
+  if (req._etagValidationClause) draftQuery.where(req._etagValidationClause)
   // do not add InProcessByUser restriction
-  Object.defineProperty(draftDelete, '_draftParams', { value: draftParams, enumerable: false })
-  const draft = await _runWithContext(this, req, { query: draftDelete })
-  if (draftParams.IsActiveEntity === false && !draft) req.reject(404)
+  const draft = await draftQuery
+  if (draftParams.IsActiveEntity === false && !draft) req.reject(req._etagValidationType ? 412 : 404)
   if (draft && draft.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id)
     req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [draft.DraftAdministrativeData?.InProcessByUser])
-  const queries = !draft ? [] : [_runWithContext(this, req, { query: DELETE.from({ ref: req.query.DELETE.from.ref }) })]
+  const queries = !draft ? [] : [this.run(DELETE.from({ ref: req.query.DELETE.from.ref }))]
   if (draft && req.target['@Common.DraftRoot.ActivationAction'])
     // only for draft root
     queries.push(
@@ -1037,14 +1048,14 @@ async function onCancel(req) {
         })
         .where({ DraftUUID: draft.DraftAdministrativeData_DraftUUID })
     )
-  if (draftParams.IsActiveEntity) queries.push(_runWithContext(this, req, { query: DELETE.from({ ref: activeRef }) }))
+  if (draftParams.IsActiveEntity) queries.push(this.run(DELETE.from({ ref: activeRef })))
   await _promiseAll(queries)
   return req.data
 }
 
 async function onPrepare(req) {
   LOG.debug('prepare draft')
-  const draftParams = req.query._draftParams
+  const draftParams = req.query[DRAFT_PARAMS]
   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')
   }
@@ -1057,8 +1068,8 @@ async function onPrepare(req) {
     })
     .columns(keys)
     .where(where)
-  Object.defineProperty(draftQuery, '_draftParams', { value: draftParams, enumerable: false })
-  const data = await _runWithContext(this, req, { query: draftQuery })
+  draftQuery[DRAFT_PARAMS] = draftParams
+  const data = await draftQuery
   if (!data) req.reject(404)
   if (data.DraftAdministrativeData?.InProcessByUser !== req.user.id)
     req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [data.DraftAdministrativeData?.InProcessByUser])
@@ -1066,4 +1077,48 @@ async function onPrepare(req) {
   return { ...data, IsActiveEntity: false }
 }
 
-module.exports = { onNew, onEdit, onCancel, onPrepare }
+module.exports = {
+  impl() {
+    if (!this._datasource) this._datasource = cds.db
+    function _wrapped(handler, isActiveEntity) {
+      const fn = function (req, next) {
+        if (!req.target?.drafts || (isActiveEntity && req.target.isDraft) || (!isActiveEntity && !req.target.isDraft))
+          return next.call(this)
+        return handler.call(this, req, next)
+      }
+      return fn
+    }
+    // Also runs those handlers if they're annotated with @odata.draft.enabled through extensibility
+    this.on('NEW', '*', _wrapped(onNew, false))
+    this.on('EDIT', '*', _wrapped(onEdit, true))
+    this.on('CANCEL', '*', _wrapped(onCancel, false))
+    this.on('draftPrepare', '*', _wrapped(onPrepare, false))
+
+    async function fioriReadCompat(req, next) {
+      if (!req.target) return next()
+      const data = await next()
+      if (!data) return data
+      let _key
+      for (const key in req.target.keys) {
+        if (key === 'IsActiveEntity') continue
+        _key = key
+        break
+      }
+      const _addIsActiveEntity = (data, IsActiveEntity) => {
+        if (Array.isArray(data)) return data.map(d => _addIsActiveEntity(d, IsActiveEntity))
+        if (_key in data) data.IsActiveEntity = IsActiveEntity
+      }
+      _addIsActiveEntity(data, !req.target?.isDraft)
+      return data
+    }
+
+    if (cds.env.fiori.draft_compat) {
+      // register after read handlers to add `IsActiveEntity`,
+      // so stakeholders have access to it when calling next()
+
+      // to check if data contains a key value
+      this.on('READ', '*', _wrapped(fioriReadCompat, true))
+      this.on('READ', '*', _wrapped(fioriReadCompat, false))
+    }
+  }
+}