@d34dman/flowdrop 0.0.1 → 0.0.2

package/dist/services/toastService.js

@@ -0,0 +1,235 @@
+/**
+ * Toast Service
+ * Centralized toast notification service using svelte-french-toast
+ * Provides consistent toast notifications across the FlowDrop application
+ */
+import { toast } from 'svelte-5-french-toast';
+/**
+ * Show a success toast notification
+ */
+export function showSuccess(message, options) {
+    return toast.success(message, {
+        duration: options?.duration || 4000,
+        position: options?.position || 'bottom-center'
+    });
+}
+/**
+ * Show an error toast notification
+ */
+export function showError(message, options) {
+    return toast.error(message, {
+        duration: options?.duration || 6000,
+        position: options?.position || 'bottom-center'
+    });
+}
+/**
+ * Show a warning toast notification
+ */
+export function showWarning(message, options) {
+    return toast.error(message, {
+        duration: options?.duration || 5000,
+        position: options?.position || 'bottom-center'
+    });
+}
+/**
+ * Show an info toast notification
+ */
+export function showInfo(message, options) {
+    return toast.success(message, {
+        duration: options?.duration || 4000,
+        position: options?.position || 'bottom-center'
+    });
+}
+/**
+ * Show a loading toast notification
+ */
+export function showLoading(message, options) {
+    return toast.loading(message, {
+        duration: options?.duration || Infinity,
+        position: options?.position || 'bottom-center'
+    });
+}
+/**
+ * Dismiss a specific toast by ID
+ */
+export function dismissToast(toastId) {
+    toast.dismiss(toastId);
+}
+/**
+ * Dismiss all toasts
+ */
+export function dismissAllToasts() {
+    toast.dismiss();
+}
+/**
+ * Show a promise-based toast (loading -> success/error)
+ */
+export function showPromise(promise, { loading, success, error, options }) {
+    return toast.promise(promise, {
+        loading,
+        success,
+        error,
+        ...options
+    });
+}
+/**
+ * Show a confirmation toast (simplified version without action buttons)
+ */
+export function showConfirmation(message, options) {
+    return toast(message, {
+        duration: options?.duration || 5000,
+        position: options?.position || 'bottom-center'
+    });
+}
+/**
+ * API-specific toast helpers
+ */
+export const apiToasts = {
+    /**
+     * Show API success message
+     */
+    success: (operation, details) => {
+        const message = details ? `${operation}: ${details}` : operation;
+        return showSuccess(message);
+    },
+    /**
+     * Show API error message
+     */
+    error: (operation, error) => {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return showError(`${operation} failed: ${errorMessage}`);
+    },
+    /**
+     * Show API loading message
+     */
+    loading: (operation) => {
+        return showLoading(`${operation}...`);
+    },
+    /**
+     * Show API promise with automatic success/error handling
+     */
+    promise: (promise, operation, options) => {
+        return showPromise(promise, {
+            loading: `${operation}...`,
+            success: options?.successMessage || `${operation} completed successfully`,
+            error: options?.errorMessage || `${operation} failed`
+        });
+    }
+};
+/**
+ * Workflow-specific toast helpers
+ */
+export const workflowToasts = {
+    /**
+     * Show workflow save success
+     */
+    saved: (workflowName) => {
+        const message = workflowName
+            ? `Workflow "${workflowName}" saved successfully`
+            : 'Workflow saved successfully';
+        return showSuccess(message);
+    },
+    /**
+     * Show workflow save error
+     */
+    saveError: (error) => {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return showError(`Failed to save workflow: ${errorMessage}`);
+    },
+    /**
+     * Show workflow delete success
+     */
+    deleted: (workflowName) => {
+        const message = workflowName
+            ? `Workflow "${workflowName}" deleted successfully`
+            : 'Workflow deleted successfully';
+        return showSuccess(message);
+    },
+    /**
+     * Show workflow delete error
+     */
+    deleteError: (error) => {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return showError(`Failed to delete workflow: ${errorMessage}`);
+    },
+    /**
+     * Show workflow execution started
+     */
+    executionStarted: (workflowName) => {
+        const message = workflowName
+            ? `Workflow "${workflowName}" execution started`
+            : 'Workflow execution started';
+        return showInfo(message);
+    },
+    /**
+     * Show workflow execution completed
+     */
+    executionCompleted: (workflowName) => {
+        const message = workflowName
+            ? `Workflow "${workflowName}" execution completed`
+            : 'Workflow execution completed';
+        return showSuccess(message);
+    },
+    /**
+     * Show workflow export success
+     */
+    exported: (workflowName) => {
+        const message = workflowName
+            ? `Workflow "${workflowName}" exported successfully`
+            : 'Workflow exported successfully';
+        return showSuccess(message);
+    },
+    /**
+     * Show workflow execution error
+     */
+    executionError: (error) => {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return showError(`Workflow execution failed: ${errorMessage}`);
+    }
+};
+/**
+ * Pipeline-specific toast helpers
+ */
+export const pipelineToasts = {
+    /**
+     * Show pipeline creation success
+     */
+    created: (pipelineName) => {
+        const message = pipelineName
+            ? `Pipeline "${pipelineName}" created successfully`
+            : 'Pipeline created successfully';
+        return showSuccess(message);
+    },
+    /**
+     * Show pipeline creation error
+     */
+    creationError: (error) => {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return showError(`Failed to create pipeline: ${errorMessage}`);
+    },
+    /**
+     * Show pipeline execution started
+     */
+    executionStarted: (pipelineId) => {
+        return showInfo(`Pipeline ${pipelineId} execution started`);
+    },
+    /**
+     * Show pipeline execution completed
+     */
+    executionCompleted: (pipelineId) => {
+        return showSuccess(`Pipeline ${pipelineId} execution completed`);
+    },
+    /**
+     * Show pipeline execution error
+     */
+    executionError: (pipelineId, error) => {
+        const errorMessage = error instanceof Error ? error.message : error;
+        return showError(`Pipeline ${pipelineId} execution failed: ${errorMessage}`);
+    },
+    /**
+     * Show pipeline status update
+     */
+    statusUpdate: (pipelineId, status) => {
+        return showInfo(`Pipeline ${pipelineId} status: ${status}`);
+    }
+};

package/dist/services/workflowStorage.d.ts

@@ -2,11 +2,11 @@
  * In-memory workflow storage service
  * This can be replaced with a database implementation later
  */
-import type { Workflow } from "../types/index.js";
+import type { Workflow } from '../types/index.js';
 /**
  * Save a workflow
  */
-export declare function saveWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
+export declare function saveWorkflow(workflow: Omit<Workflow, 'id'>): Promise<Workflow>;
 /**
  * Update an existing workflow
  */

package/dist/services/workflowStorage.js

@@ -2,7 +2,7 @@
  * In-memory workflow storage service
  * This can be replaced with a database implementation later
  */
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 // In-memory storage
 const workflows = new Map();
 /**
@@ -20,7 +20,7 @@ export async function saveWorkflow(workflow) {
         ...workflow,
         id,
         metadata: {
-            version: "1.0.0",
+            version: '1.0.0',
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             ...workflow.metadata
@@ -42,7 +42,7 @@ export async function updateWorkflow(id, workflow) {
         ...workflow,
         id, // Ensure ID doesn't change
         metadata: {
-            version: existing.metadata?.version || "1.0.0",
+            version: existing.metadata?.version || '1.0.0',
             createdAt: existing.metadata?.createdAt || new Date().toISOString(),
             updatedAt: new Date().toISOString(),
             author: workflow.metadata?.author || existing.metadata?.author,
@@ -66,9 +66,9 @@ export async function getWorkflows(options) {
     // Apply search filter
     if (options?.search) {
         const searchLower = options.search.toLowerCase();
-        filteredWorkflows = filteredWorkflows.filter(workflow => workflow.name.toLowerCase().includes(searchLower) ||
+        filteredWorkflows = filteredWorkflows.filter((workflow) => workflow.name.toLowerCase().includes(searchLower) ||
             workflow.description?.toLowerCase().includes(searchLower) ||
-            workflow.metadata?.tags?.some(tag => tag.toLowerCase().includes(searchLower)));
+            workflow.metadata?.tags?.some((tag) => tag.toLowerCase().includes(searchLower)));
     }
     // Sort by updated date (newest first)
     filteredWorkflows.sort((a, b) => new Date(b.metadata?.updatedAt || 0).getTime() -
@@ -100,16 +100,16 @@ export async function initializeSampleWorkflows() {
     }
     // Add a sample workflow
     const sampleWorkflow = {
-        name: "Sample Chat Workflow",
-        description: "A simple workflow demonstrating chat completion",
+        name: 'Sample Chat Workflow',
+        description: 'A simple workflow demonstrating chat completion',
         nodes: [],
         edges: [],
         metadata: {
-            version: "1.0.0",
+            version: '1.0.0',
             createdAt: new Date().toISOString(),
             updatedAt: new Date().toISOString(),
-            author: "System",
-            tags: ["sample", "chat"]
+            author: 'System',
+            tags: ['sample', 'chat']
         }
     };
     await saveWorkflow(sampleWorkflow);

package/dist/stores/workflowStore.d.ts

@@ -0,0 +1,53 @@
+import type { Workflow, WorkflowNode, WorkflowEdge } from '../types';
+export declare const workflowStore: import("svelte/store").Writable<Workflow>;
+export declare const workflowId: import("svelte/store").Readable<string>;
+export declare const workflowName: import("svelte/store").Readable<string>;
+export declare const workflowNodes: import("svelte/store").Readable<WorkflowNode[]>;
+export declare const workflowEdges: import("svelte/store").Readable<WorkflowEdge[]>;
+export declare const workflowMetadata: import("svelte/store").Readable<{
+    version: string;
+    createdAt: string;
+    updatedAt: string;
+    author?: string;
+    tags?: string[];
+    versionId?: string;
+    updateNumber?: number;
+}>;
+export declare const workflowActions: {
+    initialize: (workflow: Workflow) => void;
+    updateWorkflow: (workflow: Workflow) => void;
+    updateNodes: (nodes: WorkflowNode[]) => void;
+    updateEdges: (edges: WorkflowEdge[]) => void;
+    updateName: (name: string) => void;
+    addNode: (node: WorkflowNode) => void;
+    removeNode: (nodeId: string) => void;
+    addEdge: (edge: WorkflowEdge) => void;
+    removeEdge: (edgeId: string) => void;
+    updateNode: (nodeId: string, updates: Partial<WorkflowNode>) => void;
+    clear: () => void;
+    updateMetadata: (metadata: Partial<Workflow["metadata"]>) => void;
+    batchUpdate: (updates: {
+        nodes?: WorkflowNode[];
+        edges?: WorkflowEdge[];
+        name?: string;
+        description?: string;
+        metadata?: Partial<Workflow["metadata"]>;
+    }) => void;
+};
+export declare const workflowChanged: import("svelte/store").Readable<{
+    nodes: WorkflowNode[];
+    edges: WorkflowEdge[];
+    name: string;
+}>;
+export declare const workflowValidation: import("svelte/store").Readable<{
+    hasNodes: boolean;
+    hasEdges: boolean;
+    nodeCount: number;
+    edgeCount: number;
+    isValid: boolean;
+}>;
+export declare const workflowMetadataChanged: import("svelte/store").Readable<{
+    createdAt: string;
+    updatedAt: string;
+    version: string;
+}>;

package/dist/stores/workflowStore.js

@@ -0,0 +1,264 @@
+import { writable, derived } from 'svelte/store';
+// Global workflow state
+export const workflowStore = writable(null);
+// Derived stores for individual workflow properties
+export const workflowId = derived(workflowStore, ($workflow) => $workflow?.id || null);
+export const workflowName = derived(workflowStore, ($workflow) => $workflow?.name || 'Untitled Workflow');
+export const workflowNodes = derived(workflowStore, ($workflow) => $workflow?.nodes || []);
+export const workflowEdges = derived(workflowStore, ($workflow) => $workflow?.edges || []);
+export const workflowMetadata = derived(workflowStore, ($workflow) => $workflow?.metadata || {
+    version: '1.0.0',
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    versionId: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+    updateNumber: 0
+});
+// Helper function to check if workflow data has actually changed
+function hasWorkflowDataChanged(currentWorkflow, newNodes, newEdges) {
+    if (!currentWorkflow)
+        return true;
+    // Check if nodes have changed
+    if (currentWorkflow.nodes.length !== newNodes.length)
+        return true;
+    for (let i = 0; i < newNodes.length; i++) {
+        const currentNode = currentWorkflow.nodes[i];
+        const newNode = newNodes[i];
+        if (!currentNode || !newNode)
+            return true;
+        if (currentNode.id !== newNode.id)
+            return true;
+        if (currentNode.position.x !== newNode.position.x ||
+            currentNode.position.y !== newNode.position.y)
+            return true;
+        if (JSON.stringify(currentNode.data) !== JSON.stringify(newNode.data))
+            return true;
+    }
+    // Check if edges have changed
+    if (currentWorkflow.edges.length !== newEdges.length)
+        return true;
+    for (let i = 0; i < newEdges.length; i++) {
+        const currentEdge = currentWorkflow.edges[i];
+        const newEdge = newEdges[i];
+        if (!currentEdge || !newEdge)
+            return true;
+        if (currentEdge.id !== newEdge.id)
+            return true;
+        if (currentEdge.source !== newEdge.source || currentEdge.target !== newEdge.target)
+            return true;
+    }
+    return false;
+}
+// Actions for updating the workflow
+export const workflowActions = {
+    // Initialize workflow
+    initialize: (workflow) => {
+        console.log('🔍 Debug: initialize called with:', workflow);
+        workflowStore.set(workflow);
+        console.log('🔍 Debug: workflow store initialized');
+    },
+    // Update the entire workflow
+    updateWorkflow: (workflow) => {
+        console.log('🔍 Debug: updateWorkflow called with:', workflow);
+        workflowStore.set(workflow);
+        console.log('🔍 Debug: workflow store updated');
+    },
+    // Update nodes
+    updateNodes: (nodes) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            // Check if nodes have actually changed to prevent infinite loops
+            if (!hasWorkflowDataChanged($workflow, nodes, $workflow.edges)) {
+                console.log('🔍 Debug: Nodes unchanged, skipping update to prevent infinite loop');
+                return $workflow;
+            }
+            // Generate unique version identifier
+            const versionId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            console.log('🔍 Debug: Updating nodes with versionId:', versionId);
+            console.log('🔍 Debug: Node position changes detected:', nodes.map((node) => ({
+                id: node.id,
+                position: node.position
+            })));
+            return {
+                ...$workflow,
+                nodes,
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString(),
+                    versionId,
+                    updateNumber: ($workflow.metadata?.updateNumber || 0) + 1
+                }
+            };
+        });
+    },
+    // Update edges
+    updateEdges: (edges) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            // Check if edges have actually changed to prevent infinite loops
+            if (!hasWorkflowDataChanged($workflow, $workflow.nodes, edges)) {
+                console.log('🔍 Debug: Edges unchanged, skipping update to prevent infinite loop');
+                return $workflow;
+            }
+            // Generate unique version identifier
+            const versionId = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            console.log('🔍 Debug: Updating edges with versionId:', versionId);
+            return {
+                ...$workflow,
+                edges,
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString(),
+                    versionId,
+                    updateNumber: ($workflow.metadata?.updateNumber || 0) + 1
+                }
+            };
+        });
+    },
+    // Update workflow name
+    updateName: (name) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                name,
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    },
+    // Add a node
+    addNode: (node) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                nodes: [...$workflow.nodes, node],
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    },
+    // Remove a node
+    removeNode: (nodeId) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                nodes: $workflow.nodes.filter((node) => node.id !== nodeId),
+                edges: $workflow.edges.filter((edge) => edge.source !== nodeId && edge.target !== nodeId),
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    },
+    // Add an edge
+    addEdge: (edge) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                edges: [...$workflow.edges, edge],
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    },
+    // Remove an edge
+    removeEdge: (edgeId) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                edges: $workflow.edges.filter((edge) => edge.id !== edgeId),
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    },
+    // Update a specific node
+    updateNode: (nodeId, updates) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                nodes: $workflow.nodes.map((node) => (node.id === nodeId ? { ...node, ...updates } : node)),
+                metadata: {
+                    ...$workflow.metadata,
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    },
+    // Clear the workflow
+    clear: () => {
+        workflowStore.set(null);
+    },
+    // Update workflow metadata
+    updateMetadata: (metadata) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                metadata: {
+                    ...$workflow.metadata,
+                    ...metadata,
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    },
+    // Batch update nodes and edges (useful for complex operations)
+    batchUpdate: (updates) => {
+        workflowStore.update(($workflow) => {
+            if (!$workflow)
+                return null;
+            return {
+                ...$workflow,
+                ...(updates.nodes && { nodes: updates.nodes }),
+                ...(updates.edges && { edges: updates.edges }),
+                ...(updates.name && { name: updates.name }),
+                ...(updates.description !== undefined && { description: updates.description }),
+                metadata: {
+                    ...$workflow.metadata,
+                    ...(updates.metadata && { ...updates.metadata }),
+                    updatedAt: new Date().toISOString()
+                }
+            };
+        });
+    }
+};
+// Derived store for workflow changes (useful for triggering saves)
+export const workflowChanged = derived([workflowNodes, workflowEdges, workflowName], ([nodes, edges, name]) => ({ nodes, edges, name }));
+// Derived store for workflow validation
+export const workflowValidation = derived([workflowNodes, workflowEdges], ([nodes, edges]) => ({
+    hasNodes: nodes.length > 0,
+    hasEdges: edges.length > 0,
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    isValid: nodes.length > 0 && edges.length >= 0
+}));
+// Derived store for workflow metadata changes
+export const workflowMetadataChanged = derived(workflowMetadata, (metadata) => ({
+    createdAt: metadata.createdAt,
+    updatedAt: metadata.updatedAt,
+    version: metadata.version || '1.0.0'
+}));