@autofleet/matmon 2.0.8 → 2.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/matmon",
-  "version": "2.0.8",
+  "version": "2.1.0",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/cache.d.ts

@@ -1,8 +0,0 @@
-export declare const getNewLRU: (lifeTimeInSec: any, size: any) => any;
-export declare const getWithCacheSupport: ({ cacheKey, cacheGet, cacheSet, fetching, skipCache, }: {
-    cacheKey: any;
-    cacheGet: any;
-    cacheSet: any;
-    fetching: any;
-    skipCache: any;
-}) => Promise<any>;

package/lib/cache.js

@@ -1,79 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWithCacheSupport = exports.getNewLRU = void 0;
-const lru_cache_1 = __importDefault(require("lru-cache"));
-const locking = __importStar(require("./locking"));
-const dotenv_1 = __importDefault(require("dotenv"));
-dotenv_1.default.config();
-const DEFAULT_CACHE_SIZE = 300;
-const MAX_SIZE = 100000;
-const MUTEX_MAP = {};
-const getOptions = ({ lifeTimeInSec, size = DEFAULT_CACHE_SIZE, }) => ({
-    max: Math.min(size, MAX_SIZE),
-    maxAge: process.env.NODE_ENV !== 'test' ? 1000 * lifeTimeInSec : 0,
-});
-const getMutexByCacheKey = (key) => {
-    if (!MUTEX_MAP[key]) {
-        MUTEX_MAP[key] = locking.getMutex();
-    }
-    return MUTEX_MAP[key];
-};
-const deleteMutexByCacheKey = (key) => {
-    if (MUTEX_MAP[key]) {
-        delete MUTEX_MAP[key];
-    }
-};
-exports.getNewLRU = (lifeTimeInSec, size) => new lru_cache_1.default(getOptions({
-    lifeTimeInSec,
-    size,
-}));
-exports.getWithCacheSupport = async ({ cacheKey, cacheGet, cacheSet, fetching, skipCache, }) => {
-    if (skipCache || process.env.NODE_ENV === 'test') {
-        const res = await fetching();
-        await cacheSet(res);
-        return res;
-    }
-    let valueToReturn = null;
-    try {
-        await locking.wrapWithMutex(getMutexByCacheKey(cacheKey), async () => {
-            valueToReturn = await cacheGet();
-            if (!valueToReturn) {
-                valueToReturn = await fetching();
-                await cacheSet(valueToReturn);
-            }
-            else {
-                // logger.info('get value from cache');
-            }
-            deleteMutexByCacheKey(cacheKey);
-        });
-        // retry without locking if failed
-    }
-    catch (e) {
-        valueToReturn = await fetching();
-        await cacheSet(valueToReturn);
-        deleteMutexByCacheKey(cacheKey);
-    }
-    return valueToReturn;
-};

package/lib/index.d.ts

@@ -1,4 +0,0 @@
-import { getNewLRU, getWithCacheSupport } from './cache';
-import RedisCache from './redis';
-import { ORMCache, ORMTypes } from './orm-cache';
-export { getNewLRU, getWithCacheSupport, RedisCache, ORMCache, ORMTypes };

package/lib/index.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ORMTypes = exports.ORMCache = exports.RedisCache = exports.getWithCacheSupport = exports.getNewLRU = void 0;
-const cache_1 = require("./cache");
-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;
-const orm_cache_1 = require("./orm-cache");
-Object.defineProperty(exports, "ORMCache", { enumerable: true, get: function () { return orm_cache_1.ORMCache; } });
-Object.defineProperty(exports, "ORMTypes", { enumerable: true, get: function () { return orm_cache_1.ORMTypes; } });

package/lib/locking.d.ts

@@ -1,3 +0,0 @@
-import { MutexInterface } from 'async-mutex';
-export declare const wrapWithMutex: (mutex: any, funcToRun: any) => Promise<void>;
-export declare const getMutex: () => MutexInterface;

package/lib/locking.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMutex = exports.wrapWithMutex = void 0;
-const async_mutex_1 = require("async-mutex");
-const CACHE_LOCK_TIMEOUT_MILIS = 3000;
-const LOCK_TIMEOUT_MESSAGE = 'mutex - locking timeout';
-// eslint-disable-next-line import/prefer-default-export
-exports.wrapWithMutex = async (mutex, funcToRun) => {
-    const release = await mutex.acquire();
-    try {
-        await funcToRun();
-    }
-    finally {
-        release();
-    }
-};
-exports.getMutex = () => async_mutex_1.withTimeout(new async_mutex_1.Mutex(), CACHE_LOCK_TIMEOUT_MILIS, new Error(LOCK_TIMEOUT_MESSAGE));

package/lib/logger.d.ts

@@ -1,2 +0,0 @@
-declare const logger: any;
-export default logger;

package/lib/logger.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Logger = require('@autofleet/logger');
-const logger = Logger();
-exports.default = logger;

package/lib/orm-cache/adapter.d.ts

@@ -1,17 +0,0 @@
-import RedisCache from '../redis';
-export interface ModelOptions {
-    name: string;
-    associations?: AssociationOptions[];
-}
-export interface AssociationOptions {
-    name: string;
-    alias: string;
-    accessKey?: string;
-    innerAssociation?: AssociationOptions;
-}
-export interface Adapter {
-    ormInstance: any;
-    getModel: (modelName: string) => any;
-    injectGetWithCacheFunction: (cache: RedisCache, modelOptions: ModelOptions) => void;
-    addInvalidationHooks: (cache: RedisCache, modelOptions: ModelOptions) => void;
-}

package/lib/orm-cache/adapter.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/orm-cache/errors.d.ts

@@ -1,2 +0,0 @@
-export declare class UnsupportedOrmTypeError extends Error {
-}

package/lib/orm-cache/errors.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedOrmTypeError = void 0;
-class UnsupportedOrmTypeError extends Error {
-}
-exports.UnsupportedOrmTypeError = UnsupportedOrmTypeError;

package/lib/orm-cache/index.d.ts

@@ -1,12 +0,0 @@
-import { ModelOptions } from './adapter';
-export declare enum ORMTypes {
-    SEQUELIZE = "sequelize"
-}
-interface ORMCacheOptions {
-    type: ORMTypes;
-    models: ModelOptions[];
-    ormInstance: any;
-    debug: boolean;
-}
-export declare const ORMCache: (options: ORMCacheOptions) => void;
-export {};

package/lib/orm-cache/index.js

@@ -1,38 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ORMCache = exports.ORMTypes = void 0;
-const sequelize_adapter_1 = __importDefault(require("./sequelize-adapter"));
-const errors_1 = require("./errors");
-const redis_1 = __importDefault(require("../redis"));
-const logger_1 = __importDefault(require("../logger"));
-var ORMTypes;
-(function (ORMTypes) {
-    ORMTypes["SEQUELIZE"] = "sequelize";
-})(ORMTypes = exports.ORMTypes || (exports.ORMTypes = {}));
-const ORMInstanceFactory = (options) => {
-    switch (options.type) {
-        case ORMTypes.SEQUELIZE: {
-            return new sequelize_adapter_1.default(options.ormInstance, options.debug);
-        }
-        default: {
-            throw new errors_1.UnsupportedOrmTypeError(`ORM type ${options.type} is unsupported at the moment`);
-        }
-    }
-};
-exports.ORMCache = (options) => {
-    const { models } = options;
-    logger_1.default.info('Starting ORM Cache', { options });
-    const adapter = ORMInstanceFactory(options);
-    const cache = new redis_1.default({
-        host: process.env.REDIS_HOST,
-        port: process.env.REDIS_PORT,
-    });
-    // eslint-disable-next-line array-callback-return
-    models.map((modelOptions) => {
-        adapter.addInvalidationHooks(cache, modelOptions);
-        adapter.injectGetWithCacheFunction(cache, modelOptions);
-    });
-};

package/lib/orm-cache/sequelize-adapter.d.ts

@@ -1,13 +0,0 @@
-import { Sequelize } from 'sequelize';
-import { Adapter, AssociationOptions, ModelOptions } from './adapter';
-import RedisCache from '../redis';
-export default class SequelizeAdapter implements Adapter {
-    ormInstance: Sequelize;
-    debugMode: boolean;
-    constructor(sequelize: Sequelize, debug: any);
-    getModel(modelName: string): any;
-    getModelDependencies(modelName: string): AssociationOptions[];
-    debug(message: any, payload: any): void;
-    injectGetWithCacheFunction(cache: RedisCache, modelOptions: ModelOptions): void;
-    addInvalidationHooks(cache: RedisCache, modelOptions: ModelOptions): void;
-}

package/lib/orm-cache/sequelize-adapter.js

@@ -1,156 +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 logger_1 = __importDefault(require("../logger"));
-const util_1 = require("util");
-const { AF_SERVICE_NAME } = process.env;
-const ORM_CACHE_PREFIX = 'ormCache';
-const INVALIDATION_HOOKS = ['afterSave', 'afterUpdate', 'afterDestroy'];
-const BULK_HOOKS = ['beforeBulkUpdate', 'beforeBulkDestroy'];
-const generateInstanceKey = (name, id) => `${AF_SERVICE_NAME}:${ORM_CACHE_PREFIX}:${name}_${id}`;
-const generateDependencyKey = (modelName, associationName, associationId) => `${AF_SERVICE_NAME}:${ORM_CACHE_PREFIX}:${modelName}_${associationName}_${associationId}_DEPENDENCIES`;
-const getInstanceDependencyKeys = (modelOptions, instance) => {
-    const keys = modelOptions.associations
-        .filter((associationOptions) => instance[associationOptions.alias])
-        .map((associationOptions) => {
-        const accessKey = associationOptions.accessKey;
-        const depKeys = [];
-        if (Array.isArray(instance[associationOptions.alias])) {
-            instance[associationOptions.alias].map(associationInstance => {
-                depKeys.push(generateDependencyKey(modelOptions.name, associationOptions.name, associationInstance[accessKey]));
-                if (associationOptions.innerAssociation &&
-                    associationInstance[associationOptions.innerAssociation.alias]) {
-                    depKeys.push(generateDependencyKey(modelOptions.name, associationOptions.innerAssociation.name, associationInstance[associationOptions.innerAssociation.alias][associationOptions.innerAssociation.accessKey]));
-                }
-            });
-            return depKeys;
-        }
-        return [
-            generateDependencyKey(modelOptions.name, associationOptions.name, instance[associationOptions.alias][accessKey]),
-        ];
-    });
-    return keys.reduce((flattenArray, array) => flattenArray.concat(array), []);
-};
-const handleTransactionHook = (instance, options, func) => {
-    const { transaction } = options;
-    if (transaction) {
-        transaction.afterCommit(() => func(instance));
-    }
-    else {
-        func(instance);
-    }
-};
-class SequelizeAdapter {
-    constructor(sequelize, debug) {
-        this.ormInstance = sequelize;
-        this.debugMode = debug;
-    }
-    getModel(modelName) {
-        return this.ormInstance.models[modelName];
-    }
-    getModelDependencies(modelName) {
-        const { associations } = this.ormInstance.models[modelName];
-        return [
-            ...Object.keys(associations).map(association => {
-                const sequelizeAssociation = associations[association];
-                const associationOptions = {
-                    alias: sequelizeAssociation.as,
-                    name: sequelizeAssociation.target.name,
-                    accessKey: sequelizeAssociation.target.primaryKeyAttribute,
-                };
-                if (sequelizeAssociation.through) {
-                    const relationModel = sequelizeAssociation.through.model;
-                    associationOptions.innerAssociation = {
-                        alias: relationModel.name,
-                        name: relationModel.name,
-                        accessKey: relationModel.primaryKeyAttribute,
-                    };
-                }
-                return associationOptions;
-            }),
-        ];
-    }
-    debug(message, payload) {
-        if (this.debugMode) {
-            logger_1.default.info(`[ORM_CACHE Debug] ${message}`, payload);
-        }
-    }
-    injectGetWithCacheFunction(cache, modelOptions) {
-        const addDependencies = async (instance) => {
-            const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
-            const instanceKey = generateInstanceKey(modelOptions.name, instance.id);
-            this.debug('Adding dependencies', { instanceKey, dependencyKeys });
-            const addDependenciesMulti = cache.getClient().multi();
-            const addDependenciesMultiAsync = util_1.promisify(addDependenciesMulti.exec).bind(addDependenciesMulti);
-            dependencyKeys.reduce((multi, key) => multi.sadd(key, instanceKey), addDependenciesMulti);
-            return addDependenciesMultiAsync();
-        };
-        const model = this.getModel(modelOptions.name);
-        model.findByPkCached = async (id, scopes, options) => {
-            const cacheKey = generateInstanceKey(modelOptions.name, id);
-            let value = JSON.parse(await cache.getClient().getAsync(cacheKey));
-            if (!value) {
-                this.debug('Value not found in cache, looking in db', { id, cacheKey });
-                value = await model.scope(scopes).findByPk(id, options);
-                this.debug('Value from DB', { value: value || 'not found', cacheKey });
-                await Promise.all([
-                    cache.getClient().setAsync(cacheKey, JSON.stringify(value)),
-                    value && addDependencies(value),
-                ]);
-            }
-            else {
-                value = this.getModel(modelOptions.name).build(value, { isNewRecord: false, include: options.include });
-                this.debug('Found cached value', { value, id, cacheKey });
-            }
-            return value;
-        };
-    }
-    addInvalidationHooks(cache, modelOptions) {
-        const invalidateModelInstance = async (instance) => {
-            const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
-            const instanceKey = generateInstanceKey(modelOptions.name, instance.id);
-            this.debug('Removing dependencies', { instance, instanceKey, dependencyKeys });
-            const removeMulti = cache.getClient().multi();
-            const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
-            dependencyKeys.map(key => removeMulti.srem(key, instanceKey));
-            removeMulti.del(instanceKey);
-            return removeMultiAsync();
-        };
-        const invalidateModelInstanceByAssociation = async (association, associationId) => {
-            const dependentInstancesKeys = await cache.getClient().smembersAsync(generateDependencyKey(modelOptions.name, association, associationId));
-            this.debug('Invalidating dependent instances', { dependentInstancesKeys });
-            const removeMulti = cache.getClient().multi();
-            const removeMultiAsync = util_1.promisify(removeMulti.exec).bind(removeMulti);
-            const dependenciesToRemove = await Promise.all(dependentInstancesKeys.map(async (instanceKey) => {
-                const instance = JSON.parse(await cache.getClient().getAsync(instanceKey));
-                if (!instance) {
-                    return [];
-                }
-                const dependencyKeys = getInstanceDependencyKeys(modelOptions, instance);
-                dependencyKeys.reduce((multi, key) => multi.srem(key, instanceKey), removeMulti);
-                removeMulti.del(instanceKey);
-                return dependencyKeys;
-            }));
-            this.debug('Removing dependencies', { dependentInstancesKeys, dependenciesToRemove });
-            return removeMultiAsync();
-        };
-        const model = this.getModel(modelOptions.name);
-        INVALIDATION_HOOKS.map(hook => model.addHook(hook, (instance, options) => handleTransactionHook(instance, options, instance => invalidateModelInstance(instance))));
-        BULK_HOOKS.map(hook => model.addHook(hook, options => options.individualHook = true));
-        modelOptions.associations = this.getModelDependencies(modelOptions.name);
-        this.debug(`Adding Invalidations Hooks to ${modelOptions.name}'s associations`, { associations: modelOptions.associations });
-        modelOptions.associations.map((associationOptions) => {
-            const associationModel = this.getModel(associationOptions.name);
-            INVALIDATION_HOOKS.map(hook => associationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, associationInstance => invalidateModelInstanceByAssociation(associationOptions.name, associationInstance[associationOptions.accessKey]))));
-            BULK_HOOKS.map(hook => associationModel.addHook(hook, options => options.individualHook = true));
-            if (associationOptions.innerAssociation) {
-                const innerAssociationModel = this.getModel(associationOptions.innerAssociation.name);
-                INVALIDATION_HOOKS.map(hook => innerAssociationModel.addHook(hook, (instance, options) => handleTransactionHook(instance, options, innerAssociationInstance => invalidateModelInstanceByAssociation(associationOptions.innerAssociation.name, innerAssociationInstance[associationOptions.innerAssociation.accessKey]))));
-                BULK_HOOKS.map(hook => innerAssociationModel.addHook(hook, options => options.individualHook = true));
-            }
-        });
-    }
-}
-exports.default = SequelizeAdapter;

package/lib/redis/errors.d.ts

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

@@ -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,18 +0,0 @@
-declare class RedisCache {
-    private client;
-    private locker;
-    private lockTimeout;
-    private lockDuration;
-    private locks;
-    private baseTTL;
-    private lockRetries;
-    private useLock;
-    constructor(options: any);
-    get(key: any): Promise<any>;
-    set(key: any, value: any): Promise<void>;
-    remove(key: any): Promise<void>;
-    removeMultiple(keys: any): Promise<void>;
-    getClient(): any;
-    private lock;
-}
-export default RedisCache;

package/lib/redis/index.js

@@ -1,107 +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 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 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 = util_1.promisify(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;
-    }
-    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 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 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;