@d34dman/flowdrop 0.0.1 → 0.0.2

package/dist/api/enhanced-client.js

@@ -0,0 +1,211 @@
+/**
+ * Enhanced API Client for FlowDrop
+ * Uses configurable endpoints for all API actions
+ */
+import { buildEndpointUrl, getEndpointMethod, getEndpointHeaders } from '../config/endpoints.js';
+/**
+ * Enhanced HTTP API client for FlowDrop with configurable endpoints
+ */
+export class EnhancedFlowDropApiClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    /**
+     * Make HTTP request with error handling and retry logic
+     */
+    async request(endpointKey, endpointPath, params, options = {}) {
+        const url = buildEndpointUrl(this.config, endpointPath, params);
+        const method = getEndpointMethod(this.config, endpointKey);
+        const headers = getEndpointHeaders(this.config, endpointKey);
+        const config = {
+            method,
+            headers,
+            ...options
+        };
+        let lastError = null;
+        const maxAttempts = this.config.retry?.enabled ? this.config.retry.maxAttempts : 1;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                const response = await fetch(url, config);
+                if (!response.ok) {
+                    const errorData = await response.json().catch(() => ({}));
+                    throw new Error(errorData.error || `HTTP ${response.status}: ${response.statusText}`);
+                }
+                const data = await response.json();
+                return data;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                // Don't retry on last attempt
+                if (attempt === maxAttempts) {
+                    console.error(`API request failed after ${maxAttempts} attempts:`, lastError);
+                    throw lastError;
+                }
+                // Wait before retry
+                const delay = this.config.retry?.delay || 1000;
+                const backoffDelay = this.config.retry?.backoff === 'exponential' ? delay * Math.pow(2, attempt - 1) : delay;
+                await new Promise((resolve) => setTimeout(resolve, backoffDelay));
+            }
+        }
+        throw lastError;
+    }
+    // Node API Methods
+    async getAvailableNodes() {
+        const response = await this.request('nodes.list', this.config.endpoints.nodes.list);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to fetch available nodes');
+        }
+        return response.data;
+    }
+    async getNodesByCategory(category) {
+        const response = await this.request('nodes.byCategory', this.config.endpoints.nodes.byCategory, { category });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to fetch nodes by category');
+        }
+        return response.data;
+    }
+    async getNodeMetadata(nodeId) {
+        const response = await this.request('nodes.metadata', this.config.endpoints.nodes.metadata, { id: nodeId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to fetch node metadata');
+        }
+        return response.data;
+    }
+    // Workflow API Methods
+    async saveWorkflow(workflow) {
+        const response = await this.request('workflows.create', this.config.endpoints.workflows.create, undefined, {
+            method: 'POST',
+            body: JSON.stringify(workflow)
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to save workflow');
+        }
+        return response.data;
+    }
+    async updateWorkflow(workflowId, workflow) {
+        const response = await this.request('workflows.update', this.config.endpoints.workflows.update, { id: workflowId }, {
+            method: 'PUT',
+            body: JSON.stringify(workflow)
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to update workflow');
+        }
+        return response.data;
+    }
+    async loadWorkflow(workflowId) {
+        const response = await this.request('workflows.get', this.config.endpoints.workflows.get, { id: workflowId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to load workflow');
+        }
+        return response.data;
+    }
+    async listWorkflows() {
+        const response = await this.request('workflows.list', this.config.endpoints.workflows.list);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to list workflows');
+        }
+        return response.data;
+    }
+    async deleteWorkflow(workflowId) {
+        const response = await this.request('workflows.delete', this.config.endpoints.workflows.delete, { id: workflowId }, { method: 'DELETE' });
+        if (!response.success) {
+            throw new Error(response.error || 'Failed to delete workflow');
+        }
+    }
+    async validateWorkflow(workflow) {
+        const response = await this.request('workflows.validate', this.config.endpoints.workflows.validate, undefined, {
+            method: 'POST',
+            body: JSON.stringify(workflow)
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to validate workflow');
+        }
+        return response.data;
+    }
+    async exportWorkflow(workflowId) {
+        const response = await this.request('workflows.export', this.config.endpoints.workflows.export, { id: workflowId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to export workflow');
+        }
+        return response.data;
+    }
+    async importWorkflow(workflowJson) {
+        const response = await this.request('workflows.import', this.config.endpoints.workflows.import, undefined, {
+            method: 'POST',
+            body: JSON.stringify({ workflow: workflowJson })
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to import workflow');
+        }
+        return response.data;
+    }
+    // Execution API Methods
+    async executeWorkflow(workflowId, inputs) {
+        const response = await this.request('executions.execute', this.config.endpoints.executions.execute, { id: workflowId }, {
+            method: 'POST',
+            body: JSON.stringify({ inputs })
+        });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to execute workflow');
+        }
+        return response.data;
+    }
+    async getExecutionStatus(executionId) {
+        const response = await this.request('executions.status', this.config.endpoints.executions.status, { id: executionId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to get execution status');
+        }
+        return response.data;
+    }
+    async cancelExecution(executionId) {
+        const response = await this.request('executions.cancel', this.config.endpoints.executions.cancel, { id: executionId }, { method: 'POST' });
+        if (!response.success) {
+            throw new Error(response.error || 'Failed to cancel execution');
+        }
+    }
+    async getExecutionLogs(executionId) {
+        const response = await this.request('executions.logs', this.config.endpoints.executions.logs, { id: executionId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to get execution logs');
+        }
+        return response.data;
+    }
+    // Template API Methods
+    async listTemplates() {
+        const response = await this.request('templates.list', this.config.endpoints.templates.list);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to list templates');
+        }
+        return response.data;
+    }
+    async getTemplate(templateId) {
+        const response = await this.request('templates.get', this.config.endpoints.templates.get, { id: templateId });
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to get template');
+        }
+        return response.data;
+    }
+    // System API Methods
+    async getSystemHealth() {
+        const response = await this.request('system.health', this.config.endpoints.system.health);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to get system health');
+        }
+        return response.data;
+    }
+    async getSystemConfig() {
+        const response = await this.request('system.config', this.config.endpoints.system.config);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to get system config');
+        }
+        return response.data;
+    }
+    async getSystemVersion() {
+        const response = await this.request('system.version', this.config.endpoints.system.version);
+        if (!response.success || !response.data) {
+            throw new Error(response.error || 'Failed to get system version');
+        }
+        return response.data;
+    }
+}

package/dist/clients/ApiClient.d.ts

@@ -2,7 +2,7 @@
  * FlowDrop API Client
  * Type-safe client for the FlowDrop API
  */
-import type { NodeMetadata, Workflow, ApiResponse, NodesResponse, WorkflowResponse, WorkflowsResponse } from "../types/index.js";
+import type { NodeMetadata, Workflow, ApiResponse, NodesResponse, WorkflowResponse, WorkflowsResponse } from '../types/index.js';
 /**
  * API Client Configuration
  */
@@ -43,8 +43,8 @@ export interface WorkflowsQuery {
     tags?: string;
     limit?: number;
     offset?: number;
-    sort?: "created_at" | "updated_at" | "name";
-    order?: "asc" | "desc";
+    sort?: 'created_at' | 'updated_at' | 'name';
+    order?: 'asc' | 'desc';
 }
 /**
  * Create workflow request
@@ -52,8 +52,8 @@ export interface WorkflowsQuery {
 export interface CreateWorkflowRequest {
     name: string;
     description?: string;
-    nodes?: any[];
-    edges?: any[];
+    nodes?: unknown[];
+    edges?: unknown[];
     tags?: string[];
 }
 /**
@@ -62,8 +62,8 @@ export interface CreateWorkflowRequest {
 export interface UpdateWorkflowRequest {
     name?: string;
     description?: string;
-    nodes?: any[];
-    edges?: any[];
+    nodes?: unknown[];
+    edges?: unknown[];
     tags?: string[];
 }
 /**
@@ -138,7 +138,7 @@ export declare class ApiClient {
     /**
      * Export workflow
      */
-    exportWorkflow(id: string, format?: "json" | "yaml"): Promise<Workflow>;
+    exportWorkflow(id: string, format?: 'json' | 'yaml'): Promise<Workflow>;
     /**
      * Import workflow
      */
@@ -154,11 +154,11 @@ export declare class ApiClient {
     /**
      * Get workflows by tag
      */
-    getWorkflowsByTag(tag: string, query?: Omit<WorkflowsQuery, "tags">): Promise<WorkflowsResponse>;
+    getWorkflowsByTag(tag: string, query?: Omit<WorkflowsQuery, 'tags'>): Promise<WorkflowsResponse>;
     /**
      * Get node types by category
      */
-    getNodeTypesByCategory(category: string, query?: Omit<NodeTypesQuery, "category">): Promise<NodesResponse>;
+    getNodeTypesByCategory(category: string, query?: Omit<NodeTypesQuery, 'category'>): Promise<NodesResponse>;
 }
 /**
  * API Error Class
@@ -172,32 +172,28 @@ export declare class ApiError extends Error {
 /**
  * Execution response types
  */
-export interface ExecutionResponse extends ApiResponse<{
+export type ExecutionResponse = ApiResponse<{
     executionId: string;
-    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
     message: string;
-}> {
-}
-export interface ExecutionStatusResponse extends ApiResponse<{
+}>;
+export type ExecutionStatusResponse = ApiResponse<{
     executionId: string;
-    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
     result?: unknown;
     error?: string;
     startTime: string;
     endTime?: string;
     duration?: number;
     nodeResults?: Record<string, unknown>;
-}> {
-}
-export interface ValidationResponse extends ApiResponse<{
+}>;
+export type ValidationResponse = ApiResponse<{
     valid: boolean;
     errors: string[];
     warnings: string[];
     suggestions?: string[];
-}> {
-}
+}>;
 /**
  * Type for node type response
  */
-export interface NodeTypeResponse extends ApiResponse<NodeMetadata> {
-}
+export type NodeTypeResponse = ApiResponse<NodeMetadata>;

package/dist/clients/ApiClient.js

@@ -14,7 +14,7 @@ export class ApiClient {
             ...config
         };
         this.defaultHeaders = {
-            "Content-Type": "application/json",
+            'Content-Type': 'application/json',
             ...config.headers
         };
         if (config.apiKey) {
@@ -49,10 +49,10 @@ export class ApiClient {
             if (error instanceof ApiError) {
                 throw error;
             }
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new ApiError(408, "Request timeout", "TIMEOUT");
+            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");
+            throw new ApiError(500, error instanceof Error ? error.message : 'Network error', 'NETWORK_ERROR');
         }
     }
     // ===== HEALTH CHECK =====
@@ -60,7 +60,7 @@ export class ApiClient {
      * Check API health
      */
     async healthCheck() {
-        return this.request("GET", "/health");
+        return this.request('GET', '/health');
     }
     // ===== NODE TYPES =====
     /**
@@ -69,21 +69,21 @@ export class ApiClient {
     async getNodeTypes(query) {
         const params = new URLSearchParams();
         if (query?.category)
-            params.append("category", query.category);
+            params.append('category', query.category);
         if (query?.search)
-            params.append("search", query.search);
+            params.append('search', query.search);
         if (query?.limit)
-            params.append("limit", query.limit.toString());
+            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);
+            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}`);
+        return this.request('GET', `/nodes/${id}`);
     }
     // ===== WORKFLOWS =====
     /**
@@ -92,82 +92,82 @@ export class ApiClient {
     async getWorkflows(query) {
         const params = new URLSearchParams();
         if (query?.search)
-            params.append("search", query.search);
+            params.append('search', query.search);
         if (query?.tags)
-            params.append("tags", query.tags);
+            params.append('tags', query.tags);
         if (query?.limit)
-            params.append("limit", query.limit.toString());
+            params.append('limit', query.limit.toString());
         if (query?.offset)
-            params.append("offset", query.offset.toString());
+            params.append('offset', query.offset.toString());
         if (query?.sort)
-            params.append("sort", 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);
+            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}`);
+        return this.request('GET', `/workflows/${id}`);
     }
     /**
      * Create a new workflow
      */
     async createWorkflow(data) {
-        return this.request("POST", "/workflows", data);
+        return this.request('POST', '/workflows', data);
     }
     /**
      * Update workflow
      */
     async updateWorkflow(id, data) {
-        return this.request("PUT", `/workflows/${id}`, data);
+        return this.request('PUT', `/workflows/${id}`, data);
     }
     /**
      * Delete workflow
      */
     async deleteWorkflow(id) {
-        return this.request("DELETE", `/workflows/${id}`);
+        return this.request('DELETE', `/workflows/${id}`);
     }
     // ===== WORKFLOW EXECUTION =====
     /**
      * Execute workflow
      */
     async executeWorkflow(id, data) {
-        return this.request("POST", `/workflows/${id}/execute`, data);
+        return this.request('POST', `/workflows/${id}/execute`, data);
     }
     /**
      * Get execution status
      */
     async getExecutionStatus(id) {
-        return this.request("GET", `/executions/${id}`);
+        return this.request('GET', `/executions/${id}`);
     }
     /**
      * Cancel execution
      */
     async cancelExecution(id) {
-        return this.request("POST", `/executions/${id}/cancel`);
+        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}`);
+    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);
+        return this.request('POST', '/workflows/import', workflow);
     }
     // ===== VALIDATION =====
     /**
      * Validate workflow
      */
     async validateWorkflow(workflow) {
-        return this.request("POST", "/workflows/validate", workflow);
+        return this.request('POST', '/workflows/validate', workflow);
     }
     // ===== UTILITY METHODS =====
     /**
@@ -176,10 +176,12 @@ export class ApiClient {
     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") {
+            if (status.data?.status === 'completed' ||
+                status.data?.status === 'failed' ||
+                status.data?.status === 'cancelled') {
                 return status;
             }
-            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
     }
     /**
@@ -207,6 +209,6 @@ export class ApiError extends Error {
         this.status = status;
         this.code = code;
         this.details = details;
-        this.name = "ApiError";
+        this.name = 'ApiError';
     }
 }