@d34dman/flowdrop 0.0.1

package/dist/examples/adapter-usage.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Example: Using WorkflowAdapter for workflow management
+ * This demonstrates how systems can work with workflows without knowing SvelteFlow internals
+ */
+import { type StandardWorkflow } from "../adapters/WorkflowAdapter.js";
+declare function createSimpleWorkflow(): StandardWorkflow;
+declare function analyzeWorkflow(workflow: StandardWorkflow): {
+    stats: {
+        totalNodes: number;
+        totalEdges: number;
+        nodeTypeCounts: {
+            [k: string]: number;
+        };
+        lastModified: string;
+    };
+    validation: import("../adapters/WorkflowAdapter.js").WorkflowValidationResult;
+    complexity: number;
+};
+declare function calculateComplexity(workflow: StandardWorkflow): number;
+declare function optimizeWorkflow(workflow: StandardWorkflow): StandardWorkflow;
+declare function exportWorkflow(workflow: StandardWorkflow): string;
+declare function importWorkflow(json: string): StandardWorkflow;
+declare function getWorkflowStructure(workflow: StandardWorkflow): {
+    nodes: {
+        id: string;
+        type: string;
+        position: {
+            x: number;
+            y: number;
+        };
+        config: Record<string, unknown>;
+    }[];
+    edges: {
+        source: string;
+        target: string;
+        sourceHandle: string;
+        targetHandle: string;
+    }[];
+    metadata: {
+        name: string;
+        description: string;
+        version: string;
+        lastModified: string;
+    };
+};
+declare function getAvailableNodeTypes(): {
+    id: string;
+    name: string;
+    category: import("../index.js").NodeCategory;
+    description: string;
+    inputs: {
+        name: string;
+        type: import("../index.js").NodeDataType;
+        required: boolean;
+    }[];
+    outputs: {
+        name: string;
+        type: import("../index.js").NodeDataType;
+    }[];
+}[];
+declare function validateGeneratedWorkflow(workflowJson: string): {
+    valid: boolean;
+    errors: string[];
+    suggestions: string[];
+};
+export { createSimpleWorkflow, analyzeWorkflow, calculateComplexity, optimizeWorkflow, exportWorkflow, importWorkflow, getWorkflowStructure, getAvailableNodeTypes, validateGeneratedWorkflow };

package/dist/examples/adapter-usage.js

@@ -0,0 +1,138 @@
+/**
+ * Example: Using WorkflowAdapter for workflow management
+ * This demonstrates how systems can work with workflows without knowing SvelteFlow internals
+ */
+import { WorkflowAdapter } from "../adapters/WorkflowAdapter.js";
+import { sampleNodes } from "../data/samples.js";
+// Initialize the adapter with available node types
+const adapter = new WorkflowAdapter(sampleNodes);
+// Example 1: Create a simple workflow programmatically
+function createSimpleWorkflow() {
+    const workflow = adapter.createWorkflow("Chat Workflow", "A simple chat workflow");
+    // Add nodes
+    const inputNode = adapter.addNode(workflow, "text-input", { x: 100, y: 100 }, {
+        placeholder: "Enter your message"
+    });
+    const modelNode = adapter.addNode(workflow, "openai", { x: 300, y: 100 }, {
+        model: "gpt-4",
+        temperature: 0.7
+    });
+    const outputNode = adapter.addNode(workflow, "text-output", { x: 500, y: 100 });
+    // Connect nodes
+    adapter.addEdge(workflow, inputNode.id, modelNode.id, "text", "prompt");
+    adapter.addEdge(workflow, modelNode.id, outputNode.id, "text", "text");
+    return workflow;
+}
+// Example 2: Analyze a workflow structure
+function analyzeWorkflow(workflow) {
+    const stats = adapter.getWorkflowStats(workflow);
+    const validation = adapter.validateWorkflow(workflow);
+    console.log("Workflow Analysis:");
+    console.log(`- Total nodes: ${stats.totalNodes}`);
+    console.log(`- Total edges: ${stats.totalEdges}`);
+    console.log(`- Node types:`, stats.nodeTypeCounts);
+    console.log(`- Valid: ${validation.valid}`);
+    if (validation.errors.length > 0) {
+        console.log("Errors:", validation.errors);
+    }
+    if (validation.warnings.length > 0) {
+        console.log("Warnings:", validation.warnings);
+    }
+    return {
+        stats,
+        validation,
+        complexity: calculateComplexity(workflow)
+    };
+}
+// Example 3: Calculate workflow complexity
+function calculateComplexity(workflow) {
+    const nodeCount = workflow.nodes.length;
+    const edgeCount = workflow.edges.length;
+    const avgConnections = edgeCount / Math.max(nodeCount, 1);
+    // Simple complexity score
+    return nodeCount * avgConnections;
+}
+// Example 4: Optimize a workflow
+function optimizeWorkflow(workflow) {
+    const optimized = adapter.cloneWorkflow(workflow, `${workflow.name} (Optimized)`);
+    // Could make optimizations here
+    // For example, removing unused nodes, optimizing connections, etc.
+    return optimized;
+}
+// Example 5: Export/Import workflows
+function exportWorkflow(workflow) {
+    return adapter.exportWorkflow(workflow);
+}
+function importWorkflow(json) {
+    return adapter.importWorkflow(json);
+}
+// Example 6: Get workflow structure for analysis
+function getWorkflowStructure(workflow) {
+    return {
+        nodes: workflow.nodes.map(node => ({
+            id: node.id,
+            type: node.type,
+            position: node.position,
+            config: node.data.config
+        })),
+        edges: workflow.edges.map(edge => ({
+            source: edge.source,
+            target: edge.target,
+            sourceHandle: edge.sourceHandle,
+            targetHandle: edge.targetHandle
+        })),
+        metadata: {
+            name: workflow.name,
+            description: workflow.description,
+            version: workflow.metadata?.version,
+            lastModified: workflow.metadata?.updatedAt
+        }
+    };
+}
+// Example 7: Get available node types
+function getAvailableNodeTypes() {
+    return sampleNodes.map(node => ({
+        id: node.id,
+        name: node.name,
+        category: node.category,
+        description: node.description,
+        inputs: node.inputs.map(input => ({
+            name: input.name,
+            type: input.dataType,
+            required: input.required
+        })),
+        outputs: node.outputs.map(output => ({
+            name: output.name,
+            type: output.dataType
+        }))
+    }));
+}
+// Example 8: Validate generated workflow
+function validateGeneratedWorkflow(workflowJson) {
+    try {
+        const workflow = adapter.importWorkflow(workflowJson);
+        const validation = adapter.validateWorkflow(workflow);
+        const suggestions = [];
+        // Provide suggestions based on validation results
+        if (workflow.nodes.length === 0) {
+            suggestions.push("Consider adding input and output nodes");
+        }
+        if (workflow.edges.length === 0) {
+            suggestions.push("Connect nodes to create a data flow");
+        }
+        return {
+            valid: validation.valid,
+            errors: validation.errors,
+            suggestions
+        };
+    }
+    catch (error) {
+        return {
+            valid: false,
+            errors: [error instanceof Error ? error.message : "Unknown error"],
+            suggestions: ["Check the JSON format and required fields"]
+        };
+    }
+}
+// Export all examples for use
+export { createSimpleWorkflow, analyzeWorkflow, calculateComplexity, optimizeWorkflow, exportWorkflow, importWorkflow, getWorkflowStructure, getAvailableNodeTypes, validateGeneratedWorkflow };

package/dist/examples/api-client-usage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Example: Using FlowDrop API Client
+ * This demonstrates how to integrate with FlowDrop API from backend applications
+ */
+import type { Workflow } from "../types/index.js";
+declare function checkApiHealth(): Promise<{
+    status: string;
+    timestamp: string;
+    version: string;
+}>;
+declare function getNodeTypes(): Promise<import("../types/index.js").NodesResponse>;
+declare function manageWorkflows(): Promise<import("../types/index.js").WorkflowResponse>;
+declare function executeWorkflow(workflowId: string): Promise<import("../clients/ApiClient.js").ExecutionStatusResponse>;
+declare function importExportWorkflow(workflowId: string): Promise<import("../types/index.js").WorkflowResponse>;
+declare function validateWorkflow(workflow: Workflow): Promise<import("../clients/ApiClient.js").ValidationResponse>;
+declare function handleApiErrors(): Promise<void>;
+declare function batchOperations(): Promise<PromiseSettledResult<{
+    id: string;
+    name: string;
+    valid: boolean;
+    errors: number;
+    error?: undefined;
+} | {
+    id: string;
+    name: string;
+    valid: boolean;
+    error: string;
+    errors?: undefined;
+}>[]>;
+declare function monitorExecutions(workflowId: string): Promise<void>;
+export { checkApiHealth, getNodeTypes, manageWorkflows, executeWorkflow, importExportWorkflow, validateWorkflow, handleApiErrors, batchOperations, monitorExecutions };

package/dist/examples/api-client-usage.js

@@ -0,0 +1,241 @@
+/**
+ * Example: Using FlowDrop API Client
+ * This demonstrates how to integrate with FlowDrop API from backend applications
+ */
+import { ApiClient } from "../clients/ApiClient.js";
+// Initialize the API client
+const apiClient = new ApiClient({
+    baseUrl: "https://api.flowdrop.dev/v1",
+    apiKey: "your-api-key-here",
+    timeout: 30000
+});
+// Example 1: Health check
+async function checkApiHealth() {
+    try {
+        const health = await apiClient.healthCheck();
+        console.log("API Status:", health.status);
+        console.log("API Version:", health.version);
+        return health;
+    }
+    catch (error) {
+        console.error("API Health Check Failed:", error);
+        throw error;
+    }
+}
+// Example 2: Get available node types
+async function getNodeTypes() {
+    try {
+        // Get all node types
+        const allNodes = await apiClient.getNodeTypes();
+        console.log(`Found ${allNodes.data?.length || 0} node types`);
+        // Get node types by category
+        const modelNodes = await apiClient.getNodeTypesByCategory("models");
+        console.log(`Found ${modelNodes.data?.length || 0} model nodes`);
+        // Search for specific nodes
+        const searchResults = await apiClient.getNodeTypes({ search: "openai" });
+        console.log(`Found ${searchResults.data?.length || 0} OpenAI-related nodes`);
+        return allNodes;
+    }
+    catch (error) {
+        console.error("Failed to get node types:", error);
+        throw error;
+    }
+}
+// Example 3: Create and manage workflows
+async function manageWorkflows() {
+    try {
+        // Create a new workflow
+        const createRequest = {
+            name: "Chat Workflow",
+            description: "A simple chat workflow created via API",
+            tags: ["chat", "demo"]
+        };
+        const newWorkflow = await apiClient.createWorkflow(createRequest);
+        console.log("Created workflow:", newWorkflow.data?.id);
+        // Get all workflows
+        const workflows = await apiClient.getWorkflows({
+            limit: 10,
+            sort: "created_at",
+            order: "desc"
+        });
+        console.log(`Found ${workflows.data?.length || 0} workflows`);
+        // Get workflows by tag
+        const chatWorkflows = await apiClient.getWorkflowsByTag("chat");
+        console.log(`Found ${chatWorkflows.data?.length || 0} chat workflows`);
+        return newWorkflow;
+    }
+    catch (error) {
+        console.error("Failed to manage workflows:", error);
+        throw error;
+    }
+}
+// Example 4: Execute a workflow
+async function executeWorkflow(workflowId) {
+    try {
+        // Start execution
+        const execution = await apiClient.executeWorkflow(workflowId, {
+            inputs: {
+                message: "Hello, how are you?",
+                temperature: 0.7
+            },
+            options: {
+                timeout: 60,
+                maxSteps: 100
+            }
+        });
+        console.log("Execution started:", execution.data?.executionId);
+        // Wait for completion
+        const result = await apiClient.waitForExecution(execution.data.executionId);
+        if (result.data?.status === "completed") {
+            console.log("Execution completed successfully");
+            console.log("Result:", result.data?.result);
+        }
+        else {
+            console.log("Execution failed:", result.data?.error);
+        }
+        return result;
+    }
+    catch (error) {
+        console.error("Failed to execute workflow:", error);
+        throw error;
+    }
+}
+// Example 5: Import/Export workflows
+async function importExportWorkflow(workflowId) {
+    try {
+        // Export workflow
+        const exportedWorkflow = await apiClient.exportWorkflow(workflowId, "json");
+        console.log("Exported workflow:", exportedWorkflow.name);
+        // Modify the exported workflow
+        const modifiedWorkflow = {
+            ...exportedWorkflow,
+            id: "", // Will be generated by server
+            name: `${exportedWorkflow.name} (Imported)`,
+            metadata: {
+                ...exportedWorkflow.metadata,
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            }
+        };
+        // Import the modified workflow
+        const importedWorkflow = await apiClient.importWorkflow(modifiedWorkflow);
+        console.log("Imported workflow:", importedWorkflow.data?.id);
+        return importedWorkflow;
+    }
+    catch (error) {
+        console.error("Failed to import/export workflow:", error);
+        throw error;
+    }
+}
+// Example 6: Validate workflows
+async function validateWorkflow(workflow) {
+    try {
+        const validation = await apiClient.validateWorkflow(workflow);
+        if (validation.data?.valid) {
+            console.log("Workflow is valid");
+        }
+        else {
+            console.log("Workflow validation failed:");
+            console.log("Errors:", validation.data?.errors);
+            console.log("Warnings:", validation.data?.warnings);
+            console.log("Suggestions:", validation.data?.suggestions);
+        }
+        return validation;
+    }
+    catch (error) {
+        console.error("Failed to validate workflow:", error);
+        throw error;
+    }
+}
+// Example 7: Error handling
+async function handleApiErrors() {
+    try {
+        // This will fail - non-existent workflow
+        await apiClient.getWorkflow("non-existent-id");
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log("Error type:", error.constructor.name);
+            console.log("Error message:", error.message);
+            // Check if it's an API error
+            if ("status" in error) {
+                console.log("HTTP status:", error.status);
+                console.log("Error code:", error.code);
+                console.log("Error details:", error.details);
+            }
+        }
+    }
+}
+// Example 8: Batch operations
+async function batchOperations() {
+    try {
+        // Get all workflows
+        const workflows = await apiClient.getWorkflows({ limit: 100 });
+        // Process each workflow
+        const results = await Promise.allSettled(workflows.data?.map(async (workflow) => {
+            try {
+                // Validate each workflow
+                const validation = await apiClient.validateWorkflow(workflow);
+                return {
+                    id: workflow.id,
+                    name: workflow.name,
+                    valid: validation.data?.valid,
+                    errors: validation.data?.errors?.length || 0
+                };
+            }
+            catch (error) {
+                return {
+                    id: workflow.id,
+                    name: workflow.name,
+                    valid: false,
+                    error: error instanceof Error ? error.message : "Unknown error"
+                };
+            }
+        }) || []);
+        console.log("Batch validation results:", results);
+        return results;
+    }
+    catch (error) {
+        console.error("Failed to perform batch operations:", error);
+        throw error;
+    }
+}
+// Example 9: Real-time monitoring
+async function monitorExecutions(workflowId) {
+    try {
+        // Start execution
+        const execution = await apiClient.executeWorkflow(workflowId, {
+            inputs: { message: "Test message" }
+        });
+        const executionId = execution.data.executionId;
+        console.log("Monitoring execution:", executionId);
+        // Poll for status updates
+        const interval = setInterval(async () => {
+            try {
+                const status = await apiClient.getExecutionStatus(executionId);
+                console.log(`Status: ${status.data?.status}`);
+                if (status.data?.status === "completed" ||
+                    status.data?.status === "failed" ||
+                    status.data?.status === "cancelled") {
+                    clearInterval(interval);
+                    console.log("Execution finished:", status.data?.status);
+                }
+            }
+            catch (error) {
+                console.error("Failed to get execution status:", error);
+                clearInterval(interval);
+            }
+        }, 1000);
+        // Timeout after 5 minutes
+        setTimeout(() => {
+            clearInterval(interval);
+            console.log("Monitoring timeout");
+        }, 5 * 60 * 1000);
+    }
+    catch (error) {
+        console.error("Failed to monitor execution:", error);
+        throw error;
+    }
+}
+// Export all examples
+export { checkApiHealth, getNodeTypes, manageWorkflows, executeWorkflow, importExportWorkflow, validateWorkflow, handleApiErrors, batchOperations, monitorExecutions };

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * FlowDrop - Workflow Library
+ * A Svelte Flow-based library for building workflows
+ */
+import "../app.css";
+export type { NodeCategory, NodeDataType, NodePort, NodeMetadata, NodeConfig, WorkflowNode, WorkflowEdge, Workflow, ApiResponse, NodesResponse, WorkflowResponse, WorkflowsResponse, ExecutionStatus, ExecutionResult, FlowDropConfig, WorkflowEvents } from "./types/index.js";
+export { FlowDropApiClient } from "./api/client.js";
+export { default as WorkflowEditor } from "./components/WorkflowEditor.svelte";
+export { default as NodeSidebar } from "./components/NodeSidebar.svelte";
+export { default as WorkflowNodeComponent } from "./components/WorkflowNode.svelte";
+export { default as CanvasBanner } from "./components/CanvasBanner.svelte";
+export { sampleNodes, sampleWorkflow } from "./data/samples.js";
+export * from "./utils/icons.js";
+export * from "./utils/colors.js";
+export * from "./utils/connections.js";
+export * from "./services/api.js";
+export * from "./adapters/WorkflowAdapter.js";
+export * from "./clients/ApiClient.js";
+export { mountWorkflowEditor, unmountWorkflowEditor } from "./svelte-app.js";

package/dist/index.js

@@ -0,0 +1,27 @@
+/**
+ * FlowDrop - Workflow Library
+ * A Svelte Flow-based library for building workflows
+ */
+// Import CSS to ensure styles are included in the library build
+import "../app.css";
+// Export API client
+export { FlowDropApiClient } from "./api/client.js";
+// Export components
+export { default as WorkflowEditor } from "./components/WorkflowEditor.svelte";
+export { default as NodeSidebar } from "./components/NodeSidebar.svelte";
+export { default as WorkflowNodeComponent } from "./components/WorkflowNode.svelte";
+export { default as CanvasBanner } from "./components/CanvasBanner.svelte";
+// Export sample data for development
+export { sampleNodes, sampleWorkflow } from "./data/samples.js";
+// Export utilities
+export * from "./utils/icons.js";
+export * from "./utils/colors.js";
+export * from "./utils/connections.js";
+// Export services
+export * from "./services/api.js";
+// Export adapters
+export * from "./adapters/WorkflowAdapter.js";
+// Export API client
+export * from "./clients/ApiClient.js";
+// Export Svelte app wrapper for Drupal integration
+export { mountWorkflowEditor, unmountWorkflowEditor } from "./svelte-app.js";

package/dist/services/api.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Client-side API service for FlowDrop
+ * Provides methods to interact with the backend APIs
+ */
+import type { NodeMetadata, Workflow } from "../types/index.js";
+/**
+ * Set the API base URL at runtime
+ */
+export declare function setApiBaseUrl(url: string): void;
+/**
+ * Node API methods
+ */
+export declare const nodeApi: {
+    /**
+     * Get all node types with optional filtering
+     */
+    getNodes(options?: {
+        category?: string;
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<NodeMetadata[]>;
+    /**
+     * Get a specific node type by ID
+     */
+    getNode(id: string): Promise<NodeMetadata>;
+};
+/**
+ * Workflow API methods
+ */
+export declare const workflowApi: {
+    /**
+     * Get all workflows with optional filtering
+     */
+    getWorkflows(options?: {
+        search?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<Workflow[]>;
+    /**
+     * Get a specific workflow by ID
+     */
+    getWorkflow(id: string): Promise<Workflow>;
+    /**
+     * Create a new workflow
+     */
+    createWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
+    /**
+     * Update an existing workflow
+     */
+    updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow>;
+    /**
+     * Delete a workflow
+     */
+    deleteWorkflow(id: string): Promise<void>;
+    /**
+     * Save workflow (create or update)
+     */
+    saveWorkflow(workflow: Workflow): Promise<Workflow>;
+};
+/**
+ * Export the API service
+ */
+export declare const api: {
+    nodes: {
+        /**
+         * Get all node types with optional filtering
+         */
+        getNodes(options?: {
+            category?: string;
+            search?: string;
+            limit?: number;
+            offset?: number;
+        }): Promise<NodeMetadata[]>;
+        /**
+         * Get a specific node type by ID
+         */
+        getNode(id: string): Promise<NodeMetadata>;
+    };
+    workflows: {
+        /**
+         * Get all workflows with optional filtering
+         */
+        getWorkflows(options?: {
+            search?: string;
+            limit?: number;
+            offset?: number;
+        }): Promise<Workflow[]>;
+        /**
+         * Get a specific workflow by ID
+         */
+        getWorkflow(id: string): Promise<Workflow>;
+        /**
+         * Create a new workflow
+         */
+        createWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
+        /**
+         * Update an existing workflow
+         */
+        updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow>;
+        /**
+         * Delete a workflow
+         */
+        deleteWorkflow(id: string): Promise<void>;
+        /**
+         * Save workflow (create or update)
+         */
+        saveWorkflow(workflow: Workflow): Promise<Workflow>;
+    };
+};