@autofleet/matmon 1.0.0 → 1.0.2-beta-1

package/lib/index.d.ts

@@ -1,11 +1,3 @@
-declare const _default: {
-    getNewLRU: (lifeTimeInSec: any, size: any) => any;
-    getWithCacheSupport: ({ cacheKey, cacheGet, cacheSet, fetching, skipCache, }: {
-        cacheKey: any;
-        cacheGet: any;
-        cacheSet: any;
-        fetching: any;
-        skipCache: any;
-    }) => Promise<any>;
-};
-export default _default;
+import { getNewLRU, getWithCacheSupport } from './cache';
+import RedisCache from './redis';
+export { getNewLRU, getWithCacheSupport, RedisCache, };

package/lib/index.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisCache = exports.getWithCacheSupport = exports.getNewLRU = void 0;
 const cache_1 = require("./cache");
-exports.default = {
-    getNewLRU: cache_1.getNewLRU,
-    getWithCacheSupport: cache_1.getWithCacheSupport,
-};
+Object.defineProperty(exports, "getNewLRU", { enumerable: true, get: function () { return cache_1.getNewLRU; } });
+Object.defineProperty(exports, "getWithCacheSupport", { enumerable: true, get: function () { return cache_1.getWithCacheSupport; } });
+const redis_1 = __importDefault(require("./redis"));
+exports.RedisCache = redis_1.default;

package/lib/redis/errors.d.ts

@@ -0,0 +1,13 @@
+import { RedisError } from 'redis';
+declare class RedisCacheError extends RedisError {
+    innerError: any;
+    message: string;
+    constructor(msg: string, err: any);
+    toString(): string;
+}
+declare class RedisLockError extends RedisCacheError {
+    key: string;
+    constructor(msg: string, err: any, key: string);
+    toString(): string;
+}
+export { RedisCacheError, RedisLockError, };

package/lib/redis/errors.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLockError = exports.RedisCacheError = void 0;
+const redis_1 = require("redis");
+class RedisCacheError extends redis_1.RedisError {
+    constructor(msg, err) {
+        super();
+        this.innerError = err;
+        this.message = msg;
+    }
+    toString() {
+        return `${this.message}: ${this.innerError}`;
+    }
+}
+exports.RedisCacheError = RedisCacheError;
+class RedisLockError extends RedisCacheError {
+    constructor(msg, err, key) {
+        super(msg, err);
+        this.key = key;
+    }
+    toString() {
+        return `${this.message} (${this.key}): ${this.innerError}`;
+    }
+}
+exports.RedisLockError = RedisLockError;

package/lib/redis/index.d.ts

@@ -0,0 +1,14 @@
+declare class RedisCache {
+    private client;
+    private locker;
+    private lockTimeout;
+    private lockDuration;
+    private locks;
+    private baseTTL;
+    private lockRetries;
+    constructor(options: any);
+    get(key: any): Promise<any>;
+    set(key: any, value: any): Promise<void>;
+    private lock;
+}
+export default RedisCache;

package/lib/redis/index.js

@@ -0,0 +1,82 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_1 = __importDefault(require("redis"));
+const redis_lock_1 = __importDefault(require("redis-lock"));
+const bluebird_1 = __importDefault(require("bluebird"));
+const util_1 = require("util");
+const errors_1 = require("./errors");
+bluebird_1.default.promisifyAll(redis_1.default.RedisClient.prototype);
+bluebird_1.default.promisifyAll(redis_1.default.Multi.prototype);
+const { env } = process;
+const HOST = env.REDIS_HOST_NAME || '127.0.0.1';
+const PORT = env.REDIS_HOST_PORT || 6379;
+const DEFAULT_LOCK_TIMEOUT = 5000;
+const DEFAULT_LOCK_DURATION = 1000;
+const DEFAULT_BASE_TTL = 3600;
+class RedisCache {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        this.client = redis_1.default.createClient({
+            host: options.host || HOST,
+            port: options.port || PORT,
+        });
+        this.locker = util_1.promisify(redis_lock_1.default(this.client, (_a = options.lockRetries) !== null && _a !== void 0 ? _a : 10));
+        this.lockTimeout = (_b = options.lockTimeout) !== null && _b !== void 0 ? _b : DEFAULT_LOCK_TIMEOUT;
+        this.lockDuration = (_c = options.lockDuration) !== null && _c !== void 0 ? _c : DEFAULT_LOCK_DURATION;
+        this.baseTTL = (_d = options.ttl) !== null && _d !== void 0 ? _d : DEFAULT_BASE_TTL;
+        this.locks = {};
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let lock;
+            try {
+                // Try to lock the key.
+                lock = yield this.lock(key);
+            }
+            catch (err) {
+                throw new errors_1.RedisLockError('Failed to lock key', err, key);
+            }
+            // If the lock did not fail, add it to a locks dictionary.
+            this.locks[key] = lock;
+            let value;
+            try {
+                // Try to get the value from redis.
+                value = yield this.client.getAsync(key);
+            }
+            catch (err) {
+                throw new errors_1.RedisCacheError('Failed to get a value', err);
+            }
+            return JSON.parse(value);
+        });
+    }
+    set(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ttl = parseInt(String(this.baseTTL * (Math.random() + 1)), 10);
+            try {
+                yield this.client.setAsync(key, JSON.stringify(value), 'EX', ttl);
+            }
+            catch (err) {
+                throw new errors_1.RedisCacheError('Failed to set a key-value pair', err);
+            }
+        });
+    }
+    lock(key) {
+        return Promise.race([
+            this.locker(key, this.lockDuration),
+            new Promise((resolve, reject) => setTimeout(() => reject(), this.lockTimeout)),
+        ]);
+    }
+}
+exports.default = RedisCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/matmon",
-  "version": "1.0.0",
+  "version": "1.0.2-beta-1",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -29,8 +29,11 @@
   "dependencies": {
     "@types/node": "^14.14.20",
     "async-mutex": "^0.2.6",
+    "bluebird": "^3.7.2",
     "dotenv": "^8.2.0",
-    "lru-cache": "^6.0.0"
+    "lru-cache": "^6.0.0",
+    "redis": "^3.0.2",
+    "redis-lock": "^0.1.4"
   },
   "devDependencies": {
     "typescript": "^3.9.5"