lsh-framework 1.2.0 → 1.3.0

package/dist/pipeline/workflow-engine.js

@@ -1,870 +0,0 @@
-import { EventEmitter } from 'events';
-import { v4 as uuidv4 } from 'uuid';
-import { JobStatus, JobPriority } from './job-tracker.js';
-export var WorkflowStatus;
-(function (WorkflowStatus) {
-    WorkflowStatus["PENDING"] = "pending";
-    WorkflowStatus["RUNNING"] = "running";
-    WorkflowStatus["COMPLETED"] = "completed";
-    WorkflowStatus["FAILED"] = "failed";
-    WorkflowStatus["CANCELLED"] = "cancelled";
-    WorkflowStatus["PAUSED"] = "paused";
-})(WorkflowStatus || (WorkflowStatus = {}));
-export var NodeStatus;
-(function (NodeStatus) {
-    NodeStatus["PENDING"] = "pending";
-    NodeStatus["WAITING"] = "waiting";
-    NodeStatus["READY"] = "ready";
-    NodeStatus["RUNNING"] = "running";
-    NodeStatus["COMPLETED"] = "completed";
-    NodeStatus["FAILED"] = "failed";
-    NodeStatus["SKIPPED"] = "skipped";
-    NodeStatus["CANCELLED"] = "cancelled";
-})(NodeStatus || (NodeStatus = {}));
-export class WorkflowEngine extends EventEmitter {
-    pool;
-    jobTracker;
-    runningExecutions = new Map();
-    pollInterval = null;
-    constructor(pool, jobTracker) {
-        super();
-        this.pool = pool;
-        this.jobTracker = jobTracker;
-        // Listen to job completion events
-        this.setupJobEventListeners();
-    }
-    setupJobEventListeners() {
-        this.jobTracker.on('execution:completed', async (event) => {
-            await this.handleJobCompletion(event.jobId, event.executionId, 'completed', event.data);
-        });
-        this.jobTracker.on('execution:failed', async (event) => {
-            await this.handleJobCompletion(event.jobId, event.executionId, 'failed', event.data);
-        });
-    }
-    // Workflow Definition Management
-    async createWorkflow(definition) {
-        const id = definition.id || uuidv4();
-        // Validate workflow
-        this.validateWorkflow(definition);
-        const query = `
-      INSERT INTO pipeline_workflows (
-        id, name, description, version, definition, schedule_cron,
-        config, default_parameters, tags, owner, team
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
-      RETURNING *
-    `;
-        const values = [
-            id,
-            definition.name,
-            definition.description,
-            definition.version,
-            JSON.stringify(definition),
-            definition.schedule?.cron,
-            JSON.stringify({ timeout: definition.timeout, maxConcurrentRuns: definition.maxConcurrentRuns }),
-            JSON.stringify(definition.parameters || {}),
-            definition.tags,
-            definition.owner,
-            definition.team
-        ];
-        const _result = await this.pool.query(query, values);
-        this.emit('workflow:created', {
-            type: 'workflow:created',
-            workflowId: id,
-            data: definition,
-            timestamp: new Date()
-        });
-        return { ...definition, id };
-    }
-    async getWorkflow(workflowId) {
-        const query = 'SELECT * FROM pipeline_workflows WHERE id = $1';
-        const result = await this.pool.query(query, [workflowId]);
-        if (result.rows.length === 0) {
-            return null;
-        }
-        const row = result.rows[0];
-        return JSON.parse(row.definition);
-    }
-    async updateWorkflow(workflowId, definition) {
-        this.validateWorkflow(definition);
-        const query = `
-      UPDATE pipeline_workflows
-      SET definition = $2, version = $3, updated_at = CURRENT_TIMESTAMP
-      WHERE id = $1
-    `;
-        await this.pool.query(query, [workflowId, JSON.stringify(definition), definition.version]);
-        this.emit('workflow:updated', {
-            type: 'workflow:updated',
-            workflowId,
-            data: definition,
-            timestamp: new Date()
-        });
-    }
-    async deleteWorkflow(workflowId) {
-        // Check for running executions
-        const runningCount = await this.getRunningExecutionsCount(workflowId);
-        if (runningCount > 0) {
-            throw new Error(`Cannot delete workflow with ${runningCount} running executions`);
-        }
-        const query = 'UPDATE pipeline_workflows SET is_active = false WHERE id = $1';
-        await this.pool.query(query, [workflowId]);
-        this.emit('workflow:deleted', {
-            type: 'workflow:deleted',
-            workflowId,
-            timestamp: new Date()
-        });
-    }
-    // Workflow Execution
-    async executeWorkflow(workflowId, triggeredBy, triggerType, parameters = {}) {
-        const workflow = await this.getWorkflow(workflowId);
-        if (!workflow) {
-            throw new Error(`Workflow ${workflowId} not found`);
-        }
-        // Check concurrency limits
-        const runningCount = await this.getRunningExecutionsCount(workflowId);
-        const maxConcurrent = workflow.maxConcurrentRuns || 1;
-        if (runningCount >= maxConcurrent) {
-            throw new Error(`Workflow ${workflowId} has reached max concurrent runs (${maxConcurrent})`);
-        }
-        // Create execution
-        const execution = {
-            id: uuidv4(),
-            workflowId,
-            runId: this.generateRunId(workflow.name),
-            status: WorkflowStatus.PENDING,
-            triggeredBy,
-            triggerType,
-            parameters: { ...workflow.parameters, ...parameters },
-            startedAt: new Date(),
-            completedStages: [],
-            failedStages: [],
-            nodeStates: {}
-        };
-        // Initialize node states
-        for (const node of workflow.nodes) {
-            execution.nodeStates[node.id] = {
-                nodeId: node.id,
-                status: NodeStatus.PENDING,
-                retryCount: 0
-            };
-        }
-        // Store execution
-        await this.storeExecution(execution);
-        // Add to running executions
-        this.runningExecutions.set(execution.id, execution);
-        // Start execution
-        await this.startExecution(execution);
-        this.emit('workflow:started', {
-            type: 'workflow:started',
-            workflowId,
-            executionId: execution.id,
-            data: execution,
-            timestamp: new Date()
-        });
-        return execution;
-    }
-    async startExecution(execution) {
-        execution.status = WorkflowStatus.RUNNING;
-        await this.updateExecution(execution);
-        // Find ready nodes (no dependencies)
-        const readyNodes = await this.findReadyNodes(execution);
-        // Start ready nodes
-        for (const nodeId of readyNodes) {
-            await this.executeNode(execution, nodeId);
-        }
-    }
-    async executeNode(execution, nodeId) {
-        const workflow = await this.getWorkflow(execution.workflowId);
-        if (!workflow)
-            return;
-        const node = workflow.nodes.find(n => n.id === nodeId);
-        if (!node)
-            return;
-        const nodeState = execution.nodeStates[nodeId];
-        nodeState.status = NodeStatus.RUNNING;
-        nodeState.startedAt = new Date();
-        await this.updateExecution(execution);
-        try {
-            switch (node.type) {
-                case 'job':
-                    await this.executeJobNode(execution, node);
-                    break;
-                case 'condition':
-                    await this.executeConditionNode(execution, node);
-                    break;
-                case 'parallel':
-                    await this.executeParallelNode(execution, node);
-                    break;
-                case 'wait':
-                    await this.executeWaitNode(execution, node);
-                    break;
-                default:
-                    throw new Error(`Unknown node type: ${node.type}`);
-            }
-        }
-        catch (error) {
-            console.error('Error executing node:', error);
-            await this.handleNodeFailure(execution, node, error);
-        }
-    }
-    async executeJobNode(execution, node) {
-        // Create job from node configuration
-        const config = node.config;
-        const jobConfig = {
-            name: `${execution.runId}-${node.name}`,
-            type: config.type || 'workflow_job',
-            sourceSystem: 'workflow',
-            targetSystem: config.targetSystem || 'mcli',
-            status: JobStatus.PENDING,
-            priority: config.priority || JobPriority.NORMAL,
-            config: {
-                ...config,
-                workflowExecutionId: execution.id,
-                workflowNodeId: node.id,
-                workflowRunId: execution.runId
-            },
-            parameters: {
-                ...execution.parameters,
-                ...(config.parameters || {})
-            },
-            owner: execution.triggeredBy,
-            tags: [`workflow:${execution.workflowId}`, `run:${execution.runId}`]
-        };
-        // Submit job
-        const job = await this.jobTracker.createJob(jobConfig);
-        // Update node state
-        const nodeState = execution.nodeStates[node.id];
-        nodeState.jobId = job.id;
-        await this.updateExecution(execution);
-        // Job completion will be handled by event listeners
-    }
-    async executeConditionNode(execution, node) {
-        // Evaluate condition
-        const result = this.evaluateCondition(node.condition || 'true', execution.parameters);
-        const nodeState = execution.nodeStates[node.id];
-        nodeState.status = result ? NodeStatus.COMPLETED : NodeStatus.SKIPPED;
-        nodeState.completedAt = new Date();
-        nodeState.result = { conditionResult: result };
-        if (nodeState.startedAt) {
-            nodeState.durationMs = nodeState.completedAt.getTime() - nodeState.startedAt.getTime();
-        }
-        await this.updateExecution(execution);
-        // Continue with downstream nodes
-        await this.checkAndContinueExecution(execution);
-    }
-    async executeParallelNode(execution, node) {
-        // Parallel nodes are just markers - their completion is determined by their dependencies
-        const nodeState = execution.nodeStates[node.id];
-        nodeState.status = NodeStatus.COMPLETED;
-        nodeState.completedAt = new Date();
-        if (nodeState.startedAt) {
-            nodeState.durationMs = nodeState.completedAt.getTime() - nodeState.startedAt.getTime();
-        }
-        await this.updateExecution(execution);
-        await this.checkAndContinueExecution(execution);
-    }
-    async executeWaitNode(execution, node) {
-        const config = node.config;
-        const waitMs = config.waitMs || 1000;
-        setTimeout(async () => {
-            const nodeState = execution.nodeStates[node.id];
-            nodeState.status = NodeStatus.COMPLETED;
-            nodeState.completedAt = new Date();
-            if (nodeState.startedAt) {
-                nodeState.durationMs = nodeState.completedAt.getTime() - nodeState.startedAt.getTime();
-            }
-            await this.updateExecution(execution);
-            await this.checkAndContinueExecution(execution);
-        }, waitMs);
-    }
-    async handleJobCompletion(jobId, executionId, status, data) {
-        // Find workflow execution by job ID
-        let targetExecution = null;
-        let targetNodeId = null;
-        for (const [_execId, execution] of this.runningExecutions) {
-            for (const [nodeId, nodeState] of Object.entries(execution.nodeStates)) {
-                if (nodeState.jobId === jobId) {
-                    targetExecution = execution;
-                    targetNodeId = nodeId;
-                    break;
-                }
-            }
-            if (targetExecution)
-                break;
-        }
-        if (!targetExecution || !targetNodeId) {
-            return; // Job not part of workflow
-        }
-        const nodeState = targetExecution.nodeStates[targetNodeId];
-        nodeState.status = status === 'completed' ? NodeStatus.COMPLETED : NodeStatus.FAILED;
-        nodeState.completedAt = new Date();
-        nodeState.result = data;
-        if (nodeState.startedAt) {
-            nodeState.durationMs = nodeState.completedAt.getTime() - nodeState.startedAt.getTime();
-        }
-        if (status === 'failed') {
-            const errorData = data;
-            nodeState.error = errorData.errorMessage || 'Job failed';
-            // Check retry policy
-            const workflow = await this.getWorkflow(targetExecution.workflowId);
-            const node = workflow?.nodes.find(n => n.id === targetNodeId);
-            if (node?.retryPolicy && nodeState.retryCount < node.retryPolicy.maxRetries) {
-                await this.scheduleNodeRetry(targetExecution, targetNodeId, node.retryPolicy);
-                return;
-            }
-            targetExecution.failedStages.push(targetNodeId);
-            await this.handleWorkflowFailure(targetExecution, `Node ${targetNodeId} failed: ${nodeState.error}`);
-        }
-        else {
-            targetExecution.completedStages.push(targetNodeId);
-            await this.checkAndContinueExecution(targetExecution);
-        }
-        await this.updateExecution(targetExecution);
-    }
-    async scheduleNodeRetry(execution, nodeId, retryPolicy) {
-        const nodeState = execution.nodeStates[nodeId];
-        nodeState.retryCount++;
-        const backoffMs = retryPolicy.backoffMs * Math.pow(retryPolicy.backoffMultiplier, nodeState.retryCount - 1);
-        nodeState.nextRetryAt = new Date(Date.now() + backoffMs);
-        nodeState.status = NodeStatus.WAITING;
-        await this.updateExecution(execution);
-        // Schedule retry
-        setTimeout(async () => {
-            if (execution.status === WorkflowStatus.RUNNING) {
-                await this.executeNode(execution, nodeId);
-            }
-        }, backoffMs);
-    }
-    async checkAndContinueExecution(execution) {
-        const workflow = await this.getWorkflow(execution.workflowId);
-        if (!workflow)
-            return;
-        // Check if workflow is complete
-        const allNodes = workflow.nodes.map(n => n.id);
-        const completedNodes = allNodes.filter(id => execution.nodeStates[id].status === NodeStatus.COMPLETED ||
-            execution.nodeStates[id].status === NodeStatus.SKIPPED);
-        if (completedNodes.length === allNodes.length) {
-            await this.completeWorkflow(execution);
-            return;
-        }
-        // Find newly ready nodes
-        const readyNodes = await this.findReadyNodes(execution);
-        // Start ready nodes
-        for (const nodeId of readyNodes) {
-            if (execution.nodeStates[nodeId].status === NodeStatus.PENDING) {
-                await this.executeNode(execution, nodeId);
-            }
-        }
-    }
-    async findReadyNodes(execution) {
-        const workflow = await this.getWorkflow(execution.workflowId);
-        if (!workflow)
-            return [];
-        const readyNodes = [];
-        for (const node of workflow.nodes) {
-            const nodeState = execution.nodeStates[node.id];
-            // Skip if not pending
-            if (nodeState.status !== NodeStatus.PENDING) {
-                continue;
-            }
-            // Check dependencies
-            const dependenciesSatisfied = node.dependencies.every(depId => {
-                const depState = execution.nodeStates[depId];
-                return depState?.status === NodeStatus.COMPLETED || depState?.status === NodeStatus.SKIPPED;
-            });
-            if (dependenciesSatisfied) {
-                readyNodes.push(node.id);
-            }
-        }
-        return readyNodes;
-    }
-    async completeWorkflow(execution) {
-        execution.status = WorkflowStatus.COMPLETED;
-        execution.completedAt = new Date();
-        execution.durationMs = execution.completedAt.getTime() - execution.startedAt.getTime();
-        await this.updateExecution(execution);
-        this.runningExecutions.delete(execution.id);
-        this.emit('workflow:completed', {
-            type: 'workflow:completed',
-            workflowId: execution.workflowId,
-            executionId: execution.id,
-            data: execution,
-            timestamp: new Date()
-        });
-    }
-    async handleWorkflowFailure(execution, errorMessage) {
-        execution.status = WorkflowStatus.FAILED;
-        execution.completedAt = new Date();
-        execution.durationMs = execution.completedAt.getTime() - execution.startedAt.getTime();
-        execution.errorMessage = errorMessage;
-        // Cancel running nodes
-        for (const [_nodeId, nodeState] of Object.entries(execution.nodeStates)) {
-            if (nodeState.status === NodeStatus.RUNNING || nodeState.status === NodeStatus.WAITING) {
-                nodeState.status = NodeStatus.CANCELLED;
-                // Cancel job if exists
-                if (nodeState.jobId) {
-                    try {
-                        await this.jobTracker.updateJobStatus(nodeState.jobId, JobStatus.CANCELLED);
-                    }
-                    catch (error) {
-                        console.warn(`Failed to cancel job ${nodeState.jobId}:`, error);
-                    }
-                }
-            }
-        }
-        await this.updateExecution(execution);
-        this.runningExecutions.delete(execution.id);
-        this.emit('workflow:failed', {
-            type: 'workflow:failed',
-            workflowId: execution.workflowId,
-            executionId: execution.id,
-            data: execution,
-            timestamp: new Date()
-        });
-    }
-    async cancelWorkflow(executionId) {
-        const execution = this.runningExecutions.get(executionId);
-        if (!execution) {
-            throw new Error(`Workflow execution ${executionId} not found or not running`);
-        }
-        execution.status = WorkflowStatus.CANCELLED;
-        execution.completedAt = new Date();
-        execution.durationMs = execution.completedAt.getTime() - execution.startedAt.getTime();
-        // Cancel all running and waiting nodes
-        for (const [_nodeId, nodeState] of Object.entries(execution.nodeStates)) {
-            if (nodeState.status === NodeStatus.RUNNING || nodeState.status === NodeStatus.WAITING) {
-                nodeState.status = NodeStatus.CANCELLED;
-                if (nodeState.jobId) {
-                    try {
-                        await this.jobTracker.updateJobStatus(nodeState.jobId, JobStatus.CANCELLED);
-                    }
-                    catch (error) {
-                        console.warn(`Failed to cancel job ${nodeState.jobId}:`, error);
-                    }
-                }
-            }
-        }
-        await this.updateExecution(execution);
-        this.runningExecutions.delete(executionId);
-        this.emit('workflow:cancelled', {
-            type: 'workflow:cancelled',
-            workflowId: execution.workflowId,
-            executionId: execution.id,
-            data: execution,
-            timestamp: new Date()
-        });
-    }
-    // Helper methods
-    validateWorkflow(definition) {
-        if (!definition.name || !definition.version) {
-            throw new Error('Workflow name and version are required');
-        }
-        if (!definition.nodes || definition.nodes.length === 0) {
-            throw new Error('Workflow must have at least one node');
-        }
-        // Check for cycles in dependencies
-        this.detectCycles(definition.nodes);
-        // Validate nodes
-        for (const node of definition.nodes) {
-            if (!node.id || !node.name || !node.type) {
-                throw new Error('Node must have id, name, and type');
-            }
-            // Validate dependencies exist
-            for (const depId of node.dependencies) {
-                if (!definition.nodes.find(n => n.id === depId)) {
-                    throw new Error(`Node ${node.id} depends on non-existent node ${depId}`);
-                }
-            }
-        }
-    }
-    detectCycles(nodes) {
-        const visited = new Set();
-        const recursionStack = new Set();
-        const hasCycle = (nodeId) => {
-            if (recursionStack.has(nodeId)) {
-                return true; // Found cycle
-            }
-            if (visited.has(nodeId)) {
-                return false; // Already processed
-            }
-            visited.add(nodeId);
-            recursionStack.add(nodeId);
-            const node = nodes.find(n => n.id === nodeId);
-            if (node) {
-                for (const depId of node.dependencies) {
-                    if (hasCycle(depId)) {
-                        return true;
-                    }
-                }
-            }
-            recursionStack.delete(nodeId);
-            return false;
-        };
-        for (const node of nodes) {
-            if (hasCycle(node.id)) {
-                throw new Error('Workflow contains cycles in dependencies');
-            }
-        }
-    }
-    evaluateCondition(condition, parameters) {
-        try {
-            // Simple condition evaluation - in production, use a safer evaluator
-            const func = new Function('params', `return ${condition}`);
-            return !!func(parameters);
-        }
-        catch (error) {
-            console.warn('Condition evaluation failed, defaulting to false:', error);
-            return false;
-        }
-    }
-    generateRunId(workflowName) {
-        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-        const shortId = Math.random().toString(36).substr(2, 4);
-        return `${workflowName}-${timestamp}-${shortId}`;
-    }
-    async getRunningExecutionsCount(workflowId) {
-        const query = `
-      SELECT COUNT(*) as count
-      FROM workflow_executions
-      WHERE workflow_id = $1 AND status = 'running'
-    `;
-        const result = await this.pool.query(query, [workflowId]);
-        return parseInt(result.rows[0].count);
-    }
-    async storeExecution(execution) {
-        const query = `
-      INSERT INTO workflow_executions (
-        id, workflow_id, run_id, status, triggered_by, trigger_type,
-        parameters, started_at, current_stage, completed_stages, failed_stages
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
-    `;
-        const values = [
-            execution.id,
-            execution.workflowId,
-            execution.runId,
-            execution.status,
-            execution.triggeredBy,
-            execution.triggerType,
-            JSON.stringify(execution.parameters),
-            execution.startedAt,
-            execution.currentStage,
-            JSON.stringify(execution.completedStages),
-            JSON.stringify(execution.failedStages)
-        ];
-        await this.pool.query(query, values);
-    }
-    async updateExecution(execution) {
-        const query = `
-      UPDATE workflow_executions
-      SET
-        status = $2,
-        completed_at = $3,
-        duration_ms = $4,
-        current_stage = $5,
-        completed_stages = $6,
-        failed_stages = $7,
-        result = $8,
-        error_message = $9
-      WHERE id = $1
-    `;
-        const values = [
-            execution.id,
-            execution.status,
-            execution.completedAt,
-            execution.durationMs,
-            execution.currentStage,
-            JSON.stringify(execution.completedStages),
-            JSON.stringify(execution.failedStages),
-            execution.result ? JSON.stringify(execution.result) : null,
-            execution.errorMessage
-        ];
-        await this.pool.query(query, values);
-        // Also store node states (this would need a separate table in production)
-        // For now, we'll store them in the result field or create a separate storage
-    }
-    // Public query methods
-    async getExecution(executionId) {
-        // First check running executions
-        const running = this.runningExecutions.get(executionId);
-        if (running) {
-            return running;
-        }
-        // Then check database
-        const query = 'SELECT * FROM workflow_executions WHERE id = $1';
-        const result = await this.pool.query(query, [executionId]);
-        if (result.rows.length === 0) {
-            return null;
-        }
-        return this.parseExecutionRow(result.rows[0]);
-    }
-    async listExecutions(workflowId, limit = 50) {
-        let query = 'SELECT * FROM workflow_executions';
-        const values = [];
-        if (workflowId) {
-            query += ' WHERE workflow_id = $1';
-            values.push(workflowId);
-        }
-        query += ` ORDER BY started_at DESC LIMIT ${limit}`;
-        const result = await this.pool.query(query, values);
-        return result.rows.map(row => this.parseExecutionRow(row));
-    }
-    parseExecutionRow(row) {
-        return {
-            id: row.id,
-            workflowId: row.workflow_id,
-            runId: row.run_id,
-            status: row.status,
-            triggeredBy: row.triggered_by,
-            triggerType: row.trigger_type,
-            parameters: row.parameters || {},
-            startedAt: row.started_at,
-            completedAt: row.completed_at,
-            durationMs: row.duration_ms,
-            currentStage: row.current_stage,
-            completedStages: row.completed_stages || [],
-            failedStages: row.failed_stages || [],
-            result: row.result,
-            errorMessage: row.error_message,
-            nodeStates: {} // Would need to be loaded from separate storage
-        };
-    }
-    async handleNodeFailure(execution, node, error) {
-        const nodeState = execution.nodeStates[node.id];
-        nodeState.status = NodeStatus.FAILED;
-        nodeState.completedAt = new Date();
-        nodeState.error = error.message;
-        execution.status = WorkflowStatus.FAILED;
-        execution.completedAt = new Date();
-        execution.errorMessage = `Node ${node.id} failed: ${error.message}`;
-        await this.updateExecution(execution);
-        this.runningExecutions.delete(execution.id);
-        this.emit('node:failed', {
-            executionId: execution.id,
-            workflowId: execution.workflowId,
-            nodeId: node.id,
-            error: error.message,
-            timestamp: new Date()
-        });
-        this.emit('execution:failed', {
-            executionId: execution.id,
-            workflowId: execution.workflowId,
-            error: error.message,
-            timestamp: new Date()
-        });
-    }
-    async listWorkflows(filters = {}) {
-        const conditions = [];
-        const params = [];
-        let paramCount = 1;
-        if (filters.status) {
-            conditions.push(`status = $${paramCount++}`);
-            params.push(filters.status);
-        }
-        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-        const limit = filters.limit || 50;
-        const offset = filters.offset || 0;
-        const query = `
-      SELECT * FROM workflow_definitions
-      ${whereClause}
-      ORDER BY created_at DESC
-      LIMIT $${paramCount++} OFFSET $${paramCount++}
-    `;
-        params.push(limit, offset);
-        const result = await this.pool.query(query, params);
-        return result.rows.map(this.parseWorkflowRow.bind(this));
-    }
-    async getWorkflowExecutions(workflowId, filters = {}) {
-        const limit = filters.limit || 50;
-        const offset = filters.offset || 0;
-        const query = `
-      SELECT * FROM workflow_executions
-      WHERE workflow_id = $1
-      ORDER BY started_at DESC
-      LIMIT $2 OFFSET $3
-    `;
-        const result = await this.pool.query(query, [workflowId, limit, offset]);
-        return result.rows.map(this.parseExecutionRow.bind(this));
-    }
-    async cancelExecution(executionId) {
-        const execution = this.runningExecutions.get(executionId);
-        if (execution) {
-            execution.status = WorkflowStatus.CANCELLED;
-            execution.completedAt = new Date();
-            // Cancel any running jobs
-            for (const nodeId of Object.keys(execution.nodeStates)) {
-                const nodeState = execution.nodeStates[nodeId];
-                if (nodeState.status === NodeStatus.RUNNING && nodeState.jobId) {
-                    try {
-                        await this.jobTracker.updateJobStatus(nodeState.jobId, JobStatus.CANCELLED);
-                    }
-                    catch (error) {
-                        console.warn(`Failed to cancel job ${nodeState.jobId}:`, error);
-                    }
-                }
-            }
-            this.runningExecutions.delete(executionId);
-            await this.updateExecution(execution);
-            this.emit('execution:cancelled', {
-                executionId: execution.id,
-                workflowId: execution.workflowId,
-                timestamp: new Date()
-            });
-        }
-    }
-    async validateWorkflowById(workflowId) {
-        try {
-            const workflow = await this.getWorkflow(workflowId);
-            if (!workflow) {
-                return {
-                    isValid: false,
-                    errors: ['Workflow not found'],
-                    warnings: []
-                };
-            }
-            const errors = [];
-            const warnings = [];
-            // Validate basic structure
-            if (!workflow.name) {
-                errors.push('Workflow name is required');
-            }
-            if (!workflow.nodes || workflow.nodes.length === 0) {
-                errors.push('Workflow must have at least one node');
-            }
-            if (workflow.nodes) {
-                // Check for duplicate node IDs
-                const nodeIds = workflow.nodes.map(n => n.id);
-                const duplicates = nodeIds.filter((id, index) => nodeIds.indexOf(id) !== index);
-                if (duplicates.length > 0) {
-                    errors.push(`Duplicate node IDs found: ${duplicates.join(', ')}`);
-                }
-                // Check for invalid dependencies
-                for (const node of workflow.nodes) {
-                    if (node.dependencies) {
-                        for (const depId of node.dependencies) {
-                            if (!nodeIds.includes(depId)) {
-                                errors.push(`Node ${node.id} depends on non-existent node ${depId}`);
-                            }
-                        }
-                    }
-                }
-                // Check for cycles
-                try {
-                    this.detectCycles(workflow.nodes);
-                }
-                catch (error) {
-                    errors.push(error.message);
-                }
-            }
-            return {
-                isValid: errors.length === 0,
-                errors,
-                warnings
-            };
-        }
-        catch (error) {
-            return {
-                isValid: false,
-                errors: [`Validation failed: ${error.message}`],
-                warnings: []
-            };
-        }
-    }
-    async getWorkflowDependencies(workflowId) {
-        const workflow = await this.getWorkflow(workflowId);
-        if (!workflow) {
-            throw new Error(`Workflow ${workflowId} not found`);
-        }
-        const nodes = workflow.nodes.map(node => {
-            const dependencies = node.dependencies || [];
-            const dependents = workflow.nodes
-                .filter(n => n.dependencies?.includes(node.id))
-                .map(n => n.id);
-            return {
-                id: node.id,
-                dependencies,
-                dependents
-            };
-        });
-        const graph = {};
-        workflow.nodes.forEach(node => {
-            graph[node.id] = node.dependencies || [];
-        });
-        return { nodes, graph };
-    }
-    async start() {
-        // Start periodic execution polling
-        this.pollInterval = setInterval(async () => {
-            try {
-                await this.checkScheduledExecutions();
-                await this.cleanupCompletedExecutions();
-            }
-            catch (error) {
-                console.error('Error in workflow engine polling:', error);
-            }
-        }, 10000); // Poll every 10 seconds
-        console.log('WorkflowEngine started');
-    }
-    async stop() {
-        if (this.pollInterval) {
-            clearInterval(this.pollInterval);
-            this.pollInterval = null;
-        }
-        // Cancel all running executions
-        const runningExecutions = Array.from(this.runningExecutions.keys());
-        await Promise.all(runningExecutions.map(id => this.cancelExecution(id)));
-        console.log('WorkflowEngine stopped');
-    }
-    async checkScheduledExecutions() {
-        // Check for workflows scheduled to run
-        const query = `
-      SELECT * FROM workflow_executions
-      WHERE status = 'scheduled' AND started_at <= NOW()
-      ORDER BY started_at ASC
-      LIMIT 10
-    `;
-        const result = await this.pool.query(query);
-        for (const row of result.rows) {
-            const execution = this.parseExecutionRow(row);
-            if (!this.runningExecutions.has(execution.id)) {
-                await this.checkAndContinueExecution(execution);
-            }
-        }
-    }
-    async cleanupCompletedExecutions() {
-        // Remove completed executions from memory after 1 hour
-        const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000);
-        for (const [id, execution] of this.runningExecutions) {
-            if ([WorkflowStatus.COMPLETED, WorkflowStatus.FAILED, WorkflowStatus.CANCELLED].includes(execution.status) &&
-                execution.completedAt && execution.completedAt < oneHourAgo) {
-                this.runningExecutions.delete(id);
-            }
-        }
-    }
-    parseWorkflowRow(row) {
-        return {
-            id: row.id,
-            name: row.name,
-            description: row.description,
-            version: row.version,
-            nodes: JSON.parse(row.nodes || '[]'),
-            parameters: JSON.parse(row.parameters || '{}'),
-            schedule: row.schedule ? JSON.parse(row.schedule) : undefined,
-            timeout: row.timeout,
-            maxConcurrentRuns: row.max_concurrent_runs,
-            tags: JSON.parse(row.tags || '[]'),
-            owner: row.owner,
-            team: row.team
-        };
-    }
-    // Cleanup
-    async cleanup() {
-        if (this.pollInterval) {
-            clearInterval(this.pollInterval);
-            this.pollInterval = null;
-        }
-        // Cancel all running executions
-        for (const execution of this.runningExecutions.values()) {
-            await this.cancelWorkflow(execution.id);
-        }
-        this.removeAllListeners();
-    }
-}