chore: Refactor cachedFunction to use selectorToCacheKey

Author: tomerh2001

src/index.d.ts

@@ -1,5 +1,14 @@
+import {
+	type Store,
+	type FactoryConfig,
+	type FactoryStore,
+} from 'cache-manager';
 import {type ArgumentPaths, type AnyFunction} from './paths.d';
 
-export type CachedFunctionOptions<F extends AnyFunction> = {
-	selector: ArgumentPaths<F>;
-};
+export type CachedFunctionInitializerOptions =
+	{store: FactoryStore; config: FactoryConfig} |
+	{store: Store};
+
+export type CachedFunctionOptions<F extends AnyFunction> =
+	CachedFunctionInitializerOptions &
+	{selector?: ArgumentPaths<F>; ttl?: number};

src/index.ts

@@ -1,8 +1,20 @@
 
 import _ from 'lodash';
-import type {CachedFunctionOptions} from './index.d';
+import {type Cache, caching} from 'cache-manager';
+import type {CachedFunctionInitializerOptions, CachedFunctionOptions} from './index.d';
 import type {AnyFunction, ArgumentPaths} from './paths.d';
 
+let cache: Cache | undefined;
+
+export async function getOrInitializeCache(options: CachedFunctionInitializerOptions) {
+	if (!('store' in options)) {
+		throw new Error('store is required');
+	}
+
+	cache ||= await ('config' in options ? caching(options.store, options.config) : caching(options.store));
+	return cache;
+}
+
 export function selectorToCacheKey<F extends AnyFunction>(arguments_: Parameters<F>, selector: ArgumentPaths<F>) {
 	const selectors = _.castArray(selector);
 	const values = _.at(arguments_, selectors);

tests/cache.test.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+	describe, it, expect, beforeEach,
+} from 'bun:test';
+import {memoryStore} from 'cache-manager';
+import {getOrInitializeCache, selectorToCacheKey} from '../src/index';
+import type {CachedFunctionInitializerOptions} from '../src/index.d';
+
+describe('getOrInitializeCache', () => {
+	beforeEach(() => {
+		global.cache = undefined;
+	});
+
+	it('should initialize cache with config when options include config', async () => {
+		const options: CachedFunctionInitializerOptions = {
+			store: memoryStore(),
+			config: {max: 100, ttl: 60},
+		};
+
+		const result = await getOrInitializeCache(options);
+
+		expect(result).toBeDefined();
+		expect(result.store).toBeDefined();
+	});
+
+	it('should initialize cache without config when options do not include config', async () => {
+		const options: CachedFunctionInitializerOptions = {
+			store: memoryStore(),
+		};
+
+		const result = await getOrInitializeCache(options);
+
+		expect(result).toBeDefined();
+		expect(result.store).toBeDefined();
+	});
+
+	it('should reuse the initialized cache', async () => {
+		const options: CachedFunctionInitializerOptions = {
+			store: memoryStore(),
+		};
+
+		const firstInit = await getOrInitializeCache(options);
+		const secondInit = await getOrInitializeCache(options);
+
+		expect(firstInit).toBe(secondInit);
+	});
+
+	it('should throw an error if store is not provided', async () => {
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+		const options = {
+			config: {max: 100, ttl: 60},
+		} as any;
+
+		// eslint-disable-next-line @typescript-eslint/await-thenable, @typescript-eslint/no-confusing-void-expression
+		await expect(getOrInitializeCache(options)).rejects.toThrow('store is required');
+	});
+});
+
+describe('selectorToCacheKey', () => {
+	it('should generate a cache key for a single argument path', () => {
+		const arguments_ = [{id: 1, name: 'test'}];
+		const selector = '0.id';
+		const key = selectorToCacheKey(arguments_, selector);
+
+		expect(key).toBe('{"0.id":1}');
+	});
+
+	it('should generate a cache key for multiple argument paths', () => {
+		const arguments_ = [{id: 1, name: 'test'}, {value: 'data'}];
+		const key = selectorToCacheKey(arguments_, ['0.id', '1.value']);
+
+		expect(key).toBe('{"0.id":1,"1.value":"data"}');
+	});
+
+	it('should handle empty selectors and arguments', () => {
+		const arguments_: any = [];
+		const selector: any = [];
+		const key = selectorToCacheKey(arguments_, selector);
+
+		expect(key).toBe('{}');
+	});
+});