@autofleet/matmon 2.4.0 → 2.4.1

package/lib/cache.js

@@ -1,140 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (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.prototype.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.getMultipleWithCache = 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"));
-const logger_1 = __importDefault(require("./logger"));
-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) => {
-    MUTEX_MAP[key] || (MUTEX_MAP[key] = locking.getMutex());
-    return MUTEX_MAP[key];
-};
-const deleteMutexByCacheKey = (key) => {
-    if (MUTEX_MAP[key]) {
-        delete MUTEX_MAP[key];
-    }
-};
-const getNewLRU = (lifeTimeInSec, size) => new lru_cache_1.default(getOptions({
-    lifeTimeInSec,
-    size,
-}));
-exports.getNewLRU = getNewLRU;
-const IN_LOCAL_TEST = process.env.IS_IN_MATMON_TESTING === 'true';
-const IS_IN_SERVICE_TEST = process.env.NODE_ENV === 'test' && !IN_LOCAL_TEST;
-const tryToSetInCache = async (callback) => {
-    try {
-        await callback();
-    }
-    catch (e) {
-        logger_1.default.error('Failed to set in cache', e);
-    }
-};
-const getWithCacheSupport = async ({ cacheKey, cacheGet, cacheSet, fetching, skipCache, }) => {
-    if (skipCache || IS_IN_SERVICE_TEST) {
-        const res = await fetching();
-        await tryToSetInCache(() => cacheSet(res));
-        return res;
-    }
-    let valueToReturn = null;
-    try {
-        await locking.wrapWithMutex(getMutexByCacheKey(cacheKey), async () => {
-            valueToReturn = await cacheGet();
-            if (!valueToReturn) {
-                valueToReturn = await fetching();
-                await tryToSetInCache(() => cacheSet(valueToReturn));
-            }
-            else {
-                // logger.info('get value from cache');
-            }
-            deleteMutexByCacheKey(cacheKey);
-        });
-        // retry without locking if failed
-    }
-    catch (e) {
-        valueToReturn = await fetching();
-        await tryToSetInCache(() => cacheSet(valueToReturn));
-        deleteMutexByCacheKey(cacheKey);
-    }
-    return valueToReturn;
-};
-exports.getWithCacheSupport = getWithCacheSupport;
-const getIdField = (query, idField) => {
-    if (typeof query === 'string') {
-        return query;
-    }
-    return query[idField];
-};
-const getMultipleWithCache = ({ getFromCache, multiGetterFromCache, setInCache, setMultiInCache, getter, multiGetter, idField = 'id', }) => async (queries) => {
-    const queriesMap = new Map(queries.filter(Boolean).map(query => [getIdField(query, idField), query]));
-    const resultMap = new Map();
-    const valuesToPullFromCache = [...queriesMap.values()];
-    const valuesFromCache = await (multiGetterFromCache?.(valuesToPullFromCache) || // Use multiGetterFromCache if it's provided
-        Promise.all(valuesToPullFromCache.map(query => getFromCache(query))) // Otherwise, iterate over the queries with getFromCache
-    );
-    valuesFromCache.filter(Boolean).forEach((value) => {
-        queriesMap.delete(getIdField(value, idField));
-        resultMap.set(getIdField(value, idField), value);
-    });
-    if (queriesMap.size > 0) {
-        const valuesFromGetter = await (multiGetter?.([...queriesMap.values()]) || // Use multiGetter if it's provided
-            Promise.all([...queriesMap.values()].map(id => getter(id))) // Otherwise, iterate over the queries with getter
-        );
-        if (setMultiInCache && valuesFromGetter.length > 0) {
-            const setCacheObject = valuesFromGetter.reduce((acc, value) => {
-                acc[getIdField(value, idField)] = value;
-                return acc;
-            }, {});
-            await tryToSetInCache(() => setMultiInCache(setCacheObject));
-        }
-        valuesFromGetter.forEach((value) => {
-            if (!value) {
-                return;
-            }
-            if (!setMultiInCache) {
-                tryToSetInCache(() => setInCache(value[idField], value));
-            }
-            resultMap.set(getIdField(value, idField), value);
-        });
-    }
-    return queries.map((query) => {
-        if (!query) {
-            return null;
-        }
-        return resultMap.get(getIdField(query, idField));
-    });
-};
-exports.getMultipleWithCache = getMultipleWithCache;

package/lib/cache.test.d.ts

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

package/lib/cache.test.js

@@ -1,168 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const vitest_1 = require("vitest");
-const cache_1 = require("./cache");
-(0, vitest_1.describe)('Cache', () => {
-    (0, vitest_1.describe)('getNewLRU', () => {
-        (0, vitest_1.it)('should create a new LRU cache with default size', () => {
-            const cache = (0, cache_1.getNewLRU)(60);
-            (0, vitest_1.expect)(cache.max).toBe(300);
-        });
-        (0, vitest_1.it)('should create a new LRU cache with specified size', () => {
-            const cache = (0, cache_1.getNewLRU)(60, 500);
-            (0, vitest_1.expect)(cache.max).toBe(500);
-        });
-        (0, vitest_1.it)('should not exceed the maximum size', () => {
-            const cache = (0, cache_1.getNewLRU)(60, 200000);
-            (0, vitest_1.expect)(cache.max).toBe(100000);
-        });
-    });
-    (0, vitest_1.describe)('getWithCacheSupport', () => {
-        const cacheKey = 'testKey';
-        const createMocks = () => {
-            const cacheGet = vitest_1.vi.fn();
-            const cacheSet = vitest_1.vi.fn();
-            const fetching = vitest_1.vi.fn();
-            const getFromCache = vitest_1.vi.fn();
-            const setInCache = vitest_1.vi.fn();
-            const multiGetterFromCache = vitest_1.vi.fn();
-            const setMultiInCache = vitest_1.vi.fn();
-            return {
-                cacheGet,
-                cacheSet,
-                fetching,
-                getFromCache,
-                setInCache,
-                multiGetterFromCache,
-                setMultiInCache
-            };
-        };
-        (0, vitest_1.beforeEach)(() => {
-            vitest_1.vi.clearAllMocks();
-        });
-        (0, vitest_1.it)('should fetch and set value if skipCache is true', async () => {
-            const { cacheGet, cacheSet, fetching } = createMocks();
-            fetching.mockResolvedValue('fetchedValue');
-            await (0, cache_1.getWithCacheSupport)({ cacheKey, cacheGet, cacheSet, fetching, skipCache: true });
-            (0, vitest_1.expect)(fetching).toHaveBeenCalled();
-            (0, vitest_1.expect)(cacheSet).toHaveBeenCalledWith('fetchedValue');
-        });
-        (0, vitest_1.it)('should fetch and set value if cache is empty', async () => {
-            const { cacheGet, cacheSet, fetching } = createMocks();
-            cacheGet.mockResolvedValue(null);
-            fetching.mockResolvedValue('fetchedValue');
-            await (0, cache_1.getWithCacheSupport)({ cacheKey, cacheGet, cacheSet, fetching });
-            (0, vitest_1.expect)(fetching).toHaveBeenCalled();
-            (0, vitest_1.expect)(cacheSet).toHaveBeenCalledWith('fetchedValue');
-        });
-        (0, vitest_1.it)('should return cached value if available', async () => {
-            const { cacheGet, cacheSet, fetching } = createMocks();
-            cacheGet.mockResolvedValue('cachedValue');
-            const result = await (0, cache_1.getWithCacheSupport)({ cacheKey, cacheGet, cacheSet, fetching });
-            (0, vitest_1.expect)(result).toBe('cachedValue');
-            (0, vitest_1.expect)(fetching).not.toHaveBeenCalled();
-        });
-        (0, vitest_1.it)('should retry fetching if an error occurs', async () => {
-            const { cacheGet, cacheSet, fetching } = createMocks();
-            cacheGet.mockRejectedValue(new Error('Cache error'));
-            fetching.mockResolvedValue('fetchedValue');
-            const result = await (0, cache_1.getWithCacheSupport)({ cacheKey, cacheGet, cacheSet, fetching });
-            (0, vitest_1.expect)(result).toBe('fetchedValue');
-            (0, vitest_1.expect)(fetching).toHaveBeenCalled();
-            (0, vitest_1.expect)(cacheSet).toHaveBeenCalledWith('fetchedValue');
-        });
-        (0, vitest_1.it)('should not throw an error if cacheSet fails', async () => {
-            const { cacheGet, cacheSet, fetching } = createMocks();
-            cacheGet.mockResolvedValue(null);
-            cacheSet.mockRejectedValue(new Error('Cache set error'));
-            fetching.mockResolvedValue('fetchedValue');
-            await (0, vitest_1.expect)((0, cache_1.getWithCacheSupport)({ cacheKey, cacheGet, cacheSet, fetching })).resolves.not.toThrow();
-        });
-    });
-    (0, vitest_1.describe)('getMultipleWithCache', () => {
-        const buildMocks = () => {
-            const getFromCache = vitest_1.vi.fn();
-            const multiGetterFromCache = vitest_1.vi.fn();
-            const setInCache = vitest_1.vi.fn();
-            const setMultiInCache = vitest_1.vi.fn();
-            const getter = vitest_1.vi.fn();
-            const multiGetter = vitest_1.vi.fn();
-            return {
-                getFromCache,
-                multiGetterFromCache,
-                setInCache,
-                setMultiInCache,
-                getter,
-                multiGetter,
-            };
-        };
-        (0, vitest_1.beforeEach)(() => {
-            vitest_1.vi.clearAllMocks();
-        });
-        (0, vitest_1.it)('should return values from cache if available', async () => {
-            const { getFromCache, setInCache, getter } = buildMocks();
-            const queries = [{ id: 1 }, { id: 2 }];
-            getFromCache.mockResolvedValueOnce({ id: 1, value: 'cachedValue1' }).mockResolvedValueOnce({ id: 2, value: 'cachedValue2' });
-            const getMultiple = (0, cache_1.getMultipleWithCache)({ getFromCache, setInCache, getter });
-            const result = await getMultiple(queries);
-            (0, vitest_1.expect)(result.map(({ value }) => value)).toEqual(['cachedValue1', 'cachedValue2']);
-        });
-        (0, vitest_1.it)('should fetch and cache values if not in cache', async () => {
-            const { getFromCache, setInCache, getter } = buildMocks();
-            const queries = [{ id: 1 }, { id: 2 }];
-            getFromCache.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
-            getter.mockResolvedValueOnce({ id: 1, value: 'fetchedValue1' }).mockResolvedValueOnce({ id: 2, value: 'fetchedValue2' });
-            const getMultiple = (0, cache_1.getMultipleWithCache)({ getFromCache, setInCache, getter });
-            const result = await getMultiple(queries);
-            (0, vitest_1.expect)(result.map(({ value }) => value)).toEqual(['fetchedValue1', 'fetchedValue2']);
-            (0, vitest_1.expect)(setInCache).toHaveBeenCalledWith(1, { id: 1, value: 'fetchedValue1' });
-            (0, vitest_1.expect)(setInCache).toHaveBeenCalledWith(2, { id: 2, value: 'fetchedValue2' });
-        });
-        (0, vitest_1.it)('should use multiGetterFromCache if provided', async () => {
-            const { multiGetterFromCache, setInCache, getter } = buildMocks();
-            const queries = [{ id: 1 }, { id: 2 }];
-            multiGetterFromCache.mockResolvedValue([{ id: 1, value: 'cachedValue1' }, { id: 2, value: 'cachedValue2' }]);
-            const getMultiple = (0, cache_1.getMultipleWithCache)({ multiGetterFromCache, setInCache, getter });
-            const result = await getMultiple(queries);
-            (0, vitest_1.expect)(result.map(({ value }) => value)).toEqual(['cachedValue1', 'cachedValue2']);
-        });
-        (0, vitest_1.it)('should use multiGetter if provided', async () => {
-            const { getFromCache, setInCache, multiGetter } = buildMocks();
-            const queries = [{ id: 1 }, { id: 2 }];
-            getFromCache.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
-            multiGetter.mockResolvedValue([{ id: 1, value: 'fetchedValue1' }, { id: 2, value: 'fetchedValue2' }]);
-            const getMultiple = (0, cache_1.getMultipleWithCache)({ getFromCache, setInCache, multiGetter });
-            const result = await getMultiple(queries);
-            (0, vitest_1.expect)(result.map(({ value }) => value)).toEqual(['fetchedValue1', 'fetchedValue2']);
-            (0, vitest_1.expect)(setInCache).toHaveBeenCalledWith(1, { id: 1, value: 'fetchedValue1' });
-            (0, vitest_1.expect)(setInCache).toHaveBeenCalledWith(2, { id: 2, value: 'fetchedValue2' });
-        });
-        (0, vitest_1.it)('should use setMultiInCache if provided', async () => {
-            const { getFromCache, setInCache, multiGetter, setMultiInCache } = buildMocks();
-            const queries = [{ id: 1 }, { id: 2 }];
-            getFromCache.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
-            multiGetter.mockResolvedValue([{ id: 1, value: 'fetchedValue1' }, { id: 2, value: 'fetchedValue2' }]);
-            const getMultiple = (0, cache_1.getMultipleWithCache)({ getFromCache, setInCache, multiGetter, setMultiInCache });
-            await getMultiple(queries);
-            (0, vitest_1.expect)(setMultiInCache).toHaveBeenCalledWith({ 1: { id: 1, value: 'fetchedValue1' }, 2: { id: 2, value: 'fetchedValue2' } });
-        });
-        (0, vitest_1.it)('Should not throw and error if setMultiInCache throws an error', async () => {
-            const { getFromCache, setInCache, multiGetter, setMultiInCache } = buildMocks();
-            const queries = [{ id: 1 }, { id: 2 }];
-            getFromCache.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
-            multiGetter.mockResolvedValue([{ id: 1, value: 'fetchedValue1' }, { id: 2, value: 'fetchedValue2' }]);
-            setMultiInCache.mockRejectedValue(new Error('Error setting cache'));
-            const getMultiple = (0, cache_1.getMultipleWithCache)({ getFromCache, setInCache, multiGetter, setMultiInCache });
-            await (0, vitest_1.expect)(getMultiple(queries)).resolves.not.toThrow();
-        });
-        (0, vitest_1.it)('should not throw an error if setInCache fails', async () => {
-            const { getFromCache, setInCache, getter } = buildMocks();
-            const queries = [{ id: 1 }, { id: 2 }];
-            getFromCache.mockResolvedValueOnce(null).mockResolvedValueOnce(null);
-            getter.mockResolvedValueOnce({ id: 1, value: 'fetchedValue1' }).mockResolvedValueOnce({ id: 2, value: 'fetchedValue2' });
-            setInCache.mockRejectedValue(new Error('Error setting cache'));
-            const getMultiple = (0, cache_1.getMultipleWithCache)({ getFromCache, setInCache, getter });
-            await (0, vitest_1.expect)(getMultiple(queries)).resolves.not.toThrow();
-        });
-    });
-});

package/lib/locking.d.ts

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

package/lib/locking.js

@@ -1,18 +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';
-const wrapWithMutex = async (mutex, funcToRun) => {
-    const release = await mutex.acquire();
-    try {
-        await funcToRun();
-    }
-    finally {
-        release();
-    }
-};
-exports.wrapWithMutex = wrapWithMutex;
-const getMutex = () => (0, async_mutex_1.withTimeout)(new async_mutex_1.Mutex(), CACHE_LOCK_TIMEOUT_MILIS, new Error(LOCK_TIMEOUT_MESSAGE));
-exports.getMutex = getMutex;

package/lib/logger.d.ts

@@ -1,2 +0,0 @@
-declare const logger: import("@autofleet/logger").LoggerInstanceManager;
-export default logger;

package/lib/logger.js

@@ -1,8 +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("@autofleet/logger"));
-const logger = (0, logger_1.default)();
-exports.default = logger;

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

@@ -1,17 +0,0 @@
-import type 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,39 +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 = 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`);
-        }
-    }
-};
-const 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);
-    });
-};
-exports.ORMCache = ORMCache;

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 = (0, 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 = (0, 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 = (0, 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/promise-utils.d.ts

@@ -1 +0,0 @@
-export declare const promisifyAll: (obj: any) => void;

package/lib/promise-utils.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.promisifyAll = void 0;
-const util_1 = require("util");
-const promisifyAll = (obj) => {
-    Object.keys(obj).forEach((key) => {
-        if (typeof obj[key] === 'function') {
-            obj[`${key}Async`] = (0, util_1.promisify)(obj[key]);
-            // To support the `isPromisified` check in `bluebird`, we need to set the `__isPromisified__` property to `true`.
-            Object.defineProperty(obj[`${key}Async`], '__isPromisified__', {
-                value: true,
-                configurable: true,
-                enumerable: false,
-                writable: true
-            });
-        }
-    });
-};
-exports.promisifyAll = promisifyAll;

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, };