@auto-engineer/pipeline 0.0.1

package/src/server/sse-manager.specs.ts

@@ -0,0 +1,208 @@
+import type { Event } from '@auto-engineer/message-bus';
+import type { Response } from 'express';
+import { beforeEach, describe, expect, it, type Mock, vi } from 'vitest';
+import { SSEManager } from './sse-manager';
+
+interface MockResponse extends Response {
+  written: string[];
+  ended: boolean;
+  writeHeadMock: Mock;
+  endMock: Mock;
+  triggerClose: () => void;
+}
+
+function createMockResponse(): MockResponse {
+  const written: string[] = [];
+  let ended = false;
+  const listeners: Record<string, Array<() => void>> = {};
+
+  const writeHeadMock = vi.fn();
+  const endMock = vi.fn(() => {
+    ended = true;
+  });
+
+  return {
+    written,
+    ended,
+    writeHeadMock,
+    endMock,
+    writeHead: writeHeadMock,
+    write: vi.fn((data: string) => {
+      written.push(data);
+      return true;
+    }),
+    end: endMock,
+    on: vi.fn((event: string, handler: () => void) => {
+      listeners[event] = listeners[event] ?? [];
+      listeners[event].push(handler);
+    }),
+    triggerClose: () => {
+      listeners.close?.forEach((h) => h());
+    },
+  } as unknown as MockResponse;
+}
+
+describe('SSEManager', () => {
+  let manager: SSEManager;
+
+  beforeEach(() => {
+    manager = new SSEManager();
+  });
+
+  describe('client management', () => {
+    it('should add client', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res);
+      expect(manager.clientCount).toBe(1);
+    });
+
+    it('should set correct SSE headers', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res);
+      expect(res.writeHeadMock).toHaveBeenCalledWith(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+      });
+    });
+
+    it('should send heartbeat comment on connect', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res);
+      expect(res.written[0]).toBe(':\n\n');
+    });
+
+    it('should remove client', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res);
+      manager.removeClient('c1');
+      expect(manager.clientCount).toBe(0);
+    });
+
+    it('should cleanup client on response close', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res);
+      res.triggerClose();
+      expect(manager.clientCount).toBe(0);
+    });
+  });
+
+  describe('broadcasting', () => {
+    it('should broadcast event to all clients', () => {
+      const res1 = createMockResponse();
+      const res2 = createMockResponse();
+
+      manager.addClient('c1', res1);
+      manager.addClient('c2', res2);
+
+      const event: Event = { type: 'TestEvent', data: { foo: 'bar' } };
+      manager.broadcast(event);
+
+      expect(res1.written).toContainEqual(`data: ${JSON.stringify(event)}\n\n`);
+      expect(res2.written).toContainEqual(`data: ${JSON.stringify(event)}\n\n`);
+    });
+
+    it('should filter by correlationId when set', () => {
+      const res1 = createMockResponse();
+      const res2 = createMockResponse();
+
+      manager.addClient('c1', res1, 'workflow-123');
+      manager.addClient('c2', res2);
+
+      const event: Event = { type: 'TestEvent', correlationId: 'workflow-456', data: {} };
+      manager.broadcast(event);
+
+      expect(res1.written.length).toBe(1);
+      expect(res2.written.length).toBe(2);
+    });
+
+    it('should send to filtered client when correlationId matches', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res, 'workflow-123');
+
+      const event: Event = { type: 'TestEvent', correlationId: 'workflow-123', data: {} };
+      manager.broadcast(event);
+
+      expect(res.written).toContainEqual(`data: ${JSON.stringify(event)}\n\n`);
+    });
+
+    it('should not send to filtered client when correlationId does not match', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res, 'workflow-123');
+
+      const event: Event = { type: 'TestEvent', correlationId: 'workflow-456', data: {} };
+      manager.broadcast(event);
+
+      expect(res.written.length).toBe(1);
+    });
+  });
+
+  describe('broadcast error handling', () => {
+    it('should not throw when client.response.write fails', () => {
+      const res = createMockResponse();
+      manager.addClient('c1', res);
+
+      vi.mocked(res.write).mockImplementation(() => {
+        throw new Error('Connection reset');
+      });
+
+      const event: Event = { type: 'TestEvent', data: {} };
+
+      expect(() => manager.broadcast(event)).not.toThrow();
+    });
+
+    it('should remove failed client from clients map', () => {
+      const res = createMockResponse();
+      vi.mocked(res.write)
+        .mockImplementationOnce(() => true)
+        .mockImplementation(() => {
+          throw new Error('Connection reset');
+        });
+
+      manager.addClient('c1', res);
+      expect(manager.clientCount).toBe(1);
+
+      const event: Event = { type: 'TestEvent', data: {} };
+      manager.broadcast(event);
+
+      expect(manager.clientCount).toBe(0);
+    });
+
+    it('should continue broadcasting to other clients after one fails', () => {
+      const failingRes = createMockResponse();
+      const workingRes = createMockResponse();
+
+      vi.mocked(failingRes.write)
+        .mockImplementationOnce(() => true)
+        .mockImplementation(() => {
+          throw new Error('Connection reset');
+        });
+
+      manager.addClient('c1', failingRes);
+      manager.addClient('c2', workingRes);
+
+      const event: Event = { type: 'TestEvent', data: {} };
+      manager.broadcast(event);
+
+      expect(workingRes.written).toContainEqual(`data: ${JSON.stringify(event)}\n\n`);
+      expect(manager.clientCount).toBe(1);
+    });
+  });
+
+  describe('closeAll', () => {
+    it('should close all clients', () => {
+      const res1 = createMockResponse();
+      const res2 = createMockResponse();
+
+      manager.addClient('c1', res1);
+      manager.addClient('c2', res2);
+
+      manager.closeAll();
+
+      expect(manager.clientCount).toBe(0);
+      expect(res1.endMock).toHaveBeenCalled();
+      expect(res2.endMock).toHaveBeenCalled();
+    });
+  });
+});

package/src/server/sse-manager.ts

@@ -0,0 +1,79 @@
+import type { Event } from '@auto-engineer/message-bus';
+import type { Response } from 'express';
+
+interface SSEClient {
+  id: string;
+  response: Response;
+  correlationIdFilter?: string;
+}
+
+export class SSEManager {
+  private clients = new Map<string, SSEClient>();
+
+  get clientCount(): number {
+    return this.clients.size;
+  }
+
+  addClient(id: string, response: Response, correlationIdFilter?: string): void {
+    response.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      Connection: 'keep-alive',
+      'Access-Control-Allow-Origin': '*',
+    });
+
+    response.write(':\n\n');
+
+    this.clients.set(id, {
+      id,
+      response,
+      correlationIdFilter,
+    });
+
+    response.on('close', () => {
+      this.removeClient(id);
+    });
+  }
+
+  removeClient(id: string): void {
+    const client = this.clients.get(id);
+    if (client !== undefined) {
+      client.response.end();
+      this.clients.delete(id);
+    }
+  }
+
+  broadcast(event: Event): void {
+    const data = JSON.stringify(event);
+    const message = `data: ${data}\n\n`;
+    const failedClientIds: string[] = [];
+
+    for (const client of this.clients.values()) {
+      if (this.shouldSendToClient(client, event)) {
+        try {
+          client.response.write(message);
+        } catch {
+          failedClientIds.push(client.id);
+        }
+      }
+    }
+
+    for (const id of failedClientIds) {
+      this.removeClient(id);
+    }
+  }
+
+  private shouldSendToClient(client: SSEClient, event: Event): boolean {
+    if (client.correlationIdFilter === undefined) {
+      return true;
+    }
+    return event.correlationId === client.correlationIdFilter;
+  }
+
+  closeAll(): void {
+    for (const client of this.clients.values()) {
+      client.response.end();
+    }
+    this.clients.clear();
+  }
+}

package/src/testing/event-capture.specs.ts

@@ -0,0 +1,143 @@
+import type { Event } from '@auto-engineer/message-bus';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { EventCapture } from './event-capture';
+
+describe('EventCapture', () => {
+  let capture: EventCapture;
+
+  beforeEach(() => {
+    capture = new EventCapture();
+  });
+
+  describe('record', () => {
+    it('should record a single event', () => {
+      const event: Event = { type: 'TestEvent', data: { foo: 'bar' } };
+      capture.record(event);
+      expect(capture.getEvents()).toHaveLength(1);
+      expect(capture.getEvents()[0]).toEqual(event);
+    });
+
+    it('should record multiple events in order', () => {
+      const event1: Event = { type: 'First', data: {} };
+      const event2: Event = { type: 'Second', data: {} };
+      const event3: Event = { type: 'Third', data: {} };
+
+      capture.record(event1);
+      capture.record(event2);
+      capture.record(event3);
+
+      const events = capture.getEvents();
+      expect(events).toHaveLength(3);
+      expect(events[0].type).toBe('First');
+      expect(events[1].type).toBe('Second');
+      expect(events[2].type).toBe('Third');
+    });
+  });
+
+  describe('getEvents', () => {
+    it('should return empty array initially', () => {
+      expect(capture.getEvents()).toEqual([]);
+    });
+
+    it('should return a copy of events array', () => {
+      const event: Event = { type: 'TestEvent', data: {} };
+      capture.record(event);
+
+      const events = capture.getEvents();
+      events.push({ type: 'Modified', data: {} });
+
+      expect(capture.getEvents()).toHaveLength(1);
+    });
+  });
+
+  describe('getEventTypes', () => {
+    it('should return empty array initially', () => {
+      expect(capture.getEventTypes()).toEqual([]);
+    });
+
+    it('should return event types in order', () => {
+      capture.record({ type: 'A', data: {} });
+      capture.record({ type: 'B', data: {} });
+      capture.record({ type: 'C', data: {} });
+
+      expect(capture.getEventTypes()).toEqual(['A', 'B', 'C']);
+    });
+  });
+
+  describe('clear', () => {
+    it('should clear all recorded events', () => {
+      capture.record({ type: 'A', data: {} });
+      capture.record({ type: 'B', data: {} });
+
+      capture.clear();
+
+      expect(capture.getEvents()).toEqual([]);
+    });
+  });
+
+  describe('hasEvent', () => {
+    it('should return false when event not present', () => {
+      expect(capture.hasEvent('Missing')).toBe(false);
+    });
+
+    it('should return true when event is present', () => {
+      capture.record({ type: 'Present', data: {} });
+      expect(capture.hasEvent('Present')).toBe(true);
+    });
+  });
+
+  describe('getEventsOfType', () => {
+    it('should return empty array when no matching events', () => {
+      capture.record({ type: 'Other', data: {} });
+      expect(capture.getEventsOfType('Missing')).toEqual([]);
+    });
+
+    it('should return all events of specified type', () => {
+      capture.record({ type: 'A', data: { id: 1 } });
+      capture.record({ type: 'B', data: { id: 2 } });
+      capture.record({ type: 'A', data: { id: 3 } });
+
+      const aEvents = capture.getEventsOfType('A');
+      expect(aEvents).toHaveLength(2);
+      expect(aEvents[0].data).toEqual({ id: 1 });
+      expect(aEvents[1].data).toEqual({ id: 3 });
+    });
+  });
+
+  describe('waitForEvent', () => {
+    it('should resolve immediately if event already present', async () => {
+      capture.record({ type: 'Already', data: {} });
+
+      const event = await capture.waitForEvent('Already', 100);
+      expect(event.type).toBe('Already');
+    });
+
+    it('should resolve when event is recorded', async () => {
+      const promise = capture.waitForEvent('Delayed', 500);
+
+      setTimeout(() => {
+        capture.record({ type: 'Delayed', data: { success: true } });
+      }, 50);
+
+      const event = await promise;
+      expect(event.type).toBe('Delayed');
+      expect(event.data).toEqual({ success: true });
+    });
+
+    it('should reject on timeout if event not recorded', async () => {
+      await expect(capture.waitForEvent('Never', 50)).rejects.toThrow('Timeout waiting for event: Never');
+    });
+  });
+
+  describe('count', () => {
+    it('should return 0 initially', () => {
+      expect(capture.count).toBe(0);
+    });
+
+    it('should return number of recorded events', () => {
+      capture.record({ type: 'A', data: {} });
+      capture.record({ type: 'B', data: {} });
+      expect(capture.count).toBe(2);
+    });
+  });
+});

package/src/testing/event-capture.ts

@@ -0,0 +1,65 @@
+import type { Event } from '@auto-engineer/message-bus';
+
+export class EventCapture {
+  private events: Event[] = [];
+  private eventListeners: Array<(event: Event) => void> = [];
+
+  record(event: Event): void {
+    this.events.push(event);
+    this.eventListeners.forEach((listener) => listener(event));
+  }
+
+  getEvents(): Event[] {
+    return [...this.events];
+  }
+
+  getEventTypes(): string[] {
+    return this.events.map((e) => e.type);
+  }
+
+  clear(): void {
+    this.events = [];
+  }
+
+  hasEvent(eventType: string): boolean {
+    return this.events.some((e) => e.type === eventType);
+  }
+
+  getEventsOfType(eventType: string): Event[] {
+    return this.events.filter((e) => e.type === eventType);
+  }
+
+  waitForEvent(eventType: string, timeoutMs: number): Promise<Event> {
+    const existing = this.events.find((e) => e.type === eventType);
+    if (existing) {
+      return Promise.resolve(existing);
+    }
+
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        const index = this.eventListeners.indexOf(listener);
+        if (index !== -1) {
+          this.eventListeners.splice(index, 1);
+        }
+        reject(new Error(`Timeout waiting for event: ${eventType}`));
+      }, timeoutMs);
+
+      const listener = (event: Event) => {
+        if (event.type === eventType) {
+          clearTimeout(timeoutId);
+          const index = this.eventListeners.indexOf(listener);
+          if (index !== -1) {
+            this.eventListeners.splice(index, 1);
+          }
+          resolve(event);
+        }
+      };
+
+      this.eventListeners.push(listener);
+    });
+  }
+
+  get count(): number {
+    return this.events.length;
+  }
+}