@robosystems/client 0.1.11 → 0.1.13

package/extensions/OperationClient.js

@@ -1,297 +1,251 @@
-'use client'
-
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationClient = void 0;
 /**
  * General Operations Client for monitoring async operations
  * Handles graph creation, backups, imports, and other long-running tasks
  */
-
-import { cancelOperation, getOperationStatus } from '../sdk.gen'
-import { EventType, SSEClient } from './SSEClient'
-
-
-
-
-
-
-
-export class OperationClient {
-  private sseClients = new Map()
-  private cleanupTimeouts> = new Map()
-  private config
-  private cleanupIntervalMs = 300000 // 5 minutes
-  private cleanupInterval?
-
-  constructor(config) {
-    this.config = config
-
-    // Start periodic cleanup check every 5 minutes
-    this.cleanupInterval = setInterval(() => {
-      this.performPeriodicCleanup()
-    }, this.cleanupIntervalMs)
-  }
-
-  async monitorOperation(
-    operationId,
-    options = {}
-  )> {
-    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)
-        
-
-      sseClient
-        .connect(operationId)
-        .then(() => {
-          let result = { success }
-
-          // 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.message || data.status || 'Processing...',
-                progressPercent.progress_percent || data.progress,
-                details,
-              })
+const sdk_gen_1 = require("../sdk/sdk.gen");
+const SSEClient_1 = require("./SSEClient");
+class OperationClient {
+    constructor(config) {
+        this.sseClients = new Map();
+        this.cleanupTimeouts = new Map();
+        this.cleanupIntervalMs = 300000; // 5 minutes
+        this.config = config;
+        // Start periodic cleanup check every 5 minutes
+        this.cleanupInterval = setInterval(() => {
+            this.performPeriodicCleanup();
+        }, this.cleanupIntervalMs);
+    }
+    async monitorOperation(operationId, options = {}) {
+        return new Promise((resolve, reject) => {
+            const sseClient = new SSEClient_1.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 = { success: false };
+                // Track queue updates
+                if (options.onQueueUpdate) {
+                    sseClient.on(SSEClient_1.EventType.QUEUE_UPDATE, (data) => {
+                        options.onQueueUpdate(data.position || data.queue_position, data.estimated_wait_seconds || 0);
+                    });
+                }
+                // Track progress
+                if (options.onProgress) {
+                    sseClient.on(SSEClient_1.EventType.OPERATION_PROGRESS, (data) => {
+                        options.onProgress({
+                            message: data.message || data.status || 'Processing...',
+                            progressPercent: data.progress_percent || data.progress,
+                            details: data,
+                        });
+                    });
+                }
+                // Handle completion
+                sseClient.on(SSEClient_1.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(SSEClient_1.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(SSEClient_1.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);
+                });
             })
-          }
-
-          // Handle completion
-          sseClient.on(EventType.OPERATION_COMPLETED, (data) => {
-            if (timeoutHandle) clearTimeout(timeoutHandle)
-            result = {
-              success,
-              result.result || data,
-              metadata.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,
-              error.message || error.error || 'Operation failed',
-              metadata.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,
-              error: 'Operation cancelled',
-              metadata,
-            }
-            // 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(
-    operationIds,
-    options = {}
-  )>> {
-    const results = await Promise.all(
-      operationIds.map(async (id) => {
-        const result = await this.monitorOperation(id, options)
-        return [id, result] as [string, OperationResult]
-      })
-    )
-    return new Map(results)
-  }
-
-  /**
-   * Get the current status of an operation (point-in-time check)
-   */
-  async getStatus(operationId) {
-    const response = await getOperationStatus({
-      path,
-    })
-    return response.data
-  }
-
-  /**
-   * Cancel a pending or running operation
-   */
-  async cancelOperation(operationId) {
-    // First close any active SSE connection
-    this.cleanupClient(operationId)
-
-    // Then cancel the operation
-    await cancelOperationSDK({
-      path,
-    })
-  }
-
-  /**
-   * Wait for an operation with a simple promise interface
-   */
-  async waitForOperation(operationId, timeoutMs?) {
-    const result = await this.monitorOperation(operationId, {
-      timeout,
-    })
-
-    if (!result.success) {
-      throw new Error(result.error || 'Operation failed')
+                .catch((error) => {
+                if (timeoutHandle)
+                    clearTimeout(timeoutHandle);
+                this.cleanupClient(operationId);
+                reject(error);
+            });
+        });
     }
-
-    return result.result
-  }
-
-  /**
-   * Monitor operation with async iterator for progress updates
-   */
-  async *monitorWithProgress(
-    operationId
-  )> {
-    const progressQueue: (OperationProgress | OperationResult)[] = []
-    let completed = false
-    let finalResult | null = null
-
-    // Start monitoring in background
-    const monitorPromise = this.monitorOperation(operationId, {
-      onProgress: (progress) => {
-        progressQueue.push(progress)
-      },
-      onQueueUpdate: (position, estimatedWait) => {
-        progressQueue.push({
-          message: `Queue position: ${position}`,
-          progressPercent,
-          details,
-        })
-      },
-    })
-
-    // Handle completion
-    monitorPromise
-      .then((result) => {
-        finalResult = result
-        completed = true
-      })
-      .catch((error) => {
-        finalResult = {
-          success,
-          error.message,
+    /**
+     * Monitor multiple operations concurrently
+     */
+    async monitorMultiple(operationIds, options = {}) {
+        const results = await Promise.all(operationIds.map(async (id) => {
+            const result = await this.monitorOperation(id, options);
+            return [id, result];
+        }));
+        return new Map(results);
+    }
+    /**
+     * Get the current status of an operation (point-in-time check)
+     */
+    async getStatus(operationId) {
+        const response = await (0, sdk_gen_1.getOperationStatus)({
+            path: { operation_id: operationId },
+        });
+        return response.data;
+    }
+    /**
+     * Cancel a pending or running operation
+     */
+    async cancelOperation(operationId) {
+        // First close any active SSE connection
+        this.cleanupClient(operationId);
+        // Then cancel the operation
+        await (0, sdk_gen_1.cancelOperation)({
+            path: { operation_id: operationId },
+        });
+    }
+    /**
+     * Wait for an operation with a simple promise interface
+     */
+    async waitForOperation(operationId, timeoutMs) {
+        const result = await this.monitorOperation(operationId, {
+            timeout: timeoutMs,
+        });
+        if (!result.success) {
+            throw new Error(result.error || 'Operation failed');
         }
-        completed = true
-      })
-
-    // Yield progress updates 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))
-      }
+        return result.result;
     }
-
-    // Yield final result
-    if (finalResult) {
-      yield finalResult
+    /**
+     * Monitor operation with async iterator for progress updates
+     */
+    async *monitorWithProgress(operationId) {
+        const progressQueue = [];
+        let completed = false;
+        let finalResult = null;
+        // Start monitoring in background
+        const monitorPromise = this.monitorOperation(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) {
-    const client = this.sseClients.get(operationId)
-    if (client) {
-      client.close()
-      this.sseClients.delete(operationId)
+    cleanupClient(operationId) {
+        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);
+        }
     }
-
-    // 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
+     */
+    scheduleCleanup(operationId, delayMs = 60000) {
+        // 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);
     }
-  }
-
-  /**
-   * Schedule automatic cleanup of SSE client after a delay
-   */
-  private scheduleCleanup(operationId, delayMs = 60000) {
-    // Clear any existing timeout
-    const existingTimeout = this.cleanupTimeouts.get(operationId)
-    if (existingTimeout) {
-      clearTimeout(existingTimeout)
+    /**
+     * Perform periodic cleanup of stale SSE connections
+     */
+    performPeriodicCleanup() {
+        // Check each SSE client for staleness
+        this.sseClients.forEach((client, operationId) => {
+            if (!client.isConnected()) {
+                // Clean up disconnected clients immediately
+                this.cleanupClient(operationId);
+            }
+        });
     }
-
-    // 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() {
-    // 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() {
-    // Clear periodic cleanup interval
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval)
-      this.cleanupInterval = undefined
+    /**
+     * Close all active SSE connections and clean up resources
+     */
+    closeAll() {
+        // 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);
+        });
     }
-
-    // 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)
-    })
-  }
 }
+exports.OperationClient = OperationClient;

package/extensions/QueryClient.d.ts

@@ -0,0 +1,50 @@
+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>;
+    });
+    executeQuery(graphId: string, request: QueryRequest, options?: QueryOptions): Promise<QueryResult | AsyncIterableIterator<any>>;
+    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);
+}