@robosystems/client 0.2.43 → 0.2.45

package/sdk-extensions/MaterializationClient.ts

@@ -1,223 +0,0 @@
-'use client'
-
-/**
- * Materialization Client for RoboSystems API
- *
- * Manages graph materialization from DuckDB staging tables.
- * Submits materialization jobs to Dagster and monitors progress via SSE.
- */
-
-import { getMaterializationStatus, materializeGraph } from '../sdk/sdk.gen'
-import type { MaterializeRequest } from '../sdk/types.gen'
-import { OperationClient, type OperationResult } from './OperationClient'
-
-export interface MaterializationOptions {
-  ignoreErrors?: boolean
-  rebuild?: boolean
-  force?: boolean
-  timeout?: number // Default 10 minutes
-  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 class MaterializationClient {
-  private config: {
-    baseUrl: string
-    credentials?: 'include' | 'same-origin' | 'omit'
-    headers?: Record<string, string>
-    token?: string
-  }
-  private operationClient: OperationClient
-
-  constructor(config: {
-    baseUrl: string
-    credentials?: 'include' | 'same-origin' | 'omit'
-    headers?: Record<string, string>
-    token?: string
-  }) {
-    this.config = config
-    this.operationClient = new 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: string,
-    options: MaterializationOptions = {}
-  ): Promise<MaterializationResult> {
-    try {
-      options.onProgress?.('Submitting materialization job...')
-
-      const request: MaterializeRequest = {
-        ignore_errors: options.ignoreErrors ?? true,
-        rebuild: options.rebuild ?? false,
-        force: options.force ?? false,
-      }
-
-      const response = await 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 as { operation_id: string; message: string }
-      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
-   */
-  private convertOperationResult(
-    opResult: OperationResult,
-    options: MaterializationOptions
-  ): MaterializationResult {
-    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: string): Promise<MaterializationStatus | null> {
-    try {
-      const response = await 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 as any
-
-      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(): void {
-    this.operationClient.closeAll()
-  }
-}

package/sdk-extensions/TableClient.d.ts

@@ -1,38 +0,0 @@
-export interface TableInfo {
-    tableName: string;
-    rowCount: number;
-    fileCount: number;
-    totalSizeBytes: number;
-    s3Location?: string | null;
-}
-export interface TableQueryResult {
-    columns: string[];
-    rows: any[][];
-    rowCount: number;
-    executionTimeMs: number;
-    success: boolean;
-    error?: string;
-}
-export declare class TableClient {
-    private config;
-    constructor(config: {
-        baseUrl: string;
-        credentials?: 'include' | 'same-origin' | 'omit';
-        headers?: Record<string, string>;
-        token?: string;
-    });
-    /**
-     * List all DuckDB staging tables in a graph
-     */
-    list(graphId: string): Promise<TableInfo[]>;
-    /**
-     * Execute SQL query against DuckDB staging tables
-     *
-     * Example:
-     *   const result = await client.tables.query(
-     *     graphId,
-     *     "SELECT * FROM Entity WHERE entity_type = 'CORPORATION'"
-     *   )
-     */
-    query(graphId: string, sqlQuery: string, limit?: number): Promise<TableQueryResult>;
-}

package/sdk-extensions/TableClient.js

@@ -1,92 +0,0 @@
-'use client';
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableClient = void 0;
-/**
- * Table Client for RoboSystems API
- *
- * Manages DuckDB staging table operations.
- * Tables provide SQL-queryable staging layer before graph materialization.
- */
-const sdk_gen_1 = require("../sdk/sdk.gen");
-class TableClient {
-    constructor(config) {
-        this.config = config;
-    }
-    /**
-     * List all DuckDB staging tables in a graph
-     */
-    async list(graphId) {
-        try {
-            const response = await (0, sdk_gen_1.listTables)({
-                path: { graph_id: graphId },
-            });
-            if (response.error || !response.data) {
-                console.error('Failed to list tables:', response.error);
-                return [];
-            }
-            const tableData = response.data;
-            return (tableData.tables?.map((table) => ({
-                tableName: table.table_name,
-                rowCount: table.row_count,
-                fileCount: table.file_count || 0,
-                totalSizeBytes: table.total_size_bytes || 0,
-                s3Location: table.s3_location,
-            })) || []);
-        }
-        catch (error) {
-            console.error('Failed to list tables:', error);
-            return [];
-        }
-    }
-    /**
-     * Execute SQL query against DuckDB staging tables
-     *
-     * Example:
-     *   const result = await client.tables.query(
-     *     graphId,
-     *     "SELECT * FROM Entity WHERE entity_type = 'CORPORATION'"
-     *   )
-     */
-    async query(graphId, sqlQuery, limit) {
-        try {
-            const finalQuery = limit !== undefined ? `${sqlQuery.replace(/;?\s*$/, '')} LIMIT ${limit}` : sqlQuery;
-            const request = {
-                sql: finalQuery,
-            };
-            const response = await (0, sdk_gen_1.queryTables)({
-                path: { graph_id: graphId },
-                body: request,
-            });
-            if (response.error || !response.data) {
-                return {
-                    columns: [],
-                    rows: [],
-                    rowCount: 0,
-                    executionTimeMs: 0,
-                    success: false,
-                    error: `Query failed: ${response.error}`,
-                };
-            }
-            const result = response.data;
-            return {
-                columns: result.columns || [],
-                rows: result.rows || [],
-                rowCount: result.rows?.length || 0,
-                executionTimeMs: result.execution_time_ms || 0,
-                success: true,
-            };
-        }
-        catch (error) {
-            return {
-                columns: [],
-                rows: [],
-                rowCount: 0,
-                executionTimeMs: 0,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-}
-exports.TableClient = TableClient;

package/sdk-extensions/TableClient.ts

@@ -1,132 +0,0 @@
-'use client'
-
-/**
- * Table Client for RoboSystems API
- *
- * Manages DuckDB staging table operations.
- * Tables provide SQL-queryable staging layer before graph materialization.
- */
-
-import { listTables, queryTables } from '../sdk/sdk.gen'
-import type { TableListResponse, TableQueryRequest } from '../sdk/types.gen'
-
-export interface TableInfo {
-  tableName: string
-  rowCount: number
-  fileCount: number
-  totalSizeBytes: number
-  s3Location?: string | null
-}
-
-export interface TableQueryResult {
-  columns: string[]
-  rows: any[][]
-  rowCount: number
-  executionTimeMs: number
-  success: boolean
-  error?: string
-}
-
-export class TableClient {
-  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
-  }
-
-  /**
-   * List all DuckDB staging tables in a graph
-   */
-  async list(graphId: string): Promise<TableInfo[]> {
-    try {
-      const response = await listTables({
-        path: { graph_id: graphId },
-      })
-
-      if (response.error || !response.data) {
-        console.error('Failed to list tables:', response.error)
-        return []
-      }
-
-      const tableData = response.data as TableListResponse
-
-      return (
-        tableData.tables?.map((table) => ({
-          tableName: table.table_name,
-          rowCount: table.row_count,
-          fileCount: table.file_count || 0,
-          totalSizeBytes: table.total_size_bytes || 0,
-          s3Location: table.s3_location,
-        })) || []
-      )
-    } catch (error) {
-      console.error('Failed to list tables:', error)
-      return []
-    }
-  }
-
-  /**
-   * Execute SQL query against DuckDB staging tables
-   *
-   * Example:
-   *   const result = await client.tables.query(
-   *     graphId,
-   *     "SELECT * FROM Entity WHERE entity_type = 'CORPORATION'"
-   *   )
-   */
-  async query(graphId: string, sqlQuery: string, limit?: number): Promise<TableQueryResult> {
-    try {
-      const finalQuery =
-        limit !== undefined ? `${sqlQuery.replace(/;?\s*$/, '')} LIMIT ${limit}` : sqlQuery
-
-      const request: TableQueryRequest = {
-        sql: finalQuery,
-      }
-
-      const response = await queryTables({
-        path: { graph_id: graphId },
-        body: request,
-      })
-
-      if (response.error || !response.data) {
-        return {
-          columns: [],
-          rows: [],
-          rowCount: 0,
-          executionTimeMs: 0,
-          success: false,
-          error: `Query failed: ${response.error}`,
-        }
-      }
-
-      const result = response.data as any
-
-      return {
-        columns: result.columns || [],
-        rows: result.rows || [],
-        rowCount: result.rows?.length || 0,
-        executionTimeMs: result.execution_time_ms || 0,
-        success: true,
-      }
-    } catch (error) {
-      return {
-        columns: [],
-        rows: [],
-        rowCount: 0,
-        executionTimeMs: 0,
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      }
-    }
-  }
-}