如何用JavaScript实现一个支持动态规则的业务流程引擎？

class WorkflowEngine {
    constructor(processDefinition) {
        this.nodes = new Map(); // 存储节点 { id: { type, actions, transitions } }
        this.actionRegistry = new Map(); // 存储可执行的动作函数

        this.parseDefinition(processDefinition);
    }

    parseDefinition(definition) {
        // 假设 definition 是一个包含 nodes 和 edges 的对象
        definition.nodes.forEach(node => this.nodes.set(node.id, node));
        // 可以在这里进一步处理 edges，将其附加到对应的 node 上
    }

    registerAction(name, func) {
        this.actionRegistry.set(name, func);
    }

    async execute(initialContext, startNodeId) {
        let currentContext = { ...initialContext };
        let currentNode = this.nodes.get(startNodeId);

        while (currentNode && currentNode.type !== 'end') {
            console.log(`Executing node: ${currentNode.id}, type: ${currentNode.type}`);

            // 1. 执行当前节点的动作
            if (currentNode.actions && currentNode.actions.length > 0) {
                for (const actionName of currentNode.actions) {
                    const actionFunc = this.actionRegistry.get(actionName);
                    if (actionFunc) {
                        // 动作可能是异步的
                        await actionFunc(currentContext);
                    } else {
                        console.warn(`Action "${actionName}" not found.`);
                    }
                }
            }

            // 2. 评估条件，决定下一个节点
            let nextNodeId = null;
            if (currentNode.transitions && currentNode.transitions.length > 0) {
                for (const transition of currentNode.transitions) {
                    // 评估条件
                    // 这是一个简化的条件评估，实际可能需要更复杂的表达式解析
                    const conditionMet = transition.condition ? 
                                         this.evaluateCondition(transition.condition, currentContext) : 
                                         true; // 没有条件则默认通过

                    if (conditionMet) {
                        nextNodeId = transition.target;
                        break; // 找到第一个满足条件的路径
                    }
                }
            } else if (currentNode.defaultTransition) {
                // 如果没有条件转换，可能有默认转换
                nextNodeId = currentNode.defaultTransition.target;
            }

            if (nextNodeId) {
                currentNode = this.nodes.get(nextNodeId);
                if (!currentNode) {
                    throw new Error(`Node "${nextNodeId}" not found in definition.`);
                }
            } else if (currentNode.type !== 'end') {
                // 没有找到下一个节点，且不是结束节点，表示流程卡住或定义有误
                throw new Error(`No valid transition found from node "${currentNode.id}".`);
            } else {
                // 结束节点
                break;
            }
        }
        console.log(`Workflow finished at node: ${currentNode ? currentNode.id : 'N/A'}`);
        return currentContext;
    }

    // 示例：一个简单的条件评估函数，实际需要更健壮的实现
    evaluateCondition(conditionString, context) {
        try {
            // WARNING: 使用 new Function() 存在安全风险，
            // 尤其当 conditionString 来自不可信来源时。
            // 生产环境应使用安全的表达式解析库或沙箱环境。
            const func = new Function('context', `return ${conditionString};`);
            return func(context);
        } catch (error) {
            console.error(`Error evaluating condition "${conditionString}":`, error);
            return false;
        }
    }
}

// 示例用法
const myProcessDefinition = {
    nodes: [
        { id: 'start', type: 'start', transitions: [{ target: 'checkAmount' }] },
        { id: 'checkAmount', type: 'decision', transitions: [
            { condition: 'context.amount > 1000', target: 'requireApproval' },
            { condition: 'context.amount <= 1000', target: 'processPayment' }
        ]},
        { id: 'requireApproval', type: 'task', actions: ['sendApprovalRequest'], transitions: [{ target: 'end' }] },
        { id: 'processPayment', type: 'task', actions: ['deductMoney', 'sendReceipt'], transitions: [{ target: 'end' }] },
        { id: 'end', type: 'end' }
    ]
};

const engine = new WorkflowEngine(myProcessDefinition);

engine.registerAction('sendApprovalRequest', async (context) => {
    console.log(`Sending approval request for amount: ${context.amount}`);
    context.status = 'Pending Approval';
    // 实际场景可能涉及外部API调用，等待回调
});

engine.registerAction('deductMoney', async (context) => {
    console.log(`Deducting ${context.amount} from account.`);
    context.balance -= context.amount;
    context.status = 'Payment Processed';
});

engine.registerAction('sendReceipt', async (context) => {
    console.log(`Sending receipt for amount: ${context.amount}`);
});

(async () => {
    console.log('--- Scenario 1: Small amount ---');
    let context1 = await engine.execute({ amount: 500, balance: 2000 }, 'start');
    console.log('Final Context 1:', context1);

    console.log('\n--- Scenario 2: Large amount ---');
    let context2 = await engine.execute({ amount: 1500, balance: 5000 }, 'start');
    console.log('Final Context 2:', context2);
})();

// 示例：节点类型注册
const nodeTypeRegistry = new Map();

class BaseNode {
    constructor(id, config) { this.id = id; this.config = config; }
    async execute(engine, context) { /* 默认实现或抽象方法 */ }
}

class TaskNode extends BaseNode {
    async execute(engine, context) {
        // 执行配置的动作
        for (const actionName of this.config.actions) {
            await engine.executeAction(actionName, context);
        }
        // 返回下一个节点ID或处理下一个转换
        return this.config.transitions[0].target; 
    }
}

class DecisionNode extends BaseNode {
    async execute(engine, context) {
        for (const transition of this.config.transitions) {
            if (engine.evaluateCondition(transition.condition, context)) {
                return transition.target;
            }
        }
        // 如果没有匹配的条件，可能抛出错误或走默认路径
        return null; 
    }
}

nodeTypeRegistry.set('task', TaskNode);
nodeTypeRegistry.set('decision', DecisionNode);
// ... 注册其他节点类型

// 引擎解析时
// const NodeClass = nodeTypeRegistry.get(nodeDefinition.type);
// const nodeInstance = new NodeClass(nodeDefinition.id, nodeDefinition);

TimerNode

TimerNode

nodeTypeRegistry