chore: Refactor cachedFunction to use selectorToCacheKey

Author: tomerh2001

src/index.d.ts

@@ -9,7 +9,7 @@ export type CachedFunctionInitializerOptions =
 	{store: FactoryStore; config: FactoryConfig} |
 	{store: Store};
 
-export type CachedFunctionOptions<F extends AnyFunction> = CachedFunctionInitializerOptions & {
+export type CachedFunctionOptions<F extends AnyFunction> = Partial<CachedFunctionInitializerOptions> & {
 	selector: ArgumentPaths<F>;
 	ttl?: number;
 };

src/index.ts

@@ -1,21 +1,22 @@
 import _ from 'lodash';
-import {type Cache, caching} from 'cache-manager';
+import {type Cache, caching, type Store} from 'cache-manager';
 import type {CachedFunctionInitializerOptions, CachedFunctionOptions} from './index.d';
 import type {AnyFunction, ArgumentPaths} from './paths.d';
 
 let cache: Cache | undefined;
 
-export async function initializeCache(options?: CachedFunctionInitializerOptions) {
+export async function getOrInitializeCache<S extends Store>(options?: CachedFunctionInitializerOptions) {
 	if (!cache && !options) {
 		throw new Error('cache is not initialized and no options provided');
 	}
 
-	if (options && !('store' in options)) {
-		throw new Error('store is required');
+	if (!cache && options && !('store' in options)) {
+		throw new Error('Store is not provided in options but is required to initialize the cache');
 	}
 
 	cache ||= await ('config' in options! ? caching(options.store, options.config) : caching(options!.store));
-	return cache;
+
+	return cache as Cache<S>;
 }
 
 export function resetCache() {
@@ -43,8 +44,7 @@ export function selectorToCacheKey<F extends AnyFunction>(arguments_: Parameters
 export function cachedFunction<F extends AnyFunction>(function_: F, options: CachedFunctionOptions<F>) {
 	return async (...arguments_: Parameters<F>): Promise<ReturnType<F>> => {
 		const cacheKey = selectorToCacheKey(arguments_, options.selector);
-
-		const cache = await initializeCache(options);
+		const cache = await getOrInitializeCache(options as CachedFunctionInitializerOptions);
 
 		const cacheValue = await cache.get<ReturnType<F>>(cacheKey);
 		if (cacheValue !== undefined) {

src/paths.d.ts

@@ -20,13 +20,9 @@ export type AnyFunction = (...arguments_: any[]) => any;
  *
  * @template T - The type of the object.
  */
-export type Paths<T> = T extends Record<string, unknown>
-	? {[K in keyof T]: `${Exclude<K, symbol>}${'' | `.${Paths<T[K]>}`}`}[keyof T]
-	: T extends Array<infer U>
-		? Paths<U> extends string
-			? `${number}` | `${number}.${Paths<U>}`
-			: never
-		: never;
+type Paths<T> = T extends Record<string, unknown> ? {[K in keyof T]:
+	`${Exclude<K, symbol>}${'' | `.${Paths<T[K]>}`}`
+}[keyof T] : never;
 
 /**
  * Represents the paths of the arguments of a given function type.

tests/index.test.ts

@@ -4,7 +4,7 @@ import {
 } from 'bun:test';
 import {memoryStore} from 'cache-manager';
 import {
-	initializeCache, selectorToCacheKey, cachedFunction, resetCache,
+	getOrInitializeCache, selectorToCacheKey, cachedFunction, resetCache,
 } from '../src/index';
 import type {CachedFunctionInitializerOptions, CachedFunctionOptions} from '../src/index.d';
 
@@ -19,7 +19,7 @@ describe('initializeCache', () => {
 			config: {max: 100, ttl: 60},
 		};
 
-		const result = await initializeCache(options);
+		const result = await getOrInitializeCache(options);
 
 		expect(result).toBeDefined();
 		expect(result.store).toBeDefined();
@@ -30,7 +30,7 @@ describe('initializeCache', () => {
 			store: memoryStore(),
 		};
 
-		const result = await initializeCache(options);
+		const result = await getOrInitializeCache(options);
 
 		expect(result).toBeDefined();
 		expect(result.store).toBeDefined();
@@ -41,8 +41,8 @@ describe('initializeCache', () => {
 			store: memoryStore(),
 		};
 
-		const firstInit = await initializeCache(options);
-		const secondInit = await initializeCache(options);
+		const firstInit = await getOrInitializeCache(options);
+		const secondInit = await getOrInitializeCache(options);
 
 		expect(firstInit).toBe(secondInit);
 	});
@@ -52,11 +52,12 @@ describe('initializeCache', () => {
 			config: {max: 100, ttl: 60},
 		} as any;
 
-		await expect(initializeCache(options)).rejects.toThrow('store is required');
+		await expect(getOrInitializeCache(options)).rejects.toThrow('Store is not provided in options but is required to initialize the cache');
 	});
 
 	it('should throw an error if cache is not initialized and no options are provided', async () => {
-		await expect(initializeCache()).rejects.toThrow('cache is not initialized and no options provided');
+		resetCache();
+		await expect(getOrInitializeCache()).rejects.toThrow('cache is not initialized and no options provided');
 	});
 
 	it('should initialize cache only once, even with multiple config calls', async () => {
@@ -65,8 +66,8 @@ describe('initializeCache', () => {
 			config: {max: 100, ttl: 60},
 		};
 
-		const firstCall = await initializeCache(options);
-		const secondCall = await initializeCache();
+		const firstCall = await getOrInitializeCache(options);
+		const secondCall = await getOrInitializeCache();
 
 		expect(firstCall).toBe(secondCall);
 	});

tests/redis.test.ts

@@ -0,0 +1,38 @@
+import {random} from 'lodash';
+import {type RedisStore, redisStore} from 'cache-manager-ioredis-yet';
+import {cachedFunction, getOrInitializeCache, resetCache} from '../src';
+
+type Person = {
+	id?: string;
+	name: string;
+	age: number;
+	address: {
+		street: string;
+		city: string;
+	};
+};
+
+async function createPerson(person: Person) {
+	person.id = random(0, 100_000).toString();
+	console.log('Person created!!!!!');
+	return person;
+}
+
+const cache = await getOrInitializeCache<RedisStore>({
+	store: await redisStore(),
+});
+const cachedCreatePerson = cachedFunction(createPerson, {
+	selector: '0.id',
+	ttl: 10_000,
+});
+
+const person = await cachedCreatePerson({
+	name: 'Tomer Horowitz',
+	age: 23,
+	address: {
+		street: '123 Main St.',
+		city: 'Springfield',
+	},
+});
+console.log(person.id, person.name);
+