@sera4/essentia 1.1.66-rc.1 → 3.0.8

package/health/index.js

@@ -1,188 +0,0 @@
-"use strict"
-
-import pathHelper from "path";
-import logger from "./health-logger.js";
-import morgan from "morgan";
-
-class HealthCheckError extends Error {}
-
-/* Health Checking router + controller for use in all of our modules
- * Example use: Place the following code in your routes file
- *
- *    import { healthCheck } from "@sera4/essentia";
- *    const router = require('express').Router();
- *
- *      ....
- *
- *    const checkRedis = async () => { await cache.ping(); }
- *    hc.setupCheck({ name: "redis", checkResult: false, critical: true, healthFunction: checkRedis });
- *    app.use(hc.defaultPath(serverConfigs.api_prefix), hc.routes(router));
- *
- */
-class HealthCheck {
-  constructor(appendData = {}, enableLogging = true) {
-    logger.setEnabled(enableLogging);
-
-    this.defaultResponse = {
-      ...
-      appendData,
-      status: 200,
-      errors: {}
-    };
-
-    this.defaultPathRoute = `health_check\(.*\)?`
-    this.suppressLogs = false;
-    this.lastCallId = 0; // default start point/integer
-    this.pathPrefix = "";
-    this.healthChecks = [];
-  }
-
-  /* Deprecated and replaced by setupCheck
-   *   call this with an async function, must support wait capability
-   *
-   *   const dbCheck = async () => {
-   *     return { name: "db", "result": "success", critical: false };
-   *   }
-   */
-  addCheck(fcn) {
-    this.healthChecks.push(fcn);
-  }
-
-  setPrefix(prefix) {
-    this.pathPrefix = prefix;
-  }
-
-  defaultPath(prefix = "") {
-    if (prefix === "") {
-      prefix = this.pathPrefix; // maybe setup manually
-    }
-    return `${prefix}/${this.defaultPathRoute}`
-  }
-
-  routes(router) {
-    if (!router) {
-      throw new HealthCheckError("missing_express_router");
-    }
-
-    /* definition of all routes, rooted at defaultPath */
-    router.get('/', (req, res) => {
-      this.checkHealth(req, res)
-    });
-
-    return router
-  }
-
-  suppressHealthCheckLog(app) {
-    // Custom morgan skip function to ignore health check logging
-    console.log("skip: ", this.defaultPath())
-    app.use(morgan('combined', {
-      skip: (req) => req.path === defaultPath()
-    }));
-  }
-
-  // v2 version of health check, replaced addCheck
-  // example:
-  //  const checkRedisFcn = async () => { await cache.ping().then(() => true) }
-  //  setupCheck({ name: "redis", checkResult: false, critical: false, healthFunction: checkRedisFcn });
-  setupCheck(config) {
-    this.healthChecks.push(config);
-  }
-
-  /* performs health checks and returns 200 if true and 500 if not */
-  async checkHealth(req, res) {
-    const checkFormat = pathHelper.extname(req.baseUrl);
-
-    const result = await Promise.all(this.healthChecks.map(async hc => {
-      if (typeof(hc) === "function") {
-        try {
-          return await hc();
-        } catch(e) {
-          return  { name: "unknown", result: 'fail', status: e.status }
-        }
-      } else {
-        let res = { name: hc.name, critical: hc.critical }
-        try {
-          const result = await hc.healthFunction();
-          if (typeof(result) === "boolean") {
-            if (result === false) {
-              res = {"result": "fail", ...res }
-            } else {
-              res = {"result": "success", ...res }
-            }
-          } else {
-            res = {"result": "success", ...res }
-          }
-          return res;
-        } catch(e) {
-          const appendStatus = e.status ? ` (${e.status})` : ""
-          logger.warn(`${hc.name} service failed${appendStatus}` )
-          return { ...res, "result": "fail", status: e.status }
-        }
-      }
-    }));
-
-    try {
-      let callId = ++this.lastCallId;
-
-      // start the counter over
-      if ((callId % (1 << 30)) === 0) {
-        callId = this.lastCallId = 1;
-      }
-
-      let status = this.defaultResponse.status;
-
-      let nonCriticalFail = false;
-      let criticalFail = false;
-
-      result.some(e => {
-        if (e.result.match(/fail/)) {
-          if (e.critical === false) {
-            nonCriticalFail = true;
-          } else {
-            criticalFail = true;
-            status = 500;
-            return true; // break
-          }
-        }
-      })
-
-      // set this in the header no matter what
-      res.setHeader('check', callId)
-
-      if (checkFormat === ".json") {
-        const payload = { "check": callId, healthy: "true", message: "success" }
-
-        if (criticalFail) {
-          res.status(status).json({
-            ... payload,
-            "healthy": false,
-            "message": "fail",
-            "services": result
-          });
-        } else if (nonCriticalFail) {
-          res.status(status).json({
-            ... payload,
-            "message": "fail",
-            "services": result
-          });
-        } else if (status === 200) {
-          res.status(status).json(payload);
-        }
-      } else {
-        let status_message;
-        if (criticalFail) {
-          status_message = "fail"
-        } else if ((status === 200) || nonCriticalFail) {
-          status_message = "success"
-        }
-
-        res.status(status).send(status_message);
-      }
-    } catch(error) {
-      console.warn("error: ", error)
-      res.status(500).send();
-    }
-  }
-}
-
-export { HealthCheck };

package/helpers/index.js

@@ -1 +0,0 @@
-export * from "./test-server-wrapper.js";

package/helpers/test-server-wrapper.js

@@ -1,196 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-import fs from "fs";
-
-const s4Domain = "sera4.com";
-const mobileDomain = "tws-mob." + s4Domain;
-const webDomain = "tws-web." + s4Domain;
-
-/**
- * A small wrapper around an express js server
- * meant to be used in unit tests
- */
-export class TestServerWrapper {
-
-  constructor(apiPrefix, expressServer, defaultHeaders, oldAuthToken, routePrinter, chai, factory) {
-    this.server = expressServer;
-    this.defaultHeaders = defaultHeaders;
-    this.apiPrefix = apiPrefix;
-    this.routePrinter = routePrinter;
-    this.chai = chai;
-    this.mobileDomain = mobileDomain;
-    this.webDomain = webDomain;
-    this.factory = factory;
-
-    // Support for older/deprecated apis
-    const oldAuthHeaders = {headers: {"Authorization" : `Token organization_token=${oldAuthToken}`}};
-    this.v1 = {
-      get: (url) => this.getWithPrefix("/v1", url, oldAuthHeaders),
-      post: (url) => this.postWithPrefix("/v1", url, oldAuthHeaders),
-      put: (url) => this.putWithPrefix("/v1", url, oldAuthHeaders),
-      delete: (url) => this.deleteWithPrefix("/v1", url, oldAuthHeaders)
-    }
-  }
-
-  /**
-   * Adds a leading slash to the url if missing
-   * @param {String} url the url to sanitize
-   * @returns sanitized url
-   */
-  sanitizeUrl (url) {
-    // add leading slash if missing
-    if (!url.startsWith("/")) {
-      return "/" + url;
-    } else {
-      return url;
-    }
-  }
-
-  /**
-   * Apply given headers to the request object
-   * @param {Object} request
-   * @param {Object} headers
-   */
-  applyHeaders (request, headers) {
-    Object.keys(headers).map(k => {
-      request.set(k, headers[k]);
-    });
-  }
-
-  get (url, options) {
-    return this.getWithPrefix(this.apiPrefix, url, options);
-  }
-
-  getWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).get(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    if (options?.body) {
-      request.send(options.body);
-    }
-    return request;
-  }
-
-  post (url, options) {
-    return this.postWithPrefix(this.apiPrefix, url, options);
-  }
-
-  postWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).post(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    return request;
-  }
-
-  put (url, options) {
-    return this.putWithPrefix(this.apiPrefix, url, options);
-  }
-
-  putWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).put(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    return request;
-  }
-
-  delete (url, options) {
-    return this.deleteWithPrefix(this.apiPrefix, url, options);
-  }
-
-  deleteWithPrefix (prefix, url, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).delete(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    return request;
-  }
-
-  upload ( url, fields, file, options) {
-    return this.uploadWithPrefix(this.apiPrefix, url, fields, file, options);
-  }
-
-  uploadWithPrefix (prefix, url, fields, file, options) {
-    const sanitizedUrl = this.sanitizeUrl(url);
-    const request = this.chai.request(this.server).post(`${prefix}${sanitizedUrl}`);
-    this.applyHeaders(request, this.defaultHeaders);
-
-    if (options?.headers) {
-      this.applyHeaders(request, options.headers);
-    }
-
-    request.attach("data", fs.readFileSync(file), {filename: "data"});
-    const keys = Object.keys(fields);
-    keys.forEach(k => {
-      request.field(k, fields[k]);
-    });
-    return request;
-  }
-
-  stop () {
-    this.server.close();
-  }
-
-  allRoutes () {
-    return this.routePrinter.getAll();
-  }
-
-  withHeaders (headers) {
-    return {
-      get: (url, options) => this.get(url, {headers, ...options}),
-      post: (url, options) => this.post(url, {headers, ...options}),
-      put: (url, options) => this.put(url, {headers, ...options}),
-      delete: (url, options) => this.delete(url, {headers, ...options}),
-      upload: (url, fields, file, options) => this.upload(url, fields, file, {headers, ...options}),
-      stop: this.stop,
-      allRoutes: this.allRoutes,
-      v1: this.v1
-    }
-  }
-
-  // setup
-  async setMembership (membership, addlHeaders) {
-    let headers;
-
-    if (membership) {
-      headers = { "tws-account-id" : membership.account_id, "tws-membership-id": membership.id, "tws-tenant-id" : membership.tenant_id };
-    } else {
-      // auto create an s4 user
-      const m = await this.factory.create("membership", { s4Admin: true })
-      headers = { "tws-account-id" : m.account_id, "tws-membership-id": m.id, "tws-tenant-id" : m.tenant_id };
-    }
-
-    headers = { ...headers, "tws-request-host": this.webDomain, ...addlHeaders }
-    return this.withHeaders(headers);
-  };
-
-  withMembership (m) {
-    const h = { "tws-membership" : JSON.stringify(m) }
-    return this.withHeaders(h);
-  }
-
-  withS4 () {
-    return this.withMembership({s4_role: 1, id: uuidv4(), account_id: uuidv4(), tenant_id: uuidv4()});
-  }
-
-  withTap() {
-    return this.withMembership({s4_role: 2, id: uuidv4(), account_id: uuidv4(), tenant_id: uuidv4()});
-  }
-}

package/last-commit.js

@@ -1,12 +0,0 @@
-"use strict";
-import lastCommit from "./last_commit/index.js"
-
-lastCommit.writeLastCommit()
-.then(c => {
-  console.debug("Last commit written");
-  console.debug(c);
-})
-.catch(e => {
-  console.error("Failed to write last commit");
-  console.error(e);
-})

package/last_commit/index.js

@@ -1,82 +0,0 @@
-"use strict";
-
-import git from "git-rev";
-import fs from "fs";
-import async from "async";
-import { dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const appDir = dirname(fileURLToPath(import.meta.url));
-const commitFile = `${appDir}/last-commit.json`;
-
-const lastCommit = {
-  parseLastCommit() {
-    return new Promise((resolve, reject) => {
-      async.waterfall([
-        (next) => {
-          var commit = {};
-          git.branch((str) => {
-            commit["branch"] = str;
-            next(null, commit);
-          });
-        },
-        (commit, next) => {
-          git.long((str) => {
-            commit["commmit"] = str;
-            next(null, commit);
-          });
-        }
-      ], (err, commit) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(commit);
-        }
-      })
-    })
-  },
-  getLastCommit() {
-    return new Promise((resolve, reject) => {
-      fs.readFile(commitFile, 'utf8', (err, data) => {
-        if (err) {
-          reject(err);
-        } else {
-          try {
-            var commit = JSON.parse(data);
-            resolve(commit);
-          } catch (e) {
-            reject(e);
-          }
-        }
-      });
-    });
-  },
-  getLastCommitSync() {
-    var data = fs.readFileSync(commitFile, 'utf8');
-    return JSON.parse(data);
-  },
-  writeLastCommit() {
-    return new Promise((resolve, reject) => {
-      async.waterfall([
-        (next) => {
-          this.parseLastCommit()
-          .then((commit) => next(null, commit))
-          .catch(e => next(e));
-        },
-        (commit, next) => {
-          fs.writeFile(commitFile, JSON.stringify(commit, null, 2), 'utf8', (err) => {
-            next(err, commit);
-          });
-        }
-      ],(err, commit) => {
-        if (err) {
-          reject(err);
-        } else {
-          resolve(commit);
-        }
-      })
-    });
-  }
-}
-
-export default lastCommit;

package/logger/s4-logger.js

@@ -1,128 +0,0 @@
-import winston from "winston";
-import util from "util";
-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;
-    const level = info[Symbol.for('level')];
-    const args = info[Symbol.for('splat')];
-    const strArgs = args ? args.map(jsonStringify).join(' ') : "";
-    info[Symbol.for('message')] = colorizer.colorize(level, `${level}:\t`) + `${message} ${strArgs}`;
-    return info;
-  }
-};
-
-const defaultTransport = new winston.transports.Console({
-  format: devFormat,
-  level: 'trace'
-});
-
-const logger = winston.createLogger({
-  levels: levels,
-  level: defaultLevel,
-  defaultMeta: { },
-  transports: [defaultTransport]
-});
-
-class S4Logger {
-  configure(options) {
-    if (!options) {
-      return;
-    }
-
-    this.setLevel(options.level);
-
-    logger.defaultMeta.service = options.service;
-    switch(options.format.toLowerCase()) {
-      case "logstash":
-        defaultTransport.format = winston.format.logstash();
-        break;
-      case "json":
-        defaultTransport.format = winston.format.json();
-        break;
-      default:
-        defaultTransport.format = devFormat;
-        break;
-    }
-  }
-
-  setLevel(level) {
-    if (level && ["trace", "debug", "info", "error", "warn"].indexOf(level.toLowerCase())) {
-      logger.level = level;
-    }
-  }
-
-  mute() {
-    logger.transports.forEach(t => {
-      t.silent = true;
-    });
-  }
-
-  unmute() {
-    logger.transports.forEach(t => {
-      t.silent = false;
-    });
-  }
-
-  trace(...args) {
-    logger.trace(util.format(...args));
-  }
-
-  debug(...args) {
-    logger.debug(util.format(...args));
-  }
-
-  log(...args) {
-    logger.debug(util.format(...args));
-  }
-
-  warn(...args) {
-    logger.warn(util.format(...args));
-  }
-
-  info(...args) {
-    logger.info(util.format(...args));
-  }
-
-  error(...args) {
-    logger.error(util.format(...args));
-  }
-
-  getStream() {
-    return {
-      write: function(message, encoding){
-        logger.info(message);
-      }
-    }
-  }
-}
-
-const s4logger = new S4Logger();
-export default s4logger;