@robosystems/client 0.2.48 → 0.3.0

package/sdk-extensions/SSEClient.test.ts

@@ -1,375 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest'
-import { EventType, SSEClient } from './SSEClient'
-
-// Mock EventSource for testing
-class MockEventSource {
-  url: string
-  withCredentials: boolean
-  readyState: number = 0 // 0 = CONNECTING, 1 = OPEN, 2 = CLOSED
-  onopen: ((event: any) => void) | null = null
-  onerror: ((event: any) => void) | null = null
-  onmessage: ((event: any) => void) | null = null
-  private eventListeners: Map<string, Set<(event: any) => void>> = new Map()
-
-  static CONNECTING = 0
-  static OPEN = 1
-  static CLOSED = 2
-
-  constructor(url: string, options?: { withCredentials?: boolean }) {
-    this.url = url
-    this.withCredentials = options?.withCredentials ?? false
-
-    // Simulate async connection
-    setTimeout(() => {
-      this.readyState = MockEventSource.OPEN
-      if (this.onopen) {
-        this.onopen({ type: 'open' })
-      }
-    }, 0)
-  }
-
-  addEventListener(event: string, listener: (event: any) => void) {
-    if (!this.eventListeners.has(event)) {
-      this.eventListeners.set(event, new Set())
-    }
-    this.eventListeners.get(event)!.add(listener)
-  }
-
-  removeEventListener(event: string, listener: (event: any) => void) {
-    const listeners = this.eventListeners.get(event)
-    if (listeners) {
-      listeners.delete(listener)
-    }
-  }
-
-  dispatchEvent(event: any) {
-    const listeners = this.eventListeners.get(event.type)
-    if (listeners) {
-      listeners.forEach((listener) => listener(event))
-    }
-    return true
-  }
-
-  close() {
-    this.readyState = MockEventSource.CLOSED
-  }
-
-  // Test helper to simulate receiving a message
-  simulateMessage(eventType: string, data: any, lastEventId?: string) {
-    const event = {
-      type: eventType,
-      data: JSON.stringify(data),
-      lastEventId: lastEventId || '',
-    }
-
-    if (eventType === 'message' && this.onmessage) {
-      this.onmessage(event)
-    } else {
-      const listeners = this.eventListeners.get(eventType)
-      if (listeners) {
-        listeners.forEach((listener) => listener(event))
-      }
-    }
-  }
-
-  // Test helper to simulate error
-  simulateError() {
-    if (this.onerror) {
-      this.onerror({ type: 'error' })
-    }
-  }
-}
-
-describe('SSEClient', () => {
-  let mockEventSource: MockEventSource
-
-  beforeEach(() => {
-    // Mock global EventSource
-    global.EventSource = MockEventSource as any
-    vi.clearAllMocks()
-  })
-
-  describe('connect', () => {
-    it('should connect to SSE endpoint successfully', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await expect(client.connect('op_123')).resolves.toBeUndefined()
-      expect(client.isConnected()).toBe(true)
-    })
-
-    it('should include token in URL when provided', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-        token: 'my-jwt-token',
-      })
-
-      await client.connect('op_123')
-
-      // We can't directly access the EventSource URL in this mock,
-      // but the client should have connected successfully
-      expect(client.isConnected()).toBe(true)
-    })
-
-    it('should include from_sequence parameter', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await client.connect('op_123', 42)
-      expect(client.isConnected()).toBe(true)
-    })
-
-    it('should set withCredentials when credentials is include', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-        credentials: 'include',
-      })
-
-      await client.connect('op_123')
-      expect(client.isConnected()).toBe(true)
-    })
-  })
-
-  describe('event handling', () => {
-    it('should emit connected event on connection', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const connectedEvents: any[] = []
-      client.on('connected', (data) => connectedEvents.push(data))
-
-      await client.connect('op_123')
-
-      expect(connectedEvents).toHaveLength(1)
-    })
-
-    it('should handle typed events', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const progressEvents: any[] = []
-      client.on(EventType.OPERATION_PROGRESS, (data) => progressEvents.push(data))
-
-      await client.connect('op_123')
-
-      // Simulate receiving a progress event
-      const eventSource = (client as any).eventSource as MockEventSource
-      eventSource.simulateMessage(EventType.OPERATION_PROGRESS, {
-        message: 'Processing...',
-        progress_percent: 50,
-      })
-
-      expect(progressEvents).toHaveLength(1)
-      expect(progressEvents[0].message).toBe('Processing...')
-      expect(progressEvents[0].progress_percent).toBe(50)
-    })
-
-    it('should auto-close on completion events', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await client.connect('op_123')
-
-      const eventSource = (client as any).eventSource as MockEventSource
-      eventSource.simulateMessage(EventType.OPERATION_COMPLETED, {
-        result: { success: true },
-      })
-
-      // Client should close automatically
-      expect(client.isConnected()).toBe(false)
-    })
-
-    it('should auto-close on error events', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await client.connect('op_123')
-
-      const eventSource = (client as any).eventSource as MockEventSource
-      eventSource.simulateMessage(EventType.OPERATION_ERROR, {
-        error: 'Something failed',
-      })
-
-      expect(client.isConnected()).toBe(false)
-    })
-
-    it('should auto-close on cancelled events', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await client.connect('op_123')
-
-      const eventSource = (client as any).eventSource as MockEventSource
-      eventSource.simulateMessage(EventType.OPERATION_CANCELLED, {
-        message: 'Cancelled by user',
-      })
-
-      expect(client.isConnected()).toBe(false)
-    })
-
-    it('should handle heartbeat events', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const heartbeats: any[] = []
-      client.on(EventType.HEARTBEAT, (data) => heartbeats.push(data))
-
-      await client.connect('op_123')
-
-      const eventSource = (client as any).eventSource as MockEventSource
-      eventSource.simulateMessage(EventType.HEARTBEAT, { timestamp: Date.now() })
-
-      expect(heartbeats).toHaveLength(1)
-    })
-
-    it('should handle data chunk events', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const chunks: any[] = []
-      client.on(EventType.DATA_CHUNK, (data) => chunks.push(data))
-
-      await client.connect('op_123')
-
-      const eventSource = (client as any).eventSource as MockEventSource
-      eventSource.simulateMessage(EventType.DATA_CHUNK, {
-        rows: [
-          { id: 1, name: 'Alice' },
-          { id: 2, name: 'Bob' },
-        ],
-      })
-
-      expect(chunks).toHaveLength(1)
-      expect(chunks[0].rows).toHaveLength(2)
-    })
-  })
-
-  describe('listener management', () => {
-    it('should add and remove listeners', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const events: any[] = []
-      const listener = (data: any) => events.push(data)
-
-      client.on('test-event', listener)
-      await client.connect('op_123')
-
-      // Manually emit an event
-      ;(client as any).emit('test-event', { value: 1 })
-      expect(events).toHaveLength(1)
-
-      // Remove listener
-      client.off('test-event', listener)
-      ;(client as any).emit('test-event', { value: 2 })
-      expect(events).toHaveLength(1) // Should not have increased
-    })
-
-    it('should support multiple listeners for same event', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const events1: any[] = []
-      const events2: any[] = []
-
-      client.on('test-event', (data) => events1.push(data))
-      client.on('test-event', (data) => events2.push(data))
-
-      await client.connect('op_123')
-      ;(client as any).emit('test-event', { value: 1 })
-
-      expect(events1).toHaveLength(1)
-      expect(events2).toHaveLength(1)
-    })
-  })
-
-  describe('close', () => {
-    it('should close the connection', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await client.connect('op_123')
-      expect(client.isConnected()).toBe(true)
-
-      client.close()
-      expect(client.isConnected()).toBe(false)
-    })
-
-    it('should emit closed event', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const closedEvents: any[] = []
-      client.on('closed', (data) => closedEvents.push(data))
-
-      await client.connect('op_123')
-      client.close()
-
-      expect(closedEvents).toHaveLength(1)
-    })
-
-    it('should clear all listeners on close', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      const events: any[] = []
-      client.on('test-event', (data) => events.push(data))
-
-      await client.connect('op_123')
-      client.close()
-
-      // Try to emit after close - should not receive events
-      ;(client as any).emit('test-event', { value: 1 })
-      expect(events).toHaveLength(0)
-    })
-
-    it('should be safe to call close multiple times', async () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await client.connect('op_123')
-
-      client.close()
-      expect(() => client.close()).not.toThrow()
-    })
-  })
-
-  describe('configuration', () => {
-    it('should accept all config options', () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-        credentials: 'include',
-        headers: { 'X-Custom': 'value' },
-        token: 'jwt-token',
-        maxRetries: 5,
-        retryDelay: 2000,
-        heartbeatInterval: 60000,
-      })
-
-      expect(client).toBeInstanceOf(SSEClient)
-    })
-
-    it('should use default config values', () => {
-      const client = new SSEClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      expect(client).toBeInstanceOf(SSEClient)
-    })
-  })
-})

package/sdk-extensions/SSEClient.ts

@@ -1,210 +0,0 @@
-'use client'
-
-/**
- * Core SSE (Server-Sent Events) client for RoboSystems API
- * Provides automatic reconnection, event replay, and type-safe event handling
- *
- * SECURITY NOTE: When using JWT authentication, tokens are passed as query parameters
- * due to EventSource API limitations. This means tokens may appear in:
- * - Server access logs
- * - Proxy logs
- * - Browser history
- * - Referer headers
- *
- * For production environments with sensitive data, consider:
- * - Using cookie-based authentication instead
- * - Implementing a WebSocket-based alternative
- * - Using short-lived tokens that expire quickly
- * - Ensuring all connections use HTTPS
- */
-
-export interface SSEConfig {
-  baseUrl: string
-  credentials?: 'include' | 'same-origin' | 'omit'
-  headers?: Record<string, string>
-  token?: string // JWT token for authentication
-  maxRetries?: number
-  retryDelay?: number
-  heartbeatInterval?: number
-}
-
-export interface SSEEvent {
-  event: string
-  data: any
-  id?: string
-  retry?: number
-  timestamp: Date
-}
-
-export enum EventType {
-  OPERATION_STARTED = 'operation_started',
-  OPERATION_PROGRESS = 'operation_progress',
-  OPERATION_COMPLETED = 'operation_completed',
-  OPERATION_ERROR = 'operation_error',
-  OPERATION_CANCELLED = 'operation_cancelled',
-  DATA_CHUNK = 'data_chunk',
-  METADATA = 'metadata',
-  HEARTBEAT = 'heartbeat',
-  QUEUE_UPDATE = 'queue_update',
-}
-
-export class SSEClient {
-  private config: SSEConfig
-  private eventSource?: EventSource
-  private reconnectAttempts: number = 0
-  private lastEventId?: string
-  private closed: boolean = false
-  private listeners: Map<string, Set<(data: any) => void>> = new Map()
-
-  constructor(config: SSEConfig) {
-    this.config = {
-      maxRetries: 5,
-      retryDelay: 1000,
-      heartbeatInterval: 30000,
-      ...config,
-    }
-  }
-
-  async connect(operationId: string, fromSequence: number = 0): Promise<void> {
-    return new Promise((resolve, reject) => {
-      let url = `${this.config.baseUrl}/v1/operations/${operationId}/stream?from_sequence=${fromSequence}`
-
-      // Add JWT token as query parameter if provided
-      // WARNING: EventSource API doesn't support custom headers, so tokens are passed via query param
-      // This has security implications - see class documentation
-      if (this.config.token) {
-        url += `&token=${encodeURIComponent(this.config.token)}`
-      }
-
-      this.eventSource = new EventSource(url, {
-        withCredentials: this.config.credentials === 'include',
-      } as any)
-
-      const connectionTimeout = setTimeout(() => {
-        reject(new Error('Connection timeout'))
-        this.close()
-      }, 10000)
-
-      this.eventSource.onopen = () => {
-        clearTimeout(connectionTimeout)
-        this.reconnectAttempts = 0
-        this.emit('connected', null)
-        resolve()
-      }
-
-      this.eventSource.onerror = (error) => {
-        clearTimeout(connectionTimeout)
-        if (!this.closed) {
-          this.handleError(error, operationId, fromSequence)
-        }
-      }
-
-      this.eventSource.onmessage = (event) => {
-        this.handleMessage(event)
-      }
-
-      // Set up specific event listeners
-      Object.values(EventType).forEach((eventType) => {
-        this.eventSource!.addEventListener(eventType, (event: any) => {
-          this.handleTypedEvent(eventType, event)
-        })
-      })
-    })
-  }
-
-  private handleMessage(event: MessageEvent): void {
-    try {
-      const data = JSON.parse(event.data)
-      const sseEvent: SSEEvent = {
-        event: event.type || 'message',
-        data,
-        id: event.lastEventId,
-        timestamp: new Date(),
-      }
-
-      this.lastEventId = event.lastEventId
-      this.emit('event', sseEvent)
-    } catch (error) {
-      this.emit('parse_error', { error, rawData: event.data })
-    }
-  }
-
-  private handleTypedEvent(eventType: string, event: MessageEvent): void {
-    try {
-      const data = JSON.parse(event.data)
-      this.lastEventId = event.lastEventId
-      this.emit(eventType, data)
-
-      // Check for completion events
-      if (
-        eventType === EventType.OPERATION_COMPLETED ||
-        eventType === EventType.OPERATION_ERROR ||
-        eventType === EventType.OPERATION_CANCELLED
-      ) {
-        this.close()
-      }
-    } catch (error) {
-      this.emit('parse_error', { error, rawData: event.data })
-    }
-  }
-
-  private async handleError(error: any, operationId: string, fromSequence: number): Promise<void> {
-    if (this.closed) return
-
-    if (this.reconnectAttempts < this.config.maxRetries!) {
-      this.reconnectAttempts++
-      const delay = this.config.retryDelay! * Math.pow(2, this.reconnectAttempts - 1)
-
-      this.emit('reconnecting', {
-        attempt: this.reconnectAttempts,
-        delay,
-        lastEventId: this.lastEventId,
-      })
-
-      setTimeout(() => {
-        const resumeFrom = this.lastEventId ? parseInt(this.lastEventId) + 1 : fromSequence
-        this.connect(operationId, resumeFrom).catch(() => {
-          // Error handled in connect
-        })
-      }, delay)
-    } else {
-      this.emit('max_retries_exceeded', error)
-      this.close()
-    }
-  }
-
-  on(event: string, listener: (data: any) => void): void {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, new Set())
-    }
-    this.listeners.get(event)!.add(listener)
-  }
-
-  off(event: string, listener: (data: any) => void): void {
-    const listeners = this.listeners.get(event)
-    if (listeners) {
-      listeners.delete(listener)
-    }
-  }
-
-  private emit(event: string, data: any): void {
-    const listeners = this.listeners.get(event)
-    if (listeners) {
-      listeners.forEach((listener) => listener(data))
-    }
-  }
-
-  close(): void {
-    this.closed = true
-    if (this.eventSource) {
-      this.eventSource.close()
-      this.eventSource = undefined
-    }
-    this.emit('closed', null)
-    this.listeners.clear()
-  }
-
-  isConnected(): boolean {
-    return this.eventSource !== undefined && this.eventSource.readyState === EventSource.OPEN
-  }
-}

package/sdk-extensions/config.d.ts

@@ -1,57 +0,0 @@
-/**
- * Configuration for SDK extensions
- * Provides centralized configuration for CORS, credentials, and other settings
- */
-export interface SDKExtensionsConfig {
-    baseUrl?: string;
-    credentials?: 'include' | 'same-origin' | 'omit';
-    headers?: Record<string, string>;
-    token?: string;
-    timeout?: number;
-    maxRetries?: number;
-    retryDelay?: number;
-}
-/**
- * Set global configuration for SDK extensions
- * @param config Partial configuration to merge with defaults
- */
-export declare function setSDKExtensionsConfig(config: Partial<SDKExtensionsConfig>): void;
-/**
- * Get current SDK extensions configuration
- * @returns Current configuration
- */
-export declare function getSDKExtensionsConfig(): SDKExtensionsConfig;
-/**
- * Reset configuration to defaults
- */
-export declare function resetSDKExtensionsConfig(): void;
-/**
- * Extract JWT token from Authorization header
- * @param authHeader Authorization header value
- * @returns JWT token or undefined
- */
-export declare function extractJWTFromHeader(authHeader?: string | string[]): string | undefined;
-/**
- * Validate JWT token format (basic validation)
- * @param token JWT token to validate
- * @returns true if token appears valid
- */
-export declare function isValidJWT(token: string | undefined): boolean;
-/**
- * Extract JWT token from SDK client configuration
- * Centralizes the logic for extracting tokens from the client
- * @returns JWT token or undefined
- */
-export declare function extractTokenFromSDKClient(): string | undefined;
-/**
- * Configure SDK extensions for JWT authentication
- * @param token JWT token
- * @param config Additional configuration options
- */
-export declare function configureWithJWT(token: string, config?: Partial<SDKExtensionsConfig>): void;
-/**
- * Get configuration for a specific environment
- * @param env Environment name (production, staging, development)
- * @returns Environment-specific configuration
- */
-export declare function getEnvironmentConfig(env?: 'production' | 'staging' | 'development'): SDKExtensionsConfig;