@robosystems/client 0.1.11 → 0.1.13

package/extensions/QueryClient.js

@@ -1,245 +1,190 @@
-'use client'
-
+'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
  */
-
-import { executeCypherQuery } from '../sdk.gen'
-import { ExecuteCypherQueryData } from '../types.gen'
-import { EventType, SSEClient } from './SSEClient'
-
-
-
-
-
-
-
-
-
-export class QueryClient {
-  private sseClient?
-  private config
-
-  constructor(config) {
-    this.config = config
-  }
-
-  async executeQuery(
-    graphId,
-    request,
-    options = {}
-  )> {
-    const data = {
-      url: '/v1/{graph_id}/query',
-      path,
-      body,
-      query,
+const sdk_gen_1 = require("../sdk/sdk.gen");
+const SSEClient_1 = require("./SSEClient");
+class QueryClient {
+    constructor(config) {
+        this.config = config;
     }
-
-    // Execute the query
-    const response = await executeCypherQuery(data)
-    const responseData = response.data
-
-    // Check if this is an immediate response
-    if (responseData?.data !== undefined && responseData?.columns) {
-      return {
-        data.data,
-        columns.columns,
-        row_count.row_count || responseData.data.length,
-        execution_time_ms.execution_time_ms || 0,
-        graph_id,
-        timestamp.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
-      if (options.mode === 'stream') {
-        return this.streamQueryResults(queuedResponse.operation_id, options)
-      } else {
-        return this.waitForQueryCompletion(queuedResponse.operation_id, options)
-      }
-    }
-
-    // Unexpected response format
-    throw new Error('Unexpected response format from query endpoint')
-  }
-
-  private async *streamQueryResults(
-    operationId,
-    options
-  ) {
-    const buffer = []
-    let completed = false
-    let error | null = null
-
-    // Set up SSE connection
-    this.sseClient = new SSEClient(this.config)
-    await this.sseClient.connect(operationId)
-
-    // Listen for data chunks
-    this.sseClient.on(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(EventType.QUEUE_UPDATE, (data) => {
-      options.onQueueUpdate?.(data.position, data.estimated_wait_seconds)
-    })
-
-    // Listen for progress
-    this.sseClient.on(EventType.OPERATION_PROGRESS, (data) => {
-      options.onProgress?.(data.message)
-    })
-
-    // Listen for completion
-    this.sseClient.on(EventType.OPERATION_COMPLETED, (data) => {
-      if (data.result?.data) {
-        buffer.push(...data.result.data)
-      }
-      completed = true
-    })
-
-    // Listen for errors
-    this.sseClient.on(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
+    async executeQuery(graphId, request, options = {}) {
+        const data = {
+            url: '/v1/{graph_id}/query',
+            path: { graph_id: graphId },
+            body: {
+                query: request.query,
+                parameters: request.parameters,
+            },
+            query: {
+                mode: options.mode,
+                test_mode: options.testMode,
+            },
+        };
+        // Execute the query
+        const response = await (0, sdk_gen_1.executeCypherQuery)(data);
+        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(),
+            };
         }
-      } else if (!completed) {
-        // Wait for more data
-        await new Promise((resolve) => setTimeout(resolve, 100))
-      }
+        // 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
+            if (options.mode === 'stream') {
+                return this.streamQueryResults(queuedResponse.operation_id, options);
+            }
+            else {
+                return this.waitForQueryCompletion(queuedResponse.operation_id, options);
+            }
+        }
+        // Unexpected response format
+        throw new Error('Unexpected response format from query endpoint');
     }
-
-    this.sseClient.close()
-    this.sseClient = undefined
-  }
-
-  private async waitForQueryCompletion(
-    operationId,
-    options
-  ) {
-    return new Promise((resolve, reject) => {
-      const sseClient = new SSEClient(this.config)
-
-      sseClient
-        .connect(operationId)
-        .then(() => {
-          let result | null = null
-
-          // Listen for queue updates
-          sseClient.on(EventType.QUEUE_UPDATE, (data) => {
-            options.onQueueUpdate?.(data.position, data.estimated_wait_seconds)
-          })
-
-          // Listen for progress
-          sseClient.on(EventType.OPERATION_PROGRESS, (data) => {
-            options.onProgress?.(data.message)
-          })
-
-          sseClient.on(EventType.OPERATION_COMPLETED, (data) => {
-            const queryResult = data.result || data
-            result = {
-              data.data || [],
-              columns.columns || [],
-              row_count.row_count || 0,
-              execution_time_ms.execution_time_ms || 0,
-              graph_id.graph_id,
-              timestamp.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;
+                }
             }
-            sseClient.close()
-            resolve(result)
-          })
-
-          sseClient.on(EventType.OPERATION_ERROR, (error) => {
-            sseClient.close()
-            reject(new Error(error.message || error.error))
-          })
-
-          sseClient.on(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, parameters },
-      { mode }
-    )
-  }
-
-  // Streaming query for large results
-  async *streamQuery(
-    graphId,
-    cypher,
-    parameters?,
-    chunkSize = 1000
-  ) {
-    const result = await this.executeQuery(
-      graphId,
-      { query, parameters },
-      { mode, chunkSize }
-    )
-
-    if (Symbol.asyncIterator in (result)) {
-      yield* result
-    } else {
-      // If not streaming, yield all results at once
-      yield* (result).data
+            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);
+        });
     }
-  }
-
-  // Cancel any active SSE connections
-  close() {
-    if (this.sseClient) {
-      this.sseClient.close()
-      this.sseClient = undefined
+    // 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
  */
-export class QueuedQueryError extends Error {
-  constructor(public queueInfo) {
-    super('Query was queued')
-    this.name = 'QueuedQueryError'
-  }
+class QueuedQueryError extends Error {
+    constructor(queueInfo) {
+        super('Query was queued');
+        this.queueInfo = queueInfo;
+        this.name = 'QueuedQueryError';
+    }
 }
+exports.QueuedQueryError = QueuedQueryError;

package/extensions/SSEClient.d.ts

@@ -0,0 +1,48 @@
+/**
+ * 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 declare 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 declare class SSEClient {
+    private config;
+    private eventSource?;
+    private reconnectAttempts;
+    private lastEventId?;
+    private closed;
+    private listeners;
+    constructor(config: SSEConfig);
+    connect(operationId: string, fromSequence?: number): Promise<void>;
+    private handleMessage;
+    private handleTypedEvent;
+    private handleError;
+    on(event: string, listener: (data: any) => void): void;
+    off(event: string, listener: (data: any) => void): void;
+    private emit;
+    close(): void;
+    isConnected(): boolean;
+}