@sera4/essentia 1.1.66-rc.1 → 3.0.8

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/scripts/publish.sh

@@ -1,46 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$ROOT"
-
-# ── Version resolution ────────────────────────────────────────────────────────
-VERSION="${BUILD_VERSION:-}"
-
-if [ -z "$VERSION" ]; then
-  VERSION=$(node -p "require('./package.json').version")
-fi
-
-if [ -z "$VERSION" ] || [ "$VERSION" = "0.0.0" ]; then
-  echo "error: no version specified — set BUILD_VERSION or package.json version" >&2
-  exit 1
-fi
-
-PACKAGE=$(node -p "require('./package.json').name")
-echo "publishing $PACKAGE@$VERSION"
-
-# ── Stamp version, restore on exit ───────────────────────────────────────────
-ORIGINAL_VERSION=$(node -p "require('./package.json').version")
-restore_version() {
-  npm pkg set version="$ORIGINAL_VERSION" --silent
-}
-trap restore_version EXIT
-
-npm pkg set version="$VERSION" --silent
-
-# ── Build ─────────────────────────────────────────────────────────────────────
-echo "building..."
-npm run build
-
-# ── Dist-tag: prerelease versions get 'next', stable versions get 'latest' ───
-if [[ "$VERSION" =~ -[a-zA-Z] ]]; then
-  DIST_TAG="next"
-else
-  DIST_TAG="latest"
-fi
-
-# ── Publish ───────────────────────────────────────────────────────────────────
-echo "publishing with tag: $DIST_TAG"
-npm publish --access public --tag "$DIST_TAG"
-
-echo "done: $PACKAGE@$VERSION"

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/test/health.spec.js

@@ -1,213 +0,0 @@
-import { expect, should as chaiShould } from "chai";
-import sinon from "sinon";
-import express from "express";
-import { healthCheck as hc } from "../index.js";
-
-const should = chaiShould();
-
-const mockResponse = () => {
-  const res = {};
-  res.status = sinon.stub().returns(res);
-  res.setHeader = sinon.stub();
-  res.json = sinon.stub().returns(res);
-  res.send = sinon.spy();
-  return res;
-};
-
-/* algorithm for shuffling an array */
-const shuffle = (a) => {
-  for (let i = a.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [a[i], a[j]] = [a[j], a[i]];
-  }
-  return a;
-}
-
-describe("HealthCheck Testing", () => {
-  let healthCheck = new hc();
-
-  describe("Health Check Sanity", () => {
-    it ("Should have NO predefined health checks", () => {
-      return expect(healthCheck.healthChecks).to.be.an('array').that.is.empty;
-    });
-
-    it ("Should have have a sane default path route", () => {
-      return expect(healthCheck.defaultPath()).to.match(/health_check/);
-    });
-
-    it ("Should have have sane response defaults", () => {
-      expect(healthCheck.defaultResponse).to.have.property("status", 200);
-      expect(healthCheck.defaultResponse).to.have.property("errors").to.be.an('object').to.be.empty;
-    })
-  });
-
-  describe("Health Check Router", () => {
-    it ("Should throw without a proper router object", () => {
-      expect(healthCheck.routes.bind(healthCheck)).to.throw('missing_express_router');
-    })
-
-    it ("Should return a proper router object with an improved route", () => {
-      let router = express.Router();
-      let improved_router = healthCheck.routes(router);
-      expect(improved_router).to.equal(router);
-    })
-  });
-
-  describe("Check Health Checks", () => {
-    let req, res;
-
-    beforeEach("Setup hc object", () => {
-      res = mockResponse();
-      req = { baseUrl: "server.example.com/api/health_check.json" };
-      healthCheck = new hc();
-    })
-
-    it ("Returns ok with no additional health check routes defined", (done) => {
-      req = { baseUrl: "server.example.com/api/health_check.json" };
-
-      const expectedResult = { check: 1, healthy: "true", message: "success" }
-
-      healthCheck.checkHealth(req, res)
-        .then((r) => {
-          sinon.assert.alwaysCalledWith(res.status, 200);
-          sinon.assert.calledOnce(res.status);
-          sinon.assert.alwaysCalledWith(res.json, expectedResult)
-          done()
-        });
-    })
-
-    it("Returns success with a simple successful (v1) health check defined", (done) => {
-      const sampleCheck = async () => {
-        return { name: "db", "result": "success", critical: false };
-      }
-
-      healthCheck.addCheck(sampleCheck);
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      const expectedResult = { check: 1, healthy: "true", message: "success" }
-      healthCheck.checkHealth(req, res)
-        .then((r) => {
-          sinon.assert.alwaysCalledWith(res.status, 200);
-          sinon.assert.alwaysCalledWith(res.json, expectedResult);
-          done()
-        });
-    })
-
-    it("Returns fail with a failed health check", (done) => {
-      const sampleCheck = async () => {
-        return { name: "db", "result": "fail" };
-      }
-
-      healthCheck.addCheck(sampleCheck);
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      const expectedResult = { check: 1, healthy: "false", message: "fail" }
-      healthCheck.checkHealth(req, res)
-        .then(e => { done() })
-        .catch(err => {
-          sinon.assert.alwaysCalledWith(res.status, 500);
-          sinon.assert.alwaysCalledWith(res.json, expectedResult);
-          done()
-        })
-    })
-
-    it("Returns unhealthy with an OK and failed health check", (done) => {
-      const sampleFail = async () => {
-        return { name: "db", "result": "fail" };
-      }
-
-      const sampleSuccess= async () => {
-        return { name: "redis", "result": "success" };
-      }
-
-      shuffle([sampleFail, sampleSuccess]).forEach(el => {
-        healthCheck.addCheck(el);
-      })
-
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(2);
-
-      healthCheck.checkHealth(req, res)
-        .then(e => { done() })
-        .catch(err => {
-          sinon.assert.alwaysCalledWith(res.status, 500);
-          sinon.assert.alwaysCalledWith(res.json, 'fail');
-          done()
-        })
-    })
-
-    it("Returns healthy/200 when non-critical element fails (v2)", async () => {
-      const sampleCheck= async () => { throw new Error({status: 500}) }
-
-      healthCheck.setupCheck({ name: "sample", critical: false, healthFunction: sampleCheck });
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      await healthCheck.checkHealth(req, res)
-
-      sinon.assert.alwaysCalledWith(res.status, 200);
-
-      const expectedResult = {
-        check: 1,
-        healthy: "true",
-        message: "fail",
-        services: [{ critical: false, name: "sample", result: "fail", status: undefined }]
-      }
-      sinon.assert.alwaysCalledWith(res.json, expectedResult);
-    })
-
-    it("Returns unhealthy/500 when a critical component returns failure (v2)", async () => {
-      const sampleCheck= async () => { throw new Error({status: 500}) }
-
-      healthCheck.setupCheck({ name: "sample", critical: true, healthFunction: sampleCheck });
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(1);
-
-      await healthCheck.checkHealth(req, res)
-
-      const expectedResult = {
-        check: 1, healthy: false,
-        message: "fail",
-        services: [{ critical: true, name: "sample", result: "fail", status: undefined }]
-      }
-      sinon.assert.alwaysCalledWith(res.status, 500);
-      sinon.assert.alwaysCalledWith(res.json, expectedResult);
-    })
-
-    it("Returns unhealthy/500 when a critical component returns failure (v2)", async () => {
-      const sampleCheck= async () => { throw new Error({status: 500}) }
-      const sampleCheck2= async () => { return true }
-
-      healthCheck.setupCheck({ name: "sample", critical: true, healthFunction: sampleCheck });
-      healthCheck.setupCheck({ name: "sample2", critical: true, healthFunction: sampleCheck2 });
-      expect(healthCheck.healthChecks).to.be.an('array').with.lengthOf(2);
-
-      await healthCheck.checkHealth(req, res)
-
-      const expectedResult = {
-        check: 1, healthy: false,
-        message: "fail",
-        services: [
-          { critical: true, name: "sample", result: "fail", status: undefined },
-          { critical: true, name: "sample2", result: "success" }]
-      }
-      sinon.assert.alwaysCalledWith(res.status, 500);
-      sinon.assert.alwaysCalledWith(res.json, expectedResult);
-    })
-
-    it("Returns a different ID each time it runscheck", (done) => {
-      let req2, res2;
-      res2 = mockResponse();
-
-      req = { baseUrl: "server.example.com/api/health_check.json" };
-      req2 = req
-
-      healthCheck.checkHealth(req, res)
-        .then(() => {
-          expect(healthCheck.lastCallId).to.equal(1)
-          healthCheck.checkHealth(req2, res2)
-            .then(() => {
-              expect(healthCheck.lastCallId).to.equal(2)
-              done()
-            })
-        })
-    })
-  })
-});

package/test/prompt.test.js

@@ -1,91 +0,0 @@
-import { expect } from "chai";
-import sinon from "sinon";
-import prompt from "prompt";
-import { ArgumentParser } from 'argparse';
-import logger from "../logger/s4-logger.js";
-
-import { setupCLIParser, cliSleep, promptCLIAsync, commonCLIInit, waitCLIPrompt, continueCLIPrompt } from "../prompts/index.js";
-
-describe("Prompt Functions", () => {
-  describe("Setup Parser", () => {
-    let loggerStub;
-
-    beforeEach(() => {
-      loggerStub = sinon.stub(logger, "info");
-    });
-
-    afterEach(() => {
-      loggerStub.restore();
-    });
-
-    it("should create an ArgumentParser with the given description", () => {
-      const description = "Test Description";
-      const parser = setupCLIParser(description);
-
-      expect(parser).to.be.instanceOf(ArgumentParser);
-      expect(loggerStub.calledWith(description)).to.be.true;
-    });
-  });
-
-  describe("cliSleep", () => {
-    it("should return a promise that resolves after the specified time", async () => {
-      const clock = sinon.useFakeTimers();
-      const ms = 1000;
-
-      const promise = cliSleep(ms);
-      clock.tick(ms);
-
-      await promise;
-      clock.restore();
-    });
-  });
-
-  describe("Prompt Async", () => {
-    let promptStub;
-
-    beforeEach(() => {
-      promptStub = sinon.stub(prompt, "get");
-    });
-
-    afterEach(() => {
-      promptStub.restore();
-    });
-
-    it("should resolve with response when prompt succeeds", async () => {
-      const options = { name: "test" };
-      const mockResponse = { name: "response" };
-
-      promptStub.yields(null, mockResponse);
-
-      const result = await promptCLIAsync(options);
-      expect(result).to.equal(mockResponse);
-      expect(promptStub.calledWith(options)).to.be.true;
-    });
-
-    it("should reject with error when prompt fails", async () => {
-      const options = { name: "test" };
-      const mockError = new Error("Prompt error");
-
-      promptStub.yields(mockError, null);
-
-      try {
-        await promptCLIAsync(options);
-        expect.fail("Should have thrown an error");
-      } catch (error) {
-        expect(error).to.equal(mockError);
-      }
-    });
-  });
-
-  describe("Prompt Objects", () => {
-    it("should define waitPrompt with correct structure", () => {
-      expect(waitCLIPrompt).to.have.property("Push <enter> when done");
-      expect(waitCLIPrompt["Push <enter> when done"]).to.have.property("type", "boolean");
-    });
-
-    it("should define continuePrompt with correct structure", () => {
-      expect(continueCLIPrompt).to.have.property("Push <enter> to continue");
-      expect(continueCLIPrompt["Push <enter> to continue"]).to.have.property("type", "boolean");
-    });
-  });
-});

package/test/s4-formatter.spec.js

@@ -1,80 +0,0 @@
-import should from "should";
-import { expect as expect } from "chai";
-
-import S4Formatter from "../formatter/index.js";
-
-describe("Formatter", function () {
-  let response;
-
-  describe("Sending legacy format []", function () {
-    before("Setup", function () {
-      const error = { status: 200, error: ["error1"] } 
-      response = S4Formatter.formatError(error);
-    })
-
-    describe("Default values", function () {
-      it("should have a generic error", function () {
-        response.should.have.property("errors");
-      });
-
-      it("should have error code set correctly", function () {
-        response.should.have.property("status", 200);
-      });
-    });
-  });
-
-  describe("Support null error payloads", function () {
-    before("Setup", function () {
-      response = S4Formatter.formatError(null);
-    })
-
-    describe("Default values", function () {
-      it("Should have a default error level and blank errors", function () {
-        expect(response).to.have.property("status",422);
-        expect(response).to.have.property("errors").to.be.empty;
-      });
-
-    });
-  });
-
-  describe("Should not fold in funky keys/values", function () {
-    before("Setup", function () {
-      response = S4Formatter.formatError({randomKey: 123});
-    })
-
-    describe("Default values", function () {
-      it("Should not funky key name folded in", function () {
-        response.should.not.have.property("randomKey", {});
-      });
-    });
-  });
-
-  describe("Support validator formats", function () {
-    before("Setup", function () {
-      let error = {
-        "status": 422,
-        "errors": {
-            "password": {
-                "location": "body",
-                "param": "password",
-                "value": "badPassw0rd",
-                "msg": "weak"
-            }
-        }
-      }
-    
-      response = S4Formatter.formatError(error);
-    })
-
-    describe("Default values", function () {
-      it("Should have a default error level and blank errors", function () {
-        response.should.have.property("status", 422);
-        expect(response).to.be.an("object");
-        expect(response).to.have.property('errors');
-        expect(Object.keys(response['errors'])).to.have.lengthOf('1')
-        response.should.have.property("errors");
-      });
-
-    });
-  });
-})