@d34dman/flowdrop 0.0.17 → 0.0.19

package/dist/clients/ApiClient.js

@@ -1,214 +0,0 @@
-/**
- * FlowDrop API Client
- * Type-safe client for the FlowDrop API
- */
-/**
- * FlowDrop API Client Class
- */
-export class ApiClient {
-    config;
-    defaultHeaders;
-    constructor(config) {
-        this.config = {
-            timeout: 30000,
-            ...config
-        };
-        this.defaultHeaders = {
-            'Content-Type': 'application/json',
-            ...config.headers
-        };
-        if (config.apiKey) {
-            this.defaultHeaders.Authorization = `Bearer ${config.apiKey}`;
-        }
-    }
-    /**
-     * Make an HTTP request
-     */
-    async request(method, path, data, options = {}) {
-        const url = `${this.config.baseUrl}${path}`;
-        const headers = { ...this.defaultHeaders, ...options.headers };
-        const timeout = options.timeout || this.config.timeout;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), timeout);
-        try {
-            const response = await fetch(url, {
-                method,
-                headers,
-                body: data ? JSON.stringify(data) : undefined,
-                signal: controller.signal
-            });
-            clearTimeout(timeoutId);
-            if (!response.ok) {
-                const errorData = await response.json().catch(() => ({}));
-                throw new ApiError(response.status, errorData.error || `HTTP ${response.status}`, errorData.code, errorData.details);
-            }
-            return await response.json();
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof ApiError) {
-                throw error;
-            }
-            if (error instanceof Error && error.name === 'AbortError') {
-                throw new ApiError(408, 'Request timeout', 'TIMEOUT');
-            }
-            throw new ApiError(500, error instanceof Error ? error.message : 'Network error', 'NETWORK_ERROR');
-        }
-    }
-    // ===== HEALTH CHECK =====
-    /**
-     * Check API health
-     */
-    async healthCheck() {
-        return this.request('GET', '/health');
-    }
-    // ===== NODE TYPES =====
-    /**
-     * Get all node types
-     */
-    async getNodeTypes(query) {
-        const params = new URLSearchParams();
-        if (query?.category)
-            params.append('category', query.category);
-        if (query?.search)
-            params.append('search', query.search);
-        if (query?.limit)
-            params.append('limit', query.limit.toString());
-        if (query?.offset)
-            params.append('offset', query.offset.toString());
-        const path = `/nodes${params.toString() ? `?${params.toString()}` : ''}`;
-        return this.request('GET', path);
-    }
-    /**
-     * Get node type by ID
-     */
-    async getNodeType(id) {
-        return this.request('GET', `/nodes/${id}`);
-    }
-    // ===== WORKFLOWS =====
-    /**
-     * Get all workflows
-     */
-    async getWorkflows(query) {
-        const params = new URLSearchParams();
-        if (query?.search)
-            params.append('search', query.search);
-        if (query?.tags)
-            params.append('tags', query.tags);
-        if (query?.limit)
-            params.append('limit', query.limit.toString());
-        if (query?.offset)
-            params.append('offset', query.offset.toString());
-        if (query?.sort)
-            params.append('sort', query.sort);
-        if (query?.order)
-            params.append('order', query.order);
-        const path = `/workflows${params.toString() ? `?${params.toString()}` : ''}`;
-        return this.request('GET', path);
-    }
-    /**
-     * Get workflow by ID
-     */
-    async getWorkflow(id) {
-        return this.request('GET', `/workflows/${id}`);
-    }
-    /**
-     * Create a new workflow
-     */
-    async createWorkflow(data) {
-        return this.request('POST', '/workflows', data);
-    }
-    /**
-     * Update workflow
-     */
-    async updateWorkflow(id, data) {
-        return this.request('PUT', `/workflows/${id}`, data);
-    }
-    /**
-     * Delete workflow
-     */
-    async deleteWorkflow(id) {
-        return this.request('DELETE', `/workflows/${id}`);
-    }
-    // ===== WORKFLOW EXECUTION =====
-    /**
-     * Execute workflow
-     */
-    async executeWorkflow(id, data) {
-        return this.request('POST', `/workflows/${id}/execute`, data);
-    }
-    /**
-     * Get execution status
-     */
-    async getExecutionStatus(id) {
-        return this.request('GET', `/executions/${id}`);
-    }
-    /**
-     * Cancel execution
-     */
-    async cancelExecution(id) {
-        return this.request('POST', `/executions/${id}/cancel`);
-    }
-    // ===== IMPORT/EXPORT =====
-    /**
-     * Export workflow
-     */
-    async exportWorkflow(id, format = 'json') {
-        return this.request('GET', `/workflows/${id}/export?format=${format}`);
-    }
-    /**
-     * Import workflow
-     */
-    async importWorkflow(workflow) {
-        return this.request('POST', '/workflows/import', workflow);
-    }
-    // ===== VALIDATION =====
-    /**
-     * Validate workflow
-     */
-    async validateWorkflow(workflow) {
-        return this.request('POST', '/workflows/validate', workflow);
-    }
-    // ===== UTILITY METHODS =====
-    /**
-     * Wait for execution completion
-     */
-    async waitForExecution(id, pollInterval = 1000) {
-        while (true) {
-            const status = await this.getExecutionStatus(id);
-            if (status.data?.status === 'completed' ||
-                status.data?.status === 'failed' ||
-                status.data?.status === 'cancelled') {
-                return status;
-            }
-            await new Promise((resolve) => setTimeout(resolve, pollInterval));
-        }
-    }
-    /**
-     * Get workflows by tag
-     */
-    async getWorkflowsByTag(tag, query) {
-        return this.getWorkflows({ ...query, tags: tag });
-    }
-    /**
-     * Get node types by category
-     */
-    async getNodeTypesByCategory(category, query) {
-        return this.getNodeTypes({ ...query, category });
-    }
-}
-/**
- * API Error Class
- */
-export class ApiError extends Error {
-    status;
-    code;
-    details;
-    constructor(status, message, code, details) {
-        super(message);
-        this.status = status;
-        this.code = code;
-        this.details = details;
-        this.name = 'ApiError';
-    }
-}

package/dist/config/apiConfig.d.ts

@@ -1,34 +0,0 @@
-/**
- * API Configuration
- * Centralized configuration for all API endpoints
- */
-export interface ApiConfig {
-    baseUrl: string;
-    endpoints: {
-        workflows: {
-            list: string;
-            get: string;
-            create: string;
-            update: string;
-            delete: string;
-            execute: string;
-            executionState: string;
-        };
-        executions: {
-            active: string;
-        };
-        nodes: {
-            list: string;
-        };
-    };
-}
-/**
- * Default API configuration
- * For library usage, configuration should be provided at runtime
- * This provides sensible defaults that can be overridden
- */
-export declare const defaultApiConfig: ApiConfig;
-/**
- * Get full URL for an endpoint
- */
-export declare function getEndpointUrl(config: ApiConfig, endpoint: string, params?: Record<string, string>): string;

package/dist/config/apiConfig.js

@@ -1,40 +0,0 @@
-/**
- * API Configuration
- * Centralized configuration for all API endpoints
- */
-/**
- * Default API configuration
- * For library usage, configuration should be provided at runtime
- * This provides sensible defaults that can be overridden
- */
-export const defaultApiConfig = {
-    baseUrl: '/api/flowdrop',
-    endpoints: {
-        workflows: {
-            list: '/workflows',
-            get: '/workflows/{id}',
-            create: '/workflows',
-            update: '/workflows/{id}',
-            delete: '/workflows/{id}',
-            execute: '/workflows/{id}/execute',
-            executionState: '/workflows/{id}/executions/{execution_id}/state'
-        },
-        executions: {
-            active: '/executions/active'
-        },
-        nodes: {
-            list: '/nodes'
-        }
-    }
-};
-/**
- * Get full URL for an endpoint
- */
-export function getEndpointUrl(config, endpoint, params = {}) {
-    let url = config.baseUrl + endpoint;
-    // Replace path parameters
-    for (const [key, value] of Object.entries(params)) {
-        url = url.replace(`{${key}}`, value);
-    }
-    return url;
-}

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

@@ -1,66 +0,0 @@
-/**
- * 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("../index.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: string;
-        required: boolean;
-    }[];
-    outputs: {
-        name: string;
-        type: string;
-    }[];
-}[];
-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

@@ -1,133 +0,0 @@
-/**
- * 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-4o-mini',
-        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);
-    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

@@ -1,32 +0,0 @@
-/**
- * Example: Using FlowDrop API Client
- * Demonstrates how to integrate with FlowDrop API from applications
- * This client can be used with any backend that implements the FlowDrop API specification
- */
-import type { Workflow } from '../types/index.js';
-declare function checkApiHealth(): Promise<{
-    status: string;
-    timestamp: string;
-    version: string;
-}>;
-declare function getNodeTypes(): Promise<import("../index.js").NodesResponse>;
-declare function manageWorkflows(): Promise<import("../index.js").WorkflowResponse>;
-declare function executeWorkflow(workflowId: string): Promise<import("../index.js").ExecutionStatusResponse>;
-declare function importExportWorkflow(workflowId: string): Promise<import("../index.js").WorkflowResponse>;
-declare function validateWorkflow(workflow: Workflow): Promise<import("../index.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 };