amqplib 0.10.8 → 1.0.0

package/lib/channel_model.js

@@ -1,23 +1,17 @@
-//
-//
-//
-
-'use strict';
-
-const EventEmitter = require('events');
-const promisify = require('util').promisify;
+const EventEmitter = require('node:events');
+const promisify = require('node:util').promisify;
 const defs = require('./defs');
-const {BaseChannel} = require('./channel');
-const {acceptMessage} = require('./channel');
+const { BaseChannel } = require('./channel');
+const { acceptMessage } = require('./channel');
 const Args = require('./api_args');
-const {inspect} = require('./format');
+const { inspect } = require('./format');
 
 class ChannelModel extends EventEmitter {
   constructor(connection) {
     super();
     this.connection = connection;
 
-    ['error', 'close', 'blocked', 'unblocked'].forEach(ev => {
+    ['error', 'close', 'blocked', 'unblocked'].forEach((ev) => {
       connection.on(ev, this.emit.bind(this, ev));
     });
   }
@@ -41,7 +35,7 @@ class ChannelModel extends EventEmitter {
     const channel = new ConfirmChannel(this.connection);
     channel.setOptions(options);
     await channel.open();
-    await channel.rpc(defs.ConfirmSelect, {nowait: false}, defs.ConfirmSelectOk);
+    await channel.rpc(defs.ConfirmSelect, { nowait: false }, defs.ConfirmSelectOk);
     return channel;
   }
 }
@@ -59,7 +53,7 @@ class Channel extends BaseChannel {
   // response's fields; this is intended to be suitable for implementing
   // API procedures.
   async rpc(method, fields, expect) {
-    const f = await promisify(cb => {
+    const f = await promisify((cb) => {
       return this._rpc(method, fields, expect, cb);
     })();
 
@@ -69,86 +63,63 @@ class Channel extends BaseChannel {
   // Do the remarkably simple channel open handshake
   async open() {
     const ch = await this.allocate.bind(this)();
-    return ch.rpc(defs.ChannelOpen, {outOfBand: ""},
-                  defs.ChannelOpenOk);
+    return ch.rpc(defs.ChannelOpen, { outOfBand: '' }, defs.ChannelOpenOk);
   }
 
   close() {
-    return promisify(cb => {
-      return this.closeBecause("Goodbye", defs.constants.REPLY_SUCCESS,
-                      cb);
+    return promisify((cb) => {
+      return this.closeBecause('Goodbye', defs.constants.REPLY_SUCCESS, cb);
     })();
   }
 
   // === Public API, declaring queues and stuff ===
 
   assertQueue(queue, options) {
-    return this.rpc(defs.QueueDeclare,
-                    Args.assertQueue(queue, options),
-                    defs.QueueDeclareOk);
+    return this.rpc(defs.QueueDeclare, Args.assertQueue(queue, options), defs.QueueDeclareOk);
   }
 
   checkQueue(queue) {
-    return this.rpc(defs.QueueDeclare,
-                    Args.checkQueue(queue),
-                    defs.QueueDeclareOk);
+    return this.rpc(defs.QueueDeclare, Args.checkQueue(queue), defs.QueueDeclareOk);
   }
 
   deleteQueue(queue, options) {
-    return this.rpc(defs.QueueDelete,
-                    Args.deleteQueue(queue, options),
-                    defs.QueueDeleteOk);
+    return this.rpc(defs.QueueDelete, Args.deleteQueue(queue, options), defs.QueueDeleteOk);
   }
 
   purgeQueue(queue) {
-    return this.rpc(defs.QueuePurge,
-                    Args.purgeQueue(queue),
-                    defs.QueuePurgeOk);
+    return this.rpc(defs.QueuePurge, Args.purgeQueue(queue), defs.QueuePurgeOk);
   }
 
   bindQueue(queue, source, pattern, argt) {
-    return this.rpc(defs.QueueBind,
-                    Args.bindQueue(queue, source, pattern, argt),
-                    defs.QueueBindOk);
+    return this.rpc(defs.QueueBind, Args.bindQueue(queue, source, pattern, argt), defs.QueueBindOk);
   }
 
   unbindQueue(queue, source, pattern, argt) {
-    return this.rpc(defs.QueueUnbind,
-                    Args.unbindQueue(queue, source, pattern, argt),
-                    defs.QueueUnbindOk);
+    return this.rpc(defs.QueueUnbind, Args.unbindQueue(queue, source, pattern, argt), defs.QueueUnbindOk);
   }
 
   assertExchange(exchange, type, options) {
     // The server reply is an empty set of fields, but it's convenient
     // to have the exchange name handed to the continuation.
-    return this.rpc(defs.ExchangeDeclare,
-                    Args.assertExchange(exchange, type, options),
-                    defs.ExchangeDeclareOk)
-      .then(_ok => { return { exchange }; });
+    return this.rpc(defs.ExchangeDeclare, Args.assertExchange(exchange, type, options), defs.ExchangeDeclareOk).then((_ok) => {
+      return { exchange };
+    });
   }
 
   checkExchange(exchange) {
-    return this.rpc(defs.ExchangeDeclare,
-                    Args.checkExchange(exchange),
-                    defs.ExchangeDeclareOk);
+    return this.rpc(defs.ExchangeDeclare, Args.checkExchange(exchange), defs.ExchangeDeclareOk);
   }
 
   deleteExchange(name, options) {
-    return this.rpc(defs.ExchangeDelete,
-                    Args.deleteExchange(name, options),
-                    defs.ExchangeDeleteOk);
+    return this.rpc(defs.ExchangeDelete, Args.deleteExchange(name, options), defs.ExchangeDeleteOk);
   }
 
   bindExchange(dest, source, pattern, argt) {
-    return this.rpc(defs.ExchangeBind,
-                    Args.bindExchange(dest, source, pattern, argt),
-                    defs.ExchangeBindOk);
+    return this.rpc(defs.ExchangeBind, Args.bindExchange(dest, source, pattern, argt), defs.ExchangeBindOk);
   }
 
   unbindExchange(dest, source, pattern, argt) {
-    return this.rpc(defs.ExchangeUnbind,
-                    Args.unbindExchange(dest, source, pattern, argt),
-                    defs.ExchangeUnbindOk);
+    return this.rpc(defs.ExchangeUnbind, Args.unbindExchange(dest, source, pattern, argt), defs.ExchangeUnbindOk);
   }
 
   // Working with messages
@@ -176,12 +147,9 @@ class Channel extends BaseChannel {
   }
 
   async cancel(consumerTag) {
-    const ok = await promisify(cb => {
-      this._rpc(defs.BasicCancel, Args.cancel(consumerTag),
-            defs.BasicCancelOk,
-            cb);
-    })()
-    .then(ok => {
+    await promisify((cb) => {
+      this._rpc(defs.BasicCancel, Args.cancel(consumerTag), defs.BasicCancelOk, cb);
+    })().then((ok) => {
       this.unregisterConsumer(consumerTag);
       return ok.fields;
     });
@@ -194,15 +162,13 @@ class Channel extends BaseChannel {
         if (err) return reject(err);
         if (f.id === defs.BasicGetEmpty) {
           return resolve(false);
-        }
-        else if (f.id === defs.BasicGetOk) {
+        } else if (f.id === defs.BasicGetOk) {
           const fields = f.fields;
-          this.handleMessage = acceptMessage(m => {
+          this.handleMessage = acceptMessage((m) => {
             m.fields = fields;
             resolve(m);
           });
-        }
-        else {
+        } else {
           reject(new Error(`Unexpected response to BasicGet: ${inspect(f)}`));
         }
       });
@@ -210,9 +176,7 @@ class Channel extends BaseChannel {
   }
 
   ack(message, allUpTo) {
-    this.sendImmediately(
-      defs.BasicAck,
-      Args.ack(message.fields.deliveryTag, allUpTo));
+    this.sendImmediately(defs.BasicAck, Args.ack(message.fields.deliveryTag, allUpTo));
   }
 
   ackAll() {
@@ -220,14 +184,11 @@ class Channel extends BaseChannel {
   }
 
   nack(message, allUpTo, requeue) {
-    this.sendImmediately(
-      defs.BasicNack,
-      Args.nack(message.fields.deliveryTag, allUpTo, requeue));
+    this.sendImmediately(defs.BasicNack, Args.nack(message.fields.deliveryTag, allUpTo, requeue));
   }
 
   nackAll(requeue) {
-    this.sendImmediately(defs.BasicNack,
-                         Args.nack(0, true, requeue));
+    this.sendImmediately(defs.BasicNack, Args.nack(0, true, requeue));
   }
 
   // `Basic.Nack` is not available in older RabbitMQ versions (or in the
@@ -235,21 +196,15 @@ class Channel extends BaseChannel {
   // `Basic.Reject`. This is otherwise synonymous with
   // `#nack(message, false, requeue)`.
   reject(message, requeue) {
-    this.sendImmediately(
-      defs.BasicReject,
-      Args.reject(message.fields.deliveryTag, requeue));
+    this.sendImmediately(defs.BasicReject, Args.reject(message.fields.deliveryTag, requeue));
   }
 
   recover() {
-    return this.rpc(defs.BasicRecover,
-                    Args.recover(),
-                    defs.BasicRecoverOk);
+    return this.rpc(defs.BasicRecover, Args.recover(), defs.BasicRecoverOk);
   }
 
   qos(count, global) {
-    return this.rpc(defs.BasicQos,
-                    Args.prefetch(count, global),
-                    defs.BasicQosOk);
+    return this.rpc(defs.BasicQos, Args.prefetch(count, global), defs.BasicQosOk);
   }
 }
 
@@ -258,7 +213,7 @@ class Channel extends BaseChannel {
 // channels or consumers. RabbitMQ v3.3.0 and after treat prefetch
 // (without `global` set) as per-consumer (for consumers following),
 // and prefetch with `global` set as per-channel.
-Channel.prototype.prefetch = Channel.prototype.qos
+Channel.prototype.prefetch = Channel.prototype.qos;
 
 // Confirm channel. This is a channel with confirms 'switched on',
 // meaning sent messages will provoke a responding 'ack' or 'nack'
@@ -283,7 +238,7 @@ class ConfirmChannel extends Channel {
     unconfirmed.forEach((val, index) => {
       if (val !== null) {
         const confirmed = new Promise((resolve, reject) => {
-          unconfirmed[index] = err => {
+          unconfirmed[index] = (err) => {
             if (val) val(err);
             if (err === null) resolve();
             else reject(err);
@@ -294,9 +249,10 @@ class ConfirmChannel extends Channel {
     });
     // Channel closed
     if (!this.pending) {
-      var cb;
-      while (cb = this.unconfirmed.shift()) {
+      let cb = this.unconfirmed.shift();
+      while (cb) {
         if (cb) cb(new Error('channel closed'));
+        cb = this.unconfirmed.shift();
       }
     }
     return Promise.all(awaiting);