@robosystems/client 0.1.10 → 0.1.12

package/extensions/SSEClient.js

@@ -0,0 +1,166 @@
+'use client'
+
+/**
+ * Core SSE (Server-Sent Events) client for RoboSystems API
+ * Provides automatic reconnection, event replay, and type-safe event handling
+ */
+
+
+
+
+
+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
+  private eventSource?
+  private reconnectAttempts = 0
+  private lastEventId?
+  private closed = false
+  private listeners void>> = new Map()
+
+  constructor(config) {
+    this.config = {
+      maxRetries,
+      retryDelay,
+      heartbeatInterval,
+      ...config,
+    }
+  }
+
+  async connect(operationId, fromSequence = 0) {
+    return new Promise((resolve, reject) => {
+      const url = `${this.config.baseUrl}/v1/operations/${operationId}/stream?from_sequence=${fromSequence}`
+
+      this.eventSource = new EventSource(url, {
+        withCredentials.config.credentials === 'include',
+      })
+
+      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) => {
+          this.handleTypedEvent(eventType, event)
+        })
+      })
+    })
+  }
+
+  private handleMessage(event) {
+    try {
+      const data = JSON.parse(event.data)
+      const sseEvent = {
+        event.type || 'message',
+        data,
+        id.lastEventId,
+        timestamp Date(),
+      }
+
+      this.lastEventId = event.lastEventId
+      this.emit('event', sseEvent)
+    } catch (error) {
+      this.emit('parse_error', { error, rawData.data })
+    }
+  }
+
+  private handleTypedEvent(eventType, event) {
+    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.data })
+    }
+  }
+
+  private async handleError(error, operationId, fromSequence) {
+    if (this.closed) return
+
+    if (this.reconnectAttempts  {
+        const resumeFrom = this.lastEventId ? parseInt(this.lastEventId) + 1 
+        this.connect(operationId, resumeFrom).catch(() => {
+          // Error handled in connect
+        })
+      }, delay)
+    } else {
+      this.emit('max_retries_exceeded', error)
+      this.close()
+    }
+  }
+
+  on(event, listener) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, new Set())
+    }
+    this.listeners.get(event)!.add(listener)
+  }
+
+  off(event, listener) {
+    const listeners = this.listeners.get(event)
+    if (listeners) {
+      listeners.delete(listener)
+    }
+  }
+
+  private emit(event, data) {
+    const listeners = this.listeners.get(event)
+    if (listeners) {
+      listeners.forEach((listener) => listener(data))
+    }
+  }
+
+  close() {
+    this.closed = true
+    if (this.eventSource) {
+      this.eventSource.close()
+      this.eventSource = undefined
+    }
+    this.emit('closed', null)
+    this.listeners.clear()
+  }
+
+  isConnected() {
+    return this.eventSource !== undefined && this.eventSource.readyState === EventSource.OPEN
+  }
+}

package/extensions/SSEClient.ts

@@ -0,0 +1,189 @@
+'use client'
+
+/**
+ * Core SSE (Server-Sent Events) client for RoboSystems API
+ * Provides automatic reconnection, event replay, and type-safe event handling
+ */
+
+export interface SSEConfig {
+  baseUrl: string
+  credentials?: 'include' | 'same-origin' | 'omit'
+  headers?: Record<string, string>
+  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) => {
+      const url = `${this.config.baseUrl}/v1/operations/${operationId}/stream?from_sequence=${fromSequence}`
+
+      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/extensions/config.d.js

@@ -0,0 +1,25 @@
+/**
+ * Configuration for SDK extensions
+ * Provides centralized configuration for CORS, credentials, and other settings
+ */
+
+/**
+ * Set global configuration for SDK extensions
+ * @param config Partial configuration to merge with defaults
+ */
+export declare function setSDKExtensionsConfig(config);
+/**
+ * Get current SDK extensions configuration
+ * @returns Current configuration
+ */
+export declare function getSDKExtensionsConfig();
+/**
+ * Reset configuration to defaults
+ */
+export declare function resetSDKExtensionsConfig();
+/**
+ * Get configuration for a specific environment
+ * @param env Environment name (production, staging, development)
+ * @returns Environment-specific configuration
+ */
+export declare function getEnvironmentConfig(env? | 'staging' | 'development');

package/extensions/config.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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>;
+    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;
+/**
+ * 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;

package/extensions/config.js

@@ -0,0 +1,66 @@
+'use client'
+
+/**
+ * Configuration for SDK extensions
+ * Provides centralized configuration for CORS, credentials, and other settings
+ */
+
+
+
+// Default configuration
+const defaultConfig = {
+  baseUrl.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
+  credentials,
+  timeout,
+  maxRetries,
+  retryDelay,
+}
+
+// Global configuration singleton
+let globalConfig = { ...defaultConfig }
+
+/**
+ * Set global configuration for SDK extensions
+ * @param config Partial configuration to merge with defaults
+ */
+export function setSDKExtensionsConfig(config) {
+  globalConfig = {
+    ...globalConfig,
+    ...config,
+  }
+}
+
+/**
+ * Get current SDK extensions configuration
+ * @returns Current configuration
+ */
+export function getSDKExtensionsConfig() {
+  return { ...globalConfig }
+}
+
+/**
+ * Reset configuration to defaults
+ */
+export function resetSDKExtensionsConfig() {
+  globalConfig = { ...defaultConfig }
+}
+
+/**
+ * Get configuration for a specific environment
+ * @param env Environment name (production, staging, development)
+ * @returns Environment-specific configuration
+ */
+export function getEnvironmentConfig(
+  env | 'staging' | 'development' = 'development'
+) {
+  const baseConfigs> = {
+    production,
+    staging,
+    development,
+  }
+
+  return {
+    ...defaultConfig,
+    ...baseConfigs[env],
+  }
+}

package/extensions/config.ts

@@ -0,0 +1,91 @@
+'use client'
+
+/**
+ * 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>
+  timeout?: number
+  maxRetries?: number
+  retryDelay?: number
+}
+
+// Default configuration
+const defaultConfig: SDKExtensionsConfig = {
+  baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
+  credentials: 'include',
+  timeout: 30000,
+  maxRetries: 3,
+  retryDelay: 1000,
+}
+
+// Global configuration singleton
+let globalConfig: SDKExtensionsConfig = { ...defaultConfig }
+
+/**
+ * Set global configuration for SDK extensions
+ * @param config Partial configuration to merge with defaults
+ */
+export function setSDKExtensionsConfig(config: Partial<SDKExtensionsConfig>) {
+  globalConfig = {
+    ...globalConfig,
+    ...config,
+  }
+}
+
+/**
+ * Get current SDK extensions configuration
+ * @returns Current configuration
+ */
+export function getSDKExtensionsConfig(): SDKExtensionsConfig {
+  return { ...globalConfig }
+}
+
+/**
+ * Reset configuration to defaults
+ */
+export function resetSDKExtensionsConfig() {
+  globalConfig = { ...defaultConfig }
+}
+
+/**
+ * Get configuration for a specific environment
+ * @param env Environment name (production, staging, development)
+ * @returns Environment-specific configuration
+ */
+export function getEnvironmentConfig(
+  env: 'production' | 'staging' | 'development' = 'development'
+): SDKExtensionsConfig {
+  const baseConfigs: Record<string, Partial<SDKExtensionsConfig>> = {
+    production: {
+      baseUrl: process.env.NEXT_PUBLIC_API_URL || 'https://api.robosystems.ai',
+      credentials: 'include',
+      timeout: 60000,
+      maxRetries: 5,
+      retryDelay: 2000,
+    },
+    staging: {
+      baseUrl: process.env.NEXT_PUBLIC_API_URL || 'https://staging-api.robosystems.ai',
+      credentials: 'include',
+      timeout: 45000,
+      maxRetries: 3,
+      retryDelay: 1500,
+    },
+    development: {
+      baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
+      credentials: 'include',
+      timeout: 30000,
+      maxRetries: 3,
+      retryDelay: 1000,
+    },
+  }
+
+  return {
+    ...defaultConfig,
+    ...baseConfigs[env],
+  }
+}

package/extensions/hooks.d.js

@@ -0,0 +1,80 @@
+import { OperationProgress, OperationResult } from './OperationClient';
+import { OperationClient } from './OperationClient';
+import { QueryOptions, QueryResult } from './QueryClient';
+import { QueryClient } from './QueryClient';
+/**
+ * Hook for executing Cypher queries with loading states and error handling
+ *
+ * @example
+ * ```tsx
+ * const { execute, loading, error, data } = useQuery('graph_123')
+ *
+ * const handleSearch = async () => {
+ *   const result = await execute('MATCH (n:Company) RETURN n LIMIT 10')
+ *   console.log(result.data)
+ * }
+ * ```
+ */
+export declare function useQuery(graphId);
+/**
+ * Hook for streaming large query results
+ *
+ * @example
+ * ```tsx
+ * const { stream, isStreaming, error, cancel } = useStreamingQuery('graph_123')
+ *
+ * const handleStream = async () => {
+ *   const iterator = stream('MATCH (n) RETURN n')
+ *   for await (const batch of iterator) {
+ *     console.log('Received batch:', batch)
+ *   }
+ * }
+ * ```
+ */
+export declare function useStreamingQuery(graphId);
+/**
+ * Hook for monitoring long-running operations
+ *
+ * @example
+ * ```tsx
+ * const { monitor, status, progress, error, result } = useOperation()
+ *
+ * const handleBackup = async () => {
+ *   const { operation_id } = await createBackup({ ... })
+ *   const result = await monitor(operation_id)
+ *   console.log('Backup completed:', result)
+ * }
+ * ```
+ */
+export declare function useOperation(operationId?);
+/**
+ * Hook for monitoring multiple operations concurrently
+ *
+ * @example
+ * ```tsx
+ * const { monitorAll, results, allCompleted, hasErrors } = useMultipleOperations()
+ *
+ * const handleMultiple = async () => {
+ *   const operations = await Promise.all([
+ *     createBackup(...),
+ *     createExport(...),
+ *   ])
+ *
+ *   const results = await monitorAll(operations.map(op => op.operation_id))
+ * }
+ * ```
+ */
+export declare function useMultipleOperations();
+/**
+ * Hook that provides access to all SDK extension clients
+ * Useful when you need direct access to the underlying clients
+ *
+ * @example
+ * ```tsx
+ * const clients = useSDKClients()
+ *
+ * // Direct access to clients
+ * const result = await clients.query.query('graph_123', 'MATCH (n) RETURN n')
+ * ```
+ */
+export declare function useSDKClients();