@robosystems/core 0.3.0

package/task-monitoring/operationHooks.js

@@ -0,0 +1,536 @@
+'use client';
+import { changeSubscriptionPlan, client, createCheckoutSession, createGraph as createGraphAPI, createRepositorySubscription, getOrgBillingCustomer, } from '@robosystems/client';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { operationMonitor } from './operationMonitor';
+/**
+ * Hook for monitoring operations using SSE
+ */
+export function useOperationMonitoring() {
+    const [state, setState] = useState({
+        isLoading: false,
+        isMonitoring: false, // Alias for isLoading
+        progress: null,
+        currentStep: null,
+        error: null,
+        operationId: null,
+        result: null,
+        status: null,
+    });
+    const currentOperationId = useRef(null);
+    const reset = useCallback(() => {
+        setState({
+            isLoading: false,
+            isMonitoring: false, // Alias for isLoading
+            progress: null,
+            currentStep: null,
+            error: null,
+            operationId: null,
+            result: null,
+            status: null,
+        });
+        currentOperationId.current = null;
+    }, []);
+    const cancelOperation = useCallback(async () => {
+        if (currentOperationId.current) {
+            try {
+                await operationMonitor.cancelOperation(currentOperationId.current);
+                setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, isMonitoring: false, status: 'cancelled', error: 'Operation was cancelled', result: null })));
+            }
+            catch (error) {
+                console.error('Failed to cancel operation:', error);
+                setState((prev) => (Object.assign(Object.assign({}, prev), { error: 'Failed to cancel operation', result: null })));
+            }
+        }
+    }, []);
+    const startMonitoring = useCallback(async (operationId, options) => {
+        currentOperationId.current = operationId;
+        setState({
+            isLoading: true,
+            isMonitoring: true,
+            progress: 0,
+            currentStep: 'Starting...',
+            error: null,
+            operationId,
+            result: null,
+            status: 'pending',
+        });
+        try {
+            const result = await operationMonitor.monitorOperation({
+                operationId,
+                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+                onProgress: (progress) => {
+                    setState((prev) => (Object.assign(Object.assign({}, prev), { progress: progress.percent, currentStep: progress.message, status: 'running' })));
+                },
+                onComplete: (result) => {
+                    setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, isMonitoring: false, progress: 100, currentStep: 'Completed', result: result, status: 'completed' })));
+                },
+                onError: (errorMsg) => {
+                    setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, isMonitoring: false, error: errorMsg, result: null, status: 'failed' })));
+                },
+            });
+            return result.result || result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, isMonitoring: false, error: errorMessage, result: null, status: 'failed' })));
+            throw error;
+        }
+        finally {
+            currentOperationId.current = null;
+        }
+    }, []);
+    // Cleanup on unmount
+    useEffect(() => {
+        return () => {
+            if (currentOperationId.current) {
+                operationMonitor.cancelOperation(currentOperationId.current);
+            }
+        };
+    }, []);
+    return Object.assign(Object.assign({}, state), { startMonitoring,
+        cancelOperation, cancelMonitoring: cancelOperation, // Alias for consistency
+        reset });
+}
+/**
+ * Hook for graph creation using the new unified endpoint
+ */
+export function useGraphCreation() {
+    const operationMonitoring = useOperationMonitoring();
+    const [isCreating, setIsCreating] = useState(false);
+    const createGraph = useCallback(async (graphData) => {
+        var _a, _b, _c;
+        setIsCreating(true);
+        try {
+            // Check if billing is enabled and user needs to complete checkout
+            let billingData = null;
+            if (graphData.org_id) {
+                const billingResponse = await getOrgBillingCustomer({
+                    client,
+                    path: { org_id: graphData.org_id },
+                });
+                // Only set billingData if we got a successful response
+                // If billing disabled, getOrgBillingCustomer will return 404 and we skip checkout
+                if (!billingResponse.error) {
+                    billingData = billingResponse.data;
+                }
+            }
+            if (billingData &&
+                !billingData.has_payment_method &&
+                !billingData.invoice_billing_enabled) {
+                // User needs to add payment method - create checkout session
+                const checkoutResponse = await createCheckoutSession({
+                    client,
+                    body: {
+                        resource_type: 'graph',
+                        plan_name: graphData.instance_tier || 'ladybug-standard',
+                        resource_config: {
+                            graph_type: graphData.graph_type,
+                            graph_name: graphData.graph_name,
+                            description: graphData.description,
+                            tags: graphData.tags,
+                            schema_extensions: graphData.schema_extensions,
+                            create_entity: graphData.create_entity,
+                            entity_name: graphData.entity_name,
+                            entity_identifier: graphData.entity_identifier,
+                            entity_identifier_type: graphData.entity_identifier_type,
+                            company_name: graphData.company_name,
+                            company_identifier: graphData.company_identifier,
+                            company_identifier_type: graphData.company_identifier_type,
+                        },
+                    },
+                });
+                if (checkoutResponse.error) {
+                    const errorMsg = typeof checkoutResponse.error === 'object' &&
+                        'detail' in checkoutResponse.error
+                        ? String(checkoutResponse.error.detail)
+                        : 'Failed to create checkout session';
+                    throw new Error(errorMsg);
+                }
+                // Check if billing is disabled on the backend
+                // @ts-ignore - billing_disabled field will be in next SDK release
+                if ((_a = checkoutResponse.data) === null || _a === void 0 ? void 0 : _a.billing_disabled) {
+                    // Billing disabled - proceed with normal graph creation without payment
+                    // Fall through to the graph creation logic below
+                }
+                else if ((_b = checkoutResponse.data) === null || _b === void 0 ? void 0 : _b.checkout_url) {
+                    // Redirect to Stripe checkout (leave isCreating=true since we're redirecting)
+                    window.location.href = checkoutResponse.data.checkout_url;
+                    // Return a pending state to prevent further processing
+                    return {
+                        requires_checkout: true,
+                        checkout_url: checkoutResponse.data.checkout_url,
+                        session_id: checkoutResponse.data.session_id,
+                        subscription_id: checkoutResponse.data.subscription_id,
+                    };
+                }
+            }
+            // User has payment method or invoice billing - proceed with normal graph creation
+            // Prepare the request in the correct format for CreateGraphRequest
+            const requestBody = {
+                metadata: {
+                    graph_name: graphData.graph_name,
+                    description: graphData.description,
+                    tags: graphData.tags,
+                    schema_extensions: graphData.schema_extensions || [],
+                },
+                instance_tier: graphData.instance_tier || 'ladybug-standard',
+                create_entity: graphData.graph_type === 'generic'
+                    ? false
+                    : ((_c = graphData.create_entity) !== null && _c !== void 0 ? _c : true),
+            };
+            // Add initial_entity for entity or company graphs
+            if (graphData.graph_type === 'entity' && graphData.entity_name) {
+                requestBody.initial_entity = {
+                    name: graphData.entity_name,
+                    uri: graphData.entity_name.toLowerCase().replace(/\s+/g, '-'),
+                    ein: graphData.entity_identifier_type === 'ein'
+                        ? graphData.entity_identifier
+                        : undefined,
+                };
+            }
+            else if (graphData.graph_type === 'company' &&
+                graphData.company_name) {
+                // Legacy support for company type
+                requestBody.initial_entity = {
+                    name: graphData.company_name,
+                    uri: graphData.company_name.toLowerCase().replace(/\s+/g, '-'),
+                    ein: graphData.company_identifier_type === 'ein'
+                        ? graphData.company_identifier
+                        : undefined,
+                };
+            }
+            // Call the new unified graph creation endpoint
+            const response = await createGraphAPI({
+                client,
+                body: requestBody,
+            });
+            // Check for error in response
+            const apiError = response.error;
+            if (apiError) {
+                setIsCreating(false);
+                // Format validation error message
+                let errorMessage = 'Graph creation failed';
+                if (Array.isArray(apiError.detail)) {
+                    errorMessage = apiError.detail
+                        .map((err) => {
+                        var _a;
+                        if (typeof err === 'string')
+                            return err;
+                        if (err.msg)
+                            return `${((_a = err.loc) === null || _a === void 0 ? void 0 : _a.join('.')) || 'field'}: ${err.msg}`;
+                        return JSON.stringify(err);
+                    })
+                        .join(', ');
+                }
+                else if (typeof apiError.detail === 'string') {
+                    errorMessage = apiError.detail;
+                }
+                else if (apiError.message) {
+                    errorMessage = apiError.message;
+                }
+                throw new Error(errorMessage);
+            }
+            // Check if response contains operation_id (async) or direct result
+            const responseData = response.data;
+            if (responseData === null || responseData === void 0 ? void 0 : responseData.operationId) {
+                // Async operation - monitor it
+                const result = await operationMonitoring.startMonitoring(responseData.operationId);
+                setIsCreating(false);
+                return result;
+            }
+            else if ((responseData === null || responseData === void 0 ? void 0 : responseData.graph_id) || (responseData === null || responseData === void 0 ? void 0 : responseData.graphId)) {
+                // Synchronous result - return directly
+                // Handle both snake_case and camelCase, normalize initial_entity
+                setIsCreating(false);
+                return Object.assign({ graph_id: responseData.graph_id || responseData.graphId, initial_entity: responseData.initial_entity || responseData.initialEntity }, responseData);
+            }
+            else {
+                setIsCreating(false);
+                throw new Error('Invalid response from graph creation');
+            }
+        }
+        catch (error) {
+            setIsCreating(false);
+            throw error;
+        }
+    }, [operationMonitoring]);
+    const createEntityGraph = useCallback(async (entityData) => {
+        return createGraph({
+            graph_type: 'entity',
+            graph_name: entityData.entity_name,
+            entity_name: entityData.entity_name,
+            entity_identifier: entityData.entity_identifier,
+            entity_identifier_type: entityData.entity_identifier_type,
+            instance_tier: entityData.instance_tier,
+            schema_extensions: entityData.schema_extensions,
+            create_entity: entityData.create_entity,
+            description: entityData.description,
+            tags: entityData.tags,
+            org_id: entityData.org_id,
+        });
+    }, [createGraph]);
+    const createGenericGraph = useCallback(async (graphData) => {
+        return createGraph(Object.assign({ graph_type: 'generic' }, graphData));
+    }, [createGraph]);
+    return Object.assign(Object.assign({}, operationMonitoring), { isLoading: isCreating || operationMonitoring.isLoading, createGraph,
+        createEntityGraph,
+        createGenericGraph });
+}
+/**
+ * Hook for creating repository subscriptions with billing integration
+ * Mirrors the graph creation pattern for consistency
+ */
+export function useRepositorySubscription() {
+    const [isSubscribing, setIsSubscribing] = useState(false);
+    const subscribe = useCallback(async (subscriptionData) => {
+        var _a, _b;
+        setIsSubscribing(true);
+        try {
+            // Check if billing is enabled and user needs to complete checkout
+            const billingResponse = await getOrgBillingCustomer({
+                client,
+                path: { org_id: subscriptionData.org_id },
+            });
+            const billingData = billingResponse.data;
+            // Only check payment if billing is enabled (response exists without error)
+            // If billing disabled, getOrgBillingCustomer will return 404 and we skip checkout
+            if (!billingResponse.error &&
+                billingData &&
+                !billingData.has_payment_method &&
+                !billingData.invoice_billing_enabled) {
+                // User needs to add payment method - create checkout session
+                const checkoutResponse = await createCheckoutSession({
+                    client,
+                    body: {
+                        resource_type: 'repository',
+                        plan_name: subscriptionData.plan_name,
+                        resource_config: {
+                            repository_name: subscriptionData.repository_name,
+                        },
+                    },
+                });
+                if (checkoutResponse.error) {
+                    const errorMsg = typeof checkoutResponse.error === 'object' &&
+                        'detail' in checkoutResponse.error
+                        ? String(checkoutResponse.error.detail)
+                        : 'Failed to create checkout session';
+                    throw new Error(errorMsg);
+                }
+                // Check if billing is disabled on the backend
+                // @ts-ignore - billing_disabled field will be in next SDK release
+                if ((_a = checkoutResponse.data) === null || _a === void 0 ? void 0 : _a.billing_disabled) {
+                    // Billing disabled - proceed with direct subscription creation
+                    // Fall through to the subscription creation logic below
+                }
+                else if ((_b = checkoutResponse.data) === null || _b === void 0 ? void 0 : _b.checkout_url) {
+                    // Redirect to Stripe checkout
+                    window.location.href = checkoutResponse.data.checkout_url;
+                    // Return a pending state to prevent further processing
+                    return {
+                        requires_checkout: true,
+                        checkout_url: checkoutResponse.data.checkout_url,
+                        session_id: checkoutResponse.data.session_id,
+                        subscription_id: checkoutResponse.data.subscription_id,
+                    };
+                }
+            }
+            // User has payment method, invoice billing, or billing is disabled
+            // Proceed with direct subscription creation
+            const response = await createRepositorySubscription({
+                client,
+                path: { graph_id: subscriptionData.repository_name },
+                body: {
+                    plan_name: subscriptionData.plan_name,
+                },
+            });
+            if (response.error) {
+                const errorMsg = typeof response.error === 'object' && 'detail' in response.error
+                    ? String(response.error.detail)
+                    : 'Failed to create repository subscription';
+                throw new Error(errorMsg);
+            }
+            return response.data;
+        }
+        catch (error) {
+            console.error('Repository subscription failed:', error);
+            throw error;
+        }
+        finally {
+            setIsSubscribing(false);
+        }
+    }, []);
+    const changePlan = useCallback(async (data) => {
+        setIsSubscribing(true);
+        try {
+            const response = await changeSubscriptionPlan({
+                client,
+                path: { graph_id: data.repository_name },
+                body: { new_plan_name: data.new_plan_name },
+            });
+            if (response.error) {
+                const errorMsg = typeof response.error === 'object' && 'detail' in response.error
+                    ? String(response.error.detail)
+                    : 'Failed to change plan';
+                throw new Error(errorMsg);
+            }
+            return response.data;
+        }
+        catch (error) {
+            console.error('Plan change failed:', error);
+            throw error;
+        }
+        finally {
+            setIsSubscribing(false);
+        }
+    }, []);
+    return {
+        isSubscribing,
+        subscribe,
+        changePlan,
+    };
+}
+/**
+ * Hook for monitoring multiple operations simultaneously
+ */
+export function useMultipleOperations() {
+    const [operations, setOperations] = useState(new Map());
+    // Keep a ref to the latest operations for cleanup without triggering effect re-runs
+    const operationsRef = useRef(operations);
+    // Update ref whenever operations change
+    useEffect(() => {
+        operationsRef.current = operations;
+    }, [operations]);
+    const addOperation = useCallback(async (operationId, options) => {
+        // Initialize state for this operation
+        setOperations((prev) => {
+            const newMap = new Map(prev);
+            newMap.set(operationId, {
+                isLoading: true,
+                isMonitoring: true,
+                progress: 0,
+                currentStep: 'Starting...',
+                error: null,
+                operationId,
+                result: null,
+                status: 'pending',
+            });
+            return newMap;
+        });
+        try {
+            const result = await operationMonitor.monitorOperation({
+                operationId,
+                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+                onProgress: (progress) => {
+                    setOperations((prev) => {
+                        const newMap = new Map(prev);
+                        const current = newMap.get(operationId);
+                        if (current) {
+                            newMap.set(operationId, Object.assign(Object.assign({}, current), { progress: progress.percent, currentStep: progress.message, status: 'running' }));
+                        }
+                        return newMap;
+                    });
+                },
+                onComplete: (result) => {
+                    setOperations((prev) => {
+                        const newMap = new Map(prev);
+                        const current = newMap.get(operationId);
+                        if (current) {
+                            newMap.set(operationId, Object.assign(Object.assign({}, current), { isLoading: false, isMonitoring: false, progress: 100, currentStep: 'Completed', result: result, status: 'completed' }));
+                        }
+                        return newMap;
+                    });
+                },
+                onError: (errorMsg) => {
+                    setOperations((prev) => {
+                        const newMap = new Map(prev);
+                        const current = newMap.get(operationId);
+                        if (current) {
+                            newMap.set(operationId, Object.assign(Object.assign({}, current), { isLoading: false, isMonitoring: false, error: errorMsg, result: null, status: 'failed' }));
+                        }
+                        return newMap;
+                    });
+                },
+            });
+            return result;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            setOperations((prev) => {
+                const newMap = new Map(prev);
+                const current = newMap.get(operationId);
+                if (current) {
+                    newMap.set(operationId, Object.assign(Object.assign({}, current), { isLoading: false, isMonitoring: false, error: errorMessage, result: null, status: 'failed' }));
+                }
+                return newMap;
+            });
+            throw error;
+        }
+    }, []);
+    const cancelOperation = useCallback(async (operationId) => {
+        await operationMonitor.cancelOperation(operationId);
+        setOperations((prev) => {
+            const newMap = new Map(prev);
+            const current = newMap.get(operationId);
+            if (current) {
+                newMap.set(operationId, Object.assign(Object.assign({}, current), { isLoading: false, isMonitoring: false, status: 'cancelled', error: 'Operation was cancelled' }));
+            }
+            return newMap;
+        });
+    }, []);
+    const removeOperation = useCallback((operationId) => {
+        setOperations((prev) => {
+            const newMap = new Map(prev);
+            newMap.delete(operationId);
+            return newMap;
+        });
+    }, []);
+    const clearAll = useCallback(() => {
+        // Cancel all active operations
+        for (const [operationId, state] of operations) {
+            if (state.isLoading) {
+                operationMonitor.cancelOperation(operationId);
+            }
+        }
+        setOperations(new Map());
+    }, [operations]);
+    // Cleanup on unmount - use ref to avoid stale closures
+    useEffect(() => {
+        return () => {
+            for (const [operationId, state] of operationsRef.current) {
+                if (state.isLoading) {
+                    operationMonitor.cancelOperation(operationId);
+                }
+            }
+        };
+    }, []);
+    return {
+        operations: Array.from(operations.values()),
+        addOperation,
+        cancelOperation,
+        removeOperation,
+        clearAll,
+    };
+}
+/**
+ * Helper to determine if an operation is still active
+ */
+export function isOperationActive(status) {
+    return status === 'pending' || status === 'running';
+}
+/**
+ * Helper to get progress color based on status
+ */
+export function getProgressColor(status) {
+    switch (status) {
+        case 'completed':
+            return 'text-green-600';
+        case 'failed':
+            return 'text-red-600';
+        case 'cancelled':
+            return 'text-yellow-600';
+        case 'running':
+            return 'text-blue-600';
+        default:
+            return 'text-gray-600';
+    }
+}

package/task-monitoring/operationMonitor.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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
+ */
+export type OperationStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+export interface OperationEvent {
+    event: string;
+    data: any;
+    timestamp?: string;
+}
+export interface OperationProgress {
+    percent: number;
+    message?: string;
+    current_step?: string;
+    total_steps?: number;
+}
+export interface OperationResult {
+    operation_id: string;
+    status: OperationStatus;
+    result?: any;
+    error?: string;
+    duration_ms?: number;
+    events?: OperationEvent[];
+}
+export interface OperationMonitorOptions {
+    operationId: string;
+    onProgress?: (progress: OperationProgress) => void;
+    onComplete?: (result: any) => void;
+    onError?: (error: string) => void;
+    onEvent?: (event: OperationEvent) => void;
+    timeout?: number;
+}
+export declare class OperationMonitor {
+    private static instance;
+    private activeOperations;
+    private operationResults;
+    static getInstance(): OperationMonitor;
+    /**
+     * Monitor an operation using SSE streaming
+     */
+    monitorOperation({ operationId, onProgress, onComplete, onError, onEvent, timeout, }: OperationMonitorOptions): Promise<OperationResult>;
+    /**
+     * Cancel operation monitoring (does not cancel the operation itself)
+     */
+    cancelOperation(operationId: string): boolean;
+    /**
+     * Get cached operation status/result
+     */
+    getOperationStatus(operationId: string): OperationResult | null;
+    /**
+     * Clean up operation monitoring resources
+     */
+    private cleanupOperation;
+    /**
+     * Monitor operation using SDK extensions
+     */
+    private monitorWithSDKExtensions;
+    /**
+     * Clean up all active operations
+     */
+    cleanup(): void;
+    /**
+     * Get list of active operation IDs
+     */
+    getActiveOperations(): string[];
+    /**
+     * Clear operation results cache
+     */
+    clearCache(): void;
+}
+export declare const operationMonitor: OperationMonitor;
+export declare const monitorOperation: (options: OperationMonitorOptions) => Promise<OperationResult>;
+export declare const cancelOperation: (operationId: string) => boolean;
+export declare const getOperationStatus: (operationId: string) => OperationResult;
+export declare const getActiveOperations: () => string[];