myavana-bot-test-core 2.1.8 → 2.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myavana-bot-test-core",
-    "version": "2.1.8",
+    "version": "2.2.0",
     "description": "Shared bot functionality with enhanced features",
     "main": "index.js",
     "scripts": {

package/src/cacheManager.js

@@ -1,27 +1,118 @@
-// cacheManager.js
+// cacheManager.js - PRODUCTION VERSION WITH MULTI-LAYER FALLBACK
 
 const ai = require('./ai');
 const { googleAI } = require('@genkit-ai/google-genai');
 const { pgClient, redisClient } = require('./database');
-const  {GoogleGenAI} = require("@google/genai");
+const { GoogleGenAI } = require("@google/genai");
 const config = require('./config');
 
 /**
- * Cache Manager for Gemini API
- * Handles creation, retrieval, and expiration of cached system instructions
+ * Cache Manager for Gemini API with Multi-Layer Storage
+ * Storage Layers (in order of preference):
+ * 1. PostgreSQL (persistent, shared across instances)
+ * 2. Redis (fast, shared across instances)
+ * 3. Memory (fastest, single instance only)
  */
 const cacheAi = new GoogleGenAI({ apiKey: config.genkitApiKey });
+
 class CacheManager {
     constructor() {
         this.CACHE_TTL_HOURS = 24;
-        this.CACHE_TTL_SECONDS = this.CACHE_TTL_HOURS * 60 * 60; // 24 hours in seconds
+        this.CACHE_TTL_SECONDS = this.CACHE_TTL_HOURS * 60 * 60;
+        this.CACHE_REFRESH_THRESHOLD_HOURS = 1;
+        
+        // In-memory fallback (last resort)
+        this.memoryCache = new Map();
+        
+        console.log('🔧 Cache Manager initialized with multi-layer storage');
     }
 
     /**
-     * Get or create a cache for a user's system prompt
-     * @param {string} userId - User identifier
-     * @param {string} systemPrompt - The large system instruction to cache
-     * @returns {Promise<{cacheName: string, isNewCache: boolean}>}
+     * Check cache validity across all storage layers
+     */
+    async checkCacheValidity(userId) {
+        console.log('🔍 Quick cache check for user:', userId);
+        const checkStart = performance.now();
+        
+        try {
+            // Try all layers in order of preference
+            let existingCache = null;
+            let source = 'none';
+            
+            // Layer 1: PostgreSQL (preferred)
+            existingCache = await this.getUserCache(userId);
+            if (existingCache) {
+                source = 'postgresql';
+            }
+            
+            // Layer 2: Redis (if PostgreSQL failed)
+            if (!existingCache && redisClient) {
+                existingCache = await this.getUserCacheFromRedis(userId);
+                if (existingCache) source = 'redis';
+            }
+            
+            // Layer 3: Memory (if both failed)
+            if (!existingCache) {
+                existingCache = this.getUserCacheFromMemory(userId);
+                if (existingCache) source = 'memory';
+            }
+            
+            if (!existingCache) {
+                console.log('📭 No cache exists (checked:', (performance.now() - checkStart).toFixed(0), 'ms)');
+                return {
+                    hasValidCache: false,
+                    cacheName: null,
+                    needsRefresh: false,
+                    reason: 'no_cache',
+                    source: 'none'
+                };
+            }
+            
+            if (this.isCacheExpired(existingCache)) {
+                console.log('⏰ Cache expired (from:', source, ')');
+                return {
+                    hasValidCache: false,
+                    cacheName: null,
+                    needsRefresh: true,
+                    reason: 'expired',
+                    source: source
+                };
+            }
+            
+            const remainingHours = this.getCacheRemainingHours(existingCache);
+            const needsRefresh = remainingHours < this.CACHE_REFRESH_THRESHOLD_HOURS;
+            
+            console.log('✅ Valid cache found:', {
+                source: source,
+                cacheName: existingCache.cache_name,
+                remainingHours: remainingHours,
+                needsRefresh: needsRefresh,
+                checkTime: (performance.now() - checkStart).toFixed(0) + 'ms'
+            });
+            
+            return {
+                hasValidCache: true,
+                cacheName: existingCache.cache_name,
+                needsRefresh: needsRefresh,
+                remainingHours: remainingHours,
+                reason: 'valid',
+                source: source
+            };
+            
+        } catch (error) {
+            console.error('❌ Cache check failed:', error.message);
+            return {
+                hasValidCache: false,
+                cacheName: null,
+                needsRefresh: false,
+                reason: 'error',
+                source: 'none'
+            };
+        }
+    }
+
+    /**
+     * Get or create cache
      */
     async getOrCreateCache(userId, systemPrompt) {
         console.log('🔍 ===== CACHE MANAGER: GET OR CREATE =====');
@@ -33,18 +124,11 @@ class CacheManager {
         });
 
         try {
-            // Try to get existing cache for user
-            const existingCache = await this.getUserCache(userId);
+            // Quick check across all layers
+            const existingCache = await this.getUserCacheFromAnyLayer(userId);
             
             if (existingCache && !this.isCacheExpired(existingCache)) {
-                console.log('✅ Using existing cache:', {
-                    cacheName: existingCache.cache_name,
-                    createdAt: existingCache.created_at,
-                    expiresAt: existingCache.expires_at,
-                    ageHours: this.getCacheAgeHours(existingCache),
-                    remainingHours: this.getCacheRemainingHours(existingCache)
-                });
-                
+                console.log('✅ Using existing cache:', existingCache.cache_name);
                 return {
                     cacheName: existingCache.cache_name,
                     isNewCache: false
@@ -52,9 +136,10 @@ class CacheManager {
             }
 
             // Create new cache
-            console.log('🆕 Creating new cache for user:', userId);
+            console.log('🆕 Creating new Gemini cache...');
             const cacheStartTime = performance.now();
-            const modelName = "gemini-3-flash-preview"
+            const modelName = "gemini-3-flash-preview";
+            
             const cache = await cacheAi.caches.create({
                 model: modelName,
                 config: {
@@ -64,17 +149,18 @@ class CacheManager {
             });
 
             const cacheCreationTime = performance.now() - cacheStartTime;
-            console.log('✅ Cache created successfully:', {
+            console.log('✅ Gemini cache created:', {
                 cacheName: cache.name,
                 creationTime: cacheCreationTime.toFixed(2) + 'ms',
                 ttlHours: this.CACHE_TTL_HOURS,
                 expiresAt: new Date(Date.now() + this.CACHE_TTL_SECONDS * 1000).toISOString()
             });
 
-            // Save cache info to database
-            await this.saveUserCache(userId, cache.name);
+            // Save to all available storage layers
+            const saveStart = performance.now();
+            await this.saveUserCacheMultiLayer(userId, cache.name);
+            console.log('💾 Multi-layer save completed:', (performance.now() - saveStart).toFixed(0), 'ms');
             
-            console.log('💾 Cache info saved to database');
             console.log('🔍 ===== CACHE MANAGER: COMPLETE =====');
 
             return {
@@ -89,7 +175,6 @@ class CacheManager {
                 timestamp: new Date().toISOString()
             });
             
-            // Return null to indicate cache unavailable - caller should proceed without cache
             return {
                 cacheName: null,
                 isNewCache: false,
@@ -99,166 +184,327 @@ class CacheManager {
     }
 
     /**
-     * Get user's cache info from database
-     * @param {string} userId 
-     * @returns {Promise<object|null>}
+     * Try to get cache from any available layer
      */
-    async getUserCache(userId) {
-        console.log('📂 Fetching cache info from database for user:', userId);
+    async getUserCacheFromAnyLayer(userId) {
+        // Try PostgreSQL
+        let cache = await this.getUserCache(userId);
+        if (cache) return cache;
+        
+        // Try Redis
+        if (redisClient) {
+            cache = await this.getUserCacheFromRedis(userId);
+            if (cache) return cache;
+        }
+        
+        // Try Memory
+        return this.getUserCacheFromMemory(userId);
+    }
+
+    /**
+     * Save cache to all available layers (don't fail if one fails)
+     */
+    async saveUserCacheMultiLayer(userId, cacheName) {
+        const expiresAt = new Date(Date.now() + this.CACHE_TTL_SECONDS * 1000);
+        const cacheData = {
+            cache_name: cacheName,
+            created_at: new Date(),
+            expires_at: expiresAt
+        };
+        
+        const results = {
+            postgresql: false,
+            redis: false,
+            memory: false
+        };
+        
+        // Layer 1: PostgreSQL (primary)
+        try {
+            await this.saveUserCacheToPostgres(userId, cacheName, expiresAt);
+            results.postgresql = true;
+        } catch (error) {
+            console.error('❌ PostgreSQL save failed:', error.message);
+        }
+        
+        // Layer 2: Redis (fast fallback)
+        if (redisClient) {
+            try {
+                await this.saveUserCacheToRedis(userId, cacheData);
+                results.redis = true;
+            } catch (error) {
+                console.error('❌ Redis save failed:', error.message);
+            }
+        }
+        
+        // Layer 3: Memory (always succeeds)
+        try {
+            this.saveUserCacheToMemory(userId, cacheData);
+            results.memory = true;
+        } catch (error) {
+            console.error('❌ Memory save failed:', error.message);
+        }
+        
+        console.log('💾 Multi-layer save results:', results);
+        
+        // At least one layer must succeed
+        if (!results.postgresql && !results.redis && !results.memory) {
+            throw new Error('All cache storage layers failed');
+        }
+    }
+
+    /**
+     * Save to PostgreSQL with automatic fallback to DELETE+INSERT
+     */
+    async saveUserCacheToPostgres(userId, cacheName, expiresAt) {
+        console.log('💾 Saving to PostgreSQL...');
         
+        try {
+            // First try UPSERT (requires PRIMARY KEY or UNIQUE constraint)
+            try {
+                const query = `
+                    INSERT INTO user_gemini_caches (user_id, cache_name, created_at, expires_at) 
+                    VALUES ($1, $2, NOW(), $3)
+                    ON CONFLICT (user_id) 
+                    DO UPDATE SET 
+                        cache_name = EXCLUDED.cache_name,
+                        created_at = NOW(),
+                        expires_at = EXCLUDED.expires_at
+                `;
+                
+                await pgClient.query(query, [userId, cacheName, expiresAt]);
+                console.log('✅ PostgreSQL save successful (UPSERT)');
+                return true;
+                
+            } catch (upsertError) {
+                // If UPSERT fails (error code 42P10 = no constraint), use DELETE + INSERT
+                if (upsertError.code === '42P10') {
+                    console.log('⚠️ No constraint found, using DELETE+INSERT fallback');
+                    
+                    // Delete old record
+                    await pgClient.query(
+                        `DELETE FROM user_gemini_caches WHERE user_id = $1`,
+                        [userId]
+                    );
+                    
+                    // Insert new record
+                    await pgClient.query(
+                        `INSERT INTO user_gemini_caches (user_id, cache_name, created_at, expires_at) 
+                         VALUES ($1, $2, NOW(), $3)`,
+                        [userId, cacheName, expiresAt]
+                    );
+                    
+                    console.log('✅ PostgreSQL save successful (DELETE+INSERT)');
+                    return true;
+                } else {
+                    throw upsertError; // Re-throw if it's a different error
+                }
+            }
+            
+        } catch (error) {
+            console.error('❌ PostgreSQL save completely failed:', error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Save to Redis
+     */
+    async saveUserCacheToRedis(userId, cacheData) {
+        console.log('💾 Saving to Redis...');
+        
+        try {
+            const key = `gemini_cache:${userId}`;
+            await redisClient.setex(
+                key, 
+                this.CACHE_TTL_SECONDS, 
+                JSON.stringify(cacheData)
+            );
+            console.log('✅ Redis save successful');
+            return true;
+        } catch (error) {
+            console.error('❌ Redis save failed:', error.message);
+            throw error;
+        }
+    }
+
+    /**
+     * Save to Memory (always succeeds)
+     */
+    saveUserCacheToMemory(userId, cacheData) {
+        console.log('💾 Saving to memory...');
+        this.memoryCache.set(userId, cacheData);
+        console.log('✅ Memory save successful');
+        
+        // Auto-cleanup after TTL
+        setTimeout(() => {
+            if (this.memoryCache.has(userId)) {
+                this.memoryCache.delete(userId);
+                console.log('🧹 Auto-removed expired cache from memory:', userId);
+            }
+        }, this.CACHE_TTL_SECONDS * 1000);
+        
+        return true;
+    }
+
+    /**
+     * Get from PostgreSQL
+     */
+    async getUserCache(userId) {
         try {
             const query = `
                 SELECT cache_name, created_at, expires_at 
                 FROM user_gemini_caches 
-                WHERE user_id = ? 
+                WHERE user_id = $1 
                 ORDER BY created_at DESC 
                 LIMIT 1
             `;
             
             const result = await pgClient.query(query, [userId]);
             
-            if (result && result.length > 0) {
-                console.log('✅ Found existing cache record:', {
-                    cacheName: result[0].cache_name,
-                    createdAt: result[0].created_at,
-                    expiresAt: result[0].expires_at
-                });
-                return result[0];
+            if (result && result.rows && result.rows.length > 0) {
+                return result.rows[0];
             }
             
-            console.log('📭 No existing cache found for user');
             return null;
             
         } catch (error) {
-            console.error('❌ Database query failed:', error.message);
+            console.error('❌ PostgreSQL fetch failed:', error.message);
             return null;
         }
     }
 
     /**
-     * Save cache info to database
-     * @param {string} userId 
-     * @param {string} cacheName 
+     * Get from Redis
      */
-    async saveUserCache(userId, cacheName) {
-        console.log('💾 Saving cache info to database:', {
-            userId: userId,
-            cacheName: cacheName
-        });
-
+    async getUserCacheFromRedis(userId) {
+        if (!redisClient) return null;
+        
         try {
-            const expiresAt = new Date(Date.now() + this.CACHE_TTL_SECONDS * 1000);
+            const key = `gemini_cache:${userId}`;
+            const data = await redisClient.get(key);
             
-            const query = `
-                INSERT INTO user_gemini_caches 
-                (user_id, cache_name, created_at, expires_at) 
-                VALUES (?, ?, NOW(), ?)
-                ON DUPLICATE KEY UPDATE 
-                    cache_name = VALUES(cache_name),
-                    created_at = NOW(),
-                    expires_at = VALUES(expires_at)
-            `;
-            
-            await pgClient.query(query, [userId, cacheName, expiresAt]);
+            if (data) {
+                return JSON.parse(data);
+            }
             
-            console.log('✅ Cache info saved successfully');
+            return null;
             
         } catch (error) {
-            console.error('❌ Failed to save cache info:', error.message);
-            // Don't throw - cache creation succeeded, DB save is secondary
+            console.error('❌ Redis fetch failed:', error.message);
+            return null;
         }
     }
 
+    /**
+     * Get from Memory
+     */
+    getUserCacheFromMemory(userId) {
+        return this.memoryCache.get(userId) || null;
+    }
+
     /**
      * Check if cache is expired
-     * @param {object} cacheRecord 
-     * @returns {boolean}
      */
     isCacheExpired(cacheRecord) {
         const now = new Date();
         const expiresAt = new Date(cacheRecord.expires_at);
-        
-        const isExpired = now >= expiresAt;
-        
-        if (isExpired) {
-            console.log('⏰ Cache expired:', {
-                expiresAt: expiresAt.toISOString(),
-                now: now.toISOString(),
-                expiredBy: ((now - expiresAt) / (1000 * 60)).toFixed(2) + ' minutes'
-            });
-        }
-        
-        return isExpired;
+        return now >= expiresAt;
     }
 
     /**
      * Get cache age in hours
-     * @param {object} cacheRecord 
-     * @returns {number}
      */
     getCacheAgeHours(cacheRecord) {
         const now = new Date();
         const createdAt = new Date(cacheRecord.created_at);
         const ageMs = now - createdAt;
-        return (ageMs / (1000 * 60 * 60)).toFixed(2);
+        return parseFloat((ageMs / (1000 * 60 * 60)).toFixed(2));
     }
 
     /**
      * Get remaining cache lifetime in hours
-     * @param {object} cacheRecord 
-     * @returns {number}
      */
     getCacheRemainingHours(cacheRecord) {
         const now = new Date();
         const expiresAt = new Date(cacheRecord.expires_at);
         const remainingMs = expiresAt - now;
-        return Math.max(0, (remainingMs / (1000 * 60 * 60)).toFixed(2));
+        return Math.max(0, parseFloat((remainingMs / (1000 * 60 * 60)).toFixed(2)));
     }
 
     /**
-     * Clean up expired caches from database (maintenance task)
+     * Clean up expired caches from all layers
      */
     async cleanupExpiredCaches() {
-        console.log('🧹 Cleaning up expired caches...');
+        console.log('🧹 Cleaning up expired caches from all layers...');
+        
+        const results = {
+            postgresql: 0,
+            redis: 0,
+            memory: 0
+        };
         
+        // PostgreSQL cleanup
         try {
-            const query = `
-                DELETE FROM user_gemini_caches 
-                WHERE expires_at < NOW()
-            `;
-            
+            const query = `DELETE FROM user_gemini_caches WHERE expires_at < NOW()`;
             const result = await pgClient.query(query);
-            
-            console.log('✅ Cleanup complete:', {
-                deletedRecords: result.affectedRows || 0
-            });
-            
+            results.postgresql = result.rowCount || 0;
         } catch (error) {
-            console.error('❌ Cleanup failed:', error.message);
+            console.error('❌ PostgreSQL cleanup failed:', error.message);
+        }
+        
+        // Redis cleanup (would need to scan all keys - expensive, skip for now)
+        // Redis auto-expires with TTL, so not critical
+        
+        // Memory cleanup
+        for (const [userId, cacheData] of this.memoryCache.entries()) {
+            if (this.isCacheExpired(cacheData)) {
+                this.memoryCache.delete(userId);
+                results.memory++;
+            }
         }
+        
+        console.log('✅ Cleanup results:', results);
+        return results;
     }
 
     /**
-     * Get cache statistics for monitoring
+     * Get cache statistics
      */
     async getCacheStats() {
+        const stats = {
+            memory_caches: this.memoryCache.size,
+            postgresql: null,
+            redis: null
+        };
+        
+        // PostgreSQL stats
         try {
             const query = `
                 SELECT 
                     COUNT(*) as total_caches,
                     COUNT(CASE WHEN expires_at > NOW() THEN 1 END) as active_caches,
                     COUNT(CASE WHEN expires_at <= NOW() THEN 1 END) as expired_caches,
-                    AVG(TIMESTAMPDIFF(HOUR, created_at, NOW())) as avg_age_hours
+                    AVG(EXTRACT(EPOCH FROM (NOW() - created_at)) / 3600) as avg_age_hours
                 FROM user_gemini_caches
             `;
             
             const result = await pgClient.query(query);
-            return result[0];
-            
+            stats.postgresql = result.rows[0];
         } catch (error) {
-            console.error('❌ Failed to get cache stats:', error.message);
-            return null;
+            console.error('❌ PostgreSQL stats failed:', error.message);
         }
+        
+        // Redis stats (would need dbsize command)
+        if (redisClient) {
+            try {
+                const keys = await redisClient.keys('gemini_cache:*');
+                stats.redis = { total_keys: keys.length };
+            } catch (error) {
+                console.error('❌ Redis stats failed:', error.message);
+            }
+        }
+        
+        return stats;
     }
 }