caching layer implementation for improved performance

lib/cache.ts

@@ -0,0 +1,79 @@
+// Simple in-memory cache implementation (Redis simulation for development)
+// In production, this would be replaced with actual Redis client
+
+interface CacheEntry {
+  value: any
+  expiry: number
+}
+
+class SimpleCache {
+  private cache = new Map<string, CacheEntry>()
+
+  set(key: string, value: any, ttlSeconds = 300): void {
+    const expiry = Date.now() + (ttlSeconds * 1000)
+    this.cache.set(key, { value, expiry })
+  }
+
+  get<T>(key: string): T | null {
+    const entry = this.cache.get(key)
+    
+    if (!entry) return null
+    
+    if (Date.now() > entry.expiry) {
+      this.cache.delete(key)
+      return null
+    }
+    
+    return entry.value as T
+  }
+
+  del(key: string): void {
+    this.cache.delete(key)
+  }
+
+  clear(): void {
+    this.cache.clear()
+  }
+
+  // Clean expired entries
+  cleanup(): void {
+    const now = Date.now()
+    Array.from(this.cache.entries()).forEach(([key, entry]) => {
+      if (now > entry.expiry) {
+        this.cache.delete(key)
+      }
+    })
+  }
+}
+
+// Global cache instance
+export const cache = new SimpleCache()
+
+// Cleanup expired entries every 5 minutes
+setInterval(() => {
+  cache.cleanup()
+}, 5 * 60 * 1000)
+
+export function getCacheKey(...parts: (string | number)[]): string {
+  return parts.join(':')
+}
+
+export async function cacheWrapper<T>(
+  key: string,
+  fetcher: () => Promise<T>,
+  ttl = 300
+): Promise<T> {
+  // Try to get from cache first
+  const cached = cache.get<T>(key)
+  if (cached !== null) {
+    return cached
+  }
+
+  // Fetch fresh data
+  const data = await fetcher()
+  
+  // Cache the result
+  cache.set(key, data, ttl)
+  
+  return data
+}