@robosystems/client 0.2.0 → 0.2.1

package/extensions/GraphClient.d.ts

@@ -0,0 +1,58 @@
+export interface GraphMetadataInput {
+    graphName: string;
+    description?: string;
+    schemaExtensions?: string[];
+    tags?: string[];
+}
+export interface InitialEntityInput {
+    name: string;
+    uri: string;
+    category?: string;
+    sic?: string;
+    sicDescription?: string;
+}
+export interface GraphInfo {
+    graphId: string;
+    graphName: string;
+    description?: string;
+    schemaExtensions?: string[];
+    tags?: string[];
+    createdAt?: string;
+    status?: string;
+}
+export interface CreateGraphOptions {
+    timeout?: number;
+    pollInterval?: number;
+    onProgress?: (message: string) => void;
+}
+export declare class GraphClient {
+    private operationClient;
+    private config;
+    constructor(config: {
+        baseUrl: string;
+        credentials?: 'include' | 'same-origin' | 'omit';
+        headers?: Record<string, string>;
+        token?: string;
+    });
+    /**
+     * Create a graph and wait for completion
+     */
+    createGraphAndWait(metadata: GraphMetadataInput, initialEntity?: InitialEntityInput, options?: CreateGraphOptions): Promise<string>;
+    /**
+     * Get information about a graph
+     */
+    getGraphInfo(graphId: string): Promise<GraphInfo>;
+    /**
+     * List all graphs
+     */
+    listGraphs(): Promise<GraphInfo[]>;
+    /**
+     * Delete a graph
+     * Note: This will be implemented when the deleteGraph endpoint is available in the SDK
+     */
+    deleteGraph(graphId: string): Promise<void>;
+    /**
+     * Clean up resources
+     */
+    close(): void;
+}

package/extensions/GraphClient.js

@@ -0,0 +1,163 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphClient = void 0;
+/**
+ * Graph Management Client
+ * Provides high-level graph management operations with automatic operation monitoring
+ */
+const sdk_gen_1 = require("../sdk.gen");
+const OperationClient_1 = require("./OperationClient");
+class GraphClient {
+    constructor(config) {
+        this.config = config;
+        this.operationClient = new OperationClient_1.OperationClient(config);
+    }
+    /**
+     * Create a graph and wait for completion
+     */
+    async createGraphAndWait(metadata, initialEntity, options = {}) {
+        const { timeout = 60000, pollInterval = 2000, onProgress } = 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,
+            },
+        });
+        // 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) {
+            const operationId = responseData.operation_id;
+            if (onProgress) {
+                onProgress(`Graph creation queued (operation: ${operationId})`);
+            }
+            // Poll operation status
+            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 Error('Operation completed but no graph_id in result');
+                    }
+                }
+                else if (status === 'failed') {
+                    const error = statusData?.error || statusData?.message || 'Unknown error';
+                    throw new Error(`Graph creation failed: ${error}`);
+                }
+            }
+            throw new Error(`Graph creation timed out after ${timeout}ms`);
+        }
+        throw new Error('No graph_id or operation_id in response');
+    }
+    /**
+     * 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

@@ -0,0 +1,285 @@
+import { beforeEach, describe, expect, it, vi } 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
+
+  beforeEach(() => {
+    graphClient = new GraphClient({
+      baseUrl: 'http://localhost:8000',
+      token: 'test-api-key',
+      headers: { 'X-API-Key': 'test-api-key' },
+    })
+
+    // Mock global fetch
+    mockFetch = vi.fn()
+    global.fetch = mockFetch
+
+    // Reset all mocks
+    vi.clearAllMocks()
+  })
+
+  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('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()
+    })
+  })
+})