cache.js

/**
 * In-Memory Cache Layer for AI Summaries
 * Reduces API calls by caching summaries for 24 hours
 * Falls back to database persistence
 */

class SummaryCache {
  constructor() {
    this.cache = new Map();
    this.ttl = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
  }

  /**
   * Generate cache key from user bookmarks
   * @param {number} userId - User FID
   * @returns {string} - Cache key
   */
  getCacheKey(userId) {
    return `summary_${userId}`;
  }

  /**
   * Get cached summary
   * @param {number} userId - User FID
   * @returns {object|null} - Cached summary or null if expired
   */
  get(userId) {
    const key = this.getCacheKey(userId);
    const entry = this.cache.get(key);

    if (!entry) {
      return null;
    }

    // Check if cache is expired
    const now = Date.now();
    if (now - entry.timestamp > this.ttl) {
      this.cache.delete(key);
      return null;
    }

    return entry.data;
  }

  /**
   * Set cache entry
   * @param {number} userId - User FID
   * @param {object} data - Summary data { summary, castCount, timestamp }
   */
  set(userId, data) {
    const key = this.getCacheKey(userId);
    this.cache.set(key, {
      data,
      timestamp: Date.now()
    });

    // Log cache hit
    console.log(`[CACHE] Set summary for user ${userId}`);
  }

  /**
   * Invalidate cache for user (after new bookmarks)
   * @param {number} userId - User FID
   */
  invalidate(userId) {
    const key = this.getCacheKey(userId);
    if (this.cache.has(key)) {
      this.cache.delete(key);
      console.log(`[CACHE] Invalidated cache for user ${userId}`);
    }
  }

  /**
   * Get cache statistics
   * @returns {object} - Cache stats { size, entries, memoryUsage }
   */
  getStats() {
    const entries = Array.from(this.cache.entries());
    return {
      size: this.cache.size,
      entries: entries.map(([key, value]) => ({
        key,
        cached_at: new Date(value.timestamp).toISOString(),
        expires_at: new Date(value.timestamp + this.ttl).toISOString()
      })),
      memoryUsage: JSON.stringify(Array.from(this.cache.values())).length
    };
  }

  /**
   * Clear all cache
   */
  clear() {
    this.cache.clear();
    console.log('[CACHE] Cleared all cache');
  }

  /**
   * Clear expired entries
   */
  clearExpired() {
    const now = Date.now();
    let cleared = 0;

    for (const [key, entry] of this.cache.entries()) {
      if (now - entry.timestamp > this.ttl) {
        this.cache.delete(key);
        cleared++;
      }
    }

    if (cleared > 0) {
      console.log(`[CACHE] Cleared ${cleared} expired entries`);
    }
  }
}

// Create singleton instance
const summaryCache = new SummaryCache();

// Auto-cleanup expired entries every 6 hours
setInterval(() => {
  summaryCache.clearExpired();
}, 6 * 60 * 60 * 1000);

module.exports = summaryCache;