@sap/cds 5.7.3 → 5.8.1

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

@@ -3,10 +3,8 @@ const { SELECT } = cds.ql
 
 const { cqn2cqn4sql, convertWhereExists } = require('../../common/utils/cqn2cqn4sql')
 const { getElementDeep } = require('../../common/utils/csn')
-
 const { DRAFT_COLUMNS, DRAFT_COLUMNS_MAP, SCENARIO } = require('../../common/constants/draft')
 const {
-  adaptStreamCQN,
   addColumnAlias,
   draftIsLocked,
   ensureDraftsSuffix,
@@ -18,8 +16,8 @@ const {
   filterKeys
 } = require('../utils/handler')
 const { deleteCondition, readAndDeleteKeywords, removeIsActiveEntityRecursively } = require('../utils/where')
-
 const { getColumns } = require('../../cds-services/services/utils/columns')
+const { adaptStreamCQN } = require('../../cds-services/adapter/odata-v4/utils/stream')
 
 const _findRootSubSelectFor = query => {
   if (query.SELECT.where) {
@@ -50,7 +48,8 @@ const _getWhereWithAppendedDraftRestrictions = (where = [], req, scenarioAlias,
             })
 
         if (where.length) where.push('and')
-        where.push(...xpr)
+        // restriction might contain or clause -> use xpr for grouping
+        xpr.includes('or') ? where.push({ xpr }) : where.push(...xpr)
       } else {
         // > restriction inherited from parent via autoexposure
         // find inner most sub select if available and append restriction to where clause
@@ -778,13 +777,16 @@ const _getDraftDoc = (req, draftName, draftWhere) => {
   return draftDocs
 }
 
-const _getOrderByEnrichedColumns = (orderBy, columns) => {
+const _getOrderByEnrichedColumns = (orderBy, columns, entity) => {
   const enrichedCol = []
   if (orderBy && orderBy.length > 1) {
     const colNames = columns.map(el => el.ref[el.ref.length - 1])
     // REVISIT: GET Books?$select=title&$expand=NotBooks($select=pages)&$orderby=NotBooks/title - what's then?
     for (const el of orderBy) {
-      if (!DRAFT_COLUMNS.includes(el.ref[el.ref.length - 1]) && !colNames.includes(el.ref[el.ref.length - 1])) {
+      // For associations we need to 'materialise' the resulting field, otherwise we cannot access it in an outer SELECT.
+      if (entity && entity.elements[el.ref[0]] && entity.elements[el.ref[0]].isAssociation) {
+        enrichedCol.push({ ref: [...el.ref], as: _poorMansAlias4(el) })
+      } else if (!DRAFT_COLUMNS.includes(el.ref[el.ref.length - 1]) && !colNames.includes(el.ref[el.ref.length - 1])) {
         enrichedCol.push({ ref: [...el.ref] })
       }
     }
@@ -806,11 +808,11 @@ const _replaceDraftAlias = where => {
 
 const _poorMansAlias4 = xpr => '_' + xpr.ref.join('_') + '_'
 
-const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere, model) => {
+const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere, model, entity) => {
   const draftActiveWhere = _getWhereForActive(draftWhere)
   const activeDocs = getEnrichedCQN(SELECT.from(req.target), req.query.SELECT, draftActiveWhere, undefined, false)
   activeDocs.where(_getWhereWithAppendedDraftRestrictions([], req))
-  convertWhereExists(activeDocs, model, {})
+  convertWhereExists(activeDocs.SELECT, model, {})
 
   // @restrict.where not applicable for drafts (I can ALWAYS read mine)
   _replaceDraftAlias(draftWhere)
@@ -837,7 +839,7 @@ const _getUnionCQN = (req, draftName, columns, subSelect, draftWhere, model) =>
     return union.columns({ func: 'sum', args: [{ ref: ['$count'] }], as: '$count' })
   }
 
-  const enrichedColumns = _getOrderByEnrichedColumns(req.query.SELECT.orderBy, columns)
+  const enrichedColumns = _getOrderByEnrichedColumns(req.query.SELECT.orderBy, columns, entity)
 
   for (const col of enrichedColumns) {
     // if we have columns for outer order by that may also be needed for joins, we need to duplicate them
@@ -914,12 +916,14 @@ const _excludeActiveDraftExists = (req, draftWhere, columns, model) => {
     ])
     .where(_inProcessByUserWhere(req.user.id))
 
+  const targetName = ensureNoDraftsSuffix(req.target.name)
   for (const key of _getTargetKeys(req)) {
-    subSelect.where([{ ref: [ensureNoDraftsSuffix(req.target.name), key] }, '=', { ref: [draftName, key] }])
+    subSelect.where([{ ref: [targetName, key] }, '=', { ref: [draftName, key] }])
   }
 
+  const entity = model.definitions[targetName]
   draftWhere = removeIsActiveEntityRecursively(draftWhere)
-  const cqn = _getUnionCQN(req, draftName, columns, subSelect, draftWhere, model)
+  const cqn = _getUnionCQN(req, draftName, columns, subSelect, draftWhere, model, entity)
   cqn.SELECT.from.as = name
 
   if (cqn.SELECT.orderBy) {
@@ -959,13 +963,16 @@ const _validatedWithSiblingInProcess = (req, draftWhere, draftParameters, column
   )
     return _excludeActiveDraftExists(req, draftWhere, columns, model)
   if (
+    draftInProcessByUser &&
     draftInProcessByUser.op === '!=' &&
     _isValidWithDraftLocked(isActiveEntity, siblingIsActive, draftInProcessByUser)
   ) {
     return _activeWithDraftInProcess(req, draftWhere, columns, req.user.id)
-  } else if (_isValidWithDraftTimeout(isActiveEntity, siblingIsActive, draftInProcessByUser)) {
+  } else if (draftInProcessByUser && _isValidWithDraftTimeout(isActiveEntity, siblingIsActive, draftInProcessByUser)) {
     return _activeWithDraftInProcess(req, draftWhere, columns, null)
   }
+
+  //
 }
 
 const _validatedDraftOfWhichIAmOwner = (req, draftWhere, draftParameters, columns) =>
@@ -1214,16 +1221,13 @@ const _handler = async function (req) {
   // handle localized here as it was previously handled for req.target
   req.target = _getLocalizedEntity(this.model, req.target, req.user) || req.target
 
-  // REVISIT
-  delete req.query._validationQuery
-
   const originalFrom = _copyCQNPartial(req.query.SELECT.from)
 
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
-  const sqlQuery = cqn2cqn4sql(req.query, this.model, { draft: true })
+  const query4sql = cqn2cqn4sql(req.query, this.model, { _4fiori: true })
 
   // do not clone with Object.assign as that would skip all non-enumerable properties
-  const reqClone = { __proto__: req, query: _copyCQNPartial(sqlQuery) }
+  const reqClone = { __proto__: req, query: _copyCQNPartial(query4sql) }
 
   // ensure draft restrictions are copied to new query
   reqClone.query._draftRestrictions = req.query._draftRestrictions
@@ -1233,6 +1237,7 @@ const _handler = async function (req) {
     reqClone.query._streaming = true
     return cds.tx(req).run(reqClone.query)
   }
+
   let cqnScenario
 
   // to replace scenario CQNs for queries with $apply SELECT chain (new odata2cqn parser)
@@ -1263,16 +1268,13 @@ const _handler = async function (req) {
   )
 
   _adaptSubSelects(cqnScenario.cqn, cqnScenario.scenario)
-
   _adaptAnnotationAliases(cqnScenario.cqn)
 
   // unlocalize for db and after handlers as it was before
   req.target = this.model.definitions[ensureUnlocalized(req.target.name)]
 
   const result = await cds.tx(req).send({ query: cqnScenario.cqn, target: req.target })
-
   const resultAsArray = Array.isArray(result) ? result : result ? [result] : []
-
   removeDraftUUIDIfNecessary(resultAsArray, req)
 
   if (cqnScenario.scenario === SCENARIO.DRAFT_ADMIN) {

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

@@ -45,7 +45,7 @@ const _handler = async function (req) {
   }
 
   // REVISIT DRAFT HANDLING: cqn2cqn4sql must not be called here
-  const sqlQuery = cqn2cqn4sql(req.query, this.model, { draft: true })
+  const sqlQuery = cqn2cqn4sql(req.query, this.model, { _4fiori: true })
   if (req.query._streaming) {
     sqlQuery._streaming = true
   }
@@ -53,9 +53,6 @@ const _handler = async function (req) {
   const hasDraftEntity = hasDraft(this.model.definitions, sqlQuery)
 
   if (hasDraftEntity && sqlQuery.SELECT.where && sqlQuery.SELECT.where.length !== 0) {
-    // REVISIT
-    delete req.query._validationQuery
-
     let cqnDraft = SELECT.from({
       ref: [...sqlQuery.SELECT.from.ref],
       as: sqlQuery.SELECT.from.as

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

@@ -1,6 +1,5 @@
 const cds = require('../../cds')
 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')
@@ -126,7 +125,7 @@ const getEnrichedCQN = (cqn, select, draftWhere, scenarioAlias, addLimitOrder =
   }
 
   if (select.distinct) {
-    cqn.distinct()
+    cqn.SELECT.distinct = true
   }
 
   const alias = (select.from && select.from.as) || scenarioAlias
@@ -249,14 +248,6 @@ const replaceRefWithDraft = ref => {
   ref[0] = ensureDraftsSuffix(ref[0])
 }
 
-const adaptStreamCQN = cqn => {
-  if (isActiveEntityRequested(cqn.SELECT.where)) {
-    cqn.SELECT.where = removeIsActiveEntityRecursively(cqn.SELECT.where)
-  } else {
-    replaceRefWithDraft(cqn.SELECT.from.ref)
-  }
-}
-
 const draftIsLocked = lastChangedAt => {
   // default timeout timer is 15 minutes
   const DRAFT_CANCEL_TIMEOUT_IN_MS = ((cds.env.drafts && cds.env.drafts.cancellationTimeout) || 15) * 60 * 1000
@@ -289,7 +280,6 @@ module.exports = {
   hasDraft,
   proxifyToNoDraftsName,
   addColumnAlias,
-  adaptStreamCQN,
   replaceRefWithDraft,
   getKeyProperty,
   filterKeys,

package/libx/_runtime/hana/Service.js

@@ -41,7 +41,7 @@ class HanaDatabase extends DatabaseService {
     this._insert = this._queries.insert(execute.insert)
     this._read = this._queries.read(execute.select, execute.stream)
     this._update = this._queries.update(execute.update, execute.select)
-    this._delete = this._queries.delete(execute.delete)
+    this._delete = this._queries.delete(execute.delete, execute.update)
     this._run = this._queries.run(this._insert, this._read, this._update, this._delete, execute.cqn, execute.sql)
   }
 

package/libx/_runtime/hana/conversion.js

@@ -1,3 +1,5 @@
+const cds = require('../cds')
+
 const convertToBoolean = boolean => {
   if (boolean === null) {
     return null
@@ -44,9 +46,18 @@ const HANA_TYPE_CONVERSION_MAP = new Map([
   ['cds.Integer64', convertInt64ToString],
   ['cds.DateTime', convertToISONoMillis],
   ['cds.Timestamp', convertToISO],
-  ['cds.LargeString', convertToString]
+  ['cds.LargeString', convertToString],
+  ['cds.hana.CLOB', convertToString]
 ])
 
+if (cds.env.features.bigjs) {
+  const Big = require('big.js')
+  const convertToBig = value => new Big(value)
+
+  HANA_TYPE_CONVERSION_MAP.set('cds.Integer64', convertToBig)
+  HANA_TYPE_CONVERSION_MAP.set('cds.Decimal', convertToBig)
+}
+
 module.exports = {
   HANA_TYPE_CONVERSION_MAP
 }

package/libx/_runtime/hana/execute.js

@@ -1,3 +1,6 @@
+const cds = require('../cds')
+const LOG = cds.log('hana|db|sql')
+
 const { HANA_TYPE_CONVERSION_MAP } = require('./conversion')
 const CustomBuilder = require('./customBuilder')
 const { sqlFactory } = require('../db/sql-builder/')
@@ -30,9 +33,6 @@ function _cqnToSQL(model, query, user, locale, txTimestamp) {
   )
 }
 
-const cds = require('../cds')
-const LOG = cds.log('hana|db|sql')
-
 const SANITIZE_VALUES = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
 
 function _getOutputParameters(stmt) {
@@ -48,6 +48,24 @@ function _getOutputParameters(stmt) {
   return Object.keys(result).length > 0 ? result : undefined
 }
 
+const BINARY_TYPES = {
+  12: 'BINARY',
+  13: 'VARBINARY',
+  27: 'BLOB'
+}
+
+function _getBinaries(stmt) {
+  // hdb vs. @sap/hana-client
+  const parameters = stmt.parameterMetadata || stmt.getParameterInfo()
+  const typeKey = stmt.parameterMetadata ? 'dataType' : 'nativeType'
+  return parameters.reduce((acc, cur, i) => {
+    if (BINARY_TYPES[cur[typeKey]]) acc.push(i)
+    return acc
+  }, [])
+}
+
+const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{4}|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{2}={2})$/
+
 function _executeAsPreparedStatement(dbc, sql, values, reject, resolve) {
   dbc.prepare(sql, function (err, stmt) {
     if (err) {
@@ -56,18 +74,15 @@ function _executeAsPreparedStatement(dbc, sql, values, reject, resolve) {
       return reject(err)
     }
 
-    // REVISIT: adjust binary values on hdb
-    if (_hasValues(values) && dbc.name === 'hdb' && stmt.parameterMetadata) {
-      const vals = Array.isArray(values[0]) ? values : [values]
-      for (const row of vals) {
-        for (let i = 0; i < stmt.parameterMetadata.length; i++) {
-          /*
-           * BINARY: 12
-           * VARBINARY: 13
-           */
-          if (stmt.parameterMetadata[i].dataType === 12 || stmt.parameterMetadata[i].dataType === 13) {
-            if (row[i] && !Buffer.isBuffer(row[i])) {
-              row[i] = Buffer.from(row[i].match(/.{1,2}/g).map(val => parseInt(val, 16)))
+    // convert binary strings to buffers ()
+    if (cds.env.hana.base64_to_buffer !== false && _hasValues(values)) {
+      const binaries = _getBinaries(stmt)
+      if (binaries.length) {
+        const vals = Array.isArray(values[0]) ? values : [values]
+        for (const i of binaries) {
+          for (const row of vals) {
+            if (row[i] && typeof row[i] === 'string' && row[i].match(BASE64)) {
+              row[i] = Buffer.from(row[i], 'base64')
             }
           }
         }
@@ -108,7 +123,7 @@ function _executeSimpleSQL(dbc, sql, values) {
       values = Object.values(values)
     }
     // ensure that stored procedure with parameters is always executed as prepared
-    if (_hasValues(sql, values) || sql.match(/^call.*?\?.*$/i)) {
+    if (_hasValues(values) || sql.match(/^call.*?\?.*$/i)) {
       _executeAsPreparedStatement(dbc, sql, values, reject, resolve)
     } else {
       dbc.exec(sql, function (err, result, procedureReturn) {

package/libx/_runtime/hana/localized.js

@@ -31,7 +31,7 @@ const localizedHandler = function (req) {
   // suppress localization in "select for update"
   if (query.SELECT.forUpdate) return
 
-  redirect(query.SELECT, getLocalize(req.locale, this.model))
+  redirect(query, getLocalize(req.locale, this.model))
 }
 
 localizedHandler._initial = true

package/libx/_runtime/hana/search.js

@@ -11,9 +11,9 @@ function searchHandler(req) {
   // REVISIT: remove feature toggle optimized_search after grace period
   // inject the search2cqn4sql module into the rewrite handler only when
   // the optimized search feature toggle is turned on
-  if (!cds.env.features.optimized_search) return
-
-  _setSearchOptions(req.query, { search2cqn4sql, locale: req.locale })
+  if (cds.env.features.optimized_search) {
+    _setSearchOptions(req.query, { search2cqn4sql, locale: req.locale })
+  }
 }
 
 // handlers marked with `._initial = true` run in sequence

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,6 +1,7 @@
 const { computeColumnsToBeSearched } = require('../cds-services/services/utils/columns')
 const searchToLike = require('../common/utils/searchToLike')
 const { isContainsPredicateSupported, searchToContains } = require('./searchToContains')
+const { addAliasToExpression } = require('../db/utils/generateAliases')
 
 /**
  * Computes a CQN expression for a search query.
@@ -33,8 +34,7 @@ const search2cqn4sql = (query, entity, options) => {
   // suppress the localize handler from redirecting the query's target to the localized view
   Object.defineProperty(query, '_suppressLocalization', { value: true })
 
-  // do not join if subquery exists - already done in there
-  if (resolveLocalizedDataAtRuntime && !query.SELECT.from.SELECT) {
+  if (resolveLocalizedDataAtRuntime) {
     const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
     // replace $user_locale placeholder with the user locale or the HANA session context
@@ -46,56 +46,54 @@ const search2cqn4sql = (query, entity, options) => {
     query.join(localizedEntityName).on(onCondition)
 
     // prevent SQL ambiguity error for columns with the same name
-    columnsToBeSearched = _addAliasToColumns(query, entity, columnsToBeSearched)
+    columnsToBeSearched = _addAliasToQuery(query, entity, columnsToBeSearched)
   } // else --> resolve localized texts via localized view (default)
 
   const useContains = isContainsPredicateSupported(query)
   let expression
 
   if (useContains) {
-    const funcCols = columnsToBeSearched.filter(col => col.func)
-    const refCols = columnsToBeSearched.filter(col => !col.func)
-    expression = [searchToContains(cqnSearchPhrase, refCols)]
-    if (funcCols.length) expression.push('or', ...searchToLike(cqnSearchPhrase, funcCols))
+    const namedColumns = columnsToBeSearched.filter(col => !col.func)
+    expression = searchToContains(cqnSearchPhrase, namedColumns)
+
+    // func columns handling
+    if (columnsToBeSearched.length > namedColumns.length) {
+      const funcColumns = columnsToBeSearched.filter(col => col.func)
+      expression = [expression, 'or', ...searchToLike(cqnSearchPhrase, funcColumns)]
+    }
   } else {
     // No CONTAINS optimization possible. The search implementation for localized
     // texts falls back to the LIKE predicate.
     expression = searchToLike(cqnSearchPhrase, columnsToBeSearched)
   }
+
   // REVISIT: find out here if where or having must be used
   query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
   return query
 }
 
-const _getLocalizedAssociation = entity => {
-  const associations = entity.associations
-  return associations && associations.localized
-}
+const _getLocalizedAssociation = entity => entity.associations && entity.associations.localized
 
 // The inner join modifies the original SELECT ... FROM query and adds ambiguity,
 // therefore add the table/entity name (as a preceding element) to the columns ref
 // to prevent a SQL ambiguity error.
-const _addAliasToColumns = (query, entity, columnsToBeSearched) => {
+const _addAliasToQuery = (query, entity, columnsToBeSearched) => {
+  const SELECT = query.SELECT
   const localizedEntityName = _getLocalizedAssociation(entity).target
   const elements = entity.elements
   const entityName = entity.name
-  const _addAliasToColumn = (entityName, localizedEntityName, elements) => column => {
-    const columnRef = column.ref
-    if (!columnRef) return column
+  const getEntityName = columnRef => {
     const columnName = columnRef[0]
-    const localizedElement = elements[columnName].localized
+    const localizedElement = !!elements[columnName].localized
     const targetEntityName = localizedElement ? localizedEntityName : entityName
-    return { ref: [targetEntityName, columnName] }
-  }
-
-  query.SELECT.columns = query.SELECT.columns.map(_addAliasToColumn(entityName, localizedEntityName, elements))
-  const columns = columnsToBeSearched.map(_addAliasToColumn(entityName, localizedEntityName, elements))
-
-  if (query.SELECT.groupBy) {
-    query.SELECT.groupBy = query.SELECT.groupBy.map(_addAliasToColumn(entityName, localizedEntityName, elements))
+    return targetEntityName
   }
 
-  return columns
+  SELECT.columns = addAliasToExpression(SELECT.columns, getEntityName)
+  columnsToBeSearched = addAliasToExpression(columnsToBeSearched, getEntityName)
+  SELECT.groupBy = addAliasToExpression(SELECT.groupBy, getEntityName)
+  SELECT.where = addAliasToExpression(SELECT.where, getEntityName)
+  return columnsToBeSearched
 }
 
 module.exports = search2cqn4sql

package/libx/_runtime/hana/searchToContains.js

@@ -25,7 +25,7 @@
  * @returns {import("../types/api").searchContainsExp} The `CONTAINS` CQN expression
  */
 const searchToContains = (cqnSearchPhrase, columns) => {
-  // serialize CQN search phrase
+  // serialize the CQN search phrase
   const searchString = cqnSearchPhrase.reduce((searchStringAccumulator, currentValue) => {
     // Multiple search terms separated by an space are automatically
     // interpreted as an AND operator. Therefore, it is not mandatory

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -58,8 +58,10 @@ class AMQPWebhookMessaging extends MessagingService {
           await super.emit(msg)
           done()
         } catch (e) {
-          failed()
-          LOG._error && LOG.error(e)
+          // In case of AMQP and Solace, the `failed` callback must be called
+          // with an error, otherwise there are problems with the redelivery count.
+          failed(new Error('processing failed'))
+          LOG.error('ERROR occured in asynchronous event processing:', e)
         }
       })
     }

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

@@ -65,7 +65,6 @@ class EndpointRegistry {
         const other = authInfo
           ? {
               _: { req: { authInfo, headers: {}, query: {} } }, // for messaging to retrieve subdomain
-              user: new cds.User.Privileged(),
               tenant: tenantId
             }
           : {}

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

@@ -20,6 +20,7 @@ const _checkAppURL = appURL => {
     throw new Error(
       'Enterprise Messaging: You need to provide an HTTPS endpoint to your application.\n\nHint: You can set the application URI in environment variable `VCAP_APPLICATION.application_uris[0]`. This is needed because incoming messages are delivered through HTTP via webhooks.\nExample: `{ ..., "VCAP_APPLICATION": { "application_uris": ["my-app.com"] } }`\nIn case you want to use Enterprise Messaging in shared (that means single-tenant) mode, you can use kind `enterprise-messaging-amqp`.'
     )
+
   if (appURL.startsWith('https://localhost'))
     throw new Error(
       'The endpoint of your application is local and cannot be reached from Enterprise Messaging.\n\nHint: For local development you can set up a tunnel to your local endpoint and enter its public https endpoint in `VCAP_APPLICATION.application_uris[0]`.\nIn case you want to use Enterprise Messaging in shared (that means single-tenant) mode, you can use kind `enterprise-messaging-amqp`.'

package/libx/_runtime/messaging/file-based.js

@@ -53,7 +53,9 @@ class FileBasedMessaging extends MessagingService {
               if (this.subscribedTopics.has(topic)) {
                 const event = this.subscribedTopics.get(topic)
                 if (!event) return
-                super.emit({ event, ...json, inbound: true }).catch(e => LOG._debug && LOG.debug(e))
+                super
+                  .emit({ event, ...json, inbound: true })
+                  .catch(e => LOG.error('ERROR occured in asynchronous event processing:', e))
               } else other.push(each + '\n')
             }
           } catch (e) {

package/libx/_runtime/messaging/service.js

@@ -26,17 +26,24 @@ class MessagingService extends OutboxService {
     this.subscribedTopics = new Map()
     // Only for one central `messaging` service, otherwise all technical services would register themselves
     if (this.name === 'messaging') {
+      this._registeredServices = new Map()
       // listen for all subscriptions to declared events of remote, i.e. connected services
       cds.on('subscribe', (srv, event) => {
         const declared = srv.events[event]
         if (declared && srv.name in cds.requires && !srv.mocked) {
           // we register self-handlers for declared events, which are supposed
           // to be calles by subclasses calling this.dispatch on incoming events
+          let registeredEvents = this._registeredServices.get(srv.name)
+          if (!registeredEvents) {
+            registeredEvents = new Set()
+            this._registeredServices.set(srv.name, registeredEvents)
+          }
+          if (registeredEvents.has(event)) return
+          registeredEvents.add(event)
           const topic = _topic(declared)
-          this.on(topic, async (msg, next) => {
+          this.on(topic, msg => {
             const { data, headers } = msg
-            await srv.tx(msg).emit({ event, data, headers, __proto__: msg })
-            return next()
+            return srv.tx(msg).emit({ event, data, headers, __proto__: msg })
           })
         }
       })
@@ -48,10 +55,9 @@ class MessagingService extends OutboxService {
           // calls to srv.emit are forwarded to this.emit, which is expected to
           // be overwritten by subclasses to write events to message channel
           const topic = _topic(declared)
-          srv.on(event, async (msg, next) => {
+          srv.on(event, msg => {
             const { data, headers } = msg
-            await this.tx(msg).emit({ event: topic, data, headers })
-            return next()
+            return this.tx(msg).emit({ event: topic, data, headers })
           })
         }
       })
@@ -69,7 +75,8 @@ class MessagingService extends OutboxService {
   }
 
   emit(event, data, headers) {
-    const msg = event instanceof cds.Event ? event : new cds.Event(this.message4(event, data, headers))
+    const _msg = typeof event === 'object' ? event : { event, data, headers }
+    const msg = _msg instanceof cds.Event ? _msg : new cds.Event(this.message4(_msg))
     return super.emit(msg)
   }
 
@@ -102,6 +109,8 @@ class MessagingService extends OutboxService {
 
   message4(msg) {
     const _msg = { ...msg }
+    if (msg.inbound && !cds.context)
+      _msg.user = msg.tenant ? new cds.User.Privileged({ tenant: msg.tenant }) : new cds.User.Privileged()
     _msg.event = _warnAndStripTopicPrefix(_msg.event)
     if (!_msg.headers) _msg.headers = {}
     if (!_msg.inbound) {