@sap/cds 7.9.4 → 8.0.4

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

@@ -1,13 +1,14 @@
 const cds = require('../cds'),
   { Object_keys } = cds.utils
+
 const { getTransition } = require('../common/utils/resolveView')
-const { getKeyData } = require('./utils/where')
 
 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')
@@ -17,17 +18,22 @@ const AGGREGATION_FUNCTIONS = ['sum', 'min', 'max', 'avg', '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
+
     case 'd':
       return val * 1000 * 3600 * 24
+
     case 'h':
     case 'hrs':
       return val * 1000 * 3600
+
     case 'min':
       return val * 1000 * 60
+
     default:
       return val
   }
@@ -64,12 +70,6 @@ const LOCK_TIMEOUT = {
   get value() {
     let timeout_ms = _config_to_ms('draft_lock_timeout', '15min')
 
-    const deprecated = cds.env.drafts?.cancellationTimeout // in min
-    if (deprecated) {
-      // in order to still support legacy use cases for tests, e. g. 0.000001
-      timeout_ms = deprecated * 1000 * 60
-    }
-
     Object.defineProperty(LOCK_TIMEOUT, 'value', { value: timeout_ms })
     return timeout_ms
   }
@@ -78,7 +78,7 @@ const LOCK_TIMEOUT = {
 const reject_bypassed_draft = req => {
   const message =
     !cds.profiles?.includes('production') &&
-    '`cds.env.fiori.bypass_draft` must be enabled or the entity must be annotated with `@odata.draft.bypass` to support the directly modification of active instances.'
+    '`cds.env.fiori.bypass_draft` must be enabled or the entity must be annotated with `@odata.draft.bypass` to support direct modifications of active instances.'
   return req.reject({ code: 501, statusCode: 501, message })
 }
 
@@ -107,6 +107,34 @@ const DRAFT_ADMIN_ELEMENTS = [
 const numericCollator = { numeric: true }
 const emptyObject = {}
 
+const _isKeyValue = (i, keys, where) => {
+  if (!where[i].ref || !keys.includes(where[i].ref[0])) {
+    return false
+  }
+
+  return where[i + 1] === '=' && 'val' in where[i + 2]
+}
+
+const _getKeyData = (keys, where) => {
+  if (!where) {
+    return {}
+  }
+
+  const data = {}
+  let i = 0
+
+  while (where[i]) {
+    if (_isKeyValue(i, keys, where)) {
+      data[where[i].ref[0]] = where[i + 2].val
+      i = i + 3
+    } else {
+      i++
+    }
+  }
+
+  return data
+}
+
 const _fillIsActiveEntity = (row, IsActiveEntity, target) => {
   if (target.drafts) row.IsActiveEntity = IsActiveEntity
   for (const key in target.associations) {
@@ -131,7 +159,7 @@ const _filterResultSet = (resultSet, limit, offset) => {
   return pageResultSet
 }
 
-/// It's important to wait for the completion of all promises, otherwise a rollback might happen too soon
+// It's important to wait for the completion of all promises, otherwise a rollback might happen too soon
 const _promiseAll = async array => {
   const results = await Promise.allSettled(array)
   const firstRejected = results.find(response => response.status === 'rejected')
@@ -178,31 +206,36 @@ const _redirectRefToActives = (ref, model) => {
   return [root.id ? { ...root, id: active.name } : active.name, ...tail]
 }
 
-let lastCheckMap = new Map()
+const lastCheckMap = new Map()
 const _cleanUpOldDrafts = async (service, tenant) => {
   if (!DEL_TIMEOUT.value) return
 
-  const invalDate = new Date(Date.now() - DEL_TIMEOUT.value).toISOString()
+  const expiryDate = new Date(Date.now() - DEL_TIMEOUT.value).toISOString()
   const interval = DEL_TIMEOUT.value / 2
   const lastCheck = lastCheckMap.get(tenant)
 
   if (lastCheck && Date.now() - lastCheck < Number(interval)) return
 
   cds.spawn({ tenant, user: cds.User.privileged }, async () => {
-    let invalDrafts = await SELECT.from('DRAFT.DraftAdministrativeData', ['DraftUUID']).where(
+    const expiredDrafts = await SELECT.from('DRAFT.DraftAdministrativeData', ['DraftUUID']).where(
       `LastChangeDateTime <`,
-      invalDate
+      expiryDate
     )
-    if (!invalDrafts.length) return
-    invalDrafts = invalDrafts.map(el => el.DraftUUID)
+
+    if (!expiredDrafts.length) return
+
+    const expiredDraftsIds = expiredDrafts.map(el => el.DraftUUID)
     const cqns = []
+
     for (let name in service.model.definitions) {
       const target = service.model.definitions[name]
-      if (target.drafts && target['@Common.DraftRoot.ActivationAction'])
-        cqns.push(DELETE.from(target.drafts).where(`DraftAdministrativeData_DraftUUID IN`, invalDrafts))
+      if (target.drafts && target['@Common.DraftRoot.ActivationAction']) {
+        cqns.push(DELETE.from(target.drafts).where(`DraftAdministrativeData_DraftUUID IN`, expiredDraftsIds))
+      }
     }
-    cqns.push(DELETE.from('DRAFT.DraftAdministrativeData').where(`DraftUUID IN`, invalDrafts))
-    await _promiseAll(cqns)
+
+    cqns.push(DELETE.from('DRAFT.DraftAdministrativeData').where(`DraftUUID IN`, expiredDraftsIds))
+    return await _promiseAll(cqns)
   })
 
   lastCheckMap.set(tenant, Date.now())
@@ -210,7 +243,6 @@ const _cleanUpOldDrafts = async (service, tenant) => {
 
 const h = cds.ApplicationService.prototype.handle
 
-/* eslint-disable complexity */
 cds.ApplicationService.prototype.handle = async function (req) {
   const handle = h.bind(this)
 
@@ -327,9 +359,14 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
   if (req.event === 'draftEdit') req.event = 'EDIT'
 
-  if (req.event === 'NEW' || req.event === 'CANCEL' || req.event === 'draftPrepare') {
+  if (
+    req.event === 'NEW' ||
+    req.event === 'CANCEL' ||
+    req.event === 'draftPrepare' ||
+    (req.event === 'CREATE' && req.target._isDraftEnabled)
+  ) {
     if (req.event === 'draftPrepare' && draftParams.IsActiveEntity) req.reject({ code: 400, statusCode: 400 })
-    if (req.event === 'NEW' && req.data?.IsActiveEntity === true) {
+    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][
@@ -364,17 +401,33 @@ cds.ApplicationService.prototype.handle = async function (req) {
 
       const cqn = INSERT.into(query.INSERT.into).entries(data)
       await run(cqn, { event: 'CREATE' })
-      return { ...data, IsActiveEntity: true }
+      const result = { ...data, IsActiveEntity: true }
+      req.data = result //> make keys available via req.data (as with normal crud)
+      return result
     }
     req.target = req.target.drafts
 
     if (query.INSERT?.into) {
       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)
-    } else if (query.DELETE?.from?.ref) query.DELETE.from.ref = _redirectRefToDrafts(query.DELETE.from.ref, this.model)
-    else if (query.SELECT?.from?.ref) query.SELECT.from.ref = _redirectRefToDrafts(query.SELECT.from.ref, this.model)
+    } else if (query.DELETE?.from?.ref) {
+      query.DELETE.from.ref = _redirectRefToDrafts(query.DELETE.from.ref, this.model)
+    } else if (query.SELECT?.from?.ref) {
+      query.SELECT.from.ref = _redirectRefToDrafts(query.SELECT.from.ref, this.model)
+    }
+
     const _req = _newReq(req, query, draftParams, { event: req.event })
+
+    if (
+      (req.event === 'NEW' || req.event === 'CREATE') &&
+      draftParams.IsActiveEntity === false &&
+      !_req.target.isDraft
+    ) {
+      req.reject({ code: 403, statusCode: 403, message: 'ACTIVE_MODIFICATION_VIA_DRAFT' })
+    }
+
     const result = await handle(_req)
+    req.data = result //> make keys available via req.data (as with normal crud)
     return result
   }
 
@@ -422,7 +475,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
     }
 
     const targetDraft = req.target.drafts
-    const cols = expandStarStar(targetDraft)
+    const cols = expandStarStar(targetDraft, true)
 
     // Use `run` (since also etags might need to be checked)
     // REVISIT: Find a better approach (`etag` as part of CQN?)
@@ -447,25 +500,13 @@ cds.ApplicationService.prototype.handle = async function (req) {
         args: [res.DraftAdministrativeData?.InProcessByUser]
       })
     }
+
     const DraftAdministrativeData_DraftUUID = res.DraftAdministrativeData_DraftUUID
     delete res.DraftAdministrativeData_DraftUUID
     delete res.DraftAdministrativeData
     const HasActiveEntity = res.HasActiveEntity
     delete res.HasActiveEntity
 
-    if (cds.env.features.cds_assert) {
-      const assertOptions = { path: [req.target.actions[req.event]['@cds.odata.bindingparameter.name'] || 'in'] }
-      const errs = cds.assert(res, req.target, assertOptions)
-      if (errs) {
-        if (errs.length === 1) throw Object.assign(errs[0], { '@Common.numericSeverity': 4 })
-        throw Object.assign(new Error('MULTIPLE_ERRORS'), {
-          statusCode: 400,
-          details: errs,
-          '@Common.numericSeverity': 4 //> TODO: should not be needed here
-        })
-      }
-    }
-
     // First run the handlers as they might need access to DraftAdministrativeData or the draft entities
     const result = await run(
       HasActiveEntity
@@ -490,7 +531,11 @@ cds.ApplicationService.prototype.handle = async function (req) {
     }
 
     if (cds.env.features.odata_new_adapter) {
-      const read_result = await _readAfterDraftAction.bind(this)({ req, payload: res, action: 'draftActivate' })
+      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 })
@@ -517,11 +562,12 @@ cds.ApplicationService.prototype.handle = async function (req) {
     return result
   }
 
-  if (req.event === 'PATCH') {
+  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')
+
       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', {
@@ -570,6 +616,10 @@ cds.ApplicationService.prototype.handle = async function (req) {
     return req.data
   }
 
+  if (req.event === 'CREATE' && draftParams.IsActiveEntity === false && !req.target.isDraft) {
+    req.reject({ code: 403, statusCode: 403, message: 'ACTIVE_MODIFICATION_VIA_DRAFT' })
+  }
+
   req.query = query
 
   return handle(req)
@@ -604,6 +654,7 @@ const _requested = (result, query) => {
 const Read = {
   onlyActives: async function (run, query, { ignoreDrafts } = {}) {
     LOG.debug('List Editing Status: Only Active')
+
     // DraftAdministrativeData is only accessible via drafts
     if (_isCount(query)) return run(query)
     if (query._target.name.endsWith('.DraftAdministrativeData')) return run(query._drafts)
@@ -626,7 +677,7 @@ const Read = {
     else {
       try {
         drafts = await Read.complementaryDrafts(query, actives)
-      } catch (e) {
+      } catch {
         drafts = []
       }
     }
@@ -646,6 +697,7 @@ const Read = {
 
   unchanged: async function (run, query) {
     LOG.debug('List Editing Status: Unchanged')
+
     const draftsQuery = query._drafts
     if (!draftsQuery) throw new Error('Invalid draft request')
     draftsQuery.SELECT.count = undefined
@@ -697,6 +749,7 @@ const Read = {
 
   all: async function (run, query) {
     LOG.debug('List Editing Status: All')
+
     if (!query._drafts) return []
 
     query._drafts.SELECT.count = false
@@ -890,11 +943,13 @@ const Read = {
 
   unsavedChangesByAnotherUser: async function (run, query) {
     LOG.debug('List Editing Status: Unsaved Changes by Another User')
+
     return Read.activesFromDrafts(run, query, { isLocked: false })
   },
 
   lockedByAnotherUser: async function (run, query) {
     LOG.debug('List Editing Status: Locked by Another User')
+
     return Read.activesFromDrafts(run, query, { isLocked: true })
   },
 
@@ -904,10 +959,19 @@ const Read = {
     const keys = entity_keys(target)
     const dataArray = data ? (Array.isArray(data) ? data : [data]) : []
     if (not && !dataArray.length) return []
-    const left = { list: keys.map(k => ({ ref: [k] })) }
-    const op = not ? ['not', 'in'] : ['in']
-    const right = { list: dataArray.map(r => ({ list: keys.map(k => ({ val: r[k] })) })) }
-    return [left, ...op, right]
+    if (keys.length === 1) {
+      // For single keys, make it nicer (without unnecessary lists)
+      const key = keys[0]
+      const left = { ref: [key] }
+      const op = not ? ['not', 'in'] : ['in']
+      const right = { list: dataArray.map(r => ({ val: r[key] })) }
+      return [left, ...op, right]
+    } else {
+      const left = { list: keys.map(k => ({ ref: [k] })) }
+      const op = not ? ['not', 'in'] : ['in']
+      const right = { list: dataArray.map(r => ({ list: keys.map(k => ({ val: r[k] })) })) }
+      return [left, ...op, right]
+    }
   },
 
   complementaryDrafts: (query, _actives) => {
@@ -1008,6 +1072,7 @@ function _cleansed(query, model) {
     const getDrafts = () => {
       const draftsQuery = _cleanseQuery(query, {}, model) // could just clone `q` but the latter is ruined by database layer
       draftsQuery._target = undefined
+      if (!draftsQuery.SELECT.from.ref) return // invalid draft request
       const [root, ...tail] = draftsQuery.SELECT.from.ref
       const draft = model.definitions[root.id || root].drafts
       if (!draft) return
@@ -1187,12 +1252,14 @@ function _cleansed(query, model) {
 }
 
 // This function is better defined on DB layer
-function expandStarStar(target, recursion = new Map()) {
+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]
-    if (!element.isAssociation && !DRAFT_ELEMENTS.has(el) && !element['@odata.draft.skip']) columns.push({ ref: [el] })
+    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)
@@ -1204,7 +1271,7 @@ function expandStarStar(target, recursion = new Map()) {
       recursion.set(_key, cache)
     }
     if (cache >= MAX_RECURSION_DEPTH) return
-    const expand = expandStarStar(element._target, recursion)
+    const expand = expandStarStar(element._target, draftActivate, recursion)
     if (expand) columns.push({ ref: [el], expand })
   }
   return columns
@@ -1212,6 +1279,7 @@ function expandStarStar(target, recursion = new Map()) {
 
 async function onNew(req) {
   LOG.debug('new draft')
+
   if (req.target.actives['@Capabilities.InsertRestrictions.Insertable'] === false || req.target.actives['@readonly'])
     req.reject({ code: 405, statusCode: 405 })
   const isDirectAccess = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
@@ -1284,7 +1352,11 @@ async function onNew(req) {
   const draftCQN = INSERT.into(req.target).entries(draftData)
 
   await _promiseAll([adminDataCQN, this.run(draftCQN)])
-  req._.readAfterWrite = true
+
+  // 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
+
   return { ...draftData, IsActiveEntity: false }
 }
 
@@ -1354,7 +1426,7 @@ async function onEdit(req) {
   // concurrently.
   if (this._datasource === cds.db) {
     const keys = entity_keys(req.target)
-    const keyData = getKeyData(keys, req.query.SELECT.from.ref[0].where)
+    const keyData = _getKeyData(keys, req.query.SELECT.from.ref[0].where)
     const rootWhere = keys.reduce((res, key) => {
       res[key] = keyData[key]
       return res
@@ -1382,7 +1454,7 @@ async function onEdit(req) {
 
     try {
       await this.run(activeLockCQN)
-    } catch (e) {
+    } catch {
       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' })
@@ -1457,7 +1529,11 @@ async function onEdit(req) {
   }
 
   if (cds.env.features.odata_new_adapter) {
-    const read_result = await _readAfterDraftAction.bind(this)({ req, payload: res, action: 'draftEdit' })
+    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 })
@@ -1470,6 +1546,7 @@ async function onEdit(req) {
 
 async function onCancel(req) {
   LOG.debug('delete draft')
+
   const activeRef = _redirectRefToActives(req.query.DELETE.from.ref, this.model)
   const draftParams = req.query[DRAFT_PARAMS]
 
@@ -1479,7 +1556,7 @@ async function onCancel(req) {
       'DraftAdministrativeData_DraftUUID',
       { ref: ['DraftAdministrativeData'], expand: [_inProcessByUserXpr(_lock.shiftedNow)] }
     ])
-  if (req._etagValidationClause) draftQuery.where(req._etagValidationClause)
+  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)
@@ -1488,7 +1565,10 @@ async function onCancel(req) {
     if (processByUser && processByUser !== cds.context.user.id)
       req.reject({ code: 403, statusCode: 403, message: 'DRAFT_LOCKED_BY_ANOTHER_USER', args: [processByUser] })
   }
-  const queries = !draft ? [] : [this.run(DELETE.from({ ref: req.query.DELETE.from.ref }), req.data)]
+  const draftDeleteQuery = DELETE.from({ ref: req.query.DELETE.from.ref })
+  const queries = !draft
+    ? []
+    : [draftParams.IsActiveEntity === false ? this.run(draftDeleteQuery, req.data) : draftDeleteQuery]
   if (draft && req.target['@Common.DraftRoot.ActivationAction'])
     // only for draft root
     queries.push(
@@ -1504,13 +1584,14 @@ async function onCancel(req) {
         })
         .where({ DraftUUID: draft.DraftAdministrativeData_DraftUUID })
     )
-  if (draftParams.IsActiveEntity) queries.push(this.run(DELETE.from({ ref: activeRef })))
+  if (draftParams.IsActiveEntity !== false) queries.push(this.run(DELETE.from({ ref: activeRef })))
   await _promiseAll(queries)
   return req.data
 }
 
 async function onPrepare(req) {
   LOG.debug('prepare draft')
+
   const draftParams = req.query[DRAFT_PARAMS]
   if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== false) {
     req.reject({
@@ -1565,6 +1646,7 @@ const _readAfterDraftAction = async function ({ req, payload, action }) {
     })
     // also ensure selection of etag columns
     addEtagColumns(read.SELECT.columns, entity)
+    handleStreamProperties(entity, read.SELECT.columns, this.model)
   }
 
   try {

package/libx/_runtime/hana/Service.js

@@ -122,7 +122,6 @@ class HanaDatabase extends DatabaseService {
   /*
    * connection
    */
-  // eslint-disable-next-line complexity
   async acquire(arg) {
     const tenant = arg && (typeof arg === 'string' ? arg : arg.tenant)
     const dbc = await pool.acquire(tenant, this)

package/libx/_runtime/hana/driver.js

@@ -137,7 +137,7 @@ const _getHanaDriver = name => {
     let packageJson
     try {
       packageJson = require(cds.root + '/package.json')
-    } catch (e) {
+    } catch {
       LOG._debug && LOG.debug(`Could not find package.json. Trying to lookup hana driver automatically.`)
       name = 'hdb'
     }

package/libx/_runtime/hana/dynatrace.js

@@ -1,9 +1,8 @@
 const dynatrace = {}
 try {
-  // eslint-disable-next-line cds/no-missing-dependencies -- needs to be added by app dev
   dynatrace.sdk = require('@dynatrace/oneagent-sdk')
   dynatrace.api = dynatrace.sdk.createInstance()
-} catch (err) {
+} catch {
   // If module was not required, do not do anything
 }
 

package/libx/_runtime/hana/pool.js

@@ -22,7 +22,6 @@ async function credentials4(tenant, db) {
   if (!credentials) throw new Error('No database credentials provided')
 
   if (cds.requires.multitenancy) {
-    // eslint-disable-next-line cds/no-missing-dependencies
     const res = await require('@sap/cds-mtxs/lib').xt.serviceManager.get(tenant, { disableCache })
     return _getMassagedCreds(res.credentials)
   }
@@ -67,11 +66,6 @@ const _getPoolConfig = function () {
 
   // defaults
   if (!poolConfig) {
-    if (process.env.NODE_ENV === 'production') {
-      mergedConfig.acquireTimeoutMillis = 1000
-    } else {
-      mergedConfig.acquireTimeoutMillis = 10 * 1000
-    }
     mergedConfig.softIdleTimeoutMillis = 30 * 1000
     mergedConfig.idleTimeoutMillis = 30 * 1000
   }
@@ -101,28 +95,24 @@ async function pool4(tenant, db) {
           LOG._info && LOG.info('effective pool configuration:', config)
           const p = pool.createPool(factory4(creds, tenant), config)
           const INVALID_CREDENTIALS_WARNING = `Could not establish connection for tenant "${tenant}". Existing pool will be drained.`
-          const INVALID_CREDENTIALS_ERROR = new Error(
-            `Create is blocked for tenant "${tenant}" due to invalid credentials.`
-          )
+          const INVALID_CREDENTIALS_ERROR = `Create is blocked for tenant "${tenant}" due to invalid credentials.`
+          const _create = () =>
+            new Promise((_, reject) =>
+              setTimeout(() => reject(new Error(INVALID_CREDENTIALS_ERROR)), config.acquireTimeoutMillis)
+            )
 
           // The error listener for `factoryCreateError` is registered to detect failed connection attempts.
-          // If it fails due to invalid credentials, we delete the current pool from the pools map and overwrite the
-          // pool factory create function.
-          // The background is that the generic pool will keep trying to establish a connection by invoking the factory
-          // create function until the `acquireTimeoutMillis` is reached.
+          // If it fails due to invalid credentials, we delete the current pool from the pools map and overwrite the pool factory create function.
+          // The background is that the generic pool will keep trying to establish a connection by invoking the factory create function until the `acquireTimeoutMillis` is reached.
           // This leads to numerous connection attempts for a single request, even when the credentials are invalid.
           // Due to the deletion in the map, subsequent requests will retrieve the credentials again.
-          p.on('factoryCreateError', async function (err) {
+          p.on('factoryCreateError', function (err) {
             if (err._connectError) {
               LOG._warn && LOG.warn(INVALID_CREDENTIALS_WARNING)
               pools.delete(tenant)
-              if (p._factory && p._factory.create) {
-                // reject after 100 ms to not block CPU completely
-                p._factory.create = () =>
-                  new Promise((resolve, reject) => setTimeout(() => reject(INVALID_CREDENTIALS_ERROR), 100))
-              }
-              await p.drain()
-              await p.clear()
+              if (p._factory?.create) p._factory.create = _create
+              // shutdown
+              p.drain().then(p.clear.bind(p)) //> no need to await
             }
           })
 

package/libx/_runtime/hana/streaming.js

@@ -9,7 +9,6 @@ const STREAM_PLACEHOLDER = '[<stream>]'
 const _loadStreamExtensionIfNeeded = () => {
   const hana = require('./driver')
   if (hana.name !== 'hdb') {
-    // eslint-disable-next-line cds/no-missing-dependencies -- needs to be added by app dev
     const extension = require('@sap/hana-client/extension/Stream.js')
     return isDynatraceEnabled() ? dynatraceStreamingExtension(extension) : extension
   }

package/libx/_runtime/messaging/common-utils/AMQPClient.js

@@ -1,5 +1,4 @@
 const cds = require('../../cds.js')
-// eslint-disable-next-line cds/no-missing-dependencies -- needs to be added by app dev
 const ClientAmqp = require('@sap/xb-msg-amqp-v100').Client
 const { connect, disconnect } = require('./connections')
 

package/libx/_runtime/messaging/common-utils/authorizedRequest.js

@@ -39,7 +39,7 @@ const authorizedRequest = ({ method, uri, path, oa2, tenant, dataObj, headers, t
             let body
             try {
               body = res.headers && res.headers['content-type'] === 'application/json' ? JSON.parse(chunks) : chunks
-            } catch (e) {
+            } catch {
               // There are some cases (e.g. ReadinessCheck) where the content type is 'application/json'
               // but the chunks are not valid JSON.
               body = chunks

package/libx/_runtime/messaging/common-utils/normalizeIncomingMessage.js

@@ -1,7 +1,7 @@
 const _JSONorString = string => {
   try {
     return JSON.parse(string)
-  } catch (e) {
+  } catch {
     return string
   }
 }

package/libx/_runtime/messaging/enterprise-messaging-utils/getTenantInfo.js

@@ -15,7 +15,7 @@ const getTenantInfo = async tenant => {
     try {
       await tx.rollback()
       throw e
-    } catch (_) {
+    } catch {
       throw e
     }
   }