@allternit/workflow-engine 0.1.0 → 0.1.1

package/dist/visualizer/index.js.bak

@@ -1,277 +0,0 @@
-/**
- * Workflow Visualizer
- *
- * Generates visual representations of workflows.
- */
-/**
- * Create workflow visualizer
- */
-export function createVisualizer(config = {}) {
-    const { width = 1200, height = 800, nodeWidth = 180, nodeHeight = 60, hSpacing = 100, vSpacing = 80, autoLayout: enableAutoLayout = true, } = config;
-    /**
-     * Generate visual layout
-     */
-    function layout(workflow) {
-        let nodePositions;
-        if (enableAutoLayout) {
-            nodePositions = autoLayoutNodes(workflow.nodes, workflow.connections);
-        }
-        else {
-            // Use existing positions or default
-            nodePositions = {};
-            workflow.nodes.forEach(node => {
-                nodePositions[node.id] = node.position || { x: 0, y: 0 };
-            });
-        }
-        // Create visual nodes
-        const visualNodes = workflow.nodes.map(node => {
-            const pos = nodePositions[node.id];
-            return {
-                id: node.id,
-                x: pos.x,
-                y: pos.y,
-                width: nodeWidth,
-                height: nodeHeight,
-                label: node.name || node.type,
-                color: getNodeColor(node.type),
-                icon: getNodeIcon(node.type),
-            };
-        });
-        // Create visual connections
-        const visualConnections = workflow.connections.map(conn => {
-            const sourcePos = nodePositions[conn.source];
-            const targetPos = nodePositions[conn.target];
-            const source = {
-                x: sourcePos.x + nodeWidth / 2,
-                y: sourcePos.y + nodeHeight,
-            };
-            const target = {
-                x: targetPos.x + nodeWidth / 2,
-                y: targetPos.y,
-            };
-            return {
-                id: conn.id,
-                source,
-                target,
-                path: generatePath(source, target),
-            };
-        });
-        // Calculate bounds
-        const bounds = calculateBounds(visualNodes);
-        return {
-            nodes: visualNodes,
-            connections: visualConnections,
-            bounds,
-        };
-    }
-    /**
-     * Auto-layout nodes using layered graph layout
-     */
-    function autoLayout(nodes, connections) {
-        return autoLayoutNodes(nodes, connections);
-    }
-    /**
-     * Auto-layout nodes
-     */
-    function autoLayoutNodes(nodes, connections) {
-        const positions = {};
-        // Build adjacency list
-        const incoming = new Map();
-        const outgoing = new Map();
-        nodes.forEach(node => {
-            incoming.set(node.id, []);
-            outgoing.set(node.id, []);
-        });
-        connections.forEach(conn => {
-            outgoing.get(conn.source)?.push(conn.target);
-            incoming.get(conn.target)?.push(conn.source);
-        });
-        // Topological sort with layering
-        const layers = [];
-        const visited = new Set();
-        const inDegree = new Map();
-        nodes.forEach(node => {
-            inDegree.set(node.id, incoming.get(node.id)?.length || 0);
-        });
-        while (visited.size < nodes.length) {
-            const layer = [];
-            nodes.forEach(node => {
-                if (!visited.has(node.id) && (inDegree.get(node.id) || 0) === 0) {
-                    layer.push(node.id);
-                }
-            });
-            if (layer.length === 0) {
-                // Cycle detected, add remaining nodes
-                nodes.forEach(node => {
-                    if (!visited.has(node.id)) {
-                        layer.push(node.id);
-                    }
-                });
-            }
-            layers.push(layer);
-            layer.forEach(nodeId => {
-                visited.add(nodeId);
-                outgoing.get(nodeId)?.forEach(targetId => {
-                    const degree = inDegree.get(targetId) || 0;
-                    inDegree.set(targetId, degree - 1);
-                });
-            });
-        }
-        // Position nodes in layers
-        layers.forEach((layer, layerIndex) => {
-            const layerWidth = layer.length * (nodeWidth + hSpacing) - hSpacing;
-            const startX = (width - layerWidth) / 2;
-            layer.forEach((nodeId, index) => {
-                positions[nodeId] = {
-                    x: startX + index * (nodeWidth + hSpacing),
-                    y: 100 + layerIndex * (nodeHeight + vSpacing),
-                };
-            });
-        });
-        return positions;
-    }
-    /**
-     * Generate SVG path between two points
-     */
-    function generatePath(source, target) {
-        const midY = (source.y + target.y) / 2;
-        return `M ${source.x} ${source.y} C ${source.x} ${midY}, ${target.x} ${midY}, ${target.x} ${target.y}`;
-    }
-    /**
-     * Calculate bounds
-     */
-    function calculateBounds(nodes) {
-        if (nodes.length === 0) {
-            return { minX: 0, minY: 0, maxX: width, maxY: height, width, height };
-        }
-        const xs = nodes.map(n => n.x);
-        const ys = nodes.map(n => n.y);
-        const minX = Math.min(...xs) - 50;
-        const minY = Math.min(...ys) - 50;
-        const maxX = Math.max(...xs) + nodeWidth + 50;
-        const maxY = Math.max(...ys) + nodeHeight + 50;
-        return {
-            minX,
-            minY,
-            maxX,
-            maxY,
-            width: maxX - minX,
-            height: maxY - minY,
-        };
-    }
-    /**
-     * Get node color by type
-     */
-    function getNodeColor(type) {
-        const colors = {
-            'trigger:manual': '#3b82f6',
-            'trigger:schedule': '#3b82f6',
-            'trigger:webhook': '#3b82f6',
-            'transform:map': '#10b981',
-            'transform:filter': '#10b981',
-            'condition:if': '#f59e0b',
-            'loop:for-each': '#8b5cf6',
-            'delay:wait': '#6b7280',
-            'http:request': '#ec4899',
-            'output:result': '#ef4444',
-            'output:log': '#6b7280',
-        };
-        return colors[type] || '#6b7280';
-    }
-    /**
-     * Get node icon by type
-     */
-    function getNodeIcon(type) {
-        const icons = {
-            'trigger:manual': 'play',
-            'trigger:schedule': 'clock',
-            'trigger:webhook': 'webhook',
-            'transform:map': 'transform',
-            'transform:filter': 'filter',
-            'condition:if': 'git-branch',
-            'loop:for-each': 'repeat',
-            'delay:wait': 'timer',
-            'http:request': 'globe',
-            'output:result': 'check-circle',
-            'output:log': 'file-text',
-        };
-        return icons[type] || 'box';
-    }
-    /**
-     * Export to SVG
-     */
-    function toSVG(workflow) {
-        const { nodes, connections, bounds } = layout(workflow);
-        const svgWidth = bounds.width;
-        const svgHeight = bounds.height;
-        let svg = `<svg width="${svgWidth}" height="${svgHeight}" viewBox="${bounds.minX} ${bounds.minY} ${svgWidth} ${svgHeight}" xmlns="http://www.w3.org/2000/svg">\n`;
-        // Definitions
-        svg += `  <defs>\n`;
-        svg += `    <marker id="arrowhead" markerWidth="10" markerHeight="7" refX="9" refY="3.5" orient="auto">\n`;
-        svg += `      <polygon points="0 0, 10 3.5, 0 7" fill="#6b7280" />\n`;
-        svg += `    </marker>\n`;
-        svg += `  </defs>\n`;
-        // Connections
-        connections.forEach(conn => {
-            svg += `  <path d="${conn.path}" fill="none" stroke="#6b7280" stroke-width="2" marker-end="url(#arrowhead)" />\n`;
-        });
-        // Nodes
-        nodes.forEach(node => {
-            const rx = 8;
-            svg += `  <g transform="translate(${node.x}, ${node.y})">\n`;
-            svg += `    <rect width="${node.width}" height="${node.height}" rx="${rx}" fill="${node.color}" stroke="none" />\n`;
-            svg += `    <text x="${node.width / 2}" y="${node.height / 2}" text-anchor="middle" dominant-baseline="middle" fill="white" font-family="sans-serif" font-size="14">${node.label}</text>\n`;
-            svg += `  </g>\n`;
-        });
-        svg += `</svg>`;
-        return svg;
-    }
-    /**
-     * Export to Mermaid diagram
-     */
-    function toMermaid(workflow) {
-        let mermaid = 'graph TD\n';
-        // Node definitions
-        workflow.nodes.forEach(node => {
-            const label = node.name || node.type;
-            mermaid += `  ${node.id}["${label}"]\n`;
-        });
-        // Connections
-        workflow.connections.forEach(conn => {
-            mermaid += `  ${conn.source} --> ${conn.target}\n`;
-        });
-        return mermaid;
-    }
-    /**
-     * Export to DOT (Graphviz)
-     */
-    function toDOT(workflow) {
-        let dot = 'digraph Workflow {\n';
-        dot += '  rankdir=TB;\n';
-        dot += '  node [shape=box, style=filled, fontname="sans-serif"];\n';
-        // Node definitions
-        workflow.nodes.forEach(node => {
-            const label = node.name || node.type;
-            const color = getNodeColor(node.type);
-            dot += `  "${node.id}" [label="${label}", fillcolor="${color}", fontcolor=white];\n`;
-        });
-        // Connections
-        workflow.connections.forEach(conn => {
-            dot += `  "${conn.source}" -> "${conn.target}";\n`;
-        });
-        dot += '}';
-        return dot;
-    }
-    return {
-        layout,
-        autoLayout,
-        toSVG,
-        toMermaid,
-        toDOT,
-    };
-}
-/**
- * Global visualizer instance
- */
-export const globalVisualizer = createVisualizer();
-//# sourceMappingURL=index.js.map

package/src/__tests__/visualizer.test.ts.bak

@@ -1,110 +0,0 @@
-/**
- * Workflow Visualizer Tests
- */
-
-import { describe, it, expect } from 'vitest';
-import { createVisualizer } from '../visualizer';
-import type { Workflow } from '../types';
-
-describe('WorkflowVisualizer', () => {
-  const sampleWorkflow: Workflow = {
-    id: 'test-workflow',
-    name: 'Test Workflow',
-    version: '1.0.0',
-    nodes: [
-      { id: 'trigger', type: 'trigger:manual', name: 'Start', position: { x: 100, y: 100 } },
-      { id: 'http', type: 'http:request', name: 'HTTP Request', position: { x: 100, y: 200 } },
-      { id: 'condition', type: 'condition:if', name: 'Check', position: { x: 100, y: 300 } },
-      { id: 'output1', type: 'output:result', name: 'Success', position: { x: 50, y: 400 } },
-      { id: 'output2', type: 'output:result', name: 'Error', position: { x: 150, y: 400 } },
-    ],
-    connections: [
-      { id: 'c1', source: 'trigger', target: 'http' },
-      { id: 'c2', source: 'http', target: 'condition' },
-      { id: 'c3', source: 'condition', target: 'output1' },
-      { id: 'c4', source: 'condition', target: 'output2' },
-    ],
-  };
-
-  describe('layout', () => {
-    it('should generate visual layout', () => {
-      const visualizer = createVisualizer({ autoLayout: false });
-      const layout = visualizer.layout(sampleWorkflow);
-
-      expect(layout.nodes).toHaveLength(5);
-      expect(layout.connections).toHaveLength(4);
-      expect(layout.bounds).toBeDefined();
-    });
-
-    it('should position nodes correctly', () => {
-      const visualizer = createVisualizer({ autoLayout: false });
-      const layout = visualizer.layout(sampleWorkflow);
-
-      const triggerNode = layout.nodes.find(n => n.id === 'trigger');
-      expect(triggerNode?.x).toBe(100);
-      expect(triggerNode?.y).toBe(100);
-    });
-  });
-
-  describe('auto layout', () => {
-    it('should auto-layout nodes in layers', () => {
-      const visualizer = createVisualizer({ autoLayout: true });
-      const positions = visualizer.autoLayout(sampleWorkflow.nodes, sampleWorkflow.connections);
-
-      expect(Object.keys(positions)).toHaveLength(5);
-      
-      // Check that all nodes have positions
-      sampleWorkflow.nodes.forEach(node => {
-        expect(positions[node.id]).toBeDefined();
-        expect(positions[node.id].x).toBeGreaterThanOrEqual(0);
-        expect(positions[node.id].y).toBeGreaterThanOrEqual(0);
-      });
-    });
-  });
-
-  describe('export formats', () => {
-    it('should export to SVG', () => {
-      const visualizer = createVisualizer();
-      const svg = visualizer.toSVG(sampleWorkflow);
-
-      expect(svg).toContain('<svg');
-      expect(svg).toContain('</svg>');
-      expect(svg).toContain('Start');
-      expect(svg).toContain('HTTP Request');
-    });
-
-    it('should export to Mermaid', () => {
-      const visualizer = createVisualizer();
-      const mermaid = visualizer.toMermaid(sampleWorkflow);
-
-      expect(mermaid).toContain('graph TD');
-      expect(mermaid).toContain('trigger');
-      expect(mermaid).toContain('http');
-      expect(mermaid).toContain('-->');
-    });
-
-    it('should export to DOT', () => {
-      const visualizer = createVisualizer();
-      const dot = visualizer.toDOT(sampleWorkflow);
-
-      expect(dot).toContain('digraph Workflow');
-      expect(dot).toContain('trigger');
-      expect(dot).toContain('->');
-    });
-  });
-
-  describe('node colors', () => {
-    it('should assign colors by node type', () => {
-      const visualizer = createVisualizer();
-      const layout = visualizer.layout(sampleWorkflow);
-
-      const triggerNode = layout.nodes.find(n => n.id === 'trigger');
-      const httpNode = layout.nodes.find(n => n.id === 'http');
-      const conditionNode = layout.nodes.find(n => n.id === 'condition');
-
-      expect(triggerNode?.color).toBe('#3b82f6'); // Blue for triggers
-      expect(httpNode?.color).toBe('#ec4899'); // Pink for HTTP
-      expect(conditionNode?.color).toBe('#f59e0b'); // Orange for conditions
-    });
-  });
-});

package/src/__tests__/workflow-engine.test.ts.bak

@@ -1,239 +0,0 @@
-/**
- * Workflow Engine Tests
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { createWorkflowEngine } from '../engine/workflow-engine';
-import type { Workflow } from '../types';
-
-describe('WorkflowEngine', () => {
-  let engine: ReturnType<typeof createWorkflowEngine>;
-
-  beforeEach(() => {
-    engine = createWorkflowEngine();
-  });
-
-  describe('workflow management', () => {
-    it('should register and retrieve workflow', () => {
-      const workflow: Workflow = {
-        id: 'test-workflow',
-        name: 'Test Workflow',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow);
-      const retrieved = engine.getWorkflow('test-workflow');
-
-      expect(retrieved).toEqual(workflow);
-    });
-
-    it('should list all workflows', () => {
-      const workflow1: Workflow = {
-        id: 'workflow-1',
-        name: 'Workflow 1',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-
-      const workflow2: Workflow = {
-        id: 'workflow-2',
-        name: 'Workflow 2',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow1);
-      engine.registerWorkflow(workflow2);
-
-      const workflows = engine.listWorkflows();
-      expect(workflows).toHaveLength(2);
-    });
-
-    it('should delete workflow', () => {
-      const workflow: Workflow = {
-        id: 'test-workflow',
-        name: 'Test Workflow',
-        version: '1.0.0',
-        nodes: [],
-        connections: [],
-      };
-
-      engine.registerWorkflow(workflow);
-      expect(engine.getWorkflow('test-workflow')).toBeDefined();
-
-      engine.deleteWorkflow('test-workflow');
-      expect(engine.getWorkflow('test-workflow')).toBeUndefined();
-    });
-  });
-
-  describe('workflow execution', () => {
-    it('should execute simple workflow', async () => {
-      const workflow: Workflow = {
-        id: 'simple-workflow',
-        name: 'Simple Workflow',
-        version: '1.0.0',
-        nodes: [
-          {
-            id: 'trigger',
-            type: 'trigger:manual',
-            name: 'Start',
-          },
-          {
-            id: 'output',
-            type: 'output:result',
-            name: 'End',
-          },
-        ],
-        connections: [
-          { id: 'c1', source: 'trigger', target: 'output' },
-        ],
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('simple-workflow');
-
-      expect(execution.status).toBe('completed');
-      expect(execution.workflowId).toBe('simple-workflow');
-    });
-
-    it('should throw error for non-existent workflow', async () => {
-      await expect(engine.execute('non-existent')).rejects.toThrow('Workflow not found');
-    });
-
-    it('should track execution state', async () => {
-      const workflow: Workflow = {
-        id: 'tracking-workflow',
-        name: 'Tracking Workflow',
-        version: '1.0.0',
-        nodes: [
-          { id: 'trigger', type: 'trigger:manual', name: 'Start' },
-          { id: 'log', type: 'output:log', name: 'Log' },
-          { id: 'output', type: 'output:result', name: 'End' },
-        ],
-        connections: [
-          { id: 'c1', source: 'trigger', target: 'log' },
-          { id: 'c2', source: 'log', target: 'output' },
-        ],
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('tracking-workflow');
-
-      expect(execution.context?.state.completedNodes).toContain('trigger');
-      expect(execution.context?.state.completedNodes).toContain('log');
-      expect(execution.context?.state.completedNodes).toContain('output');
-      expect(execution.context?.state.executionPath).toHaveLength(3);
-    });
-  });
-
-  describe('node types', () => {
-    it('should get built-in node types', () => {
-      const triggerType = engine.getNodeType('trigger:manual');
-      expect(triggerType).toBeDefined();
-      expect(triggerType?.displayName).toBe('Manual Trigger');
-    });
-
-    it('should register custom node type', () => {
-      engine.registerNodeType({
-        type: 'custom:action',
-        category: 'custom',
-        displayName: 'Custom Action',
-        executor: async () => ({ result: 'custom' }),
-      });
-
-      const customType = engine.getNodeType('custom:action');
-      expect(customType).toBeDefined();
-      expect(customType?.displayName).toBe('Custom Action');
-    });
-  });
-
-  describe('execution control', () => {
-    it('should get execution by id', async () => {
-      const workflow: Workflow = {
-        id: 'test-workflow',
-        name: 'Test Workflow',
-        version: '1.0.0',
-        nodes: [
-          { id: 'trigger', type: 'trigger:manual', name: 'Start' },
-          { id: 'output', type: 'output:result', name: 'End' },
-        ],
-        connections: [{ id: 'c1', source: 'trigger', target: 'output' }],
-      };
-
-      engine.registerWorkflow(workflow);
-      const execution = await engine.execute('test-workflow');
-
-      const retrieved = engine.getExecution(execution.id);
-      expect(retrieved).toEqual(execution);
-    });
-  });
-});
-
-describe('WorkflowEngine with conditions', () => {
-  it('should execute conditional workflow', async () => {
-    const engine = createWorkflowEngine();
-
-    const workflow: Workflow = {
-      id: 'conditional-workflow',
-      name: 'Conditional Workflow',
-      version: '1.0.0',
-      nodes: [
-        { id: 'trigger', type: 'trigger:manual', name: 'Start' },
-        {
-          id: 'condition',
-          type: 'condition:if',
-          name: 'Check Value',
-          config: { condition: 'data.value > 10' },
-        },
-        { id: 'high', type: 'output:result', name: 'High Value' },
-        { id: 'low', type: 'output:result', name: 'Low Value' },
-      ],
-      connections: [
-        { id: 'c1', source: 'trigger', target: 'condition' },
-        { id: 'c2', source: 'condition', target: 'high', condition: 'result.true' },
-        { id: 'c3', source: 'condition', target: 'low', condition: 'result.false' },
-      ],
-    };
-
-    engine.registerWorkflow(workflow);
-    const execution = await engine.execute('conditional-workflow', { value: 15 });
-
-    expect(execution.status).toBe('completed');
-  });
-});
-
-describe('WorkflowEngine with transforms', () => {
-  it('should execute transform node', async () => {
-    const engine = createWorkflowEngine();
-
-    const workflow: Workflow = {
-      id: 'transform-workflow',
-      name: 'Transform Workflow',
-      version: '1.0.0',
-      nodes: [
-        { id: 'trigger', type: 'trigger:manual', name: 'Start' },
-        {
-          id: 'transform',
-          type: 'transform:map',
-          name: 'Double Value',
-          config: { expression: 'data.value * 2' },
-          inputs: [{ target: 'data', source: '${value}' }],
-        },
-        { id: 'output', type: 'output:result', name: 'Result' },
-      ],
-      connections: [
-        { id: 'c1', source: 'trigger', target: 'transform' },
-        { id: 'c2', source: 'transform', target: 'output' },
-      ],
-    };
-
-    engine.registerWorkflow(workflow);
-    const execution = await engine.execute('transform-workflow', { value: 5 });
-
-    expect(execution.status).toBe('completed');
-  });
-});