@sap/cds 7.8.1 → 7.9.0

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

@@ -5,6 +5,9 @@ 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 LOG = cds.log('fiori|drafts')
 const original = Symbol('original')
@@ -73,10 +76,10 @@ const LOCK_TIMEOUT = {
 }
 
 const reject_bypassed_draft = req => {
-  const msg =
+  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.'
-  return req.reject(501, msg)
+  return req.reject({ code: 501, statusCode: 501, message })
 }
 
 const DRAFT_ELEMENTS = new Set([
@@ -322,8 +325,10 @@ cds.ApplicationService.prototype.handle = async function (req) {
     return result
   }
 
+  if (req.event === 'draftEdit') req.event = 'EDIT'
+
   if (req.event === 'NEW' || req.event === 'CANCEL' || req.event === 'draftPrepare') {
-    if (req.event === 'draftPrepare' && draftParams.IsActiveEntity) req.reject(400)
+    if (req.event === 'draftPrepare' && draftParams.IsActiveEntity) req.reject({ code: 400, statusCode: 400 })
     if (req.event === 'NEW' && req.data?.IsActiveEntity === true) {
       if (!cds.env.fiori.bypass_draft && !req.target['@odata.draft.bypass']) return reject_bypassed_draft(req)
       const containsDraftRoot =
@@ -331,7 +336,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
           '@Common.DraftRoot.ActivationAction'
         ]
 
-      if (!containsDraftRoot) req.reject(403, 'DRAFT_MODIFICATION_ONLY_VIA_ROOT')
+      if (!containsDraftRoot) req.reject({ code: 403, statusCode: 403, message: 'DRAFT_MODIFICATION_ONLY_VIA_ROOT' })
 
       const isDirectAccess = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
       const data = Object.assign({}, req.data) // IsActiveEntity is not enumerable
@@ -355,7 +360,7 @@ cds.ApplicationService.prototype.handle = async function (req) {
         rootHasDraft = await SELECT.one([1]).from({ ref: draftsRootRef }).where(keyData)
       }
 
-      if (rootHasDraft) req.reject(409, 'DRAFT_ALREADY_EXISTS')
+      if (rootHasDraft) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
 
       const cqn = INSERT.into(query.INSERT.into).entries(data)
       await run(cqn, { event: 'CREATE' })
@@ -393,8 +398,8 @@ cds.ApplicationService.prototype.handle = async function (req) {
     const draft = await draftQuery
     const inProcessByUser = draft?.DraftAdministrativeData?.InProcessByUser
     if (inProcessByUser && inProcessByUser !== cds.context.user.id)
-      req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [inProcessByUser])
-    if (draft) req.reject(403, 'DRAFT_ACTIVE_DELETE_FORBIDDEN_DRAFT_EXISTS')
+      req.reject({ code: 403, statusCode: 403, message: 'DRAFT_LOCKED_BY_ANOTHER_USER', args: [inProcessByUser] })
+    if (draft) req.reject({ code: 403, statusCode: 403, message: 'DRAFT_ACTIVE_DELETE_FORBIDDEN_DRAFT_EXISTS' })
     await run(query)
     return req.data
   }
@@ -405,11 +410,15 @@ cds.ApplicationService.prototype.handle = async function (req) {
     // It would be great if we'd have a SELECT ** to deeply expand the entity (along compositions), that should
     // be implemented in expand implementation.
     if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== false) {
-      req.reject(400, 'Action "draftActivate" can only be called on the root draft entity')
+      req.reject({
+        code: 400,
+        statusCode: 400,
+        message: 'Action "draftActivate" can only be called on the root draft entity'
+      })
     }
 
     if (req.target._etag && !req.headers['if-match'] && !req.headers['if-none-match']) {
-      req.reject(428)
+      req.reject({ code: 428, statusCode: 428 })
     }
 
     const targetDraft = req.target.drafts
@@ -428,9 +437,15 @@ cds.ApplicationService.prototype.handle = async function (req) {
           { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
         ])
     )
-    if (!res) req.reject(_etagValidationType ? 412 : { code: 'DRAFT_NOT_EXISTING', status: 404 })
+    if (!res)
+      req.reject(_etagValidationType ? { code: 412, statusCode: 412 } : { code: 'DRAFT_NOT_EXISTING', statusCode: 404 })
     if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) {
-      req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [res.DraftAdministrativeData?.InProcessByUser])
+      req.reject({
+        code: 403,
+        statusCode: 403,
+        message: 'DRAFT_LOCKED_BY_ANOTHER_USER',
+        args: [res.DraftAdministrativeData?.InProcessByUser]
+      })
     }
     const DraftAdministrativeData_DraftUUID = res.DraftAdministrativeData_DraftUUID
     delete res.DraftAdministrativeData_DraftUUID
@@ -469,12 +484,21 @@ cds.ApplicationService.prototype.handle = async function (req) {
       // REVISIT: needs reworking for new adapter, especially re $batch
       if (req._?.odataRes) {
         req._?.odataRes?.setStatusCode(201, { overwrite: true })
-      } else if (req.http?.res) {
-        req.http.res.status(201)
+      } else if (req.res) {
+        req.res.status(201)
       }
     }
 
-    return Object.assign(result, { IsActiveEntity: true })
+    if (cds.env.features.odata_new_adapter) {
+      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 })
+      )
+      return read_result
+    } else {
+      return Object.assign(result, { IsActiveEntity: true })
+    }
   }
 
   if (req.target.actions?.[req.event] && draftParams.IsActiveEntity === false) {
@@ -484,27 +508,35 @@ cds.ApplicationService.prototype.handle = async function (req) {
     rootQuery.SELECT.one = true
     rootQuery.SELECT.from = { ref: [query.SELECT.from.ref[0]] }
     const root = await cds.run(rootQuery)
-    if (!root) req.reject(404)
-    if (root.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) req.reject(403)
+    if (!root) req.reject({ code: 404, statusCode: 404 })
+    if (root.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) {
+      req.reject({ code: 403, statusCode: 403 })
+    }
     const _req = _newReq(req, query, draftParams, { event: req.event })
     const result = await handle(_req)
     return result
   }
 
   if (req.event === 'PATCH') {
-    if (!('IsActiveEntity' in draftParams)) req.reject(501)
+    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(405)
+      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', {
         ref: ['DraftAdministrativeData'],
         expand: [{ ref: ['InProcessByUser'] }]
       })
-      if (!res) req.reject(404)
-      if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id)
-        req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [res.DraftAdministrativeData?.InProcessByUser])
+      if (!res) req.reject({ code: 404, statusCode: 404 })
+      if (res.DraftAdministrativeData?.InProcessByUser !== cds.context.user.id) {
+        req.reject({
+          code: 403,
+          statusCode: 403,
+          message: 'DRAFT_LOCKED_BY_ANOTHER_USER',
+          args: [res.DraftAdministrativeData?.InProcessByUser]
+        })
+      }
       await UPDATE('DRAFT.DraftAdministrativeData')
         .data({
           InProcessByUser: req.user.id,
@@ -527,12 +559,12 @@ cds.ApplicationService.prototype.handle = async function (req) {
     const entityRef = query.UPDATE.entity.ref
 
     if (!this.model.definitions[entityRef[0].id]['@Common.DraftRoot.ActivationAction']) {
-      req.reject(403, 'DRAFT_MODIFICATION_ONLY_VIA_ROOT')
+      req.reject({ code: 403, statusCode: 403, message: 'DRAFT_MODIFICATION_ONLY_VIA_ROOT' })
     }
 
     const draftsRef = _redirectRefToDrafts(entityRef, this.model)
     const hasDraft = !!(await SELECT.one([1]).from({ ref: [draftsRef[0]] }))
-    if (hasDraft) req.reject(409, 'DRAFT_ALREADY_EXISTS')
+    if (hasDraft) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
 
     await run(query)
     return req.data
@@ -1018,7 +1050,13 @@ function _cleansed(query, model) {
     const target = query._target
     const q = cds.ql.clone(query)
 
-    const ref = q.SELECT?.from.ref || q.UPDATE?.entity.ref || q.INSERT?.into.ref || q.DELETE?.from.ref
+    if (q.SELECT?.from.SELECT) q.SELECT.from = _cleanseQuery(q.SELECT?.from, draftParams, model)
+    const ref =
+      q.SELECT?.from.SELECT?.from.ref ||
+      q.SELECT?.from.ref ||
+      q.UPDATE?.entity.ref ||
+      q.INSERT?.into.ref ||
+      q.DELETE?.from.ref
     const cqn = q.SELECT || q.UPDATE || q.INSERT || q.DELETE
 
     if (ref) {
@@ -1028,7 +1066,7 @@ function _cleansed(query, model) {
         if (!entity?.drafts) return r
         return r.where ? { ...r, where: _cleanseWhere(r.where, draftParams, DRAFT_ELEMENTS) } : r
       })
-      if (q.SELECT) q.SELECT.from = { ...q.SELECT.from, ref: cleansedRef }
+      if (q.SELECT) q.SELECT.from = q.SELECT.from.SELECT ? q.SELECT.from : { ...q.SELECT.from, ref: cleansedRef }
       else if (q.DELETE) q.DELETE.from = { ...q.DELETE.from, ref: cleansedRef }
       else if (q.UPDATE) q.UPDATE.entity = { ...q.UPDATE.entity, ref: cleansedRef }
       else if (q.INSERT) q.INSERT.into = { ...q.INSERT.into, ref: cleansedRef }
@@ -1175,11 +1213,11 @@ 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(405)
+    req.reject({ code: 405, statusCode: 405 })
   const isDirectAccess = typeof req.query.INSERT.into === 'string' || req.query.INSERT.into.ref?.length === 1
   // Only allowed for pseudo draft roots (entities with this action)
   if (isDirectAccess && !req.target.actives['@Common.DraftRoot.ActivationAction'])
-    req.reject(403, 'DRAFT_MODIFICATION_ONLY_VIA_ROOT')
+    req.reject({ code: 403, statusCode: 403, message: 'DRAFT_MODIFICATION_ONLY_VIA_ROOT' })
 
   _cleanUpOldDrafts(this, req.tenant)
 
@@ -1192,9 +1230,14 @@ async function onNew(req) {
         { ref: ['DraftAdministrativeData'], expand: [{ ref: ['InProcessByUser'] }] }
       ])
       .where(req.query.INSERT.into.ref[0].where)
-    if (!rootData) req.reject(404)
+    if (!rootData) req.reject({ code: 404, statusCode: 404 })
     if (rootData.DraftAdministrativeData?.InProcessByUser !== req.user.id)
-      req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [rootData.DraftAdministrativeData.InProcessByUser])
+      req.reject({
+        code: 403,
+        statusCode: 403,
+        message: 'DRAFT_LOCKED_BY_ANOTHER_USER',
+        args: [rootData.DraftAdministrativeData.InProcessByUser]
+      })
     DraftUUID = rootData.DraftAdministrativeData_DraftUUID
   }
   const timestamp = cds.context.timestamp.toISOString() // REVISIT: toISOString should be done on db layer
@@ -1251,7 +1294,11 @@ async function onEdit(req) {
   // use symbol for _draftParams
   const draftParams = req.query[DRAFT_PARAMS]
   if (req.query.SELECT.from.ref.length > 1 || draftParams.IsActiveEntity !== true) {
-    req.reject(400, 'Action "draftEdit" can only be called on the root active entity')
+    req.reject({
+      code: 400,
+      statusCode: 400,
+      message: 'Action "draftEdit" can only be called on the root active entity'
+    })
   }
 
   if (
@@ -1259,10 +1306,10 @@ async function onEdit(req) {
     req.target['@insertonly'] ||
     req.target['@readonly']
   ) {
-    req.reject(405)
+    req.reject({ code: 405, statusCode: 405 })
   }
 
-  if (draftParams.IsActiveEntity !== true) req.reject(400)
+  if (draftParams.IsActiveEntity !== true) req.reject({ code: 400, statusCode: 400 })
 
   _cleanUpOldDrafts(this, req.tenant)
 
@@ -1337,8 +1384,8 @@ async function onEdit(req) {
       await this.run(activeLockCQN)
     } catch (e) {
       const draft = await this.run(existingDraft)
-      if (draft) req.reject(409, 'DRAFT_ALREADY_EXISTS')
-      req.reject(409, 'ENTITY_LOCKED')
+      if (draft) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
+      req.reject({ code: 409, statusCode: 409, message: 'ENTITY_LOCKED' })
     }
 
     const cqns = [
@@ -1366,12 +1413,12 @@ async function onEdit(req) {
     ])
   }
 
-  if (!res) req.reject(404)
+  if (!res) req.reject({ code: 404, statusCode: 404 })
   const preserveChanges = req.data?.PreserveChanges
   const inProcessByUser = draft?.DraftAdministrativeData?.InProcessByUser
 
   if (draft) {
-    if (inProcessByUser || preserveChanges) req.reject(409, 'DRAFT_ALREADY_EXISTS')
+    if (inProcessByUser || preserveChanges) req.reject({ code: 409, statusCode: 409, message: 'DRAFT_ALREADY_EXISTS' })
     const keys = {}
     for (const key in req.target.drafts.keys) keys[key] = res[key]
     await _promiseAll([
@@ -1405,11 +1452,20 @@ async function onEdit(req) {
   // REVISIT: needs reworking for new adapter, especially re $batch
   if (req._?.odataRes) {
     req._?.odataRes?.setStatusCode(201, { overwrite: true })
-  } else if (req.http?.res) {
-    req.http.res.status(201)
+  } else if (req.res) {
+    req.res.status(201)
   }
 
-  return { ...res, IsActiveEntity: false } // REVISIT: Flatten?
+  if (cds.env.features.odata_new_adapter) {
+    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 })
+    )
+    return read_result
+  } else {
+    return { ...res, IsActiveEntity: false } // REVISIT: Flatten?
+  }
 }
 
 async function onCancel(req) {
@@ -1430,7 +1486,7 @@ async function onCancel(req) {
   if (draft) {
     const processByUser = draft.DraftAdministrativeData?.InProcessByUser
     if (processByUser && processByUser !== cds.context.user.id)
-      req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [processByUser])
+      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)]
   if (draft && req.target['@Common.DraftRoot.ActivationAction'])
@@ -1457,23 +1513,72 @@ 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(400, 'Action "draftPrepare" can only be called on the root draft entity')
+    req.reject({
+      code: 400,
+      statusCode: 400,
+      message: 'Action "draftPrepare" can only be called on the root draft entity'
+    })
   }
   const where = req.query.SELECT.from.ref[0].where
 
   const draftQuery = SELECT.one
     .from(req.target, d => {
-      d.DraftAdministrativeData(a => a.InProcessByUser)
+      d`.*`, d.DraftAdministrativeData(a => a.InProcessByUser)
     })
-    .columns(entity_keys(req.target))
     .where(where)
   draftQuery[DRAFT_PARAMS] = draftParams
   const data = await draftQuery
-  if (!data) req.reject(404)
+  if (!data) req.reject({ code: 404, statusCode: 404 })
   if (data.DraftAdministrativeData?.InProcessByUser !== req.user.id)
-    req.reject(403, 'DRAFT_LOCKED_BY_ANOTHER_USER', [data.DraftAdministrativeData?.InProcessByUser])
+    req.reject({
+      code: 403,
+      statusCode: 403,
+      message: 'DRAFT_LOCKED_BY_ANOTHER_USER',
+      args: [data.DraftAdministrativeData?.InProcessByUser]
+    })
   delete data.DraftAdministrativeData
-  return { ...data, IsActiveEntity: false }
+  // result must not include DraftAdministrativeData_DraftUUID for plain v4 usage, however required for odata-v2
+  if (data && req.headers?.['x-cds-odata-version'] !== 'v2') {
+    delete data.DraftAdministrativeData_DraftUUID
+  }
+  return { ...data, IsActiveEntity: false, HasDraftEntity: false, HasActiveEntity: data.HasActiveEntity || false }
+}
+
+const _readAfterDraftAction = async function ({ req, payload, action }) {
+  const entity = action === 'draftActivate' ? req.target : req.target.drafts
+
+  // read after write with query options
+  const keys = {}
+  entity.keys.forEach(key => {
+    if (key.name === 'IsActiveEntity' || key.isAssociation || key.virtual) return
+    keys[key.name] = payload[key.name]
+  })
+  const read = SELECT.one.from(entity, keys)
+  if (req.req.query.$select || req.req.query.$expand) {
+    const queryOptions = []
+    if (req.req.query.$select) queryOptions.push(`$select=${req.req.query.$select}`)
+    if (req.req.query.$expand) queryOptions.push(`$expand=${req.req.query.$expand}`)
+    read.columns(cds.odata.parse(`/X?${queryOptions.join('&')}`).SELECT.columns)
+    // ensure keys are always selected
+    Object.keys(keys).forEach(key => {
+      if (!read.SELECT.columns.some(c => c.ref?.[0] === key)) read.SELECT.columns.push({ ref: [key] })
+    })
+    // also ensure selection of etag columns
+    addEtagColumns(read.SELECT.columns, entity)
+  }
+
+  try {
+    const read_result = await this.run(read)
+    // result must not include DraftAdministrativeData_DraftUUID for plain v4 usage, however required for odata-v2
+    if (read_result && req.headers?.['x-cds-odata-version'] !== 'v2') {
+      delete read_result.DraftAdministrativeData_DraftUUID
+    }
+    return read_result
+  } catch (err) {
+    if (!(Number(err.code) in { 401: 1, 403: 1, 404: 1, 405: 1 })) throw err
+    // it's important to return null if one of the above accepted errors occurs
+    return null
+  }
 }
 
 module.exports = {

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

@@ -1,7 +1,7 @@
 const cds = require('../../cds')
 const { Object_keys } = cds.utils
 const { UPDATE, SELECT } = cds.ql
-const { getColumns } = require('../../cds-services/services/utils/columns')
+const { getColumns } = require('../../common/utils/columns')
 const { ensureNoDraftsSuffix, ensureDraftsSuffix, ensureUnlocalized } = require('../../common/utils/draft')
 const getTemplate = require('../../common/utils/template')
 

package/libx/_runtime/hana/execute.js

@@ -404,10 +404,14 @@ async function executeSelectStreamCQN({ model, query, dbc, user, locale, txTimes
   if (result.length === 0) return
 
   if (cds.env.features.stream_compat) {
-    const val = Object.values(result[0])[0]
+    const res = _convertNames(result[0], query.SELECT?.columns)
+    let [key, val] = Object.entries(res)[0]
     if (val === null) return null
 
-    return { value: val }
+    res.value = val
+    delete res[key]
+
+    return res
   } else {
     return dbc.name === 'hdb' ? result[0] : _convertNames(result[0], query.SELECT?.columns)
   }

package/libx/_runtime/hana/search2cqn4sql.js

@@ -1,5 +1,5 @@
 const cds = require('../cds')
-const { computeColumnsToBeSearched } = require('../cds-services/services/utils/columns')
+const { computeColumnsToBeSearched } = require('../common/utils/columns')
 const searchToLike = require('../common/utils/searchToLike')
 const { isContainsPredicateSupported, search2Contains } = require('./search2Contains')
 const { addAliasToExpression } = require('../db/utils/generateAliases')

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

@@ -11,7 +11,6 @@ const _isAll = a => a && a.includes('all')
 class EndpointRegistry {
   constructor(basePath, LOG) {
     const deployPath = basePath + '/deploy'
-    const paths = [basePath, deployPath]
     this.webhookCallbacks = new Map()
     this.deployCallbacks = new Map()
     if (isSecured()) {
@@ -60,7 +59,7 @@ class EndpointRegistry {
     cds.app.options(basePath, (req, res) => {
       try {
         if (isSecured() && !req.user.is('emcallback')) return res.sendStatus(403)
-        res.set('WebHook-Allowed-Origin', req.headers['webhook-request-origin'])
+        res.set('webhook-allowed-origin', req.headers['webhook-request-origin'])
         res.sendStatus(200)
       } catch (error) {
         res.sendStatus(500)

package/libx/_runtime/messaging/event-broker.js

@@ -0,0 +1,212 @@
+const cds = require('../cds')
+
+// eslint-disable-next-line cds/no-missing-dependencies -- needs to be added by app dev
+const express = require('express')
+const https = require('https')
+const crypto = require('crypto')
+
+async function request(options, data) {
+  return new Promise((resolve, reject) => {
+    const req = https.request(options, res => {
+      const chunks = []
+      res.on('data', chunk => {
+        chunks.push(chunk)
+      })
+      res.on('end', () => {
+        const response = {
+          statusCode: res.statusCode,
+          headers: res.headers,
+          body: Buffer.concat(chunks).toString()
+        }
+        if (res.statusCode > 299) {
+          reject({ message: response.body })
+        } else {
+          resolve(response)
+        }
+      })
+    })
+    req.on('error', error => {
+      reject(error)
+    })
+    if (data) {
+      req.write(JSON.stringify(data))
+    }
+    req.end()
+  })
+}
+
+function _validateCertificate(req, res, next) {
+  this.LOG.debug('event broker trying to authenticate via mTLS')
+
+  if (req.headers['x-ssl-client-verify'] !== '0') {
+    this.LOG.info('cf did not validate client certificate.')
+    return res.status(401).json({ message: 'Authentication Failed' })
+  }
+
+  if (!req.headers['x-forwarded-client-cert']) {
+    this.LOG.info('no certificate in xfcc header.')
+    return res.status(401).json({ message: 'Authentication Failed' })
+  }
+
+  const bindingCert = new crypto.X509Certificate(this.options.credentials.certificate).toLegacyObject()
+  const clientCert = new crypto.X509Certificate(
+    `-----BEGIN CERTIFICATE-----\n${req.headers['x-forwarded-client-cert']}\n-----END CERTIFICATE-----`
+  ).toLegacyObject()
+
+  const cfSubject = Buffer.from(req.headers['x-ssl-client-subject-cn'], 'base64').toString()
+  if (bindingCert.subject.CN !== clientCert.subject.CN || bindingCert.subject.CN !== cfSubject) {
+    this.LOG.info('certificate subject does not match')
+    return res.status(401).json({ message: 'Authentication Failed' })
+  }
+  this.LOG.debug('incoming Subject CN is valid.')
+
+  if (bindingCert.issuer.CN !== clientCert.issuer.CN) {
+    this.LOG.info('Certificate issuer subject does not match')
+    return res.status(401).json({ message: 'Authentication Failed' })
+  }
+  this.LOG.debug('incoming issuer subject CN is valid.')
+
+  if (bindingCert.issuer.O !== clientCert.issuer.O) {
+    this.LOG.info('Certificate issuer org does not match')
+    return res.status(401).json({ message: 'Authentication Failed' })
+  }
+  this.LOG.debug('incoming Issuer Org is valid.')
+
+  if (bindingCert.issuer.OU !== clientCert.issuer.OU) {
+    this.LOG.info('certificate issuer OU does not match')
+    return res.status(401).json({ message: 'Authentication Failed' })
+  }
+  this.LOG.debug('certificate issuer OU is valid.')
+
+  const valid_from = new Date(clientCert.valid_from)
+  const valid_to = new Date(clientCert.valid_to)
+  const now = new Date(Date.now())
+  if (valid_from <= now && valid_to >= now) {
+    this.LOG.debug('certificate validation completed')
+    next()
+  } else {
+    this.LOG.error('Certificate expired')
+    return res.status(401).json({ message: 'Authentication Failed' })
+  }
+}
+
+// TODO: seems unused
+function _checkAppDomains() {
+  const pattern = /.*\.cert\.cfapps\..*\.hana\.ondemand\.com/
+  const uris = JSON.parse(process.env.VCAP_APPLICATION).application_uris
+  const matchFound = uris.some(uri => pattern.test(uri))
+  if (matchFound)
+    this.LOG.warn(
+      `*.cert.cfapps.*.hana.ondemand.com domain is in use, this is not recommended in production! Please use 'mesh.cf.<region>.hana.ondemand.com' instead!`
+    )
+}
+
+let instantiated = false
+
+class EventBroker extends cds.MessagingService {
+  async init() {
+    // TODO: Only needed if there are subscriptions
+    if (instantiated)
+      throw new Error('Event Broker service must be a singleton service, you cannot have more than one instance.')
+    instantiated = true
+    await super.init()
+    cds.once('listening', () => {
+      this.startListening()
+    })
+    this.agent = this.getAgent()
+  }
+
+  getAgent() {
+    try {
+      if (this.options.x509.certPath && this.options.x509.pkeyPath) {
+        return new https.Agent({
+          cert: cds.utils.fs.readFileSync(cds.utils.path.resolve(cds.root, this.options.x509.certPath)),
+          key: cds.utils.fs.readFileSync(cds.utils.path.resolve(cds.root, this.options.x509.pkeyPath))
+        })
+      }
+    } catch (error) {
+      if (this.LOG) this.LOG.error('GetCredentials', { error: error.message })
+      throw error
+    }
+  }
+
+  async handle(msg) {
+    if (msg.inbound) return super.handle(msg)
+    const _msg = this.message4(msg)
+    await this.emitToEventBroker(_msg)
+  }
+
+  async startListening() {
+    if (!this._listenToAll.value && !this.subscribedTopics.size) return
+    await this.registerWebhookEndpoints()
+  }
+
+  async emitToEventBroker(msg) {
+    // TODO: CSN definition probably not needed, just in case...
+    //   See if there's a CSN entry for that event
+    //   const found = cds?.model.definitions[topicOrEvent]
+    //   if (found) return found  // case for fully-qualified event name
+    //   for (const def in cds.model?.definitions) {
+    //     const definition = cds.model.definitions[def]
+    //     if (definition['@topic'] === topicOrEvent) return definition
+    //   }
+
+    // TODO: What if we're in single tenant variant?
+    try {
+      const ceSource = `${this.options.credentials.ceSource[0]}/${cds.context.tenant}`
+      const hostname = this.options.credentials.eventing.http.x509.url.replace(/^https?:\/\//, '')
+      // TODO Cloud Events Handler CAP
+      const options = {
+        hostname: hostname,
+        method: 'POST',
+        headers: {
+          'ce-id': cds.utils.uuid(),
+          'ce-source': ceSource,
+          'ce-type': msg.event,
+          'ce-specversion': '1.0',
+          'Content-Type': 'application/json'
+        },
+        agent: this.agent
+      }
+      this.LOG.debug('HTTP headers:', JSON.stringify(options.headers))
+      this.LOG.debug('HTTP body:', JSON.stringify(msg.data))
+      await request(options, msg.data) // TODO: fetch does not work with mTLS as of today, requires another module. see https://github.com/nodejs/node/issues/48977
+      if (this.LOG._info) this.LOG.info('Emit', { topic: msg.event })
+    } catch (e) {
+      this.LOG.error('Emit failed:', e.message)
+    }
+  }
+
+  async registerWebhookEndpoints() {
+    const webhookBasePath = this.options.webhookPath || '/-/cds/event-broker/webhook'
+    cds.app.post(webhookBasePath, _validateCertificate.bind(this))
+    cds.app.post(webhookBasePath, express.json())
+    cds.app.post(webhookBasePath, this.onEventReceived.bind(this))
+  }
+
+  async onEventReceived(req, res) {
+    try {
+      const event = req.headers['ce-type'] // TG27: type contains namespace, so there's no collision
+      const tenant = req.headers['ce-sapconsumertenant']
+      const msg = {
+        inbound: true,
+        event,
+        tenant,
+        data: req.body ? req.body : undefined,
+        headers: req.headers
+      }
+      cds.context = { user: cds.User.privileged }
+      if (tenant) cds.context.tenant = tenant // TODO: In single tenant case, we don't need a tenant
+      const tx = await this.tx()
+      await tx.emit(msg)
+      this.LOG.debug('Event processed successfully.')
+      return res.status(200).json({ message: 'OK' })
+    } catch (e) {
+      this.LOG.error('ERROR during inbound event processing:', e) // TODO: How does Event Broker do error handling?
+      res.status(500).json({ message: 'Internal Server Error!' })
+      throw e
+    }
+  }
+}
+
+module.exports = EventBroker