@robosystems/client 0.2.0 → 0.2.1

package/sdk-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/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/sdk-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()
+    })
+  })
+})

package/sdk-extensions/GraphClient.ts

@@ -0,0 +1,267 @@
+'use client'
+
+/**
+ * Graph Management Client
+ * Provides high-level graph management operations with automatic operation monitoring
+ */
+
+import { createGraph, getGraphs, getOperationStatus } from '../sdk/sdk.gen'
+import type { GraphMetadata, InitialEntityData } from '../sdk/types.gen'
+import { OperationClient } from './OperationClient'
+
+// API Response Types
+interface GraphCreateResponse {
+  graph_id?: string
+  operation_id?: string
+}
+
+interface OperationStatusResponse {
+  status?: 'pending' | 'completed' | 'failed' | string
+  result?: {
+    graph_id?: string
+  }
+  error?: string
+  message?: string
+}
+
+interface GraphApiData {
+  graph_id?: string
+  id?: string
+  graph_name?: string
+  name?: string
+  description?: string
+  schema_extensions?: string[]
+  tags?: string[]
+  created_at?: string
+  status?: string
+}
+
+interface GetGraphsResponse {
+  graphs?: GraphApiData[]
+}
+
+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 class GraphClient {
+  private operationClient: OperationClient
+  private config: {
+    baseUrl: string
+    credentials?: 'include' | 'same-origin' | 'omit'
+    headers?: Record<string, string>
+    token?: string
+  }
+
+  constructor(config: {
+    baseUrl: string
+    credentials?: 'include' | 'same-origin' | 'omit'
+    headers?: Record<string, string>
+    token?: string
+  }) {
+    this.config = config
+    this.operationClient = new OperationClient(config)
+  }
+
+  /**
+   * Create a graph and wait for completion
+   */
+  async createGraphAndWait(
+    metadata: GraphMetadataInput,
+    initialEntity?: InitialEntityInput,
+    options: CreateGraphOptions = {}
+  ): Promise<string> {
+    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: InitialEntityData | undefined
+    if (initialEntity) {
+      initialEntityData = {
+        name: initialEntity.name,
+        uri: initialEntity.uri,
+        category: initialEntity.category,
+        sic: initialEntity.sic,
+        sic_description: initialEntity.sicDescription,
+      }
+    }
+
+    // Build API metadata
+    const apiMetadata: GraphMetadata = {
+      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 createGraph({
+      body: {
+        metadata: apiMetadata,
+        initial_entity: initialEntityData || null,
+      },
+    })
+
+    // Check if we got immediate graph_id
+    const responseData = response.data as GraphCreateResponse
+    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 getOperationStatus({
+          path: { operation_id: operationId },
+        })
+
+        const statusData = statusResponse.data as OperationStatusResponse
+        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: string): Promise<GraphInfo> {
+    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 getGraphs()
+    const graphs = (response.data as GetGraphsResponse)?.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(): Promise<GraphInfo[]> {
+    if (!this.config.token) {
+      throw new Error('No API key provided. Set token in config.')
+    }
+
+    const response = await getGraphs()
+    const graphs = (response.data as GetGraphsResponse)?.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: string): Promise<void> {
+    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(): void {
+    this.operationClient.closeAll()
+  }
+}