@robosystems/client 0.2.48 → 0.3.0

package/sdk-extensions/OperationClient.ts

@@ -1,324 +0,0 @@
-'use client'
-
-/**
- * General Operations Client for monitoring async operations
- * Handles graph creation, backups, imports, and other long-running tasks
- */
-
-import { cancelOperation as cancelOperationSDK, getOperationStatus } from '../sdk/sdk.gen'
-import { EventType, SSEClient } from './SSEClient'
-
-export interface OperationProgress {
-  message: string
-  progressPercent?: number
-  details?: Record<string, any>
-}
-
-export interface OperationResult<T = any> {
-  success: boolean
-  result?: T
-  error?: string
-  metadata?: Record<string, any>
-}
-
-export interface OperationMonitorOptions {
-  onProgress?: (progress: OperationProgress) => void
-  onQueueUpdate?: (position: number, estimatedWait: number) => void
-  timeout?: number
-}
-
-export class OperationClient {
-  private sseClients: Map<string, SSEClient> = new Map()
-  private cleanupTimeouts: Map<string, ReturnType<typeof setTimeout>> = new Map()
-  private config: {
-    baseUrl: string
-    credentials?: 'include' | 'same-origin' | 'omit'
-    headers?: Record<string, string>
-    token?: string // JWT token for authentication
-    maxRetries?: number
-    retryDelay?: number
-  }
-  private cleanupIntervalMs = 300000 // 5 minutes
-  private cleanupInterval?: ReturnType<typeof setInterval>
-
-  constructor(config: {
-    baseUrl: string
-    credentials?: 'include' | 'same-origin' | 'omit'
-    headers?: Record<string, string>
-    token?: string // JWT token for authentication
-    maxRetries?: number
-    retryDelay?: number
-  }) {
-    this.config = config
-
-    // Start periodic cleanup check every 5 minutes
-    this.cleanupInterval = setInterval(() => {
-      this.performPeriodicCleanup()
-    }, this.cleanupIntervalMs)
-  }
-
-  async monitorOperation<T = any>(
-    operationId: string,
-    options: OperationMonitorOptions = {}
-  ): Promise<OperationResult<T>> {
-    return new Promise((resolve, reject) => {
-      const sseClient = new SSEClient(this.config)
-      this.sseClients.set(operationId, sseClient)
-
-      const timeoutHandle = options.timeout
-        ? setTimeout(() => {
-            this.cleanupClient(operationId)
-            reject(new Error(`Operation timeout after ${options.timeout}ms`))
-          }, options.timeout)
-        : undefined
-
-      sseClient
-        .connect(operationId)
-        .then(() => {
-          let result: OperationResult<T> = { success: false }
-
-          // Track queue updates
-          if (options.onQueueUpdate) {
-            sseClient.on(EventType.QUEUE_UPDATE, (data) => {
-              options.onQueueUpdate!(
-                data.position || data.queue_position,
-                data.estimated_wait_seconds || 0
-              )
-            })
-          }
-
-          // Track progress
-          if (options.onProgress) {
-            sseClient.on(EventType.OPERATION_PROGRESS, (data) => {
-              options.onProgress!({
-                message: data.message || data.status || 'Processing...',
-                progressPercent: data.progress_percent || data.progress,
-                details: data,
-              })
-            })
-          }
-
-          // Handle completion
-          sseClient.on(EventType.OPERATION_COMPLETED, (data) => {
-            if (timeoutHandle) clearTimeout(timeoutHandle)
-            result = {
-              success: true,
-              result: data.result || data,
-              metadata: data.metadata,
-            }
-            // Schedule cleanup after a short delay to ensure all data is received
-            this.scheduleCleanup(operationId, 5000)
-            resolve(result)
-          })
-
-          // Handle errors
-          sseClient.on(EventType.OPERATION_ERROR, (error) => {
-            if (timeoutHandle) clearTimeout(timeoutHandle)
-            result = {
-              success: false,
-              error: error.message || error.error || 'Operation failed',
-              metadata: error.metadata,
-            }
-            // Schedule cleanup after a short delay
-            this.scheduleCleanup(operationId, 5000)
-            resolve(result) // Resolve with error result, not reject
-          })
-
-          // Handle cancellation
-          sseClient.on(EventType.OPERATION_CANCELLED, (data) => {
-            if (timeoutHandle) clearTimeout(timeoutHandle)
-            result = {
-              success: false,
-              error: 'Operation cancelled',
-              metadata: data,
-            }
-            // Schedule cleanup after a short delay
-            this.scheduleCleanup(operationId, 5000)
-            resolve(result)
-          })
-        })
-        .catch((error) => {
-          if (timeoutHandle) clearTimeout(timeoutHandle)
-          this.cleanupClient(operationId)
-          reject(error)
-        })
-    })
-  }
-
-  /**
-   * Monitor multiple operations concurrently
-   */
-  async monitorMultiple<T = any>(
-    operationIds: string[],
-    options: OperationMonitorOptions = {}
-  ): Promise<Map<string, OperationResult<T>>> {
-    const results = await Promise.all(
-      operationIds.map(async (id) => {
-        const result = await this.monitorOperation<T>(id, options)
-        return [id, result] as [string, OperationResult<T>]
-      })
-    )
-    return new Map(results)
-  }
-
-  /**
-   * Get the current status of an operation (point-in-time check)
-   */
-  async getStatus(operationId: string): Promise<any> {
-    const response = await getOperationStatus({
-      path: { operation_id: operationId },
-    })
-    return response.data
-  }
-
-  /**
-   * Cancel a pending or running operation
-   */
-  async cancelOperation(operationId: string): Promise<void> {
-    // First close any active SSE connection
-    this.cleanupClient(operationId)
-
-    // Then cancel the operation
-    await cancelOperationSDK({
-      path: { operation_id: operationId },
-    })
-  }
-
-  /**
-   * Wait for an operation with a simple promise interface
-   */
-  async waitForOperation<T = any>(operationId: string, timeoutMs?: number): Promise<T> {
-    const result = await this.monitorOperation<T>(operationId, {
-      timeout: timeoutMs,
-    })
-
-    if (!result.success) {
-      throw new Error(result.error || 'Operation failed')
-    }
-
-    return result.result as T
-  }
-
-  /**
-   * Monitor operation with async iterator for progress updates
-   */
-  async *monitorWithProgress<T = any>(
-    operationId: string
-  ): AsyncIterableIterator<OperationProgress | OperationResult<T>> {
-    const progressQueue: (OperationProgress | OperationResult<T>)[] = []
-    let completed = false
-    let finalResult: OperationResult<T> | null = null
-
-    // Start monitoring in background
-    const monitorPromise = this.monitorOperation<T>(operationId, {
-      onProgress: (progress) => {
-        progressQueue.push(progress)
-      },
-      onQueueUpdate: (position, estimatedWait) => {
-        progressQueue.push({
-          message: `Queue position: ${position}`,
-          progressPercent: 0,
-          details: { position, estimatedWait },
-        })
-      },
-    })
-
-    // Handle completion
-    monitorPromise
-      .then((result) => {
-        finalResult = result
-        completed = true
-      })
-      .catch((error) => {
-        finalResult = {
-          success: false,
-          error: error.message,
-        }
-        completed = true
-      })
-
-    // Yield progress updates as they come
-    while (!completed || progressQueue.length > 0) {
-      if (progressQueue.length > 0) {
-        yield progressQueue.shift()!
-      } else if (!completed) {
-        // Wait for more progress
-        await new Promise((resolve) => setTimeout(resolve, 100))
-      }
-    }
-
-    // Yield final result
-    if (finalResult) {
-      yield finalResult
-    }
-  }
-
-  private cleanupClient(operationId: string): void {
-    const client = this.sseClients.get(operationId)
-    if (client) {
-      client.close()
-      this.sseClients.delete(operationId)
-    }
-
-    // Clear any cleanup timeout for this operation
-    const timeout = this.cleanupTimeouts.get(operationId)
-    if (timeout) {
-      clearTimeout(timeout)
-      this.cleanupTimeouts.delete(operationId)
-    }
-  }
-
-  /**
-   * Schedule automatic cleanup of SSE client after a delay
-   */
-  private scheduleCleanup(operationId: string, delayMs: number = 60000): void {
-    // Clear any existing timeout
-    const existingTimeout = this.cleanupTimeouts.get(operationId)
-    if (existingTimeout) {
-      clearTimeout(existingTimeout)
-    }
-
-    // Schedule new cleanup
-    const timeout = setTimeout(() => {
-      this.cleanupClient(operationId)
-      this.cleanupTimeouts.delete(operationId)
-    }, delayMs)
-
-    this.cleanupTimeouts.set(operationId, timeout)
-  }
-
-  /**
-   * Perform periodic cleanup of stale SSE connections
-   */
-  private performPeriodicCleanup(): void {
-    // Check each SSE client for staleness
-    this.sseClients.forEach((client, operationId) => {
-      if (!client.isConnected()) {
-        // Clean up disconnected clients immediately
-        this.cleanupClient(operationId)
-      }
-    })
-  }
-
-  /**
-   * Close all active SSE connections and clean up resources
-   */
-  closeAll(): void {
-    // Clear periodic cleanup interval
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval)
-      this.cleanupInterval = undefined
-    }
-
-    // Clear all cleanup timeouts
-    this.cleanupTimeouts.forEach((timeout) => {
-      clearTimeout(timeout)
-    })
-    this.cleanupTimeouts.clear()
-
-    // Close all SSE clients
-    this.sseClients.forEach((client, operationId) => {
-      this.cleanupClient(operationId)
-    })
-  }
-}

package/sdk-extensions/QueryClient.d.ts

@@ -1,52 +0,0 @@
-export interface QueryRequest {
-    query: string;
-    parameters?: Record<string, any>;
-    timeout?: number;
-}
-export interface QueryOptions {
-    mode?: 'auto' | 'sync' | 'async' | 'stream';
-    chunkSize?: number;
-    testMode?: boolean;
-    maxWait?: number;
-    onQueueUpdate?: (position: number, estimatedWait: number) => void;
-    onProgress?: (message: string) => void;
-}
-export interface QueryResult {
-    data: any[];
-    columns: string[];
-    row_count: number;
-    execution_time_ms: number;
-    graph_id?: string;
-    timestamp?: string;
-}
-export interface QueuedQueryResponse {
-    status: 'queued';
-    operation_id: string;
-    queue_position: number;
-    estimated_wait_seconds: number;
-    message: string;
-}
-export declare class QueryClient {
-    private sseClient?;
-    private config;
-    constructor(config: {
-        baseUrl: string;
-        credentials?: 'include' | 'same-origin' | 'omit';
-        headers?: Record<string, string>;
-        token?: string;
-    });
-    executeQuery(graphId: string, request: QueryRequest, options?: QueryOptions): Promise<QueryResult | AsyncIterableIterator<any>>;
-    private parseNDJSONResponse;
-    private streamQueryResults;
-    private waitForQueryCompletion;
-    query(graphId: string, cypher: string, parameters?: Record<string, any>): Promise<QueryResult>;
-    streamQuery(graphId: string, cypher: string, parameters?: Record<string, any>, chunkSize?: number): AsyncIterableIterator<any>;
-    close(): void;
-}
-/**
- * Error thrown when query is queued and maxWait is 0
- */
-export declare class QueuedQueryError extends Error {
-    queueInfo: QueuedQueryResponse;
-    constructor(queueInfo: QueuedQueryResponse);
-}

package/sdk-extensions/QueryClient.js

@@ -1,313 +0,0 @@
-'use client';
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QueuedQueryError = exports.QueryClient = void 0;
-/**
- * Enhanced Query Client with SSE support
- * Provides intelligent query execution with automatic strategy selection
- */
-const sdk_gen_1 = require("../sdk/sdk.gen");
-const SSEClient_1 = require("./SSEClient");
-class QueryClient {
-    constructor(config) {
-        this.config = config;
-    }
-    async executeQuery(graphId, request, options = {}) {
-        const data = {
-            url: '/v1/graphs/{graph_id}/query',
-            path: { graph_id: graphId },
-            body: {
-                query: request.query,
-                parameters: request.parameters,
-            },
-            query: {
-                mode: options.mode,
-                test_mode: options.testMode,
-            },
-            // For streaming mode, don't parse response - get raw Response object
-            ...(options.mode === 'stream' ? { parseAs: 'stream' } : {}),
-        };
-        const response = await (0, sdk_gen_1.executeCypherQuery)(data);
-        // Check for errors in the response (network errors, etc.)
-        if ('error' in response && response.error) {
-            const error = response.error;
-            throw error instanceof Error ? error : new Error(String(error));
-        }
-        // Check if this is a raw stream response (when parseAs: 'stream')
-        if (options.mode === 'stream' && response.response) {
-            const contentType = response.response.headers.get('content-type') || '';
-            if (contentType.includes('application/x-ndjson')) {
-                return this.parseNDJSONResponse(response.response, graphId);
-            }
-            else if (contentType.includes('application/json')) {
-                // Fallback: parse JSON manually
-                const data = await response.response.json();
-                if (data.data !== undefined && data.columns) {
-                    return {
-                        data: data.data,
-                        columns: data.columns,
-                        row_count: data.row_count || data.data.length,
-                        execution_time_ms: data.execution_time_ms || 0,
-                        graph_id: graphId,
-                        timestamp: data.timestamp || new Date().toISOString(),
-                    };
-                }
-            }
-        }
-        const responseData = response.data;
-        // Check if this is an immediate response
-        if (responseData?.data !== undefined && responseData?.columns) {
-            return {
-                data: responseData.data,
-                columns: responseData.columns,
-                row_count: responseData.row_count || responseData.data.length,
-                execution_time_ms: responseData.execution_time_ms || 0,
-                graph_id: graphId,
-                timestamp: responseData.timestamp || new Date().toISOString(),
-            };
-        }
-        // Check if this is a queued response
-        if (responseData?.status === 'queued' && responseData?.operation_id) {
-            const queuedResponse = responseData;
-            // Notify about queue status
-            options.onQueueUpdate?.(queuedResponse.queue_position, queuedResponse.estimated_wait_seconds);
-            // If user doesn't want to wait, throw with queue info
-            if (options.maxWait === 0) {
-                throw new QueuedQueryError(queuedResponse);
-            }
-            // Use SSE to monitor the operation
-            return this.waitForQueryCompletion(queuedResponse.operation_id, options);
-        }
-        // Unexpected response format
-        throw new Error('Unexpected response format from query endpoint');
-    }
-    async parseNDJSONResponse(response, graphId) {
-        const allData = [];
-        let columns = null;
-        let totalRows = 0;
-        let executionTimeMs = 0;
-        const parseErrors = [];
-        let lineNumber = 0;
-        // Use streaming reader to avoid "body already read" error
-        const reader = response.body?.getReader();
-        if (!reader) {
-            throw new Error('Response body is not readable');
-        }
-        const decoder = new TextDecoder();
-        let buffer = '';
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    break;
-                buffer += decoder.decode(value, { stream: true });
-                const lines = buffer.split('\n');
-                buffer = lines.pop() || '';
-                for (const line of lines) {
-                    lineNumber++;
-                    if (!line.trim())
-                        continue;
-                    try {
-                        const chunk = JSON.parse(line);
-                        // Extract columns from first chunk
-                        if (columns === null && chunk.columns) {
-                            columns = chunk.columns;
-                        }
-                        // Aggregate data rows (NDJSON uses "rows", regular JSON uses "data")
-                        if (chunk.rows) {
-                            allData.push(...chunk.rows);
-                            totalRows += chunk.rows.length;
-                        }
-                        else if (chunk.data) {
-                            allData.push(...chunk.data);
-                            totalRows += chunk.data.length;
-                        }
-                        // Track execution time (use max from all chunks)
-                        if (chunk.execution_time_ms) {
-                            executionTimeMs = Math.max(executionTimeMs, chunk.execution_time_ms);
-                        }
-                    }
-                    catch (error) {
-                        parseErrors.push({
-                            line: lineNumber,
-                            error: error instanceof Error ? error.message : String(error),
-                        });
-                    }
-                }
-            }
-            // Parse any remaining buffer
-            if (buffer.trim()) {
-                lineNumber++;
-                try {
-                    const chunk = JSON.parse(buffer);
-                    if (columns === null && chunk.columns) {
-                        columns = chunk.columns;
-                    }
-                    if (chunk.rows) {
-                        allData.push(...chunk.rows);
-                        totalRows += chunk.rows.length;
-                    }
-                    else if (chunk.data) {
-                        allData.push(...chunk.data);
-                        totalRows += chunk.data.length;
-                    }
-                    if (chunk.execution_time_ms) {
-                        executionTimeMs = Math.max(executionTimeMs, chunk.execution_time_ms);
-                    }
-                }
-                catch (error) {
-                    parseErrors.push({
-                        line: lineNumber,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-        }
-        catch (error) {
-            throw new Error(`NDJSON stream reading error: ${error}`);
-        }
-        // Report parse errors if any occurred
-        if (parseErrors.length > 0) {
-            const errorDetails = parseErrors.slice(0, 3).map((e) => `line ${e.line}: ${e.error}`);
-            const moreErrors = parseErrors.length > 3 ? ` (and ${parseErrors.length - 3} more)` : '';
-            throw new Error(`NDJSON parsing failed for ${parseErrors.length} line(s): ${errorDetails.join('; ')}${moreErrors}`);
-        }
-        // Return aggregated result
-        return {
-            data: allData,
-            columns: columns || [],
-            row_count: totalRows,
-            execution_time_ms: executionTimeMs,
-            graph_id: graphId,
-            timestamp: new Date().toISOString(),
-        };
-    }
-    async *streamQueryResults(operationId, options) {
-        const buffer = [];
-        let completed = false;
-        let error = null;
-        // Set up SSE connection
-        this.sseClient = new SSEClient_1.SSEClient(this.config);
-        await this.sseClient.connect(operationId);
-        // Listen for data chunks
-        this.sseClient.on(SSEClient_1.EventType.DATA_CHUNK, (data) => {
-            if (Array.isArray(data.rows)) {
-                buffer.push(...data.rows);
-            }
-            else if (data.data) {
-                buffer.push(...data.data);
-            }
-        });
-        // Listen for queue updates
-        this.sseClient.on(SSEClient_1.EventType.QUEUE_UPDATE, (data) => {
-            options.onQueueUpdate?.(data.position, data.estimated_wait_seconds);
-        });
-        // Listen for progress
-        this.sseClient.on(SSEClient_1.EventType.OPERATION_PROGRESS, (data) => {
-            options.onProgress?.(data.message);
-        });
-        // Listen for completion
-        this.sseClient.on(SSEClient_1.EventType.OPERATION_COMPLETED, (data) => {
-            if (data.result?.data) {
-                buffer.push(...data.result.data);
-            }
-            completed = true;
-        });
-        // Listen for errors
-        this.sseClient.on(SSEClient_1.EventType.OPERATION_ERROR, (err) => {
-            error = new Error(err.message || err.error);
-            completed = true;
-        });
-        // Yield buffered results
-        while (!completed || buffer.length > 0) {
-            if (error)
-                throw error;
-            if (buffer.length > 0) {
-                const chunk = buffer.splice(0, options.chunkSize || 100);
-                for (const item of chunk) {
-                    yield item;
-                }
-            }
-            else if (!completed) {
-                // Wait for more data
-                await new Promise((resolve) => setTimeout(resolve, 100));
-            }
-        }
-        this.sseClient.close();
-        this.sseClient = undefined;
-    }
-    async waitForQueryCompletion(operationId, options) {
-        return new Promise((resolve, reject) => {
-            const sseClient = new SSEClient_1.SSEClient(this.config);
-            sseClient
-                .connect(operationId)
-                .then(() => {
-                let result = null;
-                // Listen for queue updates
-                sseClient.on(SSEClient_1.EventType.QUEUE_UPDATE, (data) => {
-                    options.onQueueUpdate?.(data.position, data.estimated_wait_seconds);
-                });
-                // Listen for progress
-                sseClient.on(SSEClient_1.EventType.OPERATION_PROGRESS, (data) => {
-                    options.onProgress?.(data.message);
-                });
-                sseClient.on(SSEClient_1.EventType.OPERATION_COMPLETED, (data) => {
-                    const queryResult = data.result || data;
-                    result = {
-                        data: queryResult.data || [],
-                        columns: queryResult.columns || [],
-                        row_count: queryResult.row_count || 0,
-                        execution_time_ms: queryResult.execution_time_ms || 0,
-                        graph_id: queryResult.graph_id,
-                        timestamp: queryResult.timestamp || new Date().toISOString(),
-                    };
-                    sseClient.close();
-                    resolve(result);
-                });
-                sseClient.on(SSEClient_1.EventType.OPERATION_ERROR, (error) => {
-                    sseClient.close();
-                    reject(new Error(error.message || error.error));
-                });
-                sseClient.on(SSEClient_1.EventType.OPERATION_CANCELLED, () => {
-                    sseClient.close();
-                    reject(new Error('Query cancelled'));
-                });
-            })
-                .catch(reject);
-        });
-    }
-    // Convenience method for simple queries
-    async query(graphId, cypher, parameters) {
-        return this.executeQuery(graphId, { query: cypher, parameters }, { mode: 'auto' });
-    }
-    // Streaming query for large results
-    async *streamQuery(graphId, cypher, parameters, chunkSize = 1000) {
-        const result = await this.executeQuery(graphId, { query: cypher, parameters }, { mode: 'stream', chunkSize });
-        if (Symbol.asyncIterator in result) {
-            yield* result;
-        }
-        else {
-            // If not streaming, yield all results at once
-            yield* result.data;
-        }
-    }
-    // Cancel any active SSE connections
-    close() {
-        if (this.sseClient) {
-            this.sseClient.close();
-            this.sseClient = undefined;
-        }
-    }
-}
-exports.QueryClient = QueryClient;
-/**
- * Error thrown when query is queued and maxWait is 0
- */
-class QueuedQueryError extends Error {
-    constructor(queueInfo) {
-        super('Query was queued');
-        this.queueInfo = queueInfo;
-        this.name = 'QueuedQueryError';
-    }
-}
-exports.QueuedQueryError = QueuedQueryError;