@sap/cds 5.6.2 → 5.7.2

package/libx/_runtime/hana/pool.js

@@ -6,10 +6,9 @@ const hana = require('./driver')
 
 const _require = require('../common/utils/require')
 
-let im
+function multiTenantInstanceManager(config = cds.env.requires.db) {
+  const { credentials } = config
 
-function multiTenantInstanceManager(db = cds.env.requires.db) {
-  const credentials = db.credentials
   if (
     !credentials ||
     typeof credentials !== 'object' ||
@@ -22,10 +21,23 @@ function multiTenantInstanceManager(db = cds.env.requires.db) {
   return new Promise((resolve, reject) => {
     // REVISIT: better cache settings? current copied from old cds-hana...
     // note: may need to be low for mtx tests -> configurable?
-    const opts = Object.assign(credentials, {
+    const opts = {
       cache_max_items: 1,
       cache_item_expire_seconds: 1
-    })
+    }
+
+    // check binding to both managed-hana and service-manager for instance migration
+    if (cds.env.features.hybrid_instance_manager && process.env.VCAP_SERVICES) {
+      const vcap = JSON.parse(process.env.VCAP_SERVICES)
+      if (vcap['managed-hana'] && vcap['service-manager']) {
+        opts.smOpts = vcap['service-manager'][0].credentials
+        opts.imOpts = vcap['managed-hana'][0].credentials
+      }
+    }
+
+    // no double config -> take passed credentials (= cds.env.requires.db.credentials)
+    if (!opts.smOpts) Object.assign(opts, credentials)
+
     // REVISIT: should be relative
     // const mtxPath = require.resolve('@sap/cds-mtx', { paths: [process.env.pwd(), __dirname] })
     // const imPath = require.resolve('@sap/instance-manager', { paths: [mtxPath] })
@@ -37,29 +49,29 @@ function multiTenantInstanceManager(db = cds.env.requires.db) {
   })
 }
 
-function singleTenantInstanceManager(db = cds.env.requires.db) {
-  const credentials = db.credentials
+function singleTenantInstanceManager(config = cds.env.requires.db) {
+  const { credentials } = config
 
   if (!credentials || typeof credentials !== 'object' || !credentials.host) {
-    throw Object.assign(new Error('No or malformed db credentials'), { credentials: credentials })
+    throw Object.assign(new Error('No or malformed db credentials'), { credentials })
   }
 
   // mock instance manager
   return {
-    get: (_, cb) => {
-      cb(null, { credentials: credentials })
-    }
+    get: (_, cb) => cb(null, { credentials })
   }
 }
 
-async function credentials4(tenant, credentials) {
-  if (!im) {
-    const opts = credentials ? { credentials } : undefined
-    im = cds.env.requires.db.multiTenant ? await multiTenantInstanceManager(opts) : singleTenantInstanceManager(opts)
+async function credentials4(tenant, db) {
+  if (!db._instance_manager) {
+    const opts = db.options && db.options.credentials ? db.options : undefined
+    db._instance_manager = cds.env.requires.db.multiTenant
+      ? await multiTenantInstanceManager(opts)
+      : singleTenantInstanceManager(opts)
   }
 
   return new Promise((resolve, reject) => {
-    im.get(tenant, (err, res) => {
+    db._instance_manager.get(tenant, (err, res) => {
       if (err) return reject(err)
       if (!res)
         return reject(Object.assign(new Error(`There is no instance for tenant "${tenant}"`), { statusCode: 404 }))
@@ -85,29 +97,12 @@ function factory4(creds, tenant) {
 /*
  * default generic-pool config
  */
-const config = { min: 0, max: 100, testOnBorrow: true }
-
-// REVISIT: copied from old cds-hana
-const _getMassagedCreds = function (creds) {
-  if (!('ca' in creds) && creds.certificate) {
-    creds.ca = creds.certificate
-  }
-  if ('encrypt' in creds && !('useTLS' in creds)) {
-    creds.useTLS = creds.encrypt
-  }
-  if ('hostname_in_certificate' in creds && !('sslHostNameInCertificate' in creds)) {
-    creds.sslHostNameInCertificate = creds.hostname_in_certificate
-  }
-  if ('validate_certificate' in creds && !('sslValidateCertificate' in creds)) {
-    creds.sslValidateCertificate = creds.validate_certificate
-  }
-  return creds
-}
+const defaultConfig = { min: 0, max: 100, testOnBorrow: true }
 
 const _getPoolConfig = function () {
   const { pool: poolConfig } = cds.env.requires.db
 
-  const mergedConfig = Object.assign({}, config, poolConfig)
+  const mergedConfig = Object.assign({}, defaultConfig, poolConfig)
 
   // defaults
   if (!poolConfig) {
@@ -134,14 +129,31 @@ const _getPoolConfig = function () {
   return mergedConfig
 }
 
+// REVISIT: copied from old cds-hana
+const _getMassagedCreds = function (creds) {
+  if (!('ca' in creds) && creds.certificate) {
+    creds.ca = creds.certificate
+  }
+  if ('encrypt' in creds && !('useTLS' in creds)) {
+    creds.useTLS = creds.encrypt
+  }
+  if ('hostname_in_certificate' in creds && !('sslHostNameInCertificate' in creds)) {
+    creds.sslHostNameInCertificate = creds.hostname_in_certificate
+  }
+  if ('validate_certificate' in creds && !('sslValidateCertificate' in creds)) {
+    creds.sslValidateCertificate = creds.validate_certificate
+  }
+  return creds
+}
+
 const pools = new Map()
 
-async function pool4(tenant, credentials) {
+async function pool4(tenant, db) {
   if (!pools.get(tenant)) {
     pools.set(
       tenant,
       new Promise((resolve, reject) => {
-        credentials4(tenant, credentials)
+        credentials4(tenant, db)
           .then(creds => {
             const config = _getPoolConfig()
             LOG._info && LOG.info('effective pool configuration:', config)
@@ -217,8 +229,8 @@ async function resilientAcquire(pool, attempts = 1) {
 }
 
 module.exports = {
-  acquire: async (tenant, credentials) => {
-    const pool = await pool4(tenant, credentials)
+  acquire: async (tenant, db) => {
+    const pool = await pool4(tenant, db)
     const _attempts = cds.env.requires.db.connection_attempts
     const attempts = _attempts && !isNaN(_attempts) && parseInt(_attempts)
     const client = await resilientAcquire(pool, attempts)
@@ -229,12 +241,10 @@ module.exports = {
     return client._pool.release(client)
   },
   drain: async tenant => {
-    if (!pools.get(tenant)) {
-      return
-    }
-    const p = await pool4(tenant)
+    const pool = pools.get(tenant)
+    if (!pool) return
     pools.delete(tenant)
-    await p.drain()
-    await p.clear()
+    await pool.drain()
+    await pool.clear()
   }
 }

package/libx/_runtime/hana/search.js

@@ -1,18 +1,19 @@
 const cds = require('../cds')
 const search2cqn4sql = require('./search2cqn4sql')
 
+const _setSearchOptions = (query, _searchOptions) => {
+  if (!(query && query.SELECT)) return
+  if (query.SELECT.search) Object.defineProperty(query, '_searchOptions', { value: _searchOptions })
+  if (query.SELECT.from.SELECT) _setSearchOptions(query.SELECT.from, _searchOptions)
+}
+
 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
 
-  const query = req.query
-  const search = query && query.SELECT && query.SELECT.search
-
-  if (search) {
-    Object.defineProperty(req.query, '_searchOptions', { value: { search2cqn4sql, locale: req.locale } })
-  }
+  _setSearchOptions(req.query, { search2cqn4sql, locale: req.locale })
 }
 
 // handlers marked with `._initial = true` run in sequence

package/libx/_runtime/hana/search2cqn4sql.js

@@ -28,12 +28,13 @@ const search2cqn4sql = (query, entity, options) => {
 
   // If the localized association is defined for the target entity,
   // there should be at least one localized element.
-  const resolveLocalizedTextsAtRuntime = !!localizedAssociation
+  const resolveLocalizedDataAtRuntime = !!localizedAssociation
 
   // suppress the localize handler from redirecting the query's target to the localized view
   Object.defineProperty(query, '_suppressLocalization', { value: true })
 
-  if (resolveLocalizedTextsAtRuntime) {
+  // do not join if subquery exists - already done in there
+  if (resolveLocalizedDataAtRuntime && !query.SELECT.from.SELECT) {
     const onCondition = entity._relations[localizedAssociation.name].join(localizedAssociation.target, entity.name)
 
     // replace $user_locale placeholder with the user locale or the HANA session context
@@ -52,15 +53,17 @@ const search2cqn4sql = (query, entity, options) => {
   let expression
 
   if (useContains) {
-    expression = searchToContains(cqnSearchPhrase, columnsToBeSearched)
+    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))
   } 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 ? query.having(expression) : query.where(expression)
+  query._aggregated || /* if new parser */ query.SELECT.groupBy ? query.having(expression) : query.where(expression)
   return query
 }
 

package/libx/_runtime/hana/searchToContains.js

@@ -67,9 +67,11 @@ const searchToContains = (cqnSearchPhrase, columns) => {
 const isContainsPredicateSupported = query => {
   const cqnSearchPhrase = query.SELECT.search
 
+  if (cqnSearchPhrase && cqnSearchPhrase[0] && cqnSearchPhrase[0].val === ' ') return false
+
   // REVISIT: In the future, to further optimize search queries, you might
   // want to remove the following condition(s).
-  if (query._aggregated) return false
+  if (query._aggregated || /* new parser */ query.SELECT.groupBy) return false
 
   // REVISIT: search terms starting with whitespace after a `NOT` operator does not
   // return the expected result on SAP HANA (BCP 2180256508). In addition, double

package/libx/_runtime/index.js

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

package/libx/_runtime/messaging/AMQPWebhookMessaging.js

@@ -21,11 +21,11 @@ class AMQPWebhookMessaging extends MessagingService {
     return super.init()
   }
 
-  async emit(event, ...etc) {
-    const msg = this.message4(event, ...etc)
+  async emit(msg) {
+    const _msg = this.message4(msg)
     const client = this.getClient()
     await this.queued(() => {})()
-    return client.emit(msg)
+    return client.emit(_msg)
   }
 
   startListening(opt = {}) {

package/libx/_runtime/messaging/Outbox.js

@@ -0,0 +1,53 @@
+const cds = require('../cds')
+
+const {
+  processMessages,
+  registerMessageProcessor,
+  writeInOutbox,
+  hasPersistentOutbox,
+  isUnrecoverable
+} = require('./outbox/utils')
+
+class OutboxService extends cds.Service {
+  // eslint-disable-next-line require-await
+  async init() {
+    // REVISIT: add 'outbox' to list of module names?
+    const LOG = cds.log(this.name)
+
+    // REVISIT: Also allow to overwrite this.send
+    this._emitImmediate = this.emit
+    this.emit = async function (...args) {
+      const msg = typeof args[0] === 'object' ? args[0] : { event: args[0], data: args[1], headers: args[2] }
+      const context = this.context || cds.context
+      if (this.options.outbox && context && typeof context.on === 'function') {
+        const outboxOpts = Object.assign(
+          {},
+          (typeof cds.requires.outbox === 'object' && cds.requires.outbox) || {},
+          (this.options && typeof this.options.outbox === 'object' && this.options.outbox) || {}
+        )
+        if (hasPersistentOutbox(this, context.tenant)) {
+          // returns true if not yet registered
+          if (registerMessageProcessor(this.name, context)) {
+            context.on('succeeded', () => processMessages(this, context.tenant, outboxOpts))
+          }
+          await writeInOutbox(this.name, msg, context)
+          return
+        }
+        // Revisit: Also allow maxAttempts?
+        context.on('succeeded', async () => {
+          try {
+            await this._emitImmediate(msg)
+          } catch (e) {
+            LOG._error && LOG.error('Emit failed', { event: msg.event, cause: e })
+            // opts.crashOnError is not official!!!
+            if (isUnrecoverable(this, e) && outboxOpts.crashOnError !== false) process.exit(1)
+          }
+        })
+        return
+      }
+      return this._emitImmediate(msg)
+    }
+  }
+}
+
+module.exports = OutboxService

package/libx/_runtime/messaging/common-utils/AMQPClient.js

@@ -2,6 +2,7 @@ const cds = require('../../cds.js')
 const LOG = cds.log('messaging')
 const ClientAmqp = require('@sap/xb-msg-amqp-v100').Client
 const { connect, disconnect } = require('./connections')
+const { hasPersistentOutbox } = require('../outbox/utils')
 
 const _JSONorString = string => {
   try {
@@ -33,16 +34,19 @@ const addDataListener = (client, queue, prefix, cb) =>
       })
   })
 
-const sender = (client, optionsApp) => client.sender(`${optionsApp.appName}-${optionsApp.appID}`).attach('')
+const sender = (client, optionsApp) => client.sender(`${optionsApp.appName}-${optionsApp.appID}`)
 
-const emit = ({ data, event: topic, headers = {} }, sender, prefix) =>
+const emit = ({ data, event: topic, headers = {} }, stream, prefix) =>
   new Promise((resolve, reject) => {
     LOG._info && LOG.info('Emit', { topic })
     const message = { ...headers, data }
     const payload = { chunks: [Buffer.from(JSON.stringify(message))], type: 'application/json' }
     const msg = {
       done: resolve,
-      failed: reject,
+      failed: e => {
+        if (e.condition === 'amqp:not-allowed') e.unrecoverable = true
+        reject(e)
+      },
       payload,
       target: {
         properties: {
@@ -50,21 +54,21 @@ const emit = ({ data, event: topic, headers = {} }, sender, prefix) =>
         }
       }
     }
-    sender.write(msg)
+    stream.write(msg)
   })
 
 class AMQPClient {
-  constructor({ optionsAMQP, optionsApp, queueName, prefix, keepAlive = true }) {
+  constructor({ optionsAMQP, prefix, service, keepAlive = true }) {
     this.optionsAMQP = optionsAMQP
-    this.optionsApp = optionsApp
-    this.queueName = queueName
     this.prefix = prefix
     this.keepAlive = keepAlive
+    this.service = service
   }
 
   connect() {
     this.client = new ClientAmqp(this.optionsAMQP)
-    this.sender = sender(this.client, this.optionsApp)
+    this.sender = sender(this.client, this.service.optionsApp)
+    this.stream = this.sender.attach('')
     return connect(this.client, this.keepAlive)
   }
 
@@ -77,12 +81,15 @@ class AMQPClient {
 
   async emit(msg) {
     if (!this.client) await this.connect()
-    await emit(msg, this.sender, this.prefix.topic)
+    // REVISIT: Is this a robust way to find out if the connection is working?
+    if (hasPersistentOutbox(this.service, cds.context && cds.context.tenant) && !this.sender.opened())
+      throw new Error('AMQP: Sender is not open')
+    await emit(msg, this.stream, this.prefix.topic)
     if (!this.keepAlive) return this.disconnect()
   }
 
   listen(cb) {
-    return addDataListener(this.client, this.queueName, this.prefix.queue, cb)
+    return addDataListener(this.client, this.service.queueName, this.prefix.queue, cb)
   }
 }
 

package/libx/_runtime/messaging/common-utils/connections.js

@@ -1,17 +1,22 @@
 const cds = require('../../cds')
 const LOG = cds.log('messaging')
-
-const MAX_WAITING_TIME = 1480000
-
-const _waitingTime = x => (x > 18 ? MAX_WAITING_TIME : (Math.pow(1.5, x) + Math.random()) * 1000)
+const waitingTime = require('./waitingTime')
 
 const _connectUntilConnected = (client, x) => {
+  const _waitingTime = waitingTime(x)
   setTimeout(() => {
-    connect(client, true).catch(e => {
-      LOG._warn && LOG.warn(`Connection to Enterprise Messaging Client lost: Unsuccessful attempt to reconnect (${x}).`)
-      _connectUntilConnected(client, x + 1)
-    })
-  }, _waitingTime(x))
+    connect(client, true)
+      .then(() => {
+        LOG._warn && LOG.warn('Reconnected to Enterprise Messaging Client')
+      })
+      .catch(e => {
+        LOG._warn &&
+          LOG.warn(
+            `Connection to Enterprise Messaging Client lost: Reconnecting in ${Math.round(_waitingTime / 1000)} s`
+          )
+        _connectUntilConnected(client, x + 1)
+      })
+  }, _waitingTime)
 }
 
 const connect = (client, keepAlive) => {

package/libx/_runtime/messaging/common-utils/waitingTime.js

@@ -0,0 +1,2 @@
+const MAX_WAITING_TIME = 1480000
+module.exports = x => (x > 18 ? MAX_WAITING_TIME : (Math.pow(1.5, x) + Math.random()) * 1000)

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

@@ -17,9 +17,8 @@ class EnterpriseMessagingShared extends AMQPWebhookMessaging {
     const optionsAMQP = optionsMessaging(this.options, 'amqp10ws')
     this.client = new AMQPClient({
       optionsAMQP,
-      optionsApp: this.optionsApp,
-      queueName: this.queueName,
-      prefix: { topic: 'topic:', queue: 'queue:' }
+      prefix: { topic: 'topic:', queue: 'queue:' },
+      service: this
     })
     return this.client
   }

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

@@ -3,7 +3,7 @@ const LOG = cds.log('messaging')
 const express = require('express')
 const getTenantInfo = require('./getTenantInfo.js')
 const isSecured = () => cds.requires.uaa && cds.requires.uaa.credentials
-const { getTenant } = require('../../common/auth/strategies/utils/xssec.js')
+const { getTenant } = require('../../auth/strategies/utils/xssec.js')
 
 const _isAll = a => a && a.includes('all')
 const _hasScope = (scope, req) =>
@@ -16,7 +16,7 @@ class EndpointRegistry {
     this.webhookCallbacks = new Map()
     this.deployCallbacks = new Map()
     if (isSecured()) {
-      const JWTStrategy = require('../../common/auth/strategies/JWT.js')
+      const JWTStrategy = require('../../auth/strategies/JWT.js')
       const passport = require('passport')
       passport.use(new JWTStrategy(cds.requires.uaa))
       paths.forEach(path => {

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

@@ -162,21 +162,27 @@ class EnterpriseMessaging extends AMQPWebhookMessaging {
 
     await this.queued(() => {})()
 
-    return authorizedRequest({
-      method: 'POST',
-      uri: optionsMessagingREST.uri,
-      path: `/messagingrest/v1/topics/${encodeURIComponent(topic)}/messages`,
-      oa2: optionsMessagingREST.oa2,
-      tenant,
-      dataObj: message,
-      headers: {
-        'x-qos': 1
-      },
-      attemptInfo: () => LOG._info && LOG.info('Emit', { topic }),
-      errMsg,
-      target: { kind: 'MESSAGE', topic },
-      tokenStore: {}
-    })
+    try {
+      await authorizedRequest({
+        method: 'POST',
+        uri: optionsMessagingREST.uri,
+        path: `/messagingrest/v1/topics/${encodeURIComponent(topic)}/messages`,
+        oa2: optionsMessagingREST.oa2,
+        tenant,
+        dataObj: message,
+        headers: {
+          'x-qos': 1
+        },
+        attemptInfo: () => LOG._info && LOG.info('Emit', { topic }),
+        errMsg,
+        target: { kind: 'MESSAGE', topic },
+        tokenStore: {}
+      })
+    } 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.response && (e.response.statusCode === 400 || e.response.statusCode === 403)) e.unrecoverable = true
+      throw e
+    }
   }
 
   wildcarded(topic) {

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

@@ -20,14 +20,14 @@ class FileBasedMessaging extends MessagingService {
     return super.init()
   }
 
-  async emit(event, ...etc) {
-    const msg = this.message4(event, ...etc)
-    const e = msg.event
-    delete msg.event
+  async emit(msg) {
+    const _msg = this.message4(msg)
+    const e = _msg.event
+    delete _msg.event
     await this.queued(lock)(this.file)
     LOG._debug && LOG.debug('Emit', { topic: e, file: this.file })
     try {
-      await fs.appendFile(this.file, `\n${e} ${JSON.stringify(msg)}`)
+      await fs.appendFile(this.file, `\n${e} ${JSON.stringify(_msg)}`)
     } catch (e) {
       LOG._debug && LOG.debug('Error', e)
     } finally {

package/libx/_runtime/messaging/message-queuing.js

@@ -156,9 +156,8 @@ class MessageQueuing extends AMQPWebhookMessaging {
     const optionsAMQP = optionsMessaging(this.options)
     this.client = new AMQPClient({
       optionsAMQP,
-      optionsApp: this.optionsApp,
-      queueName: this.queueName,
-      prefix: { topic: 'topic://', queue: 'queue://' }
+      prefix: { topic: 'topic://', queue: 'queue://' },
+      service: this
     })
     return this.client
   }

package/libx/_runtime/messaging/outbox/OutboxRunner.js

@@ -0,0 +1,75 @@
+const PROCESSING = 'processing'
+const LOCKED = 'locked'
+const QUEUED = 'queued'
+const SCHEDULED = 'scheduled'
+
+class OutboxRunner {
+  constructor() {
+    this.states = new Map()
+  }
+
+  _setStateProp(prop, state, { name, tenant }) {
+    const statesSrv = this.states.get(name)
+    if (!statesSrv) {
+      const newStatesSrv = new Map()
+      newStatesSrv.set(tenant, { [prop]: state })
+      this.states.set(name, newStatesSrv)
+      return state
+    }
+    const obj = statesSrv.get(tenant)
+    if (!obj) {
+      statesSrv.set(tenant, { [prop]: state })
+      return state
+    }
+    obj[prop] = state
+    return state
+  }
+
+  _getStateProp(prop, { name, tenant }) {
+    const statesSrv = this.states.get(name)
+    if (!statesSrv) return
+    const obj = statesSrv.get(tenant)
+    return obj && obj[prop]
+  }
+
+  run({ name, tenant }, cb) {
+    const scheduled = this._getStateProp(SCHEDULED, { name, tenant })
+    if (scheduled) return // maybe make that configurable, we can also 'refresh' the current try
+    const processingState = this._getStateProp(PROCESSING, { name, tenant })
+    if (processingState === LOCKED) {
+      this._setStateProp(PROCESSING, QUEUED, { name, tenant })
+      return
+    }
+    if (processingState === QUEUED) return
+    if (!processingState) this._setStateProp(PROCESSING, LOCKED, { name, tenant })
+    return cb()
+  }
+
+  schedule({ name, tenant, waitingTime }, cb) {
+    if (this._getStateProp(SCHEDULED, { name, tenant })) return
+    const timer = setTimeout(() => {
+      this._setStateProp(SCHEDULED, undefined, { name, tenant })
+      return cb()
+    }, waitingTime)
+    this._setStateProp(SCHEDULED, timer, { name, tenant })
+  }
+
+  end({ name, tenant }, cb) {
+    const processingState = this._getStateProp(PROCESSING, { name, tenant })
+    this._setStateProp(PROCESSING, undefined, { name, tenant })
+    if (processingState === QUEUED) {
+      return cb()
+    }
+  }
+
+  success({ name, tenant }) {
+    const timer = this._getStateProp(SCHEDULED, { name, tenant })
+    if (timer) {
+      // once successful, we don't want to have another scheduled run
+      clearTimeout(timer)
+      this._setStateProp(SCHEDULED, undefined, { name, tenant })
+    }
+  }
+}
+
+module.exports = OutboxRunner