chore: Update npm dependencies and add cache manager functions and tests

Author: tomerh2001

bun.lockb

@@ -13,6 +13,8 @@
     "@semantic-release/release-notes-generator": "^14.0.1",
     "@types/lodash": "^4.17.7",
     "bun-types": "latest",
+    "jest": "^29.7.0",
+    "vitest": "^2.0.5",
     "xo": "^0.59.3"
   },
   "peerDependencies": {
@@ -23,6 +25,7 @@
   },
   "dependencies": {
     "cache-manager": "^5.7.6",
+    "cache-manager-ioredis-yet": "^2.1.1",
     "cache-manager-redis-store": "^3.0.1",
     "eslint-plugin-th-rules": "^1.13.4",
     "lodash": "^4.17.21",

package.json

@@ -2,42 +2,42 @@
 // eslint-disable-next-line import/no-unassigned-import
 import 'reflect-metadata';
 import cacheManager, {type Cache} from 'cache-manager';
-import {redisStore} from 'cache-manager-redis-store';
+import {redisStore} from 'cache-manager-ioredis-yet';
 import {get} from 'lodash';
 
-type CacheInitializationConfig = {
+export type CacheInitializationConfig = {
 	host?: string;
 	port?: number;
 	password?: string;
 	ttl: number;
 };
 
-type KeySelector = ((...arguments_: unknown[]) => unknown[]) | string | string[];
+export type KeySelector = ((...arguments_: unknown[]) => unknown[]) | string | string[];
 
-type CacheOptions = {
+export type CacheOptions = {
 	ttl: number;
 	keySelector: KeySelector;
 } & Partial<CacheInitializationConfig>;
 
 let cacheManagerInstance: Cache | undefined;
 
 /**
- * Initializes the cache manager with Redis store by default.
+ * Initializes the cache manager with ioredis store by default.
  */
-async function initializeCache(config: CacheInitializationConfig): Promise<void> {
-	cacheManagerInstance = await cacheManager.caching({
-		store: redisStore,
+export async function initializeCache(config: CacheInitializationConfig): Promise<void> {
+	const store = async () => redisStore({
 		host: config.host ?? 'localhost',
 		port: config.port ?? 6379,
 		password: config.password,
-		ttl: config.ttl,
 	});
+
+	cacheManagerInstance = await cacheManager.caching(store, {ttl: config.ttl});
 }
 
 /**
  * Automatically initializes cache if not already initialized and initialization data is present.
  */
-async function ensureCacheInitialized(config?: CacheInitializationConfig): Promise<void> {
+export async function ensureCacheInitialized(config?: CacheInitializationConfig): Promise<void> {
 	if (!cacheManagerInstance && config) {
 		await initializeCache(config);
 	}
@@ -47,7 +47,7 @@ async function ensureCacheInitialized(config?: CacheInitializationConfig): Promi
  * Decorator to provide metadata for caching with TTL and key selection.
  */
 export function cacheMeta(options: CacheOptions) {
-	return async (target: unknown, propertyKey: string): Promise<void> => {
+	return async (target: Record<string, unknown>, propertyKey: string): Promise<void> => {
 		await ensureCacheInitialized(options);
 		Reflect.defineMetadata('cacheKeySelector', options.keySelector, target, propertyKey);
 		Reflect.defineMetadata('cacheTtl', options.ttl, target, propertyKey);
@@ -86,7 +86,7 @@ export function cache(options: CacheOptions) {
 /**
  * Creates a cache key based on the key selector function or paths.
  */
-function createCacheKey(arguments_: unknown[], keySelector: KeySelector): string {
+export function createCacheKey(arguments_: unknown[], keySelector: KeySelector): string {
 	if (typeof keySelector === 'function') {
 		const result = keySelector(...arguments_);
 		return Array.isArray(result) ? result.join(':') : String(result);

src/index.ts

@@ -1,136 +1,96 @@
-import 'reflect-metadata'; // eslint-disable-line import/no-unassigned-import
-import {
-	expect, describe, it, afterEach,
-	mock,
-} from 'bun:test';
-import cacheManager, {type Cache} from 'cache-manager';
-import {redisStore} from 'cache-manager-redis-store';
+
+import {test, expect} from 'bun:test';
 import {
-	cache, cacheMeta, cacheFunction, initializeCache, ensureCacheInitialized,
+	initializeCache,
+	ensureCacheInitialized,
+	cacheMeta,
+	cache,
+	createCacheKey,
+	cacheFunction,
+	type CacheInitializationConfig,
 } from '../src/index';
 
-mock(cacheManager.caching, function_ => ({
-	async caching(config) {
-		return mockCacheManagerInstance;
-	},
-}));
-mock(redisStore, () => jest.fn());
-
-const mockCacheManagerInstance: Partial<Cache> = {
-	get: mock(async () => null),
-	set: mock(async () => undefined),
+const testConfig: CacheInitializationConfig = {
+	host: '127.0.0.1',
+	port: 6379,
+	ttl: 300,
 };
 
-describe('Cache Manager Functions', () => {
-	afterEach(() => {
-		mockCacheManagerInstance.get.mockClear();
-		mockCacheManagerInstance.set.mockClear();
-	});
-
-	describe('initializeCache', () => {
-		it('should initialize cache with given config', async () => {
-			await initializeCache({host: 'localhost', port: 6379, ttl: 100});
-
-			expect(cacheManager.caching).toHaveBeenCalledWith({
-				store: redisStore,
-				host: 'localhost',
-				port: 6379,
-				password: undefined,
-				ttl: 100,
-			});
-		});
-	});
-
-	describe('ensureCacheInitialized', () => {
-		it('should initialize cache if not already initialized', async () => {
-			await ensureCacheInitialized({ttl: 200});
-
-			expect(cacheManager.caching).toHaveBeenCalled();
-		});
-
-		it('should not initialize cache if already initialized', async () => {
-			await initializeCache({ttl: 200});
-			await ensureCacheInitialized({ttl: 200});
-
-			expect(cacheManager.caching).toHaveBeenCalledTimes(1);
-		});
-	});
-
-	describe('cacheMeta', () => {
-		it('should define cache metadata correctly', async () => {
-			const target = {};
-			const propertyKey = 'testFunction';
+test('initializeCache initializes cache manager with correct configuration', async () => {
+	await initializeCache(testConfig);
 
-			await cacheMeta({ttl: 300, keySelector: 'key.path'})(target, propertyKey);
-
-			expect(Reflect.getMetadata('cacheKeySelector', target, propertyKey)).toEqual('key.path');
-			expect(Reflect.getMetadata('cacheTtl', target, propertyKey)).toEqual(300);
-		});
-	});
-
-	describe('cache', () => {
-		it('should cache the result of the decorated function', async () => {
-			const target = {};
-			const propertyKey = 'cachedMethod';
-			const originalMethod = mock(async () => 'result');
-			const descriptor = {
-				value: originalMethod,
-			};
+	expect(globalThis.cacheManagerInstance).toBeDefined();
+});
 
-			cache({ttl: 400, keySelector: 'id'})(target, propertyKey, descriptor);
+test('ensureCacheInitialized initializes cache if not initialized', async () => {
+	globalThis.cacheManagerInstance = undefined;
+	await ensureCacheInitialized(testConfig);
+	expect(globalThis.cacheManagerInstance).toBeDefined();
+});
 
-			mockCacheManagerInstance.get.mockResolvedValueOnce(null);
+test('ensureCacheInitialized does not initialize cache if already initialized', async () => {
+	globalThis.cacheManagerInstance = {get: async () => 'mocked'} as any;
+	await ensureCacheInitialized(testConfig);
+	expect(globalThis.cacheManagerInstance.get).toBeDefined();
+});
 
-			const result = await descriptor.value.apply({}, [{id: 1}]);
+test('createCacheKey generates key correctly based on keySelector function', () => {
+	const keySelector = (a: number, b: number) => [a, b];
+	const key = createCacheKey([1, 2], keySelector);
+	expect(key).toBe('1:2');
+});
 
-			expect(originalMethod).toHaveBeenCalledWith({id: 1});
-			expect(mockCacheManagerInstance.set).toHaveBeenCalledWith(expect.any(String), 'result', 400);
-			expect(result).toEqual('result');
-		});
+test('createCacheKey generates key correctly based on string selector', () => {
+	const key = createCacheKey([{name: 'test'}], 'name');
+	expect(key).toBe('test');
+});
 
-		it('should return cached result if available', async () => {
-			const target = {};
-			const propertyKey = 'cachedMethod';
-			const originalMethod = mock(async () => 'should not be called');
-			const descriptor = {
-				value: originalMethod,
-			};
+test('createCacheKey generates key correctly based on array of selectors', () => {
+	const key = createCacheKey([{name: 'test', age: 25}], ['name', 'age']);
+	expect(key).toBe('test:25');
+});
 
-			cache({ttl: 400, keySelector: 'id'})(target, propertyKey, descriptor);
+test('cacheMeta sets metadata correctly', async () => {
+	const options = {ttl: 300, keySelector: 'name'};
+	const target = {};
+	const propertyKey = 'testMethod';
 
-			mockCacheManagerInstance.get.mockResolvedValueOnce('cachedResult');
+	await cacheMeta(options)(target, propertyKey);
 
-			const result = await descriptor.value.apply({}, [{id: 1}]);
+	expect(Reflect.getMetadata('cacheKeySelector', target, propertyKey)).toBe('name');
+	expect(Reflect.getMetadata('cacheTtl', target, propertyKey)).toBe(300);
+});
 
-			expect(originalMethod).not.toHaveBeenCalled();
-			expect(result).toEqual('cachedResult');
-		});
-	});
+test('cache decorator caches function results', async () => {
+	await initializeCache(testConfig);
+	const options = {ttl: 300, keySelector: 'name'};
+	const target = {};
+	const descriptor = {
+		async value() {
+			return 'result';
+		},
+	} as PropertyDescriptor;
 
-	describe('cacheFunction', () => {
-		it('should cache the result of the function', async () => {
-			const function_ = mock(async () => 'computedValue');
-			const wrappedFunction = cacheFunction(function_, {ttl: 500, keySelector: 'name'});
+	cache(options)(target, 'testMethod', descriptor);
 
-			mockCacheManagerInstance.get.mockResolvedValueOnce(null);
+	const result = await descriptor.value({name: 'test'});
 
-			const result = await wrappedFunction({name: 'test'});
+	const cachedResult = await globalThis.cacheManagerInstance!.get('test');
 
-			expect(function_).toHaveBeenCalledWith({name: 'test'});
-			expect(mockCacheManagerInstance.set).toHaveBeenCalledWith(expect.any(String), 'computedValue', 500);
-			expect(result).toEqual('computedValue');
-		});
+	expect(result).toBe('result');
+	expect(cachedResult).toBe('result');
+});
 
-		it('should return cached result if available', async () => {
-			const function_ = mock(async () => 'should not be called');
-			const wrappedFunction = cacheFunction(function_, {ttl: 500, keySelector: 'name'});
+test('cacheFunction caches results correctly', async () => {
+	await initializeCache(testConfig);
+	const options = {ttl: 300, keySelector: 'name'};
+	const originalFunction = async () => 'result';
 
-			mockCacheManagerInstance.get.mockResolvedValueOnce('cachedValue');
+	const wrappedFunction = cacheFunction(originalFunction, options);
+	const result = await wrappedFunction({name: 'test'});
 
-			const result = await wrappedFunction({name: 'test'});
+	const cachedResult = await globalThis.cacheManagerInstance!.get('test');
 
-			expect(function_).not.toHaveBeenCalled();
-			expect(result).toEqual('cachedValue');
-		});
-	});
+	expect(result).toBe('result');
+	expect(cachedResult).toBe('result');
 });