arnavmq 0.11.0 → 0.12.0

package/README.md

@@ -74,7 +74,9 @@ arnavmq.publish('queue:name', { message: 'content' }, { rpc: true, timeout: 1000
 
 The optional `timeout` option results in a rejection when no answer has been received after the given amount of milliseconds.
 When '0' is given, there will be no timeout for this call.
-This value will overwrite the default timeout set in the config in `rpcTimeout`.
+This value will overwrite the default timeout set in the config in `rpcTimeout`. **Update:** Message-level timeout is deprecated. 
+Please use amqp's **expiration** option instead. It gives the same rejection for the producer if the timeout is reached, 
+but together with that it also guarantees that this message will not be consumed after the expiration period.
 
 ## Routing keys
 
@@ -116,7 +118,7 @@ You can specify a config object, properties and default values are:
     hostname: process.env.HOSTNAME || process.env.USER || uuid.v4(),
 
     // Deprecated. Use 'logger' instead. The transport to use to debug. If provided, arnavmq will show some logs
-    transport: utils.emptyLogger
+    transport: utils.emptyLogger,
 
     /**
      * A logger object with a log function for each of the log levels ("debug", "info", "warn", or "error").

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arnavmq",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "ArnavMQ is a RabbitMQ wrapper",
   "keywords": [
     "rabbitmq",
@@ -15,7 +15,7 @@
   "scripts": {
     "lint": "eslint .",
     "cover": "test -d .nyc_output && nyc report --reporter lcov",
-    "test": "nyc mocha --recursive --timeout=30000 --exit"
+    "test": "nyc mocha --recursive --timeout=45000 --exit"
   },
   "repository": {
     "type": "git",

package/src/index.js

@@ -1,6 +1,7 @@
 const uuid = require('uuid');
 const utils = require('./modules/utils');
 const connection = require('./modules/connection');
+const { ARNAVMQ_TRANSPORT_LOGGER_DEPRECATED } = require('./modules/warnings');
 
 /* eslint global-require: "off" */
 module.exports = (config) => {
@@ -46,7 +47,7 @@ module.exports = (config) => {
   };
 
   if (configuration.transport !== utils.emptyLogger) {
-    process.emitWarning("The 'transport' configuration option is deprecated. Please use the 'logger' option instead.", 'DeprecationWarning');
+    utils.emitWarn(ARNAVMQ_TRANSPORT_LOGGER_DEPRECATED);
   }
 
   configuration.prefetch = parseInt(configuration.prefetch, 10) || 0;

package/src/modules/producer.js

@@ -2,6 +2,7 @@ const uuid = require('uuid');
 const pDefer = require('p-defer');
 const utils = require('./utils');
 const parsers = require('./message-parsers');
+const { ARNAVMQ_MSG_TIMEOUT_DEPRECATED } = require('./warnings');
 
 const ERRORS = {
   TIMEOUT: 'Timeout reached',
@@ -173,13 +174,28 @@ class Producer {
         // reply to us if you receive this message!
         options.replyTo = this.amqpRPCQueues[queue].queue;
 
+        // convert timeout to amqp's expiration. It's message-level expiration.
+        // The message will be discarded from a queue once it’s been there longer than the given number of milliseconds
+        // This is needed to avoid the case when the message which is already expired from caller's point of view (via timeout)
+        // is still waiting in the queue and thus is about to be processed by the consumer.
+        // Unfortunately, we can do nothing if the message is already consumed and is being processed at the moment
+        // when the timeout appears.
+        if (options.timeout && options.timeout > 0) {
+          utils.emitWarn(ARNAVMQ_MSG_TIMEOUT_DEPRECATED);
+          options.expiration = options.timeout;
+        }
+        // set expiration if it isn't set yet
+        if (!options.expiration && this._connection.config.rpcTimeout > 0) {
+          options.expiration = this._connection.config.rpcTimeout;
+        }
+
         this.publishOrSendToQueue(queue, msg, options);
         // defered promise that will resolve when response is received
         const responsePromise = pDefer();
         this.amqpRPCQueues[queue][corrId] = responsePromise;
 
         //  Using given timeout or default one
-        const timeout = options.timeout || this._connection.config.rpcTimeout || 0;
+        const timeout = options.expiration || 0;
         if (timeout > 0) {
           this.prepareTimeoutRpc(queue, corrId, timeout);
         }

package/src/modules/utils.js

@@ -28,5 +28,21 @@ module.exports = {
    */
   timeoutPromise: (timer) => new Promise((resolve) => {
     setTimeout(resolve, timer);
-  })
+  }),
+
+  /**
+   * A function that allows to emit warnings for a specified code. The idea is to
+   * limit a warning emission to one per a specific code.
+   * @param warning - {code: string, detail: string, message: string}
+   */
+  emitWarn: function emitWarn(warning) {
+    const { code, message, detail } = warning;
+    if (!emitWarn.warned) {
+      emitWarn.warned = {};
+    }
+    if (!emitWarn.warned[code]) {
+      emitWarn.warned[code] = true;
+      process.emitWarning(message, { code, detail });
+    }
+  }
 };

package/src/modules/warnings.js

@@ -0,0 +1,17 @@
+/**
+ * This script is kind of dictionary for possible different types of warning in the lib.
+ * Warning object is a value (string code is a key) and has the following structure:
+ * @type {code: string, detail: string, message: string}
+ */
+module.exports = {
+  ARNAVMQ_MSG_TIMEOUT_DEPRECATED: {
+    code: 'ARNAVMQ_MSG_TIMEOUT_DEPRECATED',
+    message: 'using timeout option on message level is deprecated',
+    detail: 'Please use expiration instead'
+  },
+  ARNAVMQ_TRANSPORT_LOGGER_DEPRECATED: {
+    code: 'ARNAVMQ_TRANSPORT_LOGGER_DEPRECATED',
+    message: "The 'transport' configuration option is deprecated",
+    detail: "Please use the 'logger' option instead"
+  }
+};