@sap/cds 5.4.6 → 5.5.0

package/libx/_runtime/fiori/utils/delete.js

@@ -2,9 +2,14 @@ const cds = require('../../cds')
 const { SELECT, DELETE } = cds.ql
 
 const { isDraftRootEntity } = require('./csn')
-const { getUpdateDraftAdminCQN, ensureDraftsSuffix, ensureNoDraftsSuffix } = require('./handler')
+const {
+  getUpdateDraftAdminCQN,
+  ensureDraftsSuffix,
+  ensureNoDraftsSuffix,
+  getDeleteDraftAdminCqn,
+  getCompositionTargets
+} = require('./handler')
 const { extractKeyConditions } = require('./where')
-const { getTargetData } = require('../../common/utils/data')
 
 const _getSelectCQN = (req, keys) => {
   return SELECT.from(ensureNoDraftsSuffix(req.target.name), [1]).where(keys.keyList)
@@ -28,23 +33,49 @@ const _validate = (activeResult, draftResult, req, IsActiveEntity) => {
   }
 }
 
-const deleteDraft = async (req, definitions, includingActive = false) => {
+const deleteDraft = async (req, srv, includingActive = false) => {
   const dbtx = cds.tx(req)
+  const definitions = srv.model.definitions
 
   // REVISIT: how to handle delete of to 1 assoc
   const keys = extractKeyConditions(req.query.DELETE.from.ref[req.query.DELETE.from.ref.length - 1].where)
+
+  // IsActiveEntity is deleted from where clause in auth.js, hence keys.IsActiveEntity is undefined here.
+  // Intentional?
+  const deleteActive = keys.IsActiveEntity !== false
+
   const [activeResult, draftResult] = await Promise.all([
     dbtx.run(_getSelectCQN(req, keys)),
     dbtx.run(_getDraftSelectCQN(req, keys))
   ])
 
-  _validate(activeResult, draftResult, req, keys.IsActiveEntity)
+  _validate(activeResult, draftResult, req, deleteActive)
+
+  if (isDraftRootEntity(definitions, ensureNoDraftsSuffix(req.target.name)) && !deleteActive) {
+    const draftUUID = draftResult[0].DraftUUID
+
+    const draftTablesToDeleteFrom = [req.target.name + '_drafts']
+    for (const [entity] of getCompositionTargets(req.target, srv).entries()) {
+      if (!draftTablesToDeleteFrom.includes(entity + '_drafts')) draftTablesToDeleteFrom.push(entity + '_drafts')
+    }
+
+    const deleteDraftAdminCqn = getDeleteDraftAdminCqn(draftUUID)
+
+    return dbtx.run([
+      deleteDraftAdminCqn,
+      ...draftTablesToDeleteFrom.map(dt => {
+        const d = DELETE.from(dt).where({ DraftAdministrativeData_DraftUUID: draftUUID })
+        d._suppressDeepDelete = true // hidden flag to tell db layer that no deep delete is required
+        return d
+      })
+    ])
+  }
 
   const source = definitions[ensureNoDraftsSuffix(req.target.name)]
   const delCQNs = []
 
   if (includingActive) {
-    delCQNs.push(DELETE.from(ensureNoDraftsSuffix(getTargetData(req.target, {}).target.name)).where(keys.keyList))
+    delCQNs.push(DELETE.from(ensureNoDraftsSuffix(req.target.name)).where(keys.keyList))
   }
 
   if (draftResult.length !== 0) {
@@ -58,8 +89,6 @@ const deleteDraft = async (req, definitions, includingActive = false) => {
     }
   }
 
-  req._oldData = keys.IsActiveEntity ? activeResult[0] : draftResult[0]
-
   return Promise.all(delCQNs.map(cqn => dbtx.run(cqn)))
 }
 

package/libx/_runtime/fiori/utils/handler.js

@@ -3,11 +3,12 @@ const { UPDATE, SELECT } = cds.ql
 const { removeIsActiveEntityRecursively, isActiveEntityRequested } = require('./where')
 const { getColumns } = require('../../cds-services/services/utils/columns')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
+const getTemplate = require('../../common/utils/template')
 
 const { DRAFT_COLUMNS } = require('../../common/constants/draft')
 
-// REVISIT: remove everywhere
-const SYMBOL_FROM_ANNOTATION = Symbol.for('sap.cds.FROM_ANNOTATION')
+// unofficial config!
+const MAX_RECURSION_DEPTH = (cds.env.features.recursion_depth && Number(cds.env.features.recursion_depth)) || 2
 
 const _getParentCQNWithKeyColumn = (parentCQN, parentKeyName) => {
   const parentCQNWithKeyColumn = Object.assign({}, parentCQN)
@@ -23,33 +24,32 @@ const _getSubSelectFromCQN = (element, columns, selectFromDraft) => {
   )
 }
 
-const getSubCQNs = ({ definitions, context, rootCQN, compositionTree, selectFromDraft = false }) => {
+const getSubCQNs = ({ definitions, rootCQN, compositionTree, selectFromDraft = false }) => {
   const subCQNs = []
   // only one backLink
-  const _generateSubCQNs = (parentEntity, parentCQN, compositionElements, level = 1) => {
+  const _generateSubCQNs = (parentCQN, compositionElements, elementMap = new Map()) => {
     for (const element of compositionElements) {
       const backLink = element.backLinks[0] || element.customBackLinks[0]
-      // to one without backlink
-      const link = element.links[0]
-
-      const parentKey = Object.keys(parentEntity.keys)[0]
-
-      const columns = getColumns(definitions[element.source], { onlyNames: true, filterVirtual: true })
-      if (parentKey && (backLink || link)) {
+      if (backLink) {
+        const fqn = element.source + ':' + element.name
+        const seen = elementMap.get(fqn)
+        if (seen && seen >= MAX_RECURSION_DEPTH) {
+          // recursion -> abort
+          continue
+        }
+
+        const columns = getColumns(definitions[element.source], { onlyNames: true, filterVirtual: true })
         const subCQN = _getSubSelectFromCQN(element, columns, selectFromDraft)
-        subCQN.where([
-          { ref: [backLink ? backLink.entityKey : link.targetKey] },
-          'in',
-          _getParentCQNWithKeyColumn(parentCQN, backLink ? parentKey : link.entityKey)
-        ])
-
-        subCQNs.push({ cqn: subCQN, level })
-        _generateSubCQNs(definitions[element.source], subCQN, element.compositionElements, level + 1)
+        subCQN.where([{ ref: [backLink.entityKey] }, 'in', _getParentCQNWithKeyColumn(parentCQN, backLink.targetKey)])
+        subCQNs.push({ cqn: subCQN })
+        const newElementMap = new Map(elementMap)
+        newElementMap.set(fqn, (seen && seen + 1) || 1)
+        _generateSubCQNs(subCQN, element.compositionElements, newElementMap)
       }
     }
   }
 
-  _generateSubCQNs(context.target, rootCQN, compositionTree.compositionElements)
+  _generateSubCQNs(rootCQN, compositionTree.compositionElements)
 
   return subCQNs
 }
@@ -96,13 +96,8 @@ const _addAlias = (where, tableName) => {
   return where.map(element => {
     if (element.ref && element.ref.length === 1) {
       // and copy ref
-      const ref = { ref: [tableName, element.ref[0]] }
-      if (element[SYMBOL_FROM_ANNOTATION] === true) {
-        ref[SYMBOL_FROM_ANNOTATION] = true
-      }
-      return ref
+      return { ref: [tableName, element.ref[0]] }
     }
-
     return element
   })
 }
@@ -169,6 +164,9 @@ const _aliasRef = (ref, alias) => {
   return newRef
 }
 
+const getDeleteDraftAdminCqn = draftUUID =>
+  DELETE.from('DRAFT.DraftAdministrativeData').where([{ ref: ['DraftUUID'] }, '=', { val: draftUUID }])
+
 const _aliased = (arr, alias) =>
   arr.map(item => {
     if (alias && item.ref && item.ref[0] !== alias) {
@@ -230,23 +228,24 @@ const addColumnAlias = (columns, alias) => {
   })
 }
 
-const replaceRefWithDraft = ref => {
-  if (!ref || !ref[0] || ref[SYMBOL_FROM_ANNOTATION] === true) return
-  ref[0] = ensureDraftsSuffix(ref[0])
-}
-
-const isAnnotated = element => element[SYMBOL_FROM_ANNOTATION] === true
-
-const removeAnnotationWhere = where => {
-  const firstIndex = where.findIndex(isAnnotated)
+const getCompositionTargets = (entity, srv) => {
+  if (!entity.own('_deepCompositionTargets')) {
+    const _deepCompositionTargets = []
+    getTemplate('delete-drafts', srv, entity, {
+      pick: element => {
+        if (element.isAssociation && !element._isAssociationStrict && srv.model.definitions[element.target].drafts)
+          _deepCompositionTargets.push(element.target)
+      }
+    })
+    entity.set('_deepCompositionTargets', new Set(_deepCompositionTargets))
+  }
 
-  if (firstIndex !== -1) {
-    const lastIndex = where.length - 1 - [...where].reverse().findIndex(isAnnotated)
+  return entity.own('_deepCompositionTargets')
+}
 
-    // HANA does not support TRUE as expression
-    where.splice(firstIndex, lastIndex - firstIndex + 1, { val: '1' }, '=', { val: '1' })
-  }
-  return where
+const replaceRefWithDraft = ref => {
+  if (!ref || !ref[0]) return
+  ref[0] = ensureDraftsSuffix(ref[0])
 }
 
 const adaptStreamCQN = cqn => {
@@ -254,7 +253,6 @@ const adaptStreamCQN = cqn => {
     cqn.SELECT.where = removeIsActiveEntityRecursively(cqn.SELECT.where)
   } else {
     replaceRefWithDraft(cqn.SELECT.from.ref)
-    removeAnnotationWhere(cqn.SELECT.where)
   }
 }
 
@@ -302,8 +300,9 @@ module.exports = {
   addColumnAlias,
   adaptStreamCQN,
   replaceRefWithDraft,
-  removeAnnotationWhere,
   getKeyProperty,
   hasKeyInWhere,
-  filterKeys
+  filterKeys,
+  getDeleteDraftAdminCqn,
+  getCompositionTargets
 }

package/libx/_runtime/fiori/utils/where.js

@@ -1,4 +1,6 @@
-const _removeMultipleBrackets = (index, whereCondition) => {
+const _removeMultipleBrackets = (index, whereCondition, isXpr) => {
+  if (isXpr) return index
+
   let resIndex = index
   if (whereCondition[index - 1] === '(') {
     while (resIndex - 2 >= 0 && whereCondition[resIndex - 2] === '(') {
@@ -17,25 +19,26 @@ const _removeMultipleBrackets = (index, whereCondition) => {
   return resIndex
 }
 
-const _calculateSpliceArgs = (index, whereCondition) => {
+const _calculateSpliceArgs = (index, whereCondition, isXpr = false) => {
   const AND_OR = ['and', 'or']
+  const len = isXpr ? 1 : 3
   if (AND_OR.includes(whereCondition[index - 1])) {
-    return { index: index - 1, count: 4 }
+    return { index: index - 1, count: 1 + len }
   }
-  if (AND_OR.includes(whereCondition[index + 3])) {
-    return { index: index, count: 4 }
+  if (AND_OR.includes(whereCondition[index + len])) {
+    return { index: index, count: len + 1 }
   }
-  if (whereCondition[index - 1] === '(' && whereCondition[index + 3] === ')') {
+  if (whereCondition[index - 1] === '(' && whereCondition[index + len] === ')') {
     if (AND_OR.includes(whereCondition[index - 2])) {
-      return { index: index - 2, count: 6 }
+      return { index: index - 2, count: len + 3 }
     }
-    if (AND_OR.includes(whereCondition[index + 4])) {
-      return { index: index - 1, count: 6 }
+    if (AND_OR.includes(whereCondition[index + len + 1])) {
+      return { index: index - 1, count: len + 3 }
     }
 
-    return { index: index - 1, count: 5 }
+    return { index: index - 1, count: len + 2 }
   }
-  return { index: index, count: 3 }
+  return { index: index, count: len }
 }
 
 const _isActiveEntity = entry => entry.ref && entry.ref[entry.ref.length - 1] === 'IsActiveEntity'
@@ -75,14 +78,26 @@ const _isKeyValue = (i, keys, where) => {
   return where[i + 1] === '=' && 'val' in where[i + 2]
 }
 
-const deleteCondition = (index, whereCondition) => {
-  index = _removeMultipleBrackets(index, whereCondition)
-  const spliceArgs = _calculateSpliceArgs(index, whereCondition)
+const deleteCondition = (index, whereCondition, isXpr = false) => {
+  index = _removeMultipleBrackets(index, whereCondition, isXpr)
+  const spliceArgs = _calculateSpliceArgs(index, whereCondition, isXpr)
   whereCondition.splice(spliceArgs.index, spliceArgs.count)
+  return spliceArgs.index
 }
 
 const readAndDeleteKeywords = (keywords, whereCondition, toDelete = true) => {
-  const index = whereCondition.findIndex(({ ref }) => {
+  let index = whereCondition.findIndex(({ xpr }) => xpr)
+  if (index !== -1) {
+    const result = readAndDeleteKeywords(keywords, whereCondition[index].xpr, toDelete)
+    if (result) {
+      if (whereCondition[index].xpr.length === 0) {
+        deleteCondition(index, whereCondition, true)
+      }
+      return result
+    }
+  }
+
+  index = whereCondition.findIndex(({ ref }) => {
     if (!ref) {
       return false
     }

package/libx/_runtime/hana/customBuilder/CustomSelectBuilder.js

@@ -29,11 +29,8 @@ class CustomSelectBuilder extends SelectBuilder {
   }
 
   _val(obj) {
-    if (typeof obj.val === 'boolean') {
-      return obj.val ? 'true' : 'false'
-    }
-
-    return obj.val
+    if (typeof obj.val === 'boolean') return { sql: obj.val ? 'true' : 'false', values: [] }
+    return super._val(obj)
   }
 
   getParameters() {
@@ -91,9 +88,10 @@ if (cds.env.sql.names === 'plain') {
   CustomSelectBuilder.prototype._buildRefElement = function (col, res, noQuoting) {
     res = new this.ReferenceBuilder(col, this._options, this._csn).build()
 
-    if (!noQuoting && !col.as && res.sql && !res.sql.includes(' as ')) {
+    if (!noQuoting && !col.as && res.sql && !res.sql.match(/\sas\s/i)) {
       res.sql += ` AS ${this._options.delimiter}${col.ref[col.ref.length - 1]}${this._options.delimiter}`
     }
+
     return res
   }
 }

package/libx/_runtime/hana/execute.js

@@ -132,7 +132,7 @@ function _executeSelectSQL(dbc, sql, values, isOne, postMapper, propertyMapper,
 
 function _processExpand(model, dbc, cqn, user, locale, txTimestamp) {
   const queries = []
-  const expandQueries = createJoinCQNFromExpanded(cqn, model, true)
+  const expandQueries = createJoinCQNFromExpanded(cqn, model)
 
   for (const cqn of expandQueries.queries) {
     cqn._conversionMapper = getPostProcessMapper(HANA_TYPE_CONVERSION_MAP, model, cqn)
@@ -144,7 +144,7 @@ function _processExpand(model, dbc, cqn, user, locale, txTimestamp) {
     queries.push(_executeSelectSQL(dbc, sql, values, false))
   }
 
-  return rawToExpanded(expandQueries, queries, cqn.SELECT.one)
+  return rawToExpanded(expandQueries, queries, cqn.SELECT.one, cqn._rootEntity)
 }
 
 function executeSelectCQN(model, dbc, query, user, locale, txTimestamp) {

package/libx/_runtime/hana/localized.js

@@ -13,15 +13,15 @@ const getLocalize = (locale, model) => name => {
 }
 
 const localizedHandler = function (req) {
-  const query = req.query
+  const { query } = req
 
   // do simple checks upfront and exit early
   if (!query || typeof query === 'string') return
   if (!query.SELECT) return
-  if (!req.user || !req.user.locale) return
   if (!this.model) return
+  if (!req.locale) return
 
-  // suppress localization
+  // suppress localization by instruction
   if (query._suppressLocalization) return
 
   // suppress localization for pure counts
@@ -31,7 +31,7 @@ const localizedHandler = function (req) {
   // suppress localization in "select for update"
   if (query.SELECT.forUpdate) return
 
-  redirect(req.query.SELECT, getLocalize(req.user.locale, this.model))
+  redirect(query.SELECT, getLocalize(req.locale, this.model))
 }
 
 localizedHandler._initial = true

package/libx/_runtime/hana/pool.js

@@ -192,22 +192,37 @@ async function pool4(tenant, credentials) {
   return pools.get(tenant)
 }
 
-module.exports = {
-  acquire: async (tenant, credentials) => {
+async function resilientAcquire(pool, attempts = 1) {
+  // max 3 attempts
+  attempts = Math.min(attempts, 3)
+  let client
+  let err
+  let attempt = 0
+  while (!client && attempt < attempts) {
     try {
-      const pool = await pool4(tenant, credentials)
-      const client = await pool.acquire()
-      client._pool = pool
-      return client
-    } catch (err) {
-      if (err.name === 'TimeoutError') {
-        err.statusCode = 503
-        err.message =
-          'Acquiring client from pool timed out. Please review your system setup, transaction handling, and pool configuration.'
-      }
-
-      throw err
+      client = await pool.acquire()
+    } catch (e) {
+      if (e.name !== 'TimeoutError') throw e
+      err = e
+      attempt++
     }
+  }
+  if (client) return client
+  err.statusCode = 503
+  err.message =
+    'Acquiring client from pool timed out. Please review your system setup, transaction handling, and pool configuration.'
+  err._attempts = attempt
+  throw err
+}
+
+module.exports = {
+  acquire: async (tenant, credentials) => {
+    const pool = await pool4(tenant, credentials)
+    const _attempts = cds.env.requires.db.connection_attempts
+    const attempts = _attempts && !isNaN(_attempts) && parseInt(_attempts)
+    const client = await resilientAcquire(pool, attempts)
+    client._pool = pool
+    return client
   },
   release: client => {
     return client._pool.release(client)

package/libx/_runtime/hana/search2cqn4sql.js

@@ -41,7 +41,7 @@ const search2cqn4sql = (cqn, entity, options) => {
     const onCondition = getOnCond(localizedAssociation, onConditionOptions)
 
     // replace $user_locale placeholder with the user locale or the HANA session context
-    onCondition[onCondition.length - 2].ref[0] = `'${locale}'` || "SESSION_CONTEXT('LOCALE')"
+    onCondition[onCondition.length - 2] = { val: locale || "SESSION_CONTEXT('LOCALE')" }
 
     // inner join the target table with the _texts table (the _texts table contains
     // the translated texts)
@@ -54,6 +54,7 @@ const search2cqn4sql = (cqn, entity, options) => {
     // defined.
     cqn.SELECT.columns = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.columns)
     columns = _unshiftEntityNameToColumnRef(entity, columns)
+    if (cqn.SELECT.groupBy) cqn.SELECT.groupBy = _unshiftEntityNameToColumnRef(entity, cqn.SELECT.groupBy)
   } // else --> resolve localized texts via localized view (default)
 
   const useContains = resolveLocalizedTextsAtRuntime && isContainsPredicateSupported(cqn)

package/libx/_runtime/hana/searchToContains.js

@@ -3,14 +3,14 @@
  *
  * OData search string           | `CONTAINS` search string
  * ----------------------------- | ------------------------
- * `foo`                         | `%foo%`
- * `NOT foo`                     | `-%foo%`
- * `foo AND bar`                 | `%foo% %bar%`
- * `foo OR bar`                  | `%foo% OR %bar%`
- * `foo or bar`                  | `%foo% OR %bar%`
- * `" foo" OR " bar"`            | `%" "foo% OR %" "bar%`
- * ` foo`                        | `%" "foo%`
- * `foo bar`                     | `%foo% %bar%`
+ * `foo`                         | `"%foo%"`
+ * `NOT foo`                     | `-"%foo%"` (Currently disabled -> BCP 2180256508)
+ * `foo AND bar`                 | `"%foo%" "%bar%"`
+ * `foo OR bar`                  | `"%foo%" OR "%bar%"`
+ * `foo or bar`                  | `"%foo%" OR "%bar%"`
+ * `" foo" OR " bar"`            | `"% foo%" OR "% bar%"`
+ * ` foo`                        | `"% foo%"`
+ * `foo bar`                     | `"%foo%" "%bar%"`
  *
  * **Some limitations of the `CONTAINS` predicate in SAP HANA:**
  * - The `-` (minus sign) search operator can not be placed directly after `OR`.
@@ -38,15 +38,15 @@ const searchToContains = (cqnSearchPhrase, columns) => {
     // the - (minus sign) is used to exclude terms from the search
     if (currentValue === 'not') return (searchStringAccumulator += '-')
 
-    // surround whitespace(s) with "" (double quotes)
-    const searchTermEscaped = currentValue.val.replace(/(\s+)/g, '"$&"')
+    // escape double quotation mark(s) with \\
+    const searchTermEscaped = currentValue.val.replace(/"/g, '\\$&')
 
     // A search term enclosed with the wildcard character % (percentage sign)
     // is used to match zero or more characters. In SAP HANA, the % sign is
     // replaced with an asterisk (*), and a wildcard search is run.
     // The % sign also prevents ambiguity, as a search input might contain
     // an 'OR' (uppercase characters), causing semantics issues.
-    return (searchStringAccumulator += `%${searchTermEscaped}%`)
+    return (searchStringAccumulator += `"%${searchTermEscaped}%"`)
   }, '')
 
   const expressionArgs = [{ list: columns }, { val: searchString }]
@@ -71,9 +71,13 @@ const isContainsPredicateSupported = cqn => {
   // want to remove the following condition(s).
   if (cqn._aggregated) return false
 
-  // search terms starting with a whitespace after a `NOT` operator does
-  // not return the expected result
-  if (cqnSearchPhrase[0] === 'not' && cqnSearchPhrase[1].val[0] === ' ') return false
+  // REVISIT: search terms starting with whitespace after a `NOT` operator does not
+  // return the expected result on SAP HANA (BCP 2180256508). In addition, double
+  // quotation marks after a `NOT` operator do not return the desired result.
+  // if (cqnSearchPhrase[0] === 'not' && cqnSearchPhrase[1].val[0] === ' ') return false
+
+  // so for now do not optimize for the `NOT` operator
+  if (cqnSearchPhrase[0] === 'not') return false
 
   // The `AND` operator in combination with the `OR` operator does not
   // return the expected result

package/libx/_runtime/index.js

@@ -16,11 +16,6 @@ module.exports = {
     return this._auth || (this._auth = require('./common/auth'))
   },
 
-  /** @type {import('./cds-services/statements')} */
-  get statements() {
-    return this._statements || (this._statements = require('./cds-services/statements'))
-  },
-
   // REVISIT: remove once not needed anymore
   get performanceMeasurement() {
     return this._perf || (this._perf = require('./cds-services/adapter/perf/performanceMeasurement'))

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -28,15 +28,23 @@ class AMQPWebhookMessaging extends MessagingService {
     return client.emit(msg)
   }
 
-  startListening() {
+  startListening(opt = {}) {
     if (this.subscribedTopics.size) {
       const management = this.getManagement()
-      this.queued(management.createQueueAndSubscriptions.bind(management))()
+      if (!opt.doNotDeploy) this.queued(management.createQueueAndSubscriptions.bind(management))()
       this.queued(this.listenToClient.bind(this))(async (_topic, _payload, _other, { done, failed }) => {
         const event = _topic
-        const data = _payload.data
-        const headers = { ..._payload }
-        delete headers.data
+        // Some messaging systems don't adhere to the standard that the payload has a `data` property.
+        // For these cases, we interpret the whole payload as `data`.
+        let data, headers
+        if ('data' in _payload) {
+          data = _payload.data
+          headers = { ..._payload }
+          delete headers.data
+        } else {
+          data = _payload
+          headers = {}
+        }
         const msg = {
           event,
           data,

package/libx/_runtime/messaging/common-utils/naming-conventions.js

@@ -5,7 +5,10 @@ const _queueName = ({ appName, appID, ownNamespace }) => {
 
 const queueName = (options, optionsApp = {}) => {
   const namespace = options.credentials && options.credentials.namespace
-  if (options.queue && options.queue.name) return options.queue.name
+  if (options.queue && options.queue.name) {
+    if (options.credentials.namespace) return options.queue.name.replace(/\$namespace/g, options.credentials.namespace)
+    return options.queue.name
+  }
   const ownNamespace = namespace
   return _queueName({
     appName: optionsApp.appName || 'CAP',

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

@@ -4,7 +4,6 @@ const LOG = cds.log('messaging')
 const sleep = require('util').promisify(setTimeout)
 
 const _getWebhookName = queueName => queueName
-const isSecured = () => cds.requires.uaa && cds.requires.uaa.credentials
 
 // REVISIT: Maybe use `error` definitions as in req.error?
 
@@ -52,6 +51,20 @@ class EMManagement {
     return res.body
   }
 
+  async getQueues() {
+    const res = await authorizedRequest({
+      method: 'GET',
+      uri: this.options.uri,
+      path: `/hub/rest/api/v1/management/messaging/queues`,
+      oa2: this.options.oa2,
+      attemptInfo: () => LOG._info && LOG.info('Get queues', this.subdomain ? { subdomain: this.subdomain } : {}),
+      errMsg: `Queues could not be retrieved ${this.subdomainInfo}`,
+      target: { kind: 'QUEUE' },
+      tokenStore: this
+    })
+    return res.body
+  }
+
   createQueue(queueName = this.queueName) {
     return authorizedRequest({
       method: 'PUT',
@@ -196,26 +209,25 @@ class EMManagement {
     const pushConfig = {
       type: 'webhook',
       endpoint: this.optionsApp.appURL + this.path,
-      exemptHandshake: false
+      exemptHandshake: false,
+      defaultContentType: 'application/json'
     }
-    if (isSecured()) {
-      // Use credentials from Enterprise Messaging.
-      // For it to work, you'll need to add scopes in your
-      // xs-security.json:
-      //
-      // scopes: [{
-      //   "name": "$XSAPPNAME.em",
-      //   "description": "EM Callback Access",
-      //   "grant-as-authority-to-apps": ["$XSSERVICENAME(messaging-name)"]
-      // }]
 
-      pushConfig.securitySchema = {
-        type: 'oauth2',
-        grantType: 'client_credentials',
-        clientId: this.optionsMessagingREST.oa2.client,
-        clientSecret: this.optionsMessagingREST.oa2.secret,
-        tokenUrl: this.optionsMessagingREST.oa2.endpoint
-      }
+    // Use credentials from Enterprise Messaging.
+    // For it to work, you'll need to add scopes in your
+    // xs-security.json:
+    //
+    // scopes: [{
+    //   "name": "$XSAPPNAME.em",
+    //   "description": "EM Callback Access",
+    //   "grant-as-authority-to-apps": ["$XSSERVICENAME(messaging-name)"]
+    // }]
+    pushConfig.securitySchema = {
+      type: 'oauth2',
+      grantType: 'client_credentials',
+      clientId: this.optionsMessagingREST.oa2.client,
+      clientSecret: this.optionsMessagingREST.oa2.secret,
+      tokenUrl: this.optionsMessagingREST.oa2.endpoint
     }
 
     const dataObj = {

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

@@ -1,5 +1,4 @@
 const cds = require('../../cds.js')
-const bodyParser = require('body-parser')
 const LOG = cds.log('messaging')
 const express = require('express')
 const getTenantInfo = require('./getTenantInfo.js')
@@ -28,7 +27,7 @@ class EndpointRegistry {
     paths.forEach(path => {
       cds.app.use(path, express.json({ type: 'application/*+json' }))
       cds.app.use(path, express.json())
-      cds.app.use(path, bodyParser.urlencoded({ extended: true }))
+      cds.app.use(path, express.urlencoded({ extended: true }))
     })
     LOG._debug && LOG.debug('Register inbound endpoint', { basePath, method: 'OPTIONS' })