@d34dman/flowdrop 0.0.1

package/dist/adapters/WorkflowAdapter.js

@@ -0,0 +1,337 @@
+/**
+ * WorkflowAdapter - Abstracts SvelteFlow internals for external systems
+ *
+ * This adapter provides a clean interface for working with workflows without
+ * needing to understand SvelteFlow's internal structure. It handles:
+ * - Converting between standard workflow format and SvelteFlow format
+ * - CRUD operations on workflows, nodes, and edges
+ * - Validation and error checking
+ * - Import/export functionality
+ *
+ * The adapter is designed to be used by:
+ * - Backend systems that need to process workflows
+ * - External applications that want to integrate with FlowDrop
+ * - Systems that need to generate or modify workflows programmatically
+ */
+import { v4 as uuidv4 } from "uuid";
+/**
+ * Workflow Adapter Class
+ * Provides a clean API for workflow operations without exposing SvelteFlow internals
+ */
+export class WorkflowAdapter {
+    nodeTypes = [];
+    constructor(nodeTypes = []) {
+        this.nodeTypes = nodeTypes;
+    }
+    /**
+     * Create a new workflow
+     */
+    createWorkflow(name, description) {
+        return {
+            id: uuidv4(),
+            name,
+            description,
+            nodes: [],
+            edges: [],
+            metadata: {
+                version: "1.0.0",
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            }
+        };
+    }
+    /**
+     * Add a node to a workflow
+     */
+    addNode(workflow, nodeType, position, config) {
+        const metadata = this.nodeTypes.find(nt => nt.id === nodeType);
+        if (!metadata) {
+            throw new Error(`Node type '${nodeType}' not found`);
+        }
+        const node = {
+            id: uuidv4(),
+            type: nodeType,
+            position,
+            data: {
+                label: metadata.name,
+                config: config || {},
+                metadata
+            }
+        };
+        workflow.nodes.push(node);
+        workflow.metadata.updatedAt = new Date().toISOString();
+        return node;
+    }
+    /**
+     * Remove a node from a workflow
+     */
+    removeNode(workflow, nodeId) {
+        const nodeIndex = workflow.nodes.findIndex(n => n.id === nodeId);
+        if (nodeIndex === -1)
+            return false;
+        workflow.nodes.splice(nodeIndex, 1);
+        // Remove associated edges
+        workflow.edges = workflow.edges.filter(edge => edge.source !== nodeId && edge.target !== nodeId);
+        workflow.metadata.updatedAt = new Date().toISOString();
+        return true;
+    }
+    /**
+     * Update node position
+     */
+    updateNodePosition(workflow, nodeId, position) {
+        const node = workflow.nodes.find(n => n.id === nodeId);
+        if (!node)
+            return false;
+        node.position = position;
+        workflow.metadata.updatedAt = new Date().toISOString();
+        return true;
+    }
+    /**
+     * Update node configuration
+     */
+    updateNodeConfig(workflow, nodeId, config) {
+        const node = workflow.nodes.find(n => n.id === nodeId);
+        if (!node)
+            return false;
+        node.data.config = { ...node.data.config, ...config };
+        workflow.metadata.updatedAt = new Date().toISOString();
+        return true;
+    }
+    /**
+     * Add an edge between nodes
+     */
+    addEdge(workflow, sourceNodeId, targetNodeId, sourceHandle, targetHandle) {
+        const edge = {
+            id: uuidv4(),
+            source: sourceNodeId,
+            target: targetNodeId,
+            sourceHandle,
+            targetHandle
+        };
+        workflow.edges.push(edge);
+        workflow.metadata.updatedAt = new Date().toISOString();
+        return edge;
+    }
+    /**
+     * Remove an edge from a workflow
+     */
+    removeEdge(workflow, edgeId) {
+        const edgeIndex = workflow.edges.findIndex(e => e.id === edgeId);
+        if (edgeIndex === -1)
+            return false;
+        workflow.edges.splice(edgeIndex, 1);
+        workflow.metadata.updatedAt = new Date().toISOString();
+        return true;
+    }
+    /**
+     * Get all nodes of a specific type
+     */
+    getNodesByType(workflow, nodeType) {
+        return workflow.nodes.filter(node => node.type === nodeType);
+    }
+    /**
+     * Get all edges connected to a node
+     */
+    getNodeEdges(workflow, nodeId) {
+        return workflow.edges.filter(edge => edge.source === nodeId || edge.target === nodeId);
+    }
+    /**
+     * Get connected nodes (both incoming and outgoing)
+     */
+    getConnectedNodes(workflow, nodeId) {
+        const connectedNodeIds = new Set();
+        workflow.edges.forEach(edge => {
+            if (edge.source === nodeId) {
+                connectedNodeIds.add(edge.target);
+            }
+            else if (edge.target === nodeId) {
+                connectedNodeIds.add(edge.source);
+            }
+        });
+        return workflow.nodes.filter(node => connectedNodeIds.has(node.id));
+    }
+    /**
+     * Validate workflow structure
+     */
+    validateWorkflow(workflow) {
+        const errors = [];
+        const warnings = [];
+        // Check for empty workflow
+        if (workflow.nodes.length === 0) {
+            warnings.push("Workflow has no nodes");
+        }
+        // Check for orphaned edges
+        const nodeIds = new Set(workflow.nodes.map(n => n.id));
+        workflow.edges.forEach(edge => {
+            if (!nodeIds.has(edge.source)) {
+                errors.push(`Edge ${edge.id} references non-existent source node ${edge.source}`);
+            }
+            if (!nodeIds.has(edge.target)) {
+                errors.push(`Edge ${edge.id} references non-existent target node ${edge.target}`);
+            }
+        });
+        // Check for self-connections
+        workflow.edges.forEach(edge => {
+            if (edge.source === edge.target) {
+                errors.push(`Node ${edge.source} cannot connect to itself`);
+            }
+        });
+        // Check for duplicate node IDs
+        const nodeIdCounts = new Map();
+        workflow.nodes.forEach(node => {
+            nodeIdCounts.set(node.id, (nodeIdCounts.get(node.id) || 0) + 1);
+        });
+        nodeIdCounts.forEach((count, id) => {
+            if (count > 1) {
+                errors.push(`Duplicate node ID: ${id}`);
+            }
+        });
+        // Check for duplicate edge IDs
+        const edgeIdCounts = new Map();
+        workflow.edges.forEach(edge => {
+            edgeIdCounts.set(edge.id, (edgeIdCounts.get(edge.id) || 0) + 1);
+        });
+        edgeIdCounts.forEach((count, id) => {
+            if (count > 1) {
+                errors.push(`Duplicate edge ID: ${id}`);
+            }
+        });
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    /**
+     * Export workflow to JSON
+     */
+    exportWorkflow(workflow) {
+        return JSON.stringify(workflow, null, 2);
+    }
+    /**
+     * Import workflow from JSON
+     */
+    importWorkflow(json) {
+        try {
+            const workflow = JSON.parse(json);
+            // Validate the imported workflow
+            const validation = this.validateWorkflow(workflow);
+            if (!validation.valid) {
+                throw new Error(`Invalid workflow: ${validation.errors.join(", ")}`);
+            }
+            // Update metadata
+            workflow.metadata = {
+                version: workflow.metadata?.version || "1.0.0",
+                createdAt: workflow.metadata?.createdAt || new Date().toISOString(),
+                updatedAt: new Date().toISOString(),
+                author: workflow.metadata?.author,
+                tags: workflow.metadata?.tags
+            };
+            return workflow;
+        }
+        catch (error) {
+            throw new Error(`Failed to import workflow: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * Convert SvelteFlow workflow to standard format
+     */
+    fromSvelteFlow(svelteFlowWorkflow) {
+        return {
+            id: svelteFlowWorkflow.id,
+            name: svelteFlowWorkflow.name,
+            description: svelteFlowWorkflow.description,
+            nodes: svelteFlowWorkflow.nodes.map(node => ({
+                id: node.id,
+                type: node.data.metadata.id,
+                position: node.position,
+                data: {
+                    label: node.data.label,
+                    config: node.data.config,
+                    metadata: node.data.metadata
+                }
+            })),
+            edges: svelteFlowWorkflow.edges.map(edge => ({
+                id: edge.id,
+                source: edge.source,
+                target: edge.target,
+                sourceHandle: edge.sourceHandle,
+                targetHandle: edge.targetHandle
+            })),
+            metadata: svelteFlowWorkflow.metadata
+        };
+    }
+    /**
+     * Convert standard workflow to SvelteFlow format
+     */
+    toSvelteFlow(workflow) {
+        return {
+            id: workflow.id,
+            name: workflow.name,
+            description: workflow.description,
+            nodes: workflow.nodes.map(node => ({
+                id: node.id,
+                type: "workflowNode",
+                position: node.position,
+                deletable: true,
+                data: {
+                    label: node.data.label,
+                    config: node.data.config,
+                    metadata: node.data.metadata,
+                    nodeId: node.id
+                }
+            })),
+            edges: workflow.edges.map(edge => ({
+                id: edge.id,
+                source: edge.source,
+                target: edge.target,
+                sourceHandle: edge.sourceHandle,
+                targetHandle: edge.targetHandle
+            })),
+            metadata: workflow.metadata
+        };
+    }
+    /**
+     * Get workflow statistics
+     */
+    getWorkflowStats(workflow) {
+        const nodeTypeCounts = new Map();
+        workflow.nodes.forEach(node => {
+            nodeTypeCounts.set(node.type, (nodeTypeCounts.get(node.type) || 0) + 1);
+        });
+        return {
+            totalNodes: workflow.nodes.length,
+            totalEdges: workflow.edges.length,
+            nodeTypeCounts: Object.fromEntries(nodeTypeCounts),
+            lastModified: workflow.metadata?.updatedAt
+        };
+    }
+    /**
+     * Clone a workflow
+     */
+    cloneWorkflow(workflow, newName) {
+        const cloned = JSON.parse(JSON.stringify(workflow));
+        // Generate new IDs for all nodes and edges
+        const idMapping = new Map();
+        cloned.nodes.forEach(node => {
+            const oldId = node.id;
+            node.id = uuidv4();
+            idMapping.set(oldId, node.id);
+        });
+        cloned.edges.forEach(edge => {
+            edge.id = uuidv4();
+            edge.source = idMapping.get(edge.source) || edge.source;
+            edge.target = idMapping.get(edge.target) || edge.target;
+        });
+        cloned.id = uuidv4();
+        cloned.name = newName || `${workflow.name} (Copy)`;
+        cloned.metadata = {
+            version: cloned.metadata?.version || "1.0.0",
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            author: cloned.metadata?.author,
+            tags: cloned.metadata?.tags
+        };
+        return cloned;
+    }
+}

package/dist/api/client.d.ts

@@ -0,0 +1,79 @@
+/**
+ * API Client for FlowDrop Workflow Library
+ */
+import type { NodeMetadata, Workflow, ExecutionResult } from "../types/index.js";
+/**
+ * HTTP API client for FlowDrop
+ */
+export declare class FlowDropApiClient {
+    private baseUrl;
+    private headers;
+    constructor(baseUrl: string, apiKey?: string);
+    /**
+     * Make HTTP request with error handling
+     */
+    private request;
+    /**
+     * Fetch available node types and their metadata
+     */
+    getAvailableNodes(): Promise<NodeMetadata[]>;
+    /**
+     * Fetch nodes by category
+     */
+    getNodesByCategory(category: string): Promise<NodeMetadata[]>;
+    /**
+     * Fetch a specific node's metadata
+     */
+    getNodeMetadata(nodeId: string): Promise<NodeMetadata>;
+    /**
+     * Save a workflow
+     */
+    saveWorkflow(workflow: Workflow): Promise<Workflow>;
+    /**
+     * Update an existing workflow
+     */
+    updateWorkflow(workflowId: string, workflow: Partial<Workflow>): Promise<Workflow>;
+    /**
+     * Load a workflow by ID
+     */
+    loadWorkflow(workflowId: string): Promise<Workflow>;
+    /**
+     * List all workflows
+     */
+    listWorkflows(): Promise<Workflow[]>;
+    /**
+     * Delete a workflow
+     */
+    deleteWorkflow(workflowId: string): Promise<void>;
+    /**
+     * Execute a workflow
+     */
+    executeWorkflow(workflowId: string, inputs?: Record<string, unknown>): Promise<ExecutionResult>;
+    /**
+     * Get execution status
+     */
+    getExecutionStatus(executionId: string): Promise<ExecutionResult>;
+    /**
+     * Cancel workflow execution
+     */
+    cancelExecution(executionId: string): Promise<void>;
+    /**
+     * Get execution logs
+     */
+    getExecutionLogs(executionId: string): Promise<string[]>;
+    /**
+     * Validate workflow configuration
+     */
+    validateWorkflow(workflow: Workflow): Promise<{
+        valid: boolean;
+        errors: string[];
+    }>;
+    /**
+     * Export workflow as JSON
+     */
+    exportWorkflow(workflowId: string): Promise<string>;
+    /**
+     * Import workflow from JSON
+     */
+    importWorkflow(workflowJson: string): Promise<Workflow>;
+}

package/dist/api/client.js

@@ -0,0 +1,208 @@
+/**
+ * API Client for FlowDrop Workflow Library
+ */
+/**
+ * HTTP API client for FlowDrop
+ */
+export class FlowDropApiClient {
+    baseUrl;
+    headers;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl.replace(/\/$/, "");
+        this.headers = {
+            "Content-Type": "application/json",
+        };
+        if (apiKey) {
+            this.headers["Authorization"] = `Bearer ${apiKey}`;
+        }
+    }
+    /**
+     * Make HTTP request with error handling
+     */
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const config = {
+            headers: this.headers,
+            ...options,
+        };
+        try {
+            const response = await fetch(url, config);
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const data = await response.json();
+            return data;
+        }
+        catch (error) {
+            console.error("API request failed:", error);
+            throw new Error(`API request failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    /**
+     * Fetch available node types and their metadata
+     */
+    async getAvailableNodes() {
+        const response = await this.request("/api/nodes");
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to fetch available nodes");
+        }
+        return response.data;
+    }
+    /**
+     * Fetch nodes by category
+     */
+    async getNodesByCategory(category) {
+        const response = await this.request(`/api/nodes?category=${encodeURIComponent(category)}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to fetch nodes by category");
+        }
+        return response.data;
+    }
+    /**
+     * Fetch a specific node's metadata
+     */
+    async getNodeMetadata(nodeId) {
+        const response = await this.request(`/api/nodes/${encodeURIComponent(nodeId)}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to fetch node metadata");
+        }
+        return response.data;
+    }
+    /**
+     * Save a workflow
+     */
+    async saveWorkflow(workflow) {
+        const response = await this.request("/api/workflows", {
+            method: "POST",
+            body: JSON.stringify(workflow),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to save workflow");
+        }
+        return response.data;
+    }
+    /**
+     * Update an existing workflow
+     */
+    async updateWorkflow(workflowId, workflow) {
+        const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}`, {
+            method: "PUT",
+            body: JSON.stringify(workflow),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to update workflow");
+        }
+        return response.data;
+    }
+    /**
+     * Load a workflow by ID
+     */
+    async loadWorkflow(workflowId) {
+        const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to load workflow");
+        }
+        return response.data;
+    }
+    /**
+     * List all workflows
+     */
+    async listWorkflows() {
+        const response = await this.request("/api/workflows");
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to list workflows");
+        }
+        return response.data;
+    }
+    /**
+     * Delete a workflow
+     */
+    async deleteWorkflow(workflowId) {
+        const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}`, {
+            method: "DELETE",
+        });
+        if (!response.success) {
+            throw new Error(response.error || "Failed to delete workflow");
+        }
+    }
+    /**
+     * Execute a workflow
+     */
+    async executeWorkflow(workflowId, inputs) {
+        const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}/execute`, {
+            method: "POST",
+            body: JSON.stringify({ inputs }),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to execute workflow");
+        }
+        return response.data;
+    }
+    /**
+     * Get execution status
+     */
+    async getExecutionStatus(executionId) {
+        const response = await this.request(`/api/executions/${encodeURIComponent(executionId)}`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to get execution status");
+        }
+        return response.data;
+    }
+    /**
+     * Cancel workflow execution
+     */
+    async cancelExecution(executionId) {
+        const response = await this.request(`/api/executions/${encodeURIComponent(executionId)}/cancel`, {
+            method: "POST",
+        });
+        if (!response.success) {
+            throw new Error(response.error || "Failed to cancel execution");
+        }
+    }
+    /**
+     * Get execution logs
+     */
+    async getExecutionLogs(executionId) {
+        const response = await this.request(`/api/executions/${encodeURIComponent(executionId)}/logs`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to get execution logs");
+        }
+        return response.data;
+    }
+    /**
+     * Validate workflow configuration
+     */
+    async validateWorkflow(workflow) {
+        const response = await this.request("/api/workflows/validate", {
+            method: "POST",
+            body: JSON.stringify(workflow),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to validate workflow");
+        }
+        return response.data;
+    }
+    /**
+     * Export workflow as JSON
+     */
+    async exportWorkflow(workflowId) {
+        const response = await this.request(`/api/workflows/${encodeURIComponent(workflowId)}/export`);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to export workflow");
+        }
+        return response.data;
+    }
+    /**
+     * Import workflow from JSON
+     */
+    async importWorkflow(workflowJson) {
+        const response = await this.request("/api/workflows/import", {
+            method: "POST",
+            body: JSON.stringify({ workflow: workflowJson }),
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || "Failed to import workflow");
+        }
+        return response.data;
+    }
+}