@sera4/essentia 1.1.36 → 1.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sera4/essentia",
-  "version": "1.1.36",
+  "version": "1.1.38",
   "description": "A library of utilities for Teleporte Web Services",
   "main": "index.js",
   "type": "module",

package/queue/index.js

@@ -145,69 +145,80 @@ class S4Queue {
   }
 
   /**
+   * @deprecated Use registerPublisher
    * Registers a new direct publisher on the given exchange.
    * If exchange doesn't exist, one will be created.
    * @param {String} exchange the name of the exchange on AMQP service.
    */
   async registerDirectPublisher(exchange) {
-    const name = exchange;
-    if (Object.keys(this.pubs).includes(name)) {
-      throw new Error(`Publisher ${name} already registered`);
-    }
-
-    const p = new Publisher(exchange, 'direct', true, name);
-    await p.init(this.connection);
-    this.pubs[name] = p;
+    return this.registerPublisher({exchange: {name: exchange, type: "direct"}});
   }
 
   /**
+   * @deprecated Use registerPublisher
    * Registers a new topic publisher on the given exchange.
    * If exchange doesn't exist, one will be created.
    * @param {String} exchange the name of the exchange on AMQP service.
    */
   async registerTopicPublisher(exchange) {
-    const name = exchange;
-    if (Object.keys(this.pubs).includes(name)) {
-      throw new Error(`Publisher ${name} already registered`);
-    }
-
-    const p = new Publisher(exchange, 'topic', true, name);
-    await p.init(this.connection);
-    this.pubs[name] = p;
+    return this.registerPublisher({exchange: {name: exchange, type: "topic"}});
   }
 
   /**
+   * @deprecated Use registerPublisher
    * Registers a new fanout publisher on the given exchange.
    * If exchange doesn't exist, one will be created.
    * @param {String} exchange the name of the exchange on AMQP service.
    */
   async registerFanoutPublisher(exchange) {
-    const name = exchange;
+    return this.registerPublisher({exchange: {name: exchange, type: "fanout"}});
+  }
+
+    /**
+   * Registers a new publisher
+   * @param {Object} options connection options.
+   */
+  async registerPublisher(options) {
+    const { exchange } = options;
+    const { name } = exchange;
     if (Object.keys(this.pubs).includes(name)) {
       throw new Error(`Publisher ${name} already registered`);
     }
 
-    const p = new Publisher(exchange, 'fanout', true, name);
+    const p = new Publisher(exchange, name);
     await p.init(this.connection);
     this.pubs[name] = p;
   }
 
+  /**
+   * Checks whether or not a publisher with given parameters
+   * has been registered already
+   * @param {String} exchange the name of the exchange.
+   * @returns true if registered already, false otherwise
+   */
+  hasPublisher(exchange) {
+    return Object.keys(this.pubs).includes(exchange);
+  }
+
   /**
    * Removes a previously registered publisher
-   * @param {String} exchange
+   * @param {Object} options
    */
-   async unregisterPublisher(exchange) {
-    const name = exchange;
+  async unregisterPublisher(options) {
+    const { exchange } = options;
+    const { name } = exchange;
     if (!Object.keys(this.pubs).includes(name)) {
       throw new Error(`Publisher ${name} not registered`);
     }
     const p = this.pubs[name];
     await p.closeChannel();
+
     delete this.pubs[name];
     logger.debug("Unregistered publisher", name);
   }
 
   /**
+   * @deprecated Use registerSubscriber
    * Registers a new direct subscriber on a given exchange and queue.
    * If exchange and queue don't exists, they'll be created
    * and bound through the provided routing key.
@@ -216,17 +227,16 @@ class S4Queue {
    * @param {String} key the name of the routing key.
    */
   async registerDirectSubscriber(exchange, queue, key) {
-    const name = `${exchange}-${queue}-${key}`;
-    if (Object.keys(this.subs).includes(name)) {
-      throw new Error(`Subscriber ${name} already registered`);
+    const options = {
+      key,
+      exchange: { name: exchange, type: "direct" },
+      queue: { name: queue }
     }
-
-    const s = new Subscriber(exchange, queue, 'direct', true, key, name);
-    await s.init(this.connection);
-    this.subs[name] = s;
+    return this.registerSubscriber(options);
   }
 
   /**
+   * @deprecated Use registerSubscriber
    * Registers a new topic subscriber on a given exchange and queue.
    * If exchange and queue don't exists, they'll be created
    * and bound through the provided routing key.
@@ -235,29 +245,59 @@ class S4Queue {
    * @param {String} key the name of the routing key.
    */
   async registerTopicSubscriber(exchange, queue, key) {
-    const name = `${exchange}-${queue}-${key}`;
+    const options = {
+      key,
+      exchange: { name: exchange, type: "topic" },
+      queue: { name: queue }
+    }
+    return this.registerSubscriber(options);
+  }
+
+  /**
+   * An overloaded version of registering a subscriber
+   * allowing for more fine tuned parameters
+   * @param {Object} options subscribing options
+   */
+  async registerSubscriber(options) {
+    const {exchange, queue, key} = options;
+    const name = `${exchange.name}-${queue.name}-${key}`;
+
     if (Object.keys(this.subs).includes(name)) {
       throw new Error(`Subscriber ${name} already registered`);
     }
 
-    const s = new Subscriber(exchange, queue, 'topic', true, key, name);
+    const s = new Subscriber(exchange, queue, key, name);
     await s.init(this.connection);
     this.subs[name] = s;
   }
 
   /**
-   * Removes a previously registered subscriber
-   * @param {String} exchange
+   * Checks whether or not a subscriber with given parameters
+   * has been registered already
+   * @param {String} exchange the name of the exchange.
    * @param {String} queue the name of the queue.
    * @param {String} key the name of the routing key.
+   * @returns true if registered already, false otherwise
    */
-   async unregisterSubscriber(exchange, queue, key) {
+  hasSubscriber(exchange, queue, key) {
     const name = `${exchange}-${queue}-${key}`;
+    return Object.keys(this.subs).includes(name);
+  }
+
+  /**
+   * Removes a previously registered subscriber
+   * @param {OBject} options
+   */
+   async unregisterSubscriber(options) {
+    const {exchange, queue, key} = options;
+    const name = `${exchange.name}-${queue.name}-${key}`;
+
     if (!Object.keys(this.subs).includes(name)) {
       throw new Error(`Subscriber ${name} not registered`);
     }
     const s = this.subs[name];
     await s.closeChannel();
+
     delete this.subs[name];
     logger.debug("Unregistered subscriber", name);
   }

package/queue/publisher.js

@@ -6,15 +6,11 @@ import uuidv4 from "uuid/v4.js";
  */
 export class Publisher {
   /**
-   * @param {String} exchange AMQP exchange name.
-   * @param {String} type direct|fanout| etc (supported types by RabbitMQ).
-   * @param {boolean} durable true if the messages should persist service restarts.
+   * @param {Object} exchange AMQP exchange name.
    * @param {String} name a name to identify this publisher in the logs.
    */
-  constructor(exchange, type, durable, name) {
+  constructor(exchange, name) {
     this.exchange = exchange;
-    this.type = type;
-    this.durable = durable;
     this.name = name;
     this.channel = null;
   }
@@ -25,7 +21,7 @@ export class Publisher {
    * @param {Object} conn amqp connection object
    */
   async init (conn) {
-    logger.debug(`Initializing PUB channel for ${this.name}. Type: ${this.type}`);
+    logger.debug(`Initializing PUB channel for ${this.name}`);
 
     if(this.channel) {
       logger.warn(`PUB channel for ${this.name} already initialized`);
@@ -38,7 +34,8 @@ export class Publisher {
     }
 
     logger.debug(`Initialized PUB channel for ${this.name}`);
-    await this.channel.assertExchange(this.exchange, this.type, {durable: this.durable});
+    const {name, type, options} = this.exchange;
+    await this.channel.assertExchange(name, type, options);
 
     this.channel.on("error", (err) => {
       logger.debug(`Connection error for ${this.name}`, err);

package/queue/subscriber.js

@@ -10,15 +10,13 @@ export class Subscriber {
    * @param {String} exchange name of the AMQP exchange.
    * @param {String} queue name of the AMQP service.
    * @param {String} type direct|fanout or other supported connection types.
-   * @param {boolean} durable durable connection or not.
    * @param {String} key routing key. This will be used to bind the queue to the exchange.
    * @param {String} name a usefull name to be printed in the logs.
+   * @param {Object} options connection options
    */
-  constructor(exchange, queue, type, durable, key, name) {
+  constructor(exchange, queue, key, name) {
     this.exchange = exchange;
     this.queue = queue;
-    this.type = type;
-    this.durable = durable;
     this.key = key;
     this.name = name;
     this.channel = null;
@@ -55,13 +53,16 @@ export class Subscriber {
     });
 
     logger.debug(`Initialized SUB channel for ${this.name}`);
-    await this.channel.assertExchange(this.exchange, this.type, {durable: this.durable});
-    await this.channel.assertQueue(this.queue, { durable: this.durable });
+    const { name: exchangeName, options: exchangeOptions, type } = this.exchange;
+    const { name: queueName, options: queueOptions } = this.queue;
 
-    logger.debug(`Binding queue ${this.queue} on ${this.exchange} exchange for ${this.key} key`);
-    await this.channel.bindQueue(this.queue, this.exchange, this.key);
+    await this.channel.assertExchange(exchangeName, type, exchangeOptions);
+    await this.channel.assertQueue(queueName, queueOptions);
 
-    this.channel.consume(this.queue, (msg) => {
+    logger.debug(`Binding queue ${queueName} on ${exchangeName} exchange for ${this.key} key`);
+    await this.channel.bindQueue(queueName, exchangeName, this.key);
+
+    this.channel.consume(queueName, (msg) => {
       const { fields, content } = msg;
       let payload = null;
       let error = null;