@sera4/essentia 1.0.38 → 1.0.39

package/cache/index.js

@@ -0,0 +1,188 @@
+"use strict"
+
+import { promisify } from "util";
+
+const isEmpty = obj => [Object, Array].includes((obj || {}).constructor) && !Object.entries((obj || {})).length;
+
+class CacheConfigError extends Error {
+  constructor(m) {
+    super(m);
+  }
+}
+
+/* Redis cache helper
+ * Example use: Place the following code in your project to setup redis use
+ *
+ *    import { cache } from "@sera4/essentia";
+ *    const cacheHelper = cache({ password: .., database: .., host: .., port: .. }, "service:"));
+ *
+ */
+
+const convertRedisKeyValueToJson = (v) => {
+  return (v && v.length > 0 && v[0] !== null) ? JSON.parse(v) : null;
+}
+
+const convertRedisHashToJson = (v) => {
+  if (v) {
+    var result = {};
+    for(var k in v) {
+      if (v.hasOwnProperty(k)) {
+        result[k] = JSON.parse(v[k]);
+      }
+    }
+    return result;
+  } else {
+    return null;
+  }
+}
+
+function convertJsonToRedisValue(j) {
+  var result = {};
+  for (var key in j) {
+    if (j.hasOwnProperty(key)) {
+      result[key] = JSON.stringify(j[key]);
+    }
+  }
+  return result;
+}
+
+class Cache {
+  constructor(config, servicePrefix) {
+    if ((config == undefined) || isEmpty(config)) {
+      throw new CacheConfigError("Invalid cache configuration");
+    }
+
+    if (servicePrefix == null) {
+      throw new CacheConfigError("Invalid service prefix");
+    }
+
+    if (config.fake) {
+      // used in testing
+      this.redisClient = require("fakeredis").createClient("fake backend")
+    } else {
+      this.redisClient = require("redis").createClient(config);
+    }
+
+    this.redisClient.on("error", (err) => {
+      logger.error("Cache/Redis error: ", err);
+    });
+
+    this.servicePrefix = servicePrefix;
+  }
+
+  ping() {
+    return this.redisClient.ping();
+  }
+
+  properKey(key, path) {
+    let p = this.servicePrefix + key
+    if (path)
+      p += path
+    return p
+  }
+
+  writeHash(path, key, value) {
+    return this.redisClient.hsetAsync(properKey(key), key, value);
+  }
+
+  writeHashBlocking(path, key, value) {
+    return this.redisClient.hset(properKey(key), key, value);
+  }
+
+  // write multiple hash keys and stringify every value
+  writeMultiHash(path, j) {
+    return this.redisClient.hmsetAsync(properKey(key), convertJsonToRedisValue(j));
+  }
+
+  readHashKey(obj, key, autoConvert=true) {
+    var k = autoConvert;
+
+    return new Promise((resolve, reject) => {
+      this.redisClient.hget(properKey(key, obj), key, (e, r) => {
+        if (e) {
+          logger.error("Redis hmget error:", e);
+          reject(e);
+        } else {
+          resolve(k ? convertRedisKeyValueToJson(r) : r);
+        }
+      });
+    });
+  }
+
+  readHash(path) {
+    return new Promise((resolve, reject) => {
+      this.redisClient.hgetall(properKey(key, path), (e, r) => {
+        if (e) {
+          console.log("Redis hget error:", e);
+          reject(e);
+        } else {
+          resolve(convertRedisHashToJson(r));
+        }
+      });
+    });
+  }
+
+  deleteHashKey(hash, key) {
+    return new Promise((resolve, reject) => {
+      this.redisClient.hdel(properKey(key, hash), key, (err) => {
+        if (err) {
+          logger.error("Redis hdel error:", err);
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+  }
+
+  get(key) {
+    return this.redisClient.getAsync(properKey(key));
+  }
+
+  getAsync(key) {
+    return promisify(this.redisClient.get(key)).bind(this.redisClient)
+  }
+
+
+  /* a single key write with optional expiry */
+  // returns bluebird promise
+  writeKey(key, value, expiry) {
+    key = this.servicePrefix + key;
+    if (expiry) {
+      return this.redisClient.setAsync(key, value, "EX", expiry);
+    } else {
+      return this.redisClient.setAsync(key, value);
+    }
+  }
+
+  deleteKey(key) {
+    return redisClient.delAsync(properKey(key));
+  }
+
+  expire(path, expiry) {
+    return this.redisClient.expire(path, expiry);
+  }
+
+  exists(path) {
+    return this.redisClient.exists(path);
+  }
+
+  deleteAllKeys() {
+    return new Promise((resolve, reject) => {
+      if(process.env.NODE_ENV === "production") {
+        throw new Error("Clearing system cache is not permitted in production");
+      }
+      this.redisClient.flushdb((err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(res);
+        }
+      });
+    });
+  }
+}
+
+export default function(config, servicePrefix) {
+  return new Cache(config, servicePrefix)
+}

package/health/index.js

@@ -35,7 +35,8 @@ class HealthCheck {
     this.healthChecks = [];
   }
 
-  /* call this with an async function, must support wait capability
+  /* 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 };
@@ -62,12 +63,15 @@ class HealthCheck {
     return router
   }
 
-  // v2 version of health check
+  // 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 */
+  /* performs health checks and returns 200 if true and 500 if not */ 
   async checkHealth(req, res) {
     const checkFormat = pathHelper.extname(req.baseUrl);
 
@@ -82,7 +86,7 @@ class HealthCheck {
       } else {
         let res = { name: hc.name, critical: hc.critical }
         try {
-          return await hc.healthFunction();
+          await hc.healthFunction();
           return { ...res, "result": "success" };
         } catch(e) {
           return { ...res, "result": "fail", status: e.status } 
@@ -148,6 +152,7 @@ class HealthCheck {
         res.status(status).send(status_message);
       }
     } catch(error) {
+      console.debug("error: ", error)
       res.status(500).send();
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sera4/essentia",
-  "version": "1.0.38",
+  "version": "1.0.39",
   "description": "A library of utilities for Teleporte Web Services",
   "main": "index.js",
   "scripts": {