@allternit/workflow-engine 0.1.0 → 0.1.1

package/dist/engine/workflow-engine.js.bak

@@ -1,532 +0,0 @@
-/**
- * Workflow Engine
- *
- * Core engine for executing workflows with DAG support.
- */
-import { v4 as uuidv4 } from 'uuid';
-/**
- * Create workflow engine
- */
-export function createWorkflowEngine(config = {}) {
-    const workflows = new Map();
-    const executions = new Map();
-    const nodeTypes = new Map();
-    const activeExecutions = new Set();
-    const { maxConcurrentExecutions = 10, defaultTimeout = 300000, // 5 minutes
-    enableHistory = true, hooks = {}, } = config;
-    /**
-     * Register built-in node types
-     */
-    function registerBuiltInNodeTypes() {
-        // Input nodes
-        registerNodeType({
-            type: 'trigger:manual',
-            category: 'input',
-            displayName: 'Manual Trigger',
-            description: 'Triggered manually or via API',
-            outputs: [{ name: 'data', type: 'any' }],
-            executor: async (_, __, inputs) => inputs,
-        });
-        registerNodeType({
-            type: 'trigger:schedule',
-            category: 'input',
-            displayName: 'Schedule Trigger',
-            description: 'Triggered on a schedule',
-            outputs: [{ name: 'timestamp', type: 'string' }],
-            executor: async (_, __, inputs) => inputs,
-        });
-        registerNodeType({
-            type: 'trigger:webhook',
-            category: 'input',
-            displayName: 'Webhook Trigger',
-            description: 'Triggered by HTTP webhook',
-            outputs: [{ name: 'body', type: 'any' }, { name: 'headers', type: 'object' }],
-            executor: async (_, __, inputs) => inputs,
-        });
-        // Transform nodes
-        registerNodeType({
-            type: 'transform:map',
-            category: 'transform',
-            displayName: 'Map',
-            description: 'Transform data using expression',
-            inputs: [{ name: 'data', type: 'any', required: true }],
-            outputs: [{ name: 'result', type: 'any' }],
-            configSchema: [
-                { name: 'expression', type: 'string', required: true, description: 'JavaScript expression' },
-            ],
-            executor: async (node, context, inputs) => {
-                const expression = node.config?.expression;
-                if (!expression)
-                    throw new Error('Expression required');
-                // Simple expression evaluation
-                const data = inputs.data;
-                const result = new Function('data', 'context', `return ${expression}`)(data, context);
-                return { result };
-            },
-        });
-        registerNodeType({
-            type: 'transform:filter',
-            category: 'transform',
-            displayName: 'Filter',
-            description: 'Filter array items',
-            inputs: [{ name: 'array', type: 'array', required: true }],
-            outputs: [{ name: 'filtered', type: 'array' }],
-            configSchema: [
-                { name: 'condition', type: 'string', required: true, description: 'Filter condition (item, index) => boolean' },
-            ],
-            executor: async (node, _, inputs) => {
-                const array = inputs.array;
-                const condition = node.config?.condition;
-                if (!condition)
-                    return { filtered: array };
-                const filterFn = new Function('item', 'index', `return ${condition}`);
-                const filtered = array.filter((item, index) => filterFn(item, index));
-                return { filtered };
-            },
-        });
-        // Condition nodes
-        registerNodeType({
-            type: 'condition:if',
-            category: 'condition',
-            displayName: 'If Condition',
-            description: 'Branch based on condition',
-            inputs: [{ name: 'data', type: 'any' }],
-            outputs: [
-                { name: 'true', type: 'any' },
-                { name: 'false', type: 'any' },
-            ],
-            configSchema: [
-                { name: 'condition', type: 'string', required: true, description: 'Boolean expression' },
-            ],
-            executor: async (node, context, inputs) => {
-                const condition = node.config?.condition;
-                if (!condition)
-                    throw new Error('Condition required');
-                const result = new Function('data', 'context', `return ${condition}`)(inputs.data, context);
-                return result ? { true: inputs.data } : { false: inputs.data };
-            },
-        });
-        // Loop nodes
-        registerNodeType({
-            type: 'loop:for-each',
-            category: 'loop',
-            displayName: 'For Each',
-            description: 'Iterate over array items',
-            inputs: [{ name: 'array', type: 'array', required: true }],
-            outputs: [{ name: 'results', type: 'array' }],
-            configSchema: [
-                { name: 'parallel', type: 'boolean', default: false, description: 'Execute in parallel' },
-                { name: 'maxConcurrency', type: 'number', default: 5, description: 'Max parallel executions' },
-            ],
-            executor: async (node, context, inputs) => {
-                // For-each logic handled by scheduler
-                return { items: inputs.array };
-            },
-        });
-        // Delay nodes
-        registerNodeType({
-            type: 'delay:wait',
-            category: 'delay',
-            displayName: 'Wait',
-            description: 'Pause execution',
-            inputs: [{ name: 'data', type: 'any' }],
-            outputs: [{ name: 'data', type: 'any' }],
-            configSchema: [
-                { name: 'delay', type: 'number', required: true, description: 'Delay in milliseconds' },
-            ],
-            executor: async (node, _, inputs) => {
-                const delay = node.config?.delay || 1000;
-                await new Promise(resolve => setTimeout(resolve, delay));
-                return { data: inputs.data };
-            },
-        });
-        // HTTP nodes
-        registerNodeType({
-            type: 'http:request',
-            category: 'http',
-            displayName: 'HTTP Request',
-            description: 'Make HTTP request',
-            inputs: [
-                { name: 'url', type: 'string', required: true },
-                { name: 'body', type: 'any' },
-            ],
-            outputs: [
-                { name: 'response', type: 'object' },
-                { name: 'status', type: 'number' },
-            ],
-            configSchema: [
-                { name: 'method', type: 'string', default: 'GET', description: 'HTTP method' },
-                { name: 'headers', type: 'object', description: 'Request headers' },
-                { name: 'timeout', type: 'number', default: 30000, description: 'Timeout in ms' },
-            ],
-            executor: async (node, _, inputs) => {
-                const method = node.config?.method || 'GET';
-                const url = inputs.url;
-                const headers = node.config?.headers || {};
-                const timeout = node.config?.timeout || 30000;
-                const controller = new AbortController();
-                const timeoutId = setTimeout(() => controller.abort(), timeout);
-                try {
-                    const response = await fetch(url, {
-                        method,
-                        headers,
-                        body: inputs.body ? JSON.stringify(inputs.body) : undefined,
-                        signal: controller.signal,
-                    });
-                    clearTimeout(timeoutId);
-                    const data = await response.json().catch(() => null);
-                    const responseHeaders = {};
-                    response.headers.forEach((value, key) => {
-                        responseHeaders[key] = value;
-                    });
-                    return {
-                        response: data,
-                        status: response.status,
-                        headers: responseHeaders,
-                    };
-                }
-                catch (error) {
-                    clearTimeout(timeoutId);
-                    throw error;
-                }
-            },
-        });
-        // Output nodes
-        registerNodeType({
-            type: 'output:result',
-            category: 'output',
-            displayName: 'Set Result',
-            description: 'Set workflow output',
-            inputs: [{ name: 'data', type: 'any' }],
-            executor: async (_, __, inputs) => inputs,
-        });
-        registerNodeType({
-            type: 'output:log',
-            category: 'output',
-            displayName: 'Log',
-            description: 'Log message to console',
-            inputs: [{ name: 'message', type: 'any' }],
-            configSchema: [
-                { name: 'level', type: 'string', default: 'info', description: 'Log level' },
-            ],
-            executor: async (node, _, inputs) => {
-                const level = node.config?.level || 'info';
-                console[level]?.('Workflow log:', inputs.message);
-                return { message: inputs.message };
-            },
-        });
-    }
-    /**
-     * Register workflow
-     */
-    function registerWorkflow(workflow) {
-        workflows.set(workflow.id, workflow);
-    }
-    /**
-     * Get workflow
-     */
-    function getWorkflow(id) {
-        return workflows.get(id);
-    }
-    /**
-     * List workflows
-     */
-    function listWorkflows() {
-        return Array.from(workflows.values());
-    }
-    /**
-     * Delete workflow
-     */
-    function deleteWorkflow(id) {
-        return workflows.delete(id);
-    }
-    /**
-     * Execute workflow
-     */
-    async function execute(workflowId, inputs = {}) {
-        const workflow = workflows.get(workflowId);
-        if (!workflow) {
-            throw new Error(`Workflow not found: ${workflowId}`);
-        }
-        // Check concurrent execution limit
-        if (activeExecutions.size >= maxConcurrentExecutions) {
-            throw new Error('Max concurrent executions reached');
-        }
-        const executionId = uuidv4();
-        // Build DAG
-        const dag = buildDAG(workflow);
-        // Initialize execution
-        const execution = {
-            id: executionId,
-            workflowId,
-            status: 'pending',
-            inputs,
-            context: {
-                variables: { ...inputs },
-                state: {
-                    activeNodes: [],
-                    completedNodes: [],
-                    failedNodes: [],
-                    nodeResults: {},
-                    executionPath: [],
-                },
-            },
-            nodeExecutions: [],
-            startedAt: new Date().toISOString(),
-        };
-        executions.set(executionId, execution);
-        activeExecutions.add(executionId);
-        // Trigger before execute hook
-        await hooks.beforeExecute?.(execution);
-        // Start execution
-        execution.status = 'running';
-        try {
-            // Execute starting nodes (no incoming connections)
-            const startNodes = dag.nodes.filter(n => !dag.connections.some(c => c.target === n.id));
-            await Promise.all(startNodes.map(node => executeNode(node, execution, dag)));
-            execution.status = 'completed';
-            execution.completedAt = new Date().toISOString();
-            // Collect outputs
-            const outputNodes = workflow.nodes.filter(n => n.type === 'output:result');
-            execution.outputs = {};
-            for (const node of outputNodes) {
-                const result = execution.context?.state.nodeResults[node.id];
-                if (result) {
-                    Object.assign(execution.outputs, result);
-                }
-            }
-        }
-        catch (error) {
-            execution.status = 'failed';
-            execution.error = {
-                code: 'EXECUTION_ERROR',
-                message: error instanceof Error ? error.message : String(error),
-            };
-            await hooks.onError?.(execution.error, execution.context);
-        }
-        finally {
-            activeExecutions.delete(executionId);
-            await hooks.afterExecute?.(execution);
-        }
-        return execution;
-    }
-    /**
-     * Build DAG from workflow
-     */
-    function buildDAG(workflow) {
-        return {
-            nodes: workflow.nodes,
-            connections: workflow.connections,
-        };
-    }
-    /**
-     * Execute a node
-     */
-    async function executeNode(node, execution, dag) {
-        if (!execution.context)
-            return;
-        const nodeType = nodeTypes.get(node.type);
-        if (!nodeType) {
-            throw new Error(`Unknown node type: ${node.type}`);
-        }
-        // Check if already executed
-        if (execution.context.state.completedNodes.includes(node.id)) {
-            return;
-        }
-        // Check dependencies
-        const incomingConnections = dag.connections.filter(c => c.target === node.id);
-        const dependenciesMet = incomingConnections.every(c => execution.context.state.completedNodes.includes(c.source) ||
-            execution.context.state.nodeResults[c.source] !== undefined);
-        if (!dependenciesMet) {
-            return; // Will be executed when dependencies complete
-        }
-        // Mark as active
-        execution.context.state.activeNodes.push(node.id);
-        execution.context.state.executionPath.push(node.id);
-        // Prepare inputs
-        const inputs = {};
-        // Get inputs from connections
-        incomingConnections.forEach(conn => {
-            const sourceResult = execution.context.state.nodeResults[conn.source];
-            if (sourceResult) {
-                const portName = conn.sourcePort || 'data';
-                inputs[portName] = sourceResult;
-            }
-        });
-        // Apply input mappings
-        node.inputs?.forEach(mapping => {
-            const value = evaluateMapping(mapping.source, execution.context);
-            if (value !== undefined || mapping.default !== undefined) {
-                inputs[mapping.target] = value ?? mapping.default;
-            }
-        });
-        // Create node execution
-        const nodeExecution = {
-            nodeId: node.id,
-            status: 'running',
-            inputs,
-            startedAt: new Date().toISOString(),
-        };
-        execution.nodeExecutions = execution.nodeExecutions || [];
-        execution.nodeExecutions.push(nodeExecution);
-        // Trigger before node execute hook
-        await hooks.beforeNodeExecute?.(node, execution.context);
-        try {
-            // Execute node
-            const executor = nodeType.executor;
-            if (!executor) {
-                throw new Error(`No executor for node type: ${node.type}`);
-            }
-            const result = await executor(node, execution.context, inputs);
-            // Store result
-            execution.context.state.nodeResults[node.id] = result;
-            execution.context.state.completedNodes.push(node.id);
-            // Update node execution
-            nodeExecution.status = 'completed';
-            nodeExecution.outputs = result;
-            nodeExecution.completedAt = new Date().toISOString();
-            // Trigger after node execute hook
-            await hooks.afterNodeExecute?.(node, execution.context, result);
-            // Execute next nodes
-            const outgoingConnections = dag.connections.filter(c => c.source === node.id);
-            for (const conn of outgoingConnections) {
-                // Check condition
-                if (conn.condition) {
-                    const conditionMet = evaluateCondition(conn.condition, result, execution.context);
-                    if (!conditionMet)
-                        continue;
-                }
-                const nextNode = dag.nodes.find(n => n.id === conn.target);
-                if (nextNode) {
-                    await executeNode(nextNode, execution, dag);
-                }
-            }
-        }
-        catch (error) {
-            nodeExecution.status = 'failed';
-            nodeExecution.error = {
-                code: 'NODE_EXECUTION_ERROR',
-                message: error instanceof Error ? error.message : String(error),
-                nodeId: node.id,
-            };
-            execution.context.state.failedNodes.push(node.id);
-            throw error;
-        }
-        finally {
-            // Remove from active
-            execution.context.state.activeNodes = execution.context.state.activeNodes.filter(id => id !== node.id);
-        }
-    }
-    /**
-     * Evaluate mapping expression
-     */
-    function evaluateMapping(expression, context) {
-        try {
-            // Simple variable substitution
-            if (expression.startsWith('${') && expression.endsWith('}')) {
-                const path = expression.slice(2, -1);
-                return getValueByPath(context.variables, path);
-            }
-            return expression;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * Evaluate condition
-     */
-    function evaluateCondition(condition, result, context) {
-        try {
-            return new Function('result', 'context', `return ${condition}`)(result, context);
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Get value by path
-     */
-    function getValueByPath(obj, path) {
-        return path.split('.').reduce((acc, key) => {
-            if (acc && typeof acc === 'object') {
-                return acc[key];
-            }
-            return undefined;
-        }, obj);
-    }
-    /**
-     * Get execution
-     */
-    function getExecution(executionId) {
-        return executions.get(executionId);
-    }
-    /**
-     * Cancel execution
-     */
-    function cancelExecution(executionId) {
-        const execution = executions.get(executionId);
-        if (execution && execution.status === 'running') {
-            execution.status = 'cancelled';
-            execution.completedAt = new Date().toISOString();
-            activeExecutions.delete(executionId);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Pause execution
-     */
-    function pauseExecution(executionId) {
-        const execution = executions.get(executionId);
-        if (execution && execution.status === 'running') {
-            execution.status = 'paused';
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Resume execution
-     */
-    function resumeExecution(executionId) {
-        const execution = executions.get(executionId);
-        if (execution && execution.status === 'paused') {
-            execution.status = 'running';
-            // TODO: Resume execution logic
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Register node type
-     */
-    function registerNodeType(nodeType) {
-        nodeTypes.set(nodeType.type, nodeType);
-    }
-    /**
-     * Get node type
-     */
-    function getNodeType(type) {
-        return nodeTypes.get(type);
-    }
-    // Initialize
-    registerBuiltInNodeTypes();
-    return {
-        registerWorkflow,
-        getWorkflow,
-        listWorkflows,
-        deleteWorkflow,
-        execute,
-        getExecution,
-        cancelExecution,
-        pauseExecution,
-        resumeExecution,
-        registerNodeType,
-        getNodeType,
-    };
-}
-/**
- * Global workflow engine instance
- */
-export const globalWorkflowEngine = createWorkflowEngine();
-//# sourceMappingURL=workflow-engine.js.map

package/dist/index.d.ts.bak

@@ -1,38 +0,0 @@
-/**
- * A2R Workflow Engine
- *
- * Visual workflow orchestration with DAG support.
- *
- * @example
- * ```typescript
- * import { createWorkflowEngine, createVisualizer } from '@allternit/workflow-engine';
- *
- * const engine = createWorkflowEngine();
- *
- * // Register workflow
- * engine.registerWorkflow({
- *   id: 'my-workflow',
- *   name: 'My Workflow',
- *   version: '1.0.0',
- *   nodes: [
- *     { id: 'trigger', type: 'trigger:manual', name: 'Start' },
- *     { id: 'http', type: 'http:request', name: 'Fetch Data', config: { method: 'GET' } },
- *     { id: 'output', type: 'output:result', name: 'Return Result' },
- *   ],
- *   connections: [
- *     { id: 'c1', source: 'trigger', target: 'http' },
- *     { id: 'c2', source: 'http', target: 'output' },
- *   ],
- * });
- *
- * // Execute workflow
- * const execution = await engine.execute('my-workflow', { url: 'https://api.example.com' });
- * console.log(execution.status); // 'completed'
- * ```
- */
-export type { Workflow, WorkflowNode, Connection, WorkflowExecution, ExecutionContext, ExecutionState, NodeExecution, ExecutionStatus, ExecutionError, ParameterSchema, Variable, InputMapping, OutputMapping, Trigger, ErrorHandlingConfig, NodeType, NodeCategory, PortDefinition, WorkflowEngineConfig, WorkflowHooks, Position, } from './types';
-export { createWorkflowEngine, globalWorkflowEngine, type WorkflowEngine, } from './engine/workflow-engine';
-export { createScheduler, globalScheduler, type Scheduler, type SchedulerConfig, type Task, type SchedulerStatus, } from './scheduler';
-export { createVisualizer, globalVisualizer, type WorkflowVisualizer, type VisualizerConfig, type VisualLayout, type VisualNode, type VisualConnection, type Bounds, } from './visualizer';
-export declare const VERSION = "0.1.0";
-//# sourceMappingURL=index.d.ts.map

package/dist/index.js.bak

@@ -1,41 +0,0 @@
-/**
- * A2R Workflow Engine
- *
- * Visual workflow orchestration with DAG support.
- *
- * @example
- * ```typescript
- * import { createWorkflowEngine, createVisualizer } from '@allternit/workflow-engine';
- *
- * const engine = createWorkflowEngine();
- *
- * // Register workflow
- * engine.registerWorkflow({
- *   id: 'my-workflow',
- *   name: 'My Workflow',
- *   version: '1.0.0',
- *   nodes: [
- *     { id: 'trigger', type: 'trigger:manual', name: 'Start' },
- *     { id: 'http', type: 'http:request', name: 'Fetch Data', config: { method: 'GET' } },
- *     { id: 'output', type: 'output:result', name: 'Return Result' },
- *   ],
- *   connections: [
- *     { id: 'c1', source: 'trigger', target: 'http' },
- *     { id: 'c2', source: 'http', target: 'output' },
- *   ],
- * });
- *
- * // Execute workflow
- * const execution = await engine.execute('my-workflow', { url: 'https://api.example.com' });
- * console.log(execution.status); // 'completed'
- * ```
- */
-// Engine
-export { createWorkflowEngine, globalWorkflowEngine, } from './engine/workflow-engine';
-// Scheduler
-export { createScheduler, globalScheduler, } from './scheduler';
-// Visualizer
-export { createVisualizer, globalVisualizer, } from './visualizer';
-// Version
-export const VERSION = '0.1.0';
-//# sourceMappingURL=index.js.map

package/dist/scheduler/index.d.ts.bak

@@ -1,53 +0,0 @@
-/**
- * Workflow Scheduler
- *
- * Handles parallel execution, queuing, and resource management.
- */
-import type { WorkflowExecution, WorkflowNode } from '../types';
-export interface SchedulerConfig {
-    /** Max concurrent tasks */
-    maxConcurrency?: number;
-    /** Queue size limit */
-    queueLimit?: number;
-    /** Default task timeout (ms) */
-    defaultTimeout?: number;
-    /** Enable task prioritization */
-    enablePriority?: boolean;
-}
-export interface Task {
-    id: string;
-    node: WorkflowNode;
-    execution: WorkflowExecution;
-    priority?: number;
-    timeout?: number;
-}
-export interface Scheduler {
-    /** Submit task for execution */
-    submit(task: Task): Promise<unknown>;
-    /** Submit multiple tasks (parallel) */
-    submitAll(tasks: Task[]): Promise<unknown[]>;
-    /** Cancel task */
-    cancel(taskId: string): boolean;
-    /** Get queue status */
-    getStatus(): SchedulerStatus;
-    /** Pause scheduler */
-    pause(): void;
-    /** Resume scheduler */
-    resume(): void;
-}
-export interface SchedulerStatus {
-    running: number;
-    queued: number;
-    completed: number;
-    failed: number;
-    isPaused: boolean;
-}
-/**
- * Create workflow scheduler
- */
-export declare function createScheduler(config?: SchedulerConfig): Scheduler;
-/**
- * Global scheduler instance
- */
-export declare const globalScheduler: Scheduler;
-//# sourceMappingURL=index.d.ts.map