@sap/cds 8.9.4 → 9.0.3

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

@@ -1,50 +1,29 @@
+const cds = require('../cds')
+const LOG = cds.log('fiori|drafts')
+
+const { Object_keys } = cds.utils
+
 const { Readable, PassThrough } = require('stream')
-const cds = require('../cds'),
-  { Object_keys } = cds.utils
 
 const { getPageSize, commonGenericPaging } = require('../common/generic/paging')
 const { handler: commonGenericSorting } = require('../common/generic/sorting')
 const { addEtagColumns } = require('../common/utils/etag')
-
-const { calculateLocationHeader } = require('../../odata/utils')
 const { handleStreamProperties } = require('../common/utils/streamProp')
 
-const LOG = cds.log('fiori|drafts')
-const original = Symbol('original')
-const DRAFT_PARAMS = Symbol('draftParams')
-const AGGREGATION_FUNCTIONS = ['sum', 'min', 'max', 'avg', 'average', 'count']
-
-const calcTimeMs = timeout => {
-  const match = timeout.match(/^([0-9]+)(w|d|h|hrs|min)$/)
-  if (!match) return
-
-  const [, val, t] = match
-  switch (t) {
-    case 'w':
-      return val * 1000 * 3600 * 24 * 7
+const location4 = require('../../http/location')
 
-    case 'd':
-      return val * 1000 * 3600 * 24
+const $original = Symbol('original')
+const $draftParams = Symbol('draftParams')
 
-    case 'h':
-    case 'hrs':
-      return val * 1000 * 3600
-
-    case 'min':
-      return val * 1000 * 60
-
-    default:
-      return val
-  }
-}
+const AGGREGATION_FUNCTIONS = ['sum', 'min', 'max', 'avg', 'average', 'count']
 
 const _config_to_ms = (config, _default) => {
   const timeout = cds.env.fiori?.[config]
   let timeout_ms
   if (timeout === true) {
-    timeout_ms = calcTimeMs(_default)
+    timeout_ms = cds.utils._unit.time2ms(_default)
   } else if (typeof timeout === 'string') {
-    timeout_ms = calcTimeMs(timeout)
+    timeout_ms = cds.utils._unit.time2ms(timeout)
     if (!timeout_ms)
       throw new Error(`
 ${timeout} is an invalid value for \`cds.fiori.${config}\`.
@@ -167,7 +146,7 @@ const _promiseAll = async array => {
 }
 
 const _isCount = query => query.SELECT.columns?.length === 1 && query.SELECT.columns[0].func === 'count'
-const entity_keys = entity =>
+const _entityKeys = entity =>
   Object_keys(entity.keys).filter(key => key !== 'IsActiveEntity' && !entity.keys[key].isAssociation)
 
 const _inProcessByUserXpr = lockShiftedNow => ({
@@ -239,7 +218,7 @@ const _cleanUpOldDrafts = (service, tenant) => {
 
     const draftRootIds = await Promise.all(
       draftRoots.map(draftRoot =>
-        SELECT.from(draftRoot, entity_keys(draftRoot)).where(`DraftAdministrativeData_DraftUUID IN`, expiredDraftsIds)
+        SELECT.from(draftRoot, _entityKeys(draftRoot)).where(`DraftAdministrativeData_DraftUUID IN`, expiredDraftsIds)
       )
     )
 
@@ -320,46 +299,45 @@ const _replaceStreams = result => {
   }
 }
 
+// REVISIT: Can we do a regular handler function instead of monky patching?
 const h = cds.ApplicationService.prototype.handle
-
-cds.ApplicationService.prototype.handle = async function (req) {
-  const handle = h.bind(this)
-
+const handle = async function (req) {
   if (req.event === 'DISCARD') req.event = 'CANCEL'
-  if (req.event === 'SAVE') {
+  else if (req.event === 'SAVE') {
     req.event = 'draftActivate'
     req.query ??= SELECT.from(req.target, req.data) //> support simple srv.send('SAVE',entity,...)
   }
-  if (
-    !req.query ||
-    // REVISIT: Currently all requests in an Object Page to nested composition targets, e.g. Incidents(ID)/conversation are also Draft Requests which seems wrong overkill -> is that required?
-    // req.path.includes('/') ||
-    req.query[DRAFT_PARAMS] ||
-    (!req.query.SELECT &&
-      !req.query.INSERT &&
-      // !req.query.UPSERT && // skip UPSERTs (might have an additional INSERT)
-      !req.query.UPDATE &&
-      !req.query.DELETE)
-  ) {
-    return handle(req)
-  }
 
-  const _etagValidationType = req.headers['if-match']
-    ? 'if-match'
-    : req.headers['if-none-match']
-      ? 'if-none-match'
-      : undefined
+  // Fast exit for non-draft requests
+  // REVISIT: should also start with else, but then this test fails: cds/tests/_runtime/odata/__tests__/integration/draft-custom-handlers.test.js
+  if (!req.query) return h.call(this, req)
+  else if ($draftParams in req.query) return h.call(this, req)
+  /* prettier-ignore */ else if (!(
+    // Note: we skip UPSERTs as these might have an additional INSERT
+    'SELECT' in req.query ||
+    'INSERT' in req.query ||
+    'UPDATE' in req.query ||
+    'DELETE' in req.query
+  )) return h.call(this, req)
+  // TODO: also skip quickly if no draft-enabled entities are involved ?!?
+  // TODO: also skip quickly if no isActiveEntity is part of the query ?!?
+  // TODO: also skip quickly for CREATE request not from Fiori clients ???
+
+  // rewrite event if necessary
+  if (req.protocol && req.target.drafts && req.event in { CREATE: 1, DELETE: 1 }) {
+    if (req.event === 'CREATE' && req.data.IsActiveEntity !== true) req.event = 'NEW'
+    if (req.event === 'DELETE' && req.data.IsActiveEntity === false) req.event = 'CANCEL'
+  }
 
   const query = _cleansed(req.query, this.model)
   _cleanseParams(req.params, req.target)
   if (req.data) _cleanseParams(req.data, req.target)
-  const draftParams = query[DRAFT_PARAMS]
+  const draftParams = query[$draftParams]
 
   const _newReq = (req, query, draftParams, { event, headers }) => {
     // REVISIT: This is a bit hacky -> better way?
     query._target = undefined
-    query.target = undefined
-    query[DRAFT_PARAMS] = draftParams
+    query[$draftParams] = draftParams
 
     // 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
@@ -372,7 +350,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
     // 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.target = cds.infer(query, this.model.definitions)
+    _req.target = cds.infer.target(query)
     _req.query = query
     _req.event =
       event ||
@@ -399,7 +377,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
   const run = (query, options = {}) => {
     const _req = _newReq(req, query, draftParams, options)
-    return handle(_req)
+    return h.call(this, _req)
   }
 
   if (req.event === 'READ') {
@@ -409,7 +387,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
       !req.query._target.drafts
     ) {
       req.query = query
-      return handle(req)
+      return h.call(this, req)
     }
 
     // apply paging and sorting on original query for protocol adapters relying on it
@@ -464,7 +442,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
     if (!containsDraftRoot) req.reject({ code: 403, statusCode: 403, message: 'DRAFT_MODIFICATION_ONLY_VIA_ROOT' })
 
     const isDirectAccess = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
-    const data = Object.assign({}, req.data) // IsActiveEntity is not enumerable
+    const data = Array.isArray(req.data) ? [...req.data] : Object.assign({}, req.data) // IsActiveEntity is not enumerable
     const draftsRootRef =
       typeof query.INSERT.into === 'string'
         ? [req.target.drafts.name]
@@ -477,8 +455,8 @@ cds.ApplicationService.prototype.handle = async function (req) {
     }
 
     // direct access and req.data contains keys: check if root has no draft with that keys
-    if (isDirectAccess && entity_keys(query._target).every(k => k in data)) {
-      const keyData = entity_keys(query._target).reduce((res, k) => {
+    if (isDirectAccess && _entityKeys(query._target).every(k => k in data)) {
+      const keyData = _entityKeys(query._target).reduce((res, k) => {
         res[k] = req.data[k]
         return res
       }, {})
@@ -489,7 +467,9 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
     const cqn = INSERT.into(query.INSERT.into).entries(data)
     await run(cqn, { event: 'CREATE' })
-    const result = { ...data, IsActiveEntity: true }
+    const result = Array.isArray(data)
+      ? data.map(d => ({ ...d, IsActiveEntity: true }))
+      : { ...data, IsActiveEntity: true }
     req.data = result //> make keys available via req.data (as with normal crud)
     return result
   }
@@ -518,7 +498,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
       req.reject({ code: 403, statusCode: 403, message: 'ACTIVE_MODIFICATION_VIA_DRAFT' })
     }
 
-    const result = await handle(_req)
+    const result = await h.call(this, _req)
     req.data = result //> make keys available via req.data (as with normal crud)
     return result
   }
@@ -536,7 +516,8 @@ cds.ApplicationService.prototype.handle = async function (req) {
     if (query.DELETE.where) draftQuery.where(query.DELETE.where)
 
     // Deletion of active instance outside draft tree, no need to check for draft
-    if (!draftQuery.target?.isDraft) {
+    const target = cds.infer.target(draftQuery) // FIXME: this should not be neccessary, does it?
+    if (!target?.isDraft) {
       await run(query)
       return req.data
     }
@@ -583,8 +564,14 @@ cds.ApplicationService.prototype.handle = async function (req) {
       ])
       .where(query.SELECT.where)
     const res = await run(draftQuery)
-    if (!res)
+    if (!res) {
+      const _etagValidationType = req.headers['if-match']
+        ? 'if-match'
+        : req.headers['if-none-match']
+          ? 'if-none-match'
+          : undefined
       req.reject(_etagValidationType ? { code: 412, statusCode: 412 } : { code: 'DRAFT_NOT_EXISTING', statusCode: 404 })
+    }
     if (!cds.context.user._is_privileged && res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) {
       req.reject({
         code: 403,
@@ -616,27 +603,17 @@ cds.ApplicationService.prototype.handle = async function (req) {
       DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: DraftAdministrativeData_DraftUUID })
     ])
 
-    if (!HasActiveEntity) {
-      // 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.res) {
+      // status code must be set in handler to allow overriding for FE V2
       // REVISIT: needs reworking for new adapter, especially re $batch
-      if (req._?.odataRes) {
-        req._?.odataRes?.setStatusCode(201, { overwrite: true })
-      } else if (req.res) {
-        req.res.status(201)
-      }
-    }
+      if (!HasActiveEntity) req.res.status(201)
 
-    if (cds.env.features.odata_new_adapter && req.res) {
       const read_result = await _readAfterDraftAction.bind(this)({
         req,
         payload: res,
         action: 'draftActivate'
       })
-      req.res.set(
-        'location',
-        '../' + calculateLocationHeader(req.target, this, read_result || { ...res, IsActiveEntity: true })
-      )
+      req.res.set('location', '../' + location4(req.target, this, read_result || { ...res, IsActiveEntity: true }))
 
       if (read_result == null) req.res.status(204)
 
@@ -658,11 +635,27 @@ cds.ApplicationService.prototype.handle = async function (req) {
       req.reject({ code: 403, statusCode: 403 })
     }
     const _req = _newReq(req, query, draftParams, { event: req.event })
-    const result = await handle(_req)
+    const result = await h.call(this, _req)
     return result
   }
 
   if (req.event === 'PATCH' || (req.event === 'UPDATE' && req.target.drafts)) {
+    // also delete `IsActiveEntity` for references
+    const _rmIsActiveEntity = (data, target) => {
+      delete data.IsActiveEntity
+      for (const assoc in target.associations) {
+        const val = data[assoc]
+        if (val && typeof val === 'object') {
+          const _target = req.target.associations[assoc]._target
+          if (Array.isArray(val)) {
+            val.forEach(v => _rmIsActiveEntity(v, _target))
+          } else {
+            _rmIsActiveEntity(val, _target)
+          }
+        }
+      }
+    }
+    _rmIsActiveEntity(req.data, req.target)
     if (draftParams.IsActiveEntity === false) {
       LOG.debug('patch draft')
 
@@ -689,9 +682,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
         })
         .where({ DraftUUID: res.DraftAdministrativeData_DraftUUID })
 
-      const updateData = { ...req.data }
-      delete updateData.IsActiveEntity
-      await run(UPDATE({ ref: draftsRef }).data(updateData))
+      await run(UPDATE({ ref: draftsRef }).data(req.data))
       req.data.IsActiveEntity = false
       return req.data
     }
@@ -723,7 +714,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
   req.query = query
 
-  return handle(req)
+  return h.call(this, req)
 }
 
 // REVISIT: It's not optimal to first calculate the whole result array and only later
@@ -731,7 +722,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
 //          especially since the current db driver always adds those fields.
 //          Once we switch to the new driver, we'll adapt it.
 const _requested = (result, query) => {
-  const originalQuery = query[original]
+  const originalQuery = query[$original]
   if (!result || !originalQuery) return result
   const all = ['HasActiveEntity', 'HasDraftEntity']
 
@@ -815,7 +806,7 @@ const Read = {
       !query.SELECT.columns.some(c => c === '*') &&
       !query.SELECT.columns.some(c => c.func && AGGREGATION_FUNCTIONS.includes(c.func))
     ) {
-      const keys = entity_keys(query._target)
+      const keys = _entityKeys(query._target)
       for (const key of keys) {
         if (!query.SELECT.columns.some(c => c.ref?.[0] === key)) query.SELECT.columns.push({ ref: [key] })
       }
@@ -857,7 +848,7 @@ const Read = {
     draftsQuery.SELECT.count = undefined
     draftsQuery.SELECT.orderBy = undefined
     draftsQuery.SELECT.limit = null
-    draftsQuery.SELECT.columns = entity_keys(query._target).map(k => ({ ref: [k] }))
+    draftsQuery.SELECT.columns = _entityKeys(query._target).map(k => ({ ref: [k] }))
 
     const drafts = await draftsQuery.where({ HasActiveEntity: true })
     const res = await Read.onlyActives(run, query.where(Read.whereNotIn(query._target, drafts)), {
@@ -911,7 +902,7 @@ const Read = {
     query._drafts.SELECT.limit = null // we need all entries for the keys to properly select actives (count)
     const isCount = _isCount(query._drafts)
     if (isCount) {
-      query._drafts.SELECT.columns = entity_keys(query._target).map(k => ({ ref: [k] }))
+      query._drafts.SELECT.columns = _entityKeys(query._target).map(k => ({ ref: [k] }))
     }
     if (!query._drafts.SELECT.columns) query._drafts.SELECT.columns = ['*']
     if (!query._drafts.SELECT.columns.some(c => c.ref?.[0] === 'HasActiveEntity')) {
@@ -963,7 +954,7 @@ const Read = {
       }
     }
 
-    const queryElements = cds.infer.elements4(query.SELECT.columns, query.source)
+    const queryElements = query.elements
     const actives = await run(query.where(Read.whereNotIn(query._target, ownDrafts)))
     const removeColumns = (columns, toRemoveCols) => {
       if (!toRemoveCols) return
@@ -1014,7 +1005,7 @@ const Read = {
 
     // runtime sort required
     if (orderByExpr && ownDrafts.length > 0 && actives.length > 0) {
-      const locale = cds.context.locale.replaceAll('_', '-')
+      const locale = cds.context.locale?.replaceAll('_', '-')
       const collatorMap = new Map()
       const elementNamesToSort = orderByExpr.map(orderByExp => orderByExp.ref.join('_'))
 
@@ -1077,7 +1068,7 @@ const Read = {
           c => c.ref && ['DraftAdministrativeData', 'DraftAdministrativeData_DraftUUID'].includes(c.ref[0])
         )
       : [{ ref: ['DraftAdministrativeData_DraftUUID'] }]
-    draftsQuery.SELECT.columns = entity_keys(query._target)
+    draftsQuery.SELECT.columns = _entityKeys(query._target)
       .map(k => ({ ref: [k] }))
       .concat(additionalCols)
     draftsQuery.where({
@@ -1114,7 +1105,7 @@ const Read = {
   whereNotIn: (target, data) => Read.whereIn(target, data, true),
 
   whereIn: (target, data, not = false) => {
-    const keys = entity_keys(target)
+    const keys = _entityKeys(target)
     const dataArray = data ? (Array.isArray(data) ? data : [data]) : []
     if (not && !dataArray.length) return []
     if (keys.length === 1) {
@@ -1137,7 +1128,7 @@ const Read = {
     if (!actives.length) return []
     const drafts = cds.ql.clone(query._drafts)
     drafts.SELECT.where = Read.whereIn(query._target, actives)
-    const newColumns = entity_keys(query._target).map(k => ({ ref: [k] }))
+    const newColumns = _entityKeys(query._target).map(k => ({ ref: [k] }))
     if (
       !drafts.SELECT.columns ||
       drafts.SELECT.columns.some(c => c === '*' || c.ref?.[0] === 'DraftAdministrativeData_DraftUUID')
@@ -1149,6 +1140,7 @@ const Read = {
     drafts.SELECT.count = undefined
     drafts.SELECT.search = undefined
     drafts.SELECT.one = undefined
+    drafts.SELECT.recurse = undefined
     return drafts
   },
 
@@ -1176,7 +1168,7 @@ const Read = {
     const dataArray = Read._makeArray(data)
     if (!dataArray.length) return
     const hash = row =>
-      entity_keys(target)
+      _entityKeys(target)
         .map(k => row[k])
         .reduce((res, curr) => res + '|$|' + curr, '')
     const hashMap = new Map()
@@ -1219,7 +1211,7 @@ function _cleanseParams(params, target) {
       if (key === 'IsActiveEntity') {
         const value = params[key]
         delete params[key]
-        Object.defineProperty(params, key, { value, enumerable: false, writeable: true })
+        Object.defineProperty(params, key, { value, enumerable: false, writeable: true, configurable: true })
       }
     }
   }
@@ -1268,7 +1260,7 @@ function _cleansed(query, model) {
       draftSelect.from = {
         ref: [root.id ? { ...root, id: draft.name } : draft.name, ...tail]
       }
-      cds.infer(draftsQuery, model.definitions)
+      cds.infer.target(draftsQuery)
 
       // draftsQuery._target = draftsQuery._target?.drafts || draftsQuery._target
       if (querySelect.columns && query._target.drafts) {
@@ -1295,7 +1287,7 @@ function _cleansed(query, model) {
         draftSelect.columns = _tweakAdminExpand(draftSelect.columns)
       }
 
-      draftsQuery[DRAFT_PARAMS] = draftParams
+      draftsQuery[$draftParams] = draftParams
       Object.defineProperty(q, '_drafts', { value: draftsQuery })
       return draftsQuery
     }
@@ -1308,8 +1300,8 @@ function _cleansed(query, model) {
     })
   }
 
-  q[DRAFT_PARAMS] = draftParams
-  q[original] = query
+  q[$draftParams] = draftParams
+  q[$original] = query
   return q
 
   function _cleanseQuery(query, draftParams, model) {
@@ -1508,10 +1500,30 @@ function expandStarStar(target, draftActivate, recursion = new Map()) {
   return columns
 }
 
-async function onNewCleanse(req) {
-  cds.validate(req.data, req.target, { insert: true })
+async function beforeNew(req) {
+  function _cleanseData(data, target) {
+    if (!data) return
+    delete data.IsActiveEntity
+    if (!target) return data
+
+    // Also support deep insertions
+    for (const key in data) {
+      if (data[key] && target.elements[key].isAssociation) delete data[key].IsActiveEntity
+      if (!target.elements[key]?.isComposition) continue
+      // do array trick
+      if (Array.isArray(data[key])) data[key] = data[key].map(v => _cleanseData(v, target.elements[key]._target))
+      else if (typeof data[key] === 'object') {
+        data[key] = _cleanseData(data[key], target.elements[key]._target)
+      }
+    }
+
+    return data
+  }
+  _cleanseData(req.data, req.target)
 }
-onNewCleanse._initial = true
+
+beforeNew._initial = true
+
 async function onNew(req) {
   LOG.debug('new draft')
 
@@ -1564,7 +1576,7 @@ async function onNew(req) {
         })
         .where({ DraftUUID })
 
-  const _setDraftUUIDandHasActiveEntity = (obj, target) => {
+  const _setDraftColumns = (obj, target) => {
     const newObj = Object.assign({}, obj, { DraftAdministrativeData_DraftUUID: DraftUUID, HasActiveEntity: false })
     if (!target) return newObj
 
@@ -1573,19 +1585,18 @@ async function onNew(req) {
       if (!target.elements[key]?.isComposition) continue
       // do array trick
       if (Array.isArray(newObj[key]))
-        newObj[key] = newObj[key].map(v => _setDraftUUIDandHasActiveEntity(v, target.elements[key]._target))
+        newObj[key] = newObj[key].map(v => _setDraftColumns(v, target.elements[key]._target))
       else if (typeof newObj[key] === 'object') {
-        newObj[key] = _setDraftUUIDandHasActiveEntity(newObj[key], target.elements[key]._target)
+        newObj[key] = _setDraftColumns(newObj[key], target.elements[key]._target)
       }
     }
 
     return newObj
   }
 
-  const draftData = _setDraftUUIDandHasActiveEntity(req.query.INSERT.entries[0], req.target)
+  const draftData = _setDraftColumns(req.query.INSERT.entries[0], req.target)
 
-  delete draftData.IsActiveEntity
-  const draftCQN = INSERT.into(req.target).entries(draftData)
+  const draftCQN = INSERT.into(req.subject).entries(draftData)
 
   await _promiseAll([adminDataCQN, this.run(draftCQN)])
 
@@ -1602,7 +1613,7 @@ async function onEdit(req) {
   req.query ??= SELECT.from(req.target, req.data).where({ IsActiveEntity: true }) //> support simple srv.send('EDIT',entity,...)
 
   // use symbol for _draftParams
-  const draftParams = req.query[DRAFT_PARAMS] || { IsActiveEntity: true } // REVISIT: can draftParams in the edit caser ever be undefined or other than IsActiveEntity=true ?
+  const draftParams = req.query[$draftParams] || { IsActiveEntity: true } // REVISIT: can draftParams in the edit caser ever be undefined or other than IsActiveEntity=true ?
   if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== true) {
     req.reject({
       code: 400,
@@ -1648,7 +1659,7 @@ async function onEdit(req) {
   })
 
   // prevent service to check for own user
-  existingDraft[DRAFT_PARAMS] = draftParams
+  existingDraft[$draftParams] = draftParams
 
   const selectActiveCQN = SELECT.one.from({ ref: req.query.SELECT.from.ref }).columns(cols)
   selectActiveCQN.SELECT.localized = false
@@ -1663,7 +1674,7 @@ async function onEdit(req) {
   // ensuring there is no waiting time for other users attempting to edit the same record
   // concurrently.
   if (this._datasource === cds.db) {
-    const keys = entity_keys(req.target)
+    const keys = _entityKeys(req.target)
     const keyData = _getKeyData(keys, req.query.SELECT.from.ref[0].where)
     const rootWhere = keys.reduce((res, key) => {
       res[key] = keyData[key]
@@ -1689,7 +1700,7 @@ async function onEdit(req) {
           })()
     const activeLockCQN = SELECT.from(lockTarget, [1]).where(lockWhere).forUpdate({ wait: 0 })
     activeLockCQN.SELECT.localized = false
-    activeLockCQN[DRAFT_PARAMS] = draftParams
+    activeLockCQN[$draftParams] = draftParams
 
     try {
       await activeLockCQN
@@ -1709,7 +1720,7 @@ async function onEdit(req) {
   } else {
     const activeLockCQN = SELECT.from({ ref: req.query.SELECT.from.ref }, [1]).forUpdate({ wait: 0 })
     activeLockCQN.SELECT.localized = false
-    activeLockCQN[DRAFT_PARAMS] = draftParams
+    activeLockCQN[$draftParams] = draftParams
 
     // Locking the underlying database table is effective only when the database is not
     // hosted on an external service. This is because the active data might be stored in
@@ -1729,6 +1740,7 @@ async function onEdit(req) {
   }
 
   if (!res) req.reject({ code: 404, statusCode: 404 })
+
   const preserveChanges = req.data?.PreserveChanges
   const inProcessByUser = draft?.DraftAdministrativeData?.InProcessByUser
 
@@ -1742,7 +1754,7 @@ async function onEdit(req) {
     ])
   }
 
-  if (!cds.env.features.stream_compat && !cds.env.features.binary_draft_compat) _replaceStreams(res)
+  if (!cds.env.features.binary_draft_compat) _replaceStreams(res)
 
   const timestamp = cds.context.timestamp.toISOString() // REVISIT: toISOString should be done on db layer
   await INSERT.into('DRAFT.DraftAdministrativeData').entries({
@@ -1772,16 +1784,13 @@ async function onEdit(req) {
     req.res.status(201)
   }
 
-  if (cds.env.features.odata_new_adapter && req.res) {
+  if (req.res) {
     const read_result = await _readAfterDraftAction.bind(this)({
       req,
       payload: res,
       action: 'draftEdit'
     })
-    req.res.set(
-      'location',
-      '../' + calculateLocationHeader(req.target, this, read_result || { ...res, IsActiveEntity: false })
-    )
+    req.res.set('location', '../' + location4(req.target, this, read_result || { ...res, IsActiveEntity: false }))
 
     if (read_result == null) req.res.status(204)
 
@@ -1796,7 +1805,7 @@ async function onCancel(req) {
 
   req.query ??= DELETE(req.target, req.data) //> support simple srv.send('CANCEL',entity,...)
   const activeRef = _redirectRefToActives(req.query.DELETE.from.ref, this.model)
-  const draftParams = req.query[DRAFT_PARAMS] || { IsActiveEntity: false } // REVISIT: can draftParams in the cancel case ever be undefined or other than IsActiveEntity=false ?
+  const draftParams = req.query[$draftParams] || { IsActiveEntity: false } // REVISIT: can draftParams in the cancel case ever be undefined or other than IsActiveEntity=false ?
 
   const draftQuery = SELECT.one
     .from({ ref: req.query.DELETE.from.ref })
@@ -1841,7 +1850,7 @@ async function onCancel(req) {
 async function onPrepare(req) {
   LOG.debug('prepare draft')
 
-  const draftParams = req.query[DRAFT_PARAMS]
+  const draftParams = req.query[$draftParams]
   if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== false) {
     req.reject({
       code: 400,
@@ -1856,7 +1865,7 @@ async function onPrepare(req) {
       d`.*`, d.DraftAdministrativeData(a => a.InProcessByUser)
     })
     .where(where)
-  draftQuery[DRAFT_PARAMS] = draftParams
+  draftQuery[$draftParams] = draftParams
   const data = await draftQuery
   if (!data) req.reject({ code: 404, statusCode: 404 })
   if (!cds.context.user._is_privileged && data.DraftAdministrativeData?.InProcessByUser !== req.user.id)
@@ -1912,78 +1921,47 @@ const _readAfterDraftAction = async function ({ req, payload, action }) {
   }
 }
 
-// REVISIT: Looking at the simplified impls, I wonder if there's really much added convenience.
-// Even more as these events are very rarely sent from programmatic clients, if at all, but rather from Fiori clients only.
-cds.extend(cds.ApplicationService).with(
-  class {
-    new(draft, key) {
-      return {
-        then: (r, e) => this.send('NEW', draft, key).then(r, e),
-        for: key => this.send('EDIT', typeof draft === 'string' ? draft.replace(/\.drafts$/, '') : draft.actives, key)
-      }
-    }
-    edit(active, key) {
-      return this.send('EDIT', active, key)
-    }
-    save(draft, key) {
-      return this.send('SAVE', draft, key)
-    }
-    cancel(draft, key) {
-      return this.send('CANCEL', draft, key)
-    }
-    discard(draft, key) {
-      return this.send('DISCARD', draft, key)
-    }
-  }
-)
-
-module.exports = {
-  impl() {
-    // REVISIT: don't pollute services... -> do we really need this?
-    Object.defineProperty(this, '_datasource', { value: 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?.()
-        return handler.call(this, req, next)
-      }
-      if (handler._initial) fn._initial = true
-      return fn
-    }
+module.exports = cds.service.impl(function () {
+  if (!this.entities?.DraftAdministrativeData) return
 
-    // Also runs those handlers if they're annotated with @odata.draft.enabled through extensibility
-    this.before('NEW', '*', _wrapped(onNewCleanse, false))
-    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
+  // REVISIT: don't pollute services... -> do we really need this?
+  Object.defineProperty(this, '_datasource', { value: cds.db })
+
+  this.new = function (draft, key) {
+    return {
+      then: (r, e) => this.send('NEW', draft, key).then(r, e),
+      for: key => this.send('EDIT', typeof draft === 'string' ? draft.replace(/\.drafts$/, '') : draft.actives, key)
     }
+  }
+  this.edit = function (active, key) {
+    return this.send('EDIT', active, key)
+  }
+  this.save = function (draft, key) {
+    return this.send('SAVE', draft, key)
+  }
+  this.cancel = function (draft, key) {
+    return this.send('CANCEL', draft, key)
+  }
+  this.discard = function (draft, key) {
+    return this.send('DISCARD', draft, key)
+  }
 
-    if (cds.env.fiori.draft_compat) {
-      // register after read handlers to add `IsActiveEntity`,
-      // so stakeholders have access to it when calling next()
+  this.handle = handle
 
-      // to check if data contains a key value
-      this.on('READ', '*', _wrapped(fioriReadCompat, true))
-      this.on('READ', '*', _wrapped(fioriReadCompat, false))
+  function _wrapped(handler, isActiveEntity) {
+    const fn = function handle_draft_requests(req, next) {
+      if (!req.target?.drafts || (isActiveEntity && req.target.isDraft) || (!isActiveEntity && !req.target.isDraft))
+        return next?.()
+      return handler.call(this, req, next)
     }
+    if (handler._initial) fn._initial = true
+    return fn
   }
-}
+
+  // Also runs those handlers if they're annotated with @odata.draft.enabled through extensibility
+  this.on('NEW', '*', _wrapped(onNew, false))
+  this.prepend(s => s.before('NEW', '*', _wrapped(beforeNew, false)))
+  this.on('EDIT', '*', _wrapped(onEdit, true))
+  this.on('CANCEL', '*', _wrapped(onCancel, false))
+  this.on('draftPrepare', '*', _wrapped(onPrepare, false))
+})