@sera4/essentia 1.1.65 → 3.0.6

package/queue/subscriber.js

@@ -1,107 +0,0 @@
-import logger from "./queue-logger.js";
-
-/**
- * A subscriber for AMQP service
- */
-export class Subscriber {
-
-  /**
-   * Builds a 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 {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, key, name) {
-    this.exchange = exchange;
-    this.queue = queue;
-    this.key = key;
-    this.name = name;
-    this.channel = null;
-    this.callbacks = [];
-  }
-
-  /**
-   * Initializes the subscriber on the given connection.
-   * During this call, the exchange and the queues are asserted
-   * and bound via the key provided in the constructor.
-   * @param {Object} conn aqmp connection object
-   */
-  async init (conn) {
-    logger.debug(`Initializing SUB channel for ${this.name}`);
-
-    if(this.channel) {
-      logger.warn(`SUB channel for ${this.name} already initialized`);
-      return;
-    }
-
-    this.channel = await conn.createChannel();
-    if (!this.channel) {
-      throw(new Error(`Cannot create SUB channel for ${this.name}`));
-    }
-
-    this.channel.on("error", (err) => {
-      logger.debug(`Connection error for ${this.name}`, err);
-      this.channel = null;
-    });
-
-    this.channel.on("close", () => {
-      logger.debug(`Connection closed for ${this.name}`);
-      this.channel = null;
-    });
-
-    logger.debug(`Initialized SUB channel for ${this.name}`);
-    const { name: exchangeName, options: exchangeOptions, type } = this.exchange;
-    const { name: queueName, options: queueOptions } = this.queue;
-
-    await this.channel.assertExchange(exchangeName, type, exchangeOptions);
-    await this.channel.assertQueue(queueName, queueOptions);
-
-    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;
-      try {
-        payload = JSON.parse(content.toString());
-      } catch (e) {
-        logger.error("Failed to parse incomming message:", e);
-        error = e;
-        payload = { error, original_content: content.toString() };
-      }
-      payload.metadata = fields;
-      logger.debug(`Got message from exchange '${fields.exchange}' with key '${fields.routingKey}'`);
-      logger.debug("Content", payload);
-      this.callbacks.forEach(cb => {
-        cb(payload, error);
-      });
-      this.channel.ack(msg);
-    }, { noAck: false });
-  }
-
-  /**
-   * Closes the channel
-   * @returns promise
-   */
-   async closeChannel() {
-    if (this.channel) {
-      logger.debug("Closing subscriber channel", this.name);
-      return this.channel.close();
-    } else {
-      logger.error("Can't close a null subscriber channel");
-    }
-  }
-
-  /**
-   * Register a new callback to recive message through this
-   * subscriber object
-   * @param {function} cb A callback to be called when a message arrives
-   */
-  registerCallback(cb) {
-    this.callbacks.push(cb);
-  }
-}

package/safe_proxy/index.js

@@ -1,61 +0,0 @@
-"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/serializer/index.js

@@ -1,90 +0,0 @@
-import _ from "lodash";
-
-const customSerializers = {};
-
-export default {
-  /**
-   * Seralizes a Sequelize Model.
-   * @param {Object} Model the squelize model to add this plugin to
-   * @param {Object} options various options for serialization. These can be:
-   *  • hide - an array of fields to be omitted
-   *  • remove - an array of fields ot be REMOVED so they cannot be unhidden
-   *  • decorators - an array of special decorators to run during serialization
-   *    • handler - a handler for transforming data using only the values
-   *    • advhandler - an advanced handler for transforming data using the value, object or options
-   *  • includeAllFields - show fields that are normally hidden
-   *  • includeFields[..] - show specific fields that are normally hidden
-   */
-  serialize : (Model, options) => {
-    Model.prototype.toJSON = function(eachOptions={}) {
-      const hide = options && options.hide ? options.hide : [];
-      const remove = options && options.remove ? options.remove : [];
-      // ignore hide principles; but still do NOT show null
-      const includeAllFields = eachOptions["includeAllFields"];
-
-      // optionally force a normally hidden fields to be seen (by name)
-      const includeFields = eachOptions["includeFields"] || []
-      const handlerOptions = eachOptions["handlerOptions"] || {}
-
-      const values = this.get();
-
-      if (options?.decorators) {
-        options.decorators.forEach(dec => {
-          const k = dec.name;
-          const v = values[k];
-          // the advanced handler takes more parameters
-          if (dec.advHandler) {
-            values[k] = dec.advHandler(v, this, handlerOptions);
-          } else {
-            values[k] = dec.handler(v);
-          }
-        });
-      }
-
-      // for security reasons, some fields may need to be removed, such as
-      //   password salts and mfa tokens
-      remove.forEach((field) => {
-        delete values[field];
-      });
-
-      // hidden fields CAN be resurrected if NOT null, and forced to be
-      //  included
-      let serialized = _.omitBy(values, (v, k) => {
-        if (v === null) return true;
-
-        let omitted = (includeAllFields ? false : hide.includes(k));
-        if (omitted && includeFields[k]) omitted = true ;
-        return omitted;
-      });
-
-      const s = eachOptions["serializer"];
-      if (s && customSerializers[s]) {
-        serialized = customSerializers[s](serialized);
-      }
-
-      if (Array.isArray(eachOptions.includes)) {
-        // Attach any included options that are
-        // not null or undefined
-        eachOptions.includes.forEach(include => {
-          if (include) {
-            const key = Object.keys(include);
-            const value = include[key];
-            if (value) {
-              serialized[key] = value;
-            }
-          }
-        });
-      }
-      return serialized;
-    }
-  },
-
-  /**
-   * Registers a custom serializer.
-   * @param {String} name the name of the custom serializer
-   * @param {Function} serializer a custom serializer function associated with the name
-   */
-  register : (name, serializer) => {
-    customSerializers[name] = serializer;
-  }
-}

package/utils/index.js

@@ -1,74 +0,0 @@
-"use strict";
-
-import { TWS_ROUTE_TYPES } from "../constants/index.js";
-
-export const utils = {
-  isValidUuidV4 : (input) => {
-    if (!input) {
-      return false
-    } else {
-      return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(input);
-    }
-  },
-  // convert a regular string or Array to array (ie, "[1,2,3, 0xA]", "1,2,3,10")
-  // useful for controller inputs
-  // - also accepts hex
-  convertToIntegerArray(input) {
-    return this.convertToArray(input)
-        .filter((el) => /^[0-9]+/.test(el))
-        .map((el) => parseInt(el))
-        .filter((el) => Number.isInteger(el));
-  },
-  convertToArray: (input) => {
-    if (Array.isArray(input)){
-      return input
-    } else {
-      if (!!input) {
-        if (typeof input === "number") {
-          return [ input ]
-        }
-        let matches;
-        if (matches = input.match(/\[(.*?)\]/)) {
-          input = matches[1]
-        }
-        input = input.replace(/[\[\]]/, '')
-
-        return input.replace(/\s+/, '').split(',').filter((el) => /^[0-9A-Za-z-.]+/.test(el));
-      } else {
-        return []
-      }
-    }
-  },
-  isBlank: (str) => {
-    return ((str === null) || (str === undefined) || /^\s*$/.test(str));
-  },
-  getRouteType: (domain) => {
-    if (!domain)
-      return -1;
-
-    let routeType;
-
-    switch (true) {
-      case /^(tws-web|local-gateway)/i.test(domain):
-        routeType = TWS_ROUTE_TYPES['web'];
-        break;
-      case /^tws-mob/i.test(domain):
-        routeType = TWS_ROUTE_TYPES['mobile'];
-        break;
-      case /^(tws-api-)/i.test(domain):
-        routeType = TWS_ROUTE_TYPES['api'];
-        break;
-      default:
-        routeType = TWS_ROUTE_TYPES['other'];
-    }
-
-    return routeType;
-  },
-  isWebRoute: (sessionType) => (parseInt(sessionType) === TWS_ROUTE_TYPES['web']),
-  isApiRoute: (sessionType) => (parseInt(sessionType) === TWS_ROUTE_TYPES['api']),
-  isMobileRoute: (sessionType) => (parseInt(sessionType) === TWS_ROUTE_TYPES['mobile']),
-  isOtherRoute: (sessionType) => {
-    const value = parseInt(sessionType);
-    return ((value === TWS_ROUTE_TYPES['other']) || isNaN(value)) ? true : false;
-  }
-}