amqplib 1.0.2 → 1.0.4

package/.github/workflows/publish.yml

@@ -9,7 +9,7 @@ jobs:
     runs-on: ubuntu-latest
     services:
       rabbitmq:
-        image: rabbitmq:3-alpine
+        image: rabbitmq:4.2-alpine
         ports:
           - 5672:5672
 

package/.github/workflows/test.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     services:
       rabbitmq:
-        image: rabbitmq:3.12-alpine
+        image: rabbitmq:4.2-alpine
         ports:
           - 5672:5672
 

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Change log for amqplib
 
+## v1.0.4
+- Updated build to use RabbitMQ 4.2
+- Fix memory leak in ConfirmChannel.publish when channel is already closed (fixes #842)
+- Close connection immediately when close() is called while the connection is blocked (fixes #744)
+
+## v1.0.3
+- Fix AssertionError crash when backpressure occurs while draining newStreams in Mux (fixes #841)
+
 ## v1.0.2
 - Replace url-parse with WHATWG URL API
 

package/Makefile

@@ -13,16 +13,16 @@ error:
 	@exit 1
 
 test:
-	node --test
+	node --test --test-reporter=spec
 
 test-all-nodejs:
 	for v in $(NODEJS_VERSIONS); \
 		do echo "-- Node version $$v --"; \
-		nave use $$v node --test; \
+		nave use $$v node --test --test-reporter=spec; \
 		done
 
 coverage:
-	node --test --test-coverage
+	node --test --test-coverage --test-reporter=spec
 
 lib/defs.js: clean bin/generate-defs test
 

package/lib/callback_model.js

@@ -246,8 +246,9 @@ function callbackWrapper(_ch, cb) {
 
 class ConfirmChannel extends Channel {
   publish(exchange, routingKey, content, options, cb) {
+    const result = Channel.prototype.publish.call(this, exchange, routingKey, content, options);
     this.pushConfirmCallback(cb);
-    return Channel.prototype.publish.call(this, exchange, routingKey, content, options);
+    return result;
   }
 
   sendToQueue(queue, content, options, cb) {

package/lib/channel_model.js

@@ -224,8 +224,9 @@ Channel.prototype.prefetch = Channel.prototype.qos;
 
 class ConfirmChannel extends Channel {
   publish(exchange, routingKey, content, options, cb) {
+    const result = super.publish(exchange, routingKey, content, options);
     this.pushConfirmCallback(cb);
-    return super.publish(exchange, routingKey, content, options);
+    return result;
   }
 
   sendToQueue(queue, content, options, cb) {

package/lib/connection.js

@@ -41,6 +41,7 @@ class Connection extends EventEmitter {
     this.recvSinceLastCheck = false;
 
     this.expectSocketClose = false;
+    this.blocked = false;
     this.freeChannels = new BitSet();
     this.channels = [
       {
@@ -301,6 +302,13 @@ class Connection extends EventEmitter {
   toClosing(capturedStack, k) {
     const send = this.sendMethod.bind(this);
 
+    if (this.blocked) {
+      if (k) k();
+      const s = stackCapture('Connection blocked: closing immediately');
+      this.toClosed(s, undefined);
+      return;
+    }
+
     this.accept = function (f) {
       if (f.id === defs.ConnectionCloseOk) {
         if (k) k();
@@ -581,8 +589,10 @@ function channel0(connection) {
       }
       connection.toClosed(s, e);
     } else if (f.id === defs.ConnectionBlocked) {
+      connection.blocked = true;
       connection.emit('blocked', f.fields.reason);
     } else if (f.id === defs.ConnectionUnblocked) {
+      connection.blocked = false;
       connection.emit('unblocked');
     } else if (f.id === defs.ConnectionUpdateSecretOk) {
       connection.emit('update-secret-ok');

package/lib/mux.js

@@ -40,14 +40,13 @@ class Mux {
     // Try to read a chunk from each stream in turn, until all streams
     // are empty, or we exhaust our ability to accept chunks.
     function roundrobin(streams) {
-      let stream = streams.shift();
-      while (accepting && stream) {
+      while (accepting && streams.length > 0) {
+        const stream = streams.shift();
         const chunk = stream.read();
         if (chunk !== null) {
           accepting = out.write(chunk);
           streams.push(stream);
         }
-        stream = streams.shift();
       }
     }
 

package/package.json

@@ -2,7 +2,7 @@
   "name": "amqplib",
   "homepage": "http://amqp-node.github.io/amqplib/",
   "main": "./channel_api.js",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "An AMQP 0-9-1 (e.g., RabbitMQ) library and client.",
   "repository": {
     "type": "git",
@@ -21,8 +21,10 @@
     "uglify-js": "2.8.x"
   },
   "scripts": {
-    "test": "make test",
-    "test:only": "node --test --test-only",
+    "test": "node --test --test-timeout=1000",
+    "test:only": "node --test --test-only --test-timeout=1000",
+    "rabbitmq-3": "docker run -d --rm --name rabbitmq -p 5672:5672 rabbitmq:3.12-alpine",
+    "rabbitmq-4": "docker run -d --rm --name rabbitmq -p 5672:5672 rabbitmq:4.2-alpine",
     "format": "biome format . --write",
     "lint": "biome lint --max-diagnostics=1000 ."
   },

package/test/callback_api.test.js

@@ -305,6 +305,17 @@ describe('Callback API', () => {
         done();
       });
     });
+
+    confirm_channel_test('publish on closed channel does not leak callbacks', (_ch, done) => {
+      ch = _ch;
+      ch.close(() => {
+        for (let i = 0; i < 10; i++) {
+          try { ch.publish('', '', Buffer.from('x'), {}, () => {}); } catch (_) {}
+        }
+        assert.strictEqual(ch.unconfirmed.length, 0);
+        done();
+      });
+    });
   });
 
   describe('Error handling', () => {

package/test/channel_api.test.js

@@ -499,6 +499,17 @@ describe('confirms', () => {
         }));
     });
   });
+
+  it('publish on closed channel does not leak callbacks', () => {
+    return withConfirmChannel((ch) => {
+      return ch.close().then(() => {
+        for (let i = 0; i < 10; i++) {
+          try { ch.publish('', '', Buffer.from('x'), {}, () => {}); } catch (_) {}
+        }
+        assert.strictEqual(ch.unconfirmed.length, 0);
+      });
+    });
+  });
 });
 
 function connect() {

package/test/connection.test.js

@@ -278,6 +278,26 @@ describe('Connection', () => {
         .then(() => send(defs.ConnectionCloseOk, {}))
         .then(cb, cb);
     }));
+
+    it('close while blocked closes immediately', connectionTest((c, cb) => {
+      const decrementLatch = latch(2, cb);
+      c.on('close', () => decrementLatch());
+      c.open(OPEN_OPTS, (err) => {
+        assert.ifError(err);
+        c.once('blocked', () => {
+          c.close((err) => {
+            assert.ifError(err);
+            decrementLatch();
+          });
+        });
+      });
+    }, (send, wait, cb) => {
+      handshake(send, wait)
+        .then(() => send(defs.ConnectionBlocked, { reason: 'memory' }, 0))
+        .then(wait(defs.ConnectionClose))
+        // deliberately do NOT send ConnectionCloseOk — client must close anyway
+        .then(cb, cb);
+    }));
   });
 
   describe('heartbeats', () => {

package/test/mux.test.js

@@ -184,6 +184,49 @@ describe('mux', () => {
     });
   });
 
+  it('backpressure does not crash when newStreams is drained', () => {
+    // Regression test: out.write() returns false (backpressure) while
+    // draining newStreams. The buggy code does an unconditional shift at the
+    // bottom of the loop, so if the next stream reads null (empty) it gets
+    // discarded without being pushed back, leaving newStreams empty and
+    // triggering assert(this.newStreams.length > 0) in the else-branch.
+    //
+    // Scenario: newStreams = [input1, input2], input1 has data, input2 empty.
+    // - shift input1, read 1, write → backpressure (false), push input1 back
+    // - (buggy) unconditional shift takes input2, loop condition false → exit
+    // - newStreams = [input1], length > 0, assert passes  ← not the bug path
+    //
+    // The crash path requires backpressure AND the shifted stream reading null
+    // with no other streams remaining. Use a single stream that has data, then
+    // engineer a second read() on the same stream returning null after the
+    // write so the stream is not pushed back, emptying newStreams entirely.
+    const input1 = stream();
+    const output = stream();
+    const mux = new Mux(output);
+
+    mux.newStreams.push(input1);
+    input1.write(1);
+
+    // After the first write (which triggers backpressure), wrap read() so
+    // the stream appears empty on the next call — simulating a stream that
+    // had one item buffered and is now drained within the same roundrobin pass.
+    const originalRead = input1.read.bind(input1);
+    let readCount = 0;
+    input1.read = (size) => {
+      readCount++;
+      if (readCount > 1) return null; // appear empty after first read
+      return originalRead(size);
+    };
+
+    const originalWrite = output.write.bind(output);
+    output.write = (...args) => {
+      originalWrite(...args);
+      return false; // signal backpressure immediately
+    };
+
+    assert.doesNotThrow(() => mux._readIncoming());
+  });
+
   it('roundrobin', (_t, done) => {
     const input1 = stream();
     const input2 = stream();

package/.claude/settings.local.json

@@ -1,16 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npx oxlint:*)",
-      "Bash(npm t)",
-      "Bash(git add:*)",
-      "Bash(git commit:*)",
-      "Bash(npm run lint:*)",
-      "Bash(git checkout:*)",
-      "Bash(npx biome lint:*)",
-      "Bash(node:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}