comq 0.25.0 → 0.25.1

package/package.json

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

package/source/channel.js

@@ -49,6 +49,9 @@ class Channel {
   /** @type {Set<Promex>} */
   #confirmations = new Set()
 
+  /** @type {Set<Promise<void>>} failed messages on their way to a retry or the parking queue */
+  #settling = new Set()
+
   #diagnostics = emitter.create()
 
   #closed = false
@@ -221,6 +224,10 @@ class Channel {
 
     await this.seal()
 
+    // a failed message is moved in two steps, its copy placed and then the original
+    // released; a channel closed between them leaves the broker holding both
+    await Promise.allSettled(this.#settling)
+
     // a channel that went down with its connection is the outcome this asks for
     await this.#channel?.close().catch(noop)
 
@@ -587,7 +594,13 @@ class Channel {
       } catch (exception) {
         if (exception?.message === 'Channel closed') { return } // the message is requeued by the broker
 
-        await this.#failed(queue, message, exception)
+        const settling = this.#failed(queue, message, exception)
+
+        this.#settling.add(settling)
+
+        await settling
+
+        this.#settling.delete(settling)
       }
     }
 

package/test/channel.test.js

@@ -1251,6 +1251,31 @@ describe('failed messages', () => {
       expect(chan.ack).toHaveBeenCalled()
     })
 
+    it('should release the original before the channel is given back', async () => {
+      await channel.consume(queue, consumer)
+
+      let confirm
+
+      chan.publish.mockImplementationOnce((_0, _1, _2, _3, callback) => (confirm = callback))
+
+      const delivering = deliver(delivery())
+
+      // closed while the copy is on its way: an original still unacknowledged then is
+      // requeued by the broker, and the message is held twice
+      const closing = channel.close()
+
+      await new Promise((resolve) => setImmediate(resolve))
+
+      confirm(null)
+
+      await closing
+      await delivering
+
+      expect(chan.ack).toHaveBeenCalledTimes(1)
+      expect(chan.ack.mock.invocationCallOrder[0])
+        .toBeLessThan(chan.close.mock.invocationCallOrder[0])
+    })
+
     it('should increment the attempt', async () => {
       await channel.consume(queue, consumer)