comq 0.22.0 → 0.24.0

package/test/io.request.test.js

@@ -41,7 +41,7 @@ let replies
 
 let promise
 
-const REPLY = new RegExp(`^${queue}..[0-9a-f]+$`)
+const REPLY = /^comq\.reply\.\.[0-9a-f]+$/
 
 beforeEach(async () => {
   promise = io.request(queue, payload)
@@ -62,6 +62,17 @@ it('should consume replies queue', async () => {
   expect(replies.consume).toHaveBeenCalledWith(expect.stringMatching(REPLY), expect.any(Function))
 })
 
+it('should consume one replies queue however many queues are requested', async () => {
+  // a reply is found by its correlation identifier, so a queue per target would
+  // name what the identifier already tells apart
+  io.request(generate(), payload)
+  io.request(generate(), payload)
+
+  await immediate()
+
+  expect(replies.consume).toHaveBeenCalledTimes(1)
+})
+
 describe('send', () => {
   let call
 
@@ -84,9 +95,8 @@ describe('send', () => {
 
   it('should set replyTo', async () => {
     const properties = call[2]
-    const rx = new RegExp(`^${queue}..[a-z0-9]+`)
 
-    expect(properties.replyTo).toMatch(rx)
+    expect(properties.replyTo).toMatch(REPLY)
   })
 
   it('should consume replyTo', async () => {
@@ -105,6 +115,19 @@ describe('send', () => {
     expect(call[2]).toMatchObject({ contentType })
   })
 
+  it('should not expire', async () => {
+    expect(call[2].expiration).toBeUndefined()
+  })
+
+  it('should refuse options other than the encoding', async () => {
+    requests.send.mockClear()
+
+    await expect(io.request(queue, payload, { timeout: 1000 })).rejects.toBeInstanceOf(TypeError)
+    await expect(io.request(queue, payload, { signal: new AbortController().signal })).rejects.toBeInstanceOf(TypeError)
+
+    expect(requests.send).not.toHaveBeenCalled()
+  })
+
   it('should throw if encoding is not supported', async () => {
     const encoding = /** @type {comq.Encoding} */ 'wtf/' + generate()
 

package/test/memory.test.js

@@ -12,7 +12,7 @@ const { timeout } = require('./helpers')
 const mock = require('./amqplib.mock')
 const { amqplib, connect } = mock
 
-jest.mock('amqplib', () => mock.amqplib)
+jest.mock('@toa.io/amqplib', () => mock.amqplib)
 
 const { connect: open, assert } = require('../source')
 const { SingletonConnection } = require('../source/singleton')

package/types/amqp.d.ts

@@ -1,4 +1,4 @@
-import * as amqplib from 'amqplib'
+import * as amqplib from '@toa.io/amqplib'
 
 declare namespace comq.amqp {
 

package/types/channel.d.ts

@@ -1,4 +1,4 @@
-import { Message, Options, Connection } from 'amqplib'
+import { Message, Options, Connection } from '@toa.io/amqplib'
 import * as _diagnostics from './diagnostic'
 
 declare namespace comq {

package/types/index.d.ts

@@ -38,9 +38,3 @@ export class Unroutable extends Error {
 export class Interrupted extends Error {
   readonly reason: string
 }
-
-/**
- * A Reply nobody is waiting for any more, or a Request made once the waiting has stopped.
- * See `IO.abandon`.
- */
-export class Abandoned extends Error {}

package/types/io.d.ts

@@ -37,19 +37,19 @@ declare namespace comq {
     signal?: AbortSignal
   }
 
-  /** How long a caller waits for a Reply. */
-  interface RequestOptions {
+  /** How long a caller waits for the Reply to a call. */
+  interface CallOptions {
     encoding?: _encoding.Encoding
 
     /**
-     * Milliseconds to wait for the Reply. A Request nobody has taken by then is dropped by the
+     * Milliseconds to wait for the Reply. A call nobody has taken by then is dropped by the
      * broker; one already taken may still be processed, and its Reply is discarded.
      */
     timeout?: number
 
     /**
-     * Ends the wait when aborted, within the timeout. The Request stays in its queue until the
-     * timeout passes, or, without one, until a Producer takes it.
+     * Ends the wait when aborted, within the timeout. The call stays in its queue until the
+     * timeout passes, or, without one, until its holder takes it.
      */
     signal?: AbortSignal
   }
@@ -64,15 +64,16 @@ declare namespace comq {
   interface IO extends _diagnostics.Diagnosable {
     reply(queue: string, produce: Producer): Promise<void>
 
-    request<Reply = any, Request = any>(queue: string, payload: Request, options?: _encoding.Encoding | RequestOptions): Promise<Reply> | Promise<Readable>
+    /** Waits for the Reply for as long as it takes. */
+    request<Reply = any, Request = any>(queue: string, payload: Request, encoding?: _encoding.Encoding): Promise<Reply> | Promise<Readable>
 
-    request(queue: string, stream: Readable, options?: _encoding.Encoding | RequestOptions): Promise<Readable>
+    request(queue: string, stream: Readable, encoding?: _encoding.Encoding): Promise<Readable>
 
     /**
      * Sends a Request to whoever holds `key` on the routed `exchange`, through `back`. One that
      * nobody holds is refused with `Unroutable`.
      */
-    call<Reply = any, Request = any>(exchange: string, key: string, payload: Request, options?: _encoding.Encoding | RequestOptions): Promise<Reply> | Promise<Readable>
+    call<Reply = any, Request = any>(exchange: string, key: string, payload: Request, options?: _encoding.Encoding | CallOptions): Promise<Reply> | Promise<Readable>
 
     /**
      * Answers the Requests `call` sends under `key`, from a queue this connection alone holds.
@@ -119,12 +120,6 @@ declare namespace comq {
 
     seal(): Promise<void>
 
-    /**
-     * Stops waiting for Replies: every one still outstanding is rejected with `Abandoned`, and a
-     * Request made from now on is refused with it. Callable while a close is already under way.
-     */
-    abandon(): Promise<void>
-
     close(): Promise<void>
 
     diagnose(event: 'open', listener: (index?: number) => void): void

package/features/closing.feature

@@ -1,32 +0,0 @@
-Feature: Abandoning the Replies a close is waiting for
-
-  A consumer callback may call out while it runs, and a close waits for every callback to return.
-  Where the answer that callback waits for is the one thing going away with the close, the two
-  wait for each other. Abandoning ends that wait.
-
-  Background:
-    Given an active connection to the broker
-
-  Scenario: Abandoning lets a close finish
-    Given a producer replying `upstream` queue by requesting the `downstream` queue
-    When the consumer sends a request to the `upstream` queue
-    And the producer is handling the request
-    And the connection abandons its replies
-    Then the connection closes within 1000ms
-    And the producer was told its reply is abandoned
-    And the consumer was told its own reply is abandoned
-
-  Scenario: A close already under way is told to stop waiting
-    Given a producer replying `upstream` queue by requesting the `downstream` queue
-    When the consumer sends a request to the `upstream` queue
-    And the producer is handling the request
-    And the connection has started closing
-    And the connection abandons its replies
-    Then the connection closes within 1000ms
-
-  Scenario: A Request made once the Replies are abandoned is refused
-    Given a producer replying `upstream` queue by requesting the `downstream` queue
-    When the consumer sends a request to the `upstream` queue
-    And the producer is handling the request
-    And the connection abandons its replies
-    Then a request to the `downstream` queue is refused as abandoned

package/features/rpc.timeout.feature

@@ -1,19 +0,0 @@
-Feature: Request timeout
-
-  A caller may say how long it waits for a reply. A request nobody took by then is dropped by the
-  broker; one already taken is still processed, and its reply is discarded.
-
-  Background:
-    Given an active connection to the broker
-
-  Scenario: A caller stops waiting at its timeout
-    Given a producer replying `slow` queue in 1000ms
-    When the consumer sends a request to the `slow` queue with a 200ms timeout
-    Then the consumer stops waiting
-
-  Scenario: A request nobody took in time is never processed
-    When the consumer sends a request to the `later` queue with a 200ms timeout
-    Then the consumer stops waiting
-    When after 300ms
-    And a producer counting requests to the `later` queue
-    Then the producer receives nothing

package/features/steps/closing.js

@@ -1,109 +0,0 @@
-'use strict'
-
-const assert = require('node:assert')
-const { Given, When, Then } = require('@cucumber/cucumber')
-const { Abandoned } = require('../../')
-const { timeout } = require('../../test/helpers')
-
-Given('a producer replying {token} queue by requesting the {token} queue',
-  /**
-   * @param {string} queue
-   * @param {string} downstream
-   * @this {comq.features.Context}
-   */
-  async function (queue, downstream) {
-    this.handling = new Promise((resolve) => { this.handled = resolve })
-
-    const producer = async (request) => {
-      const reply = this.io.request(downstream, request)
-
-      this.handled()
-
-      try {
-        return await reply
-      } catch (error) {
-        // recorded rather than rethrown: what this asserts is what the caller was told,
-        // and a rejected producer would have the delivery retried on top of it
-        this.abandoned = error
-
-        return null
-      }
-    }
-
-    await this.io.reply(queue, producer)
-  })
-
-When('the producer is handling the request',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    await this.handling
-
-    // the consumer's own Request is outstanding as well, and abandoning abandons that one too;
-    // its outcome is taken here so that it is asserted rather than left to surface as an
-    // unhandled rejection
-    this.reply.catch((error) => { this.refused = error })
-  })
-
-When('the connection has started closing',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    this.closing = this.io.close()
-  })
-
-When('the connection abandons its replies',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    await this.io.abandon()
-  })
-
-Then('the connection closes within {number}ms',
-  /**
-   * @param {number} ms
-   * @this {comq.features.Context}
-   */
-  async function (ms) {
-    const io = this.io
-
-    // taken off the world so that the hook on the way out does not await a close
-    // this may have just proven does not end
-    this.io = undefined
-    this.connected = false
-
-    const closing = io.close().then(() => true, () => true)
-    const closed = await Promise.race([closing, timeout(ms).then(() => false)])
-
-    assert.ok(closed, `The connection did not close within ${ms}ms`)
-  })
-
-Then('the producer was told its reply is abandoned',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    assert.ok(this.abandoned instanceof Abandoned,
-      `The producer was told ${this.abandoned ?? 'nothing'}`)
-  })
-
-Then('the consumer was told its own reply is abandoned',
-  /**
-   * @this {comq.features.Context}
-   */
-  async function () {
-    assert.ok(this.refused instanceof Abandoned,
-      `The consumer was told ${this.refused ?? 'nothing'}`)
-  })
-
-Then('a request to the {token} queue is refused as abandoned',
-  /**
-   * @param {string} queue
-   * @this {comq.features.Context}
-   */
-  async function (queue) {
-    await assert.rejects(() => this.io.request(queue, null), Abandoned)
-  })

package/source/abandoned.js

@@ -1,15 +0,0 @@
-'use strict'
-
-/**
- * A Reply nobody is waiting for any more, or a Request made once the waiting has stopped. The
- * Request itself was sent and may well be processed; what was given up is the answer.
- */
-class Abandoned extends Error {
-  constructor () {
-    super('The connection no longer waits for a Reply')
-
-    this.name = 'Abandoned'
-  }
-}
-
-exports.Abandoned = Abandoned

package/source/batch.js

@@ -1,62 +0,0 @@
-'use strict'
-
-/**
- * Writes as one what a connection sends in one turn of the event loop.
- *
- * amqplib hands its frames to the socket one write at a time, and a request served is two of
- * them: the reply, and the acknowledgement of the request it answers. With Nagle's algorithm off,
- * which is what a socket sending without delay runs under, each is a syscall and a packet of its
- * own. Corked, they are held in the socket's buffer and leave together, in one `writev`, at the
- * end of the same turn: nothing waits for a timer, and nothing waits for a write that may never
- * come.
- *
- * This belongs in amqplib, whose `Mux` writes the frames one at a time, and where corking that
- * loop is six lines and needs no wrapping of a socket the library does not own. It is done here
- * until amqplib carries it, and goes when it does.
- *
- * @param {import('node:net').Socket} socket
- */
-function batch (socket) {
-  // whatever a connection is carried over is left as it is unless it is a stream that corks
-  if (!corkable(socket) || socket[BATCHED] === true) return
-
-  socket[BATCHED] = true
-
-  const write = socket.write.bind(socket)
-
-  const flush = () => {
-    socket[CORKED] = false
-    socket.uncork()
-  }
-
-  const cork = () => {
-    if (socket[CORKED] === true) return
-
-    socket[CORKED] = true
-    socket.cork()
-
-    process.nextTick(flush)
-  }
-
-  socket.write = (...args) => {
-    cork()
-
-    return write(...args)
-  }
-}
-
-/**
- * @param {any} socket
- * @returns {boolean}
- */
-function corkable (socket) {
-  return socket !== null && socket !== undefined &&
-    typeof socket.write === 'function' &&
-    typeof socket.cork === 'function' &&
-    typeof socket.uncork === 'function'
-}
-
-const BATCHED = Symbol('comq.batched')
-const CORKED = Symbol('comq.corked')
-
-exports.batch = batch

package/test/batch.test.js

@@ -1,94 +0,0 @@
-'use strict'
-
-const { Writable } = require('node:stream')
-
-const { batch } = require('../source/batch')
-
-/** A socket, as far as writing to it goes: what it was given, and how many times. */
-function socket () {
-  const writes = []
-
-  return Object.assign(new Writable({
-    write (chunk, _encoding, callback) {
-      writes.push([chunk.toString()])
-      callback()
-    },
-    writev (chunks, callback) {
-      writes.push(chunks.map(({ chunk }) => chunk.toString()))
-      callback()
-    }
-  }), { writes })
-}
-
-const tick = () => new Promise((resolve) => process.nextTick(resolve))
-
-it('should be', async () => {
-  expect(batch).toBeDefined()
-})
-
-it('should write what a turn wrote as one', async () => {
-  const stream = socket()
-
-  batch(stream)
-
-  stream.write('a')
-  stream.write('b')
-
-  await tick()
-
-  expect(stream.writes).toStrictEqual([['a', 'b']])
-})
-
-it('should write what a later turn wrote on its own', async () => {
-  const stream = socket()
-
-  batch(stream)
-
-  stream.write('a')
-
-  await tick()
-
-  stream.write('b')
-
-  await tick()
-
-  expect(stream.writes).toStrictEqual([['a'], ['b']])
-})
-
-it('should not hold a write past its turn', async () => {
-  const stream = socket()
-
-  batch(stream)
-
-  stream.write('a')
-
-  await tick()
-
-  expect(stream.writes).toStrictEqual([['a']])
-})
-
-it('should take a socket once', async () => {
-  const stream = socket()
-
-  batch(stream)
-
-  const wrapped = stream.write
-
-  batch(stream)
-
-  expect(stream.write).toStrictEqual(wrapped)
-})
-
-it('should leave alone what does not cork', async () => {
-  for (const value of [undefined, null, {}, { write: () => undefined }]) {
-    expect(() => batch(value)).not.toThrow()
-  }
-
-  const written = []
-  const plain = { write: (chunk) => written.push(chunk) }
-
-  batch(plain)
-  plain.write('a')
-
-  expect(written).toStrictEqual(['a'])
-})