amqplib 1.0.4 → 1.0.6

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Change log for amqplib
 
+## v1.0.6
+- Fix channel.get() not invoking callback with error on channel close; previously only an error event was emitted (fixes #832). **Note:** if you use the callback API, ensure your channel.get() callbacks handle errors — they will now be invoked in error cases where previously they were not. If you use the promise API, the returned promise now rejects with a proper Error object (with .code, .classId and .methodId properties) rather than a raw close frame.
+
+## v1.0.5
+- Fix ConfirmChannel callbacks silently dropped on channel close when some publishes had no callback (fixes #191)
+
 ## v1.0.4
 - Updated build to use RabbitMQ 4.2
 - Fix memory leak in ConfirmChannel.publish when channel is already closed (fixes #842)

package/Makefile

@@ -2,7 +2,7 @@ RABBITMQ_SRC_VERSION=v3.12.13
 JSON=amqp-rabbitmq-0.9.1.json
 AMQP_JSON=https://raw.githubusercontent.com/rabbitmq/rabbitmq-server/$(RABBITMQ_SRC_VERSION)/deps/rabbitmq_codegen/$(JSON)
 
-NODEJS_VERSIONS='18.1.0' '20.10.0' '22.14.0' '24.7.0'
+NODEJS_VERSIONS='18.20.0' '20.10.0' '22.14.0' '24.7.0'
 
 UGLIFY=./node_modules/.bin/uglifyjs
 

package/lib/callback_model.js

@@ -1,8 +1,7 @@
 const defs = require('./defs');
 const EventEmitter = require('node:events');
-const BaseChannel = require('./channel').BaseChannel;
-const acceptMessage = require('./channel').acceptMessage;
 const Args = require('./api_args');
+const { BaseChannel, acceptMessage, convertCloseFrameToError } = require('./channel');
 
 class CallbackModel extends EventEmitter {
   constructor(connection) {
@@ -179,17 +178,17 @@ class Channel extends BaseChannel {
     const fields = Args.get(queue, options);
     const cb = callbackWrapper(this, cb0);
     this.sendOrEnqueue(defs.BasicGet, fields, (err, f) => {
-      if (err === null) {
-        if (f.id === defs.BasicGetEmpty) {
-          cb(null, false);
-        } else if (f.id === defs.BasicGetOk) {
-          this.handleMessage = acceptMessage((m) => {
-            m.fields = f.fields;
-            cb(null, m);
-          });
-        } else {
-          cb(new Error(`Unexpected response to BasicGet: ${inspect(f)}`));
-        }
+      if (err instanceof Error) return cb(err);
+      if (err) return cb(convertCloseFrameToError(defs.BasicGet, err));
+      if (f.id === defs.BasicGetEmpty) {
+        cb(null, false);
+      } else if (f.id === defs.BasicGetOk) {
+        this.handleMessage = acceptMessage((m) => {
+          m.fields = f.fields;
+          cb(null, m);
+        });
+      } else {
+        cb(new Error(`Unexpected response to BasicGet: ${inspect(f)}`));
       }
     });
     return this;

package/lib/channel.js

@@ -33,11 +33,12 @@ class Channel extends EventEmitter {
       }),
     );
     this.on('close', function () {
-      let cb = this.unconfirmed.shift();
-      while (cb) {
-        if (cb) cb(new Error('channel closed'));
-        cb = this.unconfirmed.shift();
+      const err = new Error('channel closed');
+      for (let i = 0; i < this.unconfirmed.length; i++) {
+        const cb = this.unconfirmed[i];
+        if (cb) cb(err);
       }
+      this.unconfirmed = this.unconfirmed.filter((cb) => cb === false);
     });
     // message frame state machine
     this.handleMessage = acceptDeliveryOrReturn;
@@ -115,19 +116,7 @@ class Channel extends EventEmitter {
       else if (err instanceof Error) return cb(err);
       // A close frame will be given if this is the RPC awaiting reply
       // and the channel is closed by the server
-      else {
-        // otherwise, it's a close frame
-        const closeReason = (err.fields.classId << 16) + err.fields.methodId;
-        const e =
-          method === closeReason
-            ? fmt('Operation failed: %s; %s', methodName(method), closeMsg(err))
-            : fmt('Channel closed by server: %s', closeMsg(err));
-        const closeFrameError = new Error(e);
-        closeFrameError.code = err.fields.replyCode;
-        closeFrameError.classId = err.fields.classId;
-        closeFrameError.methodId = err.fields.methodId;
-        return cb(closeFrameError);
-      }
+      else return cb(convertCloseFrameToError(method, err));
     }
 
     this.sendOrEnqueue(method, fields, reply);
@@ -427,6 +416,19 @@ function acceptMessage(continuation) {
   }
 }
 
+function convertCloseFrameToError(method, closeFrame) {
+  const closeReason = (closeFrame.fields.classId << 16) + closeFrame.fields.methodId;
+  const e =
+    method === closeReason
+      ? fmt('Operation failed: %s; %s', methodName(method), closeMsg(closeFrame))
+      : fmt('Channel closed by server: %s', closeMsg(closeFrame));
+  const error = new Error(e);
+  error.code = closeFrame.fields.replyCode;
+  error.classId = closeFrame.fields.classId;
+  error.methodId = closeFrame.fields.methodId;
+  return error;
+}
+
 // This adds just a bit more stuff useful for the APIs, but not
 // low-level machinery.
 class BaseChannel extends Channel {
@@ -470,3 +472,4 @@ class BaseChannel extends Channel {
 module.exports.acceptMessage = acceptMessage;
 module.exports.BaseChannel = BaseChannel;
 module.exports.Channel = Channel;
+module.exports.convertCloseFrameToError = convertCloseFrameToError;

package/lib/channel_model.js

@@ -1,9 +1,8 @@
 const EventEmitter = require('node:events');
-const promisify = require('node:util').promisify;
+const { promisify } = require('node:util');
 const defs = require('./defs');
-const { BaseChannel } = require('./channel');
-const { acceptMessage } = require('./channel');
 const Args = require('./api_args');
+const { BaseChannel, acceptMessage, convertCloseFrameToError } = require('./channel');
 const { inspect } = require('./format');
 
 class ChannelModel extends EventEmitter {
@@ -159,7 +158,8 @@ class Channel extends BaseChannel {
     const fields = Args.get(queue, options);
     return new Promise((resolve, reject) => {
       this.sendOrEnqueue(defs.BasicGet, fields, (err, f) => {
-        if (err) return reject(err);
+        if (err instanceof Error) return reject(err);
+        if (err) return reject(convertCloseFrameToError(defs.BasicGet, err));
         if (f.id === defs.BasicGetEmpty) {
           return resolve(false);
         } else if (f.id === defs.BasicGetOk) {
@@ -236,11 +236,11 @@ class ConfirmChannel extends Channel {
   waitForConfirms() {
     const awaiting = [];
     const unconfirmed = this.unconfirmed;
-    unconfirmed.forEach((val, index) => {
-      if (val !== null) {
+    unconfirmed.forEach((cb, index) => {
+      if (cb !== null) {
         const confirmed = new Promise((resolve, reject) => {
           unconfirmed[index] = (err) => {
-            if (val) val(err);
+            if (cb) cb(err);
             if (err === null) resolve();
             else reject(err);
           };
@@ -250,10 +250,10 @@ class ConfirmChannel extends Channel {
     });
     // Channel closed
     if (!this.pending) {
-      let cb = this.unconfirmed.shift();
-      while (cb) {
-        if (cb) cb(new Error('channel closed'));
-        cb = this.unconfirmed.shift();
+      const err = new Error('channel closed');
+      while (unconfirmed.length > 0) {
+        const cb = unconfirmed.shift();
+        if (cb) cb(err);
       }
     }
     return Promise.all(awaiting);

package/package.json

@@ -2,7 +2,7 @@
   "name": "amqplib",
   "homepage": "http://amqp-node.github.io/amqplib/",
   "main": "./channel_api.js",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "description": "An AMQP 0-9-1 (e.g., RabbitMQ) library and client.",
   "repository": {
     "type": "git",

package/test/callback_api.test.js

@@ -401,39 +401,18 @@ describe('Callback API', () => {
       });
     });
 
-    /*
-    When this test was refactored as part of the move to the node test framework
-    it failed because only the domain error handler was ever invoked and not the
-    channel.get error callback.
-
-    The original test passed because twice.first (refactored to use util.latch) short circuits on error rather
-    than waiting for twice.second to be invoked. I have verified that the pre-refactored
-    amqplib does not invoke the channel.get callback when the queue does not exist.
-    See lib/callback_model.js
-    */
     error_test('Get from non-queue invokes error', (ch, done, dom) => {
       const decrementLatch = latch(2, () => done());
       dom.on('error', (err) => {
         assert.match(err.message, /404 \(NOT-FOUND\)/);
-        decrementLatch(err);
+        decrementLatch();
       });
       ch.get('', {}, (err) => {
         assert.match(err.message, /404 \(NOT-FOUND\)/)
-        decrementLatch(err)
+        decrementLatch()
       });
     });
 
-    /*
-    When this test was refactored as part of the move to the node test framework
-    it failed because only the domain error handler was ever invoked and not the
-    channel.consume error callback. Unlike the above channel.get test,
-    channel.consume does invoke the channel.consume callback with an error, but
-    the original test did not supply one, mistakenly providing a message handler
-    function instead.
-
-    The original test passed because twice.first (refactored to use util.latch) short circuits on error
-    rather than waiting for twice.second to be invoked.
-    */
     error_test('Consume from non-queue invokes error', (ch, done, dom) => {
       const decrementLatch = latch(2, done);
       dom.on('error', (err) => {

package/test/channel.test.js

@@ -588,5 +588,25 @@ describe('Channel', () => {
         send(defs.BasicAck, { deliveryTag: 1, multiple: false }, ch);
       }, cb);
     }));
+
+    // Regression test for https://github.com/amqp-node/amqplib/issues/191
+    // pushConfirmCallback stores `false` for publishes with no callback.
+    // The close drain used `while (cb)` which stops at the first `false`,
+    // silently dropping all callbacks that follow it.
+    it('invokes all pending callbacks on close even when some publishes had no callback', channelTest((ch, cb) => {
+      let called = 0;
+      const countErr = (err) => { if (err) called++; };
+      ch.pushConfirmCallback(countErr); // tag = 1 — has callback
+      ch.pushConfirmCallback(null);     // tag = 2 — no callback, stored as `false`
+      ch.pushConfirmCallback(countErr); // tag = 3 — has callback, dropped by while(cb) bug
+      open(ch).then(() => {
+        ch.toClosed('test close');
+        completes(() => {
+          assert.equal(2, called);
+        }, cb);
+      }, cb);
+    }, (_send, _wait, cb) => {
+      cb();
+    }));
   });
 });

package/test/channel_api.test.js

@@ -176,6 +176,48 @@ describe('sendMessage', () => {
   });
 });
 
+describe('get', () => {
+  it('returns false when queue is empty', () => {
+    return withChannel((ch) =>
+      ch.assertQueue('test.get-empty', QUEUE_OPTS)
+        .then(() => ch.purgeQueue('test.get-empty'))
+        .then(() => ch.get('test.get-empty', { noAck: true }))
+        .then((m) => assert.strictEqual(false, m))
+    );
+  });
+
+  it('returns a message when queue has messages', () => {
+    const msg = randomString();
+    return withChannel((ch) =>
+      ch.assertQueue('test.get-message', QUEUE_OPTS)
+        .then(() => ch.purgeQueue('test.get-message'))
+        .then(() => {
+          ch.sendToQueue('test.get-message', Buffer.from(msg));
+          return waitForMessages('test.get-message');
+        })
+        .then(() => ch.get('test.get-message', { noAck: true }))
+        .then((m) => {
+          assert(m);
+          assert.equal(msg, m.content.toString());
+        })
+    );
+  });
+
+  it('rejects with a proper error when queue does not exist', () => {
+    return withChannel((ch) => {
+      ch.once('error', ignore);
+      return assert.rejects(() => ch.get('', {}), (err) => {
+        assert(err instanceof Error);
+        assert.match(err.message, /NOT_FOUND/);
+        assert.strictEqual(404, err.code);
+        assert.strictEqual(60, err.classId);
+        assert.strictEqual(70, err.methodId);
+        return true;
+      });
+    });
+  });
+});
+
 describe('binding, consuming', () => {
   // bind, publish, get
   it('route message', () => {