@robosystems/client 0.2.42 → 0.2.44

package/sdk-extensions/FileClient.ts

@@ -1,330 +0,0 @@
-'use client'
-
-/**
- * File Client for RoboSystems API
- *
- * Manages file upload operations including presigned URLs, S3 uploads,
- * and file status tracking.
- */
-
-import { createFileUpload, deleteFile, getFile, listFiles, updateFile } from '../sdk/sdk.gen'
-import type { FileStatusUpdate, FileUploadRequest, FileUploadResponse } from '../sdk/types.gen'
-
-export interface FileUploadOptions {
-  onProgress?: (message: string) => void
-  fileName?: string
-  ingestToGraph?: boolean
-}
-
-export interface FileUploadResult {
-  fileId: string
-  fileSize: number
-  rowCount: number
-  tableName: string
-  fileName: string
-  success: boolean
-  error?: string
-}
-
-export interface FileInfo {
-  fileId: string
-  fileName: string
-  tableName: string
-  status: string
-  fileSize: number
-  rowCount: number
-  createdAt: string
-}
-
-export type FileInput = File | Blob | Buffer | ReadableStream<Uint8Array>
-
-export class FileClient {
-  private config: {
-    baseUrl: string
-    credentials?: 'include' | 'same-origin' | 'omit'
-    headers?: Record<string, string>
-    token?: string
-    s3EndpointUrl?: string // Override S3 endpoint (e.g., for LocalStack)
-  }
-
-  constructor(config: {
-    baseUrl: string
-    credentials?: 'include' | 'same-origin' | 'omit'
-    headers?: Record<string, string>
-    token?: string
-    s3EndpointUrl?: string
-  }) {
-    this.config = config
-  }
-
-  /**
-   * Upload a Parquet file to staging
-   *
-   * Handles the complete 3-step upload process:
-   * 1. Get presigned upload URL
-   * 2. Upload file to S3
-   * 3. Mark file as 'uploaded' (backend validates, calculates size/row count)
-   */
-  async upload(
-    graphId: string,
-    tableName: string,
-    fileOrBuffer: FileInput,
-    options: FileUploadOptions = {}
-  ): Promise<FileUploadResult> {
-    const fileName = this.getFileName(fileOrBuffer, options.fileName)
-
-    try {
-      options.onProgress?.(`Getting upload URL for ${fileName} -> table '${tableName}'...`)
-
-      const uploadRequest: FileUploadRequest = {
-        file_name: fileName,
-        content_type: 'application/x-parquet',
-        table_name: tableName,
-      }
-
-      const uploadUrlResponse = await createFileUpload({
-        path: { graph_id: graphId },
-        body: uploadRequest,
-      })
-
-      if (uploadUrlResponse.error || !uploadUrlResponse.data) {
-        return {
-          fileId: '',
-          fileSize: 0,
-          rowCount: 0,
-          tableName,
-          fileName,
-          success: false,
-          error: `Failed to get upload URL: ${uploadUrlResponse.error}`,
-        }
-      }
-
-      const uploadData = uploadUrlResponse.data as FileUploadResponse
-      let uploadUrl = uploadData.upload_url
-      const fileId = uploadData.file_id
-
-      // Override S3 endpoint if configured (e.g., for LocalStack)
-      if (this.config.s3EndpointUrl) {
-        const originalUrl = new URL(uploadUrl)
-        const overrideUrl = new URL(this.config.s3EndpointUrl)
-        // Replace scheme, host, and port with the override endpoint
-        originalUrl.protocol = overrideUrl.protocol
-        originalUrl.host = overrideUrl.host
-        uploadUrl = originalUrl.toString()
-      }
-
-      options.onProgress?.(`Uploading ${fileName} to S3...`)
-
-      const fileContent = await this.getFileContent(fileOrBuffer)
-      const fileSize = fileContent.byteLength
-
-      const s3Response = await fetch(uploadUrl, {
-        method: 'PUT',
-        body: fileContent,
-        headers: {
-          'Content-Type': 'application/x-parquet',
-        },
-      })
-
-      if (!s3Response.ok) {
-        return {
-          fileId,
-          fileSize,
-          rowCount: 0,
-          tableName,
-          fileName,
-          success: false,
-          error: `S3 upload failed: ${s3Response.status} ${s3Response.statusText}`,
-        }
-      }
-
-      options.onProgress?.(`Marking ${fileName} as uploaded...`)
-
-      const statusUpdate: FileStatusUpdate = {
-        status: 'uploaded',
-      }
-
-      const updateResponse = await updateFile({
-        path: { graph_id: graphId, file_id: fileId },
-        body: statusUpdate,
-      })
-
-      if (updateResponse.error || !updateResponse.data) {
-        return {
-          fileId,
-          fileSize,
-          rowCount: 0,
-          tableName,
-          fileName,
-          success: false,
-          error: 'Failed to complete file upload',
-        }
-      }
-
-      const responseData = updateResponse.data as any
-      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: actualFileSize,
-        rowCount: actualRowCount,
-        tableName,
-        fileName,
-        success: true,
-      }
-    } catch (error) {
-      return {
-        fileId: '',
-        fileSize: 0,
-        rowCount: 0,
-        tableName,
-        fileName,
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      }
-    }
-  }
-
-  /**
-   * List files in a graph
-   */
-  async list(graphId: string, tableName?: string, status?: string): Promise<FileInfo[]> {
-    try {
-      const response = await listFiles({
-        path: { graph_id: graphId },
-        query: {
-          table_name: tableName,
-          status: status as any,
-        },
-      })
-
-      if (response.error || !response.data) {
-        console.error('Failed to list files:', response.error)
-        return []
-      }
-
-      const fileData = response.data as any
-
-      return (
-        fileData.files?.map((file: any) => ({
-          fileId: file.file_id,
-          fileName: file.file_name,
-          tableName: file.table_name,
-          status: file.status,
-          fileSize: file.file_size_bytes || 0,
-          rowCount: file.row_count || 0,
-          createdAt: file.created_at,
-        })) || []
-      )
-    } catch (error) {
-      console.error('Failed to list files:', error)
-      return []
-    }
-  }
-
-  /**
-   * Get file information
-   */
-  async get(graphId: string, fileId: string): Promise<FileInfo | null> {
-    try {
-      const response = await getFile({
-        path: { graph_id: graphId, file_id: fileId },
-      })
-
-      if (response.error || !response.data) {
-        console.error('Failed to get file:', response.error)
-        return null
-      }
-
-      const file = response.data as any
-
-      return {
-        fileId: file.file_id,
-        fileName: file.file_name,
-        tableName: file.table_name,
-        status: file.status,
-        fileSize: file.file_size_bytes || 0,
-        rowCount: file.row_count || 0,
-        createdAt: file.created_at,
-      }
-    } catch (error) {
-      console.error('Failed to get file:', error)
-      return null
-    }
-  }
-
-  /**
-   * Delete a file
-   */
-  async delete(graphId: string, fileId: string, cascade: boolean = false): Promise<boolean> {
-    try {
-      const response = await deleteFile({
-        path: { graph_id: graphId, file_id: fileId },
-        query: { cascade },
-      })
-
-      return !response.error
-    } catch (error) {
-      console.error('Failed to delete file:', error)
-      return false
-    }
-  }
-
-  private getFileName(fileOrBuffer: FileInput, override?: string): string {
-    if (override) return override
-
-    if ('name' in fileOrBuffer && typeof fileOrBuffer.name === 'string') {
-      return fileOrBuffer.name
-    }
-
-    return 'data.parquet'
-  }
-
-  private async getFileContent(fileOrBuffer: FileInput): Promise<ArrayBuffer> {
-    if (fileOrBuffer instanceof Blob || fileOrBuffer instanceof File) {
-      return fileOrBuffer.arrayBuffer()
-    }
-
-    if (Buffer.isBuffer(fileOrBuffer)) {
-      const buffer = fileOrBuffer.buffer.slice(
-        fileOrBuffer.byteOffset,
-        fileOrBuffer.byteOffset + fileOrBuffer.byteLength
-      )
-      // Convert SharedArrayBuffer to ArrayBuffer if needed
-      if (buffer instanceof ArrayBuffer) {
-        return buffer
-      }
-      // Handle SharedArrayBuffer by copying to ArrayBuffer
-      const arrayBuffer = new ArrayBuffer(buffer.byteLength)
-      new Uint8Array(arrayBuffer).set(new Uint8Array(buffer))
-      return arrayBuffer
-    }
-
-    if ('getReader' in fileOrBuffer) {
-      const reader = fileOrBuffer.getReader()
-      const chunks: Uint8Array[] = []
-
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        if (value) chunks.push(value)
-      }
-
-      const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0)
-      const result = new Uint8Array(totalLength)
-      let offset = 0
-      for (const chunk of chunks) {
-        result.set(chunk, offset)
-        offset += chunk.length
-      }
-      return result.buffer
-    }
-
-    throw new Error('Unsupported file input type')
-  }
-}

package/sdk-extensions/GraphClient.d.ts

@@ -1,91 +0,0 @@
-/**
- * Error thrown when a graph operation fails (as reported by the server)
- * This is distinct from connection/SSE errors
- */
-export declare class GraphOperationError extends Error {
-    constructor(message: string);
-}
-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 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
-     *
-     * 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
-     */
-    createGraphAndWait(metadata: GraphMetadataInput, initialEntity?: InitialEntityInput, options?: CreateGraphOptions): Promise<string>;
-    /**
-     * Wait for operation completion using SSE stream
-     */
-    private waitWithSSE;
-    /**
-     * Wait for operation completion using polling
-     */
-    private waitWithPolling;
-    /**
-     * 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/sdk-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/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;