comq 0.8.0 → 0.9.0

package/.github/workflows/release.yaml

@@ -31,8 +31,8 @@ jobs:
         with:
           fetch-depth: 0
 
-#      - name: Run tests
-#        run: npm i && npm test
+      - name: Run tests
+        run: npm i && npm test
 
       - name: Import GPG key
         id: gpg
@@ -65,6 +65,8 @@ jobs:
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
         run: |
+          npm pkg delete scripts.prepare # husky
+          
           if [ ${{ github.base_ref }} = main ]; then
             npm publish
           else

package/features/events.feature

@@ -19,3 +19,8 @@ Feature: Events
     Given that events are exclusively consumed from the `numbers_added` exchange
     When an event is emitted to the `numbers_added` exchange
     Then the event is received
+
+  Scenario: Streaming requests
+    Given that events are exclusively consumed from the `numbers_added` exchange
+    When a stream of 1k events is emitted to the `numbers_added` exchange
+    Then 1k events is received

package/features/recovery.feature

@@ -98,9 +98,6 @@ Feature: Request-Reply Topology Recovery
     And `someone` receives the event
 
   Scenario: Start consuming events while broker is down
-
-  First consume will assert queue, so error will happen while calling AMQP.consume()
-
     Given that `first` is consuming events from the `numbers_added` exchange
     And `second` consuming events from the `numbers_added` exchange is expected
     When the broker has crashed

package/features/rpc.feature

@@ -5,18 +5,18 @@ Feature: Request-reply (RPC)
 
   Scenario: Sending request and getting reply
     Given function replying `add_numbers` queue:
-    """
-    ({ a, b }) => { return a + b }
-    """
+      """
+      ({ a, b }) => { return a + b }
+      """
     When the consumer sends the following request to the `add_numbers` queue:
-    """yaml
-    a: 1
-    b: 2
-    """
+      """yaml
+      a: 1
+      b: 2
+      """
     Then the consumer receives the reply:
-    """yaml
-    3
-    """
+      """yaml
+      3
+      """
 
   Scenario: Request causing an exception is discarded
     Given function replying `throw_error` queue:
@@ -26,3 +26,8 @@ Feature: Request-reply (RPC)
     When the consumer sends a request to the `throw_error` queue
     Then the message is discarded
     And the consumer does not receive the reply
+
+  Scenario: Streaming requests
+    Given a producer replying `ping` queue
+    When the consumer sends 1k requests to the `ping` queue as a stream
+    Then the consumer receives 1k replies as a stream

package/features/steps/.test/events.test.js

@@ -232,9 +232,9 @@ describe('Given I\'m publishing {quantity}B events to the {token} exchange at {q
 
     step.call(context, bytesQ, exchange, frequencyQ)
 
-    await timeout(100 + 12)
+    await timeout(100)
 
-    const callsAmountExpected = [10, 11]
+    const callsAmountExpected = [9, 10]
 
     expect(callsAmountExpected).toContain(context.io.emit.mock.calls.length)
     expect(context.publishing).toBeDefined()

package/features/steps/.test/rpc.test.js

@@ -221,7 +221,7 @@ describe('Given I\'m sending {quantity}B requests to the {token} queue at {quant
 
     await timeout(100 + 12)
 
-    const callsAmountExpected = [10, 11]
+    const callsAmountExpected = [9, 10, 11, 12]
 
     expect(callsAmountExpected).toContain(context.io.request.mock.calls.length)
     expect(context.sending).toBeDefined()

package/features/steps/events.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const stream = require('node:stream')
 const assert = require('node:assert')
 const { randomBytes } = require('node:crypto')
 const { timeout, quantity, match } = require('@toa.io/generic')
@@ -61,6 +62,23 @@ When('an event is emitted to the {token} exchange with properties:',
     await emit.call(this, exchange, message, properties)
   })
 
+When('a stream of {quantity} events is emitted to the {token} exchange',
+  /**
+   * @param {string} exchange
+   * @this {comq.features.Context}
+   */
+  async function (amountQ, exchange) {
+    const amount = quantity(amountQ)
+
+    function * generate () {
+      for (let i = 0; i < amount; i++) yield randomBytes(8)
+    }
+
+    const events = stream.Readable.from(generate())
+
+    await emit.call(this, exchange, events)
+  })
+
 Then('{token} receives the event',
   /**
    * @param {string} group
@@ -93,6 +111,17 @@ Then('the event is received',
     await consumed.call(this)
   })
 
+Then('{quantity} events is received',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function (expectedQ) {
+    const expected = quantity(expectedQ)
+
+    await timeout(100) // let it consume
+    assert.equal(this.eventsConsumedCount, expected, 'Not all events have been consumed')
+  })
+
 Given('I\'m publishing {quantity}B events to the {token} exchange at {quantity}Hz',
   /**
    * @param {string} bytesQ

package/features/steps/rpc.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const stream = require('node:stream')
 const assert = require('node:assert')
 const { randomBytes } = require('node:crypto')
 const { parse } = require('@toa.io/yaml')
@@ -106,6 +107,43 @@ Then('the consumer does not receive the reply',
     assert.equal(reply, undefined, 'The reply was received')
   })
 
+When('the consumer sends {quantity} requests to the {token} queue as a stream',
+  /**
+   * @param {string} queue
+   * @this {comq.features.Context}
+   */
+  async function (amountQ, queue) {
+    const amount = quantity(amountQ)
+
+    function * generate () {
+      for (let i = 0; i < amount; i++) {
+        yield randomBytes(8)
+      }
+    }
+
+    const input = stream.Readable.from(generate())
+
+    await send.call(this, queue, input)
+  })
+
+Then('the consumer receives {quantity} replies as a stream',
+  /**
+   * @this {comq.features.Context}
+   */
+  async function (amountQ) {
+    const expected = quantity(amountQ)
+    const output = await this.reply
+
+    let actual = 0
+
+    // eslint-disable-next-line no-unused-vars
+    for await (const _ of output) {
+      actual++
+    }
+
+    assert.equal(actual, expected, 'The amount of replies mismatches')
+  })
+
 Given('I\'m sending {quantity}B requests to the {token} queue at {quantity}Hz',
   /**
    * @param {string} bytesQ

package/lerna.json

@@ -1,5 +1,5 @@
 {
   "useWorkspaces": true,
-  "version": "0.8.0",
+  "version": "0.9.0",
   "conventionalCommits": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",
@@ -45,7 +45,6 @@
     "msgpackr": "^1.9.5"
   },
   "scripts": {
-    "prepare": "husky install",
     "test": "standard && jest",
     "features": "cucumber-js",
     "lint": "standard --fix --verbose | snazzy"

package/readme.md

@@ -5,18 +5,20 @@ Node.js.
 
 ## Features
 
-1. [Dynamic topology](#topology)
-2. [Request](#request)-[reply](#reply) (RPC)
-3. Events ([pub](#emission)/[sub](#consumption))
-4. [Content encoding](#encoding)
-5. [Flow control](#flow-control) and back pressure handling
-6. [Consumer acknowledgments](#messages) and [publisher confirms](#channels)
-7. [Poison message handling](#messages)
-8. [Connection tolerance](#connection-tolerance) and broker restart resilience
-9. [Sharded connection](#sharded-connection)
-10. [Graceful shutdown](#graceful-shutdown)
-
-> CommonJS, ECMAScript and TypeScript compatible (types included).
+- [Dynamic topology](#topology)
+- [Request](#request)-[reply](#reply) (RPC)
+- Events ([pub](#emission)/[sub](#consumption))
+- [Content encoding](#encoding)
+- [Flow control](#flow-control) and back pressure handling
+- [Pipelines](#pipelines)
+- [Consumer acknowledgments](#messages) and [publisher confirms](#channels)
+- [Poison message handling](#messages)
+- [Connection tolerance](#connection-tolerance) and broker restart resilience
+- [Sharded connection](#sharded-connection)
+- [Singleton connection](#singleton-connection)
+- [Graceful shutdown](#graceful-shutdown)
+
+> CommonJS, ECMAScript, and TypeScript compatible (types included).
 
 ## TL;DR
 
@@ -180,6 +182,34 @@ underlying broker connection is lost, any current and future outgoing messages w
 Corresponding returned promises will remain in a `pending` state until the pressure is removed or
 the connection is restored.
 
+### Pipelines
+
+Payloads for Requests and Events can be passed as a readable stream
+in [object mode](https://nodejs.org/api/stream.html#object-mode), enabling the handling of large amounts of data with
+the benefits of RabbitMQ back pressure and flow control.
+
+`async IO.request(queue: string, payload: Readable, [encoding: string]): Readable`
+
+Returns a readable stream of replies.
+
+`async IO.emit(exchange: string, payload: Readable, [encoding: string]): void`
+
+```javascript
+function * generate () {
+  yield { a: 1, b: 2 };
+  yield { a: 3, b: 4 };
+}
+
+const events = Readable.from(generate())
+
+await io.emit('numbers_added', events)
+
+const requests = Readable.from(generate())
+
+for await (const reply of io.request('add_numbers', requests))
+  console.log(reply)
+```
+
 ## Connection tolerance
 
 When the established connection is lost, it will be automatically restored.
@@ -362,12 +392,16 @@ Subscribe to one of the diagnostic events:
   exceptions. Channel type,
   raw [amqp message object](https://amqp-node.github.io/amqplib/channel_api.html#channel_consume)
   and the exception are passed as arguments.
+- `pause`: channel is paused. Channel type is passed.
+- `resume`: channel is resumed. Channel type is passed.
 
 In the case of a [sharded connection](#sharded-connection), an additional argument specifying the
-shard number will be passed to listeners. The shard number corresponds to the number of the argument
-used in the `connect` function call.
+shard number will be passed to listeners.
+This is applicable except for the `pause` and `resume` events,
+which are emitted when the associated channels are paused or resumed across all shards.
+The shard number corresponds to the position of the argument used in the `connect` function call.
 
-[^3]: As [`connect`](#connect) function returns an instance of `IO` *after* the connection has been
+[^3]: As the [`connect`](#connect) function returns an instance of `IO` *after* the connection has been
 established, there is no way to capture the initial `open` event.
 
 ### Example

package/source/channel.js

@@ -281,6 +281,7 @@ class Channel {
     this.#paused = promex()
     this.#channel.once('drain', this.#unpause)
     this.#diagnostics.emit('flow')
+    this.#diagnostics.emit('pause')
   }
 
   /**
@@ -294,6 +295,7 @@ class Channel {
 
     this.#paused = undefined
     this.#diagnostics.emit('drain')
+    this.#diagnostics.emit('resume')
   }
 
   async #unpaused () {

package/source/events.js

@@ -4,4 +4,4 @@
 exports.connection = ['open', 'close']
 
 /** @type {comq.diagnostics.event[]} */
-exports.channel = ['flow', 'drain', 'recover', 'discard']
+exports.channel = ['flow', 'drain', 'recover', 'discard', 'pause', 'resume']

package/source/io.js

@@ -1,11 +1,13 @@
 'use strict'
 
+const stream = require('node:stream')
 const { EventEmitter } = require('node:events')
 const { randomBytes } = require('node:crypto')
 const { lazy, track, failsafe, promex } = require('@toa.io/generic')
 
 const { decode } = require('./decode')
 const { encode } = require('./encode')
+const { pipeline, transform } = require('./pipeline')
 const events = require('./events')
 const io = require('./.io')
 
@@ -61,12 +63,20 @@ class IO {
     failsafe(this, this.#recover,
       /**
        * @param {string} queue
-       * @param {any} payload
+       * @param {any | Readable} payload
        * @param {comq.encoding} [encoding]
        * @param {comq.ReplyToPropertyFormatter} [replyToFormatter]
-       * @returns {Promise<void>}
+       * @returns {Promise<any | Readable>}
        */
       async (queue, payload, encoding, replyToFormatter) => {
+        if (payload instanceof stream.Readable) {
+          return pipeline(
+            payload,
+            (payload) => this.request(queue, payload, encoding, replyToFormatter),
+            this.#requests
+          )
+        }
+
         const [buffer, contentType] = this.#encode(payload, encoding)
         const emitter = this.#emitters.get(queue)
         const reply = this.#createReply()
@@ -84,7 +94,7 @@ class IO {
 
   consume = lazy(this, this.#createEventChannel,
     async (exchange, group, callback) => {
-      if (callback === undefined) { // 2 arguments passed
+      if (callback === undefined) { // two arguments passed
         callback = group
         group = undefined
       }
@@ -104,6 +114,14 @@ class IO {
      * @returns {Promise<void>}
      */
     async (exchange, payload, encoding) => {
+      if (payload instanceof stream.Readable) {
+        return transform(
+          payload,
+          (payload) => this.emit(exchange, payload, encoding),
+          this.#events
+        )
+      }
+
       /** @type {comq.amqp.options.Publish} */
       const properties = {}
 

package/source/pipeline.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { Transform } = require('node:stream')
+const stream = require('node:stream/promises')
+
+function pipeline (source, transform, channel) {
+  const destination = new Pipeline(transform)
+
+  // eslint-disable-next-line no-void
+  void stream.pipeline(source, destination)
+
+  channel.diagnose('pause', source.pause.bind(source))
+  channel.diagnose('resume', source.resume.bind(source))
+
+  return destination
+}
+
+async function transform (source, transform, channel) {
+  const readable = pipeline(source, transform, channel)
+
+  // eslint-disable-next-line no-void, no-unused-vars
+  for await (const _ of readable) void 0
+}
+
+class Pipeline extends Transform {
+  #transform
+
+  constructor (transform) {
+    super({ objectMode: true })
+
+    this.#transform = transform
+  }
+
+  _transform (request, _, callback) {
+    const promise = this.#transform(request)
+
+    this.push(promise)
+    callback()
+  }
+}
+
+exports.pipeline = pipeline
+exports.transform = transform

package/source/shards/channel.js

@@ -120,7 +120,7 @@ class Channel {
    */
   #add (channel) {
     this.#channels.add(channel)
-    this.#pool = Array.from(this.#channels)
+    this.#update()
   }
 
   /**
@@ -131,10 +131,23 @@ class Channel {
 
     this.#bench.set(channel, promex())
     this.#channels.delete(channel)
-    this.#pool = Array.from(this.#channels)
+    this.#update()
     this.#diagnostics.emit('remove', channel.index)
   }
 
+  #update () {
+    const from = this.#pool?.length
+    const to = this.#channels.size
+
+    this.#pool = Array.from(this.#channels)
+
+    if (from === undefined) return
+
+    if (from !== 0 && to === 0) { this.#diagnostics.emit('pause') }
+
+    if (from === 0 && to !== 0) { this.#diagnostics.emit('resume') }
+  }
+
   /**
    * @param {comq.Channel} channel
    */

package/test/channel.test.js

@@ -823,17 +823,23 @@ describe('diagnostics', () => {
 
     let flowed = false
     let drained = false
+    let paused = false
+    let resumed = false
 
     channel.diagnose('flow', () => (flowed = true))
     channel.diagnose('drain', () => (drained = true))
+    channel.diagnose('pause', () => (paused = true))
+    channel.diagnose('resume', () => (resumed = true))
 
     await channel.publish(exchange, buffer)
 
     expect(flowed).toStrictEqual(true)
+    expect(paused).toStrictEqual(true)
 
     chan.emit('drain')
 
     expect(drained).toStrictEqual(true)
+    expect(resumed).toStrictEqual(true)
   })
 
   it.each(/** @type {[string, boolean][]} */ [

package/test/io.diagnostics.test.js

@@ -28,7 +28,7 @@ describe.each(['request', 'reply', 'event'])('%s channel events',
    * @param {comq.topology.type} type
    */
   (type) => {
-    it.each(['flow', 'drain', 'recover', 'discard'])('should re-emit %s',
+    it.each(['flow', 'drain', 'recover', 'discard', 'pause', 'resume'])('should re-emit %s',
       /**
        * @param {comq.diagnostics.event} event
        */

package/test/io.emit.test.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const stream = require('node:stream')
 const { randomBytes } = require('node:crypto')
 const { generate } = require('randomstring')
 
@@ -18,6 +19,9 @@ let connection
 /** @type {jest.MockedObject<comq.Channel>} */
 let events
 
+const exchange = generate()
+const payload = generate()
+
 beforeEach(async () => {
   jest.clearAllMocks()
 
@@ -33,9 +37,6 @@ it('should be', async () => {
   expect(io.emit).toBeDefined()
 })
 
-const exchange = generate()
-const payload = generate()
-
 it('should create events channel', async () => {
   expect(connection.createChannel).toHaveBeenCalledWith('event')
   expect(events).toBeDefined()
@@ -49,6 +50,20 @@ it('should publish to an exchange', async () => {
   expect(args[0]).toStrictEqual(exchange)
 })
 
+it('should publish stream of events', async () => {
+  jest.clearAllMocks()
+
+  function * generate () {
+    for (let i = 0; i < 10; i++) yield i
+  }
+
+  const input = stream.Readable.from(generate())
+
+  await io.emit(exchange, input)
+
+  expect(events.publish).toHaveBeenCalledTimes(10)
+})
+
 it('should encode message as msgpack by default', async () => {
   const encoding = 'application/msgpack'
   const buf = encode(payload, encoding)

package/test/io.request.test.js

@@ -2,6 +2,7 @@
 
 // region setup
 
+const stream = require('node:stream')
 const { randomBytes } = require('node:crypto')
 const { generate } = require('randomstring')
 const { immediate } = require('@toa.io/generic')
@@ -160,6 +161,33 @@ describe('send', () => {
     expect(properties.contentType).toStrictEqual(encoding)
   })
 
+  it('should send stream of requests', async () => {
+    requests.send.mockClear()
+
+    function * generate () {
+      for (let i = 0; i < 10; i++) yield i
+    }
+
+    const encoding = 'application/json'
+    const replyFormatter = (queue) => queue
+
+    setTimeout(replyAll, 10) // read the stream to end
+
+    const input = stream.Readable.from(generate())
+
+    /** @type {Readable} */
+    const output = await io.request(queue, input, encoding, replyFormatter)
+
+    expect(output).toBeInstanceOf(stream.Readable)
+
+    const replies = []
+
+    for await (const reply of output) replies.push(reply)
+
+    expect(replies.length).toStrictEqual(10)
+    expect(requests.send).toHaveBeenCalledTimes(10)
+  })
+
   it('should resend unanswered Requests', async () => {
     expect(requests.diagnose).toHaveBeenCalledWith('recover', expect.any(Function))
 
@@ -239,6 +267,19 @@ const reply = async (content = randomBytes(8), contentType = undefined) => {
   await callback(message)
 }
 
+async function replyAll () {
+  const callback = replies.consume.mock.calls[0][1]
+
+  for (let i = 0; i < requests.send.mock.calls.length; i++) {
+    const call = requests.send.mock.calls[i]
+    const correlationId = call[2].correlationId
+    const properties = { correlationId }
+    const message = /** @type {comq.amqp.Message} */ { content: randomBytes(8), properties }
+
+    await callback(message)
+  }
+}
+
 /**
  * @param {comq.topology.type} type
  * @returns {jest.MockedObject<comq.Channel>}

package/test/pipeline.test.js

@@ -0,0 +1,81 @@
+'use strict'
+
+const { EventEmitter } = require('node:events')
+const stream = require('node:stream')
+const { pipeline, transform } = require('../source/pipeline')
+const { timeout } = require('@toa.io/generic')
+
+/** @type {Channel} */
+let channel
+
+beforeEach(() => {
+  channel = new Channel()
+})
+
+it('should pipeline', async () => {
+  const input = stream.Readable.from([1, 2, 3])
+  const pipe = pipeline(input, (x) => x * x, channel)
+  const output = []
+
+  for await (const x of pipe) {
+    output.push(x)
+  }
+
+  expect(output).toStrictEqual([1, 4, 9])
+})
+
+it('should control source', async () => {
+  async function * generate () {
+    for (let i = 1; i < 4; i++) {
+      await timeout(1)
+
+      yield i
+    }
+  }
+
+  const input = stream.Readable.from(generate())
+
+  // eslint-disable-next-line no-void
+  void pipeline(input, (x) => x * x, channel)
+
+  channel.emit('pause')
+
+  await timeout(0)
+
+  expect(input.isPaused()).toBe(true)
+
+  channel.emit('resume')
+
+  await timeout(0)
+
+  expect(input.isPaused()).toBe(false)
+})
+
+it('should wait for end', async () => {
+  async function * generate () {
+    for (let i = 1; i < 4; i++) {
+      await timeout(1)
+
+      yield i
+    }
+  }
+
+  let finished = 0
+
+  const fn = jest.fn(async () => {
+    await timeout(1)
+    finished++
+  })
+  const input = stream.Readable.from(generate())
+
+  await transform(input, fn, channel)
+
+  expect(fn).toHaveBeenCalledTimes(3)
+  expect(finished).toBe(3)
+})
+
+class Channel extends EventEmitter {
+  diagnose (event, callback) {
+    this.on(event, callback)
+  }
+}

package/test/shards/channel.test.js

@@ -187,7 +187,7 @@ describe.each(/** @type {string[]} */['send', 'publish', 'fire'])('%s', (method)
 
     const last = label + i
 
-    // now channel has thrown an exception
+    // now the channel has thrown an exception
     expect(broken[method]).toHaveBeenCalledWith(last, buffer, options)
 
     const r = (b + 1) % 2
@@ -202,7 +202,7 @@ describe.each(/** @type {string[]} */['send', 'publish', 'fire'])('%s', (method)
     /** @type {jest.MockedObject<comq.Channel>} */
     let recovered
 
-    // both shards rejects and will be removed from the pool
+    // both shards reject and will be removed from the pool
     channels[0][method].mockImplementationOnce(reject)
     channels[1][method].mockImplementationOnce(reject)
 
@@ -338,6 +338,42 @@ describe('diagnose', () => {
 
     expect(listener).toHaveBeenCalledWith(expect.any(Number))
   })
+
+  it('should emit `pause` and `unpause` events', async () => {
+    const queue = generate()
+    const buffer = randomBytes(8)
+    const pause = /** @type {jest.MockedFunction} */ jest.fn()
+    const resume = /** @type {jest.MockedFunction} */ jest.fn()
+
+    channel.diagnose('pause', pause)
+    channel.diagnose('resume', resume)
+
+    for (const chan of channels) {
+      chan.send.mockImplementationOnce(() => {
+        expect(pause).not.toHaveBeenCalled()
+        throw new Error()
+      })
+    }
+
+    // recover
+    setImmediate(() => {
+      for (const chan of channels) {
+        // subscriptions to the 'recover' event
+        const calls = chan.diagnose.mock.calls.filter(
+          (call) => call[0] === 'recover')
+
+        expect(calls.length).toBeGreaterThan(0)
+
+        // emit 'recover' event to return shard to the pool
+        for (const call of calls) call[1]()
+      }
+    })
+
+    await channel.send(queue, buffer)
+
+    expect(pause).toHaveBeenCalledTimes(1)
+    expect(resume).toHaveBeenCalledTimes(1)
+  })
 })
 
 it('should not throw on recovery (if the "bench" is empty)', async () => {

package/types/diagnostic.d.ts

@@ -1,6 +1,6 @@
 declare namespace comq.diagnostics {
 
-  type event = 'open' | 'close' | 'flow' | 'drain' | 'remove' | 'recover' | 'discard'
+  type event = 'open' | 'close' | 'flow' | 'drain' | 'remove' | 'recover' | 'discard' | 'pause' | 'resume'
 
   interface Diagnosable {
     diagnose(event: event, listener: Function): void

package/types/io.d.ts

@@ -1,3 +1,4 @@
+import type { Readable } from 'node:stream'
 import * as _diagnostics from './diagnostic'
 import * as _encoding from './encoding'
 import * as _topology from './topology'
@@ -30,6 +31,13 @@ declare namespace comq {
       replyToFormatter?: ReplyToPropertyFormatter)
       : Promise<any>
 
+    request(
+      queue: string,
+      stream: Readable,
+      encoding?: _encoding.encoding,
+      replyToFormatter?: ReplyToPropertyFormatter)
+      : Promise<Readable>
+
     consume(exchange: string, group: string, consumer: consumer): Promise<void>
 
     consume(exchange: string, consumer: consumer): Promise<void>
@@ -38,23 +46,27 @@ declare namespace comq {
 
     emit(exchange: string, payload: any, properties?: _amqp.Properties): Promise<void>
 
+    emit(exchange: string, stream: Readable, encoding?: _encoding.encoding): Promise<void>
+
+    emit(exchange: string, stream: Readable, properties?: _amqp.Properties): Promise<void>
+
     seal(): Promise<void>
 
     close(): Promise<void>
 
-    diagnose(event: 'open', listener: (index?: number) => void)
+    diagnose(event: 'open', listener: (index?: number) => void): void
 
-    diagnose(event: 'close', listener: (index?: number) => void)
+    diagnose(event: 'close', listener: (index?: number) => void): void
 
-    diagnose(event: 'flow', listener: (channel: _topology.type, index?: number) => void)
+    diagnose(event: 'flow', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'drain', listener: (channel: _topology.type, index?: number) => void)
+    diagnose(event: 'drain', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'remove', listener: (index?: number) => void)
+    diagnose(event: 'remove', listener: (index?: number) => void): void
 
-    diagnose(event: 'recover', listener: (channel: _topology.type, index?: number) => void)
+    diagnose(event: 'recover', listener: (channel: _topology.type, index?: number) => void): void
 
-    diagnose(event: 'discard', listener: (channel: _topology.type, message: any, index?: number) => void)
+    diagnose(event: 'discard', listener: (channel: _topology.type, message: any, index?: number) => void): void
   }
 }