@sap/cds-dk 9.9.3 → 10.0.4

package/node_modules/@sap/cds/libx/_runtime/messaging/enterprise-messaging-utils/registerEndpoints.js

@@ -0,0 +1,158 @@
+const cds = require('../../cds.js')
+const express = require('express')
+const getTenantInfo = require('./getTenantInfo.js')
+
+const _isAll = a => a && a.includes('all')
+
+const _xsuaa_fallback = () => {
+  let xsuaa = cds.env.requires.messaging.xsuaa
+  xsuaa = typeof xsuaa === 'string' ? xsuaa : 'xsuaa'
+  const xsuaa_config = cds.env.requires[xsuaa]
+  if (!xsuaa_config) throw new Error(`Fallback XSUAA instance '${xsuaa}' not found!`)
+  if (!xsuaa_config.credentials) throw new Error(`Fallback XSUAA instance '${xsuaa}' has no credentials!`)
+  const jwt_auth = require('../../../../lib/srv/middlewares/auth/jwt-auth.js')
+  return jwt_auth(xsuaa_config)
+}
+
+class EndpointRegistry {
+  constructor(basePath, LOG) {
+    const deployPath = basePath + '/deploy'
+    this.webhookCallbacks = new Map()
+    this.deployCallbacks = new Map()
+
+    const _IS_SECURED = !!(
+      cds.env.requires.auth &&
+      (cds.env.requires.auth.impl || !(cds.env.requires.auth.kind in { mocked: 1, 'mocked-auth': 1 }))
+    )
+    const _IS_PRODUCTION = process.env.NODE_ENV === 'production'
+
+    cds.app.use(basePath, cds.middlewares.context())
+    if (_IS_SECURED) {
+      // unofficial XSUAA fallback
+      if (cds.env.requires.messaging?.xsuaa) {
+        cds.app.use(basePath, _xsuaa_fallback())
+      } else {
+        cds.app.use(basePath, cds.middlewares.auth())
+      }
+      // ensure that anonymous users get 401 on messaging endpoints
+      cds.app.use(basePath, (_req, _res, next) => {
+        next(cds.context.user._is_anonymous ? 401 : undefined)
+      })
+    } else if (_IS_PRODUCTION) LOG.warn('Messaging endpoints not secured')
+
+    cds.app.use(basePath, express.json({ type: 'application/*+json' }))
+    cds.app.use(basePath, express.json())
+    cds.app.use(basePath, express.urlencoded({ extended: true }))
+
+    LOG._debug && LOG.debug('Register inbound endpoint', { basePath, method: 'OPTIONS' })
+    cds.app.options(basePath, (req, res) => {
+      try {
+        if (_IS_SECURED && !cds.context.user.is('emcallback')) return res.sendStatus(403)
+        res.set('webhook-allowed-origin', req.headers['webhook-request-origin'])
+        res.sendStatus(200)
+      } catch {
+        res.sendStatus(500)
+      }
+    })
+
+    LOG._debug && LOG.debug('Register inbound endpoint', { basePath, method: 'POST' })
+    cds.app.post(basePath, (req, res) => {
+      try {
+        if (_IS_SECURED && !cds.context.user.is('emcallback')) return res.sendStatus(403)
+        const queueName = req.query.q
+        if (!queueName) {
+          LOG.error('Query parameter `q` not found.')
+          return res.sendStatus(400)
+        }
+        const xAddress = req.headers['x-address']
+        const topic = xAddress && xAddress.match(/^topic:(.*)/)?.[1]
+        if (!topic) {
+          LOG.error('Incoming message does not contain a topic in header `x-address`: ' + xAddress)
+          return res.sendStatus(400)
+        }
+        const payload = req.body
+        const cb = this.webhookCallbacks.get(queueName)
+        if (!cb) return res.sendStatus(200)
+        const { tenant } = cds.context
+        const other = tenant
+          ? {
+              _: { req, res }, // For `cds.context.http`
+              tenant
+            }
+          : {}
+        if (!cb) return res.sendStatus(200)
+        cb(topic, payload, other, {
+          done: () => {
+            res.sendStatus(200)
+          },
+          failed: () => {
+            res.sendStatus(500)
+          }
+        })
+      } catch (error) {
+        LOG.error(error)
+        return res.sendStatus(500)
+      }
+    })
+
+    cds.app.post(deployPath, async (req, res) => {
+      LOG.debug('Handling deploy request')
+      try {
+        if (_IS_SECURED && !cds.context.user.is('emmanagement')) return res.sendStatus(403)
+        const tenants = req.body && !_isAll(req.body.tenants) && req.body.tenants
+        const queues = req.body && !_isAll(req.body.queues) && req.body.queues
+        const options = { wipeData: req.body && req.body.wipeData }
+
+        if (tenants && !Array.isArray(tenants)) res.status(400).send('Request parameter `tenants` must be an array.')
+        if (queues && !Array.isArray(queues)) res.status(400).send('Request parameter `queues` must be an array.')
+
+        const tenantInfo = tenants ? await Promise.all(tenants.map(t => getTenantInfo(t))) : await getTenantInfo()
+
+        const callbacks = queues ? queues.map(q => this.deployCallbacks.get(q)) : [...this.deployCallbacks.values()]
+        const results = await Promise.all(callbacks.map(c => c(tenantInfo, options)))
+
+        // [{ queue: '...', failed: [...], succeeded: [...] }, ...]
+        const hasError = results.some(r => r.failed.length)
+        if (hasError) return res.status(500).send(results)
+        return res.status(201).send(results)
+      } catch (e) {
+        LOG.error('Error while handling deploy request: ', e)
+        // REVISIT: Still needed with cds-mtxs?
+        // If an unknown tenant id is provided, cds-mtx will crash ("Cannot read property 'hanaClient' of undefined")
+        return res.sendStatus(500)
+      }
+    })
+
+    cds.app.use(basePath, cds.middlewares.errors())
+  }
+
+  registerWebhookCallback(queueName, cb) {
+    this.webhookCallbacks.set(queueName, cb)
+  }
+
+  registerDeployCallback(queueName, cb) {
+    this.deployCallbacks.set(queueName, cb)
+  }
+}
+
+// Singleton registries per basePath
+const registries = new Map()
+
+// REVISIT: Use cds mechanism instead of express? -> Need option method and handler for specifica
+const registerWebhookEndpoints = (basePath, queueName, LOG, cb) => {
+  const registry =
+    registries.get(basePath) ||
+    (registries.set(basePath, new EndpointRegistry(basePath, LOG)) && registries.get(basePath))
+  registry.registerWebhookCallback(queueName, cb)
+}
+
+const registerDeployEndpoints = (basePath, queueName, cb) => {
+  const registry =
+    registries.get(basePath) || (registries.set(basePath, new EndpointRegistry(basePath)) && registries.get(basePath))
+  registry.registerDeployCallback(queueName, cb)
+}
+
+// Only needed for testing, not used in productive code
+const __clearRegistries = () => registries.clear()
+
+module.exports = { registerWebhookEndpoints, registerDeployEndpoints, __clearRegistries }

package/node_modules/@sap/cds/libx/_runtime/messaging/enterprise-messaging.js

@@ -0,0 +1,209 @@
+const cds = require('../cds.js')
+const AMQPWebhookMessaging = require('./AMQPWebhookMessaging.js')
+const { optionsMessagingREST } = require('./enterprise-messaging-utils/options-messaging.js')
+const optionsManagement = require('./enterprise-messaging-utils/options-management.js')
+const EMManagement = require('./enterprise-messaging-utils/EMManagement.js')
+const optionsForSubdomain = require('./common-utils/optionsForSubdomain.js')
+const authorizedRequest = require('./common-utils/authorizedRequest')
+const getTenantInfo = require('./enterprise-messaging-utils/getTenantInfo')
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms).unref())
+const {
+  registerDeployEndpoints,
+  registerWebhookEndpoints
+} = require('./enterprise-messaging-utils/registerEndpoints.js')
+const cloudEvents = require('./enterprise-messaging-utils/cloudEvents.js')
+
+const BASE_PATH = '/messaging/enterprise-messaging'
+
+const _checkAppURL = appURL => {
+  if (!appURL)
+    cds.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-shared`.'
+    )
+
+  if (appURL.startsWith('https://localhost'))
+    cds.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-shared`.'
+    )
+}
+
+// REVISIT: It's bad to have to rely on the subdomain.
+// For all interactions where we perform the token exchange ourselves,
+// we will be able to use the zoneId instead of the subdomain.
+const _subdomainFromContext = context => context?.user?.authInfo?.getSubdomain?.()
+
+class EnterpriseMessaging extends AMQPWebhookMessaging {
+  init() {
+    cloudEvents.defaultOptions(this.options)
+    return super.init()
+  }
+
+  // New mtx based on @sap/cds-mtxs
+  async addMTXSHandlers() {
+    // REVISIT: Is that tested with MTX services in sidecar?
+    const deploymentSrv = await cds.connect.to('cds.xt.DeploymentService')
+    const provisioningSrv = await cds.connect.to('cds.xt.SaasProvisioningService')
+    deploymentSrv.prepend(() => {
+      deploymentSrv.after('subscribe', async (_res, req) => {
+        const { subscribedSubdomain: subdomain } = req.data.metadata
+        const management = await this.getManagement(subdomain).waitUntilReady()
+        await management.deploy()
+      })
+      deploymentSrv.before('unsubscribe', async req => {
+        const { tenant } = req.data
+        let subdomain
+        try {
+          const tenantInfo = await getTenantInfo(tenant)
+          subdomain = tenantInfo.subdomain
+        } catch (e) {
+          if (e.status === 404) return // idempotent
+          throw e
+        }
+        try {
+          const management = await this.getManagement(subdomain).waitUntilReady()
+          await management.undeploy()
+        } catch (error) {
+          this.LOG.error('Failed to delete messaging artifacts for subdomain', subdomain, '(', error, ')')
+        }
+      })
+    })
+    provisioningSrv.prepend(() => {
+      provisioningSrv.on('dependencies', async (_req, next) => {
+        this.LOG._info && this.LOG.info('Include Enterprise-Messaging as SaaS dependency')
+        const res = (await next()) || []
+        const xsappname = this.options.credentials?.xsappname
+        if (xsappname) {
+          const exists = res.some(d => d.xsappname === xsappname)
+          if (!exists) res.push({ xsappname })
+        }
+        return res
+      })
+    })
+  }
+
+  startListening() {
+    const doNotDeploy = cds.requires.multitenancy && !this.options.deployForProvider
+    if (doNotDeploy) this.LOG._info && this.LOG.info('Skipping deployment of messaging artifacts for provider account')
+    super.startListening({ doNotDeploy })
+    if (!doNotDeploy && (this._listenToAll.value || this.subscribedTopics.size)) {
+      const management = this.getManagement()
+      // Webhooks will perform an OPTIONS call on creation to check the availability of the app.
+      // On systems like Cloud Foundry the app URL will only be advertised once
+      // the app is healthy, i.e. when the health check was performed successfully.
+      // Therefore we need to wait a few seconds (configurable) to make sure the app
+      // can be reached from Enterprise Messaging.
+      const waitingPeriod = this.options.webhook && this.options.webhook.waitingPeriod
+      if (waitingPeriod === 0) return this._runInSequence(management.createWebhook.bind(management))()
+      sleep(waitingPeriod || 5000).then(() => this._runInSequence(management.createWebhook.bind(management))())
+    }
+  }
+
+  async listenToClient(cb) {
+    _checkAppURL(this.optionsApp.appURL)
+    registerWebhookEndpoints(BASE_PATH, this.queueName, this.LOG, cb)
+    if (cds.requires.multitenancy) {
+      await this.addMTXSHandlers()
+      registerDeployEndpoints(BASE_PATH, this.queueName, async (tenantInfo, options) => {
+        const result = { queue: this.queueName, succeeded: [], failed: [] }
+        await Promise.all(
+          tenantInfo.map(async info => {
+            try {
+              const management = await this.getManagement(info.subdomain).waitUntilReady()
+              if (options.wipeData) await management.undeploy()
+              await management.deploy()
+              result.succeeded.push(info.tenant)
+            } catch (error) {
+              this.LOG.error('Failed to create messaging artifacts for subdomain', info.subdomain, ':', error)
+              result.failed.push({ error: error.message, tenant: info.tenant })
+            }
+          })
+        )
+        return result
+      })
+    }
+  }
+
+  getManagement(subdomain) {
+    const _subdomain = (typeof subdomain === 'string' && subdomain) || _subdomainFromContext(this.context || subdomain)
+    const optsManagement = optionsManagement(this.options)
+    const queueConfig = this.queueConfig
+    const queueName = this.queueName
+    const optsManagementSwitched = _subdomain
+      ? optionsForSubdomain.oa2ForSubdomain(optsManagement, _subdomain)
+      : optsManagement
+    const _optionsMessagingREST = optionsMessagingREST(this.options)
+    const _optionsMessagingRESTSwitched = _subdomain
+      ? optionsForSubdomain.oa2ForSubdomain(_optionsMessagingREST, _subdomain)
+      : _optionsMessagingREST
+    const optionsWebhook = { ...this.options.webhook }
+    delete optionsWebhook.waitingPeriod
+
+    return new EMManagement({
+      optionsManagement: optsManagementSwitched,
+      queueConfig,
+      queueName,
+      optionsMessagingREST: _optionsMessagingRESTSwitched,
+      optionsWebhook,
+      optionsApp: this.optionsApp,
+      maxRetries: this.options.maxRetries,
+      path: `${BASE_PATH}?q=${this.queueName}`,
+      subscribedTopics: this.subscribedTopics,
+      alternativeTopics: this.alternativeTopics,
+      subdomain: _subdomain,
+      namespace: this.options.credentials && this.options.credentials.namespace,
+      LOG: this.LOG
+    })
+  }
+
+  async handle(msg) {
+    if (msg.inbound) return super.handle(msg)
+    const _msg = this.message4(msg)
+    const _optionsMessagingREST = optionsMessagingREST(this.options)
+    const context = this.context || cds.context
+    const tenant = cds.requires.multitenancy && context && context.tenant
+    const topic = _msg.event
+    const message = { ...(_msg.headers || {}), data: _msg.data }
+
+    const contentType =
+      _msg.headers && ['id', 'source', 'specversion', 'type'].every(el => el in _msg.headers)
+        ? 'application/cloudevents+json'
+        : 'application/json'
+
+    await this._runInSequence(() => {})()
+
+    try {
+      const params = {
+        method: 'POST',
+        uri: _optionsMessagingREST.uri,
+        path: `/messagingrest/v1/topics/${encodeURIComponent(topic)}/messages`,
+        oa2: _optionsMessagingREST.oa2,
+        dataObj: message,
+        headers: {
+          'Content-Type': contentType,
+          'x-qos': 1
+        },
+        tokenStore: (this._tokenStore ??= {})
+      }
+      if (tenant) params.tenant = tenant
+      await authorizedRequest(params)
+    } catch (e) {
+      // Note: If the topic rules don't allow the topic, we get a 403 (which is a strange choice by Event Mesh)
+      if (e && (e.statusCode === 400 || e.statusCode === 403)) e.unrecoverable = true
+      throw e
+    }
+  }
+
+  wildcarded(topic) {
+    return topic.replace(/.*?\/.*?\/.*?\//, '+/+/+/')
+  }
+
+  prepareTopic(topic, inbound) {
+    return cloudEvents.prepareTopic(topic, inbound, this.options, super.prepareTopic.bind(this))
+  }
+
+  prepareHeaders(headers, event) {
+    cloudEvents.prepareHeaders(headers, event, this.options, super.prepareHeaders.bind(this))
+  }
+}
+
+module.exports = EnterpriseMessaging

package/node_modules/@sap/cds/libx/_runtime/messaging/file-based.js

@@ -0,0 +1,104 @@
+const cds = require('../cds')
+
+const path = require('path')
+const fs = require('fs').promises
+
+const MessagingService = require('./service.js')
+
+class FileBasedMessaging extends MessagingService {
+  async init() {
+    this.file = resolve(this.options.file || (this.options.credentials && this.options.credentials.file))
+    try {
+      await fs.lstat(this.file)
+    } catch {
+      await fs.writeFile(this.file, '\n')
+    }
+    cds.once('listening', () => {
+      this.startWatching()
+    })
+    return super.init()
+  }
+
+  async handle(msg) {
+    if (msg.inbound) return super.handle(msg)
+    const _msg = this.message4(msg)
+    const e = _msg.event
+    delete _msg.event
+    await this._runInSequence(lock)(this.file)
+    this.LOG._debug && this.LOG.debug('Emit', { topic: e, file: this.file })
+    try {
+      await fs.appendFile(this.file, `\n${e} ${JSON.stringify(_msg)}`)
+      unlock(this.file)
+    } catch (e) {
+      this.LOG._debug && this.LOG.debug('Error', e)
+      unlock(this.file)
+      throw e
+    }
+  }
+
+  startWatching() {
+    if (!this._listenToAll.value && !this.subscribedTopics.size) return
+    const watcher = async () => {
+      if (!(await touched(this.file, this.recent))) return // > not touched since last check
+      // REVISIT: Bad if lock file wasn't cleaned up (due to crashes...)
+      if (!(await this._runInSequence(lock)(this.file, 1))) return // > file is locked -> try again next time
+      try {
+        const content = await fs.readFile(this.file, 'utf8')
+        const lines = content.split('\n')
+        const other = [] // used to collect non-matching entries
+        for (const each of lines) {
+          try {
+            const match = /^([\s]*)([^\s]+) ({.*)/.exec(each)
+            if (match) {
+              const [, , topic, jsonString] = match
+              const json = JSON.parse(jsonString)
+              if (this.subscribedTopics.has(topic)) {
+                const event = this.subscribedTopics.get(topic)
+                if (!event) return
+                this.processInboundMsg({}, { event, ...json }).catch(e => {
+                  e.message = 'ERROR occurred in asynchronous event processing: ' + e.message
+                  this.LOG.error(e)
+                })
+              } else other.push(each + '\n')
+            }
+          } catch {
+            // ignore invalid messages
+          }
+        }
+        if (other.length < lines.length) await fs.writeFile(this.file, other.join(''))
+        this.recent = await touched(this.file)
+      } catch (e) {
+        this.LOG._debug && this.LOG.debug(e)
+      } finally {
+        unlock(this.file)
+      }
+    }
+    this.watching = setInterval(watcher, this.options.interval || 500).unref()
+  }
+
+  disconnect() {
+    this.watching = clearInterval(this.watching)
+  }
+}
+
+const resolve = f => path.resolve(f.replace(/^~/, () => require('os').userInfo().homedir))
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms).unref())
+const lock = async (file, n = 11) => {
+  const lock = file + '.lock'
+  try {
+    while (n--) await fs.lstat(lock).then(() => n && sleep(150))
+    return false
+  } catch {
+    // lock file does not exist -> create it
+    await fs.writeFile(lock, 'locked')
+    return true
+  }
+}
+const unlock = file => fs.unlink(file + '.lock').catch(() => {})
+const touched = (file, t0 = 0) =>
+  fs.lstat(file).then(
+    ({ ctimeMs: t }) => t > t0 && t,
+    () => 0
+  )
+
+module.exports = FileBasedMessaging

package/node_modules/@sap/cds/libx/_runtime/messaging/http-utils/token.js

@@ -0,0 +1,75 @@
+const https = require('https')
+
+const _errorObj = result => {
+  const errorObj = new Error('Authorization failed')
+  errorObj.target = { kind: 'TOKEN' }
+  errorObj.response = result
+  return errorObj
+}
+
+const requestToken = ({ client, secret, endpoint, mTLS }, tenant, tokenStore) => {
+  const promise = new Promise((resolve, reject) => {
+    const options = {
+      host: endpoint.replace('/oauth/token', '').replace('https://', ''),
+      headers: {}
+    }
+    if (mTLS) {
+      options.method = 'POST'
+      options.path = '/oauth/token'
+      options.headers['content-type'] = 'application/x-www-form-urlencoded'
+      options.cert = mTLS.cert
+      options.key = mTLS.key
+    } else {
+      options.method = 'GET'
+      options.path = '/oauth/token?grant_type=client_credentials&response_type=token'
+      options.headers.Authorization = 'Basic ' + Buffer.from(client + ':' + secret).toString('base64')
+    }
+
+    if (tenant) options.headers['x-zid'] = tenant
+
+    const req = https.request(options, res => {
+      res.setEncoding('utf8')
+      let chunks = ''
+      res.on('data', chunk => {
+        chunks += chunk
+      })
+      res.on('end', () => {
+        const result = { body: chunks, headers: res.headers, statusCode: res.statusCode }
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          return reject(_errorObj(result))
+        }
+        try {
+          const json = JSON.parse(result.body)
+          if (!json.access_token) {
+            reject(_errorObj(result))
+            return
+          }
+          // set timeout to delete token from cache 5 minutes (300 seconds) before it expires
+          const expiresIn = json.expires_in || 3600
+          const timeout = Math.max(0, (expiresIn - 300) * 1000)
+          if (tokenStore.expirationTimeout) clearTimeout(tokenStore.expirationTimeout)
+          tokenStore.expires_in = json.expires_in
+          tokenStore.expirationTimeout = setTimeout(() => {
+            delete tokenStore.token
+            delete tokenStore.expires_in
+            delete tokenStore.expirationTimeout
+          }, timeout)
+          tokenStore.expirationTimeout.unref()
+
+          // store token value on tokenStore
+          tokenStore.token = json.access_token
+          resolve(json.access_token)
+        } catch {
+          reject(_errorObj(result))
+        }
+      })
+    })
+    if (options.method === 'POST') req.write(`client_id=${client}&grant_type=client_credentials&response_type=token`)
+    req.end()
+  })
+
+  tokenStore.token = promise
+  return promise
+}
+
+module.exports = requestToken