@qwickapps/qwickbrain-proxy 1.0.2 → 1.1.0

package/src/lib/__tests__/cache-manager.test.ts

@@ -6,7 +6,7 @@ import { createDatabase, runMigrations } from '../../db/client.js';
 import { CacheManager } from '../cache-manager.js';
 import type { Config } from '../../types/config.js';
 
-describe('CacheManager', () => {
+describe('CacheManager - LRU Two-Tier Storage', () => {
   let tmpDir: string;
   let cacheManager: CacheManager;
   let db: ReturnType<typeof createDatabase>['db'];
@@ -22,12 +22,7 @@ describe('CacheManager', () => {
 
     const config: Config['cache'] = {
       dir: tmpDir,
-      ttl: {
-        workflows: 3600,
-        rules: 3600,
-        documents: 1800,
-        memories: 900,
-      },
+      maxCacheSizeBytes: 10 * 1024, // 10KB limit for testing
       preload: [],
     };
 
@@ -49,7 +44,7 @@ describe('CacheManager', () => {
       expect(cached?.data.content).toBe('content here');
       expect(cached?.data.doc_type).toBe('workflow');
       expect(cached?.data.name).toBe('test-workflow');
-      expect(cached?.isExpired).toBe(false);
+      expect(cached?.age).toBeGreaterThanOrEqual(0);
     });
 
     it('should store document with metadata', async () => {
@@ -97,29 +92,39 @@ describe('CacheManager', () => {
       expect(cached?.data.content).toBe('version 2');
     });
 
-    it('should mark document as expired after TTL', async () => {
-      // Override config to have very short TTL for testing
-      const shortTTLConfig: Config['cache'] = {
-        dir: tmpDir,
-        ttl: {
-          workflows: 0, // Expire immediately
-          rules: 0,
-          documents: 0,
-          memories: 0,
-        },
-        preload: [],
-      };
-
-      const shortCacheManager = new CacheManager(db, shortTTLConfig);
-      await shortCacheManager.setDocument('workflow', 'test', 'content');
-
-      // Wait to ensure timestamp difference
-      await new Promise(resolve => setTimeout(resolve, 100));
+    it('should mark critical document types as critical', async () => {
+      // Critical types: workflow, rule, agent, template
+      await cacheManager.setDocument('workflow', 'test-workflow', 'content');
+      await cacheManager.setDocument('rule', 'test-rule', 'content');
+      await cacheManager.setDocument('agent', 'test-agent', 'content');
+      await cacheManager.setDocument('template', 'test-template', 'content');
 
-      const cached = await shortCacheManager.getDocument('workflow', 'test');
+      // Non-critical type
+      await cacheManager.setDocument('frd', 'test-frd', 'content');
 
-      expect(cached).not.toBeNull();
-      expect(cached?.isExpired).toBe(true);
+      const stats = await cacheManager.getCacheStats();
+
+      expect(stats.criticalCount).toBe(4);
+      expect(stats.dynamicCount).toBeGreaterThan(0); // FRD is dynamic
+    });
+
+    it('should update lastAccessedAt on read', async () => {
+      await cacheManager.setDocument('workflow', 'test', 'content');
+
+      const cached1 = await cacheManager.getDocument('workflow', 'test');
+      const cachedAt1 = cached1?.cachedAt.getTime();
+
+      // Wait 200ms
+      await new Promise(resolve => setTimeout(resolve, 200));
+
+      const cached2 = await cacheManager.getDocument('workflow', 'test');
+      const cachedAt2 = cached2?.cachedAt.getTime();
+
+      // cachedAt should remain the same (shows when first cached)
+      expect(cachedAt2).toBe(cachedAt1);
+
+      // But age should increase over time
+      expect(cached2?.age).toBeGreaterThanOrEqual(0);
     });
   });
 
@@ -132,7 +137,6 @@ describe('CacheManager', () => {
       expect(cached).not.toBeNull();
       expect(cached?.data.content).toBe('memory content');
       expect(cached?.data.name).toBe('test-memory');
-      expect(cached?.isExpired).toBe(false);
     });
 
     it('should store memory with metadata', async () => {
@@ -168,83 +172,169 @@ describe('CacheManager', () => {
       const cached = await cacheManager.getMemory('non-existent');
       expect(cached).toBeNull();
     });
+  });
 
-    it('should mark memory as expired after TTL', async () => {
-      const shortTTLConfig: Config['cache'] = {
-        dir: tmpDir,
-        ttl: {
-          workflows: 0,
-          rules: 0,
-          documents: 0,
-          memories: 0,
-        },
-        preload: [],
-      };
-
-      const shortCacheManager = new CacheManager(db, shortTTLConfig);
-      await shortCacheManager.setMemory('test', 'content');
+  describe('LRU Eviction - Two-Tier Storage', () => {
+    it('should NOT evict critical documents when storage limit reached', async () => {
+      // Create large critical documents (workflows)
+      const largeContent = 'x'.repeat(3000); // 3KB each
+
+      // Add 4 critical documents = 12KB (exceeds 10KB limit)
+      await cacheManager.setDocument('workflow', 'critical1', largeContent);
+      await cacheManager.setDocument('workflow', 'critical2', largeContent);
+      await cacheManager.setDocument('workflow', 'critical3', largeContent);
+      await cacheManager.setDocument('workflow', 'critical4', largeContent);
+
+      // All should still be present (critical tier bypasses limit)
+      const doc1 = await cacheManager.getDocument('workflow', 'critical1');
+      const doc2 = await cacheManager.getDocument('workflow', 'critical2');
+      const doc3 = await cacheManager.getDocument('workflow', 'critical3');
+      const doc4 = await cacheManager.getDocument('workflow', 'critical4');
+
+      expect(doc1).not.toBeNull();
+      expect(doc2).not.toBeNull();
+      expect(doc3).not.toBeNull();
+      expect(doc4).not.toBeNull();
+    });
 
-      await new Promise(resolve => setTimeout(resolve, 100));
+    it('should evict oldest dynamic documents when storage limit reached', async () => {
+      const largeContent = 'x'.repeat(3000); // 3KB each
 
-      const cached = await shortCacheManager.getMemory('test');
+      // Add dynamic documents
+      await cacheManager.setDocument('frd', 'dynamic1', largeContent);
+      await new Promise(resolve => setTimeout(resolve, 10));
 
-      expect(cached).not.toBeNull();
-      expect(cached?.isExpired).toBe(true);
+      await cacheManager.setDocument('frd', 'dynamic2', largeContent);
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      await cacheManager.setDocument('frd', 'dynamic3', largeContent);
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      // Now add another that pushes us over limit (9KB current, 3KB new = 12KB > 10KB)
+      // Should evict dynamic1 (oldest)
+      await cacheManager.setDocument('frd', 'dynamic4', largeContent);
+
+      // dynamic1 should be evicted
+      const doc1 = await cacheManager.getDocument('frd', 'dynamic1');
+      expect(doc1).toBeNull();
+
+      // dynamic2, dynamic3, dynamic4 should remain
+      const doc2 = await cacheManager.getDocument('frd', 'dynamic2');
+      const doc3 = await cacheManager.getDocument('frd', 'dynamic3');
+      const doc4 = await cacheManager.getDocument('frd', 'dynamic4');
+
+      expect(doc2).not.toBeNull();
+      expect(doc3).not.toBeNull();
+      expect(doc4).not.toBeNull();
     });
-  });
 
-  describe('cleanupExpiredEntries', () => {
-    it('should delete expired documents and memories', async () => {
-      const shortTTLConfig: Config['cache'] = {
-        dir: tmpDir,
-        ttl: {
-          workflows: 0,
-          rules: 0,
-          documents: 0,
-          memories: 0,
-        },
-        preload: [],
-      };
-
-      const shortCacheManager = new CacheManager(db, shortTTLConfig);
-
-      // Add some items that will immediately expire
-      await shortCacheManager.setDocument('workflow', 'test1', 'content1');
-      await shortCacheManager.setDocument('rule', 'test2', 'content2');
-      await shortCacheManager.setMemory('memory1', 'content3');
-
-      // Wait to ensure they're expired (need sufficient time for clock to advance)
-      await new Promise(resolve => setTimeout(resolve, 100));
+    it('should use LRU ordering based on lastAccessedAt', async () => {
+      const largeContent = 'x'.repeat(3000); // 3KB each
 
-      // Clean up
-      const result = await shortCacheManager.cleanupExpiredEntries();
+      // Add 3 dynamic documents with delays to ensure distinct timestamps
+      await cacheManager.setDocument('frd', 'doc1', largeContent);
+      await new Promise(resolve => setTimeout(resolve, 50));
 
-      expect(result.documentsDeleted).toBe(2);
-      expect(result.memoriesDeleted).toBe(1);
+      await cacheManager.setDocument('frd', 'doc2', largeContent);
+      await new Promise(resolve => setTimeout(resolve, 50));
 
-      // Verify they're gone
-      const doc1 = await shortCacheManager.getDocument('workflow', 'test1');
-      const mem1 = await shortCacheManager.getMemory('memory1');
+      await cacheManager.setDocument('frd', 'doc3', largeContent);
+      await new Promise(resolve => setTimeout(resolve, 50));
 
-      expect(doc1).toBeNull();
-      expect(mem1).toBeNull();
+      // Access doc2 and doc3 (updates their lastAccessedAt to be newest)
+      await cacheManager.getDocument('frd', 'doc2');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      await cacheManager.getDocument('frd', 'doc3');
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      // Now doc1 has oldest lastAccessedAt, should be evicted first
+      // Add doc4, should evict doc1 (oldest access)
+      await cacheManager.setDocument('frd', 'doc4', largeContent);
+
+      const doc1 = await cacheManager.getDocument('frd', 'doc1');
+      const doc2 = await cacheManager.getDocument('frd', 'doc2');
+      const doc3 = await cacheManager.getDocument('frd', 'doc3');
+      const doc4 = await cacheManager.getDocument('frd', 'doc4');
+
+      expect(doc1).toBeNull(); // Oldest access, evicted
+      expect(doc2).not.toBeNull(); // Accessed recently, kept
+      expect(doc3).not.toBeNull(); // Accessed recently, kept
+      expect(doc4).not.toBeNull(); // Just added
+    });
+
+    it('should evict memories when document eviction insufficient', async () => {
+      const largeContent = 'x'.repeat(3000); // 3KB each
+
+      // Add one dynamic document
+      await cacheManager.setDocument('frd', 'doc1', largeContent);
+
+      // Add memories
+      await cacheManager.setMemory('mem1', largeContent);
+      await cacheManager.setMemory('mem2', largeContent);
+
+      // Current: 9KB (over limit when we add another 3KB)
+      // Should evict doc1 and mem1 to make room
+      await cacheManager.setDocument('frd', 'doc2', largeContent);
+
+      const doc1 = await cacheManager.getDocument('frd', 'doc1');
+      const mem1 = await cacheManager.getMemory('mem1');
+      const mem2 = await cacheManager.getMemory('mem2');
+
+      // At least one should be evicted (LRU order)
+      const evictedCount = [doc1, mem1, mem2].filter(item => item === null).length;
+      expect(evictedCount).toBeGreaterThan(0);
     });
+  });
 
-    it('should not delete non-expired items', async () => {
+  describe('Cache invalidation', () => {
+    it('should invalidate specific document', async () => {
       await cacheManager.setDocument('workflow', 'test', 'content');
-      await cacheManager.setMemory('memory', 'content');
 
-      const result = await cacheManager.cleanupExpiredEntries();
+      const cached1 = await cacheManager.getDocument('workflow', 'test');
+      expect(cached1).not.toBeNull();
+
+      await cacheManager.invalidateDocument('workflow', 'test');
+
+      const cached2 = await cacheManager.getDocument('workflow', 'test');
+      expect(cached2).toBeNull();
+    });
+
+    it('should invalidate specific memory', async () => {
+      await cacheManager.setMemory('test', 'content');
+
+      const cached1 = await cacheManager.getMemory('test');
+      expect(cached1).not.toBeNull();
+
+      await cacheManager.invalidateMemory('test');
+
+      const cached2 = await cacheManager.getMemory('test');
+      expect(cached2).toBeNull();
+    });
+  });
+
+  describe('Cache statistics', () => {
+    it('should return accurate cache statistics', async () => {
+      const content = 'x'.repeat(1000); // 1KB each
+
+      // Add critical documents
+      await cacheManager.setDocument('workflow', 'wf1', content);
+      await cacheManager.setDocument('rule', 'rule1', content);
+
+      // Add dynamic documents
+      await cacheManager.setDocument('frd', 'frd1', content);
 
-      expect(result.documentsDeleted).toBe(0);
-      expect(result.memoriesDeleted).toBe(0);
+      // Add memories
+      await cacheManager.setMemory('mem1', content);
 
-      // Verify they're still there
-      const doc = await cacheManager.getDocument('workflow', 'test');
-      const mem = await cacheManager.getMemory('memory');
+      const stats = await cacheManager.getCacheStats();
 
-      expect(doc).not.toBeNull();
-      expect(mem).not.toBeNull();
+      expect(stats.criticalCount).toBe(2);
+      expect(stats.dynamicCount).toBeGreaterThan(0);
+      expect(stats.memoryCount).toBe(1);
+      expect(stats.criticalSize).toBeGreaterThan(0);
+      expect(stats.dynamicSize).toBeGreaterThan(0);
+      expect(stats.totalSize).toBe(stats.criticalSize + stats.dynamicSize);
+      expect(stats.totalCount).toBe(stats.criticalCount + stats.dynamicCount);
     });
   });
 

package/src/lib/__tests__/connection-manager.test.ts

@@ -154,11 +154,11 @@ describe('ConnectionManager', () => {
       }
     });
 
-    it('should emit maxReconnectAttemptsReached after max attempts', async () => {
+    it('should emit dormant after max attempts', async () => {
       mockClient.healthCheck = vi.fn().mockRejectedValue(new Error('Failed'));
 
       const maxAttemptsListener = vi.fn();
-      connectionManager.on('maxReconnectAttemptsReached', maxAttemptsListener);
+      connectionManager.on('dormant', maxAttemptsListener);
 
       await connectionManager.start();
 

package/src/lib/__tests__/proxy-server.test.ts

@@ -53,12 +53,7 @@ describe('ProxyServer', () => {
       },
       cache: {
         dir: tmpDir,
-        ttl: {
-          workflows: 3600,
-          rules: 3600,
-          documents: 1800,
-          memories: 900,
-        },
+        maxCacheSizeBytes: 100 * 1024 * 1024, // 100MB
         preload: [],
       },
       connection: {
@@ -102,63 +97,33 @@ describe('ProxyServer', () => {
     });
   });
 
-  describe('cache cleanup on startup', () => {
-    it('should clean up expired cache entries on start', async () => {
-      // Add some expired entries
-      const shortTTLConfig = { ...config };
-      shortTTLConfig.cache.ttl = {
-        workflows: 0,
-        rules: 0,
-        documents: 0,
-        memories: 0,
-      };
-
-      const tempServer = new ProxyServer(db, shortTTLConfig);
+  describe('cache behavior', () => {
+    it('should use LRU cache with no expiration', async () => {
+      // With LRU cache, items never expire by time
+      await server['cacheManager'].setDocument('workflow', 'test', 'content');
 
-      await tempServer['cacheManager'].setDocument('workflow', 'test', 'content');
+      // Wait some time
       await new Promise(resolve => setTimeout(resolve, 100));
 
-      // Verify entry exists before cleanup
-      const beforeCleanup = await tempServer['cacheManager'].getDocument('workflow', 'test');
-      expect(beforeCleanup).not.toBeNull();
-
-      await tempServer.start();
-
-      // Entry should be removed after cleanup
-      const afterCleanup = await tempServer['cacheManager'].getDocument('workflow', 'test');
-      expect(afterCleanup).toBeNull();
-
-      await tempServer.stop();
+      // Entry should still be present (no TTL expiration)
+      const cached = await server['cacheManager'].getDocument('workflow', 'test');
+      expect(cached).not.toBeNull();
+      expect(cached?.data.content).toBe('content');
     });
   });
 
   describe('graceful degradation', () => {
-    it('should serve stale cache when disconnected', async () => {
-      // Create server with short TTL to make cache expire
-      const shortTTLConfig = { ...config };
-      shortTTLConfig.cache.ttl = {
-        workflows: 0,
-        rules: 0,
-        documents: 0,
-        memories: 0,
-      };
-      const tempServer = new ProxyServer(db, shortTTLConfig);
-
-      // Add item to cache
-      await tempServer['cacheManager'].setDocument('workflow', 'test', 'cached content');
-
-      // Wait for cache to expire
-      await new Promise(resolve => setTimeout(resolve, 100));
+    it('should serve cached data when disconnected', async () => {
+      // LRU cache always serves cached data (no staleness - always fresh)
+      await server['cacheManager'].setDocument('workflow', 'test', 'cached content');
 
       // Simulate disconnected state
-      tempServer['connectionManager']['state'] = 'disconnected';
+      server['connectionManager']['state'] = 'disconnected';
 
-      const result = await tempServer['handleGetDocument']('workflow', 'test');
+      const result = await server['handleGetDocument']('workflow', 'test');
 
       expect((result.data as any).content).toBe('cached content');
-      expect(result._metadata.source).toBe('stale_cache');
-
-      await tempServer.stop();
+      expect(result._metadata.source).toBe('cache'); // Fresh cache, not stale
     });
 
     it('should return error when no cache available and disconnected', async () => {

package/src/lib/__tests__/qwickbrain-client.test.ts

@@ -244,7 +244,9 @@ describe('QwickBrainClient', () => {
       const isHealthy = await client.healthCheck();
 
       expect(isHealthy).toBe(true);
-      expect(global.fetch).toHaveBeenCalledWith('http://api.test.com/health');
+      expect(global.fetch).toHaveBeenCalledWith('http://api.test.com/health', expect.objectContaining({
+        signal: expect.any(AbortSignal),
+      }));
     });
 
     it('should return false on health check failure', async () => {