@sap/cds 9.0.4 → 9.2.0

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

@@ -10,20 +10,23 @@ const { handler: commonGenericSorting } = require('../common/generic/sorting')
 const { addEtagColumns } = require('../common/utils/etag')
 const { handleStreamProperties } = require('../common/utils/streamProp')
 
+const { getLocalizedMessages } = require('../../odata/middleware/error')
+const { Responses } = require('../../../lib/req/response')
 const location4 = require('../../http/location')
 
 const $original = Symbol('original')
 const $draftParams = Symbol('draftParams')
 
 const AGGREGATION_FUNCTIONS = ['sum', 'min', 'max', 'avg', 'average', 'count']
+const MAX_RECURSION_DEPTH = cds.env.features.recursion_depth != null ? Number(cds.env.features.recursion_depth) : 4
 
 const _config_to_ms = (config, _default) => {
   const timeout = cds.env.fiori?.[config]
   let timeout_ms
   if (timeout === true) {
-    timeout_ms = cds.utils._unit.time2ms(_default)
+    timeout_ms = cds.utils.ms4(_default)
   } else if (typeof timeout === 'string') {
-    timeout_ms = cds.utils._unit.time2ms(timeout)
+    timeout_ms = cds.utils.ms4(timeout)
     if (!timeout_ms)
       throw new Error(`
 ${timeout} is an invalid value for \`cds.fiori.${config}\`.
@@ -71,16 +74,6 @@ const DRAFT_ELEMENTS = new Set([
 const DRAFT_ELEMENTS_WITHOUT_HASACTIVE = new Set(DRAFT_ELEMENTS)
 DRAFT_ELEMENTS_WITHOUT_HASACTIVE.delete('HasActiveEntity')
 const REDUCED_DRAFT_ELEMENTS = new Set(['IsActiveEntity', 'HasDraftEntity', 'SiblingEntity'])
-const DRAFT_ADMIN_ELEMENTS = [
-  'DraftUUID',
-  'LastChangedByUser',
-  'LastChangeDateTime',
-  'CreatedByUser',
-  'CreationDateTime',
-  'InProcessByUser',
-  'DraftIsCreatedByMe',
-  'DraftIsProcessedByMe'
-]
 
 const numericCollator = { numeric: true }
 const emptyObject = {}
@@ -279,6 +272,96 @@ const _removeEmptyStreams = async result => {
   }
 }
 
+const getUpdateFromSelectQueries = (target, draftRef, activeRef, depth = 0) => {
+  const updateMediaDataQueries = []
+
+  // Collect relevant elements
+  const compositionElements = []
+  const mediaDataElements = []
+  const autogeneratedElements = []
+  const targetElements = Array.isArray(target.elements) ? target.elements : Object.values(target.elements)
+  for (const element of targetElements) {
+    if (element['@cds.on.update']) autogeneratedElements.push(element)
+    else if (element.isComposition) compositionElements.push(element)
+    else if (element._type === 'cds.LargeBinary') mediaDataElements.push(element)
+  }
+
+  // Recurse into compositions
+  const nextDepth = depth + 1
+  if (nextDepth <= MAX_RECURSION_DEPTH) {
+    for (const composition of compositionElements) {
+      const compositionTargetElement = cds.model.definitions[composition.target]
+
+      const nextDraftRef = [...draftRef, composition.name]
+      const nextActiveRef = [...activeRef, composition.name]
+
+      updateMediaDataQueries.push(
+        ...getUpdateFromSelectQueries(compositionTargetElement, nextDraftRef, nextActiveRef, nextDepth)
+      )
+    }
+  }
+
+  // Construct update queries for media data elements
+  if (mediaDataElements.length) {
+    const updateWith = {}
+    for (const element of autogeneratedElements) {
+      updateWith[element.name] = { ref: ['active', element.name] }
+    }
+
+    // Construct WHERE to match draft and active entities
+    const selectWhere = Object.values(target.keys).reduce((acc, key) => {
+      if (key.virtual || key.isAssociation) return acc
+      if (acc.length) acc.push('and')
+      acc.push({ ref: ['draft', key.name] })
+      acc.push('=')
+      acc.push({ ref: ['active', key.name] })
+      return acc
+    }, [])
+
+    for (const element of mediaDataElements) {
+      const activeElementRef = { ref: ['active', element.name] }
+      const draftElementRef = { ref: ['draft', element.name] }
+
+      // cds.ql.xpr`CASE WHEN (${draftElementRef} IS NULL OR length(${draftElementRef}) > 0) THEN ${draftElementRef} ELSE ${activeElementRef} END`
+      const columnExpression = {
+        xpr: [
+          'case',
+          'when',
+          {
+            xpr: [
+              draftElementRef,
+              '=',
+              { val: null },
+              'or',
+              { func: 'length', args: [draftElementRef] },
+              '>',
+              { val: 0 }
+            ]
+          },
+          'then',
+          draftElementRef,
+          'else',
+          activeElementRef,
+          'end'
+        ]
+      }
+      columnExpression.as = element.name
+
+      const qSelectNextMediaData = SELECT.columns([columnExpression])
+        .from({ ref: draftRef, as: 'draft' })
+        .where(selectWhere)
+
+      updateWith[element.name] = qSelectNextMediaData
+    }
+
+    // Construct & Collect the actual update query for this composition level
+    const updateMediaDataQuery = UPDATE.entity({ ref: activeRef, as: 'active' }).with(updateWith)
+    updateMediaDataQueries.push(updateMediaDataQuery)
+  }
+
+  return updateMediaDataQueries
+}
+
 // REVISIT: Can be replaced with SQL WHEN statement (see commented code in expandStarStar) in the new HANA db layer - doesn't work with old db layer
 const _replaceStreams = result => {
   if (!result) return
@@ -299,6 +382,108 @@ const _replaceStreams = result => {
   }
 }
 
+const _compileUpdatedDraftMessages = (newMessages, persistedMessages, requestData, draftsRef) => {
+  const prefixRef = []
+
+  // Determine the path prefix required for a fully qualified validation message 'target'
+  let targetEntity = cds.context.tx.model.definitions[draftsRef[0].id || draftsRef[0]]
+  for (let refIdx = 0; refIdx < draftsRef.length; refIdx++) {
+    const dRef = draftsRef[refIdx],
+      dRefId = dRef.id ?? dRef
+
+    // Determine entity, referenced by the processesd segment of 'draftsRef'
+    if (refIdx > 0) targetEntity = targetEntity.elements[dRefId]._target
+
+    // Construct 'prefixRef' segment
+    const pRef = { where: [] }
+
+    if (dRefId === targetEntity.name) {
+      if (!targetEntity.isDraft) pRef.id = targetEntity.name.replace(`${targetEntity._service.name}.`, '')
+      else pRef.id = targetEntity.actives.name.replace(`${targetEntity.actives._service.name}.`, '')
+    } else pRef.id = dRefId
+
+    if (targetEntity.isDraft) targetEntity = targetEntity.actives
+
+    if (typeof dRef === 'string' || !dRef.where?.length) {
+      // In case of CREATE: The WHERE for the created entity must be constructed for use in 'prefixRef'
+
+      for (const k in targetEntity.keys) {
+        const key = targetEntity.keys[k]
+        let v = requestData[key.name]
+        if (v === undefined)
+          if (key.name === 'IsActiveEntity') v = false
+          else return null
+        if (pRef.where.length > 0) pRef.where.push('and')
+        pRef.where.push(key.name, '=', v)
+      }
+    } else {
+      // 'dRef.where' regards the draft and will never contain 'IsActiveEntity=false'
+      pRef.where.push(...dRef.where, 'and', 'IsActiveEntity', '=', false)
+    }
+
+    prefixRef.push(pRef)
+  }
+
+  const nextMessages = []
+
+  // Collect messages that were created during the most recent validation run
+  const newMessagesByCodeAndTarget = newMessages.reduce((acc, message) => {
+    message.numericSeverity ??= 4
+
+    // Handle validation messages produced during draftActivate, that went through error normalization already
+    // > We must not store pre-localized data in DraftAdministrativeData.DraftMessages
+    const messageTarget = message.target.startsWith('in/') ? message.target.slice(3) : message.target
+    if (message.code) {
+      message.message = message.code
+      delete message.code
+    }
+
+    // Process the message target produced by validation
+    // > The message target contains the relative path of the erroneous entity
+    // > For a message specific 'prefixRef', this info must be added to the entity 'prefixRef'
+    const messagePrefixRef = [...prefixRef]
+    const messageTargetRef = cds.odata.parse(messageTarget).SELECT.from.ref
+    message.target = messageTargetRef.pop()
+
+    for (const tRef of messageTargetRef) {
+      messagePrefixRef.push(tRef)
+      if ((tRef.where ??= []).some(w => w === 'IsActiveEntity' || w.ref?.[0] === 'IsActiveEntity')) continue
+      if (tRef.where.length > 0) tRef.where.push('and', 'IsActiveEntity', '=', false)
+    }
+
+    message.prefix = cds.odata.urlify({ SELECT: { from: { ref: messagePrefixRef } } }).path
+
+    nextMessages.push(message)
+
+    return acc.set(`${message.message}:${message.prefix}:${message.target}`, message)
+  }, new Map())
+
+  const draftMessageTargetPrefix = cds.odata.urlify({ SELECT: { from: { ref: prefixRef } } }).path
+
+  // Merge new messages with persisted ones & eliminate outdated ones
+  const simplePathElements = prefixRef.map(pRef => pRef.id)
+  for (const message of persistedMessages) {
+    // Drop persisted draft messages that are replaced by new ones
+    if (newMessagesByCodeAndTarget.has(`${message.message}:${message.prefix}:${message.target}`)) continue
+
+    // Drop persisted draft messages where the value of the target field changed without a new error
+    if (message.prefix === draftMessageTargetPrefix && requestData[message.target] !== undefined) continue
+
+    // Drop persisted draft messages, whose target's use navigations, where the value of the target field changed without a new error
+    const messageSimplePathElements = message.prefix.replaceAll(/\([^(]*\)/g, '').split('/')
+    if (messageSimplePathElements.length > simplePathElements.length)
+      if (requestData[messageSimplePathElements[simplePathElements.length]] !== undefined) continue
+
+    nextMessages.push(message)
+  }
+
+  // REVISIT: Do this by default in validation?
+  for (const msg of nextMessages)
+    for (const i in msg.args) if (msg.args[i] instanceof RegExp) msg.args[i] = msg.args[i].toString()
+
+  return nextMessages
+}
+
 // REVISIT: Can we do a regular handler function instead of monky patching?
 const h = cds.ApplicationService.prototype.handle
 const handle = async function (req) {
@@ -365,12 +550,23 @@ const handle = async function (req) {
     if (!_req._.event) _req._.event = req.event
     const cqnData = _req.query.UPDATE?.data || _req.query.INSERT?.entries?.[0]
     if (cqnData) _req.data = cqnData // must point to the same object
+    if (req.tx && !_req.tx) _req.tx = req.tx
+
+    // Ensure messages are added to the original request
     Object.defineProperty(_req, '_messages', {
       get: function () {
         return req._messages
       }
     })
-    if (req.tx && !_req.tx) _req.tx = req.tx
+
+    if (cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages) {
+      if (_req.target.isDraft && (_req.event === 'UPDATE' || _req.event === 'NEW')) {
+        // Degrade all errors to messages & prevent !!req.errors into req.reject() in dispatch
+        _req.error = (...args) => {
+          for (const err of args) _req._messages.add(4, err)
+        }
+      }
+    }
 
     return _req
   }
@@ -447,6 +643,7 @@ const handle = async function (req) {
       typeof query.INSERT.into === 'string'
         ? [req.target.drafts.name]
         : _redirectRefToDrafts([query.INSERT.into.ref[0]], this.model)
+
     let rootHasDraft
 
     // children: check root entity has no draft
@@ -478,6 +675,33 @@ const handle = async function (req) {
   if (req.event === 'NEW' || req.event === 'CANCEL' || req.event === 'draftPrepare') {
     if (!req.target.isDraft) req.target = req.target.drafts // COMPAT: also support these events for actives
 
+    if (cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages && query.DELETE) {
+      const prefixRef = query.DELETE.from.ref.map(dRef => {
+        const pRef = { id: dRef.id, where: [...dRef.where] }
+        pRef.where.push('and', 'IsActiveEntity', '=', false)
+        return pRef
+      })
+      const messageTargetPrefix = cds.odata.urlify({ SELECT: { from: { ref: prefixRef } } }).path
+
+      const draftData = await SELECT.one
+        .from({ ref: _redirectRefToDrafts(query.DELETE.from.ref, this.model) }) // REVISIT: Avoid redundant redirect
+        .columns('DraftAdministrativeData_DraftUUID', {
+          ref: ['DraftAdministrativeData'],
+          expand: [{ ref: ['DraftMessages'] }]
+        })
+
+      const draftAdminDataUUID = draftData?.DraftAdministrativeData_DraftUUID
+      const persistedDraftMessages = draftData?.DraftAdministrativeData?.DraftMessages || []
+
+      if (draftAdminDataUUID && persistedDraftMessages?.length) {
+        const nextDraftMessages = persistedDraftMessages.filter(msg => !msg.prefix.startsWith(messageTargetPrefix))
+
+        await UPDATE('DRAFT.DraftAdministrativeData')
+          .set({ DraftMessages: nextDraftMessages })
+          .where({ DraftUUID: draftAdminDataUUID })
+      }
+    }
+
     if (query.INSERT) {
       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)
@@ -490,15 +714,12 @@ const handle = async function (req) {
     const _req = _newReq(req, query, draftParams, { event: req.event })
 
     // Do not allow to create active instances via drafts
-    if (
-      (req.event === 'NEW' || req.event === 'CREATE') &&
-      draftParams.IsActiveEntity === false &&
-      !_req.target.isDraft
-    ) {
+    if (req.event === 'NEW' && draftParams.IsActiveEntity === false && !_req.target.isDraft) {
       req.reject({ code: 403, statusCode: 403, message: 'ACTIVE_MODIFICATION_VIA_DRAFT' })
     }
 
     const result = await h.call(this, _req)
+
     req.data = result //> make keys available via req.data (as with normal crud)
     return result
   }
@@ -506,13 +727,13 @@ const handle = async function (req) {
   // Delete active instance of draft-enabled entity
   if (req.target.drafts && !req.target.isDraft && req.event === 'DELETE' && draftParams.IsActiveEntity !== false) {
     const draftsRef = _redirectRefToDrafts(query.DELETE.from.ref, this.model)
-    const draftQuery = SELECT.one.from({ ref: draftsRef }).columns([
-      { ref: ['DraftAdministrativeData_DraftUUID'] },
-      {
-        ref: ['DraftAdministrativeData'],
-        expand: [_inProcessByUserXpr(_lock.shiftedNow)]
-      }
-    ])
+    const inProcessByUserCol = {
+      ref: ['DraftAdministrativeData'],
+      expand: [_inProcessByUserXpr(_lock.shiftedNow)]
+    }
+    const draftQuery = SELECT.one
+      .from({ ref: draftsRef })
+      .columns([{ ref: ['DraftAdministrativeData_DraftUUID'] }, inProcessByUserCol])
     if (query.DELETE.where) draftQuery.where(query.DELETE.where)
 
     // Deletion of active instance outside draft tree, no need to check for draft
@@ -523,11 +744,59 @@ const handle = async function (req) {
     }
 
     // Deletion of active instance inside draft tree, need to check that no draft exists
-    const draft = await draftQuery
-    const inProcessByUser = draft?.DraftAdministrativeData?.InProcessByUser
-    if (!cds.context.user._is_privileged && inProcessByUser && inProcessByUser !== cds.context.user.id)
-      req.reject({ code: 403, statusCode: 403, message: 'DRAFT_LOCKED_BY_ANOTHER_USER', args: [inProcessByUser] })
-    if (draft) req.reject({ code: 403, statusCode: 403, message: 'DRAFT_ACTIVE_DELETE_FORBIDDEN_DRAFT_EXISTS' })
+    const drafts = []
+    const draftsRes = await draftQuery
+    if (draftsRes) drafts.push(draftsRes)
+
+    // For hierarchies, check that no sub node exists.
+    if (target?.elements?.LimitedDescendantCount) {
+      let key
+      for (const _key in req.target.keys) {
+        if (_key === 'IsActiveEntity') continue
+        key = _key // only single key supported
+      }
+      // We must only do this for recursive _composition_ children.
+      // For recursive _association_ children, app developers must deal with dangling pointers themselves.
+      const _recursiveComposition = target => {
+        for (const _comp in target.compositions) {
+          if (target.compositions[_comp]['@odata.draft.ignore']) {
+            return target.compositions[_comp]
+          }
+        }
+      }
+      const recursiveComposition = _recursiveComposition(req.target)
+      if (recursiveComposition) {
+        let uplinkName
+        for (const key in req.target) {
+          if (key.match(/@Aggregation\.RecursiveHierarchy\s*#.*\.ParentNavigationProperty/)) {
+            uplinkName = req.target[key]['=']
+            break
+          }
+        }
+        const keyVal = req.query.DELETE.from.ref[0].where?.[2]?.val
+        if (keyVal === undefined) req.reject(400, 'Deletion not supported')
+        // We must select actives and check for corresponding drafts (drafts themselve don't necessarily form a hierarchy)
+        const recursiveQ = SELECT.from(req.target).columns(key)
+        recursiveQ.SELECT.recurse = {
+          ref: [uplinkName],
+          where: [{ func: 'DistanceTo', args: [{ val: keyVal }, { val: null }] }]
+        }
+        const recursives = await recursiveQ
+        if (recursives.length) {
+          const recursiveDrafts = await SELECT.from(req.target.drafts)
+            .columns(inProcessByUserCol)
+            .where(Read.whereIn(req.target, recursives))
+          drafts.push(...recursiveDrafts)
+        }
+      }
+    }
+
+    for (const draft of drafts) {
+      const inProcessByUser = draft?.DraftAdministrativeData?.InProcessByUser
+      if (!cds.context.user._is_privileged && inProcessByUser && inProcessByUser !== cds.context.user.id)
+        req.reject({ code: 403, statusCode: 403, message: 'DRAFT_LOCKED_BY_ANOTHER_USER', args: [inProcessByUser] })
+      else req.reject({ code: 403, statusCode: 403, message: 'DRAFT_ACTIVE_DELETE_FORBIDDEN_DRAFT_EXISTS' })
+    }
     await run(query)
     return req.data
   }
@@ -535,8 +804,6 @@ const handle = async function (req) {
   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 === true) {
       req.reject({
         code: 400,
@@ -549,21 +816,29 @@ const handle = async function (req) {
       req.reject({ code: 428, statusCode: 428 })
     }
 
-    const cols = expandStarStar(req.target.drafts, true)
+    const columns = expandStarStar(req.target.drafts, true)
 
-    // Use `run` (since also etags might need to be checked)
-    // REVISIT: Find a better approach (`etag` as part of CQN?)
     const draftRef = _redirectRefToDrafts(query.SELECT.from.ref, this.model)
     const draftQuery = SELECT.one
       .from({ ref: draftRef })
-      .columns(cols)
+      .columns(columns)
       .columns([
-        'HasActiveEntity',
-        'DraftAdministrativeData_DraftUUID',
-        { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
+        // Will automatically select 'IsActiveEntity' as key column
+        { ref: ['HasActiveEntity'] },
+        { ref: ['DraftAdministrativeData_DraftUUID'] },
+        {
+          ref: ['DraftAdministrativeData'],
+          expand: [
+            { ref: ['InProcessByUser'] },
+            ...(cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages
+              ? [{ ref: ['DraftMessages'] }]
+              : [])
+          ]
+        }
       ])
       .where(query.SELECT.where)
     const res = await run(draftQuery)
+
     if (!res) {
       const _etagValidationType = req.headers['if-match']
         ? 'if-match'
@@ -581,23 +856,64 @@ const handle = async function (req) {
       })
     }
 
+    // Remove draft artefacts from persistedDraft entry
     const DraftAdministrativeData_DraftUUID = res.DraftAdministrativeData_DraftUUID
+    const persistedDraftMessages = res.DraftAdministrativeData?.DraftMessages || []
     delete res.DraftAdministrativeData_DraftUUID
     delete res.DraftAdministrativeData
     const HasActiveEntity = res.HasActiveEntity
     delete res.HasActiveEntity
 
-    if (_hasStreaming(draftQuery.SELECT.columns, draftQuery._target, true) && !cds.env.features.binary_draft_compat)
+    if (
+      _hasStreaming(draftQuery.SELECT.columns, draftQuery._target, true) &&
+      !cds.env.features.binary_draft_compat &&
+      !cds.env.fiori.move_media_data_in_db
+    ) {
       await _removeEmptyStreams(res)
+    }
 
     // First run the handlers as they might need access to DraftAdministrativeData or the draft entities
     const activesRef = _redirectRefToActives(query.SELECT.from.ref, this.model)
-    const result = await run(
-      HasActiveEntity
-        ? UPDATE({ ref: activesRef }).data(res).where(query.SELECT.where)
-        : INSERT.into({ ref: activesRef }).entries(res),
-      { headers: Object.assign({}, req.headers, { 'if-match': '*' }) }
-    )
+
+    // Upsert draft into active, not considering media data columns
+    const upsertQuery = HasActiveEntity
+      ? UPDATE({ ref: activesRef }).data(res).where(query.SELECT.where)
+      : INSERT.into({ ref: activesRef }).entries(res)
+    const upsertOptions = { headers: Object.assign({}, req.headers, { 'if-match': '*' }) }
+
+    const _req = _newReq(req, upsertQuery, draftParams, upsertOptions)
+
+    let result
+    try {
+      result = await h.call(this, _req)
+    } catch (error) {
+      if (cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages && _req.errors)
+        _req.on('failed', async () => {
+          const nextDraftMessages = _compileUpdatedDraftMessages(
+            _req.errors.map(e => ({ ...e })),
+            persistedDraftMessages,
+            {},
+            draftRef
+          )
+
+          await cds.tx(async () => {
+            await UPDATE('DRAFT.DraftAdministrativeData')
+              .set({ DraftMessages: nextDraftMessages })
+              .where({ DraftUUID: DraftAdministrativeData_DraftUUID })
+          })
+        })
+
+      throw error
+    }
+
+    // REVISIT: Remove feature flag dependency
+    if (cds.env.fiori.move_media_data_in_db) {
+      // Move cds.LargeBinary data from draft to active
+      const updateMediaDataQueries = getUpdateFromSelectQueries(req.target, draftRef, activesRef)
+      await _promiseAll(updateMediaDataQueries)
+    }
+
+    // Delete draft artefacts
     await _promiseAll([
       DELETE.from({ ref: draftRef }).where(query.SELECT.where),
       DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: DraftAdministrativeData_DraftUUID })
@@ -656,15 +972,23 @@ const handle = async function (req) {
       }
     }
     _rmIsActiveEntity(req.data, req.target)
+
     if (draftParams.IsActiveEntity === false) {
       LOG.debug('patch draft')
 
       if (req.target?.name.endsWith('DraftAdministrativeData')) req.reject({ code: 405, statusCode: 405 })
+
       const draftsRef = _redirectRefToDrafts(query.UPDATE.entity.ref, this.model)
       const res = await SELECT.one.from({ ref: draftsRef }).columns('DraftAdministrativeData_DraftUUID', {
         ref: ['DraftAdministrativeData'],
-        expand: [{ ref: ['InProcessByUser'] }]
+        expand: [
+          { ref: ['InProcessByUser'] },
+          ...(cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages
+            ? [{ ref: ['DraftMessages'] }]
+            : [])
+        ]
       })
+
       if (!res) req.reject({ code: 404, statusCode: 404 })
       if (!cds.context.user._is_privileged && res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) {
         req.reject({
@@ -674,15 +998,31 @@ const handle = async function (req) {
           args: [res.DraftAdministrativeData?.InProcessByUser]
         })
       }
+
+      await run(UPDATE({ ref: draftsRef }).data(req.data))
+
+      const nextDraftAdminData = {
+        InProcessByUser: req.user.id,
+        LastChangedByUser: req.user.id,
+        LastChangeDateTime: new Date()
+      }
+
+      if (cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages) {
+        nextDraftAdminData.DraftMessages = _compileUpdatedDraftMessages(
+          req.messages ?? [],
+          res.DraftAdministrativeData?.DraftMessages ?? [],
+          req.data ?? {},
+          draftsRef
+        )
+
+        // Prevent validation errors from being sent in 'sap-messages' header
+        req.messages = req._set('_messages', new Responses())
+      }
+
       await UPDATE('DRAFT.DraftAdministrativeData')
-        .data({
-          InProcessByUser: req.user.id,
-          LastChangedByUser: req.user.id,
-          LastChangeDateTime: new Date()
-        })
+        .data(nextDraftAdminData)
         .where({ DraftUUID: res.DraftAdministrativeData_DraftUUID })
 
-      await run(UPDATE({ ref: draftsRef }).data(req.data))
       req.data.IsActiveEntity = false
       return req.data
     }
@@ -877,6 +1217,16 @@ const Read = {
       }
       return result
     }
+
+    if (cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages) {
+      // Replace selection of 'DraftMessages' with the proper path expression
+
+      query._drafts.SELECT.columns = [
+        ...(query._drafts.SELECT.columns ?? ['*']).filter(c => c.ref?.[0] !== 'DraftMessages'),
+        { ref: ['DraftAdministrativeData', 'DraftMessages'], as: 'DraftMessages' }
+      ]
+    }
+
     const draftsQuery = query._drafts.where(
       { ref: ['DraftAdministrativeData', 'InProcessByUser'] },
       '=',
@@ -889,7 +1239,33 @@ const Read = {
         HasDraftEntity: false
       })
       _fillIsActiveEntity(row, false, query._drafts._target)
+
+      if (cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages && row.DraftMessages?.length) {
+        // Reduce persisted draft messages to the set of those that are part of the queried entities tree
+
+        const simplePath = query._drafts.SELECT.from.ref
+          .map(refElement => {
+            refElement = (refElement.id ?? refElement).split('.')
+            if (refElement.length === 1) return refElement[0]
+            if (refElement[refElement.length - 1] === 'drafts') return refElement[refElement.length - 2]
+            return refElement[refElement.length - 1]
+          })
+          .join('/')
+
+        row.DraftMessages = row.DraftMessages.reduce((acc, msg) => {
+          const messageSimplePath = msg.prefix.replaceAll(/\([^(]*\)/g, '')
+          if (!messageSimplePath.startsWith(simplePath)) return acc
+          msg.target = `/${msg.prefix}/${msg.target}`
+          delete msg.prefix
+          delete msg.simplePathElements
+          acc.push(msg)
+          return acc
+        }, [])
+
+        row.DraftMessages = getLocalizedMessages(row.DraftMessages, cds.context.http.req)
+      }
     })
+
     return _requested(drafts, query)
   },
 
@@ -1229,6 +1605,7 @@ function _cleanseCols(columns, elements, target) {
   })
 }
 
+let DRAFT_ADMIN_ELEMENTS
 /**
  * Creates a clone of the query, cleanses and collects all draft parameters into DRAFT_PARAMS.
  */
@@ -1355,6 +1732,11 @@ function _cleansed(query, model) {
   }
 
   function _tweakAdminCols(columns) {
+    if (!DRAFT_ADMIN_ELEMENTS) {
+      DRAFT_ADMIN_ELEMENTS = []
+      for (const key in cds.model.definitions['DRAFT.DraftAdministrativeData'].elements) DRAFT_ADMIN_ELEMENTS.push(key)
+    }
+
     if (!columns || columns.some(c => c === '*')) columns = DRAFT_ADMIN_ELEMENTS.map(k => ({ ref: [k] }))
     return columns.map(col => {
       const name = col.ref?.[0]
@@ -1444,59 +1826,40 @@ function _cleansed(query, model) {
   }
 }
 
-// This function is better defined on DB layer
+// REVISIT: This function is better defined on DB layer
 function expandStarStar(target, draftActivate, 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]
 
-    // no need to read calculated elements
+    // Skip calculated elements
     if (draftActivate && element.value) continue
 
-    // REVISIT: This does not work with old HANA db layer.
-    // Use it after removing old db layer.
-    /*
-    if (element._type === 'cds.LargeBinary') {
-      if (!draftActivate) {
-        columns.push({
-          xpr: [
-            'case',
-            'when',
-            { ref: [el] },
-            'IS',
-            'NULL',
-            'then',
-            { val: null },
-            'else',
-            { val: '' },
-            'end'
-          ],
-          as: el,
-          // cast: 'cds.LargeBinary'  <-- This should be fixed for new HANA db layer
-        })
-        continue
-      }
-    }*/
-
-    const skip_managed = draftActivate && (element['@cds.on.insert'] || element['@cds.on.update'])
-    if (!skip_managed && !element.isAssociation && !DRAFT_ELEMENTS.has(el) && !element['@odata.draft.skip'])
-      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, draftActivate, recursion)
-    if (expand) columns.push({ ref: [el], expand })
+    // Make sure column is releveant & add it to output
+    const isDraftInfo = DRAFT_ELEMENTS.has(el)
+    const isGenerated = draftActivate && !!(element['@cds.on.insert'] || element['@cds.on.update'])
+    const isLargeBinary = cds.env.fiori.move_media_data_in_db && draftActivate && element._type === 'cds.LargeBinary'
+    const isSkippedType = element.isAssociation || isLargeBinary
+    if (!isDraftInfo && !isGenerated && !isSkippedType && !element['@odata.draft.skip']) columns.push({ ref: [el] })
+
+    // Skip children where draft is explicitly disabled
+    if (!element.isComposition || element._target['@odata.draft.enabled'] === false || element['@odata.draft.ignore'])
+      continue // happens for texts if not @fiori.draft.enabled
+
+    // Make sure recursion depth is not exceeded
+    const cacheKey = target.name + ':' + el
+    let cache = recursion.get(cacheKey) ?? 0
+    recursion.set(cacheKey, ++cache)
+    if (cache >= MAX_RECURSION_DEPTH) continue
+
+    // Recurse
+    const expandedColumns = expandStarStar(element._target, draftActivate, recursion)
+
+    // Unpack recursion result
+    if (expandedColumns.length) columns.push({ ref: [el], expand: expandedColumns })
   }
+
   return columns
 }
 
@@ -1521,7 +1884,6 @@ async function beforeNew(req) {
   }
   _cleanseData(req.data, req.target)
 }
-
 beforeNew._initial = true
 
 async function onNew(req) {
@@ -1529,8 +1891,10 @@ async function onNew(req) {
 
   if (req.target.actives['@Capabilities.InsertRestrictions.Insertable'] === false || req.target.actives['@readonly'])
     req.reject({ code: 405, statusCode: 405 })
+
   req.query ??= INSERT.into(req.subject).entries(req.data || {}) //> support simple srv.send('NEW',entity,...)
   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 (isDirectAccess && !req.target.actives['@Common.DraftRoot.ActivationAction'])
     req.reject({ code: 403, statusCode: 403, message: 'DRAFT_MODIFICATION_ONLY_VIA_ROOT' })
@@ -1538,14 +1902,25 @@ async function onNew(req) {
   _cleanUpOldDrafts(this, req.tenant)
 
   let DraftUUID
+  let DraftMessages = []
+  let newDraftMessages = req.messages ?? req._messages ?? []
   if (isDirectAccess) DraftUUID = cds.utils.uuid()
   else {
     const rootData = await SELECT.one(req.query.INSERT.into.ref[0].id)
       .columns([
         { ref: ['DraftAdministrativeData_DraftUUID'] },
-        { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
+        {
+          ref: ['DraftAdministrativeData'],
+          expand: [
+            { ref: ['InProcessByUser'] },
+            ...(cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages
+              ? [{ ref: ['DraftMessages'] }]
+              : [])
+          ]
+        }
       ])
       .where(req.query.INSERT.into.ref[0].where)
+
     if (!rootData) req.reject({ code: 404, statusCode: 404 })
     if (!cds.context.user._is_privileged && rootData.DraftAdministrativeData?.InProcessByUser !== req.user.id)
       req.reject({
@@ -1554,27 +1929,10 @@ async function onNew(req) {
         message: 'DRAFT_LOCKED_BY_ANOTHER_USER',
         args: [rootData.DraftAdministrativeData.InProcessByUser]
       })
+
     DraftUUID = rootData.DraftAdministrativeData_DraftUUID
+    DraftMessages = rootData.DraftAdministrativeData?.DraftMessages || []
   }
-  const timestamp = cds.context.timestamp.toISOString() // REVISIT: toISOString should be done on db layer
-  const adminDataCQN = isDirectAccess
-    ? INSERT.into('DRAFT.DraftAdministrativeData').entries({
-        DraftUUID,
-        CreationDateTime: timestamp,
-        CreatedByUser: req.user.id,
-        LastChangeDateTime: timestamp,
-        LastChangedByUser: req.user.id,
-        DraftIsCreatedByMe: true, // Dummy values
-        DraftIsProcessedByMe: true, // Dummy values
-        InProcessByUser: req.user.id
-      })
-    : UPDATE('DRAFT.DraftAdministrativeData')
-        .data({
-          InProcessByUser: req.user.id,
-          LastChangedByUser: req.user.id,
-          LastChangeDateTime: timestamp
-        })
-        .where({ DraftUUID })
 
   const _setDraftColumns = (obj, target) => {
     const newObj = Object.assign({}, obj, { DraftAdministrativeData_DraftUUID: DraftUUID, HasActiveEntity: false })
@@ -1594,15 +1952,49 @@ async function onNew(req) {
     return newObj
   }
 
+  const timestamp = cds.context.timestamp.toISOString() // REVISIT: toISOString should be done on db layer
   const draftData = _setDraftColumns(req.query.INSERT.entries[0], req.target)
-
   const draftCQN = INSERT.into(req.subject).entries(draftData)
 
-  await _promiseAll([adminDataCQN, this.run(draftCQN)])
+  await this.run(draftCQN)
 
-  // flag to trigger read after write in legacy odata adapter
-  if (req.constructor.name in { ODataRequest: 1 }) req._.readAfterWrite = true
-  if (req.protocol?.match(/odata/)) req._.readAfterWrite = true //> REVISIT for noah
+  if (cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages) {
+    newDraftMessages = _compileUpdatedDraftMessages(
+      newDraftMessages,
+      DraftMessages,
+      draftData,
+      req.query.INSERT.into.ref
+    )
+  }
+
+  const adminDataCQN = isDirectAccess
+    ? INSERT.into('DRAFT.DraftAdministrativeData').entries({
+        DraftUUID,
+        CreationDateTime: timestamp,
+        CreatedByUser: req.user.id,
+        LastChangeDateTime: timestamp,
+        LastChangedByUser: req.user.id,
+        DraftIsCreatedByMe: true, // Dummy values
+        DraftIsProcessedByMe: true, // Dummy values
+        InProcessByUser: req.user.id,
+        ...(cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages
+          ? { DraftMessages: newDraftMessages }
+          : {})
+      })
+    : UPDATE('DRAFT.DraftAdministrativeData')
+        .data({
+          InProcessByUser: req.user.id,
+          LastChangedByUser: req.user.id,
+          LastChangeDateTime: timestamp,
+          ...(cds.model.definitions['DRAFT.DraftAdministrativeData'].elements.DraftMessages
+            ? { DraftMessages: newDraftMessages }
+            : {})
+        })
+        .where({ DraftUUID })
+
+  await adminDataCQN
+
+  if (req.protocol?.match(/odata/)) req._.readAfterWrite = true
 
   return { ...draftData, IsActiveEntity: false }
 }
@@ -1612,8 +2004,8 @@ 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[$draftParams] || { IsActiveEntity: true } // REVISIT: can draftParams in the edit caser ever be undefined or other than IsActiveEntity=true ?
+  // REVISIT: can draftParams in the edit case ever be undefined or other than IsActiveEntity=true ?
+  const draftParams = req.query[$draftParams] || { IsActiveEntity: true }
   if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== true) {
     req.reject({
       code: 400,
@@ -1650,6 +2042,7 @@ async function onEdit(req) {
       }
     }
   }
+
   _addDraftColumns(req.target, cols)
 
   const draftsRef = _redirectRefToDrafts(req.query.SELECT.from.ref, this.model)
@@ -1698,6 +2091,7 @@ async function onEdit(req) {
             })
             return w
           })()
+
     const activeLockCQN = SELECT.from(lockTarget, [1]).where(lockWhere).forUpdate({ wait: 0 })
     activeLockCQN.SELECT.localized = false
     activeLockCQN[$draftParams] = draftParams
@@ -1775,16 +2169,11 @@ async function onEdit(req) {
   // change to db run
   await INSERT.into(req.target.drafts).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
-  // REVISIT: needs reworking for new adapter, especially re $batch
-  if (req._?.odataRes) {
-    req._?.odataRes?.setStatusCode(201, { overwrite: true })
-  } else if (req.res) {
+  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
     req.res.status(201)
-  }
 
-  if (req.res) {
     const read_result = await _readAfterDraftAction.bind(this)({
       req,
       payload: res,
@@ -1804,7 +2193,6 @@ async function onCancel(req) {
   LOG.debug('delete draft')
 
   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[$draftParams] || { IsActiveEntity: false } // REVISIT: can draftParams in the cancel case ever be undefined or other than IsActiveEntity=false ?
 
   const draftQuery = SELECT.one
@@ -1816,16 +2204,16 @@ async function onCancel(req) {
   if (req._etagValidationClause && draftParams.IsActiveEntity === false) draftQuery.where(req._etagValidationClause)
   // do not add InProcessByUser restriction
   const draft = await draftQuery
-  if (draftParams.IsActiveEntity === false && !draft) req.reject(req._etagValidationType ? 412 : 404)
+  if (!draft) req.reject(req._etagValidationType ? 412 : 404)
   if (draft) {
     const processByUser = draft.DraftAdministrativeData?.InProcessByUser
     if (!cds.context.user._is_privileged && processByUser && processByUser !== cds.context.user.id)
       req.reject({ code: 403, statusCode: 403, message: 'DRAFT_LOCKED_BY_ANOTHER_USER', args: [processByUser] })
   }
+
   const draftDeleteQuery = DELETE.from({ ref: req.query.DELETE.from.ref }) // REVISIT: Isn't that == req.query ?
-  const queries = !draft
-    ? []
-    : [draftParams.IsActiveEntity === false ? this.run(draftDeleteQuery, req.data) : draftDeleteQuery]
+
+  const queries = !draft ? [] : [this.run(draftDeleteQuery, req.data)]
   if (draft && req.target['@Common.DraftRoot.ActivationAction'])
     // only for draft root
     queries.push(
@@ -1841,8 +2229,6 @@ async function onCancel(req) {
         })
         .where({ DraftUUID: draft.DraftAdministrativeData_DraftUUID })
     )
-  if (draftParams.IsActiveEntity !== false && !req.target.isDraft)
-    queries.push(this.run(DELETE.from({ ref: activeRef })))
   await _promiseAll(queries)
   return req.data
 }
@@ -1862,7 +2248,7 @@ async function onPrepare(req) {
 
   const draftQuery = SELECT.one
     .from(req.target, d => {
-      d`.*`, d.DraftAdministrativeData(a => a.InProcessByUser)
+      ;(d`.*`, d.DraftAdministrativeData(a => a.InProcessByUser))
     })
     .where(where)
   draftQuery[$draftParams] = draftParams
@@ -1959,8 +2345,8 @@ module.exports = cds.service.impl(function () {
   }
 
   // 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('NEW', '*', _wrapped(onNew, false))
   this.on('EDIT', '*', _wrapped(onEdit, true))
   this.on('CANCEL', '*', _wrapped(onCancel, false))
   this.on('draftPrepare', '*', _wrapped(onPrepare, false))