@go-mailer/jarvis 10.4.2 → 10.5.0

package/index.js

@@ -10,6 +10,8 @@ const { RequestLogger, ProcessLogger } = require('./lib/middlewares/logger')
 const Utility = require('./lib/utilitiy/index')
 const { HTTPCacheManager } = require('./lib/middlewares/cache/manager')
 const { AutoHealer } = require('./lib/middlewares/healer')
+const { localCache } = require('./lib/redis/cache')
+const { QueueThrottler } = require('./lib/queue/throttler')
 
 module.exports = {
   APIClient,
@@ -20,8 +22,10 @@ module.exports = {
   FeatureFlag,
   HTTP,
   HTTPCacheManager,
+  localCache,
   ProcessLogger,
   QueryBuilder,
+  QueueThrottler,
   Redis,
   RequestLogger,
   Utility

package/lib/middlewares/auth.js

@@ -120,8 +120,8 @@ const authorizeUser = ({ action, resource }) => {
       const has_authority = localCache.get_item(key)
       if (has_authority == null) {
         const is_permitted = await checkAuthority({ action, resource, tenant_id, user_id })
-        localCache.add_item(key,  is_permitted, 15 * 60)
-      } else if (has_authority === false){
+        localCache.add_item(key, is_permitted, 15 * 60)
+      } else if (has_authority === false) {
         throw new Error('Unauthorized')
       }
 

package/lib/middlewares/cache/manager.js

@@ -1,104 +1,104 @@
-const { EntityId } = require("redis-om");
-const { RedisClient } = require("../../redis");
-const { HTTPCache } = require("./schema");
+const { EntityId } = require('redis-om')
+const { RedisClient } = require('../../redis')
+const { HTTPCache } = require('./schema')
 
 const HTTPCacheManager = () => {
   const clearCache = async (request, response, next) => {
-    const { tenant_id, cache_resource } = request;
-    if (isNaN(tenant_id)) return next();
+    const { tenant_id, cache_resource } = request
+    if (isNaN(tenant_id)) return next()
 
-    const repo = await RedisClient.register_schema(HTTPCache);
+    const repo = await RedisClient.register_schema(HTTPCache)
     const cached_records = await repo
       .search()
-      .where("tenant_id")
+      .where('tenant_id')
       .equals(Number(tenant_id))
-      .where("resource")
+      .where('resource')
       .equals(cache_resource)
-      .returnAll();
+      .returnAll()
     for (const cached_record of cached_records) {
-      await repo.remove(cached_record[EntityId]);
+      await repo.remove(cached_record[EntityId])
     }
-    next();
-  };
+    next()
+  }
 
   const clearCacheByResource = async (tenant_id, cache_resource) => {
-    const repo = await RedisClient.register_schema(HTTPCache);
+    const repo = await RedisClient.register_schema(HTTPCache)
     const cached_records = await repo
       .search()
-      .where("tenant_id")
+      .where('tenant_id')
       .equals(Number(tenant_id))
-      .where("resource")
+      .where('resource')
       .equals(cache_resource)
-      .returnAll();
+      .returnAll()
     for (const cached_record of cached_records) {
-      await repo.remove(cached_record[EntityId]);
+      await repo.remove(cached_record[EntityId])
     }
-  };
+  }
 
   const handleRequest = async (request, response, next) => {
-    const { tenant_id, cache_key } = request;
-    if (isNaN(tenant_id)) return next();
+    const { tenant_id, cache_key } = request
+    if (isNaN(tenant_id)) return next()
 
-    const repo = await RedisClient.register_schema(HTTPCache);
-    let cached_record = await repo
+    const repo = await RedisClient.register_schema(HTTPCache)
+    const cached_record = await repo
       .search()
-      .where("tenant_id")
+      .where('tenant_id')
       .equals(Number(tenant_id))
-      .where("key")
+      .where('key')
       .equals(cache_key)
-      .returnFirst();
+      .returnFirst()
 
-    let payload = {};
+    let payload = {}
     if (cached_record) {
-      payload = JSON.parse(cached_record.data);
-      return response.status(payload.status_code).json(payload);
+      payload = JSON.parse(cached_record.data)
+      return response.status(payload.status_code).json(payload)
     }
 
-    next();
-  };
+    next()
+  }
 
   const save = async (request, __, next) => {
-    const { tenant_id, cache_key, cache_resource, payload } = request;
-    if (isNaN(tenant_id)) return next();
+    const { tenant_id, cache_key, cache_resource, payload } = request
+    if (isNaN(tenant_id)) return next()
 
     if (payload.status_code >= 200 && payload.status_code < 300) {
-      const repo = await RedisClient.register_schema(HTTPCache);
+      const repo = await RedisClient.register_schema(HTTPCache)
 
       let cached_record = await repo
         .search()
-        .where("tenant_id")
+        .where('tenant_id')
         .equals(Number(tenant_id))
-        .where("key")
+        .where('key')
         .equals(cache_key)
-        .returnFirst();
+        .returnFirst()
 
       const data_to_cache = {
         tenant_id: Number(tenant_id),
         key: cache_key,
         resource: cache_resource,
-        data: JSON.stringify(payload),
-      };
+        data: JSON.stringify(payload)
+      }
 
       if (cached_record) {
-        await repo.save(cached_record[EntityId], data_to_cache);
+        await repo.save(cached_record[EntityId], data_to_cache)
       } else {
-        cached_record = await repo.save(data_to_cache);
-        await repo.expire(cached_record[EntityId], 10 * 60);
+        cached_record = await repo.save(data_to_cache)
+        await repo.expire(cached_record[EntityId], 10 * 60)
       }
     }
 
-    next();
-  };
+    next()
+  }
 
   const setup = (request, __, next) => {
-    const { _parsedUrl, body } = request;
-    const resource = _parsedUrl.pathname.split("/")[1];
-    request.cache_key = request.originalUrl + "&" + JSON.stringify(body);
-    request.cache_resource = resource;
-    next();
-  };
+    const { _parsedUrl, body } = request
+    const resource = _parsedUrl.pathname.split('/')[1]
+    request.cache_key = request.originalUrl + '&' + JSON.stringify(body)
+    request.cache_resource = resource
+    next()
+  }
 
-  return { clearCache, clearCacheByResource, handleRequest, save, setup };
-};
+  return { clearCache, clearCacheByResource, handleRequest, save, setup }
+}
 
-module.exports = { HTTPCacheManager };
+module.exports = { HTTPCacheManager }

package/lib/middlewares/cache/schema.js

@@ -1,12 +1,12 @@
-const { Schema } = require("redis-om");
+const { Schema } = require('redis-om')
 
-const HTTPCache = new Schema("httpcache", {
-  data: { type: "string" },
-  key: { type: "string" },
-  resource: { type: "string" },
-  tenant_id: { type: "number" },
-});
+const HTTPCache = new Schema('httpcache', {
+  data: { type: 'string' },
+  key: { type: 'string' },
+  resource: { type: 'string' },
+  tenant_id: { type: 'number' }
+})
 
 module.exports = {
-  HTTPCache,
-};
+  HTTPCache
+}

package/lib/middlewares/healer.js

@@ -1,12 +1,7 @@
-const cron = require("node-cron");
+const cron = require('node-cron')
 
-function AutoHealer(timer = "******", handler = () => {}) {
-  const execute = async (request, response, next) => {
-    cron.schedule(timer, () => handler(...handler.arguments, request, response));
-    next();
-  };
-
-  return execute;
+function AutoHealer (timer = '* * * * * *', handler = () => {}) {
+  cron.schedule(timer, handler)
 }
 
-module.exports = { AutoHealer };
+module.exports = { AutoHealer }

package/lib/queue/throttler.js

@@ -0,0 +1,29 @@
+class QueueThrottler {
+  constructor (concurrency = 25) {
+    this.concurrency = concurrency
+    this.isEmpty = true
+    this.tasks = new Map()
+  }
+
+  addTask (key, value) {
+    if (!key || !value || this.tasks.size === this.concurrency || this.tasks.has(key)) return
+
+    this.tasks.set(key, value)
+    this.isEmpty = false
+  }
+
+  getTask (key) {
+    return this.tasks.get(key)
+  }
+
+  getTaskCount () {
+    return this.tasks.size
+  }
+
+  removeTask (key) {
+    this.tasks.delete(key)
+    this.isEmpty = this.tasks.size === 0
+  }
+}
+
+module.exports = { QueueThrottler }

package/lib/redis/cache.js

@@ -3,13 +3,13 @@ class LocalCache {
     this.cache = new Map()
   }
 
-  add_item (key='', value, duration) {
+  add_item (key = '', value, duration) {
     if (!key || !value) return
     this.cache.set(key, value)
     this.expire_item(key, duration)
   }
 
-  expire_item(key, duration = 5)  {
+  expire_item (key, duration = 5) {
     setTimeout(() => {
       this.cache.delete(key)
     }, duration * 1000)
@@ -20,12 +20,12 @@ class LocalCache {
     return this.cache.get(key)
   }
 
-  remove_item(key) {
+  remove_item (key) {
     if (!key || !this.cache.has(key)) return
     this.cache.delete(key)
   }
 }
 
 module.exports = {
-    localCache: new LocalCache()
-}
+  localCache: new LocalCache()
+}

package/lib/redis/schemas/mailing/Draft.js

@@ -2,7 +2,7 @@ const { Schema } = require('redis-om')
 
 const DraftSchema = new Schema('draft', {
   id: { type: 'number' },
-  data: { type: 'string' },
+  data: { type: 'string' }
 })
 
 module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-mailer/jarvis",
-  "version": "10.4.2",
+  "version": "10.5.0",
   "main": "index.js",
   "repository": "git@github.com:go-mailer-ltd/jarvis-node.git",
   "author": "Nathan Oguntuberu <nateoguns.work@gmail.com>",
@@ -11,14 +11,14 @@
   },
   "dependencies": {
     "@logtail/node": "^0.3.3",
-    "axios": "^1.3.4",
-    "dotenv": "^16.0.3",
+    "axios": "^1.11.0",
+    "dotenv": "^17.2.2",
     "geoip-lite": "^1.4.10",
     "jsonwebtoken": "^9.0.0",
     "node-cron": "^4.2.1",
     "node-device-detector": "^2.1.1",
-    "redis": "^4.6.12",
-    "redis-om": "^0.4.3",
+    "redis": "^5.8.2",
+    "redis-om": "^0.4.7",
     "request-ip": "^3.3.0"
   },
   "devDependencies": {