cache: add .clear()

Author: feunard

packages/cache-redis/src/providers/RedisCacheProvider.ts

@@ -87,6 +87,13 @@ export class RedisCacheProvider implements CacheProvider {
 		return this.redisProvider.keys(`${this.prefix(name)}:*`);
 	}
 
+	public async clear(): Promise<void> {
+		this.log.debug("Clearing all cache");
+		const pattern = `${this.prefix()}:*`;
+		const keys = await this.redisProvider.keys(pattern);
+		await this.redisProvider.del(keys);
+	}
+
 	protected prefix(...path: string[]): string {
 		const parts = ["cache", ...path];
 

packages/cache-redis/test/cache-redis.spec.ts

@@ -8,6 +8,7 @@ import {
 	testCacheInvalidateByKey,
 	testCacheKeys,
 	testCacheMissingProvider,
+	testCacheProviderClear,
 	testCacheReturnTypes,
 	testCacheStop,
 	testSimpleKeyMappingHandler,
@@ -61,3 +62,7 @@ test("$cache - keys (redis)", async () => {
 test("$cache - unique key with args (redis)", async () => {
 	await testSimpleKeyMappingHandler();
 });
+
+test("$cache - provider clear (redis)", async () => {
+	await testCacheProviderClear(env(), provider);
+});

packages/cache/src/providers/CacheProvider.ts

@@ -46,4 +46,9 @@ export abstract class CacheProvider {
 	public abstract has(name: string, key: string): Promise<boolean>;
 
 	public abstract keys(name: string, filter?: string): Promise<string[]>;
+
+	/**
+	 * Remove all keys from all cache names.
+	 */
+	public abstract clear(): Promise<void>;
 }

packages/cache/src/providers/MemoryCacheProvider.ts

@@ -100,4 +100,20 @@ export class MemoryCacheProvider implements CacheProvider {
 		}
 		return keys;
 	}
+
+	public async clear(): Promise<void> {
+		this.log.debug("Clearing all cache");
+
+		// Clear all timeouts before clearing the store
+		for (const name of Object.keys(this.store)) {
+			for (const key of Object.keys(this.store[name])) {
+				const timeout = this.store[name][key]?.timeout;
+				if (timeout) {
+					this.dateTimeProvider.clearTimeout(timeout);
+				}
+			}
+		}
+
+		this.store = {};
+	}
 }

packages/cache/test/$cache.spec.ts

@@ -13,6 +13,7 @@ import {
 	testCacheInvalidateByKey,
 	testCacheKeys,
 	testCacheMissingProvider,
+	testCacheProviderClear,
 	testCacheReturnTypes,
 	testCacheStop,
 	testSimpleKeyMappingHandler,
@@ -102,3 +103,7 @@ test("$cache - unique key", async () => {
 test("$cache - unique key with args", async () => {
 	await testSimpleKeyMappingHandler();
 });
+
+test("$cache - provider clear", async () => {
+	await testCacheProviderClear();
+});

packages/cache/test/shared.ts

@@ -320,3 +320,58 @@ export const testSimpleKeyMappingHandler = async (
 	expect(await app.run("B")).toBe("B=2");
 	expect(await app.run("C")).toBe("C=3");
 };
+
+export const testCacheProviderClear = async (
+	env: Env = {},
+	cacheProvider: Service<CacheProvider> = MemoryCacheProvider,
+): Promise<void> => {
+	class TestClearCache {
+		cursor_a = 0;
+		cursor_b = 0;
+
+		a = $cache({
+			key: (args) => args.name,
+			ttl: [5, "seconds"],
+			handler: async (user: { name: string }) => {
+				return `${user.name}:${this.cursor_a++}`;
+			},
+		});
+
+		b = $cache({
+			key: (args) => args.name,
+			handler: async (user: { name: string }) => {
+				return `${user.name}:${this.cursor_b++}`;
+			},
+		});
+	}
+
+	const app = Alepha.create({
+		env,
+	}).with({
+		provide: CacheProvider,
+		use: cacheProvider,
+	});
+
+	const test = app.inject(TestClearCache);
+	const provider = app.inject(CacheProvider);
+	await app.start();
+
+	// Set some cache values
+	expect(await test.a({ name: "A" })).toBe("A:0");
+	expect(await test.a({ name: "A" })).toBe("A:0");
+	expect(await test.a({ name: "B" })).toBe("B:1");
+	expect(await test.b({ name: "C" })).toBe("C:0");
+	expect(await test.b({ name: "C" })).toBe("C:0");
+
+	// Verify cache is working
+	expect(await test.a({ name: "A" })).toBe("A:0");
+	expect(await test.b({ name: "C" })).toBe("C:0");
+
+	// Clear all cache
+	await provider.clear();
+
+	// Verify cache was cleared - new values should be generated
+	expect(await test.a({ name: "A" })).toBe("A:2");
+	expect(await test.a({ name: "B" })).toBe("B:3");
+	expect(await test.b({ name: "C" })).toBe("C:1");
+};