@robosystems/client 0.2.43 → 0.2.44

package/extensions/GraphClient.js

@@ -1,244 +0,0 @@
-'use client';
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GraphClient = exports.GraphOperationError = void 0;
-/**
- * Graph Management Client
- * Provides high-level graph management operations with automatic operation monitoring.
- * Supports SSE (Server-Sent Events) for real-time updates with polling fallback.
- */
-const sdk_gen_1 = require("../sdk.gen");
-const OperationClient_1 = require("./OperationClient");
-/**
- * Error thrown when a graph operation fails (as reported by the server)
- * This is distinct from connection/SSE errors
- */
-class GraphOperationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'GraphOperationError';
-    }
-}
-exports.GraphOperationError = GraphOperationError;
-class GraphClient {
-    constructor(config) {
-        this.config = config;
-        this.operationClient = new OperationClient_1.OperationClient(config);
-    }
-    /**
-     * Create a graph and wait for completion
-     *
-     * Uses SSE (Server-Sent Events) for real-time progress updates with
-     * automatic fallback to polling if SSE connection fails.
-     *
-     * @param metadata - Graph metadata (name, description, etc.)
-     * @param initialEntity - Optional initial entity to create
-     * @param options - Additional options including:
-     *   - createEntity: Whether to create the entity node and upload initial data.
-     *                   Only applies when initialEntity is provided. Set to false to
-     *                   create graph without populating entity data (useful for file-based ingestion).
-     *                   Defaults to true.
-     *   - timeout: Maximum time to wait in milliseconds (default: 60000)
-     *   - pollInterval: Time between status checks in milliseconds (default: 2000, for polling fallback)
-     *   - onProgress: Callback for progress updates
-     *   - useSSE: Whether to try SSE first (default: true). Falls back to polling on failure.
-     * @returns The graph ID when creation completes
-     */
-    async createGraphAndWait(metadata, initialEntity, options = {}) {
-        const { createEntity = true, timeout = 60000, pollInterval = 2000, onProgress, useSSE = true, } = options;
-        if (!this.config.token) {
-            throw new Error('No API key provided. Set token in config.');
-        }
-        // Build initial entity if provided
-        let initialEntityData;
-        if (initialEntity) {
-            initialEntityData = {
-                name: initialEntity.name,
-                uri: initialEntity.uri,
-                category: initialEntity.category,
-                sic: initialEntity.sic,
-                sic_description: initialEntity.sicDescription,
-            };
-        }
-        // Build API metadata
-        const apiMetadata = {
-            graph_name: metadata.graphName,
-            description: metadata.description,
-            schema_extensions: metadata.schemaExtensions || [],
-            tags: metadata.tags || [],
-        };
-        if (onProgress) {
-            onProgress(`Creating graph: ${metadata.graphName}`);
-        }
-        // Create graph request - SDK expects options format, not data format
-        const response = await (0, sdk_gen_1.createGraph)({
-            body: {
-                metadata: apiMetadata,
-                initial_entity: initialEntityData || null,
-                create_entity: createEntity,
-            },
-        });
-        // Check if we got immediate graph_id
-        const responseData = response.data;
-        if (responseData?.graph_id) {
-            if (onProgress) {
-                onProgress(`Graph created: ${responseData.graph_id}`);
-            }
-            return responseData.graph_id;
-        }
-        // Otherwise, we have an operation_id to monitor
-        if (!responseData?.operation_id) {
-            throw new Error('No graph_id or operation_id in response');
-        }
-        const operationId = responseData.operation_id;
-        if (onProgress) {
-            onProgress(`Graph creation queued (operation: ${operationId})`);
-        }
-        // Try SSE first, fall back to polling
-        if (useSSE) {
-            try {
-                return await this.waitWithSSE(operationId, timeout, onProgress);
-            }
-            catch (error) {
-                // Only fall back to polling for SSE connection failures
-                // If it's a GraphOperationError, the operation actually failed - don't retry with polling
-                if (error instanceof GraphOperationError) {
-                    throw error;
-                }
-                // SSE connection failed, fall back to polling
-                if (onProgress) {
-                    onProgress('SSE unavailable, using polling...');
-                }
-            }
-        }
-        // Fallback to polling
-        return await this.waitWithPolling(operationId, timeout, pollInterval, onProgress);
-    }
-    /**
-     * Wait for operation completion using SSE stream
-     */
-    async waitWithSSE(operationId, timeout, onProgress) {
-        const result = await this.operationClient.monitorOperation(operationId, {
-            timeout,
-            onProgress: (progress) => {
-                if (onProgress) {
-                    if (progress.progressPercent !== undefined) {
-                        onProgress(`${progress.message} (${Math.round(progress.progressPercent)}%)`);
-                    }
-                    else {
-                        onProgress(progress.message);
-                    }
-                }
-            },
-        });
-        if (!result.success) {
-            throw new GraphOperationError(result.error || 'Graph creation failed');
-        }
-        const graphId = result.result?.graph_id;
-        if (!graphId) {
-            throw new GraphOperationError('Operation completed but no graph_id in result');
-        }
-        if (onProgress) {
-            onProgress(`Graph created: ${graphId}`);
-        }
-        return graphId;
-    }
-    /**
-     * Wait for operation completion using polling
-     */
-    async waitWithPolling(operationId, timeout, pollInterval, onProgress) {
-        const maxAttempts = Math.floor(timeout / pollInterval);
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            await new Promise((resolve) => setTimeout(resolve, pollInterval));
-            const statusResponse = await (0, sdk_gen_1.getOperationStatus)({
-                path: { operation_id: operationId },
-            });
-            const statusData = statusResponse.data;
-            const status = statusData?.status;
-            if (onProgress) {
-                onProgress(`Status: ${status} (attempt ${attempt + 1}/${maxAttempts})`);
-            }
-            if (status === 'completed') {
-                const result = statusData?.result;
-                const graphId = result?.graph_id;
-                if (graphId) {
-                    if (onProgress) {
-                        onProgress(`Graph created: ${graphId}`);
-                    }
-                    return graphId;
-                }
-                else {
-                    throw new GraphOperationError('Operation completed but no graph_id in result');
-                }
-            }
-            else if (status === 'failed') {
-                const error = statusData?.error || statusData?.message || 'Unknown error';
-                throw new GraphOperationError(`Graph creation failed: ${error}`);
-            }
-        }
-        throw new GraphOperationError(`Graph creation timed out after ${timeout}ms`);
-    }
-    /**
-     * Get information about a graph
-     */
-    async getGraphInfo(graphId) {
-        if (!this.config.token) {
-            throw new Error('No API key provided. Set token in config.');
-        }
-        // Use getGraphs to list all graphs and find the one we want
-        // Note: This is a workaround since there's no dedicated getGraph endpoint yet
-        const response = await (0, sdk_gen_1.getGraphs)();
-        const graphs = response.data?.graphs || [];
-        const graph = graphs.find((g) => g.graph_id === graphId || g.id === graphId);
-        if (!graph) {
-            throw new Error(`Graph not found: ${graphId}`);
-        }
-        return {
-            graphId: graph.graph_id || graph.id,
-            graphName: graph.graph_name || graph.name,
-            description: graph.description,
-            schemaExtensions: graph.schema_extensions,
-            tags: graph.tags,
-            createdAt: graph.created_at,
-            status: graph.status,
-        };
-    }
-    /**
-     * List all graphs
-     */
-    async listGraphs() {
-        if (!this.config.token) {
-            throw new Error('No API key provided. Set token in config.');
-        }
-        const response = await (0, sdk_gen_1.getGraphs)();
-        const graphs = response.data?.graphs || [];
-        return graphs.map((graph) => ({
-            graphId: graph.graph_id || graph.id,
-            graphName: graph.graph_name || graph.name,
-            description: graph.description,
-            schemaExtensions: graph.schema_extensions,
-            tags: graph.tags,
-            createdAt: graph.created_at,
-            status: graph.status,
-        }));
-    }
-    /**
-     * Delete a graph
-     * Note: This will be implemented when the deleteGraph endpoint is available in the SDK
-     */
-    async deleteGraph(_graphId) {
-        throw new Error('deleteGraph is not yet implemented - waiting for SDK endpoint to be generated');
-        // TODO: Implement when deleteGraph endpoint is available
-        // const response = await deleteGraph({ path: { graph_id: _graphId } })
-        // if (response.status !== 200 && response.status !== 204) {
-        //   throw new Error(`Failed to delete graph: ${response.status}`)
-        // }
-    }
-    /**
-     * Clean up resources
-     */
-    close() {
-        this.operationClient.closeAll();
-    }
-}
-exports.GraphClient = GraphClient;

package/extensions/GraphClient.test.ts

@@ -1,455 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest'
-import type { GraphMetadataInput, InitialEntityInput } from './GraphClient'
-import { GraphClient } from './GraphClient'
-
-// Helper to create proper mock Response objects
-function createMockResponse(data: any, options: { ok?: boolean; status?: number } = {}) {
-  return {
-    ok: options.ok ?? true,
-    status: options.status ?? 200,
-    statusText: options.status === 200 ? 'OK' : 'Error',
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: async () => data,
-    text: async () => JSON.stringify(data),
-    blob: async () => new Blob([JSON.stringify(data)]),
-    arrayBuffer: async () => new TextEncoder().encode(JSON.stringify(data)).buffer,
-  }
-}
-
-describe('GraphClient', () => {
-  let graphClient: GraphClient
-  let mockFetch: any
-  let mockMonitorOperation: MockInstance
-  let mockCloseAll: MockInstance
-
-  beforeEach(() => {
-    // Mock global fetch first
-    mockFetch = vi.fn()
-    global.fetch = mockFetch
-
-    // Create graphClient
-    graphClient = new GraphClient({
-      baseUrl: 'http://localhost:8000',
-      token: 'test-api-key',
-      headers: { 'X-API-Key': 'test-api-key' },
-    })
-
-    // Access the internal operationClient and spy on its methods
-    const internalOperationClient = (graphClient as any).operationClient
-    mockMonitorOperation = vi.spyOn(internalOperationClient, 'monitorOperation')
-    mockCloseAll = vi.spyOn(internalOperationClient, 'closeAll').mockImplementation(() => {})
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  describe('createGraphAndWait', () => {
-    const mockMetadata: GraphMetadataInput = {
-      graphName: 'Test Graph',
-      description: 'A test graph',
-      schemaExtensions: ['custom_prop'],
-      tags: ['test'],
-    }
-
-    it('should create graph with immediate response', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          graph_id: 'graph_123',
-        })
-      )
-
-      const graphId = await graphClient.createGraphAndWait(mockMetadata)
-
-      expect(graphId).toBe('graph_123')
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should create graph with initial entity', async () => {
-      const mockInitialEntity: InitialEntityInput = {
-        name: 'ACME Corp',
-        uri: 'https://example.com/acme',
-        category: 'Technology',
-        sic: '7372',
-        sicDescription: 'Prepackaged Software',
-      }
-
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          graph_id: 'graph_456',
-        })
-      )
-
-      const graphId = await graphClient.createGraphAndWait(mockMetadata, mockInitialEntity)
-
-      expect(graphId).toBe('graph_456')
-      expect(mockFetch).toHaveBeenCalled()
-    })
-
-    it('should poll operation status when queued', async () => {
-      // First call: createGraph returns operation_id
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          operation_id: 'op_789',
-        })
-      )
-
-      // Second call: getOperationStatus returns pending
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          status: 'pending',
-        })
-      )
-
-      // Third call: getOperationStatus returns completed
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          status: 'completed',
-          result: {
-            graph_id: 'graph_completed',
-          },
-        })
-      )
-
-      const graphId = await graphClient.createGraphAndWait(mockMetadata, undefined, {
-        pollInterval: 100,
-      })
-
-      expect(graphId).toBe('graph_completed')
-      expect(mockFetch).toHaveBeenCalledTimes(3)
-    })
-
-    it('should handle operation failure', async () => {
-      mockFetch
-        .mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_fail',
-          })
-        )
-        .mockResolvedValueOnce(
-          createMockResponse({
-            status: 'failed',
-            error: 'Graph creation failed',
-          })
-        )
-
-      await expect(
-        graphClient.createGraphAndWait(mockMetadata, undefined, { pollInterval: 100 })
-      ).rejects.toThrow('Graph creation failed')
-    })
-
-    it('should timeout if operation takes too long', async () => {
-      mockFetch
-        .mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_timeout',
-          })
-        )
-        .mockResolvedValue(
-          createMockResponse({
-            status: 'pending',
-          })
-        )
-
-      await expect(
-        graphClient.createGraphAndWait(mockMetadata, undefined, {
-          timeout: 500,
-          pollInterval: 100,
-        })
-      ).rejects.toThrow('timed out')
-    })
-
-    it('should call onProgress callback', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          graph_id: 'graph_progress',
-        })
-      )
-
-      const onProgress = vi.fn()
-
-      await graphClient.createGraphAndWait(mockMetadata, undefined, { onProgress })
-
-      expect(onProgress).toHaveBeenCalledWith(expect.stringContaining('Creating graph'))
-      expect(onProgress).toHaveBeenCalledWith(expect.stringContaining('Graph created'))
-    })
-
-    it('should throw error if no token provided', async () => {
-      const clientNoToken = new GraphClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await expect(clientNoToken.createGraphAndWait(mockMetadata)).rejects.toThrow(
-        'No API key provided'
-      )
-    })
-
-    describe('SSE mode', () => {
-      it('should use SSE when operation_id is returned and SSE succeeds', async () => {
-        // createGraph returns operation_id
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_sse_success',
-          })
-        )
-
-        mockMonitorOperation.mockResolvedValueOnce({
-          success: true,
-          result: { graph_id: 'graph_from_sse' },
-        })
-
-        const graphId = await graphClient.createGraphAndWait(mockMetadata)
-
-        expect(graphId).toBe('graph_from_sse')
-        expect(mockMonitorOperation).toHaveBeenCalledWith(
-          'op_sse_success',
-          expect.objectContaining({ timeout: 60000 })
-        )
-        // Should only call fetch once (createGraph), no polling calls
-        expect(mockFetch).toHaveBeenCalledTimes(1)
-      })
-
-      it('should format SSE progress with percentage', async () => {
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_progress',
-          })
-        )
-
-        mockMonitorOperation.mockImplementationOnce(
-          async (_opId: string, options: { onProgress?: (p: any) => void }) => {
-            // Simulate progress callback with percentage
-            if (options.onProgress) {
-              options.onProgress({ message: 'Processing', progressPercent: 50 })
-            }
-            return { success: true, result: { graph_id: 'graph_progress' } }
-          }
-        )
-
-        const onProgress = vi.fn()
-        await graphClient.createGraphAndWait(mockMetadata, undefined, { onProgress })
-
-        expect(onProgress).toHaveBeenCalledWith('Processing (50%)')
-      })
-
-      it('should format SSE progress without percentage', async () => {
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_no_percent',
-          })
-        )
-
-        mockMonitorOperation.mockImplementationOnce(
-          async (_opId: string, options: { onProgress?: (p: any) => void }) => {
-            if (options.onProgress) {
-              options.onProgress({ message: 'Initializing' })
-            }
-            return { success: true, result: { graph_id: 'graph_init' } }
-          }
-        )
-
-        const onProgress = vi.fn()
-        await graphClient.createGraphAndWait(mockMetadata, undefined, { onProgress })
-
-        expect(onProgress).toHaveBeenCalledWith('Initializing')
-      })
-
-      it('should fall back to polling when SSE fails', async () => {
-        // createGraph returns operation_id
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_sse_fail',
-          })
-        )
-
-        // SSE fails
-        mockMonitorOperation.mockRejectedValueOnce(new Error('SSE connection failed'))
-
-        // Polling succeeds
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            status: 'completed',
-            result: { graph_id: 'graph_from_polling' },
-          })
-        )
-
-        const onProgress = vi.fn()
-        const graphId = await graphClient.createGraphAndWait(mockMetadata, undefined, {
-          pollInterval: 100,
-          onProgress,
-        })
-
-        expect(graphId).toBe('graph_from_polling')
-        expect(onProgress).toHaveBeenCalledWith('SSE unavailable, using polling...')
-        // createGraph + 1 polling call
-        expect(mockFetch).toHaveBeenCalledTimes(2)
-      })
-
-      it('should skip SSE when useSSE is false', async () => {
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_no_sse',
-          })
-        )
-
-        // Polling succeeds
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            status: 'completed',
-            result: { graph_id: 'graph_polling_only' },
-          })
-        )
-
-        const graphId = await graphClient.createGraphAndWait(mockMetadata, undefined, {
-          useSSE: false,
-          pollInterval: 100,
-        })
-
-        expect(graphId).toBe('graph_polling_only')
-        // SSE should never be called
-        expect(mockMonitorOperation).not.toHaveBeenCalled()
-      })
-
-      it('should throw error when SSE operation fails', async () => {
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_sse_error',
-          })
-        )
-
-        mockMonitorOperation.mockResolvedValueOnce({
-          success: false,
-          error: 'Operation failed on server',
-        })
-
-        await expect(
-          graphClient.createGraphAndWait(mockMetadata, undefined, { useSSE: true })
-        ).rejects.toThrow('Operation failed on server')
-      })
-
-      it('should throw error when SSE completes but no graph_id in result', async () => {
-        mockFetch.mockResolvedValueOnce(
-          createMockResponse({
-            operation_id: 'op_no_graph_id',
-          })
-        )
-
-        mockMonitorOperation.mockResolvedValueOnce({
-          success: true,
-          result: {}, // No graph_id
-        })
-
-        await expect(graphClient.createGraphAndWait(mockMetadata)).rejects.toThrow(
-          'Operation completed but no graph_id in result'
-        )
-      })
-    })
-  })
-
-  describe('getGraphInfo', () => {
-    it('should get graph info by ID', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          graphs: [
-            {
-              graph_id: 'graph_123',
-              graph_name: 'Test Graph',
-              description: 'Test description',
-              schema_extensions: ['prop1'],
-              tags: ['test'],
-              created_at: '2024-01-01T00:00:00Z',
-              status: 'active',
-            },
-            {
-              graph_id: 'graph_456',
-              graph_name: 'Other Graph',
-            },
-          ],
-        })
-      )
-
-      const info = await graphClient.getGraphInfo('graph_123')
-
-      expect(info.graphId).toBe('graph_123')
-      expect(info.graphName).toBe('Test Graph')
-      expect(info.description).toBe('Test description')
-      expect(info.tags).toEqual(['test'])
-    })
-
-    it('should throw error if graph not found', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          graphs: [
-            {
-              graph_id: 'graph_other',
-              graph_name: 'Other Graph',
-            },
-          ],
-        })
-      )
-
-      await expect(graphClient.getGraphInfo('graph_notfound')).rejects.toThrow('Graph not found')
-    })
-
-    it('should throw error if no token provided', async () => {
-      const clientNoToken = new GraphClient({
-        baseUrl: 'http://localhost:8000',
-      })
-
-      await expect(clientNoToken.getGraphInfo('graph_123')).rejects.toThrow('No API key provided')
-    })
-  })
-
-  describe('listGraphs', () => {
-    it('should list all graphs', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          graphs: [
-            {
-              graph_id: 'graph_1',
-              graph_name: 'Graph 1',
-              description: 'First graph',
-            },
-            {
-              graph_id: 'graph_2',
-              graph_name: 'Graph 2',
-              tags: ['production'],
-            },
-          ],
-        })
-      )
-
-      const graphs = await graphClient.listGraphs()
-
-      expect(graphs).toHaveLength(2)
-      expect(graphs[0].graphId).toBe('graph_1')
-      expect(graphs[0].graphName).toBe('Graph 1')
-      expect(graphs[1].graphId).toBe('graph_2')
-      expect(graphs[1].tags).toEqual(['production'])
-    })
-
-    it('should return empty array if no graphs', async () => {
-      mockFetch.mockResolvedValueOnce(
-        createMockResponse({
-          graphs: [],
-        })
-      )
-
-      const graphs = await graphClient.listGraphs()
-
-      expect(graphs).toEqual([])
-    })
-  })
-
-  describe('deleteGraph', () => {
-    it('should throw not implemented error', async () => {
-      await expect(graphClient.deleteGraph('graph_123')).rejects.toThrow('not yet implemented')
-    })
-  })
-
-  describe('close', () => {
-    it('should close without errors', () => {
-      expect(() => graphClient.close()).not.toThrow()
-    })
-  })
-})