@robosystems/client 0.1.11 → 0.1.13

package/extensions/SSEClient.js

@@ -1,166 +1,148 @@
-'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,
+'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 });
+        }
     }
-  }
-
-  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)
+    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 });
         }
-      }
-
-      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 })
+    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();
+        }
     }
-  }
-
-  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);
     }
-  }
-
-  on(event, listener) {
-    if (!this.listeners.has(event)) {
-      this.listeners.set(event, new Set())
+    off(event, listener) {
+        const listeners = this.listeners.get(event);
+        if (listeners) {
+            listeners.delete(listener);
+        }
     }
-    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));
+        }
     }
-  }
-
-  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();
     }
-  }
-
-  close() {
-    this.closed = true
-    if (this.eventSource) {
-      this.eventSource.close()
-      this.eventSource = undefined
+    isConnected() {
+        return this.eventSource !== undefined && this.eventSource.readyState === EventSource.OPEN;
     }
-    this.emit('closed', null)
-    this.listeners.clear()
-  }
-
-  isConnected() {
-    return this.eventSource !== undefined && this.eventSource.readyState === EventSource.OPEN
-  }
 }
+exports.SSEClient = SSEClient;

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

@@ -1,66 +1,74 @@
-'use client'
-
-/**
- * Configuration for SDK extensions
- * Provides centralized configuration for CORS, credentials, and other settings
- */
-
-
-
+'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.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
-  credentials,
-  timeout,
-  maxRetries,
-  retryDelay,
-}
-
+    baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
+    credentials: 'include',
+    timeout: 30000,
+    maxRetries: 3,
+    retryDelay: 1000,
+};
 // Global configuration singleton
-let globalConfig = { ...defaultConfig }
-
+let globalConfig = { ...defaultConfig };
 /**
  * Set global configuration for SDK extensions
  * @param config Partial configuration to merge with defaults
  */
-export function setSDKExtensionsConfig(config) {
-  globalConfig = {
-    ...globalConfig,
-    ...config,
-  }
+function setSDKExtensionsConfig(config) {
+    globalConfig = {
+        ...globalConfig,
+        ...config,
+    };
 }
-
 /**
  * Get current SDK extensions configuration
  * @returns Current configuration
  */
-export function getSDKExtensionsConfig() {
-  return { ...globalConfig }
+function getSDKExtensionsConfig() {
+    return { ...globalConfig };
 }
-
 /**
  * Reset configuration to defaults
  */
-export function resetSDKExtensionsConfig() {
-  globalConfig = { ...defaultConfig }
+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],
-  }
+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/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;
+};