@d34dman/flowdrop 0.0.1

package/dist/services/api.js

@@ -0,0 +1,149 @@
+/**
+ * Client-side API service for FlowDrop
+ * Provides methods to interact with the backend APIs
+ */
+let API_BASE = "/api";
+/**
+ * Set the API base URL at runtime
+ */
+export function setApiBaseUrl(url) {
+    API_BASE = url;
+}
+/**
+ * Generic API request helper
+ */
+async function apiRequest(endpoint, options = {}) {
+    try {
+        const response = await fetch(`${API_BASE}${endpoint}`, {
+            headers: {
+                "Content-Type": "application/json",
+                ...options.headers
+            },
+            ...options
+        });
+        const data = await response.json();
+        if (!response.ok) {
+            throw new Error(data.error || `HTTP ${response.status}: ${response.statusText}`);
+        }
+        return data;
+    }
+    catch (error) {
+        console.error(`API request failed for ${endpoint}:`, error);
+        throw error;
+    }
+}
+/**
+ * Node API methods
+ */
+export const nodeApi = {
+    /**
+     * Get all node types with optional filtering
+     */
+    async getNodes(options) {
+        const params = new URLSearchParams();
+        if (options?.category)
+            params.append("category", options.category);
+        if (options?.search)
+            params.append("search", options.search);
+        if (options?.limit)
+            params.append("limit", options.limit.toString());
+        if (options?.offset)
+            params.append("offset", options.offset.toString());
+        const response = await apiRequest("/nodes?" + params.toString());
+        return response.data || [];
+    },
+    /**
+     * Get a specific node type by ID
+     */
+    async getNode(id) {
+        const response = await apiRequest(`/nodes/${id}`);
+        if (!response.data) {
+            throw new Error("Node not found");
+        }
+        return response.data;
+    }
+};
+/**
+ * Workflow API methods
+ */
+export const workflowApi = {
+    /**
+     * Get all workflows with optional filtering
+     */
+    async getWorkflows(options) {
+        const params = new URLSearchParams();
+        if (options?.search)
+            params.append("search", options.search);
+        if (options?.limit)
+            params.append("limit", options.limit.toString());
+        if (options?.offset)
+            params.append("offset", options.offset.toString());
+        const response = await apiRequest("/workflows?" + params.toString());
+        return response.data || [];
+    },
+    /**
+     * Get a specific workflow by ID
+     */
+    async getWorkflow(id) {
+        const response = await apiRequest(`/workflows/${id}`);
+        if (!response.data) {
+            throw new Error("Workflow not found");
+        }
+        return response.data;
+    },
+    /**
+     * Create a new workflow
+     */
+    async createWorkflow(workflow) {
+        const response = await apiRequest("/workflows", {
+            method: "POST",
+            body: JSON.stringify(workflow)
+        });
+        if (!response.data) {
+            throw new Error("Failed to create workflow");
+        }
+        return response.data;
+    },
+    /**
+     * Update an existing workflow
+     */
+    async updateWorkflow(id, workflow) {
+        const response = await apiRequest(`/workflows/${id}`, {
+            method: "PUT",
+            body: JSON.stringify(workflow)
+        });
+        if (!response.data) {
+            throw new Error("Failed to update workflow");
+        }
+        return response.data;
+    },
+    /**
+     * Delete a workflow
+     */
+    async deleteWorkflow(id) {
+        await apiRequest(`/workflows/${id}`, {
+            method: "DELETE"
+        });
+    },
+    /**
+     * Save workflow (create or update)
+     */
+    async saveWorkflow(workflow) {
+        if (workflow.id && workflow.id.length === 36) {
+            // Update existing workflow (UUID is 36 characters)
+            return this.updateWorkflow(workflow.id, workflow);
+        }
+        else {
+            // Create new workflow
+            const { id, ...workflowData } = workflow;
+            return this.createWorkflow(workflowData);
+        }
+    }
+};
+/**
+ * Export the API service
+ */
+export const api = {
+    nodes: nodeApi,
+    workflows: workflowApi
+};

package/dist/services/workflowStorage.d.ts

@@ -0,0 +1,37 @@
+/**
+ * In-memory workflow storage service
+ * This can be replaced with a database implementation later
+ */
+import type { Workflow } from "../types/index.js";
+/**
+ * Save a workflow
+ */
+export declare function saveWorkflow(workflow: Omit<Workflow, "id">): Promise<Workflow>;
+/**
+ * Update an existing workflow
+ */
+export declare function updateWorkflow(id: string, workflow: Partial<Workflow>): Promise<Workflow | null>;
+/**
+ * Get a workflow by ID
+ */
+export declare function getWorkflow(id: string): Promise<Workflow | null>;
+/**
+ * Get all workflows with optional filtering
+ */
+export declare function getWorkflows(options?: {
+    search?: string;
+    limit?: number;
+    offset?: number;
+}): Promise<Workflow[]>;
+/**
+ * Delete a workflow
+ */
+export declare function deleteWorkflow(id: string): Promise<boolean>;
+/**
+ * Get workflow count
+ */
+export declare function getWorkflowCount(): Promise<number>;
+/**
+ * Initialize with sample workflows (for development)
+ */
+export declare function initializeSampleWorkflows(): Promise<void>;

package/dist/services/workflowStorage.js

@@ -0,0 +1,116 @@
+/**
+ * In-memory workflow storage service
+ * This can be replaced with a database implementation later
+ */
+import { v4 as uuidv4 } from "uuid";
+// In-memory storage
+const workflows = new Map();
+/**
+ * Generate a unique workflow ID using UUID v4
+ */
+function generateWorkflowId() {
+    return uuidv4();
+}
+/**
+ * Save a workflow
+ */
+export async function saveWorkflow(workflow) {
+    const id = generateWorkflowId();
+    const newWorkflow = {
+        ...workflow,
+        id,
+        metadata: {
+            version: "1.0.0",
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            ...workflow.metadata
+        }
+    };
+    workflows.set(id, newWorkflow);
+    return newWorkflow;
+}
+/**
+ * Update an existing workflow
+ */
+export async function updateWorkflow(id, workflow) {
+    const existing = workflows.get(id);
+    if (!existing) {
+        return null;
+    }
+    const updatedWorkflow = {
+        ...existing,
+        ...workflow,
+        id, // Ensure ID doesn't change
+        metadata: {
+            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,
+            tags: workflow.metadata?.tags || existing.metadata?.tags
+        }
+    };
+    workflows.set(id, updatedWorkflow);
+    return updatedWorkflow;
+}
+/**
+ * Get a workflow by ID
+ */
+export async function getWorkflow(id) {
+    return workflows.get(id) || null;
+}
+/**
+ * Get all workflows with optional filtering
+ */
+export async function getWorkflows(options) {
+    let filteredWorkflows = Array.from(workflows.values());
+    // Apply search filter
+    if (options?.search) {
+        const searchLower = options.search.toLowerCase();
+        filteredWorkflows = filteredWorkflows.filter(workflow => workflow.name.toLowerCase().includes(searchLower) ||
+            workflow.description?.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() -
+        new Date(a.metadata?.updatedAt || 0).getTime());
+    // Apply pagination
+    const offset = options?.offset || 0;
+    const limit = options?.limit || filteredWorkflows.length;
+    return filteredWorkflows.slice(offset, offset + limit);
+}
+/**
+ * Delete a workflow
+ */
+export async function deleteWorkflow(id) {
+    return workflows.delete(id);
+}
+/**
+ * Get workflow count
+ */
+export async function getWorkflowCount() {
+    return workflows.size;
+}
+/**
+ * Initialize with sample workflows (for development)
+ */
+export async function initializeSampleWorkflows() {
+    // Only initialize if no workflows exist
+    if (workflows.size > 0) {
+        return;
+    }
+    // Add a sample workflow
+    const sampleWorkflow = {
+        name: "Sample Chat Workflow",
+        description: "A simple workflow demonstrating chat completion",
+        nodes: [],
+        edges: [],
+        metadata: {
+            version: "1.0.0",
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            author: "System",
+            tags: ["sample", "chat"]
+        }
+    };
+    await saveWorkflow(sampleWorkflow);
+}