full upgrade to dev

lib/redis.ts

@@ -1,27 +1,42 @@
-import { createClient } from 'redis';
+import { createClient } from "redis";
 
 let redisClient: ReturnType<typeof createClient> | null = null;
 let connectionFailed = false; // Track if connection has permanently failed
 
+interface RedisError {
+  code?: string;
+  message?: string;
+  errors?: RedisError[];
+  cause?: unknown;
+}
+
 // Helper to check if error is connection refused
-const isConnectionRefused = (err: any): boolean => {
+const isConnectionRefused = (err: unknown): boolean => {
   if (!err) return false;
-  
+
+  const error = err as RedisError;
+
   // Check direct properties
-  if (err.code === 'ECONNREFUSED' || err.message?.includes('ECONNREFUSED')) {
+  if (
+    error.code === "ECONNREFUSED" ||
+    error.message?.includes("ECONNREFUSED")
+  ) {
     return true;
   }
-  
+
   // Check AggregateError
-  if (err.errors && Array.isArray(err.errors)) {
-    return err.errors.some((e: any) => e?.code === 'ECONNREFUSED' || e?.message?.includes('ECONNREFUSED'));
+  if (error.errors && Array.isArray(error.errors)) {
+    return error.errors.some(
+      (e: RedisError) =>
+        e?.code === "ECONNREFUSED" || e?.message?.includes("ECONNREFUSED"),
+    );
   }
-  
+
   // Check nested error
-  if (err.cause) {
-    return isConnectionRefused(err.cause);
+  if (error.cause) {
+    return isConnectionRefused(error.cause);
   }
-  
+
   return false;
 };
 
@@ -38,7 +53,7 @@ export const getRedisClient = async () => {
 
   if (!redisClient) {
     const redisUrl = process.env.REDIS_URL;
-    
+
     try {
       redisClient = createClient({
         url: redisUrl,
@@ -50,46 +65,46 @@ export const getRedisClient = async () => {
               return false;
             }
             return false; // Don't reconnect automatically
-          }
-        }
+          },
+        },
       });
 
-      redisClient.on('error', (err: any) => {
+      redisClient.on("error", (err: unknown) => {
         // Silently handle connection refused errors - Redis is optional
         if (isConnectionRefused(err)) {
           connectionFailed = true;
           return; // Don't log connection refused errors
         }
         // Only log non-connection-refused errors
-        console.error('Redis Client Error:', err);
+        console.error("Redis Client Error:", err);
       });
 
-      redisClient.on('connect', () => {
-        console.log('Redis Client Connected');
+      redisClient.on("connect", () => {
+        console.log("Redis Client Connected");
         connectionFailed = false; // Reset on successful connection
       });
 
-      redisClient.on('ready', () => {
-        console.log('Redis Client Ready');
+      redisClient.on("ready", () => {
+        console.log("Redis Client Ready");
         connectionFailed = false; // Reset on ready
       });
 
-      redisClient.on('end', () => {
-        console.log('Redis Client Disconnected');
+      redisClient.on("end", () => {
+        console.log("Redis Client Disconnected");
       });
 
-      await redisClient.connect().catch((err: any) => {
+      await redisClient.connect().catch((err: unknown) => {
         // Connection failed
         if (isConnectionRefused(err)) {
           connectionFailed = true;
           // Silently handle connection refused - Redis is optional
         } else {
           // Only log non-connection-refused errors
-          console.error('Redis connection failed:', err);
+          console.error("Redis connection failed:", err);
         }
         redisClient = null;
       });
-    } catch (error: any) {
+    } catch (error: unknown) {
       // If connection fails, set to null
       if (isConnectionRefused(error)) {
         connectionFailed = true;
@@ -116,7 +131,7 @@ export const cache = {
       if (!client) return null;
       const value = await client.get(key);
       return value ? JSON.parse(value) : null;
-    } catch (error) {
+    } catch (_error) {
       // Silently fail if Redis is not available
       return null;
     }
@@ -128,7 +143,7 @@ export const cache = {
       if (!client) return false;
       await client.setEx(key, ttlSeconds, JSON.stringify(value));
       return true;
-    } catch (error) {
+    } catch (_error) {
       // Silently fail if Redis is not available
       return false;
     }
@@ -140,7 +155,7 @@ export const cache = {
       if (!client) return false;
       await client.del(key);
       return true;
-    } catch (error) {
+    } catch (_error) {
       // Silently fail if Redis is not available
       return false;
     }
@@ -151,7 +166,7 @@ export const cache = {
       const client = await getRedisClient();
       if (!client) return false;
       return await client.exists(key);
-    } catch (error) {
+    } catch (_error) {
       // Silently fail if Redis is not available
       return false;
     }
@@ -163,11 +178,11 @@ export const cache = {
       if (!client) return false;
       await client.flushAll();
       return true;
-    } catch (error) {
+    } catch (_error) {
       // Silently fail if Redis is not available
       return false;
     }
-  }
+  },
 };
 
 // Session management
@@ -188,7 +203,7 @@ export const session = {
 
   async destroy(sessionId: string) {
     return await cache.del(sessionId);
-  }
+  },
 };
 
 // Analytics caching
@@ -202,16 +217,16 @@ export const analyticsCache = {
   },
 
   async getOverallStats() {
-    return await cache.get('analytics:overall');
+    return await cache.get("analytics:overall");
   },
 
   async setOverallStats(stats: unknown, ttlSeconds = 600) {
-    return await cache.set('analytics:overall', stats, ttlSeconds);
+    return await cache.set("analytics:overall", stats, ttlSeconds);
   },
 
   async invalidateProject(projectId: number) {
     await cache.del(`analytics:project:${projectId}`);
-    await cache.del('analytics:overall');
+    await cache.del("analytics:overall");
   },
 
   async clearAll() {
@@ -219,12 +234,12 @@ export const analyticsCache = {
       const client = await getRedisClient();
       if (!client) return;
       // Clear all analytics-related keys
-      const keys = await client.keys('analytics:*');
+      const keys = await client.keys("analytics:*");
       if (keys.length > 0) {
         await client.del(keys);
       }
-    } catch (error) {
+    } catch (_error) {
       // Silently fail if Redis is not available
     }
-  }
+  },
 };