@sap/cds 8.1.0 → 8.2.0

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

@@ -1,3 +1,4 @@
+const { Readable, PassThrough } = require('stream')
 const cds = require('../cds'),
   { Object_keys } = cds.utils
 
@@ -241,6 +242,67 @@ const _cleanUpOldDrafts = (service, tenant) => {
   lastCheckMap.set(tenant, Date.now())
 }
 
+const _hasStreaming = (cols, target, deep) => {
+  return cols?.some(col => {
+    const name = col.as || col.ref?.at(-1)
+    if (!target.elements[name]) return
+    return (
+      target.elements[name]._type === 'cds.LargeBinary' ||
+      (deep && col.expand && _hasStreaming(col.expand, target.elements[name]._target, deep))
+    )
+  })
+}
+
+const _waitForReadable = readable => {
+  return new Promise((resolve, reject) => {
+    readable.once('readable', resolve)
+    readable.once('error', reject)
+  })
+}
+
+const _removeEmptyStreams = async result => {
+  if (!result) return
+
+  const res = Array.isArray(result) ? result : [result]
+  for (let r of res) {
+    for (let key in r) {
+      const el = r[key]
+      if (el instanceof Readable) {
+        // In case hana-client Readable may not be ready
+        if (cds.db?.constructor?.name === 'HANAService') await _waitForReadable(el)
+        const chunk0 = el.read()
+        if (chunk0 === null) delete r[key]
+        else el.unshift(chunk0)
+      } else if (typeof el === 'object') {
+        const res = Array.isArray(el) ? el : [el]
+        for (let r of res) {
+          await _removeEmptyStreams(r)
+        }
+      }
+    }
+  }
+}
+
+// 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
+
+  const res = Array.isArray(result) ? result : [result]
+  for (let r of res) {
+    for (let key in r) {
+      const el = r[key]
+      if (el instanceof Readable) {
+        const stream = new Readable()
+        stream.push(null)
+        r[key] = stream
+      } else if (typeof el === 'object') {
+        const res = Array.isArray(el) ? el : [el]
+        res.forEach(_replaceStreams)
+      }
+    }
+  }
+}
+
 const h = cds.ApplicationService.prototype.handle
 
 cds.ApplicationService.prototype.handle = async function (req) {
@@ -333,78 +395,86 @@ cds.ApplicationService.prototype.handle = async function (req) {
       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 read =
+      draftParams.IsActiveEntity === false &&
+      _hasStreaming(query.SELECT.columns, query._target) &&
+      !cds.env.features.binary_draft_compat
+        ? Read.draftStream
+        : 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 === 'draftEdit') req.event = 'EDIT'
+  if (req.event === 'draftPrepare' && draftParams.IsActiveEntity) req.reject({ code: 400, statusCode: 400 })
 
+  // Create active instance of draft-enabled entity
+  // Careful: New OData adapter only sets `NEW` for drafts... how to distinguish programmatic modifications?
   if (
-    req.event === 'NEW' ||
-    req.event === 'CANCEL' ||
-    req.event === 'draftPrepare' ||
-    (req.event === 'CREATE' && req.target._isDraftEnabled)
+    (req.event === 'NEW' && req.data.IsActiveEntity === true) || // old OData adapter changes CREATE to NEW also for actives
+    (req.event === 'CREATE' && req.target.drafts && req.data?.IsActiveEntity !== false && !req.target.isDraft)
   ) {
-    if (req.event === 'draftPrepare' && draftParams.IsActiveEntity) req.reject({ code: 400, statusCode: 400 })
-    if ((req.event === 'NEW' || req.event === 'CREATE') && req.data?.IsActiveEntity === true) {
-      if (!cds.env.fiori.bypass_draft && !req.target['@odata.draft.bypass']) return reject_bypassed_draft(req)
-      const containsDraftRoot =
-        this.model.definitions[query.INSERT.into?.ref?.[0]?.id || query.INSERT.into?.ref?.[0] || query.INSERT.into][
-          '@Common.DraftRoot.ActivationAction'
-        ]
-
-      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 draftsRootRef =
-        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
-      if (!isDirectAccess) {
-        rootHasDraft = await SELECT.one([1]).from({ ref: draftsRootRef })
-      }
+    if (req.protocol === 'odata' && !cds.env.fiori.bypass_draft && !req.target['@odata.draft.bypass'])
+      return reject_bypassed_draft(req)
+    const containsDraftRoot =
+      this.model.definitions[query.INSERT.into?.ref?.[0]?.id || query.INSERT.into?.ref?.[0] || query.INSERT.into][
+        '@Common.DraftRoot.ActivationAction'
+      ]
+
+    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 draftsRootRef =
+      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
+    if (!isDirectAccess) {
+      rootHasDraft = await SELECT.one([1]).from({ ref: draftsRootRef })
+    }
 
-      // 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) => {
-          res[k] = req.data[k]
-          return res
-        }, {})
-        rootHasDraft = await SELECT.one([1]).from({ ref: draftsRootRef }).where(keyData)
-      }
+    // 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) => {
+        res[k] = req.data[k]
+        return res
+      }, {})
+      rootHasDraft = await SELECT.one([1]).from({ ref: draftsRootRef }).where(keyData)
+    }
 
-      if (rootHasDraft) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
+    if (rootHasDraft) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
 
-      const cqn = INSERT.into(query.INSERT.into).entries(data)
-      await run(cqn, { event: 'CREATE' })
-      const result = { ...data, IsActiveEntity: true }
-      req.data = result //> make keys available via req.data (as with normal crud)
-      return result
-    }
+    const cqn = INSERT.into(query.INSERT.into).entries(data)
+    await run(cqn, { event: 'CREATE' })
+    const result = { ...data, IsActiveEntity: true }
+    req.data = result //> make keys available via req.data (as with normal crud)
+    return result
+  }
+
+  // It needs to be redirected to drafts
+  if (req.event === 'NEW' || req.event === 'CANCEL' || req.event === 'draftPrepare') {
     req.target = req.target.drafts
 
     if (query.INSERT?.into) {
@@ -418,6 +488,7 @@ cds.ApplicationService.prototype.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 &&
@@ -431,7 +502,8 @@ cds.ApplicationService.prototype.handle = async function (req) {
     return result
   }
 
-  if (req.event === 'DELETE' && draftParams.IsActiveEntity) {
+  // 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'] },
@@ -440,6 +512,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
         expand: [_inProcessByUserXpr(_lock.shiftedNow)]
       }
     ])
+    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) {
@@ -462,7 +535,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
     // It would be great if we'd have a SELECT ** to deeply expand the entity (along compositions), that should
     // be implemented in expand implementation.
-    if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== false) {
+    if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity === true) {
       req.reject({
         code: 400,
         statusCode: 400,
@@ -480,16 +553,16 @@ cds.ApplicationService.prototype.handle = async function (req) {
     // 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 res = await run(
-      SELECT.one
-        .from({ ref: draftRef })
-        .columns(cols)
-        .columns([
-          'HasActiveEntity',
-          'DraftAdministrativeData_DraftUUID',
-          { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
-        ])
-    )
+    const draftQuery = SELECT.one
+      .from({ ref: draftRef })
+      .columns(cols)
+      .columns([
+        'HasActiveEntity',
+        'DraftAdministrativeData_DraftUUID',
+        { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
+      ])
+      .where(query.SELECT.where)
+    const res = await run(draftQuery)
     if (!res)
       req.reject(_etagValidationType ? { code: 412, statusCode: 412 } : { code: 'DRAFT_NOT_EXISTING', statusCode: 404 })
     if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) {
@@ -507,15 +580,19 @@ cds.ApplicationService.prototype.handle = async function (req) {
     const HasActiveEntity = res.HasActiveEntity
     delete res.HasActiveEntity
 
+    if (_hasStreaming(draftQuery.SELECT.columns, draftQuery._target, true) && !cds.env.features.binary_draft_compat)
+      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: query.SELECT.from.ref }).data(res)
-        : INSERT.into({ ref: query.SELECT.from.ref }).entries(res),
+        ? UPDATE({ ref: activesRef }).data(res).where(query.SELECT.where)
+        : INSERT.into({ ref: activesRef }).entries(res),
       { headers: Object.assign({}, req.headers, { 'if-match': '*' }) }
     )
     await _promiseAll([
-      DELETE.from({ ref: draftRef }),
+      DELETE.from({ ref: draftRef }).where(query.SELECT.where),
       DELETE.from('DRAFT.DraftAdministrativeData').where({ DraftUUID: DraftAdministrativeData_DraftUUID })
     ])
 
@@ -536,7 +613,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
         payload: res,
         action: 'draftActivate'
       })
-      req.res.set(
+      req.res?.set(
         'location',
         '../' + calculateLocationHeader(req.target, this, read_result || { ...res, IsActiveEntity: true })
       )
@@ -563,8 +640,6 @@ cds.ApplicationService.prototype.handle = async function (req) {
   }
 
   if (req.event === 'PATCH' || (req.event === 'UPDATE' && req.target.drafts)) {
-    if (!('IsActiveEntity' in draftParams)) req.reject({ code: 501, statusCode: 501 })
-
     if (draftParams.IsActiveEntity === false) {
       LOG.debug('patch draft')
 
@@ -600,16 +675,19 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
     LOG.debug('patch active')
 
-    if (!cds.env.fiori.bypass_draft && !req.target['@odata.draft.bypass']) return reject_bypassed_draft(req)
+    if (req.protocol === 'odata' && !cds.env.fiori.bypass_draft && !req.target['@odata.draft.bypass'])
+      return reject_bypassed_draft(req)
 
     const entityRef = query.UPDATE.entity.ref
 
-    if (!this.model.definitions[entityRef[0].id]['@Common.DraftRoot.ActivationAction']) {
+    if (!this.model.definitions[entityRef[0].id || entityRef[0]]['@Common.DraftRoot.ActivationAction']) {
       req.reject({ code: 403, statusCode: 403, message: 'DRAFT_MODIFICATION_ONLY_VIA_ROOT' })
     }
 
     const draftsRef = _redirectRefToDrafts(entityRef, this.model)
-    const hasDraft = !!(await SELECT.one([1]).from({ ref: [draftsRef[0]] }))
+    const draftsQuery = SELECT.one([1]).from({ ref: [draftsRef[0]] })
+    if (query.UPDATE.where) draftsQuery.where(query.UPDATE.where)
+    const hasDraft = !!(await draftsQuery)
     if (hasDraft) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
 
     await run(query)
@@ -651,6 +729,52 @@ const _requested = (result, query) => {
   return result
 }
 
+const _readDraftStream = (draftStream, activeCQN, property) =>
+  Readable.from(
+    (async function* () {
+      let isActive = true
+      this._stream = draftStream
+      for await (const chunk of draftStream) {
+        isActive = false
+        yield chunk
+      }
+
+      if (isActive) {
+        const active = (await activeCQN)?.[property]
+        if (active) {
+          for await (const chunk of active) {
+            yield chunk
+          }
+        }
+      }
+    })()
+  )
+
+// REVISIT: HanaLobStream of @sap/hana-client cannot read chunks with "for await" - hangs
+const _readDraftStreamHanaClient = async (draftStream, activeCQN, property) =>
+  Readable.from(
+    (async function* () {
+      let isActive = true
+      const pth = new PassThrough()
+      draftStream.pipe(pth)
+      for await (const chunk of pth) {
+        isActive = false
+        yield chunk
+      }
+
+      if (isActive) {
+        const active = (await activeCQN)?.[property]
+        if (active) {
+          const pth = new PassThrough()
+          active.pipe(pth)
+          for await (const chunk of pth) {
+            yield chunk
+          }
+        }
+      }
+    })()
+  )
+
 const Read = {
   onlyActives: async function (run, query, { ignoreDrafts } = {}) {
     LOG.debug('List Editing Status: Only Active')
@@ -737,6 +861,7 @@ const Read = {
       '=',
       cds.context.user.id
     )
+
     const drafts = await run(draftsQuery)
     Read.merge(query._target, drafts, [], row => {
       Object.assign(row, {
@@ -862,8 +987,11 @@ const Read = {
       const locale = cds.context.locale.replaceAll('_', '-')
       const collatorMap = new Map()
       const elementNamesToSort = orderByExpr.map(orderByExp => orderByExp.ref.join('_'))
+
       for (const elementName of elementNamesToSort) {
-        const element = queryElements[elementName]
+        const element = queryElements[elementName] ?? query._target.elements[elementName] // The latter is needed for CDS orderBy statements
+        if (!element) continue
+
         let collatorOptions
 
         switch (element.type) {
@@ -994,6 +1122,23 @@ const Read = {
     return drafts
   },
 
+  draftStream: async (run, query) => {
+    // read from draft
+    const result = await Read.ownDrafts(run, query)
+    if (!Array.isArray(result)) {
+      for (let key in result) {
+        if (result[key] instanceof Readable) {
+          result[key] =
+            result[key].constructor.name === 'HanaLobStream'
+              ? await _readDraftStreamHanaClient(result[key], query, key)
+              : _readDraftStream(result[key], query, key)
+        }
+      }
+    }
+
+    return result
+  },
+
   _makeArray: data => (Array.isArray(data) ? data : data ? [data] : []),
 
   _index: (target, data) => {
@@ -1081,14 +1226,23 @@ function _cleansed(query, model) {
       }
       cds.infer(draftsQuery, model.definitions)
       // draftsQuery._target = draftsQuery._target?.drafts || draftsQuery._target
-      if (query.SELECT.columns && query._target.drafts)
-        draftsQuery.SELECT.columns = _cleanseCols(query.SELECT.columns, REDUCED_DRAFT_ELEMENTS, draft)
+      if (query.SELECT.columns && query._target.drafts) {
+        if (draftsQuery._target.isDraft)
+          draftsQuery.SELECT.columns = _cleanseCols(query.SELECT.columns, REDUCED_DRAFT_ELEMENTS, draft)
+        else draftsQuery.SELECT.columns = _cleanseCols(query.SELECT.columns, DRAFT_ELEMENTS, draft)
+      }
 
-      if (query.SELECT.where && query._target.drafts)
-        draftsQuery.SELECT.where = _cleanseWhere(query.SELECT.where, {}, DRAFT_ELEMENTS_WITHOUT_HASACTIVE)
+      if (query.SELECT.where && query._target.drafts) {
+        if (draftsQuery._target.isDraft)
+          draftsQuery.SELECT.where = _cleanseWhere(query.SELECT.where, {}, DRAFT_ELEMENTS_WITHOUT_HASACTIVE)
+        else draftsQuery.SELECT.where = _cleanseWhere(query.SELECT.where, {}, DRAFT_ELEMENTS)
+      }
 
-      if (query.SELECT.orderBy && query._target.drafts)
-        draftsQuery.SELECT.orderBy = _cleanseWhere(query.SELECT.orderBy, {}, REDUCED_DRAFT_ELEMENTS)
+      if (query.SELECT.orderBy && query._target.drafts) {
+        if (draftsQuery._target.isDraft)
+          draftsQuery.SELECT.orderBy = _cleanseWhere(query.SELECT.orderBy, {}, REDUCED_DRAFT_ELEMENTS)
+        else draftsQuery.SELECT.orderBy = _cleanseWhere(query.SELECT.orderBy, {}, DRAFT_ELEMENTS)
+      }
 
       if (draftsQuery._target.name.endsWith('.DraftAdministrativeData')) {
         draftsQuery.SELECT.columns = _tweakAdminCols(draftsQuery.SELECT.columns)
@@ -1257,9 +1411,39 @@ function expandStarStar(target, draftActivate, recursion = new Map()) {
   const columns = []
   for (const el in target.elements) {
     const element = target.elements[el]
+
+    // no need to read 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)
@@ -1388,7 +1572,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 cols = expandStarStar(req.target, false)
   const _addDraftColumns = (target, columns) => {
     if (target.drafts) {
       columns.push({ val: true, as: 'HasActiveEntity' })
@@ -1450,11 +1634,13 @@ async function onEdit(req) {
             return w
           })()
     const activeLockCQN = SELECT.from(lockTarget, [1]).where(lockWhere).forUpdate({ wait: 0 })
+    activeLockCQN.SELECT.localized = false
     activeLockCQN[DRAFT_PARAMS] = draftParams
 
     try {
       await this.run(activeLockCQN)
-    } catch {
+    } catch (error) {
+      LOG._debug && LOG.debug('Failed to acquire database lock:', error)
       const draft = await this.run(existingDraft)
       if (draft) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
       req.reject({ code: 409, statusCode: 409, message: 'ENTITY_LOCKED' })
@@ -1468,6 +1654,7 @@ async function onEdit(req) {
     ;[res, draft] = await _promiseAll(cqns)
   } else {
     const activeLockCQN = SELECT.from({ ref: req.query.SELECT.from.ref }, [1]).forUpdate({ wait: 0 })
+    activeLockCQN.SELECT.localized = false
     activeLockCQN[DRAFT_PARAMS] = draftParams
 
     // Locking the underlying database table is effective only when the database is not
@@ -1475,7 +1662,9 @@ async function onEdit(req) {
     // a separate system.
     try {
       await activeLockCQN
-    } catch {} // eslint-disable-line no-empty
+    } catch (error) {
+      LOG._debug && LOG.debug('Failed to acquire database lock:', error)
+    }
 
     ;[res, draft] = await _promiseAll([
       // REVISIT: inofficial compat flag just in case it breaks something -> do not document
@@ -1499,6 +1688,8 @@ async function onEdit(req) {
     ])
   }
 
+  if (!cds.env.features.stream_compat && !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({
     DraftUUID,
@@ -1630,12 +1821,12 @@ const _readAfterDraftAction = async function ({ req, payload, action }) {
 
   // read after write with query options
   const keys = {}
-  entity.keys.forEach(key => {
-    if (key.name === 'IsActiveEntity' || key.isAssociation || key.virtual) return
+  for (let key of entity.keys) {
+    if (key.name === 'IsActiveEntity' || key.isAssociation || key.virtual) continue
     keys[key.name] = payload[key.name]
-  })
+  }
   const read = SELECT.one.from(entity, keys)
-  if (req.req.query.$select || req.req.query.$expand) {
+  if (req.req?.query.$select || req.req?.query.$expand) {
     const queryOptions = []
     if (req.req.query.$select) queryOptions.push(`$select=${req.req.query.$select}`)
     if (req.req.query.$expand) queryOptions.push(`$expand=${req.req.query.$expand}`)