@robosystems/core 0.3.0

package/task-monitoring/operationErrors.js

@@ -0,0 +1,251 @@
+/**
+ * Error handling for operation-based monitoring
+ */
+export var OperationErrorCode;
+(function (OperationErrorCode) {
+    // Network errors
+    OperationErrorCode["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+    OperationErrorCode["CONNECTION_LOST"] = "CONNECTION_LOST";
+    OperationErrorCode["TIMEOUT"] = "TIMEOUT";
+    // Operation errors
+    OperationErrorCode["OPERATION_NOT_FOUND"] = "OPERATION_NOT_FOUND";
+    OperationErrorCode["OPERATION_CANCELLED"] = "OPERATION_CANCELLED";
+    OperationErrorCode["OPERATION_FAILED"] = "OPERATION_FAILED";
+    // Permission errors
+    OperationErrorCode["UNAUTHORIZED"] = "UNAUTHORIZED";
+    OperationErrorCode["FORBIDDEN"] = "FORBIDDEN";
+    OperationErrorCode["INSUFFICIENT_CREDITS"] = "INSUFFICIENT_CREDITS";
+    // Resource errors
+    OperationErrorCode["RESOURCE_NOT_FOUND"] = "RESOURCE_NOT_FOUND";
+    OperationErrorCode["RESOURCE_LOCKED"] = "RESOURCE_LOCKED";
+    OperationErrorCode["RESOURCE_LIMIT_EXCEEDED"] = "RESOURCE_LIMIT_EXCEEDED";
+    // Validation errors
+    OperationErrorCode["INVALID_INPUT"] = "INVALID_INPUT";
+    OperationErrorCode["INVALID_QUERY"] = "INVALID_QUERY";
+    OperationErrorCode["SCHEMA_VIOLATION"] = "SCHEMA_VIOLATION";
+    // System errors
+    OperationErrorCode["INTERNAL_ERROR"] = "INTERNAL_ERROR";
+    OperationErrorCode["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
+    OperationErrorCode["RATE_LIMITED"] = "RATE_LIMITED";
+})(OperationErrorCode || (OperationErrorCode = {}));
+export class OperationError extends Error {
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'OperationError';
+    }
+    /**
+     * Check if error is recoverable
+     */
+    isRecoverable() {
+        return [
+            OperationErrorCode.CONNECTION_LOST,
+            OperationErrorCode.TIMEOUT,
+            OperationErrorCode.SERVICE_UNAVAILABLE,
+            OperationErrorCode.RATE_LIMITED,
+        ].includes(this.code);
+    }
+    /**
+     * Check if error requires user action
+     */
+    requiresUserAction() {
+        return [
+            OperationErrorCode.UNAUTHORIZED,
+            OperationErrorCode.FORBIDDEN,
+            OperationErrorCode.INSUFFICIENT_CREDITS,
+            OperationErrorCode.INVALID_INPUT,
+            OperationErrorCode.INVALID_QUERY,
+        ].includes(this.code);
+    }
+    /**
+     * Get user-friendly message
+     */
+    getUserMessage() {
+        switch (this.code) {
+            case OperationErrorCode.CONNECTION_FAILED:
+                return 'Unable to connect to the server. Please check your internet connection.';
+            case OperationErrorCode.CONNECTION_LOST:
+                return 'Connection to the server was lost. Attempting to reconnect...';
+            case OperationErrorCode.TIMEOUT:
+                return 'The operation took too long to complete. Please try again.';
+            case OperationErrorCode.OPERATION_NOT_FOUND:
+                return 'The operation could not be found. It may have expired.';
+            case OperationErrorCode.OPERATION_CANCELLED:
+                return 'The operation was cancelled.';
+            case OperationErrorCode.OPERATION_FAILED:
+                return 'The operation failed. Please check the details and try again.';
+            case OperationErrorCode.UNAUTHORIZED:
+                return 'You are not authorized. Please log in and try again.';
+            case OperationErrorCode.FORBIDDEN:
+                return 'You do not have permission to perform this action.';
+            case OperationErrorCode.INSUFFICIENT_CREDITS:
+                return 'You have insufficient credits. Please upgrade your plan.';
+            case OperationErrorCode.RESOURCE_NOT_FOUND:
+                return 'The requested resource could not be found.';
+            case OperationErrorCode.RESOURCE_LOCKED:
+                return 'The resource is currently locked. Please try again later.';
+            case OperationErrorCode.RESOURCE_LIMIT_EXCEEDED:
+                return 'You have exceeded the resource limit for your plan.';
+            case OperationErrorCode.INVALID_INPUT:
+                return 'The provided input is invalid. Please check and try again.';
+            case OperationErrorCode.INVALID_QUERY:
+                return 'The query syntax is invalid. Please check your query.';
+            case OperationErrorCode.SCHEMA_VIOLATION:
+                return 'The operation violates the schema constraints.';
+            case OperationErrorCode.INTERNAL_ERROR:
+                return 'An internal error occurred. Please try again later.';
+            case OperationErrorCode.SERVICE_UNAVAILABLE:
+                return 'The service is temporarily unavailable. Please try again later.';
+            case OperationErrorCode.RATE_LIMITED:
+                return 'Too many requests. Please slow down and try again.';
+            default:
+                return this.message || 'An unexpected error occurred.';
+        }
+    }
+    /**
+     * Get recommended action for the user
+     */
+    getRecommendedAction() {
+        switch (this.code) {
+            case OperationErrorCode.CONNECTION_FAILED:
+            case OperationErrorCode.CONNECTION_LOST:
+                return 'Check your internet connection and refresh the page.';
+            case OperationErrorCode.TIMEOUT:
+                return 'Try running the operation with smaller data or during off-peak hours.';
+            case OperationErrorCode.UNAUTHORIZED:
+                return 'Please log in again to continue.';
+            case OperationErrorCode.FORBIDDEN:
+                return 'Contact your administrator for access.';
+            case OperationErrorCode.INSUFFICIENT_CREDITS:
+                return 'Upgrade your plan or purchase additional credits.';
+            case OperationErrorCode.INVALID_QUERY:
+                return 'Review the query syntax documentation.';
+            case OperationErrorCode.RATE_LIMITED:
+                return 'Wait a few moments before trying again.';
+            default:
+                return null;
+        }
+    }
+}
+/**
+ * Parse SSE error events into OperationError
+ */
+export function parseOperationError(event) {
+    // Check for specific error codes in the event
+    if (event.code) {
+        const code = event.code;
+        return new OperationError(code, event.message || 'Unknown error', event.details);
+    }
+    // Map error messages to codes
+    const message = event.message || event.error || '';
+    if (message.includes('unauthorized') || message.includes('401')) {
+        return new OperationError(OperationErrorCode.UNAUTHORIZED, message);
+    }
+    if (message.includes('forbidden') || message.includes('403')) {
+        return new OperationError(OperationErrorCode.FORBIDDEN, message);
+    }
+    if (message.includes('credits') || message.includes('quota')) {
+        return new OperationError(OperationErrorCode.INSUFFICIENT_CREDITS, message);
+    }
+    if (message.includes('not found') || message.includes('404')) {
+        return new OperationError(OperationErrorCode.RESOURCE_NOT_FOUND, message);
+    }
+    if (message.includes('timeout')) {
+        return new OperationError(OperationErrorCode.TIMEOUT, message);
+    }
+    if (message.includes('rate limit') || message.includes('429')) {
+        return new OperationError(OperationErrorCode.RATE_LIMITED, message);
+    }
+    if (message.includes('invalid') || message.includes('validation')) {
+        return new OperationError(OperationErrorCode.INVALID_INPUT, message);
+    }
+    if (message.includes('syntax') || message.includes('query')) {
+        return new OperationError(OperationErrorCode.INVALID_QUERY, message);
+    }
+    if (message.includes('connection')) {
+        return new OperationError(OperationErrorCode.CONNECTION_FAILED, message);
+    }
+    if (message.includes('cancelled')) {
+        return new OperationError(OperationErrorCode.OPERATION_CANCELLED, message);
+    }
+    // Default to internal error
+    return new OperationError(OperationErrorCode.INTERNAL_ERROR, message);
+}
+/**
+ * Error recovery strategies
+ */
+export class ErrorRecovery {
+    constructor() {
+        this.retryCount = new Map();
+        this.maxRetries = 3;
+        this.baseDelay = 1000;
+    }
+    /**
+     * Determine if we should retry
+     */
+    shouldRetry(operationId, error) {
+        if (!error.isRecoverable()) {
+            return false;
+        }
+        const count = this.retryCount.get(operationId) || 0;
+        if (count >= this.maxRetries) {
+            return false;
+        }
+        this.retryCount.set(operationId, count + 1);
+        return true;
+    }
+    /**
+     * Get retry delay with exponential backoff
+     */
+    getRetryDelay(operationId) {
+        const count = this.retryCount.get(operationId) || 0;
+        return this.baseDelay * Math.pow(2, count);
+    }
+    /**
+     * Reset retry count for an operation
+     */
+    reset(operationId) {
+        this.retryCount.delete(operationId);
+    }
+    /**
+     * Clear all retry counts
+     */
+    clear() {
+        this.retryCount.clear();
+    }
+}
+export function createErrorNotification(error) {
+    const severity = error.requiresUserAction()
+        ? 'error'
+        : error.isRecoverable()
+            ? 'warning'
+            : 'error';
+    return {
+        title: getErrorTitle(error.code),
+        message: error.getUserMessage(),
+        action: error.getRecommendedAction() || undefined,
+        severity,
+    };
+}
+function getErrorTitle(code) {
+    switch (code) {
+        case OperationErrorCode.CONNECTION_FAILED:
+        case OperationErrorCode.CONNECTION_LOST:
+            return 'Connection Error';
+        case OperationErrorCode.UNAUTHORIZED:
+        case OperationErrorCode.FORBIDDEN:
+            return 'Access Denied';
+        case OperationErrorCode.INSUFFICIENT_CREDITS:
+            return 'Insufficient Credits';
+        case OperationErrorCode.INVALID_INPUT:
+        case OperationErrorCode.INVALID_QUERY:
+            return 'Validation Error';
+        case OperationErrorCode.RATE_LIMITED:
+            return 'Rate Limited';
+        case OperationErrorCode.TIMEOUT:
+            return 'Timeout';
+        default:
+            return 'Operation Error';
+    }
+}

package/task-monitoring/operationHooks.d.ts

@@ -0,0 +1,117 @@
+import type { OperationStatus } from './operationMonitor';
+export interface OperationMonitorState {
+    isLoading: boolean;
+    isMonitoring: boolean;
+    progress: number | null;
+    currentStep: string | null;
+    error: string | null;
+    operationId: string | null;
+    result: any | null;
+    status: OperationStatus | null;
+}
+export interface UseOperationMonitoringResult extends OperationMonitorState {
+    startMonitoring: (operationId: string, options?: {
+        timeout?: number;
+    }) => Promise<any>;
+    cancelOperation: () => Promise<void>;
+    reset: () => void;
+    cancelMonitoring: () => Promise<void>;
+}
+/**
+ * Hook for monitoring operations using SSE
+ */
+export declare function useOperationMonitoring(): UseOperationMonitoringResult;
+/**
+ * Hook for graph creation using the new unified endpoint
+ */
+export declare function useGraphCreation(): {
+    isLoading: boolean;
+    createGraph: (graphData: {
+        graph_type: "generic" | "company" | "entity";
+        graph_name: string;
+        description?: string;
+        tags?: string[];
+        instance_tier?: string;
+        schema_extensions?: string[];
+        create_entity?: boolean;
+        company_name?: string;
+        company_identifier?: string;
+        company_identifier_type?: "ein" | "name";
+        entity_name?: string;
+        entity_identifier?: string;
+        entity_identifier_type?: "ein" | "name";
+        org_id?: string;
+    }) => Promise<any>;
+    createEntityGraph: (entityData: {
+        entity_name: string;
+        entity_identifier?: string;
+        entity_identifier_type?: "ein" | "name";
+        instance_tier?: string;
+        schema_extensions?: string[];
+        create_entity?: boolean;
+        description?: string;
+        tags?: string[];
+        org_id?: string;
+    }) => Promise<any>;
+    createGenericGraph: (graphData: {
+        graph_name: string;
+        description?: string;
+        instance_tier?: string;
+        schema_extensions?: string[];
+        org_id?: string;
+    }) => Promise<any>;
+    startMonitoring: (operationId: string, options?: {
+        timeout?: number;
+    }) => Promise<any>;
+    cancelOperation: () => Promise<void>;
+    reset: () => void;
+    cancelMonitoring: () => Promise<void>;
+    isMonitoring: boolean;
+    progress: number | null;
+    currentStep: string | null;
+    error: string | null;
+    operationId: string | null;
+    result: any | null;
+    status: OperationStatus | null;
+};
+/**
+ * Hook for creating repository subscriptions with billing integration
+ * Mirrors the graph creation pattern for consistency
+ */
+export declare function useRepositorySubscription(): {
+    isSubscribing: boolean;
+    subscribe: (subscriptionData: {
+        repository_name: string;
+        plan_name: string;
+        org_id: string;
+    }) => Promise<import("@robosystems/client").GraphSubscriptionResponse | {
+        requires_checkout: boolean;
+        checkout_url: string;
+        session_id: string;
+        subscription_id: string;
+    }>;
+    changePlan: (data: {
+        repository_name: string;
+        new_plan_name: string;
+    }) => Promise<import("@robosystems/client").GraphSubscriptionResponse>;
+};
+/**
+ * Hook for monitoring multiple operations simultaneously
+ */
+export declare function useMultipleOperations(): {
+    operations: OperationMonitorState[];
+    addOperation: (operationId: string, options?: {
+        timeout?: number;
+    }) => Promise<import("./operationMonitor").OperationResult>;
+    cancelOperation: (operationId: string) => Promise<void>;
+    removeOperation: (operationId: string) => void;
+    clearAll: () => void;
+};
+/**
+ * Helper to determine if an operation is still active
+ */
+export declare function isOperationActive(status: OperationStatus | null): boolean;
+/**
+ * Helper to get progress color based on status
+ */
+export declare function getProgressColor(status: OperationStatus | null): string;