feat: Add force option to cachedFunction

Author: tomerh2001

src/index.d.ts

@@ -12,4 +12,5 @@ export type CachedFunctionInitializerOptions =
 export type CachedFunctionOptions<F extends AnyFunction> = Partial<CachedFunctionInitializerOptions> & {
 	selector?: ArgumentPaths<F>;
 	ttl?: number;
+	force?: boolean;
 };

src/index.ts

@@ -1,7 +1,12 @@
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
 import _ from 'lodash';
-import {type Cache, caching, type Store} 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';
+import type {AnyFunction as CacheableFunction, ArgumentPaths} from './paths.d';
 
 let cache: Cache | undefined;
 
@@ -19,11 +24,14 @@ export async function getOrInitializeCache<S extends Store>(options?: CachedFunc
 	return cache as Cache<S>;
 }
 
+/**
+	* @deprecated To close any open connections, please retrieve the cache object from `getOrInitializeCache` and close it directly.
+	*/
 export function resetCache() {
 	cache = undefined;
 }
 
-export function selectorToCacheKey<F extends AnyFunction>(arguments_: Parameters<F>, selector: ArgumentPaths<F>) {
+export function selectorToCacheKey<F extends CacheableFunction>(arguments_: Parameters<F>, selector: ArgumentPaths<F>) {
 	const selectors = _.castArray(selector);
 	if (selectors.length === 0) {
 		return JSON.stringify(arguments_);
@@ -45,26 +53,47 @@ export function selectorToCacheKey<F extends AnyFunction>(arguments_: Parameters
 	return JSON.stringify(result);
 }
 
-export function cachedFunction<F extends AnyFunction>(function_: F, options: CachedFunctionOptions<F>) {
+export function cachedFunction<F extends CacheableFunction>(function_: F, options?: CachedFunctionOptions<F>) {
 	return async (...arguments_: Parameters<F>): Promise<ReturnType<F>> => {
-		const selector = options.selector ?? function_.cacheKeys ?? [];
-		const cacheKey = selectorToCacheKey(arguments_, selector);
+		const cacheOptions = _.merge({}, options ?? {}, function_.cacheOptions ?? {});
+		if (_.keys(cacheOptions).length === 0) {
+			throw new Error('No cache options provided, either use the @CacheOptions decorator or provide options to cachedFunction directly.');
+		}
+
+		const cacheKey = selectorToCacheKey(arguments_, cacheOptions.selector!);
 		const cache = await getOrInitializeCache(options as CachedFunctionInitializerOptions);
 
 		const cacheValue = await cache.get<ReturnType<F>>(cacheKey);
-		if (cacheValue !== undefined) {
+		if (!cacheOptions.force && cacheValue !== undefined) {
 			return cacheValue;
 		}
 
 		const result = await function_(...arguments_) as ReturnType<F>;
-		await cache.set(cacheKey, result, options.ttl);
+		await cache.set(cacheKey, result, cacheOptions.ttl);
 
 		return result;
 	};
 }
 
-export function cacheKeys<F extends AnyFunction>(function_: F, ...selector: Array<ArgumentPaths<F>>) {
-	const selectors = _(selector).flatMap().value();
-	function_.cacheKeys = selectors;
-	return function_;
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export function CacheOptions<F extends CacheableFunction>(
+	selectorOrOptions: ArgumentPaths<F> | CachedFunctionOptions<F>,
+	ttl?: number,
+) {
+	const options = (_.isArrayLike(selectorOrOptions) || _.isString(selectorOrOptions))
+		? {selector: selectorOrOptions, ttl}
+		: selectorOrOptions as CachedFunctionOptions<F>;
+
+	return (
+		_target: any,
+		_propertyKey: string | symbol,
+		descriptor: TypedPropertyDescriptor<F>,
+	): any => {
+		if (!descriptor.value) {
+			return;
+		}
+
+		descriptor.value.cacheOptions = options;
+		return descriptor;
+	};
 }

src/paths.d.ts

@@ -1,7 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+import {type Cache} from 'cache-manager';
 import _ from 'lodash';
+import {type CachedFunctionOptions} from './index.d';
 
 /**
  * Represents a type that can either be a single value of type T or an array of type T.
@@ -14,7 +16,7 @@ export type SingleOrArray<T> = T | T[];
  * Represents any function that takes any number of arguments and returns any value.
  */
 export type AnyFunction = ((...arguments_: any[]) => any) & {
-	cacheKeys?: string[];
+	cacheOptions?: CachedFunctionOptions<any>;
 };
 
 /**

tests/redis.test.ts

@@ -1,6 +1,14 @@
+/* eslint-disable @typescript-eslint/unbound-method */
 import {random} from 'lodash';
 import {type RedisStore, redisStore} from 'cache-manager-ioredis-yet';
-import {cachedFunction, getOrInitializeCache} from '../src';
+import {cachedFunction, CacheOptions, getOrInitializeCache} from '../src';
+
+const cache = await getOrInitializeCache<RedisStore>({
+	store: await redisStore({
+		host: 'localhost',
+		port: 6379,
+	}),
+});
 
 type Person = {
 	id?: string;
@@ -12,22 +20,15 @@ type Person = {
 	};
 };
 
-async function createPerson(person: Person) {
-	console.log('Person created!!!!!');
-	return person;
+class CachedPersonCreator {
+	@CacheOptions({selector: '0.name', ttl: 1000})
+	static async createPerson(person: Person) {
+		console.log('Person created!!!!!');
+		return person;
+	}
 }
 
-const cache = await getOrInitializeCache<RedisStore>({
-	store: await redisStore({
-		host: 'localhost',
-		port: 6379,
-	}),
-});
-const cachedCreatePerson = cachedFunction(createPerson, {
-	selector: '0.name',
-	ttl: 1000,
-});
-
+const cachedCreatePerson = cachedFunction(CachedPersonCreator.createPerson);
 const person = await cachedCreatePerson({
 	id: random(0, 100_000).toString(),
 	name: 'Tomer Horowitz',

tsconfig.json

@@ -17,6 +17,8 @@
     "allowJs": true,
     "types": [
       "bun-types" // add Bun global
-    ]
+    ],
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
   }
 }