arnavmq 0.11.0 → 0.13.0

package/.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [12.x, 14.x, 16.x]
+        node-version: [14.x, 16.x, 18.x]
 
     steps:
     - uses: actions/checkout@v2

package/.prettierignore

@@ -0,0 +1,19 @@
+/bin/**
+/build/**
+/coverage/**
+/docs/**
+/jsdoc/**
+/templates/**
+/tests/bench/**
+/tests/fixtures/**
+/tests/performance/**
+/tmp/**
+/public/**
+/node_modules/**
+/lib-cov/**
+/.grunt/**
+/.sonar/**
+/logs/**
+/.idea/**
+/.github/**
+/samples/**

package/README.md

@@ -62,12 +62,11 @@ arnavmq.subscribe('queue:name', function (msg) {
 You can create RPC requests easily by adding the `rpc: true` option to the `produce` call:
 
 ```javascript
-arnavmq.subscribe('queue:name', function() {
+arnavmq.subscribe('queue:name', function () {
   return 'hello world!'; // you can also return a promise if you want to do async stuff
 });
 
-arnavmq.publish('queue:name', { message: 'content' }, { rpc: true, timeout: 1000 })
-.then(function(consumerResponse) {
+arnavmq.publish('queue:name', { message: 'content' }, { rpc: true, timeout: 1000 }).then(function (consumerResponse) {
   console.log(consumerResponse); // prints hello world!
 });
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnavmq",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "ArnavMQ is a RabbitMQ wrapper",
   "keywords": [
     "rabbitmq",
@@ -13,10 +13,15 @@
   ],
   "main": "src/index.js",
   "scripts": {
-    "lint": "eslint .",
+    "lint": "eslint . && prettier -c .",
+    "format": "eslint --fix . && prettier --write .",
     "cover": "test -d .nyc_output && nyc report --reporter lcov",
     "test": "nyc mocha --recursive --timeout=30000 --exit"
   },
+  "prettier": {
+    "singleQuote": true,
+    "printWidth": 120
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/bringg/node-arnavmq.git"
@@ -37,12 +42,14 @@
     "child-process-promise": "^2.2.1",
     "eslint": "^8.25.0",
     "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-import": "^2.26.0",
     "mocha": "^10.0.0",
     "nyc": "^15.1.0",
+    "prettier": "^2.8.3",
     "sinon": "^14.0.1"
   },
   "engines": {
-    "node": ">=12"
+    "node": ">=14"
   }
 }

package/src/index.js

@@ -42,11 +42,14 @@ module.exports = (config) => {
      */
     logger: utils.emptyLogger,
 
-    ...config
+    ...config,
   };
 
   if (configuration.transport !== utils.emptyLogger) {
-    process.emitWarning("The 'transport' configuration option is deprecated. Please use the 'logger' option instead.", 'DeprecationWarning');
+    process.emitWarning(
+      "The 'transport' configuration option is deprecated. Please use the 'logger' option instead.",
+      'DeprecationWarning'
+    );
   }
 
   configuration.prefetch = parseInt(configuration.prefetch, 10) || 0;

package/src/modules/arnavmq.js

@@ -51,12 +51,12 @@ module.exports = (connection) => {
 
   const consumer = {
     consume: instance.consume.bind(instance),
-    subscribe: instance.subscribe.bind(instance)
+    subscribe: instance.subscribe.bind(instance),
   };
 
   const producer = {
     produce: instance.produce.bind(instance),
-    publish: instance.publish.bind(instance)
+    publish: instance.publish.bind(instance),
   };
 
   return {
@@ -66,6 +66,6 @@ module.exports = (connection) => {
     produce: producer.produce,
     publish: producer.publish,
     consumer,
-    producer
+    producer,
   };
 };

package/src/modules/connection.js

@@ -12,7 +12,7 @@ class Connection {
   /**
    * Connect to the broker. We keep only 1 connection for each connection string provided in config, as advised by RabbitMQ
    * @return {Promise} A promise that resolve with an amqp.node connection object
-  */
+   */
   getConnection() {
     const url = this._config.host;
     const { hostname } = this._config;
@@ -25,28 +25,31 @@ class Connection {
     // prepare the connection internal object, and reset channel if connection has been closed
     this.connections[url] = {
       conn: null,
-      channel: null
+      channel: null,
     };
     connection = this.connections[url];
-    connection.conn = amqp.connect(url, {
-      clientProperties: {
-        hostname,
-        arnavmq: packageVersion,
-        startedAt: this.startedAt,
-        connectedAt: new Date().toISOString()
-      }
-    }).then((conn) => {
-      // on connection close, delete connection
-      conn.on('close', () => {
-        delete connection.conn;
+    connection.conn = amqp
+      .connect(url, {
+        clientProperties: {
+          hostname,
+          arnavmq: packageVersion,
+          startedAt: this.startedAt,
+          connectedAt: new Date().toISOString(),
+        },
+      })
+      .then((conn) => {
+        // on connection close, delete connection
+        conn.on('close', () => {
+          delete connection.conn;
+        });
+        conn.on('error', this._onError.bind(this));
+        connection.conn = conn;
+        return conn;
+      })
+      .catch((e) => {
+        connection.conn = null;
+        throw e;
       });
-      conn.on('error', this._onError.bind(this));
-      connection.conn = conn;
-      return conn;
-    }).catch((e) => {
-      connection.conn = null;
-      throw e;
-    });
     return connection.conn;
   }
 
@@ -54,7 +57,7 @@ class Connection {
    * Create the channel on the broker, once connection is successfuly opened.
    * Since RabbitMQ advise to open one channel by process and node is mono-core, we keep only 1 channel for the whole connection.
    * @return {Promise} A promise that resolve with an amqp.node channel object
-  */
+   */
   getChannel() {
     const url = this._config.host;
     const { prefetch } = this._config;
@@ -65,17 +68,18 @@ class Connection {
       return Promise.resolve(connection.chann);
     }
 
-    connection.chann = connection.conn.createChannel()
-      .then((channel) => {
-        channel.prefetch(prefetch);
+    connection.chann = connection.conn.createChannel().then((channel) => {
+      channel.prefetch(prefetch);
 
-        // on error we remove the channel so the next call will recreate it (auto-reconnect are handled by connection users)
-        channel.on('close', () => { delete connection.chann; });
-        channel.on('error', this._onError.bind(this));
-
-        connection.chann = channel;
-        return channel;
+      // on error we remove the channel so the next call will recreate it (auto-reconnect are handled by connection users)
+      channel.on('close', () => {
+        delete connection.chann;
       });
+      channel.on('error', this._onError.bind(this));
+
+      connection.chann = channel;
+      return channel;
+    });
     return connection.chann;
   }
 
@@ -87,7 +91,7 @@ class Connection {
     this._config.transport.error(error);
     this._config.logger.error({
       message: error.message,
-      error
+      error,
     });
   }
 

package/src/modules/consumer.js

@@ -35,7 +35,7 @@ class Consumer {
         this._connection.config.transport.debug(loggerAlias, `[${queue}][${msg.properties.replyTo}] >`, content);
         this._connection.config.logger.debug({
           message: `${loggerAlias} [${queue}][${msg.properties.replyTo}] > ${content}`,
-          params: { content }
+          params: { content },
         });
         this.channel.sendToQueue(msg.properties.replyTo, parsers.out(content, options), options);
       }
@@ -68,55 +68,63 @@ class Consumer {
     // ex: service-something with suffix :ci becomes service-suffix:ci etc.
     const suffixedQueue = `${queue}${this._connection.config.consumerSuffix || ''}`;
 
-    return this._connection.get().then((channel) => {
-      this.channel = channel;
+    return this._connection
+      .get()
+      .then((channel) => {
+        this.channel = channel;
 
-      // when channel is closed, we want to be sure we recreate the queue ASAP so we trigger a reconnect by recreating the consumer
-      this.channel.addListener('close', () => {
-        this.subscribe(queue, options, callback);
-      });
-
-      return this.channel.assertQueue(suffixedQueue, options).then((q) => {
-        this._connection.config.transport.debug(loggerAlias, 'init', q.queue);
-        this._connection.config.logger.debug({
-          message: `${loggerAlias} init ${q.queue}`,
-          params: { queue: q.queue }
+        // when channel is closed, we want to be sure we recreate the queue ASAP so we trigger a reconnect by recreating the consumer
+        this.channel.addListener('close', () => {
+          this.subscribe(queue, options, callback);
         });
 
-        this.channel.consume(q.queue, (msg) => {
-          const messageString = msg.content.toString();
-          this._connection.config.transport.debug(loggerAlias, `[${q.queue}] < ${messageString}`);
+        return this.channel.assertQueue(suffixedQueue, options).then((q) => {
+          this._connection.config.transport.debug(loggerAlias, 'init', q.queue);
           this._connection.config.logger.debug({
-            message: `${loggerAlias} [${q.queue}] < ${messageString}`,
-            params: { queue: q.queue, message: messageString }
+            message: `${loggerAlias} init ${q.queue}`,
+            params: { queue: q.queue },
           });
 
-          // main answer management chaining
-          // receive message, parse it, execute callback, check if should answer, ack/reject message
-          Promise.resolve(parsers.in(msg))
-            .then((body) => callback(body, msg.properties))
-            .then(this.checkRpc(msg, q.queue))
-            .then(() => {
-              this.channel.ack(msg);
-            })
-            .catch((error) => {
-              // if something bad happened in the callback, reject the message so we can requeue it (or not)
-              this._connection.config.transport.error(loggerAlias, error);
-              this._connection.config.logger.error({
-                message: `${loggerAlias} Failed processing message from queue ${q.queue}: ${error.message}`,
-                error,
-                params: { queue: q.queue, message: messageString }
+          this.channel.consume(
+            q.queue,
+            (msg) => {
+              const messageString = msg.content.toString();
+              this._connection.config.transport.debug(loggerAlias, `[${q.queue}] < ${messageString}`);
+              this._connection.config.logger.debug({
+                message: `${loggerAlias} [${q.queue}] < ${messageString}`,
+                params: { queue: q.queue, message: messageString },
               });
 
-              this.channel.reject(msg, this._connection.config.requeue);
-            });
-        }, { noAck: false });
-
-        return true;
-      });
-      // in case of any error creating the channel, wait for some time and then try to reconnect again (to avoid overflow)
-    }).catch(() => utils.timeoutPromise(this._connection.config.timeout)
-      .then(() => this.subscribe(queue, options, callback)));
+              // main answer management chaining
+              // receive message, parse it, execute callback, check if should answer, ack/reject message
+              Promise.resolve(parsers.in(msg))
+                .then((body) => callback(body, msg.properties))
+                .then(this.checkRpc(msg, q.queue))
+                .then(() => {
+                  this.channel.ack(msg);
+                })
+                .catch((error) => {
+                  // if something bad happened in the callback, reject the message so we can requeue it (or not)
+                  this._connection.config.transport.error(loggerAlias, error);
+                  this._connection.config.logger.error({
+                    message: `${loggerAlias} Failed processing message from queue ${q.queue}: ${error.message}`,
+                    error,
+                    params: { queue: q.queue, message: messageString },
+                  });
+
+                  this.channel.reject(msg, this._connection.config.requeue);
+                });
+            },
+            { noAck: false }
+          );
+
+          return true;
+        });
+        // in case of any error creating the channel, wait for some time and then try to reconnect again (to avoid overflow)
+      })
+      .catch(() =>
+        utils.timeoutPromise(this._connection.config.timeout).then(() => this.subscribe(queue, options, callback))
+      );
   }
 }
 

package/src/modules/producer.js

@@ -50,27 +50,21 @@ class Producer {
 
       if (responsePromise === undefined) {
         const error = new Error(`Receiving RPC message from previous session: callback no more in memory. ${queue}`);
-        this._connection.config.transport.warn(
-          loggerAlias,
-          error
-        );
+        this._connection.config.transport.warn(loggerAlias, error);
         this._connection.config.logger.warn({
           message: `${loggerAlias} ${error.message}`,
           error,
-          params: { queue, rpcQueue }
+          params: { queue, rpcQueue },
         });
 
         return;
       }
 
       // if we found one, we execute the callback and delete it because it will never be received again anyway
-      this._connection.config.transport.info(
-        loggerAlias,
-        `[${queue}] < answer`
-      );
+      this._connection.config.transport.info(loggerAlias, `[${queue}] < answer`);
       this._connection.config.logger.debug({
         message: `${loggerAlias} [${queue}] < answer`,
-        params: { queue }
+        params: { queue },
       });
 
       try {
@@ -100,30 +94,30 @@ class Producer {
     const resQueue = `${queue}:${this._connection.config.hostname}:${process.pid}:res`;
     rpcQueue.queue = this._connection
       .get()
-      .then((channel) => channel
-        .assertQueue(resQueue, {
-          durable: true,
-          exclusive: true,
-        })
-        .then((q) => {
-          rpcQueue.queue = q.queue;
-
-          // if channel is closed, we want to make sure we cleanup the queue so future calls will recreate it
-          this._connection.addListener('close', () => {
-            delete rpcQueue.queue;
-            this.createRpcQueue(queue);
-          });
-
-          return channel.consume(q.queue, this.maybeAnswer(queue), {
-            noAck: true,
-          });
-        })
-        .then(() => rpcQueue.queue))
+      .then((channel) =>
+        channel
+          .assertQueue(resQueue, {
+            durable: true,
+            exclusive: true,
+          })
+          .then((q) => {
+            rpcQueue.queue = q.queue;
+
+            // if channel is closed, we want to make sure we cleanup the queue so future calls will recreate it
+            this._connection.addListener('close', () => {
+              delete rpcQueue.queue;
+              this.createRpcQueue(queue);
+            });
+
+            return channel.consume(q.queue, this.maybeAnswer(queue), {
+              noAck: true,
+            });
+          })
+          .then(() => rpcQueue.queue)
+      )
       .catch(() => {
         delete rpcQueue.queue;
-        return utils
-          .timeoutPromise(this._connection.config.timeout)
-          .then(() => this.createRpcQueue(queue));
+        return utils.timeoutPromise(this._connection.config.timeout).then(() => this.createRpcQueue(queue));
       });
 
     return rpcQueue.queue;
@@ -236,14 +230,10 @@ class Producer {
         // undefined can't be serialized/buffered :p
         if (!message) message = null;
 
-        this._connection.config.transport.info(
-          loggerAlias,
-          `[${queue}] > `,
-          message
-        );
+        this._connection.config.transport.info(loggerAlias, `[${queue}] > `, message);
         this._connection.config.logger.debug({
           message: `${loggerAlias} [${queue}] > ${message}`,
-          params: { queue, message }
+          params: { queue, message },
         });
 
         return this.checkRpc(queue, parsers.out(message, settings), settings);
@@ -258,7 +248,7 @@ class Producer {
         this._connection.config.logger.error({
           message: `${loggerAlias} Failed sending message to queue ${queue}: ${error.message}`,
           error,
-          params: { queue, message }
+          params: { queue, message },
         });
         return utils
           .timeoutPromise(this._connection.config.timeout)

package/src/modules/utils.js

@@ -5,7 +5,7 @@ const emptyLogger = {
   debug: empty,
   warn: empty,
   error: empty,
-  log: empty
+  log: empty,
 };
 
 module.exports = {
@@ -26,7 +26,8 @@ module.exports = {
    * @param  {number} timer How much ws to wait
    * @return {Promise}      A Promise that will resolve when timer is expired
    */
-  timeoutPromise: (timer) => new Promise((resolve) => {
-    setTimeout(resolve, timer);
-  })
+  timeoutPromise: (timer) =>
+    new Promise((resolve) => {
+      setTimeout(resolve, timer);
+    }),
 };