@d34dman/flowdrop 0.0.1 → 0.0.3

package/dist/services/nodeExecutionService.js

@@ -0,0 +1,261 @@
+/**
+ * Node Execution Service
+ * Handles fetching and managing node execution information from the backend
+ */
+import { getEndpointConfig } from './api.js';
+import { buildEndpointUrl } from '../config/endpoints.js';
+/**
+ * Service for managing node execution information
+ */
+export class NodeExecutionService {
+    static instance;
+    cache = new Map();
+    cacheTimeout = 30000; // 30 seconds
+    lastFetch = 0;
+    apiUnavailable = false;
+    apiUnavailableUntil = 0;
+    constructor() { }
+    static getInstance() {
+        if (!NodeExecutionService.instance) {
+            NodeExecutionService.instance = new NodeExecutionService();
+        }
+        return NodeExecutionService.instance;
+    }
+    /**
+     * Get execution information for a specific node from pipeline data
+     */
+    async getNodeExecutionInfo(nodeId, pipelineId) {
+        if (!pipelineId) {
+            console.warn('Pipeline ID is required to fetch node execution info');
+            return null;
+        }
+        try {
+            const endpointConfig = getEndpointConfig();
+            const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
+                id: pipelineId
+            });
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const pipelineData = await response.json();
+            const jobs = pipelineData.jobs || [];
+            const nodeStatuses = pipelineData.node_statuses || {};
+            // Find the job for this node
+            const nodeJob = jobs.find((job) => job.node_id === nodeId);
+            const nodeStatus = nodeStatuses[nodeId];
+            if (!nodeJob && !nodeStatus) {
+                return {
+                    status: 'idle',
+                    executionCount: 0,
+                    isExecuting: false
+                };
+            }
+            const executionInfo = {
+                status: this.mapJobStatusToExecutionStatus(nodeStatus?.status || nodeJob?.status || 'idle'),
+                executionCount: nodeJob?.execution_count || 0,
+                isExecuting: nodeStatus?.status === 'running' || nodeJob?.status === 'running',
+                lastExecuted: nodeJob?.last_executed || nodeStatus?.last_executed,
+                lastExecutionDuration: nodeJob?.execution_time || nodeStatus?.execution_time,
+                lastError: nodeJob?.error || nodeStatus?.error
+            };
+            this.cache.set(nodeId, executionInfo);
+            return executionInfo;
+        }
+        catch (error) {
+            console.error('Failed to fetch node execution info:', error);
+            return null;
+        }
+    }
+    /**
+     * Get execution information for multiple nodes from pipeline data
+     */
+    async getMultipleNodeExecutionInfo(nodeIds, pipelineId) {
+        if (!pipelineId) {
+            console.warn('Pipeline ID is required to fetch node execution info');
+            return {};
+        }
+        // Check if API is temporarily unavailable
+        if (this.apiUnavailable && Date.now() < this.apiUnavailableUntil) {
+            console.log('API temporarily unavailable, returning cached/default values');
+            const defaultExecutionInfo = {};
+            nodeIds.forEach((nodeId) => {
+                defaultExecutionInfo[nodeId] = {
+                    status: 'idle',
+                    executionCount: 0,
+                    isExecuting: false
+                };
+            });
+            return defaultExecutionInfo;
+        }
+        try {
+            const endpointConfig = getEndpointConfig();
+            const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.pipelines.get, {
+                id: pipelineId
+            });
+            const response = await fetch(url);
+            if (!response.ok) {
+                // If the endpoint returns 404, it means the pipeline API is not available
+                // Mark API as unavailable for 5 minutes to prevent repeated calls
+                if (response.status === 404) {
+                    console.warn(`Pipeline API endpoint not available for pipeline ${pipelineId}`);
+                    this.apiUnavailable = true;
+                    this.apiUnavailableUntil = Date.now() + 5 * 60 * 1000; // 5 minutes
+                    const defaultExecutionInfo = {};
+                    nodeIds.forEach((nodeId) => {
+                        defaultExecutionInfo[nodeId] = {
+                            status: 'idle',
+                            executionCount: 0,
+                            isExecuting: false
+                        };
+                    });
+                    return defaultExecutionInfo;
+                }
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const result = await response.json();
+            const jobs = result.jobs || [];
+            const executionInfoMap = {};
+            // Initialize all nodes with default values
+            nodeIds.forEach((nodeId) => {
+                executionInfoMap[nodeId] = {
+                    status: 'idle',
+                    executionCount: 0,
+                    isExecuting: false
+                };
+            });
+            // Update with actual job data
+            jobs.forEach((job) => {
+                const nodeId = job.node_id;
+                if (nodeIds.includes(nodeId)) {
+                    executionInfoMap[nodeId] = {
+                        status: this.mapJobStatusToExecutionStatus(job.status),
+                        executionCount: job.execution_count || 0,
+                        isExecuting: job.status === 'running',
+                        lastExecuted: job.completed || job.started,
+                        lastExecutionDuration: job.execution_time,
+                        lastError: job.error_message
+                    };
+                    // Update cache
+                    this.cache.set(nodeId, executionInfoMap[nodeId]);
+                }
+            });
+            return executionInfoMap;
+        }
+        catch (error) {
+            console.error('Failed to fetch multiple node execution info:', error);
+            // Return default values instead of empty object to prevent repeated calls
+            const defaultExecutionInfo = {};
+            nodeIds.forEach((nodeId) => {
+                defaultExecutionInfo[nodeId] = {
+                    status: 'idle',
+                    executionCount: 0,
+                    isExecuting: false
+                };
+            });
+            return defaultExecutionInfo;
+        }
+    }
+    /**
+     * Get all node execution counts
+     */
+    async getAllNodeExecutionCounts() {
+        try {
+            const endpointConfig = getEndpointConfig();
+            const url = buildEndpointUrl(endpointConfig, '/node-execution-counts');
+            const response = await fetch(url);
+            if (!response.ok) {
+                throw new Error(`HTTP error! status: ${response.status}`);
+            }
+            const result = await response.json();
+            if (result.success && result.data) {
+                return result.data;
+            }
+            return {};
+        }
+        catch (error) {
+            console.error('Failed to fetch all node execution counts:', error);
+            return {};
+        }
+    }
+    /**
+     * Get cached execution info for a node
+     */
+    getCachedNodeExecutionInfo(nodeId) {
+        return this.cache.get(nodeId) || null;
+    }
+    /**
+     * Clear cache for a specific node
+     */
+    clearNodeCache(nodeId) {
+        this.cache.delete(nodeId);
+    }
+    /**
+     * Clear all cache
+     */
+    clearAllCache() {
+        this.cache.clear();
+        this.lastFetch = 0;
+    }
+    /**
+     * Check if cache is stale
+     */
+    isCacheStale() {
+        return Date.now() - this.lastFetch > this.cacheTimeout;
+    }
+    /**
+     * Update execution info for a node (for real-time updates)
+     */
+    updateNodeExecutionInfo(nodeId, executionInfo) {
+        const existing = this.cache.get(nodeId);
+        if (existing) {
+            this.cache.set(nodeId, { ...existing, ...executionInfo });
+        }
+        else {
+            this.cache.set(nodeId, {
+                status: 'idle',
+                executionCount: 0,
+                isExecuting: false,
+                ...executionInfo
+            });
+        }
+    }
+    /**
+     * Map job status to execution status
+     */
+    mapJobStatusToExecutionStatus(jobStatus) {
+        switch (jobStatus) {
+            case 'pending':
+                return 'pending';
+            case 'running':
+                return 'running';
+            case 'completed':
+                return 'completed';
+            case 'failed':
+                return 'failed';
+            case 'cancelled':
+                return 'cancelled';
+            case 'skipped':
+                return 'skipped';
+            default:
+                return 'idle';
+        }
+    }
+    /**
+     * Batch update execution info for multiple nodes
+     */
+    updateMultipleNodeExecutionInfo(updates) {
+        Object.entries(updates).forEach(([nodeId, executionInfo]) => {
+            this.updateNodeExecutionInfo(nodeId, executionInfo);
+        });
+    }
+    /**
+     * Reset API availability status (useful for testing or when API becomes available)
+     */
+    resetApiAvailability() {
+        this.apiUnavailable = false;
+        this.apiUnavailableUntil = 0;
+    }
+}
+// Export singleton instance
+export const nodeExecutionService = NodeExecutionService.getInstance();

package/dist/services/portConfigApi.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Port Configuration API Service
+ * Handles fetching port configuration from the backend
+ */
+import type { PortConfig } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
+/**
+ * Fetch port configuration from API
+ */
+export declare function fetchPortConfig(endpointConfig: EndpointConfig): Promise<PortConfig>;
+/**
+ * Validate port configuration structure
+ */
+export declare function validatePortConfig(config: PortConfig): boolean;

package/dist/services/portConfigApi.js

@@ -0,0 +1,69 @@
+/**
+ * Port Configuration API Service
+ * Handles fetching port configuration from the backend
+ */
+import { buildEndpointUrl } from '../config/endpoints.js';
+import { DEFAULT_PORT_CONFIG } from '../config/defaultPortConfig.js';
+import { FlowDropApiClient } from '../api/client.js';
+/**
+ * Fetch port configuration from API
+ */
+export async function fetchPortConfig(endpointConfig) {
+    try {
+        const url = buildEndpointUrl(endpointConfig, endpointConfig.endpoints.portConfig);
+        console.log('📡 Fetching port configuration from:', url);
+        // Create API client instance
+        const client = new FlowDropApiClient(endpointConfig.baseUrl);
+        // Use the client to fetch port configuration
+        const portConfig = await client.getPortConfig();
+        // Validate the configuration has required fields
+        if (!portConfig.dataTypes || !Array.isArray(portConfig.dataTypes)) {
+            console.warn('⚠️ Invalid port config received from API, using default');
+            return DEFAULT_PORT_CONFIG;
+        }
+        console.log('✅ Port configuration loaded successfully:', {
+            version: portConfig.version,
+            dataTypesCount: portConfig.dataTypes.length,
+            rulesCount: portConfig.compatibilityRules?.length || 0,
+            defaultType: portConfig.defaultDataType
+        });
+        return portConfig;
+    }
+    catch (error) {
+        console.error('❌ Error fetching port configuration:', error);
+        console.log('🔄 Falling back to default port configuration');
+        return DEFAULT_PORT_CONFIG;
+    }
+}
+/**
+ * Validate port configuration structure
+ */
+export function validatePortConfig(config) {
+    if (!config || typeof config !== 'object') {
+        return false;
+    }
+    if (!config.dataTypes || !Array.isArray(config.dataTypes)) {
+        return false;
+    }
+    if (!config.defaultDataType || typeof config.defaultDataType !== 'string') {
+        return false;
+    }
+    // Check that all data types have required fields
+    for (const dataType of config.dataTypes) {
+        if (!dataType.id || !dataType.name || !dataType.color) {
+            return false;
+        }
+    }
+    // Check that compatibility rules reference valid data types
+    if (config.compatibilityRules) {
+        // TODO: Fix type definition for PortCompatibilityRule - sourceType and targetType properties missing
+        // const dataTypeIds = new Set(config.dataTypes.map((dt) => dt.id));
+        // for (const rule of config.compatibilityRules) {
+        //   if (!dataTypeIds.has(rule.sourceType) || !dataTypeIds.has(rule.targetType)) {
+        //     console.warn("⚠️ Compatibility rule references unknown data type:", rule);
+        //     return false;
+        //   }
+        // }
+    }
+    return true;
+}

package/dist/services/toastService.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Toast Service
+ * Centralized toast notification service using svelte-french-toast
+ * Provides consistent toast notifications across the FlowDrop application
+ */
+/**
+ * Toast notification types
+ */
+export type ToastType = 'success' | 'error' | 'warning' | 'info' | 'loading';
+/**
+ * Toast configuration options
+ */
+export interface ToastOptions {
+    duration?: number;
+    position?: 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+}
+/**
+ * Show a success toast notification
+ */
+export declare function showSuccess(message: string, options?: ToastOptions): string;
+/**
+ * Show an error toast notification
+ */
+export declare function showError(message: string, options?: ToastOptions): string;
+/**
+ * Show a warning toast notification
+ */
+export declare function showWarning(message: string, options?: ToastOptions): string;
+/**
+ * Show an info toast notification
+ */
+export declare function showInfo(message: string, options?: ToastOptions): string;
+/**
+ * Show a loading toast notification
+ */
+export declare function showLoading(message: string, options?: ToastOptions): string;
+/**
+ * Dismiss a specific toast by ID
+ */
+export declare function dismissToast(toastId: string): void;
+/**
+ * Dismiss all toasts
+ */
+export declare function dismissAllToasts(): void;
+/**
+ * Show a promise-based toast (loading -> success/error)
+ */
+export declare function showPromise<T>(promise: Promise<T>, { loading, success, error, options }: {
+    loading: string;
+    success: string | ((data: T) => string);
+    error: string | ((error: any) => string);
+    options?: ToastOptions;
+}): Promise<T>;
+/**
+ * Show a confirmation toast (simplified version without action buttons)
+ */
+export declare function showConfirmation(message: string, options?: ToastOptions): string;
+/**
+ * API-specific toast helpers
+ */
+export declare const apiToasts: {
+    /**
+     * Show API success message
+     */
+    success: (operation: string, details?: string) => string;
+    /**
+     * Show API error message
+     */
+    error: (operation: string, error: string | Error) => string;
+    /**
+     * Show API loading message
+     */
+    loading: (operation: string) => string;
+    /**
+     * Show API promise with automatic success/error handling
+     */
+    promise: <T>(promise: Promise<T>, operation: string, options?: {
+        successMessage?: string;
+        errorMessage?: string;
+    }) => Promise<T>;
+};
+/**
+ * Workflow-specific toast helpers
+ */
+export declare const workflowToasts: {
+    /**
+     * Show workflow save success
+     */
+    saved: (workflowName?: string) => string;
+    /**
+     * Show workflow save error
+     */
+    saveError: (error: string | Error) => string;
+    /**
+     * Show workflow delete success
+     */
+    deleted: (workflowName?: string) => string;
+    /**
+     * Show workflow delete error
+     */
+    deleteError: (error: string | Error) => string;
+    /**
+     * Show workflow execution started
+     */
+    executionStarted: (workflowName?: string) => string;
+    /**
+     * Show workflow execution completed
+     */
+    executionCompleted: (workflowName?: string) => string;
+    /**
+     * Show workflow export success
+     */
+    exported: (workflowName?: string) => string;
+    /**
+     * Show workflow execution error
+     */
+    executionError: (error: string | Error) => string;
+};
+/**
+ * Pipeline-specific toast helpers
+ */
+export declare const pipelineToasts: {
+    /**
+     * Show pipeline creation success
+     */
+    created: (pipelineName?: string) => string;
+    /**
+     * Show pipeline creation error
+     */
+    creationError: (error: string | Error) => string;
+    /**
+     * Show pipeline execution started
+     */
+    executionStarted: (pipelineId: string) => string;
+    /**
+     * Show pipeline execution completed
+     */
+    executionCompleted: (pipelineId: string) => string;
+    /**
+     * Show pipeline execution error
+     */
+    executionError: (pipelineId: string, error: string | Error) => string;
+    /**
+     * Show pipeline status update
+     */
+    statusUpdate: (pipelineId: string, status: string) => string;
+};