refactor: improve typing by adding generics to setItem methods

- Add generic type parameter `<T>` to setItem methods in all interfaces
  allowing type-safe content storage: `setItem<T>(key, content: T | undefined)`
- Update AbstractBaseStrategy and ExpirationStrategy with generic setItem
- Update all storage implementations with generic setItem methods
- Narrow intermediate deserialization types in Redis storages from `unknown`
  to more specific union types (e.g., `string | T` during JSON parsing)
- Fix test to use explicit union type for mixed content arrays

This improves type inference and allows consumers to get compile-time
type checking when storing typed data in the cache.

Author: claude

storages/lru-redis/src/LRUWithRedisStorage.ts

@@ -45,7 +45,11 @@ export class LRUWithRedisStorage implements IAsynchronousCacheType {
 	}
 
 	/** ttl in seconds! */
-	public async setItem(key: string, content: unknown, options?: { ttl?: number }): Promise<void> {
+	public async setItem<T = unknown>(
+		key: string,
+		content: T | undefined,
+		options?: { ttl?: number }
+	): Promise<void> {
 		this.myCache.set(key, content);
 		if (this.options?.maxAge) {
 			await this.redis().setex(key, options?.ttl || this.options.maxAge, JSON.stringify(content));

storages/lru/src/LRUStorage.ts

@@ -18,7 +18,7 @@ export class LRUStorage implements ISynchronousCacheType, IMultiSynchronousCache
 		};
 	}
 
-	setItems(values: { key: string; content: unknown }[]): void {
+	setItems<T = unknown>(values: { key: string; content: T | undefined }[]): void {
 		values.forEach(val => {
 			this.myCache.set(val.key, val.content);
 		});
@@ -28,7 +28,7 @@ export class LRUStorage implements ISynchronousCacheType, IMultiSynchronousCache
 		return this.myCache.get(key) as T | undefined;
 	}
 
-	public setItem(key: string, content: unknown): void {
+	public setItem<T = unknown>(key: string, content: T | undefined): void {
 		this.myCache.set(key, content);
 	}
 

storages/node-cache/src/node-cache.storage.ts

@@ -13,15 +13,15 @@ export class NodeCacheStorage implements ISynchronousCacheType, IMultiSynchronou
 		return this.myCache.mget(keys);
 	}
 
-	setItems(values: { key: string; content: unknown }[]): void {
+	setItems<T = unknown>(values: { key: string; content: T | undefined }[]): void {
 		this.myCache.mset(values.map(v => ({ key: v.key, val: v.content })));
 	}
 
 	public getItem<T>(key: string): T | undefined {
 		return this.myCache.get(key) || undefined;
 	}
 
-	public setItem(key: string, content: unknown): void {
+	public setItem<T = unknown>(key: string, content: T | undefined): void {
 		this.myCache.set(key, content);
 	}
 

storages/redis/src/redis.storage.ts

@@ -20,26 +20,23 @@ export class RedisStorage implements IAsynchronousCacheType {
 		if (entry === null) {
 			return undefined;
 		}
-		let finalItem: unknown = entry;
+		// Try to parse as JSON, fallback to raw string
+		let parsedItem: T | string = entry;
 		try {
-			finalItem = JSON.parse(entry);
+			parsedItem = JSON.parse(entry) as T;
 		} catch (error) {
-			/** ignore */
+			/** Not JSON, keep as string */
 		}
-		return finalItem as T | undefined;
+		return parsedItem as T | undefined;
 	}
 
-	public async setItem(key: string, content: unknown): Promise<void> {
-		let stringContent: string;
+	public async setItem<T = unknown>(key: string, content: T | undefined): Promise<void> {
 		if (content === undefined) {
 			await this.client.delAsync(key);
 			return;
 		}
-		if (typeof content === 'object') {
-			stringContent = JSON.stringify(content);
-		} else {
-			stringContent = String(content);
-		}
+		const stringContent: string =
+			typeof content === 'object' ? JSON.stringify(content) : String(content);
 		await this.client.setAsync(key, stringContent);
 	}
 

storages/redisio/src/redisio.storage.ts

@@ -32,18 +32,23 @@ export class RedisIOStorage implements IAsynchronousCacheType, IMultiIAsynchrono
 						return [keys[i], null]; // value does exist, but is empty
 					}
 
-					let finalItem: unknown =
+					// Decompress if needed, result is a string
+					const stringValue: string =
 						entry && this.options.compress
 							? await this.uncompress(entry as Buffer)
 							: (entry as string);
 
+					// Try to parse as JSON
+					let parsedItem: T | string = stringValue;
 					try {
-						finalItem = finalItem && JSON.parse(finalItem as string);
+						if (stringValue) {
+							parsedItem = JSON.parse(stringValue) as T;
+						}
 					} catch (error) {
-						/** ignore */
+						/** Not JSON, keep as string */
 					}
 
-					return [keys[i], finalItem];
+					return [keys[i], parsedItem];
 				})
 			)
 		);
@@ -61,8 +66,8 @@ export class RedisIOStorage implements IAsynchronousCacheType, IMultiIAsynchrono
 		return result.toString();
 	}
 
-	async setItems(
-		values: { key: string; content: unknown }[],
+	async setItems<T = unknown>(
+		values: { key: string; content: T | undefined }[],
 		options?: { ttl?: number }
 	): Promise<void> {
 		const redisPipeline = this.redis().pipeline();
@@ -95,7 +100,7 @@ export class RedisIOStorage implements IAsynchronousCacheType, IMultiIAsynchrono
 	}
 
 	public async getItem<T>(key: string): Promise<T | undefined> {
-		const entry = this.options.compress
+		const entry: Buffer | string | null = this.options.compress
 			? await this.redis().getBuffer(key)
 			: await this.redis().get(key);
 		if (entry === null) {
@@ -104,36 +109,44 @@ export class RedisIOStorage implements IAsynchronousCacheType, IMultiIAsynchrono
 		if (entry === '') {
 			return null as T; // value exists but is empty
 		}
-		let finalItem: unknown =
+
+		// Decompress if needed, result is a string
+		const stringValue: string =
 			entry && this.options.compress ? await this.uncompress(entry as Buffer) : (entry as string);
 
+		// Try to parse as JSON
+		let parsedItem: T | string = stringValue;
 		try {
-			finalItem = JSON.parse(finalItem as string);
+			parsedItem = JSON.parse(stringValue) as T;
 		} catch (error) {
-			/** ignore */
+			/** Not JSON, keep as string */
 		}
-		return finalItem as T;
+		return parsedItem as T;
 	}
 
-	public async setItem(key: string, content: unknown, options?: { ttl?: number }): Promise<void> {
-		if (typeof content === 'object') {
-			content = JSON.stringify(content);
-		} else if (content === undefined) {
+	public async setItem<T = unknown>(
+		key: string,
+		content: T | undefined,
+		options?: { ttl?: number }
+	): Promise<void> {
+		if (content === undefined) {
 			await this.redis().del(key);
 			return;
 		}
 
+		// Serialize to string, then optionally compress
+		let serialized: string | Buffer =
+			typeof content === 'object' ? JSON.stringify(content) : String(content);
+
 		if (this.options.compress) {
-			content = await this.compress(content as string);
+			serialized = await this.compress(serialized);
 		}
 
 		const ttl = options?.ttl ?? this.options.maxAge;
-		let savePromise: Promise<'OK' | null>;
-		if (ttl) {
-			savePromise = this.redis().setex(key, ttl, content as Buffer | string);
-		} else {
-			savePromise = this.redis().set(key, content as Buffer | string);
-		}
+		const savePromise: Promise<'OK' | null> = ttl
+			? this.redis().setex(key, ttl, serialized)
+			: this.redis().set(key, serialized);
+
 		if (this.errorHandler) {
 			// if we have an error handler, we do not need to await the result
 			savePromise.catch(err => this.errorHandler && this.errorHandler(err));

storages/redisio/test/redis.storage.test.ts

@@ -83,7 +83,7 @@ describe('RedisIOStorage', () => {
 		});
 
 		it('Mutli Should set and retrieve item correclty', async () => {
-			await storage.setItems([
+			await storage.setItems<{ asdf: number } | string>([
 				{ key: 'test', content: { asdf: 2 } },
 				{ key: 'test2', content: '2' }
 			]);

ts-cache/src/storage/fs/fs.json.storage.ts

@@ -14,7 +14,7 @@ export class FsJsonStorage implements IAsynchronousCacheType {
 		return (await this.getCacheObject())[key] as T | undefined;
 	}
 
-	public async setItem(key: string, content: unknown): Promise<void> {
+	public async setItem<T = unknown>(key: string, content: T | undefined): Promise<void> {
 		const cache = await this.getCacheObject();
 		cache[key] = content;
 		await this.setCache(cache);

ts-cache/src/storage/memory/memory.storage.ts

@@ -7,7 +7,7 @@ export class MemoryStorage implements ISynchronousCacheType {
 		return this.memCache[key] as T | undefined;
 	}
 
-	public setItem(key: string, content: unknown): void {
+	public setItem<T = unknown>(key: string, content: T | undefined): void {
 		this.memCache[key] = content;
 	}
 

ts-cache/src/strategy/caching/abstract.base.strategy.ts

@@ -9,7 +9,11 @@ export abstract class AbstractBaseStrategy implements IAsynchronousCacheType {
 
 	public abstract getItem<T>(key: string): Promise<T | undefined>;
 
-	public abstract setItem(key: string, content: unknown, options?: ICacheOptions): Promise<void>;
+	public abstract setItem<T = unknown>(
+		key: string,
+		content: T | undefined,
+		options?: ICacheOptions
+	): Promise<void>;
 
 	public abstract clear(): Promise<void>;
 }

ts-cache/src/strategy/caching/expiration.strategy.ts

@@ -35,7 +35,11 @@ export class ExpirationStrategy extends AbstractBaseStrategy {
 		return item.meta !== false && typeof item.meta.ttl === 'number';
 	}
 
-	public async setItem(key: string, content: unknown, options?: ICacheOptions): Promise<void> {
+	public async setItem<T = unknown>(
+		key: string,
+		content: T | undefined,
+		options?: ICacheOptions
+	): Promise<void> {
 		const mergedOptions: IExpirationOptions = {
 			ttl: 60,
 			isLazy: true,