@robosystems/core 0.11.2 → 0.11.3

package/task-monitoring/operationHooks.js

@@ -1,7 +1,30 @@
 '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';
+import { toApiError } from '../lib/sdk-errors';
+import { MONITORING_STOPPED, operationMonitor } from './operationMonitor';
+/**
+ * Thrown by `startMonitoring` (and so by `createGraph`) when an operation
+ * ends in any state but `completed`. `status` is the terminal state;
+ * `'cancelled'` with `stopped: true` means monitoring was stopped locally
+ * and the operation may still be running.
+ */
+export class OperationOutcomeError extends Error {
+    constructor(result) {
+        const stopped = result.error === MONITORING_STOPPED;
+        super(stopped
+            ? STOPPED_MESSAGE
+            : result.error ||
+                (result.status === 'cancelled'
+                    ? 'Operation was cancelled'
+                    : 'Operation failed'));
+        this.name = 'OperationOutcomeError';
+        this.status = result.status;
+        this.operationId = result.operation_id;
+        this.stopped = stopped;
+    }
+}
+const STOPPED_MESSAGE = 'Stopped monitoring. The operation continues on the server.';
 /**
  * Hook for monitoring operations using SSE
  */
@@ -30,11 +53,13 @@ export function useOperationMonitoring() {
         });
         currentOperationId.current = null;
     }, []);
+    // Stops watching; the server-side operation is not cancelled (graph
+    // creation, for one, cannot be cancelled mid-provision).
     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 })));
+                operationMonitor.cancelOperation(currentOperationId.current);
+                setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, isMonitoring: false, status: 'cancelled', error: STOPPED_MESSAGE, result: null })));
             }
             catch (error) {
                 console.error('Failed to cancel operation:', error);
@@ -43,6 +68,10 @@ export function useOperationMonitoring() {
         }
     }, []);
     const startMonitoring = useCallback(async (operationId, options) => {
+        if (currentOperationId.current &&
+            currentOperationId.current !== operationId) {
+            operationMonitor.cancelOperation(currentOperationId.current);
+        }
         currentOperationId.current = operationId;
         setState({
             isLoading: true,
@@ -68,15 +97,20 @@ export function useOperationMonitoring() {
                     setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, isMonitoring: false, error: errorMsg, result: null, status: 'failed' })));
                 },
             });
+            if (result.status !== 'completed') {
+                throw new OperationOutcomeError(result);
+            }
             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' })));
+            setState((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false, isMonitoring: false, error: errorMessage, result: null, status: error instanceof OperationOutcomeError ? error.status : 'failed' })));
             throw error;
         }
         finally {
-            currentOperationId.current = null;
+            // A newer run may have started meanwhile; leave its id in place.
+            if (currentOperationId.current === operationId)
+                currentOperationId.current = null;
         }
     }, []);
     // Cleanup on unmount
@@ -91,6 +125,19 @@ export function useOperationMonitoring() {
         cancelOperation, cancelMonitoring: cancelOperation, // Alias for consistency
         reset });
 }
+/**
+ * The schema sent for a generic graph: the caller's, or an empty one named
+ * after the graph (a bare database the user fills in later).
+ */
+function genericSchema(graphData) {
+    if (graphData.custom_schema)
+        return graphData.custom_schema;
+    const name = graphData.graph_name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '') || 'custom_graph';
+    return { name, nodes: [], relationships: [] };
+}
 /**
  * Hook for graph creation using the new unified endpoint
  */
@@ -98,7 +145,7 @@ export function useGraphCreation() {
     const operationMonitoring = useOperationMonitoring();
     const [isCreating, setIsCreating] = useState(false);
     const createGraph = useCallback(async (graphData) => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         setIsCreating(true);
         try {
             // Check if billing is enabled and user needs to complete checkout
@@ -129,6 +176,9 @@ export function useGraphCreation() {
                             description: graphData.description,
                             tags: graphData.tags,
                             schema_extensions: graphData.schema_extensions,
+                            custom_schema: graphData.graph_type === 'generic'
+                                ? genericSchema(graphData)
+                                : undefined,
                             create_entity: graphData.create_entity,
                             entity_name: graphData.entity_name,
                             entity_identifier: graphData.entity_identifier,
@@ -140,11 +190,7 @@ export function useGraphCreation() {
                     },
                 });
                 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);
+                    throw toApiError(checkoutResponse.error, checkoutResponse.response);
                 }
                 // Check if billing is disabled on the backend
                 // @ts-ignore - billing_disabled field will be in next SDK release
@@ -173,11 +219,19 @@ export function useGraphCreation() {
                     tags: graphData.tags,
                     schema_extensions: graphData.schema_extensions || [],
                 },
+                // The API files tags from the top-level field; `metadata.tags` is
+                // kept for older servers.
+                tags: (_c = graphData.tags) !== null && _c !== void 0 ? _c : [],
                 instance_tier: graphData.instance_tier || 'ladybug-standard',
                 create_entity: graphData.graph_type === 'generic'
                     ? false
-                    : ((_c = graphData.create_entity) !== null && _c !== void 0 ? _c : true),
+                    : ((_d = graphData.create_entity) !== null && _d !== void 0 ? _d : true),
             };
+            // A generic graph is defined by its schema; the API requires either
+            // a custom_schema or an initial_entity.
+            if (graphData.graph_type === 'generic') {
+                requestBody.custom_schema = genericSchema(graphData);
+            }
             // Add initial_entity for entity or company graphs
             if (graphData.graph_type === 'entity' && graphData.entity_name) {
                 requestBody.initial_entity = {
@@ -310,11 +364,7 @@ export function useRepositorySubscription() {
                     },
                 });
                 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);
+                    throw toApiError(checkoutResponse.error, checkoutResponse.response);
                 }
                 // Check if billing is disabled on the backend
                 // @ts-ignore - billing_disabled field will be in next SDK release

package/task-monitoring/operationMonitor.d.ts

@@ -31,8 +31,15 @@ export interface OperationMonitorOptions {
     onComplete?: (result: any) => void;
     onError?: (error: string) => void;
     onEvent?: (event: OperationEvent) => void;
+    /**
+     * Give up watching after this many milliseconds. No default: an operation
+     * runs as long as it runs (backups, large graph creations), and a monitor
+     * that times out reports a failure for work that is still succeeding.
+     */
     timeout?: number;
 }
+/** Error message on a result whose monitoring was stopped locally. */
+export declare const MONITORING_STOPPED = "Monitoring stopped";
 export declare class OperationMonitor {
     private static instance;
     private activeOperations;
@@ -43,7 +50,9 @@ export declare class OperationMonitor {
      */
     monitorOperation({ operationId, onProgress, onComplete, onError, onEvent, timeout, }: OperationMonitorOptions): Promise<OperationResult>;
     /**
-     * Cancel operation monitoring (does not cancel the operation itself)
+     * Stop monitoring an operation: closes its stream and settles its
+     * `monitorOperation` promise with `status: 'cancelled'` and
+     * `error: MONITORING_STOPPED`. Does not cancel the operation itself.
      */
     cancelOperation(operationId: string): boolean;
     /**

package/task-monitoring/operationMonitor.js

@@ -16,6 +16,30 @@ const getSDKExtensions = async () => {
         return null;
     }
 };
+/** Error message on a result whose monitoring was stopped locally. */
+export const MONITORING_STOPPED = 'Monitoring stopped';
+function createActiveOperation() {
+    let resolveStopped = () => undefined;
+    const entry = {
+        client: null,
+        stopped: false,
+        stoppedPromise: new Promise((resolve) => {
+            resolveStopped = resolve;
+        }),
+        stop: () => {
+            var _a;
+            entry.stopped = true;
+            resolveStopped(null);
+            (_a = entry.client) === null || _a === void 0 ? void 0 : _a.closeAll();
+        },
+    };
+    return entry;
+}
+const stoppedResult = (operationId) => ({
+    operation_id: operationId,
+    status: 'cancelled',
+    error: MONITORING_STOPPED,
+});
 export class OperationMonitor {
     constructor() {
         this.activeOperations = new Map();
@@ -30,40 +54,55 @@ export class OperationMonitor {
     /**
      * 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.');
+    async monitorOperation({ operationId, onProgress, onComplete, onError, onEvent, timeout, }) {
+        // Registered before any await, so a stop issued while the SDK loads
+        // (an immediate cancel, an unmount, a StrictMode remount) is honoured.
+        if (this.activeOperations.has(operationId)) {
+            this.cancelOperation(operationId);
+        }
+        const entry = createActiveOperation();
+        this.activeOperations.set(operationId, entry);
+        try {
+            // Get SDK extensions at runtime
+            const sdkExtensions = await getSDKExtensions();
+            if (entry.stopped)
+                return stoppedResult(operationId);
+            // 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 await this.monitorWithSDKExtensions({
+                operationId,
+                onProgress,
+                onComplete,
+                onError,
+                onEvent,
+                timeout,
+            }, sdkExtensions, entry);
+        }
+        finally {
+            if (this.activeOperations.get(operationId) === entry) {
+                this.activeOperations.delete(operationId);
+            }
         }
-        return this.monitorWithSDKExtensions({
-            operationId,
-            onProgress,
-            onComplete,
-            onError,
-            onEvent,
-            timeout,
-        }, sdkExtensions);
     }
     /**
-     * Cancel operation monitoring (does not cancel the operation itself)
+     * Stop monitoring an operation: closes its stream and settles its
+     * `monitorOperation` promise with `status: 'cancelled'` and
+     * `error: MONITORING_STOPPED`. 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;
-            }
+        const active = this.activeOperations.get(operationId);
+        if (!active)
             return false;
+        this.activeOperations.delete(operationId);
+        try {
+            active.stop();
         }
         catch (error) {
-            console.error('Failed to cancel operation:', error);
-            return false;
+            console.error('Failed to stop operation monitoring:', error);
         }
+        return true;
     }
     /**
      * Get cached operation status/result
@@ -80,49 +119,63 @@ export class OperationMonitor {
      * Clean up operation monitoring resources
      */
     cleanupOperation(operationId) {
-        const eventSource = this.activeOperations.get(operationId);
-        if (eventSource) {
-            eventSource.close();
-            this.activeOperations.delete(operationId);
-        }
+        this.cancelOperation(operationId);
     }
     /**
      * Monitor operation using SDK extensions
      */
-    async monitorWithSDKExtensions(options, sdkExtensions) {
+    async monitorWithSDKExtensions(options, sdkExtensions, entry) {
         var _a, _b, _c;
         const { OperationClient, extractTokenFromSDKClient } = sdkExtensions;
-        const { getToken } = await import('../auth-core/token-storage');
+        const { getToken, getValidToken } = await import('../auth-core/token-storage');
+        if (entry.stopped)
+            return stoppedResult(options.operationId);
         const config = client.getConfig();
-        const jwtToken = getToken() || extractTokenFromSDKClient();
-        // Create operation client with proper configuration
+        // One client per operation, tracked so `cancelOperation` can close it.
+        // The credential is resolved per connect (`tokenProvider`), so a stream
+        // that reconnects after the JWT rotates presents the current token; the
+        // static `token` only serves SDK versions that predate the provider.
         const operationClient = new OperationClient({
             baseUrl: config.baseUrl || 'http://localhost:8000',
             credentials: 'include',
-            token: jwtToken,
+            token: getToken() || (extractTokenFromSDKClient === null || extractTokenFromSDKClient === void 0 ? void 0 : extractTokenFromSDKClient()) || undefined,
+            tokenProvider: async () => { var _a; return (_a = (await getValidToken())) !== null && _a !== void 0 ? _a : null; },
             maxRetries: 3,
             retryDelay: 1000,
         });
+        entry.client = operationClient;
+        const stopped = () => entry.stopped;
         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,
-            });
+            const result = await Promise.race([
+                operationClient.monitorOperation(options.operationId, {
+                    onProgress: (progress) => {
+                        var _a, _b, _c, _d;
+                        if (stopped())
+                            return;
+                        (_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;
+                        if (stopped())
+                            return;
+                        (_a = options.onEvent) === null || _a === void 0 ? void 0 : _a.call(options, {
+                            event: event.type,
+                            data: event.data,
+                        });
+                    },
+                    timeout: options.timeout,
+                }),
+                entry.stoppedPromise,
+            ]);
+            if (result === null) {
+                // Stopped locally: report it without firing the outcome callbacks.
+                return stoppedResult(options.operationId);
+            }
             // Map OperationResult (success: boolean) to status string
             const status = result.success
                 ? 'completed'
@@ -158,10 +211,9 @@ export class OperationMonitor {
      * Clean up all active operations
      */
     cleanup() {
-        for (const [, eventSource] of this.activeOperations.entries()) {
-            eventSource.close();
+        for (const operationId of Array.from(this.activeOperations.keys())) {
+            this.cancelOperation(operationId);
         }
-        this.activeOperations.clear();
     }
     /**
      * Get list of active operation IDs

package/task-monitoring/taskMonitor.d.ts

@@ -1,9 +1,22 @@
 import type { TaskPollingOptions, TaskStatusResponse } from './types';
+/** Rejection message when watching stopped locally (`stopPolling`). */
+export declare const POLLING_CANCELLED = "Task polling was cancelled";
 export declare class TaskMonitor {
     private static instance;
     private activeTasks;
     static getInstance(): TaskMonitor;
-    pollTask({ taskId, onProgress, onComplete, onError, pollInterval, maxAttempts, }: TaskPollingOptions): Promise<TaskStatusResponse>;
+    pollTask({ taskId, onProgress, onComplete, onError, pollInterval, maxAttempts, // 5 minutes at 2s intervals
+    maxConsecutiveErrors, }: TaskPollingOptions): Promise<TaskStatusResponse>;
+    /**
+     * Stop watching a task locally. The operation itself keeps running on the
+     * server — this is what leaving a page should do.
+     */
+    stopPolling(taskId: string): boolean;
+    /**
+     * Cancel the operation on the server, then stop watching it. Only for an
+     * explicit user action. Returns false when the server refused — the task
+     * is then still being watched, and its real outcome still arrives.
+     */
     cancelTask(taskId: string): Promise<boolean>;
     cancelAllTasks(): void;
     getActiveTasks(): string[];
@@ -11,4 +24,5 @@ export declare class TaskMonitor {
 export declare const taskMonitor: TaskMonitor;
 export declare const pollTaskStatus: (options: TaskPollingOptions) => Promise<TaskStatusResponse>;
 export declare const cancelTask: (taskId: string) => Promise<boolean>;
+export declare const stopPollingTask: (taskId: string) => boolean;
 export declare const getActiveTasks: () => string[];