@sap/cds 5.7.2 → 5.8.0

package/libx/_runtime/db/generic/read.js

@@ -7,32 +7,10 @@
  *
  * @param req - cds.Request
  */
-module.exports = async function (req) {
+module.exports = function (req) {
   if (typeof req.query === 'string') {
     return this._execute.sql(this.dbc, req.query, req.data)
   }
 
-  // REVISIT: should be handled in protocol adapter
-  // execute validation query first to fail early
-  if (req.query._validationQuery) {
-    const validationResult = await this._read(this.model, this.dbc, req.query._validationQuery, req)
-
-    if (validationResult.length === 0) {
-      // > validation target (e.g., root of navigation) doesn't exist
-      req.reject(404)
-    }
-  }
-
-  const result = await this._read(this.model, this.dbc, req.query, req)
-
-  if (
-    req.query._validationQuery &&
-    req.query._validationQuery.__navToManyWithKeys &&
-    (!result || result.length === 0)
-  ) {
-    // > navigation to collection with key specified without result -> 404
-    req.reject(404)
-  }
-
-  return result
+  return this._read(this.model, this.dbc, req.query, req)
 }

package/libx/_runtime/db/generic/rewrite.js

@@ -1,5 +1,5 @@
 const { cqn2cqn4sql } = require('../../common/utils/cqn2cqn4sql')
-const generateAliases = require('../utils/generateAliases')
+const { generateAliases } = require('../utils/generateAliases')
 const { restoreLink } = require('../../common/utils/resolveView')
 
 const _isLinked = req => {
@@ -18,7 +18,6 @@ function handler(req) {
   }
 
   const streaming = req.query._streaming
-  const validationQuery = req.query._validationQuery
 
   // for restore link to req.data
   const linked = _isLinked(req)
@@ -31,7 +30,6 @@ function handler(req) {
   if (linked) restoreLink(req)
 
   if (streaming) req.query._streaming = streaming
-  if (validationQuery) req.query._validationQuery = validationQuery
 
   generateAliases(req.query)
 }

package/libx/_runtime/db/generic/update.js

@@ -70,7 +70,7 @@ module.exports = async function (req) {
   if (onlyKeysRemain(req)) return
 
   try {
-    const result = await this._update(this.model, this.dbc, req.query, req)
+    const result = await this._update(this.model, this.dbc, req)
     return result
   } catch (err) {
     // REVISIT: db specifics

package/libx/_runtime/db/query/delete.js

@@ -1,14 +1,14 @@
 const { getFlatArray, processCQNs } = require('../utils/deep')
 const { timestampToISO } = require('../data-conversion/timestamp')
-const { hasDeepDelete, getDeepDeleteCQNs } = require('../../common/composition')
+const { hasDeepDelete, getDeepDeleteCQNs, getSetNullParentForeignKeyCQNs } = require('../../common/composition')
 
-const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
+const deleteFn = (executeDeleteCQN, executeUpdateCQN) => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
   let result
-  if (hasDeepDelete(model && model.definitions, query)) {
-    let cqns = getDeepDeleteCQNs(model && model.definitions, query)
+  if (hasDeepDelete(model, query)) {
+    let cqns = await getDeepDeleteCQNs(model, req)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []
@@ -25,6 +25,12 @@ const deleteFn = executeDeleteCQN => async (model, dbc, query, req) => {
     result = results[results.length - 1]
   } else {
     result = await executeDeleteCQN(model, dbc, query, user, locale, isoTs)
+    if (result) {
+      const updateCQNs = await getSetNullParentForeignKeyCQNs(model, req)
+      for (const cqn of updateCQNs) {
+        await executeUpdateCQN(model, dbc, cqn, user, locale, isoTs)
+      }
+    }
   }
 
   return result

package/libx/_runtime/db/query/insert.js

@@ -6,8 +6,8 @@ const insert = executeInsertCQN => async (model, dbc, query, req) => {
   const { user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepInsert(model && model.definitions, query)) {
-    const cqns = getFlatArray(getDeepInsertCQNs(model && model.definitions, query))
+  if (hasDeepInsert(model, query)) {
+    const cqns = getFlatArray(getDeepInsertCQNs(model, query))
 
     // return array of individual results
     if (cqns.length === 0) return []
@@ -15,7 +15,7 @@ const insert = executeInsertCQN => async (model, dbc, query, req) => {
     return getFlatArray(results)
   }
 
-  cleanEmptyCompositionsOfMany(model && model.definitions, query)
+  cleanEmptyCompositionsOfMany(model, query)
   return executeInsertCQN(model, dbc, query, user, locale, isoTs)
 }
 

package/libx/_runtime/db/query/read.js

@@ -1,5 +1,7 @@
 const { timestampToISO } = require('../data-conversion/timestamp')
 
+const { deepCopyObject } = require('../../common/utils/copy')
+
 function _arrayWithCount(a, count) {
   const _map = a.map
   const map = (..._) => _arrayWithCount(_map.call(a, ..._), count)
@@ -10,22 +12,27 @@ function _arrayWithCount(a, count) {
 }
 
 function _createCountQuery(query) {
-  const _query = JSON.parse(JSON.stringify(query)) // REVISIT: Use query.clone() instead
-  _query.SELECT.columns = [{ func: 'count', args: [{ val: 1 }], as: '$count' }]
-  delete _query.SELECT.groupBy
-  delete _query.SELECT.limit
+  // REVISIT: Use query.clone() instead
+  let _query = { SELECT: deepCopyObject(query.SELECT) }
   delete _query.SELECT.orderBy // not necessary to keep that
+  delete _query.SELECT.limit
   // Also change columns in sub queries
   if (_query.SELECT.from.SET) {
     _query.SELECT.from.SET.args.forEach(subCountQuery => {
       subCountQuery.SELECT.columns = [{ val: 1 }]
     })
   }
+  if (query.SELECT.__countAggregated) {
+    _query = SELECT.from(_query)
+  }
+  _query.SELECT.columns = [{ func: 'count', args: [{ val: 1 }], as: '$count' }]
   if (query.SELECT._4odata) _query.SELECT._4odata = true
   return _query
 }
 
-const countValue = countResult => {
+const countValue = countResults => {
+  if (!countResults.length) return 0
+  const countResult = countResults[0]
   if (countResult._counted_ != null) return countResult._counted_
   if (countResult.$count != null) return countResult.$count
 }
@@ -50,11 +57,11 @@ const read = (executeSelectCQN, executeStreamCQN) => (model, dbc, query, req) =>
       const countResultPromise = executeSelectCQN(model, dbc, countQuery, user, locale, isoTs)
       if (query.SELECT.limit.rows && query.SELECT.limit.rows.val === 0) {
         // We don't need to perform our result query
-        return countResultPromise.then(countResult => _arrayWithCount([], countValue(countResult[0])))
+        return countResultPromise.then(countResults => _arrayWithCount([], countValue(countResults)))
       } else {
         const resultPromise = executeSelectCQN(model, dbc, query, user, locale, isoTs)
-        return Promise.all([countResultPromise, resultPromise]).then(([countResult, result]) =>
-          _arrayWithCount(result, countValue(countResult[0]))
+        return Promise.all([countResultPromise, resultPromise]).then(([countResults, result]) =>
+          _arrayWithCount(result, countValue(countResults))
         )
       }
     } else {

package/libx/_runtime/db/query/update.js

@@ -50,11 +50,11 @@ const _getFilteredCqns = (cqns, model) => {
   return cqns
 }
 
-const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query, req) => {
-  const { user, locale, timestamp } = req
+const update = executeUpdateCQN => async (model, dbc, req) => {
+  const { query, user, locale, timestamp } = req
   const isoTs = timestampToISO(timestamp)
 
-  if (hasDeepUpdate(model && model.definitions, query)) {
+  if (hasDeepUpdate(model, query)) {
     // REVISIT: _activeData gets set in case of draftActivate for performance, but this is a layer violation
     let selectData = req._ && req._.query && req._.query._activeData
 
@@ -62,10 +62,10 @@ const update = (executeUpdateCQN, executeSelectCQN) => async (model, dbc, query,
       selectData = [selectData]
     } else {
       // REVISIT: avoid additional read
-      selectData = await selectDeepUpdateData(model && model.definitions, query, req, false, false, cds.db)
+      selectData = await selectDeepUpdateData(cds.db, model, req)
     }
 
-    let cqns = getDeepUpdateCQNs(model && model.definitions, query, selectData)
+    let cqns = await getDeepUpdateCQNs(model, req, selectData)
 
     // the delete chunks, i.e., how many deletes can be processed in parallel
     const chunks = []

package/libx/_runtime/db/sql-builder/ExpressionBuilder.js

@@ -11,6 +11,10 @@ function _fillAfterDot(val) {
   return `${beforeDot}.${afterDot.padEnd(3, '0')}`
 }
 
+function _valButNoBuffer(arg) {
+  return arg && arg.val && typeof arg.val === 'object' && !(arg.val instanceof Buffer)
+}
+
 /**
  * ExpressionBuilder is used to take a part of a CQN object as an input and to build an object representing an expression
  * with SQL string and values to be used with a prepared statement.
@@ -87,9 +91,9 @@ class ExpressionBuilder extends BaseBuilder {
   }
 
   _isStructured(op1, comp, op2) {
-    if (op1.ref && comp === '=' && op2.val && typeof op2.val === 'object' && !(op2.val instanceof Buffer)) return true
+    if (op1.ref && comp === '=' && _valButNoBuffer(op2)) return true
     // also check reverse
-    if (op1.val && typeof op1.val === 'object' && comp === '=' && op2.ref && !(op1.val instanceof Buffer)) return true
+    if (_valButNoBuffer(op1) && comp === '=' && op2.ref) return true
   }
 
   _expressionObjectsToSQL(objects) {
@@ -379,4 +383,7 @@ class ExpressionBuilder extends BaseBuilder {
   }
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = ExpressionBuilder

package/libx/_runtime/db/sql-builder/FunctionBuilder.js

@@ -214,4 +214,7 @@ class FunctionBuilder extends BaseBuilder {
   }
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = FunctionBuilder

package/libx/_runtime/db/sql-builder/index.js

@@ -9,6 +9,9 @@ const ReferenceBuilder = require('./ReferenceBuilder')
 const FunctionBuilder = require('./FunctionBuilder')
 const sqlFactory = require('./sqlFactory')
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = {
   CreateBuilder,
   DropBuilder,

package/libx/_runtime/db/utils/columns.js

@@ -11,7 +11,7 @@ const { DRAFT_COLUMNS } = require('../../common/constants/draft')
  * @param entity - the csn entity
  * @returns {Array} - array of columns
  */
-const getColumns = (entity, { db, onlyKeys } = { db: true, onlyKeys: false }) => {
+const getColumns = (entity, { _4db, onlyKeys } = { _4db: true, onlyKeys: false }) => {
   // REVISIT is this correct or just a problem that occurs because of new structure we do not deal with yet?
   if (!(entity && entity.elements)) return []
   const columnNames = []
@@ -21,7 +21,7 @@ const getColumns = (entity, { db, onlyKeys } = { db: true, onlyKeys: false }) =>
     const element = elements[elementName]
     if (onlyKeys && !element.key) continue
     if (element.isAssociation) continue
-    if (db && entity._isDraftEnabled && DRAFT_COLUMNS.includes(elementName)) continue
+    if (_4db && entity._isDraftEnabled && DRAFT_COLUMNS.includes(elementName)) continue
     if (cds.env.effective.odata.structs && element.elements) {
       columnNames.push(...resolveStructured({ structName: elementName, structProperties: [] }, element.elements, false))
       continue
@@ -31,4 +31,7 @@ const getColumns = (entity, { db, onlyKeys } = { db: true, onlyKeys: false }) =>
   return columnNames.map(name => elements[name] || { name })
 }
 
+/*
+ * this module is required by cds-pg. -> in case of incompatible changes, we should let them know.
+ */
 module.exports = getColumns

package/libx/_runtime/db/utils/deep.js

@@ -28,20 +28,14 @@ async function processCQNs(processFn, cqns, model, dbc, user, locale, ts, chunks
   const results = new Array(cqns.length)
 
   const deletes = []
-  const updatesBeforeDelete = []
+  const updatesForDeletes = []
   const others = []
   for (let i = 0; i < cqns.length; i++) {
     if (cqns[i].DELETE) deletes.push(i)
-    else if (cqns[i].UPDATE && cqns[i].UPDATE._beforeDelete) updatesBeforeDelete.push(i)
+    else if (cqns[i].__4delete) updatesForDeletes.push(i)
     else others.push(i)
   }
 
-  // UPDATEs to SET null parent's foreign keys of one compositions
-  // which are otherwise violate foreign key constraints
-  if (updatesBeforeDelete.length) {
-    await _processChunk(processFn, model, dbc, cqns, user, locale, ts, updatesBeforeDelete, results)
-  }
-
   if (deletes.length > 0) {
     if (chunks) {
       let offset = 0
@@ -55,6 +49,10 @@ async function processCQNs(processFn, cqns, model, dbc, user, locale, ts, chunks
     }
   }
 
+  if (updatesForDeletes.length > 0) {
+    await _processChunk(processFn, model, dbc, cqns, user, locale, ts, updatesForDeletes, results)
+  }
+
   if (others.length > 0) {
     await _processChunk(processFn, model, dbc, cqns, user, locale, ts, others, results)
   }

package/libx/_runtime/db/utils/generateAliases.js

@@ -1,10 +1,9 @@
 const { ensureUnlocalized } = require('../../common/utils/draft')
-
 const ALIAS_PREFIX = 'ALIAS_'
-
-const cleanUpName = name => {
-  return ensureUnlocalized(name).replace(/\./g, '_')
-}
+const PARENT_ALIAS = '_parent_'
+const FOREIGN_ALIAS = '_foreign_'
+const PARENT_ALIAS_REGEX = new RegExp('^' + PARENT_ALIAS + '\\d*$')
+const cleanUpName = name => ensureUnlocalized(name).replace(/\./g, '_')
 
 const _redirectXpr = (xpr, aliasMap) => {
   if (!xpr) return
@@ -97,4 +96,55 @@ const generateAliases = query => {
   _generateAliases(query)
 }
 
-module.exports = generateAliases
+const _addParentAlias = (where, alias) => {
+  where.forEach(e => {
+    if (e.ref && e.ref[0].match(PARENT_ALIAS_REGEX)) {
+      e.ref[0] = alias
+    }
+  })
+}
+
+const _addAliasToElement = (expr, alias) => {
+  if (expr.ref) {
+    if (typeof alias === 'function') {
+      alias = alias(expr.ref)
+    }
+
+    return { ref: [alias, ...expr.ref] }
+  }
+
+  if (expr.list) {
+    return { list: expr.list.map(arg => _addAliasToElement(arg, alias)) }
+  }
+
+  if (expr.func) {
+    const args = expr.args.map(arg => _addAliasToElement(arg, alias))
+    return { ...expr, args }
+  }
+
+  if (expr.SELECT && expr.SELECT.where) {
+    // special case in lambda functions
+    _addParentAlias(expr.SELECT.where, alias)
+  }
+
+  if (expr.xpr) {
+    return { xpr: expr.xpr.map(xpr => _addAliasToElement(xpr, alias)) }
+  }
+
+  return expr
+}
+
+const addAliasToExpression = (expression, alias) => {
+  if (expression && alias) {
+    return expression.map(expr => _addAliasToElement(expr, alias))
+  }
+
+  return expression
+}
+
+module.exports = {
+  generateAliases,
+  addAliasToExpression,
+  PARENT_ALIAS,
+  FOREIGN_ALIAS
+}

package/libx/_runtime/fiori/generic/before.js

@@ -12,9 +12,7 @@ const { DRAFT_COLUMNS_ADMIN } = require('../../common/constants/draft')
 
 // copied from adapter/odata-v4/utils/context-object
 const _getTargetEntityName = (service, pathSegments) => {
-  if (isCustomOperation(pathSegments, false)) {
-    return undefined
-  }
+  if (isCustomOperation(pathSegments, false)) return
 
   let navSegmentName
   let entityName = `${service.name}.${pathSegments[0].getEntitySet().getName()}`
@@ -36,12 +34,11 @@ const _getTargetEntityName = (service, pathSegments) => {
  * @returns {object}
  * @private
  */
-const _getParent = (service, req) => {
+const _getParent = (req, service) => {
   // REVISIT: get rid of getUriInfo
   if (!req.getUriInfo) return
 
   const segments = req.getUriInfo().getPathSegments()
-
   if (segments.length === 1) return
 
   const parent = {
@@ -50,6 +47,7 @@ const _getParent = (service, req) => {
 
   const parentKeyPredicates = segments[segments.length - 2].getKeyPredicates()
   let keyPredicateName, keyPredicateText
+
   for (const keyPredicate of parentKeyPredicates) {
     keyPredicateName = keyPredicate.getEdmRef().getName()
     keyPredicateText = keyPredicate.getText()
@@ -65,36 +63,28 @@ const _getParent = (service, req) => {
   return parent
 }
 
-const _validateDraft = (draftResult, req) => {
-  if (!draftResult || draftResult.length === 0) {
-    req.reject(404)
-  }
-
+const _validateDraft = (req, draftResult, isBoundAction) => {
+  if (!draftResult || draftResult.length === 0) req.reject(404)
   const draftAdminData = draftResult[0]
 
-  // the same user that locked the entity can always delete it
-  if (draftAdminData.InProcessByUser === req.user.id) {
-    return
-  }
+  // the same user that locked the entity can always delete/update it
+  if (draftAdminData.InProcessByUser === req.user.id) return
 
-  // proceed with the delete action only if it was initiated by a different user
-  // than the one who locked the entity and the configured drafts cancellation
+  // proceed with the delete/update action only if it was initiated by a different
+  // user than the one who locked the entity and the configured drafts cancellation
   // timeout timer has expired
   if (draftIsLocked(draftAdminData.LastChangeDateTime)) {
     req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER')
   }
+
+  // At this point, the request user ID isn't the owner of the draft.
+  if (isBoundAction) req.reject(403)
 }
 
 const _addDraftDataToContext = (req, result) => {
-  _validateDraft(result, req)
-
-  if (req.rejected) {
-    return
-  }
-
-  if (!req._draftMetadata) {
-    req._draftMetadata = {}
-  }
+  if (!result || result.length === 0) return
+  if (req.rejected) return
+  if (!req._draftMetadata) req._draftMetadata = {}
 
   DRAFT_COLUMNS_ADMIN.forEach(column => {
     if (column in result[0]) req._draftMetadata[column] = result[0][column]
@@ -103,11 +93,7 @@ const _addDraftDataToContext = (req, result) => {
   req.data.DraftAdministrativeData_DraftUUID = result[0].DraftUUID
 }
 
-const _prefixDraftColumns = () => {
-  return DRAFT_COLUMNS_ADMIN.map(col => {
-    return { ref: ['DRAFT_DraftAdministrativeData', col] }
-  })
-}
+const _prefixDraftColumns = () => DRAFT_COLUMNS_ADMIN.map(col => ({ ref: ['DRAFT_DraftAdministrativeData', col] }))
 
 const _getSelectDraftDataCqn = (entityName, where) => {
   return SELECT.from(ensureDraftsSuffix(entityName), _prefixDraftColumns())
@@ -116,27 +102,41 @@ const _getSelectDraftDataCqn = (entityName, where) => {
     .where(where)
 }
 
-const _addDraftDataFromExistingDraft = async (req, service) => {
-  const parent = _getParent(service, req)
-  let result
-
-  if (parent && parent.IsActiveEntity === 'false') {
-    const parentWhere = [{ ref: [parent.keyName] }, '=', { val: parent.keyValue }]
-    result = await cds.tx(req).run(_getSelectDraftDataCqn(parent.entityName, parentWhere))
-    _addDraftDataToContext(req, result)
-    return result
+const _getDraftDataFromExistingDraft = async (req, service, parent = _getParent(req, service)) => {
+  if (parent) {
+    if (parent.IsActiveEntity === 'false') {
+      const parentWhere = [{ ref: [parent.keyName] }, '=', { val: parent.keyValue }]
+      const query = _getSelectDraftDataCqn(parent.entityName, parentWhere)
+      const result = await cds.tx(req).run(query)
+      return result
+    }
+
+    return []
   }
 
-  if (!parent) {
-    const rootWhere = getKeysCondition(req.target, req.data)
-    result = await cds.tx(req).run(_getSelectDraftDataCqn(ensureNoDraftsSuffix(req.target.name), rootWhere))
-    if (result && result.length > 0) {
+  const rootWhere = getKeysCondition(req.target, req.data)
+  const query = _getSelectDraftDataCqn(ensureNoDraftsSuffix(req.target.name), rootWhere)
+  const result = await cds.tx(req).run(query)
+  return result
+}
+
+const _addDraftDataFromExistingDraft = async (req, service) => {
+  const parent = _getParent(req, service)
+  const result = await _getDraftDataFromExistingDraft(req, service, parent)
+
+  if (parent) {
+    if (parent.IsActiveEntity === 'false') {
+      _validateDraft(req, result)
       _addDraftDataToContext(req, result)
+      return result
     }
-    return result
+
+    return []
   }
 
-  return []
+  if (result && result.length > 0) _validateDraft(req, result)
+  _addDraftDataToContext(req, result)
+  return result
 }
 
 const _addGeneratedDraftUUID = async req => {
@@ -156,11 +156,12 @@ const _new = async function (req) {
   if (isNavigationToMany(req)) {
     const result = await _addDraftDataFromExistingDraft(req, this)
 
-    // in order to fix strange case where active subitems are created in draft case
+    // in order to fix corner case where active subitems are created in draft case
     if (result.length === 0) req.reject(404)
-  } else {
-    _addGeneratedDraftUUID(req)
+    return
   }
+
+  _addGeneratedDraftUUID(req)
 }
 
 /**
@@ -173,7 +174,7 @@ const _patchUpdate = async function (req) {
 
   const result = await _addDraftDataFromExistingDraft(req, this)
 
-  // means that draft not exists
+  // means that the draft does not exists
   if (result.length === 0) req.reject(404)
 }
 
@@ -186,6 +187,28 @@ const _deleteCancel = async function (req) {
   await _addDraftDataFromExistingDraft(req, this)
 }
 
+const _validateDraftBoundAction = async function (req, srv) {
+  const result = await _getDraftDataFromExistingDraft(req, srv)
+  const isBoundAction = true
+  if (result && result.length > 0) _validateDraft(req, result, isBoundAction)
+}
+
+const _registerBoundActionHandlers = function (entityName, actions) {
+  if (!actions) return
+
+  const boundActions = Object.values(actions).filter(
+    action =>
+      action.kind === 'action' &&
+      action.name !== 'draftPrepare' &&
+      action.name !== 'draftEdit' &&
+      action.name !== 'draftActivate'
+  )
+
+  for (const action of boundActions) {
+    this.before(action.name, entityName, req => _validateDraftBoundAction(req, this))
+  }
+}
+
 module.exports = cds.service.impl(function () {
   _new._initial = true
   _patchUpdate._initial = true
@@ -196,5 +219,6 @@ module.exports = cds.service.impl(function () {
     this.before('NEW', entity, _new)
     this.before(['PATCH', 'UPDATE'], entity, _patchUpdate)
     this.before(['DELETE', 'CANCEL'], entity, _deleteCancel)
+    _registerBoundActionHandlers.call(this, entity.name, entity.actions)
   }
 })

package/libx/_runtime/fiori/generic/edit.js

@@ -56,21 +56,18 @@ const _getLockWhere = (where, columnsMap) => {
   return lockWhere
 }
 
-const _select = async (CQNs, req, dbtx) => {
-  let allResults
-
+const _select = async (lockRecordCQN, draftExistsCQN, selectCQNs, req, dbtx) => {
   try {
-    allResults = await Promise.all(CQNs.map(CQN => dbtx.run(CQN)))
-  } catch (err) {
-    // resource busy and NOWAIT (WAIT 0) specified (heuristic error handling method)
-    if (err.query.includes('FOR UPDATE')) {
-      req.reject(409, 'DRAFT_ALREADY_EXISTS')
-    }
-
-    req.reject(err)
+    await dbtx.run(lockRecordCQN)
+  } catch (e) {
+    const drafts = await dbtx.run(draftExistsCQN)
+    if (drafts.length) req.reject(409, 'DRAFT_ALREADY_EXISTS')
+    req.reject(409, 'ENTITY_LOCKED')
   }
-
-  return allResults
+  const promisesResults = await Promise.allSettled([dbtx.run(draftExistsCQN), ...selectCQNs.map(cqn => dbtx.run(cqn))])
+  const firstRejected = promisesResults.find(r => r.status === 'rejected')
+  if (firstRejected) req.reject(firstRejected.reason)
+  return promisesResults.map(r => r.value)
 }
 
 /**
@@ -127,11 +124,9 @@ const _handler = async function (req) {
     }
   }
 
-  const lockAndSelectCQNs = [lockRecordCQN, draftExistsCQN, ...selectCQNs]
-
   const dbtx = cds.tx(req)
   // REVISIT: Use service.read with expand **
-  const [, draftExists, ...results] = await _select(lockAndSelectCQNs, req, dbtx)
+  const [draftExists, ...results] = await _select(lockRecordCQN, draftExistsCQN, [...selectCQNs], req, dbtx)
 
   if (!results[0].length) {
     req.reject(404)
@@ -169,12 +164,13 @@ const _handler = async function (req) {
 
   await Promise.all(insertCQNs.map(CQN => dbtx.run(CQN)))
   setStatusCodeAndHeader(req._.odataRes, rootWhere, req.target.name.replace(`${this.name}.`, ''), false)
-
   return Object.assign({}, results[0][0], { HasDraftEntity: false, HasActiveEntity: true, IsActiveEntity: false })
 }
 
 module.exports = cds.service.impl(function () {
-  for (const entity of Object.values(this.entities).filter(e => e._isDraftEnabled)) {
+  const entities = Object.values(this.entities).filter(e => e._isDraftEnabled)
+
+  for (const entity of entities) {
     this.on('EDIT', entity, _handler)
   }
 })