@sera4/essentia 1.1.5 → 1.1.11

package/index.js

@@ -8,16 +8,5 @@ export { default as halDecorator } from "./hal/index.js";
 export { default as formatter } from "./formatter/index.js";
 export { HealthCheck as healthCheck } from "./health/index.js";
 export { default as queue } from "./queue/index.js";
-export { default as utils } from "./utils/index.js";
-
-//export default {
-//  paginator : require("./paginator/s4-pagination"),
-//  sqlPaginator : require("./paginator/sql-pagination"),
-//  logger : require("./logger/s4-logger"),
-//  lastCommit : require("./last_commit"),
-//  halDecorator : require("./hal"),
-//  formatter : require("./formatter"),
-//  healthCheck : require("./health"),
-//  queue : require("./queue"),
-//  utils : require("./utils")
-//}
+export * from "./utils/index.js";
+export * from "./safe_proxy/index.js";

package/logger/s4-logger.js

@@ -4,6 +4,30 @@ import jsonStringify from "fast-safe-stringify";
 const colorizer = winston.format.colorize();
 import "winston-logstash";
 
+// IETF RFC5424:
+// Severity of all levels is assumed to be numerically ascending from most important to least important.
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4,
+};
+
+// These colors are not used, however if colors are not defined for custom levels
+// then winston will throw an exception.
+winston.addColors({
+  trace: 'white'
+});
+
+const defaultLevel = process.env.NODE_ENV === 'production' ? 'info' : 'debug';
+
+// These colors are not used, however if colors are not defined for custom levels
+// then winston will throw an exception.
+winston.addColors({
+  trace: 'white'
+});
+
 const devFormat = {
   transform(info) {
     const { message } = info;
@@ -16,11 +40,13 @@ const devFormat = {
 };
 
 const defaultTransport = new winston.transports.Console({
-  format: devFormat
+  format: devFormat,
+  level: 'trace'
 });
 
 const logger = winston.createLogger({
-  level: 'debug',
+  levels: levels,
+  level: defaultLevel,
   defaultMeta: { },
   transports: [defaultTransport]
 });
@@ -31,15 +57,13 @@ class S4Logger {
       return;
     }
 
-    if (options.level && ["debug", "info", "error", "warn"].indexOf(options.level.toLowerCase())) {
-      logger.level = options.level;
-    }
+    this.setLevel(options.level);
 
     logger.defaultMeta.service = options.service;
     switch(options.format.toLowerCase()) {
       case "logstash":
-          defaultTransport.format = winston.format.logstash();
-          break;
+        defaultTransport.format = winston.format.logstash();
+        break;
       case "json":
         defaultTransport.format = winston.format.json();
         break;
@@ -50,7 +74,7 @@ class S4Logger {
   }
 
   setLevel(level) {
-    if (level && ["debug", "info", "error", "warn"].indexOf(level.toLowerCase())) {
+    if (level && ["trace", "debug", "info", "error", "warn"].indexOf(level.toLowerCase())) {
       logger.level = level;
     }
   }
@@ -67,6 +91,10 @@ class S4Logger {
     });
   }
 
+  trace(...args) {
+    logger.trace(util.format(...args));
+  }
+
   debug(...args) {
     logger.debug(util.format(...args));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sera4/essentia",
-  "version": "1.1.5",
+  "version": "1.1.11",
   "description": "A library of utilities for Teleporte Web Services",
   "main": "index.js",
   "type": "module",
@@ -28,10 +28,12 @@
     "sinon": "^5.1.1"
   },
   "dependencies": {
-    "amqplib": "^0.7.1",
+    "amqplib": "^0.8.0",
     "async": "^2.6.3",
+    "axios": "^0.21.1",
     "fast-safe-stringify": "^2.0.7",
     "git-rev": "^0.2.1",
+    "lodash": "^4.17.21",
     "url-parse": "^1.5.1",
     "uuid": "^3.4.0",
     "winston": "^3.3.3",

package/queue/index.js

@@ -29,6 +29,7 @@ class S4Queue {
    */
   async testConnection() {
     if (!this.isConnected()) {
+      this.connectionTestChannel = null;
       throw("queue service not connected")
     }
 
@@ -72,12 +73,16 @@ class S4Queue {
       amqp.connect(options.connectionUrl, socketOptions, (err, conn) => {
 
         if (err) {
-          return reject(err);
+          logger.error("Error while connecting", err)
+          logger.error("Attempting again in", this.retry, "seconds");
+          return setTimeout(() => this.openConnection(options), this.retry * 1000);
         }
 
         this.connection = conn;
         if (!this.connection) {
           return reject(new Error("Failed to obtain connection"));
+        } else {
+          this.updatePubsAndSubsConnectionRef(conn);
         }
 
         this.connection.on("error", (err) => {
@@ -91,8 +96,8 @@ class S4Queue {
           logger.error("connection closed");
           this.connection = null;
           if (err) {
-            logger.debug("connection closed due to error:", err);
-            logger.debug("Reconnecting in", this.retry, "seconds");
+            logger.error("connection closed due to error:", err);
+            logger.error("Reconnecting in", this.retry, "seconds");
             setTimeout(() => this.openConnection(options), this.retry * 1000);
           } else {
             // If there was no error, it is us who closed
@@ -171,6 +176,22 @@ class S4Queue {
     this.pubs[name] = p;
   }
 
+  /**
+   * 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;
+    if (Object.keys(this.pubs).includes(name)) {
+      throw new Error(`Publisher ${name} already registered`);
+    }
+
+    const p = new Publisher(exchange, 'fanout', true, name);
+    await p.init(this.connection);
+    this.pubs[name] = p;
+  }
+
   /**
    * Registers a new direct subscriber on a given exchange and queue.
    * If exchange and queue don't exists, they'll be created
@@ -273,6 +294,26 @@ class S4Queue {
     return await p.publish({key: topic, content});
   }
 
+  /**
+   * Binds an exchange to a queue
+   * @param {String} exchange the name of the exchange.
+   * @param {String} queue the name of the queue.
+   * @param {pattern} (optional) pattern for routing key
+  */
+  async bindQueueToExchange(exchange, queue, pattern) {
+    const p = this.pubs[exchange];
+
+    if (!p) {
+      throw(new Error(`No PUB for ${exchange} found`));
+    }
+
+    if (!queue) {
+      throw(new Error(`Binding a queue requires a queue name`));
+    }
+
+    return await p.bindQueue(queue, pattern)
+  }
+
   /**
    * Adds a listener for a specific key.
    * If a subscriber that was regitered was found
@@ -289,6 +330,29 @@ class S4Queue {
       }
     });
   }
+
+  /**
+   * Updates the connection reference to all the previously
+   * registered publishers and subscribers.
+   * After we successfully establish a connection and register pubs/subs,
+   * it's possible for the connection to break. This object will try
+   * to re-establish a new connection every 3 seconds (or whatever configuration is set)
+   * and if a new connection is established, we need to pass that connection to
+   * all our pubs/subs, otherwise they'll be operating with old/stale references
+   * @param {Object} connRef a new connection reference to the AMQP service
+   */
+  updatePubsAndSubsConnectionRef(connRef) {
+    Object.keys(this.pubs).forEach(k => {
+      logger.debug(`Updating publisher ${k} with a new connection object`);
+      const p = this.pubs[k];
+      p.init(connRef);
+    });
+    Object.keys(this.subs).forEach(k => {
+      logger.debug(`Updating subscriber ${k} with a new connection object`);
+      const s = this.subs[k];
+      s.init(connRef);
+    });
+  }
 }
 
 const queue = new S4Queue();

package/queue/publisher.js

@@ -5,9 +5,7 @@ import uuidv4 from "uuid/v4.js";
  * A publisher for AMQP service
  */
 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.
@@ -65,6 +63,7 @@ export class Publisher {
 
     const parcel = {
       tracking_id: uuidv4(),
+      timestamp: new Date(),
       data: msg.content
     }
     logger.debug("Publishing message");
@@ -80,4 +79,8 @@ export class Publisher {
 
     return parcel.tracking_id;
   }
+
+  async bindQueue(queue, pattern, args) {
+    await this.channel.bindQueue(queue, this.exchange, pattern, args)
+  }
 }

package/safe_proxy/index.js

@@ -0,0 +1,61 @@
+"use strict";
+
+import axios from "axios"; 
+import lodash from 'lodash';
+const { omitBy, isNil } = lodash;
+
+/* A class which safely wraps an axios connection in order to pass the current user through to
+ * the next service.  Useful when one of our microservices requires auth as either an admin (sera4tal)
+ * or as the end user (example: DELETE /auth/sessions/:id
+ *
+ * Similar to proxy however this isn't a proxy, it's a full out new call that we can manage
+ * each method requires a res.locals from a pre-authd session
+ */
+class SafeProxy {
+  constructor() {
+  }
+
+  // a safe post request
+  // locals = res.locals - your authentication details
+  post(locals, url, options = { headers: {}, data: {}}) {
+    let { account, tenant, membership } = locals;
+    return this._proxyRequest({ account, tenant, membership }, url, "post", options);
+  }
+  delete(locals, url, options = { headers: {}, data: {}}) {
+    let { account, tenant, membership } = locals;
+    return this._proxyRequest({ account, tenant, membership }, url, "delete", options);
+  }
+
+  /* private methods */
+  // supports get, delete, post
+  // options includes { headers, data } for post / delete payloads
+  async _proxyRequest(locals, url, method = "get", options) {
+    let request;
+    let membership = locals.membership ? JSON.stringify(locals.membership) : null;
+    let headers = omitBy({ ...options.headers,
+      "tws-account-id": locals.account?.id,
+      "tws-tenant-id": locals.tenant?.id,
+      "tws-membership-id": locals.membership?.id,
+      "tws-membership": membership
+    }, isNil);
+
+    switch(method) {
+      case "post":
+        request = axios.post(url, { ...options.data }, { headers })
+        break;
+      case "delete":
+        request = axios.delete(url, { ...options.data, headers } )
+        break;
+      case "get":
+        request = axios.get(url, { headers, data } )
+        break;
+      default:
+        throw new Error("uknown type called in proxyRequest");
+    }
+
+    return request;
+  }
+
+}
+
+export const safeProxy = new SafeProxy();

package/utils/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-const utils = {
+export const utils = {
   isValidUuidV4 : (input) => {
     if (!input) {
       return false
@@ -36,5 +36,3 @@ const utils = {
     }
   }
 }
-
-export default utils;