@sera4/essentia 1.1.64 → 1.1.66-rc.1

package/paper-trail/index.js

@@ -1,4 +1,5 @@
-import * as jsdiff from 'diff';
+import { createRequire } from 'module';
+const jsdiff = createRequire(import.meta.url)('diff');
 import _ from 'lodash';
 import helpers from './helpers.js';
 import paginator from "../paginator/sql-pagination.js";
@@ -297,35 +298,42 @@ paperTrail.init = (sequelize, sequelizePackage, optionsArg) => {
 						);
 				}
 
-				let objectsChanged = new Set();
-				// if the previous version or new version contain objects; push them onto this list
-				_.forEach(previousVersion, (value, key) => {
-					if (typeof(value) === 'object' ) {
-						objectsChanged.add(key);
-						// blank it so we can set it equal to ONLY the values changed in the next segment
-						previousVersion[key] = {};
-					}
-				});
-				_.forEach(currentVersion, (value, key) => {
-					if (typeof(value) === 'object' ) {
-						objectsChanged.add(key);
-						currentVersion[key] = {};
-					}
-				});
+				// For create/restore, keep full currentVersion (including JSONB/plain objects) so
+				// the revision document has complete newValues. For update, blank object values
+				// and repopulate only from delta so we store minimal nested changes.
+				const blankObjectsAndApplyDelta = !createOperation && !restoreOperation;
+
+				if (blankObjectsAndApplyDelta) {
+					let objectsChanged = new Set();
+					// if the previous version or new version contain objects; push them onto this list
+					_.forEach(previousVersion, (value, key) => {
+						if (typeof(value) === 'object' ) {
+							objectsChanged.add(key);
+							// blank it so we can set it equal to ONLY the values changed in the next segment
+							previousVersion[key] = {};
+						}
+					});
+					_.forEach(currentVersion, (value, key) => {
+						if (typeof(value) === 'object' ) {
+							objectsChanged.add(key);
+							currentVersion[key] = {};
+						}
+					});
 
 
-				// we don't want to see a full object; we want to see only
-				// x.y.z -> value
-				if (delta && objectsChanged.size > 0 ) {
-					// the format of these are A,E,D,N (added, edited, deleted, new) for the kind
-					// the array is either the key or key + subkeys ['options','subkey','subkey2'] etc.
-					// {kind: 'E', path: Array(2), lhs: false, rhs: true}
-					for (const difference of delta) {
-						// blank the currentVersion[difference.path[0]]
-						// and previousVersion[difference.path[0]]
-						_.set(currentVersion, difference.path, difference.rhs);
-						_.set(previousVersion, difference.path, difference.lhs);
-					};
+					// we don't want to see a full object; we want to see only
+					// x.y.z -> value
+					if (delta && objectsChanged.size > 0 ) {
+						// the format of these are A,E,D,N (added, edited, deleted, new) for the kind
+						// the array is either the key or key + subkeys ['options','subkey','subkey2'] etc.
+						// {kind: 'E', path: Array(2), lhs: false, rhs: true}
+						for (const difference of delta) {
+							// blank the currentVersion[difference.path[0]]
+							// and previousVersion[difference.path[0]]
+							_.set(currentVersion, difference.path, difference.rhs);
+							_.set(previousVersion, difference.path, difference.lhs);
+						};
+					}
 				}
 
 				let document;

package/queue/index.js

@@ -1,5 +1,5 @@
 "use strict";
-import amqp from "amqplib/callback_api.js";
+import amqp from "amqplib";
 import logger from "./queue-logger.js";
 import urlParse from "url-parse";
 import { Publisher } from "./publisher.js";
@@ -11,6 +11,7 @@ import { Subscriber } from "./subscriber.js";
 class S4Queue {
   constructor() {
     this.connection = null;
+    this.connectionTestChannel = null;
     this.retry = 10;
     this.pubs = {};
     this.subs = {};
@@ -30,15 +31,20 @@ class S4Queue {
   async testConnection() {
     if (!this.isConnected()) {
       this.connectionTestChannel = null;
-      throw("queue service not connected")
+      throw new Error("queue service not connected");
     }
 
-    this.connectionTestChannel = this.connectionTestChannel || await this.connection.createChannel();
     if (!this.connectionTestChannel) {
-      throw("queue service failed to obtain a channel")
+      const ch = await this.connection.createChannel();
+      if (!ch) {
+        throw new Error("queue service failed to obtain a channel");
+      }
+      ch.on("error", () => { this.connectionTestChannel = null; });
+      ch.on("close", () => { this.connectionTestChannel = null; });
+      this.connectionTestChannel = ch;
     }
 
-    await this.connectionTestChannel.assertExchange("--health-check--", "topic", {durable: false});
+    await this.connectionTestChannel.assertExchange("--health-check--", "topic", { durable: false });
   }
 
   /**
@@ -56,60 +62,51 @@ class S4Queue {
     const retry = parseInt(options.retryInterval);
     this.retry = retry || 10;
 
-    logger.debug("Attempting connection...");
+    // We may run into issues with SNI TLS if
+    // we host with 3rd parties using our own certs.
+    // To avoid any issues, let's parse the url
+    // and provide the server name in the socket options
+    const urlParts = urlParse(options.connectionUrl);
+    const socketOptions = { servername: urlParts.hostname };
 
-    // The docs say there is amqp.connect returning
-    // a promise, but this version doesn't seem to like
-    // when a callback isn't provided, therefore run
-    // in a new Promise
-    return new Promise((resolve, reject) => {
-      // We may run into issues with SNI TLS if
-      // we host with 3rd parties using our own certs.
-      // To avoid any issues, let's parse the url
-      // and provide the server name in the socket options
-      const urlParts = urlParse(options.connectionUrl);
-      const socketOptions = {servername: urlParts.hostname};
+    return new Promise((resolve) => {
+      const attempt = async () => {
+        logger.debug("Attempting connection...");
+        try {
+          const conn = await amqp.connect(options.connectionUrl, socketOptions);
 
-      amqp.connect(options.connectionUrl, socketOptions, (err, conn) => {
+          this.connection = conn;
+          this.updatePubsAndSubsConnectionRef(conn);
 
-        if (err) {
-          logger.error("Error while connecting", err)
+          this.connection.on("error", (err) => {
+            logger.error("connection error", err);
+            // Do not attempt to reconnect as the
+            // 'close' event will also be emitted
+            // if this error closes the connection
+          });
+
+          this.connection.on("close", (err) => {
+            logger.error("connection closed");
+            this.connection = null;
+            this.connectionTestChannel = null;
+            if (err) {
+              logger.error("connection closed due to error:", err);
+              logger.error("Reconnecting in", this.retry, "seconds");
+              setTimeout(attempt, this.retry * 1000);
+            } else {
+              logger.debug("Will not re-attempt");
+            }
+          });
+
+          logger.debug("Connected");
+          resolve();
+        } catch (err) {
+          logger.error("Error while connecting", err);
           logger.error("Attempting again in", this.retry, "seconds");
-          return setTimeout(() => this.openConnection(options), this.retry * 1000);
+          setTimeout(attempt, 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) => {
-          logger.error("connection error", err);
-          // Do not attempt to reconnect as the
-          // 'close' event will also be emitted
-          // if this error closes the connection
-        });
-
-        this.connection.on("close", (err) => {
-          logger.error("connection closed");
-          this.connection = null;
-          if (err) {
-            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
-            // this connection, thus a reconnection will not
-            // be attempted.
-            logger.debug("Will not re-attempt");
-          }
-        });
-
-        logger.debug("Connected");
-        resolve();
-      });
+      };
+      attempt();
     });
   }
 
@@ -119,21 +116,12 @@ class S4Queue {
    * and subscribers
    */
   async closeConnection() {
-    return new Promise((resolve, reject) => {
-      if (!this.connection) {
-        return resolve();
-      }
-      this.connection.close((err) => {
-        if (err) {
-          reject(err);
-        } else {
-          this.subs = {};
-          this.pubs = {};
-          this.connection = null;
-          resolve();
-        }
-      });
-    });
+    if (!this.connection) return;
+    await this.connection.close();
+    this.subs = {};
+    this.pubs = {};
+    this.connectionTestChannel = null;
+    this.connection = null;
   }
 
   /**

package/scripts/publish.sh

@@ -0,0 +1,46 @@
+#!/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/test/health.spec.js

@@ -0,0 +1,213 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,80 @@
+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");
+      });
+
+    });
+  });
+})