@robosystems/client 0.1.15 → 0.1.16

package/sdk-extensions/SSEClient.js

@@ -0,0 +1,148 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEClient = exports.EventType = void 0;
+var EventType;
+(function (EventType) {
+    EventType["OPERATION_STARTED"] = "operation_started";
+    EventType["OPERATION_PROGRESS"] = "operation_progress";
+    EventType["OPERATION_COMPLETED"] = "operation_completed";
+    EventType["OPERATION_ERROR"] = "operation_error";
+    EventType["OPERATION_CANCELLED"] = "operation_cancelled";
+    EventType["DATA_CHUNK"] = "data_chunk";
+    EventType["METADATA"] = "metadata";
+    EventType["HEARTBEAT"] = "heartbeat";
+    EventType["QUEUE_UPDATE"] = "queue_update";
+})(EventType || (exports.EventType = EventType = {}));
+class SSEClient {
+    constructor(config) {
+        this.reconnectAttempts = 0;
+        this.closed = false;
+        this.listeners = new Map();
+        this.config = {
+            maxRetries: 5,
+            retryDelay: 1000,
+            heartbeatInterval: 30000,
+            ...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: this.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);
+                });
+            });
+        });
+    }
+    handleMessage(event) {
+        try {
+            const data = JSON.parse(event.data);
+            const 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 });
+        }
+    }
+    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: event.data });
+        }
+    }
+    async handleError(error, operationId, fromSequence) {
+        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, 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);
+        }
+    }
+    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;
+    }
+}
+exports.SSEClient = SSEClient;

package/sdk-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/sdk-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/sdk-extensions/config.js

@@ -0,0 +1,74 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setSDKExtensionsConfig = setSDKExtensionsConfig;
+exports.getSDKExtensionsConfig = getSDKExtensionsConfig;
+exports.resetSDKExtensionsConfig = resetSDKExtensionsConfig;
+exports.getEnvironmentConfig = getEnvironmentConfig;
+// Default configuration
+const defaultConfig = {
+    baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
+    credentials: 'include',
+    timeout: 30000,
+    maxRetries: 3,
+    retryDelay: 1000,
+};
+// Global configuration singleton
+let globalConfig = { ...defaultConfig };
+/**
+ * Set global configuration for SDK extensions
+ * @param config Partial configuration to merge with defaults
+ */
+function setSDKExtensionsConfig(config) {
+    globalConfig = {
+        ...globalConfig,
+        ...config,
+    };
+}
+/**
+ * Get current SDK extensions configuration
+ * @returns Current configuration
+ */
+function getSDKExtensionsConfig() {
+    return { ...globalConfig };
+}
+/**
+ * Reset configuration to defaults
+ */
+function resetSDKExtensionsConfig() {
+    globalConfig = { ...defaultConfig };
+}
+/**
+ * Get configuration for a specific environment
+ * @param env Environment name (production, staging, development)
+ * @returns Environment-specific configuration
+ */
+function getEnvironmentConfig(env = 'development') {
+    const baseConfigs = {
+        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/sdk-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/sdk-extensions/hooks.d.ts

@@ -0,0 +1,110 @@
+import type { OperationProgress, OperationResult } from './OperationClient';
+import { OperationClient } from './OperationClient';
+import type { 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: string): {
+    execute: (query: string, parameters?: Record<string, any>, options?: QueryOptions) => Promise<QueryResult | null>;
+    query: (cypher: string, parameters?: Record<string, any>) => Promise<any[]>;
+    loading: boolean;
+    error: Error;
+    data: QueryResult;
+    queuePosition: number;
+};
+/**
+ * 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: string): {
+    stream: (query: string, parameters?: Record<string, any>, chunkSize?: number) => AsyncIterableIterator<any[]>;
+    isStreaming: boolean;
+    error: Error;
+    rowsReceived: number;
+    cancel: () => void;
+};
+/**
+ * Hook for monitoring long-running operations
+ *
+ * @example
+ * ```tsx
+ * const { monitor, status, progress, error, result } = useOperation<BackupResult>()
+ *
+ * const handleBackup = async () => {
+ *   const { operation_id } = await createBackup({ ... })
+ *   const result = await monitor(operation_id)
+ *   console.log('Backup completed:', result)
+ * }
+ * ```
+ */
+export declare function useOperation<T = any>(operationId?: string): {
+    monitor: (id: string, timeout?: number) => Promise<OperationResult<T> | null>;
+    cancel: (id: string) => Promise<void>;
+    status: "error" | "idle" | "running" | "completed";
+    progress: OperationProgress;
+    error: Error;
+    result: OperationResult<T>;
+};
+/**
+ * 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<T = any>(): {
+    monitorAll: (operationIds: string[]) => Promise<Map<string, OperationResult<T>>>;
+    results: Map<string, OperationResult<T>>;
+    errors: Map<string, Error>;
+    loading: boolean;
+    allCompleted: boolean;
+    hasErrors: boolean;
+};
+/**
+ * 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(): {
+    query: QueryClient | null;
+    operations: OperationClient | null;
+};