@sap/cds 8.9.3 → 9.0.2

package/libx/_runtime/sqlite/execute.js

@@ -1,345 +0,0 @@
-const { SQLITE_TYPE_CONVERSION_MAP } = require('./conversion')
-const CustomBuilder = require('./customBuilder')
-const { sqlFactory } = require('../db/sql-builder/')
-const { getPostProcessMapper, postProcess } = require('../db/data-conversion/post-processing')
-const { createJoinCQNFromExpanded, hasExpand, rawToExpanded, expandV2 } = require('../db/expand')
-const { Readable } = require('stream')
-
-const cds = require('../cds')
-const LOG = cds.log('sqlite|db|sql')
-// && {_debug:true, debug(sql){ cds._debug && console.log(sql+';\n') }} //> please keep that for debugging stakeholder tests
-const coloredTxCommands = require('../db/utils/coloredTxCommands')
-const { convertStream } = require('../db/utils/stream')
-const { inspect } = require('util')
-
-const SANITIZE_VALUES = process.env.NODE_ENV === 'production' && cds.env.log.sanitize_values !== false
-
-/*
- * capture stack trace on the way to exec to know origin
- * -> very expensive
- * -> only if DEBUG (which should not be used in production)
- */
-const DEBUG = cds.debug('sqlite')
-const _exec = DEBUG
-  ? (dbc, op, ...args) => {
-      const callback = args[args.length - 1]
-      const captured = {}
-      Error.captureStackTrace(captured, _exec)
-      args[args.length - 1] = function (err) {
-        if (err) {
-          err.message += ' in: \n' + args[0]
-          err.query = args[0]
-          if (args.length > 2) err.values = SANITIZE_VALUES ? ['***'] : args[1]
-          err.stack =
-            err.message +
-            captured.stack
-              .slice(5)
-              .replace(/at( _exec)? /, 'at SQLite.' + op + ' ')
-              .replace(/\s+at new Promise .*\n.*/, '')
-        }
-        callback.apply(this, arguments)
-      }
-      return dbc[op](...args)
-    }
-  : (dbc, op, ...args) => {
-      const callback = args[args.length - 1]
-      args[args.length - 1] = function (err) {
-        if (err) {
-          err.message += ' in: \n' + args[0]
-          err.query = args[0]
-          if (args.length > 2) err.values = SANITIZE_VALUES ? ['***'] : args[1]
-        }
-        callback.apply(this, arguments)
-      }
-      return dbc[op](...args)
-    }
-
-function _executeSimpleSQL(dbc, sql, values) {
-  LOG._debug &&
-    LOG.debug(coloredTxCommands[sql] || sql, Array.isArray(values) ? (SANITIZE_VALUES ? ['***'] : values) : '')
-
-  return new Promise((resolve, reject) => {
-    _exec(dbc, 'run', sql, values, function (err) {
-      if (err) return reject(err)
-      resolve(this.changes)
-    })
-  })
-}
-
-function executeSelectSQL(dbc, sql, values, isOne, postMapper) {
-  LOG._debug && LOG.debug(sql, SANITIZE_VALUES ? ['***'] : values)
-
-  return new Promise((resolve, reject) => {
-    _exec(dbc, isOne ? 'get' : 'all', sql, values, (err, result) => {
-      if (err) return reject(err)
-      resolve(result)
-    })
-  }).then(result => postProcess(result, postMapper))
-}
-
-function _processExpand(model, dbc, cqn, user, locale, txTimestamp) {
-  const queries = []
-  const expandQueries = createJoinCQNFromExpanded(cqn, model, locale)
-
-  for (const cqn of expandQueries.queries) {
-    cqn._conversionMapper = getPostProcessMapper(SQLITE_TYPE_CONVERSION_MAP, model, cqn)
-
-    // REVISIT
-    // Why is the post processing in expand different?
-    const { sql, values } = sqlFactory(cqn, { user, now: txTimestamp, customBuilder: CustomBuilder }, model)
-    queries.push(executeSelectSQL(dbc, sql, values, false))
-  }
-
-  return rawToExpanded(expandQueries, queries, cqn.SELECT.one, cqn._target)
-}
-
-function executeSelectCQN(model, dbc, query, user, locale, txTimestamp) {
-  if (hasExpand(query)) {
-    // expand: '**' or '*3' is handled by new impl
-    if (
-      query.SELECT.columns.some(c => c.expand && typeof c.expand[0] === 'string' && /^\*{1}[\d|*]+/.test(c.expand[0]))
-    ) {
-      return expandV2(model, dbc, query, user, locale, txTimestamp, executeSelectCQN)
-    }
-
-    return _processExpand(model, dbc, query, user, locale, txTimestamp)
-  }
-
-  const { sql, values = [] } = sqlFactory(
-    query,
-    {
-      user,
-      customBuilder: CustomBuilder,
-      now: txTimestamp || { sql: "strftime('%Y-%m-%dT%H:%M:%fZ','now')" }, // '2012-12-03T07:16:23.574Z'
-      locale
-    },
-    model
-  )
-
-  return executeSelectSQL(
-    dbc,
-    sql,
-    values,
-    query.SELECT.one,
-    getPostProcessMapper(SQLITE_TYPE_CONVERSION_MAP, model, query)
-  )
-}
-
-function executeDeleteCQN(model, dbc, cqn, user, locale, txTimestamp) {
-  const { sql, values = [] } = sqlFactory(
-    cqn,
-    {
-      user,
-      customBuilder: CustomBuilder,
-      now: txTimestamp || { sql: "strftime('%Y-%m-%dT%H:%M:%fZ','now')" } // '2012-12-03T07:16:23.574Z'
-    },
-    model
-  )
-
-  return _executeSimpleSQL(dbc, sql, values)
-}
-
-const _executeBulkInsertSQL = (dbc, sql, values) =>
-  new Promise((resolve, reject) => {
-    if (!Array.isArray(values)) {
-      return reject(new Error(`Cannot execute SQL statement. Invalid values provided: ${inspect(values)}`))
-    }
-
-    LOG._debug && LOG.debug(sql, SANITIZE_VALUES ? ['***'] : values)
-    const stmt = _exec(dbc, 'prepare', sql, err => {
-      if (err) return reject(err)
-
-      // REVISIT: better?
-      if (dbc._closed) return reject(new Error('Transaction is already closed'))
-
-      if (!Array.isArray(values[0])) values = [values]
-
-      // guarantee order through counters in closure
-      let i = 0
-      let n = values.length
-      let isFinalized = false
-      const results = Array(n)
-      values.forEach(each => {
-        const k = i
-        i++
-        stmt.run(each, function (err) {
-          if (err) {
-            if (!isFinalized) {
-              isFinalized = true
-              stmt.finalize()
-              return reject(err)
-            }
-          }
-
-          // InsertResult needs an object per row with its values
-          results[k] = { lastID: this.lastID, affectedRows: 1, values: each }
-          n--
-          if (n === 0) {
-            if (!isFinalized) {
-              isFinalized = true
-              stmt.finalize()
-              resolve(results)
-            }
-          }
-        })
-      })
-    })
-  })
-
-function executePlainSQL(dbc, sql, values, isOne, postMapper) {
-  // support named binding parameters
-  if (values && typeof values === 'object' && !Array.isArray(values)) {
-    values = new Proxy(values, {
-      getOwnPropertyDescriptor: (o, p) => Object.getOwnPropertyDescriptor(o, p.slice(1)),
-      get: (o, p) => o[p.slice(1)],
-      ownKeys: o => Reflect.ownKeys(o).map(k => `:${k}`)
-    })
-  }
-
-  if (/^\s*(select|pragma)/i.test(sql)) {
-    return executeSelectSQL(dbc, sql, values, isOne, postMapper)
-  }
-
-  if (/^\s*insert/i.test(sql) || /^\s*upsert/i.test(sql)) {
-    return executeInsertSQL(dbc, sql, values)
-  }
-
-  return _executeSimpleSQL(dbc, sql, values && Array.isArray(values[0]) ? values[0] : values)
-}
-
-function executeInsertSQL(dbc, sql, values, query) {
-  // Only bulk inserts will have arrays in arrays
-  if (Array.isArray(values[0])) {
-    if (values.length > 1) {
-      return _executeBulkInsertSQL(dbc, sql, values)
-    } else {
-      values = values[0]
-    }
-  }
-
-  LOG._debug && LOG.debug(sql, SANITIZE_VALUES ? ['***'] : values)
-
-  return new Promise((resolve, reject) => {
-    _exec(dbc, 'run', sql, values, function (err) {
-      if (err) return reject(err)
-
-      // InsertResult needs an object per row with its values
-      if (query && values.length > 0) {
-        // > single row via cqn
-        resolve([{ lastID: this.lastID, affectedRows: 1, values }])
-      } else {
-        // > plain sql or INSERT into SELECT
-        resolve([{ lastID: this.lastID, affectedRows: this.changes }])
-      }
-    })
-  })
-}
-
-// REVISIT: optimize - now sub-arrays are called sequentially
-async function _convertStreamValues(values) {
-  let any
-  for (let i = 0; i < values.length; i++) {
-    const v = values[i]
-    if (v instanceof Readable) {
-      any = values[i] = new Promise(resolve => {
-        const chunks = []
-        v.on('data', chunk => chunks.push(chunk))
-        v.on('end', () => resolve(Buffer.concat(chunks)))
-        v.on('error', () => {
-          v.removeAllListeners('error')
-          v.push(null)
-        })
-      })
-    } else if (Array.isArray(v)) {
-      values[i] = await _convertStreamValues(v)
-    }
-  }
-  return any ? Promise.all(values) : values
-}
-
-async function executeInsertCQN(model, dbc, query, user, locale, txTimestamp) {
-  const { sql, values = [] } = sqlFactory(
-    query,
-    {
-      user,
-      customBuilder: CustomBuilder,
-      now: txTimestamp || { sql: "strftime('%Y-%m-%dT%H:%M:%fZ','now')" } // '2012-12-03T07:16:23.574Z'
-    },
-    model
-  )
-  const vals = await _convertStreamValues(values)
-  return executeInsertSQL(dbc, sql, vals, query)
-}
-
-async function executeUpdateCQN(model, dbc, cqn, user, locale, txTimestamp) {
-  const { sql, values = [] } = sqlFactory(
-    cqn,
-    {
-      user,
-      customBuilder: CustomBuilder,
-      now: txTimestamp || { sql: "strftime('%Y-%m-%dT%H:%M:%fZ','now')" } // '2012-12-03T07:16:23.574Z'
-    },
-    model
-  )
-  const vals = await _convertStreamValues(values)
-  return executePlainSQL(dbc, sql, vals)
-}
-
-// e. g. DROP, CREATE TABLE
-function executeGenericCQN(model, dbc, cqn, user, locale, txTimestamp) {
-  const { sql, values } = sqlFactory(
-    cqn,
-    {
-      user,
-      customBuilder: CustomBuilder,
-      now: txTimestamp || { sql: "strftime('%Y-%m-%dT%H:%M:%fZ','now')" } // '2012-12-03T07:16:23.574Z'
-    },
-    model
-  )
-
-  return executePlainSQL(dbc, sql, values)
-}
-
-// REVISIT: consider deleting this function after removing stream_compat
-async function executeSelectStreamCQN({ model, dbc, query, user, locale, txTimestamp }) {
-  let result = await executeSelectCQN(model, dbc, query, user, locale, txTimestamp)
-
-  if (result == null || result.length === 0) {
-    return
-  }
-
-  if (!cds.env.features.stream_compat) {
-    convertStream(query.SELECT.columns, query.target, result, query.SELECT.one)
-    return result
-  }
-
-  // REVISIT: following code to be deleted after cds.env.features.stream_compat is removed
-  if (Array.isArray(result)) result = result[0]
-  let [key, val] = Object.entries(result)[0]
-  if (val === null) {
-    return null
-  }
-  if (typeof val === 'number') {
-    val = val.toString()
-  }
-
-  const stream_ = new Readable()
-  stream_.push(val)
-  stream_.push(null)
-
-  result.value = stream_
-  delete result[key]
-
-  return result
-}
-
-module.exports = {
-  delete: executeDeleteCQN,
-  insert: executeInsertCQN,
-  update: executeUpdateCQN,
-  select: executeSelectCQN,
-  stream: executeSelectStreamCQN,
-  convert: convertStream,
-  cqn: executeGenericCQN,
-  sql: executePlainSQL
-}

package/libx/_runtime/sqlite/localized.js

@@ -1,49 +0,0 @@
-const { ensureUnlocalized } = require('../common/utils/draft')
-const { redirect } = require('../db/utils/localized')
-const cds = require('../cds')
-const LOG = cds.log('sqlite|db|sql')
-
-if (cds.env.i18n && Array.isArray(cds.env.i18n.for_sqlite) && !cds.env.i18n.for_sqlite.length) {
-  LOG._warn && LOG.warn('No language configuration found in cds.env.i18n.for_sqlite')
-}
-
-const _translations = cds.env.i18n.for_sqlite.reduce((all, l) => ((all[l] = true), all), {})
-
-// REVISIT: this is actually configurable
-// there is no localized.en.<name>
-const getLocalize = (locale, model) => name => {
-  if (name.endsWith('_drafts')) return name
-
-  // if we get here via onReadDraft, target is already localized
-  // because of subrequest using SELECT.from as new target
-  const target = model.definitions[ensureUnlocalized(name)]
-  if (target?.['@cds.localized'] === false) return name
-
-  const view = model.definitions[`localized${locale in _translations ? '.' + locale : ''}.${name}`]
-  return view?.name || name
-}
-
-const sqliteLocalized = function (req) {
-  const { query } = req
-
-  // do simple checks upfront and exit early
-  if (!query || typeof query === 'string') return
-  if (!query.SELECT) return
-  if (!this.model) return
-  if (!req.locale) return
-
-  // suppress localization by instruction
-  if (query.SELECT.localized === false) return
-
-  // suppress localization for pure counts
-  const columns = query.SELECT.columns
-  if (columns && columns.length === 1 && columns[0].func === 'count') return
-
-  // suppress localization in "select for update" n/a for sqlite
-
-  redirect(query, getLocalize(req.locale, this.model))
-}
-
-sqliteLocalized._initial = true
-
-module.exports = sqliteLocalized

package/libx/outbox/index.js

@@ -1,307 +0,0 @@
-const cds = require('../_runtime/cds')
-const LOG = cds.log('persistent-outbox')
-
-const { inspect } = require('util')
-
-const OutboxRunner = require('./OutboxRunner')
-const outboxRunner = new OutboxRunner()
-
-const waitingTime = require('../_runtime/common/utils/waitingTime')
-const { isStandardError } = require('../_runtime/common/error/standardError')
-
-const cdsUser = 'cds.internal.user'
-const $messageProcessorRegistered = Symbol('message processor registered')
-const $outboxed = Symbol('outboxed')
-const $unboxed = Symbol('unboxed')
-const $stored_reqs = Symbol('stored_reqs')
-
-const _get100NanosecondTimestampISOString = () => {
-  const [now, nanoseconds] = [new Date(), process.hrtime()[1]]
-  return now.toISOString().replace('Z', `${nanoseconds}`.padStart(9, '0').substring(3, 7) + 'Z')
-}
-
-const _getMessagesEntity = () => {
-  const messagesDbName = 'cds.outbox.Messages'
-  const messagesEntity = cds.model.definitions[messagesDbName]
-  if (!messagesEntity)
-    throw new Error(`The entity '${messagesDbName}' is missing but needed for the persistent outbox.`)
-  return messagesEntity
-}
-
-// REVISIT: Is this always a reliable way to identify the provider tenant?
-//          Are there scenarios where the credentials have a different format?
-const _isProviderTenant = tenant =>
-  cds.requires.auth && cds.requires.auth.credentials && cds.requires.auth.credentials.identityzoneid === tenant || cds.requires.multitenancy.t0 === tenant
-
-const hasPersistentOutbox = tenant => {
-  if (!cds.requires.outbox || cds.requires.outbox.kind !== 'persistent-outbox') return false
-  if (cds.requires.multitenancy && tenant && _isProviderTenant(tenant)) return false // no persistence for provider account
-  return true
-}
-
-const _safeJSONParse = string => {
-  try {
-    return string && JSON.parse(string)
-  } catch {
-    // Don't throw
-  }
-}
-
-// Note: This function can also run for each tenant on startup
-const processMessages = async (service, tenant, _opts = {}) => {
-  const opts = Object.assign({ attempt: 0 }, _opts)
-  const name = service.name
-  const messagesEntity = _getMessagesEntity()
-
-  outboxRunner.run({ name, tenant }, () => {
-    let letAppCrash = false
-    const config = tenant ? { tenant, user: cds.User.privileged } : { user: cds.User.privileged }
-    config.after = 1 // make sure spawn puts its cb on the `timer` queue (via setTimeout), which is also used by `outboxRunner`
-    const spawn = cds.spawn(async () => {
-      let messages
-      try {
-        const messagesQuery = SELECT.from(messagesEntity)
-          .where({ target: name })
-          .orderBy(['timestamp', 'ID'])
-          .limit(opts.chunkSize)
-          .forUpdate()
-        if (opts.maxAttempts) messagesQuery.where({ attempts: { '<': opts.maxAttempts } })
-        if (opts.parallel) messagesQuery.SELECT.forUpdate.ignoreLocked = true
-        messages = await messagesQuery
-      } catch (e) {
-        // could potentially be a timeout
-        const _waitingTime = waitingTime(opts.attempt)
-        LOG.error(`${name}: Message retrieval failed`, e, `Retrying in ${Math.round(_waitingTime / 1000)} s`)
-        outboxRunner.schedule(
-          {
-            name,
-            tenant,
-            waitingTime: _waitingTime
-          },
-          () => processMessages(service, tenant, { ...opts, attempt: opts.attempt + 1 })
-        )
-        return
-      }
-      let currMaxAttempts = 0
-      const messagesGen = function* () {
-        for (const _message of messages) {
-          const _msg = _safeJSONParse(_message.msg)
-          const userId = _msg[cdsUser]
-          const msg = _msg._fromSend ? new cds.Request(_msg) : new cds.Event(_msg)
-          delete msg._fromSend
-          Object.defineProperty(msg, '_fromOutbox', { value: true, enumerable: false })
-          delete msg[cdsUser]
-          currMaxAttempts = Math.max(_message.attempts || 0, currMaxAttempts)
-          const user = new cds.User.Privileged(userId)
-          if (!msg) continue
-          const res = {
-            ID: _message.ID,
-            msg,
-            user
-          }
-          yield res
-        }
-      }
-
-      const toBeDeleted = []
-      const toBeUpdated = []
-      try {
-        const _handleWithErr = async ({ msg, user, ID }) => {
-          try {
-            await cds._context.run({ user, tenant }, async () => {
-              if (opts.handle) await opts.handle.call(service, msg)
-              else await service.handle(msg)
-            })
-            toBeDeleted.push(ID)
-          } catch (e) {
-            if (isStandardError(e)) {
-              LOG.error(`${service.name}: Programming error detected:`, e)
-              toBeDeleted.push(ID)
-              throw new Error(`${service.name}: Programming error detected.`)
-            }
-            if (e.unrecoverable) {
-              LOG.error(`${service.name}: Unrecoverable error:`, e)
-              if (opts.maxAttempts) {
-                const _msg = { ID, attempts: opts.maxAttempts }
-                if (opts.storeLastError !== false) _msg.lastError = e
-                toBeUpdated.push(_msg)
-              } else toBeDeleted.push(ID)
-            } else {
-              LOG.error(`${service.name}: Emit failed:`, e)
-              const _msg = { ID }
-              if (opts.storeLastError !== false) _msg.lastError = e
-              toBeUpdated.push(_msg)
-              return false
-            }
-          }
-        }
-        const messages = messagesGen()
-        // REVISIT: Maybe we can also support handleMany and provide the iterator (for batch processing)
-        if (opts.parallel) {
-          const first = messages.next()?.value // First try to see if message can be emitted
-          if (!(first && (await _handleWithErr(first)) === false)) { // No need to process the rest if the first emit failed
-            const res = await Promise.allSettled([...messages].map(_handleWithErr))
-            const errors = res.filter(r => r.status === 'rejected').map(r => r.reason)
-            if (errors.length) {
-              throw new Error(`${service.name}: Programming errors detected.`)
-            }
-          }
-        } else {
-          for (const msg of messages) {
-            if ((await _handleWithErr(msg)) === false) break
-          }
-        }
-      } catch {
-        letAppCrash = true
-      }
-
-      const queries = []
-      const _waitingTime = waitingTime(currMaxAttempts)
-      if (toBeDeleted.length) queries.push(DELETE.from(messagesEntity).where('ID in', toBeDeleted))
-      if (toBeUpdated.length) {
-        for (const toBeUpdatedMsg of toBeUpdated) {
-          if (toBeDeleted.includes(toBeUpdatedMsg.ID)) continue
-          const data = {
-            attempts: { '+=': 1 }
-          }
-          Object.assign(data, toBeUpdatedMsg)
-          if (data.lastError && typeof data.lastError !== 'string') data.lastError = inspect(data.lastError)
-          queries.push(UPDATE(messagesEntity).where({ ID: toBeUpdatedMsg.ID }).set(data))
-        }
-      }
-
-      await Promise.all(queries)
-
-      if (letAppCrash) return
-
-      if (toBeUpdated.length) {
-        LOG.error(`${name}: Some messages could not be emitted, retrying in ${Math.round(_waitingTime / 1000)} s`)
-        return outboxRunner.schedule(
-          {
-            name,
-            tenant,
-            waitingTime: _waitingTime
-          },
-          () => processMessages(service, tenant, opts)
-        )
-      }
-      outboxRunner.success({ name, tenant })
-      if (toBeDeleted.length === opts.chunkSize) {
-        processMessages(service, tenant, opts) // We only processed max. opts.chunkSize, so there might be more
-      } else {
-        LOG._debug && LOG.debug(`${name}: All messages processed`)
-      }
-    }, config)
-    spawn.on('done', () => {
-      if (letAppCrash) cds.exit(1)
-      outboxRunner.end({ name, tenant }, () => processMessages(service, tenant, opts))
-    })
-  })
-}
-
-const registerMessageProcessor = (name, context) => {
-  const registry = context[$messageProcessorRegistered] || (context[$messageProcessorRegistered] = new Set())
-  if (!registry.has(name)) {
-    registry.add(name)
-    return true
-  }
-  return false
-}
-
-const _createMessage = (name, msg, context) => {
-  const _msg = { [cdsUser]: context.user.id }
-  if (msg._fromSend || msg.reply) _msg._fromSend = true // send or emit?
-  if (msg.inbound) _msg.inbound = msg.inbound
-  if (msg.event) _msg.event = msg.event
-  if (msg.data) _msg.data = msg.data
-  if (msg.headers) _msg.headers = msg.headers
-  if (msg.query) _msg.query = msg.query
-  const outboxMsg = {
-    ID: cds.utils.uuid(),
-    target: name,
-    timestamp: _get100NanosecondTimestampISOString(), // needs to be different for each emit
-    msg: JSON.stringify(_msg)
-  }
-  return outboxMsg
-}
-
-const writeInOutbox = async (name, msg, context) => {
-  const outboxMsg = _createMessage(name, msg, context)
-  const messagesEntity = _getMessagesEntity()
-  return cds.tx(context).run(INSERT.into(messagesEntity).entries(outboxMsg))
-}
-
-function unboxed(srv) {
-  return srv[$unboxed] || srv
-}
-
-function outboxed(srv, customOpts) {
-  // outbox max. once
-  if (!new.target) {
-    const former = srv[$outboxed]
-    if (former) return former
-  }
-
-  const originalSrv = srv[$unboxed] || srv
-  const outboxedSrv = Object.create(originalSrv)
-  outboxedSrv[$unboxed] = originalSrv
-
-  if (!new.target) Object.defineProperty(srv, $outboxed, { value: outboxedSrv })
-
-  let requiresOpts = cds.requires.outbox
-  let serviceOpts = srv.options?.outbox
-
-  if (typeof requiresOpts === 'string') requiresOpts = { kind: requiresOpts }
-  if (typeof serviceOpts === 'string') serviceOpts = { kind: serviceOpts }
-
-  const outboxOpts = Object.assign(
-    {},
-    (typeof requiresOpts === 'object' && requiresOpts) || {},
-    (typeof serviceOpts === 'object' && serviceOpts) || {},
-    customOpts || {}
-  )
-
-
-  outboxedSrv.handle = async function (req) {
-    const context = req.context || cds.context
-    if (outboxOpts.kind === 'persistent-outbox' && hasPersistentOutbox(context.tenant)) {
-      // returns true if not yet registered
-      if (registerMessageProcessor(srv.name, context)) {
-        // NOTE: What if there are different outbox options for the same service?!
-        //       There could be messages for srv1 with { maxAttempts: 1 }
-        //       and messages for srv1 with { maxAttempts: 9 }.
-        //       How would they be processed? I'd rather not have dedicated
-        //       service names or store serialized options for each message.
-        context.on('succeeded', () => processMessages(originalSrv, context.tenant, outboxOpts))
-      }
-      await writeInOutbox(srv.name, req, context)
-      return
-    }
-
-    if (!context[$stored_reqs]) {
-      context[$stored_reqs] = []
-      context.on('succeeded', async () => {
-        // REVISIT: Also allow maxAttempts for in-memory outbox?
-        for (const _req of context[$stored_reqs]) {
-          try {
-            if (_req.reply) await originalSrv.send(_req)
-            else await originalSrv.emit(_req)
-          } catch (e) {
-            LOG.error('Emit failed', { event: _req.event, cause: e })
-            if (isStandardError(e)) {
-              cds.log().error('❗️Uncaught', e)
-              await cds.shutdown(e)
-              return
-            }
-          }
-        }
-        delete context[$stored_reqs]
-      })
-    }
-    context[$stored_reqs].push(req)
-  }
-
-  return outboxedSrv
-}
-
-module.exports = { outboxed, unboxed }