comq 0.15.3 → 0.15.4

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.15.4](https://github.com/toa-io/comq/compare/v0.15.3...v0.15.4) (2026-08-16)
+
+
+### Bug Fixes
+
+* remove request() timeout ([#246](https://github.com/toa-io/comq/issues/246)) ([d432388](https://github.com/toa-io/comq/commit/d4323889bcad867a870d0ed351b92098f6aad551))
+
 ## [0.15.3](https://github.com/toa-io/comq/compare/v0.15.2...v0.15.3) (2026-08-04)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "comq",
-  "version": "0.15.3",
+  "version": "0.15.4",
   "description": "ComQ",
   "author": {
     "name": "Artem Gurtovoi",

package/readme.md

@@ -103,11 +103,10 @@ await io.reply('add_numbers', ({ a, b }) => (a + b))
 
 ## Request
 
-`async IO.request(queue: string, payload: any, encoding?: string, timeout?: number): any`
+`async IO.request(queue: string, payload: any, encoding?: string): any`
 
 Send encoded Request message with `replyTo` and `correlationId` properties set and
-return decoded Reply content. Optional `timeout` (ms) rejects with `ETIMEDOUT` if no
-Reply arrives in time; encoding may be omitted when only `timeout` is passed.
+return decoded Reply content. The promise stays pending until the Reply arrives.
 
 On the initial call, queues for Requests and Replies are asserted.
 
@@ -115,7 +114,6 @@ On the initial call, queues for Requests and Replies are asserted.
 
 ```javascript
 const sum = await io.request('add_numbers', { a: 1, b: 2 })
-const sumOrTimeout = await io.request('add_numbers', { a: 1, b: 2 }, 5000)
 ```
 
 ## Consumption
@@ -332,8 +330,7 @@ Outgoing messages are sent to a single connection chosen at random from the shar
 underlying connection or experience channel [back pressure](#flow-control) on a corresponding channel are removed from
 the pool until the issue is resolved. Pending messages meeting these conditions are immediately routed among the
 remaining shards in the pool. If no shards are available, `send` / `publish` / `request` wait until a shard's
-connection is re-established (unbounded). For RPC, pass a [`request` timeout](#request) so callers fail with
-`ETIMEDOUT` instead of hanging while the pool is empty or a Reply never arrives.
+connection is re-established.
 
 Incoming messages are consumed from all shards.
 

package/source/io.js

@@ -3,7 +3,7 @@
 const stream = require('node:stream')
 const { EventEmitter } = require('node:events')
 const { randomBytes } = require('node:crypto')
-const { setTimeout: delay } = require('node:timers/promises')
+const { setTimeout } = require('node:timers/promises')
 const { Promex } = require('promex')
 const { memo, failsafe, lazy, track } = require('./attributes')
 
@@ -75,45 +75,24 @@ class IO {
       /**
        * @param {string} queue
        * @param {any | Readable} payload
-       * @param {comq.Encoding | number} [encoding]
-       * @param {number} [timeout]
+       * @param {comq.Encoding} [encoding]
        * @returns {Promise<any | Readable>}
        */
-      async (queue, payload, encoding, timeout) => {
-        if (typeof encoding === 'number') {
-          timeout = encoding
-          encoding = undefined
-        }
-
+      async (queue, payload, encoding) => {
         if (payload instanceof stream.Readable) {
           return pipeline(
             payload,
-            (payload) => this.request(queue, payload, encoding, timeout),
+            (payload) => this.request(queue, payload, encoding),
             this.#requests
           )
         }
 
-        const request = this.#createRequest(queue, payload, /** @type {comq.Encoding} */ encoding)
+        const request = this.#createRequest(queue, payload, encoding)
         const reply = this.#createReply(request)
 
-        const done = this.#requests.send(queue, request.buffer, request.properties)
-          .then(() => reply)
-
-        if (typeof timeout !== 'number') return done
+        await this.#requests.send(queue, request.buffer, request.properties)
 
-        try {
-          return await Promise.race([
-            done,
-            delay(timeout).then(() => Promise.reject(timeoutError(timeout)))
-          ])
-        } catch (exception) {
-          if (exception.code === 'ETIMEDOUT') {
-            request.emitter.removeAllListeners(request.properties.correlationId)
-            reply.reject(exception)
-          }
-
-          throw exception
-        }
+        return reply
       }))
 
   consume = lazy(this, this.#createEventChannel,
@@ -428,7 +407,7 @@ class IO {
     Even if these messages are lost, the reply stream will be closed anyway,
     either due to missing heartbeat or the deletion of the stream queue.
     */
-    await delay(50)
+    await setTimeout(50)
   }
 
   /**
@@ -495,19 +474,6 @@ const DEFAULT = 'application/json'
 
 const RETRANSMISSION = /** @type {Error} */ Symbol('retransmission')
 
-/**
- * @param {number} timeout
- * @returns {Error}
- */
-function timeoutError (timeout) {
-  const error = /** @type {Error & { code: string }} */ new Error(
-    `Request timed out after ${timeout}ms`)
-
-  error.code = 'ETIMEDOUT'
-
-  return error
-}
-
 function noop () {}
 
 exports.IO = IO

package/types/io.d.ts

@@ -27,11 +27,9 @@ declare namespace comq {
   interface IO extends _diagnostics.Diagnosable {
     reply(queue: string, produce: Producer): Promise<void>
 
-    request<Reply = any, Request = any>(queue: string, payload: Request, encoding?: _encoding.Encoding, timeout?: number): Promise<Reply> | Promise<Readable>
+    request<Reply = any, Request = any>(queue: string, payload: Request, encoding?: _encoding.Encoding): Promise<Reply> | Promise<Readable>
 
-    request<Reply = any, Request = any>(queue: string, payload: Request, timeout: number): Promise<Reply> | Promise<Readable>
-
-    request(queue: string, stream: Readable, encoding?: _encoding.Encoding, timeout?: number): Promise<Readable>
+    request(queue: string, stream: Readable, encoding?: _encoding.Encoding): Promise<Readable>
 
     consume<T = any>(exchange: string, group: string, consumer: Consumer<T>): Promise<void>
 

package/test/io.request.timeout.test.js

@@ -1,61 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const mock = require('./connection.mock')
-const { IO } = require('../source/io')
-
-/** @type {comq.IO} */
-let io
-
-/** @type {jest.MockedObject<comq.Connection>} */
-let connection
-
-const queue = generate()
-const payload = { [generate()]: generate() }
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  connection = mock.connection()
-  io = new IO(connection)
-})
-
-it('should reject when request times out', async () => {
-  await expect(io.request(queue, payload, 50)).rejects.toMatchObject({
-    message: expect.stringContaining('timed out'),
-    code: 'ETIMEDOUT'
-  })
-})
-
-it('should reject when request times out with encoding', async () => {
-  await expect(io.request(queue, payload, 'application/json', 50)).rejects.toMatchObject({
-    code: 'ETIMEDOUT'
-  })
-})
-
-it('should time out while send is still pending', async () => {
-  connection.createChannel.mockImplementation(async () => hangingChannel())
-
-  await expect(io.request(queue, payload, 50)).rejects.toMatchObject({
-    code: 'ETIMEDOUT'
-  })
-})
-
-/**
- * @returns {jest.MockedObject<comq.Channel>}
- */
-function hangingChannel () {
-  return /** @type {jest.MockedObject<comq.Channel>} */ ({
-    sharded: false,
-    consume: jest.fn(async () => undefined),
-    send: jest.fn(() => new Promise(() => {})),
-    deliver: jest.fn(async () => undefined),
-    fire: jest.fn(async () => undefined),
-    subscribe: jest.fn(async () => undefined),
-    publish: jest.fn(async () => undefined),
-    diagnose: jest.fn(),
-    seal: jest.fn(async () => undefined),
-    recover: jest.fn(async () => undefined)
-  })
-}