@dotdo/postgres 0.1.0

package/src/worker/cdc-sse.test.ts

@@ -0,0 +1,780 @@
+/**
+ * Tests for CDC SSE (Server-Sent Events) Transport
+ * Task: postgres-r3pu - SSE Transport implementation
+ *
+ * Tests cover:
+ * 1. SSE response creation with proper headers
+ * 2. Event serialization (INSERT, UPDATE, DELETE)
+ * 3. Connection keepalive (heartbeat)
+ * 4. Last-Event-ID parsing for resumption
+ * 5. TransformStream-based encoding
+ * 6. Subscription management
+ * 7. CDCSSEManager integration
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import {
+  CDCSSETransport,
+  CDCSSEManager,
+  SSEEncoderStream,
+  createCDCSSETransport,
+  createCDCSSEManager,
+  handleCDCSSERequest,
+  type SSEEvent,
+  type SSERequestContext,
+  type CDCSSESubscription,
+} from './cdc-sse'
+import type { ChangePayload } from './types'
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Read all chunks from a ReadableStream
+ */
+async function readStream(stream: ReadableStream<Uint8Array>): Promise<string> {
+  const reader = stream.getReader()
+  const decoder = new TextDecoder()
+  const chunks: string[] = []
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      chunks.push(decoder.decode(value, { stream: true }))
+    }
+  } finally {
+    reader.releaseLock()
+  }
+
+  return chunks.join('')
+}
+
+/**
+ * Parse SSE text into events
+ */
+function parseSSEText(text: string): Array<{
+  id?: string
+  event?: string
+  data?: string
+  retry?: number
+}> {
+  const events: Array<{
+    id?: string
+    event?: string
+    data?: string
+    retry?: number
+  }> = []
+
+  // Split by double newline (event boundary)
+  const eventTexts = text.split('\n\n').filter(Boolean)
+
+  for (const eventText of eventTexts) {
+    const event: { id?: string; event?: string; data?: string; retry?: number } = {}
+    const dataLines: string[] = []
+
+    for (const line of eventText.split('\n')) {
+      if (line.startsWith('id: ')) {
+        event.id = line.slice(4)
+      } else if (line.startsWith('event: ')) {
+        event.event = line.slice(7)
+      } else if (line.startsWith('data: ')) {
+        dataLines.push(line.slice(6))
+      } else if (line.startsWith('retry: ')) {
+        event.retry = parseInt(line.slice(7), 10)
+      }
+    }
+
+    if (dataLines.length > 0) {
+      event.data = dataLines.join('\n')
+    }
+
+    events.push(event)
+  }
+
+  return events
+}
+
+/**
+ * Create a mock request context
+ */
+function createMockContext(
+  params: Record<string, string> = {},
+  headers: Record<string, string> = {}
+): SSERequestContext {
+  const url = new URL('https://test.com/cdc/sse')
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, value)
+  }
+
+  const headerObj = new Headers(headers)
+
+  return {
+    url,
+    headers: headerObj,
+  }
+}
+
+/**
+ * Create a mock Request object
+ */
+function createMockRequest(
+  params: Record<string, string> = {},
+  headers: Record<string, string> = {}
+): Request {
+  const url = new URL('https://test.com/cdc/sse')
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, value)
+  }
+
+  return new Request(url.toString(), {
+    headers: new Headers(headers),
+  })
+}
+
+// ============================================================================
+// SSEEncoderStream Tests
+// ============================================================================
+
+describe('SSEEncoderStream', () => {
+  it('should encode a basic event', async () => {
+    const encoder = new SSEEncoderStream()
+    const writer = encoder.writable.getWriter()
+
+    const event: SSEEvent = {
+      type: 'insert',
+      data: { table: 'users', data: { id: 1 } },
+    }
+
+    await writer.write(event)
+    await writer.close()
+
+    const text = await readStream(encoder.readable)
+    const events = parseSSEText(text)
+
+    expect(events).toHaveLength(1)
+    expect(events[0]!.event).toBe('insert')
+    expect(events[0]!.data).toBeDefined()
+
+    const data = JSON.parse(events[0]!.data!)
+    expect(data.table).toBe('users')
+  })
+
+  it('should include event ID when provided', async () => {
+    const encoder = new SSEEncoderStream()
+    const writer = encoder.writable.getWriter()
+
+    const event: SSEEvent = {
+      type: 'insert',
+      id: 'lsn-123',
+      data: { table: 'users' },
+    }
+
+    await writer.write(event)
+    await writer.close()
+
+    const text = await readStream(encoder.readable)
+    const events = parseSSEText(text)
+
+    expect(events[0]!.id).toBe('lsn-123')
+  })
+
+  it('should include retry when provided', async () => {
+    const encoder = new SSEEncoderStream()
+    const writer = encoder.writable.getWriter()
+
+    const event: SSEEvent = {
+      type: 'error',
+      retry: 5000,
+      data: { error: 'Connection lost' },
+    }
+
+    await writer.write(event)
+    await writer.close()
+
+    const text = await readStream(encoder.readable)
+    const events = parseSSEText(text)
+
+    expect(events[0]!.retry).toBe(5000)
+  })
+
+  it('should encode multiple events', async () => {
+    const encoder = new SSEEncoderStream()
+    const writer = encoder.writable.getWriter()
+
+    await writer.write({ type: 'insert', data: { table: 'users' } })
+    await writer.write({ type: 'update', data: { table: 'users' } })
+    await writer.write({ type: 'delete', data: { table: 'users' } })
+    await writer.close()
+
+    const text = await readStream(encoder.readable)
+    const events = parseSSEText(text)
+
+    expect(events).toHaveLength(3)
+    expect(events[0]!.event).toBe('insert')
+    expect(events[1]!.event).toBe('update')
+    expect(events[2]!.event).toBe('delete')
+  })
+})
+
+// ============================================================================
+// CDCSSETransport Tests
+// ============================================================================
+
+describe('CDCSSETransport', () => {
+  let transport: CDCSSETransport
+
+  beforeEach(() => {
+    transport = createCDCSSETransport({
+      heartbeatIntervalMs: 100000, // Disable heartbeat for most tests
+    })
+  })
+
+  afterEach(async () => {
+    await transport.close()
+  })
+
+  describe('createResponse', () => {
+    it('should return a Response with correct headers', () => {
+      const context = createMockContext({ tables: 'users' })
+      const response = transport.createResponse(context)
+
+      expect(response.status).toBe(200)
+      expect(response.headers.get('Content-Type')).toBe('text/event-stream')
+      expect(response.headers.get('Cache-Control')).toContain('no-cache')
+      expect(response.headers.get('Connection')).toBe('keep-alive')
+    })
+
+    it('should create subscriptions from query parameters', () => {
+      const context = createMockContext({
+        tables: 'users,posts',
+        schemas: 'public,blog',
+        events: 'INSERT,UPDATE',
+      })
+
+      transport.createResponse(context)
+
+      const subscriptions = transport.getSubscriptions()
+      expect(subscriptions).toHaveLength(2)
+      expect(subscriptions[0]!.table).toBe('users')
+      expect(subscriptions[0]!.schema).toBe('public')
+      expect(subscriptions[1]!.table).toBe('posts')
+      expect(subscriptions[1]!.schema).toBe('blog')
+    })
+
+    it('should parse event types correctly', () => {
+      const context = createMockContext({
+        tables: 'users',
+        events: 'INSERT,DELETE',
+      })
+
+      transport.createResponse(context)
+
+      const subscriptions = transport.getSubscriptions()
+      expect(subscriptions[0]!.events).toEqual(['INSERT', 'DELETE'])
+    })
+
+    it('should default to all events when not specified', () => {
+      const context = createMockContext({ tables: 'users' })
+
+      transport.createResponse(context)
+
+      const subscriptions = transport.getSubscriptions()
+      expect(subscriptions[0]!.events).toEqual(['INSERT', 'UPDATE', 'DELETE'])
+    })
+
+    it('should use default schema when not provided', () => {
+      const context = createMockContext({ tables: 'users,posts' })
+
+      transport.createResponse(context)
+
+      const subscriptions = transport.getSubscriptions()
+      expect(subscriptions[0]!.schema).toBe('public')
+      expect(subscriptions[1]!.schema).toBe('public')
+    })
+
+    it('should parse includeOldRow option', () => {
+      const context = createMockContext({
+        tables: 'users',
+        includeOldRow: 'true',
+      })
+
+      transport.createResponse(context)
+
+      const subscriptions = transport.getSubscriptions()
+      expect(subscriptions[0]!.includeOldRow).toBe(true)
+    })
+
+    it('should parse trackChangedColumns option', () => {
+      const context = createMockContext({
+        tables: 'users',
+        trackChangedColumns: 'true',
+      })
+
+      transport.createResponse(context)
+
+      const subscriptions = transport.getSubscriptions()
+      expect(subscriptions[0]!.trackChangedColumns).toBe(true)
+    })
+  })
+
+  describe('broadcastChange', () => {
+    it('should broadcast INSERT events', async () => {
+      const context = createMockContext({ tables: 'users' })
+      const response = transport.createResponse(context)
+
+      const change: ChangePayload = {
+        table: 'users',
+        operation: 'INSERT',
+        newRow: { id: 1, name: 'Alice' },
+      }
+
+      await transport.broadcastChange(change)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      // First event is 'subscribed', second is the change
+      const insertEvent = events.find(e => e.event === 'insert')
+      expect(insertEvent).toBeDefined()
+
+      const data = JSON.parse(insertEvent!.data!)
+      expect(data.table).toBe('users')
+      expect(data.data).toEqual({ id: 1, name: 'Alice' })
+    })
+
+    it('should broadcast UPDATE events with old and new row', async () => {
+      const context = createMockContext({
+        tables: 'users',
+        includeOldRow: 'true',
+      })
+      const response = transport.createResponse(context)
+
+      const change: ChangePayload = {
+        table: 'users',
+        operation: 'UPDATE',
+        oldRow: { id: 1, name: 'Alice' },
+        newRow: { id: 1, name: 'Alicia' },
+      }
+
+      await transport.broadcastChange(change)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const updateEvent = events.find(e => e.event === 'update')
+      expect(updateEvent).toBeDefined()
+
+      const data = JSON.parse(updateEvent!.data!)
+      expect(data.data.old).toEqual({ id: 1, name: 'Alice' })
+      expect(data.data.new).toEqual({ id: 1, name: 'Alicia' })
+    })
+
+    it('should broadcast DELETE events with old row', async () => {
+      const context = createMockContext({ tables: 'users' })
+      const response = transport.createResponse(context)
+
+      const change: ChangePayload = {
+        table: 'users',
+        operation: 'DELETE',
+        oldRow: { id: 1, name: 'Alice' },
+      }
+
+      await transport.broadcastChange(change)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const deleteEvent = events.find(e => e.event === 'delete')
+      expect(deleteEvent).toBeDefined()
+
+      const data = JSON.parse(deleteEvent!.data!)
+      expect(data.data).toEqual({ id: 1, name: 'Alice' })
+    })
+
+    it('should not broadcast to non-matching tables', async () => {
+      const context = createMockContext({ tables: 'orders' })
+      const response = transport.createResponse(context)
+
+      const change: ChangePayload = {
+        table: 'users',
+        operation: 'INSERT',
+        newRow: { id: 1 },
+      }
+
+      await transport.broadcastChange(change)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const insertEvent = events.find(e => e.event === 'insert')
+      expect(insertEvent).toBeUndefined()
+    })
+
+    it('should not broadcast filtered event types', async () => {
+      const context = createMockContext({
+        tables: 'users',
+        events: 'INSERT',
+      })
+      const response = transport.createResponse(context)
+
+      const change: ChangePayload = {
+        table: 'users',
+        operation: 'UPDATE',
+        oldRow: { id: 1 },
+        newRow: { id: 1 },
+      }
+
+      await transport.broadcastChange(change)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const updateEvent = events.find(e => e.event === 'update')
+      expect(updateEvent).toBeUndefined()
+    })
+
+    it('should track changed columns when enabled', async () => {
+      const context = createMockContext({
+        tables: 'users',
+        trackChangedColumns: 'true',
+      })
+      const response = transport.createResponse(context)
+
+      const change: ChangePayload = {
+        table: 'users',
+        operation: 'UPDATE',
+        oldRow: { id: 1, name: 'Alice', email: 'alice@test.com' },
+        newRow: { id: 1, name: 'Alicia', email: 'alice@test.com' },
+      }
+
+      await transport.broadcastChange(change)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const updateEvent = events.find(e => e.event === 'update')
+      expect(updateEvent).toBeDefined()
+
+      const data = JSON.parse(updateEvent!.data!)
+      expect(data.changedColumns).toEqual(['name'])
+    })
+
+    it('should include event ID (LSN) for resumption', async () => {
+      const context = createMockContext({ tables: 'users' })
+      const response = transport.createResponse(context)
+
+      const change: ChangePayload = {
+        table: 'users',
+        operation: 'INSERT',
+        newRow: { id: 1 },
+        lsn: 'abc123',
+      }
+
+      await transport.broadcastChange(change)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const insertEvent = events.find(e => e.event === 'insert')
+      expect(insertEvent!.id).toBe('abc123')
+    })
+  })
+
+  describe('subscription management', () => {
+    it('should add subscriptions dynamically', async () => {
+      const context = createMockContext({ tables: 'users' })
+      transport.createResponse(context)
+
+      expect(transport.getSubscriptionCount()).toBe(1)
+
+      transport.addSubscription({
+        id: 'sub-new',
+        table: 'posts',
+        schema: 'public',
+        events: ['INSERT'],
+      })
+
+      expect(transport.getSubscriptionCount()).toBe(2)
+    })
+
+    it('should remove subscriptions', async () => {
+      const context = createMockContext({
+        tables: 'users',
+        subscriptionIds: 'sub-1',
+      })
+      const response = transport.createResponse(context)
+
+      expect(transport.getSubscriptionCount()).toBe(1)
+
+      const removed = await transport.removeSubscription('sub-1')
+      expect(removed).toBe(true)
+      expect(transport.getSubscriptionCount()).toBe(0)
+
+      // Stream should close when no subscriptions remain
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const unsubEvent = events.find(e => e.event === 'unsubscribed')
+      expect(unsubEvent).toBeDefined()
+    })
+
+    it('should return false when removing non-existent subscription', async () => {
+      const context = createMockContext({ tables: 'users' })
+      transport.createResponse(context)
+
+      const removed = await transport.removeSubscription('non-existent')
+      expect(removed).toBe(false)
+    })
+  })
+
+  describe('Last-Event-ID resumption', () => {
+    it('should parse Last-Event-ID header', async () => {
+      const context = createMockContext(
+        { tables: 'users' },
+        { 'Last-Event-ID': 'lsn-12345' }
+      )
+      const response = transport.createResponse(context)
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const subscribedEvent = events.find(e => e.event === 'subscribed')
+      expect(subscribedEvent).toBeDefined()
+
+      const data = JSON.parse(subscribedEvent!.data!)
+      expect(data.message).toContain('Resumed from lsn-12345')
+    })
+  })
+
+  describe('error handling', () => {
+    it('should send error events', async () => {
+      const context = createMockContext({ tables: 'users' })
+      const response = transport.createResponse(context)
+
+      await transport.sendError(new Error('Test error'), 'TEST_ERROR')
+      await transport.close()
+
+      const text = await readStream(response.body!)
+      const events = parseSSEText(text)
+
+      const errorEvent = events.find(e => e.event === 'error')
+      expect(errorEvent).toBeDefined()
+      expect(errorEvent!.retry).toBe(3000) // default retry
+
+      const data = JSON.parse(errorEvent!.data!)
+      expect(data.error).toBe('Test error')
+      expect(data.code).toBe('TEST_ERROR')
+    })
+  })
+
+  describe('transport state', () => {
+    it('should report closed state correctly', async () => {
+      const context = createMockContext({ tables: 'users' })
+      transport.createResponse(context)
+
+      expect(transport.isClosed()).toBe(false)
+
+      await transport.close()
+
+      expect(transport.isClosed()).toBe(true)
+    })
+
+    it('should not broadcast after close', async () => {
+      const context = createMockContext({ tables: 'users' })
+      transport.createResponse(context)
+
+      await transport.close()
+
+      // Should not throw
+      await transport.broadcastChange({
+        table: 'users',
+        operation: 'INSERT',
+        newRow: { id: 1 },
+      })
+    })
+  })
+})
+
+// ============================================================================
+// CDCSSEManager Tests
+// ============================================================================
+
+describe('CDCSSEManager', () => {
+  let manager: CDCSSEManager
+
+  beforeEach(() => {
+    manager = createCDCSSEManager()
+  })
+
+  afterEach(async () => {
+    await manager.closeAll()
+  })
+
+  describe('createConnection', () => {
+    it('should create a new connection with unique ID', () => {
+      const request = createMockRequest({ tables: 'users' })
+      const { connectionId, response, transport } = manager.createConnection(request)
+
+      expect(connectionId).toMatch(/^sse-\d+-\d+$/)
+      expect(response.status).toBe(200)
+      expect(transport).toBeDefined()
+    })
+
+    it('should track connection count', () => {
+      expect(manager.getConnectionCount()).toBe(0)
+
+      manager.createConnection(createMockRequest({ tables: 'users' }))
+      expect(manager.getConnectionCount()).toBe(1)
+
+      manager.createConnection(createMockRequest({ tables: 'posts' }))
+      expect(manager.getConnectionCount()).toBe(2)
+    })
+  })
+
+  describe('broadcastChange', () => {
+    it('should broadcast to all connections', async () => {
+      const { response: response1, transport: transport1 } = manager.createConnection(
+        createMockRequest({ tables: 'users' })
+      )
+      const { response: response2, transport: transport2 } = manager.createConnection(
+        createMockRequest({ tables: 'users' })
+      )
+
+      await manager.broadcastChange({
+        table: 'users',
+        operation: 'INSERT',
+        newRow: { id: 1 },
+      })
+
+      await transport1.close()
+      await transport2.close()
+
+      const text1 = await readStream(response1.body!)
+      const text2 = await readStream(response2.body!)
+
+      const events1 = parseSSEText(text1)
+      const events2 = parseSSEText(text2)
+
+      expect(events1.find(e => e.event === 'insert')).toBeDefined()
+      expect(events2.find(e => e.event === 'insert')).toBeDefined()
+    })
+
+    it('should only broadcast to matching subscriptions', async () => {
+      const { response: usersResponse, transport: usersTransport } = manager.createConnection(
+        createMockRequest({ tables: 'users' })
+      )
+      const { response: ordersResponse, transport: ordersTransport } = manager.createConnection(
+        createMockRequest({ tables: 'orders' })
+      )
+
+      await manager.broadcastChange({
+        table: 'users',
+        operation: 'INSERT',
+        newRow: { id: 1 },
+      })
+
+      await usersTransport.close()
+      await ordersTransport.close()
+
+      const usersText = await readStream(usersResponse.body!)
+      const ordersText = await readStream(ordersResponse.body!)
+
+      const usersEvents = parseSSEText(usersText)
+      const ordersEvents = parseSSEText(ordersText)
+
+      expect(usersEvents.find(e => e.event === 'insert')).toBeDefined()
+      expect(ordersEvents.find(e => e.event === 'insert')).toBeUndefined()
+    })
+  })
+
+  describe('getSubscriptionCount', () => {
+    it('should return total subscriptions across connections', () => {
+      manager.createConnection(createMockRequest({ tables: 'users,posts' }))
+      manager.createConnection(createMockRequest({ tables: 'orders' }))
+
+      expect(manager.getSubscriptionCount()).toBe(3)
+    })
+  })
+
+  describe('closeAll', () => {
+    it('should close all connections', async () => {
+      const { transport: transport1 } = manager.createConnection(
+        createMockRequest({ tables: 'users' })
+      )
+      const { transport: transport2 } = manager.createConnection(
+        createMockRequest({ tables: 'posts' })
+      )
+
+      await manager.closeAll()
+
+      expect(transport1.isClosed()).toBe(true)
+      expect(transport2.isClosed()).toBe(true)
+      expect(manager.getConnectionCount()).toBe(0)
+    })
+  })
+})
+
+// ============================================================================
+// handleCDCSSERequest Tests
+// ============================================================================
+
+describe('handleCDCSSERequest', () => {
+  it('should return a valid SSE response', () => {
+    const request = createMockRequest({ tables: 'users' })
+    const response = handleCDCSSERequest(request)
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get('Content-Type')).toBe('text/event-stream')
+  })
+
+  it('should accept custom configuration', () => {
+    const request = createMockRequest({ tables: 'users' })
+    const response = handleCDCSSERequest(request, {
+      heartbeatIntervalMs: 60000,
+      defaultRetryMs: 5000,
+    })
+
+    expect(response.status).toBe(200)
+  })
+})
+
+// ============================================================================
+// Heartbeat Tests
+// ============================================================================
+
+describe('Heartbeat', () => {
+  it('should send keepalive events at configured interval', async () => {
+    vi.useFakeTimers()
+
+    const transport = createCDCSSETransport({
+      heartbeatIntervalMs: 1000, // 1 second
+    })
+
+    const context = createMockContext({ tables: 'users' })
+    const response = transport.createResponse(context)
+
+    // Advance time to trigger heartbeats
+    await vi.advanceTimersByTimeAsync(3500)
+
+    await transport.close()
+
+    vi.useRealTimers()
+
+    const text = await readStream(response.body!)
+    const events = parseSSEText(text)
+
+    const keepaliveEvents = events.filter(e => e.event === 'keepalive')
+    // Should have ~3 keepalive events (at 1s, 2s, 3s)
+    expect(keepaliveEvents.length).toBeGreaterThanOrEqual(2)
+  })
+})