@robosystems/client 0.2.0 → 0.2.2

package/sdk-extensions/GraphClient.ts

@@ -0,0 +1,281 @@
+'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 {
+  createEntity?: boolean
+  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
+   *
+   * @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)
+   *   - onProgress: Callback for progress updates
+   * @returns The graph ID when creation completes
+   */
+  async createGraphAndWait(
+    metadata: GraphMetadataInput,
+    initialEntity?: InitialEntityInput,
+    options: CreateGraphOptions = {}
+  ): Promise<string> {
+    const { createEntity = true, 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,
+        create_entity: createEntity,
+      },
+    })
+
+    // 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()
+  }
+}

package/sdk-extensions/TableIngestClient.d.ts

@@ -44,7 +44,7 @@ export declare class TableIngestClient {
      * This method handles the complete 3-step upload process:
      * 1. Get presigned upload URL
      * 2. Upload file to S3
-     * 3. Update file metadata
+     * 3. Mark file as 'uploaded' (backend validates, calculates size/row count)
      *
      * Supports File (browser), Blob (browser), Buffer (Node.js), and ReadableStream.
      */

package/sdk-extensions/TableIngestClient.js

@@ -19,7 +19,7 @@ class TableIngestClient {
      * This method handles the complete 3-step upload process:
      * 1. Get presigned upload URL
      * 2. Upload file to S3
-     * 3. Update file metadata
+     * 3. Mark file as 'uploaded' (backend validates, calculates size/row count)
      *
      * Supports File (browser), Blob (browser), Buffer (Node.js), and ReadableStream.
      */
@@ -32,7 +32,7 @@ class TableIngestClient {
                 file_name: fileName,
                 content_type: 'application/x-parquet',
             };
-            const uploadUrlResponse = await (0, sdk_gen_1.getUploadUrlV1GraphsGraphIdTablesTableNameFilesPost)({
+            const uploadUrlResponse = await (0, sdk_gen_1.getUploadUrl)({
                 path: { graph_id: graphId, table_name: tableName },
                 body: uploadRequest,
                 query: this.config.token ? { token: this.config.token } : undefined,
@@ -77,36 +77,36 @@ class TableIngestClient {
                     error: `S3 upload failed: ${s3Response.status} ${s3Response.statusText}`,
                 };
             }
-            // Step 3: Update file metadata
-            options.onProgress?.(`Updating file metadata for ${fileName}...`);
-            // Estimate row count (TypeScript can't read Parquet metadata without library)
-            // Rough estimate: ~100 bytes per row for typical data
-            const estimatedRowCount = Math.floor(fileSize / 100);
-            const metadataUpdate = {
-                file_size_bytes: fileSize,
-                row_count: estimatedRowCount,
+            // Step 3: Mark file as uploaded (backend validates and calculates size/row count)
+            options.onProgress?.(`Marking ${fileName} as uploaded...`);
+            const statusUpdate = {
+                status: 'uploaded',
             };
-            const updateResponse = await (0, sdk_gen_1.updateFileV1GraphsGraphIdTablesFilesFileIdPatch)({
+            const updateResponse = await (0, sdk_gen_1.updateFileStatus)({
                 path: { graph_id: graphId, file_id: fileId },
-                body: metadataUpdate,
+                body: statusUpdate,
                 query: this.config.token ? { token: this.config.token } : undefined,
             });
-            if (updateResponse.error) {
+            if (updateResponse.error || !updateResponse.data) {
                 return {
                     fileId,
                     fileSize,
-                    rowCount: estimatedRowCount,
+                    rowCount: 0,
                     tableName,
                     fileName,
                     success: false,
-                    error: 'Failed to update file metadata',
+                    error: 'Failed to complete file upload',
                 };
             }
-            options.onProgress?.(`✅ Uploaded ${fileName} (${fileSize.toLocaleString()} bytes, ~${estimatedRowCount.toLocaleString()} rows)`);
+            // Extract size and row count from response (calculated by backend)
+            const responseData = updateResponse.data;
+            const actualFileSize = responseData.file_size_bytes || 0;
+            const actualRowCount = responseData.row_count || 0;
+            options.onProgress?.(`✅ Uploaded ${fileName} (${actualFileSize.toLocaleString()} bytes, ${actualRowCount.toLocaleString()} rows)`);
             return {
                 fileId,
-                fileSize,
-                rowCount: estimatedRowCount,
+                fileSize: actualFileSize,
+                rowCount: actualRowCount,
                 tableName,
                 fileName,
                 success: true,
@@ -129,7 +129,7 @@ class TableIngestClient {
      */
     async listStagingTables(graphId) {
         try {
-            const response = await (0, sdk_gen_1.listTablesV1GraphsGraphIdTablesGet)({
+            const response = await (0, sdk_gen_1.listTables)({
                 path: { graph_id: graphId },
                 query: this.config.token ? { token: this.config.token } : undefined,
             });
@@ -160,7 +160,7 @@ class TableIngestClient {
                 ignore_errors: options.ignoreErrors ?? true,
                 rebuild: options.rebuild ?? false,
             };
-            const response = await (0, sdk_gen_1.ingestTablesV1GraphsGraphIdTablesIngestPost)({
+            const response = await (0, sdk_gen_1.ingestTables)({
                 path: { graph_id: graphId },
                 body: ingestRequest,
                 query: this.config.token ? { token: this.config.token } : undefined,

package/sdk-extensions/TableIngestClient.test.ts

@@ -153,7 +153,7 @@ describe('TableIngestClient', () => {
       const result = await tableClient.uploadParquetFile('graph_123', 'Entity', buffer)
 
       expect(result.success).toBe(false)
-      expect(result.error).toContain('Failed to update file metadata')
+      expect(result.error).toContain('Failed to complete file upload')
     })
   })
 

package/sdk-extensions/TableIngestClient.ts

@@ -7,15 +7,10 @@
  * Supports File (browser), Blob (browser), Buffer (Node.js), and ReadableStream.
  */
 
-import {
-  getUploadUrlV1GraphsGraphIdTablesTableNameFilesPost,
-  ingestTablesV1GraphsGraphIdTablesIngestPost,
-  listTablesV1GraphsGraphIdTablesGet,
-  updateFileV1GraphsGraphIdTablesFilesFileIdPatch,
-} from '../sdk/sdk.gen'
+import { getUploadUrl, ingestTables, listTables, updateFileStatus } from '../sdk/sdk.gen'
 import type {
   BulkIngestRequest,
-  FileUpdateRequest,
+  FileStatusUpdate,
   FileUploadRequest,
   FileUploadResponse,
   TableListResponse,
@@ -83,7 +78,7 @@ export class TableIngestClient {
    * This method handles the complete 3-step upload process:
    * 1. Get presigned upload URL
    * 2. Upload file to S3
-   * 3. Update file metadata
+   * 3. Mark file as 'uploaded' (backend validates, calculates size/row count)
    *
    * Supports File (browser), Blob (browser), Buffer (Node.js), and ReadableStream.
    */
@@ -104,7 +99,7 @@ export class TableIngestClient {
         content_type: 'application/x-parquet',
       }
 
-      const uploadUrlResponse = await getUploadUrlV1GraphsGraphIdTablesTableNameFilesPost({
+      const uploadUrlResponse = await getUploadUrl({
         path: { graph_id: graphId, table_name: tableName },
         body: uploadRequest,
         query: this.config.token ? { token: this.config.token } : undefined,
@@ -157,44 +152,44 @@ export class TableIngestClient {
         }
       }
 
-      // Step 3: Update file metadata
-      options.onProgress?.(`Updating file metadata for ${fileName}...`)
+      // Step 3: Mark file as uploaded (backend validates and calculates size/row count)
+      options.onProgress?.(`Marking ${fileName} as uploaded...`)
 
-      // Estimate row count (TypeScript can't read Parquet metadata without library)
-      // Rough estimate: ~100 bytes per row for typical data
-      const estimatedRowCount = Math.floor(fileSize / 100)
-
-      const metadataUpdate: FileUpdateRequest = {
-        file_size_bytes: fileSize,
-        row_count: estimatedRowCount,
+      const statusUpdate: FileStatusUpdate = {
+        status: 'uploaded',
       }
 
-      const updateResponse = await updateFileV1GraphsGraphIdTablesFilesFileIdPatch({
+      const updateResponse = await updateFileStatus({
         path: { graph_id: graphId, file_id: fileId },
-        body: metadataUpdate,
+        body: statusUpdate,
         query: this.config.token ? { token: this.config.token } : undefined,
       })
 
-      if (updateResponse.error) {
+      if (updateResponse.error || !updateResponse.data) {
         return {
           fileId,
           fileSize,
-          rowCount: estimatedRowCount,
+          rowCount: 0,
           tableName,
           fileName,
           success: false,
-          error: 'Failed to update file metadata',
+          error: 'Failed to complete file upload',
         }
       }
 
+      // Extract size and row count from response (calculated by backend)
+      const responseData = updateResponse.data as any
+      const actualFileSize = responseData.file_size_bytes || 0
+      const actualRowCount = responseData.row_count || 0
+
       options.onProgress?.(
-        `✅ Uploaded ${fileName} (${fileSize.toLocaleString()} bytes, ~${estimatedRowCount.toLocaleString()} rows)`
+        `✅ Uploaded ${fileName} (${actualFileSize.toLocaleString()} bytes, ${actualRowCount.toLocaleString()} rows)`
       )
 
       return {
         fileId,
-        fileSize,
-        rowCount: estimatedRowCount,
+        fileSize: actualFileSize,
+        rowCount: actualRowCount,
         tableName,
         fileName,
         success: true,
@@ -217,7 +212,7 @@ export class TableIngestClient {
    */
   async listStagingTables(graphId: string): Promise<TableInfo[]> {
     try {
-      const response = await listTablesV1GraphsGraphIdTablesGet({
+      const response = await listTables({
         path: { graph_id: graphId },
         query: this.config.token ? { token: this.config.token } : undefined,
       })
@@ -255,7 +250,7 @@ export class TableIngestClient {
         rebuild: options.rebuild ?? false,
       }
 
-      const response = await ingestTablesV1GraphsGraphIdTablesIngestPost({
+      const response = await ingestTables({
         path: { graph_id: graphId },
         body: ingestRequest,
         query: this.config.token ? { token: this.config.token } : undefined,

package/sdk-extensions/hooks.d.ts

@@ -63,7 +63,7 @@ export declare function useStreamingQuery(graphId: string): {
 export declare function useOperation<T = any>(operationId?: string): {
     monitor: (id: string, timeout?: number) => Promise<OperationResult<T> | null>;
     cancel: (id: string) => Promise<void>;
-    status: "error" | "idle" | "running" | "completed";
+    status: "error" | "completed" | "idle" | "running";
     progress: OperationProgress;
     error: Error;
     result: OperationResult<T>;

package/sdk-extensions/index.d.ts

@@ -6,6 +6,7 @@ import { OperationClient } from './OperationClient';
 import { QueryClient } from './QueryClient';
 import { SSEClient } from './SSEClient';
 import { TableIngestClient } from './TableIngestClient';
+import { GraphClient } from './GraphClient';
 export interface RoboSystemsExtensionConfig {
     baseUrl?: string;
     credentials?: 'include' | 'same-origin' | 'omit';
@@ -18,6 +19,7 @@ export declare class RoboSystemsExtensions {
     readonly query: QueryClient;
     readonly operations: OperationClient;
     readonly tables: TableIngestClient;
+    readonly graphs: GraphClient;
     private config;
     constructor(config?: RoboSystemsExtensionConfig);
     /**
@@ -37,11 +39,13 @@ export * from './OperationClient';
 export * from './QueryClient';
 export * from './SSEClient';
 export * from './TableIngestClient';
-export { OperationClient, QueryClient, SSEClient, TableIngestClient };
+export * from './GraphClient';
+export { OperationClient, QueryClient, SSEClient, TableIngestClient, GraphClient };
 export { useMultipleOperations, useOperation, useQuery, useSDKClients, useStreamingQuery, useTableUpload, } from './hooks';
 export declare const extensions: {
     readonly query: QueryClient;
     readonly operations: OperationClient;
+    readonly graphs: GraphClient;
     monitorOperation: (operationId: string, onProgress?: (progress: any) => void) => Promise<any>;
     createSSEClient: () => SSEClient;
     close: () => void;

package/sdk-extensions/index.js

@@ -18,7 +18,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamQuery = exports.executeQuery = exports.monitorOperation = exports.extensions = exports.useTableUpload = exports.useStreamingQuery = exports.useSDKClients = exports.useQuery = exports.useOperation = exports.useMultipleOperations = exports.TableIngestClient = exports.SSEClient = exports.QueryClient = exports.OperationClient = exports.RoboSystemsExtensions = void 0;
+exports.streamQuery = exports.executeQuery = exports.monitorOperation = exports.extensions = exports.useTableUpload = exports.useStreamingQuery = exports.useSDKClients = exports.useQuery = exports.useOperation = exports.useMultipleOperations = exports.GraphClient = exports.TableIngestClient = exports.SSEClient = exports.QueryClient = exports.OperationClient = exports.RoboSystemsExtensions = void 0;
 const client_gen_1 = require("../sdk/client.gen");
 const config_1 = require("./config");
 const OperationClient_1 = require("./OperationClient");
@@ -29,6 +29,8 @@ const SSEClient_1 = require("./SSEClient");
 Object.defineProperty(exports, "SSEClient", { enumerable: true, get: function () { return SSEClient_1.SSEClient; } });
 const TableIngestClient_1 = require("./TableIngestClient");
 Object.defineProperty(exports, "TableIngestClient", { enumerable: true, get: function () { return TableIngestClient_1.TableIngestClient; } });
+const GraphClient_1 = require("./GraphClient");
+Object.defineProperty(exports, "GraphClient", { enumerable: true, get: function () { return GraphClient_1.GraphClient; } });
 class RoboSystemsExtensions {
     constructor(config = {}) {
         // Get base URL from SDK client config or use provided/default
@@ -62,6 +64,12 @@ class RoboSystemsExtensions {
             token: this.config.token,
             headers: this.config.headers,
         });
+        this.graphs = new GraphClient_1.GraphClient({
+            baseUrl: this.config.baseUrl,
+            credentials: this.config.credentials,
+            token: this.config.token,
+            headers: this.config.headers,
+        });
     }
     /**
      * Convenience method to monitor any operation
@@ -88,6 +96,7 @@ class RoboSystemsExtensions {
     close() {
         this.query.close();
         this.operations.closeAll();
+        this.graphs.close();
     }
 }
 exports.RoboSystemsExtensions = RoboSystemsExtensions;
@@ -96,6 +105,7 @@ __exportStar(require("./OperationClient"), exports);
 __exportStar(require("./QueryClient"), exports);
 __exportStar(require("./SSEClient"), exports);
 __exportStar(require("./TableIngestClient"), exports);
+__exportStar(require("./GraphClient"), exports);
 // Export React hooks
 var hooks_1 = require("./hooks");
 Object.defineProperty(exports, "useMultipleOperations", { enumerable: true, get: function () { return hooks_1.useMultipleOperations; } });
@@ -119,6 +129,9 @@ exports.extensions = {
     get operations() {
         return getExtensions().operations;
     },
+    get graphs() {
+        return getExtensions().graphs;
+    },
     monitorOperation: (operationId, onProgress) => getExtensions().monitorOperation(operationId, onProgress),
     createSSEClient: () => getExtensions().createSSEClient(),
     close: () => getExtensions().close(),

package/sdk-extensions/index.test.ts

@@ -24,10 +24,12 @@ describe('RoboSystemsExtensions', () => {
       expect(extensions.query).toBeDefined()
       expect(extensions.operations).toBeDefined()
       expect(extensions.tables).toBeDefined()
+      expect(extensions.graphs).toBeDefined()
       // Verify clients have expected methods
       expect(typeof extensions.query.executeQuery).toBe('function')
       expect(typeof extensions.operations.monitorOperation).toBe('function')
       expect(typeof extensions.tables.uploadParquetFile).toBe('function')
+      expect(typeof extensions.graphs.createGraphAndWait).toBe('function')
     })
 
     it('should create instance with custom baseUrl', () => {
@@ -38,6 +40,7 @@ describe('RoboSystemsExtensions', () => {
       expect(extensions.query).toBeDefined()
       expect(extensions.operations).toBeDefined()
       expect(extensions.tables).toBeDefined()
+      expect(extensions.graphs).toBeDefined()
     })
 
     it('should create instance with JWT token', () => {
@@ -88,6 +91,7 @@ describe('RoboSystemsExtensions', () => {
       expect(extensions.query).toBeDefined()
       expect(extensions.operations).toBeDefined()
       expect(extensions.tables).toBeDefined()
+      expect(extensions.graphs).toBeDefined()
     })
   })
 
@@ -152,11 +156,13 @@ describe('RoboSystemsExtensions', () => {
 
       const queryCloseSpy = vi.spyOn(extensions.query, 'close')
       const operationsCloseSpy = vi.spyOn(extensions.operations, 'closeAll')
+      const graphsCloseSpy = vi.spyOn(extensions.graphs, 'close')
 
       extensions.close()
 
       expect(queryCloseSpy).toHaveBeenCalled()
       expect(operationsCloseSpy).toHaveBeenCalled()
+      expect(graphsCloseSpy).toHaveBeenCalled()
     })
 
     it('should not throw when called multiple times', () => {
@@ -188,9 +194,11 @@ describe('RoboSystemsExtensions', () => {
       expect(extensions.query).toBeDefined()
       expect(extensions.operations).toBeDefined()
       expect(extensions.tables).toBeDefined()
+      expect(extensions.graphs).toBeDefined()
       expect(typeof extensions.query.executeQuery).toBe('function')
       expect(typeof extensions.operations.monitorOperation).toBe('function')
       expect(typeof extensions.tables.uploadParquetFile).toBe('function')
+      expect(typeof extensions.graphs.createGraphAndWait).toBe('function')
     })
 
     it('should use SDK client baseUrl when no baseUrl provided', () => {
@@ -200,6 +208,20 @@ describe('RoboSystemsExtensions', () => {
       expect(extensions.query).toBeDefined()
       expect(extensions.operations).toBeDefined()
       expect(extensions.tables).toBeDefined()
+      expect(extensions.graphs).toBeDefined()
+    })
+  })
+
+  describe('graphs client', () => {
+    it('should have graphs client with all methods', () => {
+      const extensions = new RoboSystemsExtensions()
+
+      expect(extensions.graphs).toBeDefined()
+      expect(typeof extensions.graphs.createGraphAndWait).toBe('function')
+      expect(typeof extensions.graphs.getGraphInfo).toBe('function')
+      expect(typeof extensions.graphs.listGraphs).toBe('function')
+      expect(typeof extensions.graphs.deleteGraph).toBe('function')
+      expect(typeof extensions.graphs.close).toBe('function')
     })
   })
 })