@autofleet/matmon 2.3.1-beta-4 → 2.3.1-beta-5

package/lib/cache.js

@@ -113,7 +113,7 @@ const getMultipleWithCache = ({ getFromCache, multiGetterFromCache, setInCache,
         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) {
+        if (setMultiInCache && valuesFromGetter.length > 0) {
             const setCacheObject = valuesFromGetter.reduce((acc, value) => {
                 acc[getIdField(value, idField)] = value;
                 return acc;

package/lib/cache.test.js

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

package/lib/promise-utils.d.ts

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

package/lib/promise-utils.js

@@ -0,0 +1,19 @@
+"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/index.js

@@ -8,15 +8,9 @@ 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 promisifyAll = (obj) => {
-    Object.keys(obj).forEach((key) => {
-        if (typeof obj[key] === 'function') {
-            obj[`${key}Async`] = (0, util_1.promisify)(obj[key]);
-        }
-    });
-};
-promisifyAll(redis_1.default.RedisClient.prototype);
-promisifyAll(redis_1.default.Multi.prototype);
+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;

package/lib/redis/index.test.js

@@ -4,62 +4,59 @@ var __importDefault = (this && this.__importDefault) || function (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 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]);
-        }
-    });
-};
-promisifyAll(redis_1.default.RedisClient.prototype);
-describe('RedisCache', () => {
+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();
-    beforeEach(() => {
+    (0, vitest_1.beforeEach)(() => {
         redisCache = new index_1.default({});
     });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    describe('setMultiple', () => {
-        it('should set multiple key-value pairs in redis', async () => {
+    (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);
-                expect(valueInRedis).toBe(value);
+                (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]);
-            expect(currentTTL).toBeGreaterThanOrEqual(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);
         });
     });
-    describe('set', () => {
-        it('should set a key-value pair in redis', async () => {
+    (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);
-            expect(valueInRedis).toBe(JSON.stringify(value));
+            (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);
-            expect(currentTTL).toBeGreaterThanOrEqual(0);
+            (0, vitest_1.expect)(currentTTL).toBeGreaterThanOrEqual(0);
         });
-        it('should release the lock after setting a key-value pair', async () => {
+        (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);
-            expect(valueInRedis).toBe(JSON.stringify(value));
+            (0, vitest_1.expect)(valueInRedis).toBe(JSON.stringify(value));
             // Check that the lock is released
-            expect(redisCache.locks[keyWithPrefix]).toBeUndefined();
+            (0, vitest_1.expect)(redisCache.locks[keyWithPrefix]).toBeUndefined();
         });
     });
 });

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@autofleet/matmon",
-  "version": "2.3.1-beta-4",
+  "version": "2.3.1-beta-5",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {
     "build": "rm -rf lib && tsc",
     "prepublish": "npm run build",
-    "coverage": "jest --coverage --forceExit --runInBand",
-    "test": "jest --forceExit --runInBand",
-    "test-auto": "jest --watch --runInBand",
+    "coverage": "vitest --coverage",
+    "test": "vitest run",
+    "test-auto": "vitest run --watch",
     "linter": "./node_modules/.bin/eslint ."
   },
   "repository": {
@@ -24,7 +24,6 @@
   "homepage": "https://github.com/Autofleet/matmon",
   "dependencies": {
     "@autofleet/logger": "^4",
-    "@types/node": "^14.14.20",
     "async-mutex": "^0.2.6",
     "dotenv": "^8.2.0",
     "lru-cache": "^6.0.0",
@@ -35,13 +34,11 @@
   },
   "devDependencies": {
     "@autofleet/logger": "^4.0.3",
-    "@types/jest": "^29.5.14",
     "@types/lru-cache": "^5.1.1",
-    "@types/node": "^14.14.20",
+    "@types/node": "^20.17.10",
     "@types/redis": "^4.0.11",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.5.2"
+    "typescript": "^5.5.2",
+    "vitest": "^2.1.8"
   },
   "peerDependencies": {
     "@autofleet/logger": "^4"