@robosystems/client 0.2.42 → 0.2.44

package/sdk-extensions/GraphClient.ts

@@ -1,371 +0,0 @@
-'use client'
-
-/**
- * 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.
- */
-
-import { createGraph, getGraphs, getOperationStatus } from '../sdk/sdk.gen'
-import type { GraphMetadata, InitialEntityData } from '../sdk/types.gen'
-import { OperationClient } from './OperationClient'
-
-/**
- * Error thrown when a graph operation fails (as reported by the server)
- * This is distinct from connection/SSE errors
- */
-export class GraphOperationError extends Error {
-  constructor(message: string) {
-    super(message)
-    this.name = 'GraphOperationError'
-  }
-}
-
-// 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
-  useSSE?: boolean
-}
-
-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
-   *
-   * 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: GraphMetadataInput,
-    initialEntity?: InitialEntityInput,
-    options: CreateGraphOptions = {}
-  ): Promise<string> {
-    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: 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) {
-      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
-   */
-  private async waitWithSSE(
-    operationId: string,
-    timeout: number,
-    onProgress?: (message: string) => void
-  ): Promise<string> {
-    const result = await this.operationClient.monitorOperation<{ graph_id?: string }>(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
-   */
-  private async waitWithPolling(
-    operationId: string,
-    timeout: number,
-    pollInterval: number,
-    onProgress?: (message: string) => void
-  ): Promise<string> {
-    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 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: 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/MaterializationClient.d.ts

@@ -1,61 +0,0 @@
-export interface MaterializationOptions {
-    ignoreErrors?: boolean;
-    rebuild?: boolean;
-    force?: boolean;
-    timeout?: number;
-    onProgress?: (message: string) => void;
-}
-export interface MaterializationResult {
-    status: string;
-    wasStale: boolean;
-    staleReason?: string;
-    tablesMaterialized: string[];
-    totalRows: number;
-    executionTimeMs: number;
-    message: string;
-    success: boolean;
-    error?: string;
-}
-export interface MaterializationStatus {
-    graphId: string;
-    isStale: boolean;
-    staleReason?: string;
-    staleSince?: string;
-    lastMaterializedAt?: string;
-    materializationCount: number;
-    hoursSinceMaterialization?: number;
-    message: string;
-}
-export declare class MaterializationClient {
-    private config;
-    private operationClient;
-    constructor(config: {
-        baseUrl: string;
-        credentials?: 'include' | 'same-origin' | 'omit';
-        headers?: Record<string, string>;
-        token?: string;
-    });
-    /**
-     * Materialize graph from DuckDB staging tables
-     *
-     * Submits a materialization job to Dagster and monitors progress via SSE.
-     * The operation runs asynchronously on the server but this method waits
-     * for completion and returns the final result.
-     */
-    materialize(graphId: string, options?: MaterializationOptions): Promise<MaterializationResult>;
-    /**
-     * Convert SSE operation result to MaterializationResult
-     */
-    private convertOperationResult;
-    /**
-     * Get current materialization status for the graph
-     *
-     * Shows whether the graph is stale (DuckDB has changes not yet in graph database),
-     * when it was last materialized, and how long since last materialization.
-     */
-    status(graphId: string): Promise<MaterializationStatus | null>;
-    /**
-     * Close any active SSE connections
-     */
-    close(): void;
-}

package/sdk-extensions/MaterializationClient.js

@@ -1,157 +0,0 @@
-'use client';
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MaterializationClient = void 0;
-/**
- * Materialization Client for RoboSystems API
- *
- * Manages graph materialization from DuckDB staging tables.
- * Submits materialization jobs to Dagster and monitors progress via SSE.
- */
-const sdk_gen_1 = require("../sdk/sdk.gen");
-const OperationClient_1 = require("./OperationClient");
-class MaterializationClient {
-    constructor(config) {
-        this.config = config;
-        this.operationClient = new OperationClient_1.OperationClient(config);
-    }
-    /**
-     * Materialize graph from DuckDB staging tables
-     *
-     * Submits a materialization job to Dagster and monitors progress via SSE.
-     * The operation runs asynchronously on the server but this method waits
-     * for completion and returns the final result.
-     */
-    async materialize(graphId, options = {}) {
-        try {
-            options.onProgress?.('Submitting materialization job...');
-            const request = {
-                ignore_errors: options.ignoreErrors ?? true,
-                rebuild: options.rebuild ?? false,
-                force: options.force ?? false,
-            };
-            const response = await (0, sdk_gen_1.materializeGraph)({
-                path: { graph_id: graphId },
-                body: request,
-            });
-            if (response.error || !response.data) {
-                return {
-                    status: 'failed',
-                    wasStale: false,
-                    tablesMaterialized: [],
-                    totalRows: 0,
-                    executionTimeMs: 0,
-                    message: `Failed to materialize graph: ${response.error}`,
-                    success: false,
-                    error: `Failed to materialize graph: ${response.error}`,
-                };
-            }
-            const queuedResponse = response.data;
-            const operationId = queuedResponse.operation_id;
-            options.onProgress?.(`Materialization queued (operation: ${operationId})`);
-            // Monitor the operation via SSE until completion
-            const opResult = await this.operationClient.monitorOperation(operationId, {
-                timeout: (options.timeout ?? 600) * 1000, // Convert to milliseconds, 10 minute default
-                onProgress: (progress) => {
-                    if (options.onProgress) {
-                        let msg = progress.message;
-                        if (progress.progressPercent !== undefined) {
-                            msg += ` (${progress.progressPercent.toFixed(0)}%)`;
-                        }
-                        options.onProgress(msg);
-                    }
-                },
-            });
-            // Convert operation result to materialization result
-            return this.convertOperationResult(opResult, options);
-        }
-        catch (error) {
-            return {
-                status: 'failed',
-                wasStale: false,
-                tablesMaterialized: [],
-                totalRows: 0,
-                executionTimeMs: 0,
-                message: error instanceof Error ? error.message : String(error),
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-    /**
-     * Convert SSE operation result to MaterializationResult
-     */
-    convertOperationResult(opResult, options) {
-        if (opResult.success) {
-            // Extract details from SSE completion event result
-            const sseResult = opResult.result || {};
-            const tables = sseResult.tables_materialized || [];
-            const rows = sseResult.total_rows || 0;
-            const timeMs = sseResult.execution_time_ms || 0;
-            options.onProgress?.(`✅ Materialization complete: ${tables.length} tables, ` +
-                `${rows.toLocaleString()} rows in ${timeMs.toFixed(2)}ms`);
-            return {
-                status: 'success',
-                wasStale: sseResult.was_stale || false,
-                staleReason: sseResult.stale_reason,
-                tablesMaterialized: tables,
-                totalRows: rows,
-                executionTimeMs: timeMs,
-                message: sseResult.message || 'Graph materialized successfully',
-                success: true,
-            };
-        }
-        else {
-            // Operation failed or was cancelled
-            return {
-                status: 'failed',
-                wasStale: false,
-                tablesMaterialized: [],
-                totalRows: 0,
-                executionTimeMs: 0,
-                message: opResult.error || 'Operation failed',
-                success: false,
-                error: opResult.error,
-            };
-        }
-    }
-    /**
-     * Get current materialization status for the graph
-     *
-     * Shows whether the graph is stale (DuckDB has changes not yet in graph database),
-     * when it was last materialized, and how long since last materialization.
-     */
-    async status(graphId) {
-        try {
-            const response = await (0, sdk_gen_1.getMaterializationStatus)({
-                path: { graph_id: graphId },
-            });
-            if (response.error || !response.data) {
-                console.error('Failed to get materialization status:', response.error);
-                return null;
-            }
-            const status = response.data;
-            return {
-                graphId: status.graph_id,
-                isStale: status.is_stale,
-                staleReason: status.stale_reason,
-                staleSince: status.stale_since,
-                lastMaterializedAt: status.last_materialized_at,
-                materializationCount: status.materialization_count || 0,
-                hoursSinceMaterialization: status.hours_since_materialization,
-                message: status.message,
-            };
-        }
-        catch (error) {
-            console.error('Failed to get materialization status:', error);
-            return null;
-        }
-    }
-    /**
-     * Close any active SSE connections
-     */
-    close() {
-        this.operationClient.closeAll();
-    }
-}
-exports.MaterializationClient = MaterializationClient;