dubs-server 1.0.0

package/services/redisService.js

@@ -0,0 +1,422 @@
+/**
+ * Redis Service - High-performance caching layer
+ * 
+ * Provides connection management with graceful fallback when Redis is unavailable.
+ * Used primarily for notification caching but designed for general-purpose caching.
+ */
+
+const Redis = require('ioredis');
+
+class RedisService {
+  constructor() {
+    this.client = null;
+    this.isConnected = false;
+    this.connectionAttempts = 0;
+    this.maxRetries = 3;
+    this.retryDelay = 1000;
+  }
+
+  /**
+   * Initialize Redis connection
+   * Gracefully handles missing REDIS_URL - will operate in fallback mode
+   */
+  async connect() {
+    const redisUrl = process.env.REDIS_URL;
+
+    if (!redisUrl) {
+      console.log('⚠️  [Redis] REDIS_URL not configured - running in PostgreSQL-only mode');
+      return false;
+    }
+
+    try {
+      this.client = new Redis(redisUrl, {
+        maxRetriesPerRequest: 3,
+        retryDelayOnFailover: 100,
+        enableReadyCheck: true,
+        lazyConnect: false,
+        // Connection pool settings
+        family: 4, // IPv4
+        connectTimeout: 10000,
+        // Heroku Redis requires TLS
+        tls: redisUrl.startsWith('rediss://') ? { rejectUnauthorized: false } : undefined,
+      });
+
+      // Event handlers
+      this.client.on('connect', () => {
+        console.log('✅ [Redis] Connected successfully');
+        this.isConnected = true;
+        this.connectionAttempts = 0;
+      });
+
+      this.client.on('error', (err) => {
+        console.error('❌ [Redis] Connection error:', err.message);
+        this.isConnected = false;
+      });
+
+      this.client.on('close', () => {
+        console.log('🔌 [Redis] Connection closed');
+        this.isConnected = false;
+      });
+
+      this.client.on('reconnecting', () => {
+        this.connectionAttempts++;
+        console.log(`🔄 [Redis] Reconnecting (attempt ${this.connectionAttempts})...`);
+      });
+
+      // Test connection
+      await this.client.ping();
+      this.isConnected = true;
+      return true;
+
+    } catch (error) {
+      console.error('❌ [Redis] Failed to connect:', error.message);
+      this.isConnected = false;
+      return false;
+    }
+  }
+
+  /**
+   * Check if Redis is available
+   */
+  isAvailable() {
+    return this.isConnected && this.client !== null;
+  }
+
+  /**
+   * Graceful disconnect
+   */
+  async disconnect() {
+    if (this.client) {
+      await this.client.quit();
+      this.client = null;
+      this.isConnected = false;
+      console.log('🔌 [Redis] Disconnected gracefully');
+    }
+  }
+
+  // ============================================
+  // SORTED SET OPERATIONS (for paginated lists)
+  // ============================================
+
+  /**
+   * Add item to sorted set with score (timestamp)
+   * @param {string} key - Sorted set key
+   * @param {number} score - Score (typically timestamp)
+   * @param {string} member - Member value (typically ID)
+   */
+  async zadd(key, score, member) {
+    if (!this.isAvailable()) return false;
+    try {
+      await this.client.zadd(key, score, member);
+      return true;
+    } catch (error) {
+      console.error('[Redis] zadd error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get range from sorted set (high to low score)
+   * Perfect for timestamp-based pagination
+   * @param {string} key - Sorted set key
+   * @param {number} start - Start index
+   * @param {number} stop - Stop index
+   * @param {boolean} withScores - Include scores in result
+   */
+  async zrevrange(key, start, stop, withScores = false) {
+    if (!this.isAvailable()) return null;
+    try {
+      if (withScores) {
+        return await this.client.zrevrange(key, start, stop, 'WITHSCORES');
+      }
+      return await this.client.zrevrange(key, start, stop);
+    } catch (error) {
+      console.error('[Redis] zrevrange error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get range by score (for cursor-based pagination)
+   * @param {string} key - Sorted set key
+   * @param {number} max - Max score (exclusive with '(' prefix)
+   * @param {number} min - Min score
+   * @param {number} offset - Offset for pagination
+   * @param {number} count - Number of items
+   */
+  async zrevrangebyscore(key, max, min, offset = 0, count = 10) {
+    if (!this.isAvailable()) return null;
+    try {
+      return await this.client.zrevrangebyscore(key, max, min, 'LIMIT', offset, count);
+    } catch (error) {
+      console.error('[Redis] zrevrangebyscore error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get score for a member
+   */
+  async zscore(key, member) {
+    if (!this.isAvailable()) return null;
+    try {
+      const score = await this.client.zscore(key, member);
+      return score ? parseFloat(score) : null;
+    } catch (error) {
+      console.error('[Redis] zscore error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get count of items in sorted set
+   */
+  async zcard(key) {
+    if (!this.isAvailable()) return null;
+    try {
+      return await this.client.zcard(key);
+    } catch (error) {
+      console.error('[Redis] zcard error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Remove member from sorted set
+   */
+  async zrem(key, member) {
+    if (!this.isAvailable()) return false;
+    try {
+      await this.client.zrem(key, member);
+      return true;
+    } catch (error) {
+      console.error('[Redis] zrem error:', error.message);
+      return false;
+    }
+  }
+
+  // ============================================
+  // HASH OPERATIONS (for structured data)
+  // ============================================
+
+  /**
+   * Set hash field(s)
+   * @param {string} key - Hash key
+   * @param {Object} data - Object with field:value pairs
+   */
+  async hset(key, data) {
+    if (!this.isAvailable()) return false;
+    try {
+      await this.client.hset(key, data);
+      return true;
+    } catch (error) {
+      console.error('[Redis] hset error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get all fields from hash
+   */
+  async hgetall(key) {
+    if (!this.isAvailable()) return null;
+    try {
+      const result = await this.client.hgetall(key);
+      return Object.keys(result).length > 0 ? result : null;
+    } catch (error) {
+      console.error('[Redis] hgetall error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Get multiple hashes at once (for batch lookups)
+   * @param {string[]} keys - Array of hash keys
+   */
+  async hmgetall(keys) {
+    if (!this.isAvailable() || keys.length === 0) return null;
+    try {
+      const pipeline = this.client.pipeline();
+      keys.forEach(key => pipeline.hgetall(key));
+      const results = await pipeline.exec();
+      return results.map(([err, data]) => {
+        if (err) return null;
+        return Object.keys(data).length > 0 ? data : null;
+      });
+    } catch (error) {
+      console.error('[Redis] hmgetall error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Delete hash
+   */
+  async hdel(key) {
+    if (!this.isAvailable()) return false;
+    try {
+      await this.client.del(key);
+      return true;
+    } catch (error) {
+      console.error('[Redis] hdel error:', error.message);
+      return false;
+    }
+  }
+
+  // ============================================
+  // COUNTER OPERATIONS
+  // ============================================
+
+  /**
+   * Increment counter
+   */
+  async incr(key) {
+    if (!this.isAvailable()) return null;
+    try {
+      return await this.client.incr(key);
+    } catch (error) {
+      console.error('[Redis] incr error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Decrement counter (min 0)
+   */
+  async decr(key) {
+    if (!this.isAvailable()) return null;
+    try {
+      const result = await this.client.decr(key);
+      // Ensure we don't go below 0
+      if (result < 0) {
+        await this.client.set(key, 0);
+        return 0;
+      }
+      return result;
+    } catch (error) {
+      console.error('[Redis] decr error:', error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Set counter to specific value
+   */
+  async set(key, value, ttlSeconds = null) {
+    if (!this.isAvailable()) return false;
+    try {
+      if (ttlSeconds) {
+        await this.client.set(key, value, 'EX', ttlSeconds);
+      } else {
+        await this.client.set(key, value);
+      }
+      return true;
+    } catch (error) {
+      console.error('[Redis] set error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Get value
+   */
+  async get(key) {
+    if (!this.isAvailable()) return null;
+    try {
+      return await this.client.get(key);
+    } catch (error) {
+      console.error('[Redis] get error:', error.message);
+      return null;
+    }
+  }
+
+  // ============================================
+  // TTL & CLEANUP
+  // ============================================
+
+  /**
+   * Set expiry on key
+   */
+  async expire(key, seconds) {
+    if (!this.isAvailable()) return false;
+    try {
+      await this.client.expire(key, seconds);
+      return true;
+    } catch (error) {
+      console.error('[Redis] expire error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Delete key(s)
+   */
+  async del(...keys) {
+    if (!this.isAvailable()) return false;
+    try {
+      await this.client.del(...keys);
+      return true;
+    } catch (error) {
+      console.error('[Redis] del error:', error.message);
+      return false;
+    }
+  }
+
+  /**
+   * Check if key exists
+   */
+  async exists(key) {
+    if (!this.isAvailable()) return false;
+    try {
+      return (await this.client.exists(key)) === 1;
+    } catch (error) {
+      console.error('[Redis] exists error:', error.message);
+      return false;
+    }
+  }
+
+  // ============================================
+  // SCAN OPERATIONS (for pattern-based key lookup)
+  // ============================================
+
+  /**
+   * Scan for keys matching a pattern using SCAN (non-blocking, production-safe).
+   * @param {string} pattern - Glob pattern (e.g. "user_game:*")
+   * @returns {string[]} - All matching keys
+   */
+  async scanKeys(pattern) {
+    if (!this.isAvailable()) return [];
+    try {
+      const keys = [];
+      let cursor = '0';
+      do {
+        const [nextCursor, batch] = await this.client.scan(cursor, 'MATCH', pattern, 'COUNT', 200);
+        cursor = nextCursor;
+        keys.push(...batch);
+      } while (cursor !== '0');
+      return keys;
+    } catch (error) {
+      console.error('[Redis] scanKeys error:', error.message);
+      return [];
+    }
+  }
+
+  // ============================================
+  // PIPELINE (for batch operations)
+  // ============================================
+
+  /**
+   * Create pipeline for batch operations
+   */
+  pipeline() {
+    if (!this.isAvailable()) return null;
+    return this.client.pipeline();
+  }
+}
+
+// Singleton instance
+const redisService = new RedisService();
+
+module.exports = redisService;
+
+