@autofleet/matmon 2.4.0 → 2.4.1

package/lib/redis/errors.js

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

@@ -1,21 +0,0 @@
-declare class RedisCache {
-    private client;
-    private locker;
-    private lockTimeout;
-    private lockDuration;
-    locks: any;
-    private baseTTL;
-    private lockRetries;
-    keyPrefix: string;
-    useLock: boolean;
-    constructor(options: any);
-    get(key: any): Promise<any>;
-    getMultiple(keys: any): Promise<any>;
-    set(key: any, value: any): Promise<void>;
-    setMultiple(keyValues: Record<string, any>): Promise<any>;
-    remove(key: any): Promise<void>;
-    removeMultiple(keys: any): Promise<void>;
-    getClient(): any;
-    private lock;
-}
-export default RedisCache;

package/lib/redis/index.js

@@ -1,148 +0,0 @@
-"use strict";
-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 util_1 = require("util");
-const errors_1 = require("./errors");
-const logger_1 = __importDefault(require("../logger"));
-const promise_utils_1 = require("../promise-utils");
-(0, promise_utils_1.promisifyAll)(redis_1.default.RedisClient.prototype);
-(0, promise_utils_1.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 SERVICE_NAME = env.AF_SERVICE_NAME;
-const DEFAULT_LOCK_TIMEOUT = 5000;
-const DEFAULT_LOCK_DURATION = 1000;
-const DEFAULT_BASE_TTL = 3600;
-const KEY_PREFIX = SERVICE_NAME + ':';
-if (!SERVICE_NAME) {
-    throw new Error('SERVICE_NAME cannot be null, please check your env.AF_SERVICE_NAME');
-}
-class RedisCache {
-    constructor(options) {
-        this.client = redis_1.default.createClient({
-            host: options.host || HOST,
-            port: options.port || PORT,
-        });
-        this.locker = (0, util_1.promisify)((0, redis_lock_1.default)(this.client, options.lockRetries ?? 10));
-        this.lockTimeout = options.lockTimeout ?? DEFAULT_LOCK_TIMEOUT;
-        this.lockDuration = options.lockDuration ?? DEFAULT_LOCK_DURATION;
-        this.baseTTL = options.ttl ?? DEFAULT_BASE_TTL;
-        this.locks = {};
-        this.useLock = !!options.useLock;
-        this.keyPrefix = KEY_PREFIX;
-    }
-    async get(key) {
-        const keyWithPrefix = KEY_PREFIX + key;
-        let value;
-        try {
-            // Try to get the value from redis.
-            value = await this.client.getAsync(keyWithPrefix);
-        }
-        catch (err) {
-            throw new errors_1.RedisCacheError('Failed to get a value', err);
-        }
-        if (this.useLock) {
-            let lock;
-            try {
-                // Try to lock the key.
-                lock = await this.lock(keyWithPrefix);
-            }
-            catch (err) {
-                throw new errors_1.RedisLockError('Failed to lock key', err, keyWithPrefix);
-            }
-            // If the lock did not fail, add it to a locks dictionary.
-            this.locks[keyWithPrefix] = lock;
-        }
-        return JSON.parse(value);
-    }
-    async getMultiple(keys) {
-        const keysWithPrefix = keys.map(key => KEY_PREFIX + key);
-        let values;
-        try {
-            if (keysWithPrefix.length === 0) {
-                return [];
-            }
-            // Try to get the value from redis.
-            values = await this.client.mgetAsync(keysWithPrefix);
-        }
-        catch (err) {
-            throw new errors_1.RedisCacheError('Failed to get a value', err);
-        }
-        return values.map(value => JSON.parse(value));
-    }
-    async set(key, value) {
-        const keyWithPrefix = KEY_PREFIX + key;
-        const ttl = parseInt(String(this.baseTTL * (Math.random() + 1)), 10);
-        try {
-            await this.client.setAsync(keyWithPrefix, JSON.stringify(value), 'EX', ttl);
-            if (this.locks[keyWithPrefix]) {
-                await this.locks[keyWithPrefix]();
-                delete this.locks[keyWithPrefix];
-            }
-        }
-        catch (err) {
-            throw new errors_1.RedisCacheError('Failed to set a key-value pair', err);
-        }
-    }
-    async setMultiple(keyValues) {
-        if (typeof keyValues !== 'object') {
-            const error = new errors_1.RedisCacheError('keyValues must be an object', new Error('keyValues must be an object'));
-            logger_1.default.error('keyValues must be an object', { error });
-            throw error;
-        }
-        if (keyValues === null || keyValues === undefined || Object.keys(keyValues).length === 0) {
-            return;
-        }
-        const keyValuesWithPrefix = Object.entries(keyValues).map(([key, value]) => [KEY_PREFIX + key, JSON.stringify(value)]);
-        const ttl = Math.trunc(this.baseTTL * (Math.random() + 1));
-        try {
-            const multi = this.client.multi();
-            const setPromise = multi.msetAsync(...keyValuesWithPrefix.flat());
-            keyValuesWithPrefix.map(([key]) => {
-                return multi.expireAsync(key, ttl);
-            });
-            await multi.exec();
-            return setPromise;
-        }
-        catch (err) {
-            throw new errors_1.RedisCacheError('Failed to set multiple key-value pairs', err);
-        }
-    }
-    async remove(key) {
-        const keyWithPrefix = KEY_PREFIX + key;
-        try {
-            if (this.locks[keyWithPrefix]) {
-                await this.locks[keyWithPrefix]();
-                delete this.locks[keyWithPrefix];
-            }
-            await this.client.delAsync(keyWithPrefix);
-        }
-        catch (err) {
-            throw new errors_1.RedisCacheError(`Failed to delete key ${keyWithPrefix}`, err);
-        }
-    }
-    async removeMultiple(keys) {
-        const keysWithPrefix = keys.map(key => KEY_PREFIX + key);
-        try {
-            await this.client.delAsync(keysWithPrefix);
-        }
-        catch (err) {
-            throw new errors_1.RedisCacheError(`Failed to delete multiple keys ${keysWithPrefix.join('|')}`, err);
-        }
-    }
-    getClient() {
-        return this.client;
-    }
-    lock(key) {
-        return Promise.race([
-            this.locker(key, this.lockDuration),
-            new Promise((resolve, reject) => setTimeout(() => reject(), this.lockTimeout)),
-        ]);
-    }
-}
-exports.default = RedisCache;

package/lib/redis/index.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/redis/index.test.js

@@ -1,62 +0,0 @@
-"use strict";
-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 vitest_1 = require("vitest");
-const index_1 = __importDefault(require("./index"));
-const promise_utils_1 = require("../promise-utils");
-(0, promise_utils_1.promisifyAll)(redis_1.default.RedisClient.prototype);
-(0, vitest_1.describe)('RedisCache', () => {
-    let redisCache;
-    const testClient = redis_1.default.createClient();
-    (0, vitest_1.beforeEach)(() => {
-        redisCache = new index_1.default({});
-    });
-    (0, vitest_1.describe)('setMultiple', () => {
-        (0, vitest_1.it)('should set multiple key-value pairs in redis', async () => {
-            const keyValues = { testKey1: 'testValue1', testKey2: 'testValue2' };
-            const keyValuesArray = Object.entries(keyValues);
-            await redisCache.setMultiple(keyValues);
-            const expectedKeyValues = keyValuesArray.map(([key, value]) => [`${redisCache.keyPrefix}${key}`, JSON.stringify(value)]);
-            await Promise.all(expectedKeyValues.map(async ([key, value]) => {
-                const valueInRedis = await testClient.getAsync(key);
-                (0, vitest_1.expect)(valueInRedis).toBe(value);
-            }));
-            // Check that the keys expire after a random amount of time.
-            const currentTTL = await testClient.ttlAsync(expectedKeyValues[0][0]);
-            (0, vitest_1.expect)(currentTTL).toBeGreaterThanOrEqual(0);
-        });
-        (0, vitest_1.it)('should not set any key-value pairs if keyValues is an empty object', async () => {
-            const currentKeys = await testClient.keysAsync(`${redisCache.keyPrefix}*`);
-            await redisCache.setMultiple({});
-            const keys = await testClient.keysAsync(`${redisCache.keyPrefix}*`);
-            (0, vitest_1.expect)(keys).toEqual(currentKeys);
-        });
-    });
-    (0, vitest_1.describe)('set', () => {
-        (0, vitest_1.it)('should set a key-value pair in redis', async () => {
-            const key = 'testKey';
-            const value = 'testValue';
-            await redisCache.set(key, value);
-            const keyWithPrefix = `${redisCache.keyPrefix}${key}`;
-            const valueInRedis = await testClient.getAsync(keyWithPrefix);
-            (0, vitest_1.expect)(valueInRedis).toBe(JSON.stringify(value));
-            // Check that the key expires after a random amount of time.
-            const currentTTL = await testClient.ttlAsync(keyWithPrefix);
-            (0, vitest_1.expect)(currentTTL).toBeGreaterThanOrEqual(0);
-        });
-        (0, vitest_1.it)('should release the lock after setting a key-value pair', async () => {
-            const key = 'testKeyWithLock';
-            const value = 'testValueWithLock';
-            redisCache.useLock = true;
-            await redisCache.set(key, value);
-            const keyWithPrefix = `${redisCache.keyPrefix}${key}`;
-            const valueInRedis = await testClient.getAsync(keyWithPrefix);
-            (0, vitest_1.expect)(valueInRedis).toBe(JSON.stringify(value));
-            // Check that the lock is released
-            (0, vitest_1.expect)(redisCache.locks[keyWithPrefix]).toBeUndefined();
-        });
-    });
-});