@sera4/essentia 1.1.37 → 1.1.39

package/package.json

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

package/queue/index.js

@@ -145,52 +145,47 @@ 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.
-   * @param {Object} options connection options
    */
-  async registerDirectPublisher(exchange, options) {
-    const name = exchange;
-    if (Object.keys(this.pubs).includes(name)) {
-      throw new Error(`Publisher ${name} already registered`);
-    }
-
-    const p = new Publisher(exchange, 'direct', name, options);
-    await p.init(this.connection);
-    this.pubs[name] = p;
+  async registerDirectPublisher(exchange) {
+    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.
-   * @param {Object} options connection options
    */
-  async registerTopicPublisher(exchange, options) {
-    const name = exchange;
-    if (Object.keys(this.pubs).includes(name)) {
-      throw new Error(`Publisher ${name} already registered`);
-    }
-
-    const p = new Publisher(exchange, 'topic', name, options);
-    await p.init(this.connection);
-    this.pubs[name] = p;
+  async registerTopicPublisher(exchange) {
+    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.
-   * @param {Object} options connection options
    */
-  async registerFanoutPublisher(exchange, options) {
-    const name = exchange;
+  async registerFanoutPublisher(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', name, options);
+    const p = new Publisher(exchange, name);
     await p.init(this.connection);
     this.pubs[name] = p;
   }
@@ -207,55 +202,71 @@ class S4Queue {
 
   /**
    * 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.
    * @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.
-   * @param {Object} options connection options
    */
-  async registerDirectSubscriber(exchange, queue, key, options) {
-    const name = `${exchange}-${queue}-${key}`;
-    if (Object.keys(this.subs).includes(name)) {
-      throw new Error(`Subscriber ${name} already registered`);
+  async registerDirectSubscriber(exchange, queue, key) {
+    const options = {
+      key,
+      exchange: { name: exchange, type: "direct" },
+      queue: { name: queue }
     }
-
-    const s = new Subscriber(exchange, queue, 'direct', key, name, options);
-    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.
    * @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.
-   * @param {Object} options connection options
    */
-  async registerTopicSubscriber(exchange, queue, key, options) {
-    const name = `${exchange}-${queue}-${key}`;
+  async registerTopicSubscriber(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', key, name, options);
+    const s = new Subscriber(exchange, queue, key, name);
     await s.init(this.connection);
     this.subs[name] = s;
   }
@@ -275,17 +286,18 @@ class S4Queue {
 
   /**
    * Removes a previously registered subscriber
-   * @param {String} exchange
-   * @param {String} queue the name of the queue.
-   * @param {String} key the name of the routing key.
+   * @param {OBject} options
    */
-   async unregisterSubscriber(exchange, queue, key) {
-    const name = `${exchange}-${queue}-${key}`;
+   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);
   }
@@ -297,29 +309,7 @@ class S4Queue {
    * @param {Object} msg a JSON object as the message.
    */
   async publishDirectMessage(exchange, key, msg) {
-    const p = this.pubs[exchange];
-
-    if (!key) {
-      throw(new Error(`Direct message require a key`));
-    }
-
-    if (!p) {
-      throw(new Error(`No PUB for ${exchange} found`));
-    }
-
-    if (p.type !== 'direct') {
-      throw(new Error(`PUB ${exchange} is not direct`));
-    }
-
-    let content = msg;
-    if (content.constructor !== ({}).constructor) {
-      // if not in JSON format, let's make it so
-      content = {
-        msg: msg
-      }
-    }
-
-    return await p.publish({key, content});
+    return this.publishMessage(exchange, key, msg)
   }
 
   /**
@@ -329,20 +319,25 @@ class S4Queue {
    * @param {Object} msg a JSON object as the message.
    */
   async publishTopicMessage(exchange, topic, msg) {
-    const p = this.pubs[exchange];
+    return this.publishMessage(exchange, topic, msg)
+  }
 
-    if (!topic) {
-      throw(new Error(`Topic message require a topic`));
+  /**
+   * Publish a message to the exchange
+   * @param {String} exchange name of exchange
+   * @param {String} key name of the key or topic
+   * @param {Object} msg payload to be published
+   */
+  async publishMessage(exchange, key, msg) {
+    if (!key) {
+      throw(new Error(`Key argument not defined`));
     }
 
+    const p = this.pubs[exchange];
     if (!p) {
       throw(new Error(`No PUB for ${exchange} found`));
     }
 
-    if (p.type !== 'topic') {
-      throw(new Error(`PUB ${exchange} is not topic`));
-    }
-
     let content = msg;
     if (content.constructor !== ({}).constructor) {
       // if not in JSON format, let's make it so
@@ -351,7 +346,7 @@ class S4Queue {
       }
     }
 
-    return await p.publish({key: topic, content});
+    return await p.publish({key, content});
   }
 
   /**

package/queue/publisher.js

@@ -6,16 +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 {Object} exchange AMQP exchange name.
    * @param {String} name a name to identify this publisher in the logs.
-   * @param {Object} options connection options
-
    */
-  constructor(exchange, type, name, options = {}) {
+  constructor(exchange, name) {
     this.exchange = exchange;
-    this.type = type;
-    this.options = {durable: true, ...options};
     this.name = name;
     this.channel = null;
   }
@@ -26,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`);
@@ -39,7 +34,8 @@ export class Publisher {
     }
 
     logger.debug(`Initialized PUB channel for ${this.name}`);
-    await this.channel.assertExchange(this.exchange, this.type, this.options);
+    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);
@@ -72,7 +68,7 @@ export class Publisher {
     logger.debug("Data", parcel);
 
     const content = Buffer.from(JSON.stringify(parcel));
-    const res = await this.channel.publish(this.exchange, msg.key, content, {persistent: true});
+    const res = await this.channel.publish(this.exchange.name, msg.key, content, {persistent: true});
 
     if (!res) {
       throw(new Error("Channel write buffer is full"));

package/queue/subscriber.js

@@ -14,11 +14,9 @@ export class Subscriber {
    * @param {String} name a usefull name to be printed in the logs.
    * @param {Object} options connection options
    */
-  constructor(exchange, queue, type, key, name, options = {}) {
+  constructor(exchange, queue, key, name) {
     this.exchange = exchange;
     this.queue = queue;
-    this.type = type;
-    this.options = {durable: true, ...options};
     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, this.options);
-    await this.channel.assertQueue(this.queue, this.options);
+    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;