@robosystems/core 0.3.0

package/task-monitoring/operationMonitor.js

@@ -0,0 +1,200 @@
+/**
+ * Operation Monitor - SSE-based monitoring for unified backend operations
+ * Replaces the polling-based TaskMonitor with EventSource streaming
+ *
+ * Uses SDK extensions when available (@robosystems/client v0.1.21+)
+ * No fallback - fails fast if SDK extensions not available
+ */
+import { client } from '@robosystems/client';
+// Import SDK extensions - check at runtime
+const getSDKExtensions = async () => {
+    try {
+        return await import('@robosystems/client/clients');
+    }
+    catch (error) {
+        console.error('SDK extensions not available:', error);
+        return null;
+    }
+};
+export class OperationMonitor {
+    constructor() {
+        this.activeOperations = new Map();
+        this.operationResults = new Map();
+    }
+    static getInstance() {
+        if (!OperationMonitor.instance) {
+            OperationMonitor.instance = new OperationMonitor();
+        }
+        return OperationMonitor.instance;
+    }
+    /**
+     * Monitor an operation using SSE streaming
+     */
+    async monitorOperation({ operationId, onProgress, onComplete, onError, onEvent, timeout = 300000, // 5 minutes default
+     }) {
+        // Get SDK extensions at runtime
+        const sdkExtensions = await getSDKExtensions();
+        // Require SDK extensions - fail fast if not available
+        if (!(sdkExtensions === null || sdkExtensions === void 0 ? void 0 : sdkExtensions.OperationClient)) {
+            throw new Error('SDK extensions not available. Please install @robosystems/client with extensions support.');
+        }
+        return this.monitorWithSDKExtensions({
+            operationId,
+            onProgress,
+            onComplete,
+            onError,
+            onEvent,
+            timeout,
+        }, sdkExtensions);
+    }
+    /**
+     * Cancel operation monitoring (does not cancel the operation itself)
+     */
+    cancelOperation(operationId) {
+        try {
+            const eventSource = this.activeOperations.get(operationId);
+            if (eventSource) {
+                eventSource.close();
+                this.activeOperations.delete(operationId);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('Failed to cancel operation:', error);
+            return false;
+        }
+    }
+    /**
+     * Get cached operation status/result
+     */
+    getOperationStatus(operationId) {
+        if (this.operationResults.has(operationId)) {
+            return this.operationResults.get(operationId);
+        }
+        try {
+            const config = client.getConfig();
+            const baseUrl = config.baseUrl || 'http://localhost:8000';
+            // This would need to be implemented as a sync call or return cached data only
+            // For now, just return cached results
+            return null;
+        }
+        catch (error) {
+            console.error('Failed to get operation status:', error);
+            return null;
+        }
+    }
+    /**
+     * Clean up operation monitoring resources
+     */
+    cleanupOperation(operationId) {
+        const eventSource = this.activeOperations.get(operationId);
+        if (eventSource) {
+            eventSource.close();
+            this.activeOperations.delete(operationId);
+        }
+    }
+    /**
+     * Monitor operation using SDK extensions
+     */
+    async monitorWithSDKExtensions(options, sdkExtensions) {
+        var _a, _b, _c;
+        const { OperationClient, extractTokenFromSDKClient } = sdkExtensions;
+        const { getToken } = await import('../auth-core/token-storage');
+        const config = client.getConfig();
+        const jwtToken = getToken() || extractTokenFromSDKClient();
+        // Create operation client with proper configuration
+        const operationClient = new OperationClient({
+            baseUrl: config.baseUrl || 'http://localhost:8000',
+            credentials: 'include',
+            token: jwtToken,
+            maxRetries: 3,
+            retryDelay: 1000,
+        });
+        try {
+            const result = await operationClient.monitorOperation(options.operationId, {
+                onProgress: (progress) => {
+                    var _a, _b, _c, _d;
+                    (_a = options.onProgress) === null || _a === void 0 ? void 0 : _a.call(options, {
+                        percent: progress.progressPercent || 0,
+                        message: progress.message || '',
+                        current_step: (_c = (_b = progress.details) === null || _b === void 0 ? void 0 : _b.current_step) === null || _c === void 0 ? void 0 : _c.toString(),
+                        total_steps: (_d = progress.details) === null || _d === void 0 ? void 0 : _d.total_steps,
+                    });
+                },
+                onEvent: (event) => {
+                    var _a;
+                    (_a = options.onEvent) === null || _a === void 0 ? void 0 : _a.call(options, {
+                        event: event.type,
+                        data: event.data,
+                    });
+                },
+                timeout: options.timeout,
+            });
+            // Map OperationResult (success: boolean) to status string
+            const status = result.success
+                ? 'completed'
+                : result.error === 'Operation cancelled'
+                    ? 'cancelled'
+                    : 'failed';
+            // Normalize to documented shape
+            const normalizedResult = {
+                operation_id: options.operationId,
+                status,
+                result: result.result,
+                error: result.error,
+            };
+            // Store normalized result in cache
+            this.operationResults.set(options.operationId, normalizedResult);
+            // Handle different success/failure states properly
+            if (status === 'completed') {
+                (_a = options.onComplete) === null || _a === void 0 ? void 0 : _a.call(options, result.result || {});
+            }
+            else if (status === 'failed') {
+                (_b = options.onError) === null || _b === void 0 ? void 0 : _b.call(options, result.error || 'Operation failed');
+            }
+            else if (status === 'cancelled') {
+                (_c = options.onError) === null || _c === void 0 ? void 0 : _c.call(options, result.error || 'Operation cancelled');
+            }
+            return normalizedResult;
+        }
+        finally {
+            operationClient.closeAll();
+        }
+    }
+    /**
+     * Clean up all active operations
+     */
+    cleanup() {
+        for (const [, eventSource] of this.activeOperations.entries()) {
+            eventSource.close();
+        }
+        this.activeOperations.clear();
+    }
+    /**
+     * Get list of active operation IDs
+     */
+    getActiveOperations() {
+        return Array.from(this.activeOperations.keys());
+    }
+    /**
+     * Clear operation results cache
+     */
+    clearCache() {
+        this.operationResults.clear();
+    }
+}
+// Export singleton instance and convenience functions
+export const operationMonitor = OperationMonitor.getInstance();
+export const monitorOperation = (options) => {
+    return operationMonitor.monitorOperation(options);
+};
+export const cancelOperation = (operationId) => {
+    return operationMonitor.cancelOperation(operationId);
+};
+export const getOperationStatus = (operationId) => {
+    return operationMonitor.getOperationStatus(operationId);
+};
+export const getActiveOperations = () => {
+    return operationMonitor.getActiveOperations();
+};

package/task-monitoring/operationTypes.d.ts

@@ -0,0 +1,236 @@
+/**
+ * TypeScript types for the unified SSE operation system
+ */
+export interface Operation {
+    operation_id: string;
+    status: OperationStatus;
+    created_at: string;
+    updated_at?: string;
+    completed_at?: string;
+    error?: string;
+    result?: any;
+    metadata?: OperationMetadata;
+}
+export type OperationStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface OperationMetadata {
+    operation_type: string;
+    graph_id?: string;
+    user_id?: string;
+    request_id?: string;
+    duration_ms?: number;
+    credits_used?: number;
+}
+export interface SSEEvent<T = any> {
+    event: string;
+    data: T;
+    id?: string;
+    retry?: number;
+}
+export interface OperationStartedEvent {
+    operation_id: string;
+    operation_type: string;
+    message?: string;
+    timestamp: string;
+}
+export interface OperationProgressEvent {
+    operation_id: string;
+    progress_percent: number;
+    message: string;
+    current_step?: number;
+    total_steps?: number;
+    timestamp: string;
+}
+export interface OperationCompletedEvent {
+    operation_id: string;
+    result: any;
+    duration_ms: number;
+    credits_used?: number;
+    timestamp: string;
+}
+export interface OperationErrorEvent {
+    operation_id: string;
+    error: string;
+    code?: string;
+    details?: any;
+    timestamp: string;
+}
+export interface OperationCancelledEvent {
+    operation_id: string;
+    reason?: string;
+    timestamp: string;
+}
+export interface CreateGraphRequest {
+    graph_type: 'generic' | 'company';
+    graph_name: string;
+    description?: string;
+    company_name?: string;
+    company_identifier?: string;
+    company_identifier_type?: 'ein' | 'name';
+    metadata?: Record<string, any>;
+}
+export interface CreateGraphResponse {
+    graph_id: string;
+    graph_type: 'generic' | 'company';
+    status: 'created' | 'pending';
+    operation_id?: string;
+    created_at: string;
+    metadata?: Record<string, any>;
+}
+export interface ExecuteQueryRequest {
+    query: string;
+    parameters?: Record<string, any>;
+    mode?: 'auto' | 'sync' | 'async' | 'stream';
+    chunk_size?: number;
+    timeout?: number;
+    test_mode?: boolean;
+}
+export interface ExecuteQueryResponse {
+    data?: any[];
+    columns?: string[];
+    row_count?: number;
+    execution_time_ms?: number;
+    status?: 'queued';
+    operation_id?: string;
+    queue_position?: number;
+    estimated_wait_seconds?: number;
+}
+export interface QueryChunkEvent {
+    chunk_number: number;
+    total_chunks?: number;
+    rows: any[];
+    columns?: string[];
+    has_more: boolean;
+}
+export interface DataImportRequest {
+    graph_id: string;
+    source_type: 'csv' | 'json' | 'parquet' | 's3';
+    source_uri: string;
+    target_table: string;
+    mapping?: Record<string, string>;
+    options?: DataImportOptions;
+}
+export interface DataImportOptions {
+    batch_size?: number;
+    skip_errors?: boolean;
+    validate?: boolean;
+    transform?: string;
+}
+export interface DataImportResponse {
+    operation_id: string;
+    status: 'started' | 'queued';
+    estimated_rows?: number;
+    estimated_duration_ms?: number;
+}
+export interface DataImportProgressEvent {
+    operation_id: string;
+    rows_processed: number;
+    total_rows: number;
+    errors_count: number;
+    progress_percent: number;
+    current_batch?: number;
+    total_batches?: number;
+}
+export interface BackupRequest {
+    graph_id: string;
+    backup_type: 'full' | 'incremental';
+    destination?: string;
+    include_metadata?: boolean;
+}
+export interface BackupResponse {
+    operation_id: string;
+    backup_id?: string;
+    status: 'started' | 'queued';
+    estimated_size_mb?: number;
+}
+export interface RestoreRequest {
+    backup_id: string;
+    target_graph_id?: string;
+    restore_type: 'full' | 'schema_only' | 'data_only';
+}
+export interface RestoreResponse {
+    operation_id: string;
+    status: 'started' | 'queued';
+    new_graph_id?: string;
+}
+export interface GetOperationStatusRequest {
+    operation_id: string;
+}
+export interface GetOperationStatusResponse {
+    operation: Operation;
+    events?: OperationEvent[];
+}
+export interface CancelOperationRequest {
+    operation_id: string;
+    reason?: string;
+}
+export interface CancelOperationResponse {
+    success: boolean;
+    message?: string;
+}
+export interface ListOperationsRequest {
+    graph_id?: string;
+    status?: OperationStatus;
+    operation_type?: string;
+    limit?: number;
+    offset?: number;
+    since?: string;
+}
+export interface ListOperationsResponse {
+    operations: Operation[];
+    total_count: number;
+    has_more: boolean;
+}
+export type OperationEvent = {
+    type: 'started';
+    data: OperationStartedEvent;
+} | {
+    type: 'progress';
+    data: OperationProgressEvent;
+} | {
+    type: 'completed';
+    data: OperationCompletedEvent;
+} | {
+    type: 'error';
+    data: OperationErrorEvent;
+} | {
+    type: 'cancelled';
+    data: OperationCancelledEvent;
+} | {
+    type: 'query_chunk';
+    data: QueryChunkEvent;
+} | {
+    type: 'import_progress';
+    data: DataImportProgressEvent;
+};
+export declare function isOperationStarted(event: OperationEvent): event is {
+    type: 'started';
+    data: OperationStartedEvent;
+};
+export declare function isOperationProgress(event: OperationEvent): event is {
+    type: 'progress';
+    data: OperationProgressEvent;
+};
+export declare function isOperationCompleted(event: OperationEvent): event is {
+    type: 'completed';
+    data: OperationCompletedEvent;
+};
+export declare function isOperationError(event: OperationEvent): event is {
+    type: 'error';
+    data: OperationErrorEvent;
+};
+export declare function isOperationCancelled(event: OperationEvent): event is {
+    type: 'cancelled';
+    data: OperationCancelledEvent;
+};
+export declare function isQueryChunk(event: OperationEvent): event is {
+    type: 'query_chunk';
+    data: QueryChunkEvent;
+};
+export declare function isImportProgress(event: OperationEvent): event is {
+    type: 'import_progress';
+    data: DataImportProgressEvent;
+};
+export declare function isOperationActive(status: OperationStatus): boolean;
+export declare function isOperationTerminal(status: OperationStatus): boolean;
+export declare function getOperationDuration(operation: Operation): number | null;
+export declare function formatOperationStatus(status: OperationStatus): string;

package/task-monitoring/operationTypes.js

@@ -0,0 +1,60 @@
+/**
+ * TypeScript types for the unified SSE operation system
+ */
+// ============================================
+// Helper Type Guards
+// ============================================
+export function isOperationStarted(event) {
+    return event.type === 'started';
+}
+export function isOperationProgress(event) {
+    return event.type === 'progress';
+}
+export function isOperationCompleted(event) {
+    return event.type === 'completed';
+}
+export function isOperationError(event) {
+    return event.type === 'error';
+}
+export function isOperationCancelled(event) {
+    return event.type === 'cancelled';
+}
+export function isQueryChunk(event) {
+    return event.type === 'query_chunk';
+}
+export function isImportProgress(event) {
+    return event.type === 'import_progress';
+}
+// ============================================
+// Utility Functions
+// ============================================
+export function isOperationActive(status) {
+    return status === 'pending' || status === 'running';
+}
+export function isOperationTerminal(status) {
+    return status === 'completed' || status === 'failed' || status === 'cancelled';
+}
+export function getOperationDuration(operation) {
+    if (!operation.created_at || !operation.completed_at) {
+        return null;
+    }
+    const start = new Date(operation.created_at).getTime();
+    const end = new Date(operation.completed_at).getTime();
+    return end - start;
+}
+export function formatOperationStatus(status) {
+    switch (status) {
+        case 'pending':
+            return 'Pending';
+        case 'running':
+            return 'Running';
+        case 'completed':
+            return 'Completed';
+        case 'failed':
+            return 'Failed';
+        case 'cancelled':
+            return 'Cancelled';
+        default:
+            return 'Unknown';
+    }
+}

package/task-monitoring/taskMonitor.d.ts

@@ -0,0 +1,14 @@
+import type { TaskPollingOptions, TaskStatusResponse } from './types';
+export declare class TaskMonitor {
+    private static instance;
+    private activeTasks;
+    static getInstance(): TaskMonitor;
+    pollTask({ taskId, onProgress, onComplete, onError, pollInterval, maxAttempts, }: TaskPollingOptions): Promise<TaskStatusResponse>;
+    cancelTask(taskId: string): Promise<boolean>;
+    cancelAllTasks(): void;
+    getActiveTasks(): string[];
+}
+export declare const taskMonitor: TaskMonitor;
+export declare const pollTaskStatus: (options: TaskPollingOptions) => Promise<TaskStatusResponse>;
+export declare const cancelTask: (taskId: string) => Promise<boolean>;
+export declare const getActiveTasks: () => string[];

package/task-monitoring/taskMonitor.js

@@ -0,0 +1,132 @@
+import * as SDK from '@robosystems/client';
+export class TaskMonitor {
+    constructor() {
+        this.activeTasks = new Map();
+    }
+    static getInstance() {
+        if (!TaskMonitor.instance) {
+            TaskMonitor.instance = new TaskMonitor();
+        }
+        return TaskMonitor.instance;
+    }
+    async pollTask({ taskId, onProgress, onComplete, onError, pollInterval = 2000, maxAttempts = 150, // 5 minutes at 2s intervals
+     }) {
+        let attempts = 0;
+        const abortController = new AbortController();
+        this.activeTasks.set(taskId, abortController);
+        return new Promise((resolve, reject) => {
+            const poll = async () => {
+                try {
+                    if (abortController.signal.aborted) {
+                        this.activeTasks.delete(taskId);
+                        reject(new Error('Task polling was cancelled'));
+                        return;
+                    }
+                    attempts++;
+                    const response = await SDK.getOperationStatus({
+                        path: { operation_id: taskId },
+                    });
+                    if (!response.data) {
+                        throw new Error('No data received from task status endpoint');
+                    }
+                    const status = response.data;
+                    switch (status.status) {
+                        case 'pending':
+                        case 'in_progress':
+                        case 'retrying':
+                            onProgress === null || onProgress === void 0 ? void 0 : onProgress(status);
+                            if (attempts < maxAttempts && !abortController.signal.aborted) {
+                                setTimeout(poll, pollInterval);
+                            }
+                            else if (attempts >= maxAttempts) {
+                                this.activeTasks.delete(taskId);
+                                const timeoutError = new Error(`Task polling timeout after ${attempts} attempts`);
+                                onError === null || onError === void 0 ? void 0 : onError(timeoutError.message);
+                                reject(timeoutError);
+                            }
+                            break;
+                        case 'completed':
+                            this.activeTasks.delete(taskId);
+                            onComplete === null || onComplete === void 0 ? void 0 : onComplete(status.details || status);
+                            resolve(status);
+                            break;
+                        case 'failed': {
+                            this.activeTasks.delete(taskId);
+                            const failureError = new Error(status.message || 'Task failed without error message');
+                            onError === null || onError === void 0 ? void 0 : onError(failureError.message);
+                            reject(failureError);
+                            break;
+                        }
+                        case 'cancelled': {
+                            this.activeTasks.delete(taskId);
+                            const cancelError = new Error('Task was cancelled');
+                            onError === null || onError === void 0 ? void 0 : onError(cancelError.message);
+                            reject(cancelError);
+                            break;
+                        }
+                        default:
+                            // Handle unknown status as in_progress
+                            onProgress === null || onProgress === void 0 ? void 0 : onProgress(status);
+                            if (attempts < maxAttempts && !abortController.signal.aborted) {
+                                setTimeout(poll, pollInterval);
+                            }
+                            else if (attempts >= maxAttempts) {
+                                this.activeTasks.delete(taskId);
+                                const unknownError = new Error(`Unknown task status: ${status.status}`);
+                                onError === null || onError === void 0 ? void 0 : onError(unknownError.message);
+                                reject(unknownError);
+                            }
+                    }
+                }
+                catch (error) {
+                    this.activeTasks.delete(taskId);
+                    const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+                    console.error('Task polling error:', error);
+                    onError === null || onError === void 0 ? void 0 : onError(errorMessage);
+                    reject(error);
+                }
+            };
+            // Start polling
+            poll();
+        });
+    }
+    async cancelTask(taskId) {
+        try {
+            // Cancel local polling
+            const abortController = this.activeTasks.get(taskId);
+            if (abortController) {
+                abortController.abort();
+                this.activeTasks.delete(taskId);
+            }
+            // Cancel task on server
+            await SDK.cancelOperation({
+                path: { operation_id: taskId },
+            });
+            return true;
+        }
+        catch (error) {
+            console.error('Failed to cancel task:', error);
+            return false;
+        }
+    }
+    cancelAllTasks() {
+        for (const [, abortController] of this.activeTasks.entries()) {
+            abortController.abort();
+        }
+        this.activeTasks.clear();
+    }
+    getActiveTasks() {
+        return Array.from(this.activeTasks.keys());
+    }
+}
+// Utility functions for easier usage
+export const taskMonitor = TaskMonitor.getInstance();
+export const pollTaskStatus = (options) => {
+    return taskMonitor.pollTask(options);
+};
+export const cancelTask = (taskId) => {
+    return taskMonitor.cancelTask(taskId);
+};
+export const getActiveTasks = () => {
+    return taskMonitor.getActiveTasks();
+};

package/task-monitoring/types.d.ts

@@ -0,0 +1,31 @@
+export interface TaskStatusResponse {
+    status: TaskStatus;
+    progress?: number;
+    step?: string;
+    message?: string;
+    details?: any;
+    result?: any;
+    error?: string;
+}
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled' | 'retrying';
+export interface TaskPollingOptions {
+    taskId: string;
+    onProgress?: (status: TaskStatusResponse) => void;
+    onComplete?: (result: any) => void;
+    onError?: (error: string) => void;
+    pollInterval?: number;
+    maxAttempts?: number;
+}
+export interface TaskMonitorState {
+    isLoading: boolean;
+    progress: number | null;
+    currentStep: string | null;
+    error: string | null;
+    taskId: string | null;
+    result: any | null;
+}
+export interface TaskCreateResponse {
+    task_id: string;
+    status: TaskStatus;
+    message?: string;
+}

package/task-monitoring/types.js

@@ -0,0 +1 @@
+export {};