@qwickapps/qwickbrain-proxy 1.0.1 → 1.0.3

package/src/lib/__tests__/sse-invalidation-listener.test.ts

@@ -0,0 +1,326 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { createDatabase, runMigrations } from '../../db/client.js';
+import { CacheManager } from '../cache-manager.js';
+import { SSEInvalidationListener } from '../sse-invalidation-listener.js';
+import type { Config } from '../../types/config.js';
+import { EventSource } from 'eventsource';
+
+// Mock EventSource
+vi.mock('eventsource', () => {
+  const EventSourceMock = vi.fn();
+  return { EventSource: EventSourceMock };
+});
+
+describe('SSEInvalidationListener', () => {
+  let tmpDir: string;
+  let cacheManager: CacheManager;
+  let listener: SSEInvalidationListener;
+  let db: ReturnType<typeof createDatabase>['db'];
+  let mockEventSource: any;
+  let eventListeners: Map<string, Function[]>;
+
+  beforeEach(() => {
+    // Create temporary directory for test database
+    tmpDir = mkdtempSync(join(tmpdir(), 'sse-test-'));
+    const dbResult = createDatabase(tmpDir);
+    db = dbResult.db;
+
+    // Run migrations to create tables
+    runMigrations(db);
+
+    const config: Config['cache'] = {
+      dir: tmpDir,
+      maxCacheSizeBytes: 100 * 1024 * 1024,
+      preload: [],
+    };
+
+    cacheManager = new CacheManager(db, config);
+
+    // Setup EventSource mock
+    eventListeners = new Map();
+
+    mockEventSource = {
+      readyState: 1, // OPEN
+      addEventListener: vi.fn((event: string, handler: Function) => {
+        if (!eventListeners.has(event)) {
+          eventListeners.set(event, []);
+        }
+        eventListeners.get(event)!.push(handler);
+      }),
+      close: vi.fn(),
+      onopen: null,
+      onerror: null,
+    };
+
+    (EventSource as any).mockImplementation(() => mockEventSource);
+    (EventSource as any).OPEN = 1;
+    (EventSource as any).CLOSED = 2;
+
+    listener = new SSEInvalidationListener(
+      'http://test.local:3000',
+      cacheManager,
+      'test-api-key'
+    );
+  });
+
+  afterEach(() => {
+    listener.stop();
+    rmSync(tmpDir, { recursive: true, force: true });
+    vi.clearAllMocks();
+  });
+
+  describe('start', () => {
+    it('should connect to SSE endpoint', async () => {
+      await listener.start();
+
+      expect(EventSource).toHaveBeenCalledWith(
+        'http://test.local:3000/sse/cache-invalidation',
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: 'Bearer test-api-key',
+          }),
+        })
+      );
+    });
+
+    it('should register event listeners', async () => {
+      await listener.start();
+
+      expect(mockEventSource.addEventListener).toHaveBeenCalledWith(
+        'document:invalidate',
+        expect.any(Function)
+      );
+      expect(mockEventSource.addEventListener).toHaveBeenCalledWith(
+        'memory:invalidate',
+        expect.any(Function)
+      );
+      expect(mockEventSource.addEventListener).toHaveBeenCalledWith(
+        'cache:invalidate:batch',
+        expect.any(Function)
+      );
+    });
+
+    it('should call onopen handler', async () => {
+      await listener.start();
+
+      // Trigger onopen
+      mockEventSource.onopen?.();
+
+      // Should be listening
+      expect(listener.isListening()).toBe(true);
+    });
+  });
+
+  describe('document invalidation', () => {
+    it('should invalidate document cache on event', async () => {
+      // Pre-populate cache
+      await cacheManager.setDocument('workflow', 'test-workflow', 'content');
+
+      const cached1 = await cacheManager.getDocument('workflow', 'test-workflow');
+      expect(cached1).not.toBeNull();
+
+      // Start listener
+      await listener.start();
+
+      // Trigger invalidation event
+      const handlers = eventListeners.get('document:invalidate') || [];
+      const invalidationEvent = {
+        data: JSON.stringify({
+          type: 'document',
+          docType: 'workflow',
+          name: 'test-workflow',
+        }),
+      };
+
+      for (const handler of handlers) {
+        await handler(invalidationEvent);
+      }
+
+      // Cache should be invalidated
+      const cached2 = await cacheManager.getDocument('workflow', 'test-workflow');
+      expect(cached2).toBeNull();
+    });
+
+    it('should invalidate project-scoped document', async () => {
+      await cacheManager.setDocument('rule', 'test-rule', 'content', 'my-project');
+
+      const cached1 = await cacheManager.getDocument('rule', 'test-rule', 'my-project');
+      expect(cached1).not.toBeNull();
+
+      await listener.start();
+
+      const handlers = eventListeners.get('document:invalidate') || [];
+      const invalidationEvent = {
+        data: JSON.stringify({
+          type: 'document',
+          docType: 'rule',
+          name: 'test-rule',
+          project: 'my-project',
+        }),
+      };
+
+      for (const handler of handlers) {
+        await handler(invalidationEvent);
+      }
+
+      const cached2 = await cacheManager.getDocument('rule', 'test-rule', 'my-project');
+      expect(cached2).toBeNull();
+    });
+  });
+
+  describe('memory invalidation', () => {
+    it('should invalidate memory cache on event', async () => {
+      await cacheManager.setMemory('test-memory', 'content');
+
+      const cached1 = await cacheManager.getMemory('test-memory');
+      expect(cached1).not.toBeNull();
+
+      await listener.start();
+
+      const handlers = eventListeners.get('memory:invalidate') || [];
+      const invalidationEvent = {
+        data: JSON.stringify({
+          type: 'memory',
+          name: 'test-memory',
+        }),
+      };
+
+      for (const handler of handlers) {
+        await handler(invalidationEvent);
+      }
+
+      const cached2 = await cacheManager.getMemory('test-memory');
+      expect(cached2).toBeNull();
+    });
+
+    it('should invalidate project-scoped memory', async () => {
+      await cacheManager.setMemory('test-memory', 'content', 'my-project');
+
+      const cached1 = await cacheManager.getMemory('test-memory', 'my-project');
+      expect(cached1).not.toBeNull();
+
+      await listener.start();
+
+      const handlers = eventListeners.get('memory:invalidate') || [];
+      const invalidationEvent = {
+        data: JSON.stringify({
+          type: 'memory',
+          name: 'test-memory',
+          project: 'my-project',
+        }),
+      };
+
+      for (const handler of handlers) {
+        await handler(invalidationEvent);
+      }
+
+      const cached2 = await cacheManager.getMemory('test-memory', 'my-project');
+      expect(cached2).toBeNull();
+    });
+  });
+
+  describe('batch invalidation', () => {
+    it('should invalidate multiple items in batch', async () => {
+      // Pre-populate cache
+      await cacheManager.setDocument('workflow', 'wf1', 'content');
+      await cacheManager.setDocument('rule', 'rule1', 'content');
+      await cacheManager.setMemory('mem1', 'content');
+
+      await listener.start();
+
+      const handlers = eventListeners.get('cache:invalidate:batch') || [];
+      const batchEvent = {
+        data: JSON.stringify([
+          { type: 'document', docType: 'workflow', name: 'wf1' },
+          { type: 'document', docType: 'rule', name: 'rule1' },
+          { type: 'memory', name: 'mem1' },
+        ]),
+      };
+
+      for (const handler of handlers) {
+        await handler(batchEvent);
+      }
+
+      // All should be invalidated
+      const wf1 = await cacheManager.getDocument('workflow', 'wf1');
+      const rule1 = await cacheManager.getDocument('rule', 'rule1');
+      const mem1 = await cacheManager.getMemory('mem1');
+
+      expect(wf1).toBeNull();
+      expect(rule1).toBeNull();
+      expect(mem1).toBeNull();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle malformed invalidation events', async () => {
+      await listener.start();
+
+      const handlers = eventListeners.get('document:invalidate') || [];
+
+      // Should not throw on malformed JSON
+      expect(() => {
+        for (const handler of handlers) {
+          handler({ data: 'invalid json' });
+        }
+      }).not.toThrow();
+    });
+
+    it('should handle missing docType in document event', async () => {
+      await cacheManager.setDocument('workflow', 'test', 'content');
+
+      await listener.start();
+
+      const handlers = eventListeners.get('document:invalidate') || [];
+      const invalidEvent = {
+        data: JSON.stringify({
+          type: 'document',
+          name: 'test',
+          // Missing docType
+        }),
+      };
+
+      // Should not throw
+      expect(() => {
+        for (const handler of handlers) {
+          handler(invalidEvent);
+        }
+      }).not.toThrow();
+
+      // Cache should still be present (invalidation skipped)
+      const cached = await cacheManager.getDocument('workflow', 'test');
+      expect(cached).not.toBeNull();
+    });
+  });
+
+  describe('stop', () => {
+    it('should close EventSource and stop listening', async () => {
+      await listener.start();
+
+      expect(listener.isListening()).toBe(true);
+
+      listener.stop();
+
+      expect(mockEventSource.close).toHaveBeenCalled();
+      expect(listener.isListening()).toBe(false);
+    });
+
+    it('should prevent reconnection after stop', async () => {
+      await listener.start();
+
+      listener.stop();
+
+      // Trigger error (would normally trigger reconnect)
+      mockEventSource.onerror?.(new Error('Connection lost'));
+
+      // Wait a bit
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Should not have tried to reconnect
+      expect(EventSource).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/lib/__tests__/write-queue-manager.test.ts

@@ -0,0 +1,383 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { createDatabase, runMigrations } from '../../db/client.js';
+import { WriteQueueManager } from '../write-queue-manager.js';
+import { QwickBrainClient } from '../qwickbrain-client.js';
+import type { Config } from '../../types/config.js';
+
+describe('WriteQueueManager', () => {
+  let tmpDir: string;
+  let writeQueueManager: WriteQueueManager;
+  let qwickbrainClient: QwickBrainClient;
+  let db: ReturnType<typeof createDatabase>['db'];
+
+  beforeEach(() => {
+    // Create temporary directory for test database
+    tmpDir = mkdtempSync(join(tmpdir(), 'queue-test-'));
+    const dbResult = createDatabase(tmpDir);
+    db = dbResult.db;
+
+    // Run migrations to create tables
+    runMigrations(db);
+
+    // Create mock client
+    const config: Config['qwickbrain'] = {
+      mode: 'sse',
+      url: 'http://test.local:3000',
+    };
+
+    qwickbrainClient = new QwickBrainClient(config);
+
+    // Mock the write methods
+    vi.spyOn(qwickbrainClient, 'createDocument').mockResolvedValue();
+    vi.spyOn(qwickbrainClient, 'setMemory').mockResolvedValue();
+    vi.spyOn(qwickbrainClient, 'deleteDocument').mockResolvedValue();
+    vi.spyOn(qwickbrainClient, 'deleteMemory').mockResolvedValue();
+
+    writeQueueManager = new WriteQueueManager(db, qwickbrainClient);
+  });
+
+  afterEach(() => {
+    // Clean up temporary directory
+    rmSync(tmpDir, { recursive: true, force: true });
+    vi.restoreAllMocks();
+  });
+
+  describe('queueOperation', () => {
+    it('should queue a create_document operation', async () => {
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'test-workflow',
+        content: 'workflow content',
+      });
+
+      const stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(1);
+      expect(stats.total).toBe(1);
+    });
+
+    it('should queue a set_memory operation', async () => {
+      await writeQueueManager.queueOperation('set_memory', {
+        name: 'test-memory',
+        content: 'memory content',
+      });
+
+      const stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(1);
+    });
+
+    it('should queue multiple operations', async () => {
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'wf1',
+        content: 'content1',
+      });
+
+      await writeQueueManager.queueOperation('set_memory', {
+        name: 'mem1',
+        content: 'content2',
+      });
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'rule',
+        name: 'rule1',
+        content: 'content3',
+      });
+
+      const stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(3);
+      expect(stats.total).toBe(3);
+    });
+  });
+
+  describe('syncPendingOperations', () => {
+    it('should sync pending create_document operations', async () => {
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'test-workflow',
+        content: 'workflow content',
+        project: 'my-project',
+        metadata: { author: 'test' },
+      });
+
+      const { synced, failed } = await writeQueueManager.syncPendingOperations();
+
+      expect(synced).toBe(1);
+      expect(failed).toBe(0);
+      expect(qwickbrainClient.createDocument).toHaveBeenCalledWith(
+        'workflow',
+        'test-workflow',
+        'workflow content',
+        'my-project',
+        { author: 'test' }
+      );
+
+      const stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(0);
+      expect(stats.total).toBe(0); // Completed operations are cleaned up
+    });
+
+    it('should sync pending set_memory operations', async () => {
+      await writeQueueManager.queueOperation('set_memory', {
+        name: 'test-memory',
+        content: 'memory content',
+        project: 'my-project',
+      });
+
+      const { synced, failed } = await writeQueueManager.syncPendingOperations();
+
+      expect(synced).toBe(1);
+      expect(failed).toBe(0);
+      expect(qwickbrainClient.setMemory).toHaveBeenCalledWith(
+        'test-memory',
+        'memory content',
+        'my-project',
+        undefined
+      );
+    });
+
+    it('should sync multiple operations in order (FIFO)', async () => {
+      const callOrder: string[] = [];
+
+      vi.spyOn(qwickbrainClient, 'createDocument').mockImplementation(async (docType, name) => {
+        callOrder.push(`doc:${name}`);
+      });
+
+      vi.spyOn(qwickbrainClient, 'setMemory').mockImplementation(async (name) => {
+        callOrder.push(`mem:${name}`);
+      });
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'first',
+        content: 'content',
+      });
+
+      await writeQueueManager.queueOperation('set_memory', {
+        name: 'second',
+        content: 'content',
+      });
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'rule',
+        name: 'third',
+        content: 'content',
+      });
+
+      const { synced } = await writeQueueManager.syncPendingOperations();
+
+      expect(synced).toBe(3);
+      expect(callOrder).toEqual(['doc:first', 'mem:second', 'doc:third']);
+    });
+
+    it('should handle operation failures and retry', async () => {
+      let callCount = 0;
+      vi.spyOn(qwickbrainClient, 'createDocument').mockImplementation(async () => {
+        callCount++;
+        if (callCount < 3) {
+          throw new Error('Network error');
+        }
+      });
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'test',
+        content: 'content',
+      });
+
+      // First sync - should fail (attempt 1)
+      let result = await writeQueueManager.syncPendingOperations();
+      expect(result.synced).toBe(0);
+      expect(result.failed).toBe(0);
+
+      let stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(1); // Still pending
+
+      // Second sync - should fail (attempt 2)
+      result = await writeQueueManager.syncPendingOperations();
+      expect(result.synced).toBe(0);
+      expect(result.failed).toBe(0);
+
+      // Third sync - should succeed (attempt 3)
+      result = await writeQueueManager.syncPendingOperations();
+      expect(result.synced).toBe(1);
+      expect(result.failed).toBe(0);
+
+      stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(0);
+    });
+
+    it('should mark operation as failed after max attempts', async () => {
+      vi.spyOn(qwickbrainClient, 'createDocument').mockRejectedValue(new Error('Permanent error'));
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'test',
+        content: 'content',
+      });
+
+      // Attempt 1
+      let result = await writeQueueManager.syncPendingOperations();
+      expect(result.failed).toBe(0);
+
+      // Attempt 2
+      result = await writeQueueManager.syncPendingOperations();
+      expect(result.failed).toBe(0);
+
+      // Attempt 3 - max reached, marked as failed
+      result = await writeQueueManager.syncPendingOperations();
+      expect(result.synced).toBe(0);
+      expect(result.failed).toBe(1);
+
+      const stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(0);
+      expect(stats.failed).toBe(1);
+
+      const failedOps = await writeQueueManager.getFailedOperations();
+      expect(failedOps.length).toBe(1);
+      expect(failedOps[0].error).toContain('Permanent error');
+      expect(failedOps[0].attempts).toBe(3);
+    });
+
+    it('should skip sync if already syncing', async () => {
+      // Queue an operation that takes time
+      let resolveSync: () => void;
+      const syncPromise = new Promise<void>((resolve) => {
+        resolveSync = resolve;
+      });
+
+      vi.spyOn(qwickbrainClient, 'createDocument').mockImplementation(async () => {
+        await syncPromise;
+      });
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'test',
+        content: 'content',
+      });
+
+      // Start first sync (won't complete)
+      const sync1 = writeQueueManager.syncPendingOperations();
+
+      // Start second sync while first is running
+      const sync2 = writeQueueManager.syncPendingOperations();
+
+      // Second should skip
+      const result2 = await sync2;
+      expect(result2.synced).toBe(0);
+      expect(result2.failed).toBe(0);
+
+      // Complete first sync
+      resolveSync!();
+      const result1 = await sync1;
+      expect(result1.synced).toBe(1);
+    });
+  });
+
+  describe('retryOperation', () => {
+    it('should reset a failed operation for retry', async () => {
+      vi.spyOn(qwickbrainClient, 'createDocument').mockRejectedValue(new Error('Error'));
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'test',
+        content: 'content',
+      });
+
+      // Fail 3 times to mark as failed
+      await writeQueueManager.syncPendingOperations();
+      await writeQueueManager.syncPendingOperations();
+      await writeQueueManager.syncPendingOperations();
+
+      let stats = await writeQueueManager.getQueueStats();
+      expect(stats.failed).toBe(1);
+
+      const failedOps = await writeQueueManager.getFailedOperations();
+      const opId = failedOps[0].id;
+
+      // Fix the mock
+      vi.spyOn(qwickbrainClient, 'createDocument').mockResolvedValue();
+
+      // Retry the operation
+      await writeQueueManager.retryOperation(opId);
+
+      stats = await writeQueueManager.getQueueStats();
+      expect(stats.pending).toBe(1);
+      expect(stats.failed).toBe(0);
+
+      // Sync should now succeed
+      const result = await writeQueueManager.syncPendingOperations();
+      expect(result.synced).toBe(1);
+    });
+  });
+
+  describe('clearFailed', () => {
+    it('should clear all failed operations', async () => {
+      vi.spyOn(qwickbrainClient, 'createDocument').mockRejectedValue(new Error('Error'));
+
+      // Queue and fail 2 operations
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'workflow',
+        name: 'test1',
+        content: 'content',
+      });
+
+      await writeQueueManager.queueOperation('create_document', {
+        docType: 'rule',
+        name: 'test2',
+        content: 'content',
+      });
+
+      // Fail them
+      for (let i = 0; i < 3; i++) {
+        await writeQueueManager.syncPendingOperations();
+      }
+
+      let stats = await writeQueueManager.getQueueStats();
+      expect(stats.failed).toBe(2);
+
+      const cleared = await writeQueueManager.clearFailed();
+      expect(cleared).toBe(2);
+
+      stats = await writeQueueManager.getQueueStats();
+      expect(stats.failed).toBe(0);
+      expect(stats.total).toBe(0);
+    });
+  });
+
+  describe('delete operations', () => {
+    it('should sync delete_document operations', async () => {
+      await writeQueueManager.queueOperation('delete_document', {
+        docType: 'workflow',
+        name: 'test-workflow',
+        project: 'my-project',
+      });
+
+      const { synced } = await writeQueueManager.syncPendingOperations();
+
+      expect(synced).toBe(1);
+      expect(qwickbrainClient.deleteDocument).toHaveBeenCalledWith(
+        'workflow',
+        'test-workflow',
+        'my-project'
+      );
+    });
+
+    it('should sync delete_memory operations', async () => {
+      await writeQueueManager.queueOperation('delete_memory', {
+        name: 'test-memory',
+        project: 'my-project',
+      });
+
+      const { synced } = await writeQueueManager.syncPendingOperations();
+
+      expect(synced).toBe(1);
+      expect(qwickbrainClient.deleteMemory).toHaveBeenCalledWith(
+        'test-memory',
+        'my-project'
+      );
+    });
+  });
+});