@d34dman/flowdrop 0.0.1 → 0.0.2

package/dist/mocks/app-stores.js

@@ -0,0 +1,26 @@
+/**
+ * Mock for $app/stores
+ * Provides minimal implementations for SvelteKit stores in library context
+ */
+
+import { writable } from 'svelte/store';
+
+// Mock page store
+export const page = writable({
+	url: new URL('http://localhost:3000'),
+	params: {},
+	route: { id: null },
+	status: 200,
+	error: null,
+	data: {},
+	form: null
+});
+
+// Mock navigating store
+export const navigating = writable(null);
+
+// Mock updated store
+export const updated = writable(false);
+
+// Mock preloadData function
+export const preloadData = async () => ({});

package/dist/services/api.d.ts

@@ -1,10 +1,20 @@
 /**
  * Client-side API service for FlowDrop
- * Provides methods to interact with the backend APIs
+ * Provides methods to interact with the backend APIs using configurable endpoints
  */
-import type { NodeMetadata, Workflow } from "../types/index.js";
+import type { NodeMetadata, Workflow } from '../types/index.js';
+import type { EndpointConfig } from '../config/endpoints.js';
 /**
- * Set the API base URL at runtime
+ * Set the endpoint configuration at runtime
+ */
+export declare function setEndpointConfig(config: EndpointConfig): void;
+/**
+ * Get the current endpoint configuration
+ */
+export declare function getEndpointConfig(): EndpointConfig | null;
+/**
+ * Set the API base URL (deprecated - use setEndpointConfig instead)
+ * @deprecated Use setEndpointConfig() with a full EndpointConfig object instead
  */
 export declare function setApiBaseUrl(url: string): void;
 /**

package/dist/services/api.js

@@ -1,24 +1,55 @@
 /**
  * Client-side API service for FlowDrop
- * Provides methods to interact with the backend APIs
+ * Provides methods to interact with the backend APIs using configurable endpoints
  */
-let API_BASE = "/api";
+import { buildEndpointUrl, getEndpointMethod, getEndpointHeaders } from '../config/endpoints.js';
+let endpointConfig = null;
 /**
- * Set the API base URL at runtime
+ * Set the endpoint configuration at runtime
+ */
+export function setEndpointConfig(config) {
+    endpointConfig = config;
+}
+/**
+ * Get the current endpoint configuration
+ */
+export function getEndpointConfig() {
+    return endpointConfig;
+}
+/**
+ * Set the API base URL (deprecated - use setEndpointConfig instead)
+ * @deprecated Use setEndpointConfig() with a full EndpointConfig object instead
  */
 export function setApiBaseUrl(url) {
-    API_BASE = url;
+    console.warn('⚠️ setApiBaseUrl() is deprecated. Use setEndpointConfig() with a full EndpointConfig object instead.');
+    if (!endpointConfig) {
+        // Dynamic import for backward compatibility
+        import('../config/endpoints.js')
+            .then(({ createEndpointConfig }) => {
+            endpointConfig = createEndpointConfig(url);
+        })
+            .catch((error) => {
+            // Failed to load endpoint config
+        });
+    }
+    else {
+        endpointConfig.baseUrl = url.replace(/\/$/, '');
+    }
 }
 /**
- * Generic API request helper
+ * Generic API request helper with endpoint configuration
  */
-async function apiRequest(endpoint, options = {}) {
+async function apiRequest(endpointKey, endpointPath, params, options = {}) {
+    if (!endpointConfig) {
+        throw new Error('Endpoint configuration not set. Call setEndpointConfig() first.');
+    }
     try {
-        const response = await fetch(`${API_BASE}${endpoint}`, {
-            headers: {
-                "Content-Type": "application/json",
-                ...options.headers
-            },
+        const url = buildEndpointUrl(endpointConfig, endpointPath, params);
+        const method = getEndpointMethod(endpointConfig, endpointKey);
+        const headers = getEndpointHeaders(endpointConfig, endpointKey);
+        const response = await fetch(url, {
+            method,
+            headers,
             ...options
         });
         const data = await response.json();
@@ -28,7 +59,6 @@ async function apiRequest(endpoint, options = {}) {
         return data;
     }
     catch (error) {
-        console.error(`API request failed for ${endpoint}:`, error);
         throw error;
     }
 }
@@ -40,25 +70,31 @@ export const nodeApi = {
      * Get all node types with optional filtering
      */
     async getNodes(options) {
+        if (!endpointConfig) {
+            throw new Error('Endpoint configuration not set');
+        }
         const params = new URLSearchParams();
         if (options?.category)
-            params.append("category", options.category);
+            params.append('category', options.category);
         if (options?.search)
-            params.append("search", options.search);
+            params.append('search', options.search);
         if (options?.limit)
-            params.append("limit", options.limit.toString());
+            params.append('limit', options.limit.toString());
         if (options?.offset)
-            params.append("offset", options.offset.toString());
-        const response = await apiRequest("/nodes?" + params.toString());
+            params.append('offset', options.offset.toString());
+        const response = await apiRequest('nodes.list', endpointConfig.endpoints.nodes.list + '?' + params.toString());
         return response.data || [];
     },
     /**
      * Get a specific node type by ID
      */
     async getNode(id) {
-        const response = await apiRequest(`/nodes/${id}`);
+        if (!endpointConfig) {
+            throw new Error('Endpoint configuration not set');
+        }
+        const response = await apiRequest('nodes.get', endpointConfig.endpoints.nodes.get, { id });
         if (!response.data) {
-            throw new Error("Node not found");
+            throw new Error('Node not found');
         }
         return response.data;
     }
@@ -71,23 +107,29 @@ export const workflowApi = {
      * Get all workflows with optional filtering
      */
     async getWorkflows(options) {
+        if (!endpointConfig) {
+            throw new Error('Endpoint configuration not set');
+        }
         const params = new URLSearchParams();
         if (options?.search)
-            params.append("search", options.search);
+            params.append('search', options.search);
         if (options?.limit)
-            params.append("limit", options.limit.toString());
+            params.append('limit', options.limit.toString());
         if (options?.offset)
-            params.append("offset", options.offset.toString());
-        const response = await apiRequest("/workflows?" + params.toString());
+            params.append('offset', options.offset.toString());
+        const response = await apiRequest('workflows.list', endpointConfig.endpoints.workflows.list + '?' + params.toString());
         return response.data || [];
     },
     /**
      * Get a specific workflow by ID
      */
     async getWorkflow(id) {
-        const response = await apiRequest(`/workflows/${id}`);
+        if (!endpointConfig) {
+            throw new Error('Endpoint configuration not set');
+        }
+        const response = await apiRequest('workflows.get', endpointConfig.endpoints.workflows.get, { id });
         if (!response.data) {
-            throw new Error("Workflow not found");
+            throw new Error('Workflow not found');
         }
         return response.data;
     },
@@ -95,12 +137,15 @@ export const workflowApi = {
      * Create a new workflow
      */
     async createWorkflow(workflow) {
-        const response = await apiRequest("/workflows", {
-            method: "POST",
+        if (!endpointConfig) {
+            throw new Error('Endpoint configuration not set');
+        }
+        const response = await apiRequest('workflows.create', endpointConfig.endpoints.workflows.create, undefined, {
+            method: 'POST',
             body: JSON.stringify(workflow)
         });
         if (!response.data) {
-            throw new Error("Failed to create workflow");
+            throw new Error('Failed to create workflow');
         }
         return response.data;
     },
@@ -108,12 +153,15 @@ export const workflowApi = {
      * Update an existing workflow
      */
     async updateWorkflow(id, workflow) {
-        const response = await apiRequest(`/workflows/${id}`, {
-            method: "PUT",
+        if (!endpointConfig) {
+            throw new Error('Endpoint configuration not set');
+        }
+        const response = await apiRequest('workflows.update', endpointConfig.endpoints.workflows.update, { id }, {
+            method: 'PUT',
             body: JSON.stringify(workflow)
         });
         if (!response.data) {
-            throw new Error("Failed to update workflow");
+            throw new Error('Failed to update workflow');
         }
         return response.data;
     },
@@ -121,20 +169,27 @@ export const workflowApi = {
      * Delete a workflow
      */
     async deleteWorkflow(id) {
-        await apiRequest(`/workflows/${id}`, {
-            method: "DELETE"
-        });
+        if (!endpointConfig) {
+            throw new Error('Endpoint configuration not set');
+        }
+        await apiRequest('workflows.delete', endpointConfig.endpoints.workflows.delete, { id }, { method: 'DELETE' });
     },
     /**
      * Save workflow (create or update)
      */
     async saveWorkflow(workflow) {
-        if (workflow.id && workflow.id.length === 36) {
-            // Update existing workflow (UUID is 36 characters)
+        // Check if this is an existing workflow by looking for a valid ID
+        // Valid IDs should not be a UUID (which indicates a new workflow)
+        const isExistingWorkflow = workflow.id &&
+            workflow.id.length > 0 &&
+            !workflow.id.match(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+        if (isExistingWorkflow) {
+            // Update existing workflow
             return this.updateWorkflow(workflow.id, workflow);
         }
         else {
             // Create new workflow
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
             const { id, ...workflowData } = workflow;
             return this.createWorkflow(workflowData);
         }

package/dist/services/globalSave.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Global Save Service
+ * Provides save and export functionality that can be accessed from anywhere in the app
+ * This allows the main navbar to save workflows without being tied to a specific component
+ */
+/**
+ * Global save function that can be called from anywhere
+ * Uses the current workflow from the global store
+ */
+export declare function globalSaveWorkflow(): Promise<void>;
+/**
+ * Global export function that can be called from anywhere
+ * Uses the current workflow from the global store
+ */
+export declare function globalExportWorkflow(): Promise<void>;
+/**
+ * Initialize global save functions on window object for external access
+ * This allows the functions to be called from anywhere in the application
+ */
+export declare function initializeGlobalSave(): void;

package/dist/services/globalSave.js

@@ -0,0 +1,165 @@
+/**
+ * Global Save Service
+ * Provides save and export functionality that can be accessed from anywhere in the app
+ * This allows the main navbar to save workflows without being tied to a specific component
+ */
+import { get } from 'svelte/store';
+import { workflowStore } from '../stores/workflowStore.js';
+import { workflowApi, setEndpointConfig } from './api.js';
+import { createEndpointConfig } from '../config/endpoints.js';
+import { v4 as uuidv4 } from 'uuid';
+import { apiToasts, workflowToasts, dismissToast } from './toastService.js';
+/**
+ * Ensure API configuration is initialized
+ * This is needed when the global save function is called from the layout component
+ * which doesn't initialize the API configuration like the App component does
+ */
+async function ensureApiConfiguration() {
+    // Check if we need to initialize the API configuration
+    // We'll check if the endpointConfig is already set by importing the api module
+    try {
+        // Import the api module to check if endpointConfig is already set
+        const { getEndpointConfig } = await import('./api.js');
+        // Try to get the current configuration
+        const currentConfig = getEndpointConfig();
+        if (currentConfig && currentConfig.baseUrl) {
+            return;
+        }
+    }
+    catch (error) {
+        // Could not check existing API configuration, initializing
+    }
+    // API configuration is not initialized, so let's initialize it
+    // Use the same environment variable priority as the App component
+    // Prioritize VITE_API_BASE_URL since it's configured correctly
+    const apiBaseUrl = import.meta.env.VITE_API_BASE_URL ||
+        import.meta.env.VITE_DRUPAL_API_URL ||
+        import.meta.env.VITE_FLOWDROP_API_URL ||
+        (() => {
+            // If we're in development (localhost:5173), use relative path
+            if (window.location.hostname === 'localhost' && window.location.port === '5173') {
+                return '/api/flowdrop';
+            }
+            // Otherwise, use the current domain
+            return `${window.location.protocol}//${window.location.host}/api/flowdrop`;
+        })();
+    const config = createEndpointConfig(apiBaseUrl, {
+        auth: {
+            type: 'none' // No authentication for now
+        },
+        timeout: 10000, // 10 second timeout
+        retry: {
+            enabled: true,
+            maxAttempts: 2,
+            delay: 1000,
+            backoff: 'exponential'
+        }
+    });
+    setEndpointConfig(config);
+}
+/**
+ * Global save function that can be called from anywhere
+ * Uses the current workflow from the global store
+ */
+export async function globalSaveWorkflow() {
+    let loadingToast;
+    try {
+        // Show loading toast
+        loadingToast = apiToasts.loading('Saving workflow');
+        // Ensure API configuration is initialized
+        await ensureApiConfiguration();
+        // Get current workflow from global store
+        const currentWorkflow = get(workflowStore);
+        if (!currentWorkflow) {
+            if (loadingToast)
+                dismissToast(loadingToast);
+            apiToasts.error('Save workflow', 'No workflow to save');
+            return;
+        }
+        // Determine the workflow ID
+        let workflowId;
+        if (currentWorkflow.id) {
+            workflowId = currentWorkflow.id;
+        }
+        else {
+            workflowId = uuidv4();
+        }
+        // Create workflow object for saving
+        const finalWorkflow = {
+            id: workflowId,
+            name: currentWorkflow.name || 'Untitled Workflow',
+            nodes: currentWorkflow.nodes || [],
+            edges: currentWorkflow.edges || [],
+            metadata: {
+                version: '1.0.0',
+                createdAt: currentWorkflow.metadata?.createdAt || new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            }
+        };
+        const savedWorkflow = await workflowApi.saveWorkflow(finalWorkflow);
+        // Dismiss loading toast and show success toast
+        if (loadingToast)
+            dismissToast(loadingToast);
+        workflowToasts.saved(finalWorkflow.name);
+    }
+    catch (error) {
+        // Dismiss loading toast and show error toast
+        if (loadingToast)
+            dismissToast(loadingToast);
+        apiToasts.error('Save workflow', error instanceof Error ? error.message : 'Unknown error');
+        throw error;
+    }
+}
+/**
+ * Global export function that can be called from anywhere
+ * Uses the current workflow from the global store
+ */
+export async function globalExportWorkflow() {
+    try {
+        // Get current workflow from global store
+        const currentWorkflow = get(workflowStore);
+        if (!currentWorkflow) {
+            apiToasts.error('Export workflow', 'No workflow to export');
+            return;
+        }
+        // Create workflow object for export
+        const finalWorkflow = {
+            id: currentWorkflow.id || 'untitled-workflow',
+            name: currentWorkflow.name || 'Untitled Workflow',
+            nodes: currentWorkflow.nodes || [],
+            edges: currentWorkflow.edges || [],
+            metadata: {
+                version: '1.0.0',
+                createdAt: currentWorkflow.metadata?.createdAt || new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            }
+        };
+        // Create and download the file
+        const dataStr = JSON.stringify(finalWorkflow, null, 2);
+        const dataBlob = new Blob([dataStr], { type: 'application/json' });
+        const url = URL.createObjectURL(dataBlob);
+        const link = document.createElement('a');
+        link.href = url;
+        link.download = `${finalWorkflow.name}.json`;
+        link.click();
+        URL.revokeObjectURL(url);
+        // Show success toast
+        workflowToasts.exported(finalWorkflow.name);
+    }
+    catch (error) {
+        // Export failed
+        apiToasts.error('Export workflow', error instanceof Error ? error.message : 'Unknown error');
+    }
+}
+/**
+ * Initialize global save functions on window object for external access
+ * This allows the functions to be called from anywhere in the application
+ */
+export function initializeGlobalSave() {
+    if (typeof window !== 'undefined') {
+        // @ts-ignore - Adding to window for external access
+        window.flowdropGlobalSave = globalSaveWorkflow;
+        // @ts-ignore - Adding to window for external access
+        window.flowdropGlobalExport = globalExportWorkflow;
+    }
+}

package/dist/services/nodeExecutionService.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Node Execution Service
+ * Handles fetching and managing node execution information from the backend
+ */
+import type { NodeExecutionInfo } from '../types/index.js';
+/**
+ * Service for managing node execution information
+ */
+export declare class NodeExecutionService {
+    private static instance;
+    private cache;
+    private cacheTimeout;
+    private lastFetch;
+    private apiUnavailable;
+    private apiUnavailableUntil;
+    private constructor();
+    static getInstance(): NodeExecutionService;
+    /**
+     * Get execution information for a specific node from pipeline data
+     */
+    getNodeExecutionInfo(nodeId: string, pipelineId?: string): Promise<NodeExecutionInfo | null>;
+    /**
+     * Get execution information for multiple nodes from pipeline data
+     */
+    getMultipleNodeExecutionInfo(nodeIds: string[], pipelineId?: string): Promise<Record<string, NodeExecutionInfo>>;
+    /**
+     * Get all node execution counts
+     */
+    getAllNodeExecutionCounts(): Promise<Record<string, number>>;
+    /**
+     * Get cached execution info for a node
+     */
+    getCachedNodeExecutionInfo(nodeId: string): NodeExecutionInfo | null;
+    /**
+     * Clear cache for a specific node
+     */
+    clearNodeCache(nodeId: string): void;
+    /**
+     * Clear all cache
+     */
+    clearAllCache(): void;
+    /**
+     * Check if cache is stale
+     */
+    isCacheStale(): boolean;
+    /**
+     * Update execution info for a node (for real-time updates)
+     */
+    updateNodeExecutionInfo(nodeId: string, executionInfo: Partial<NodeExecutionInfo>): void;
+    /**
+     * Map job status to execution status
+     */
+    private mapJobStatusToExecutionStatus;
+    /**
+     * Batch update execution info for multiple nodes
+     */
+    updateMultipleNodeExecutionInfo(updates: Record<string, Partial<NodeExecutionInfo>>): void;
+    /**
+     * Reset API availability status (useful for testing or when API becomes available)
+     */
+    resetApiAvailability(): void;
+}
+export declare const nodeExecutionService: NodeExecutionService;