@logicflow/engine/lib/nodes/base.js

a process engine for javascript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BaseNode = void 0;
const tslib_1 = require("tslib");
const constant_1 = require("../constant");
const platform_1 = require("../platform");
class BaseNode {
    constructor({ nodeConfig, context, globalData }) {
        const { outgoing, incoming, id, type, properties } = nodeConfig;
        this.baseType = 'base';
        this.outgoing = outgoing;
        this.incoming = incoming;
        this.nodeId = id;
        this.type = type;
        this.properties = properties;
        this.context = context;
        this.globalData = globalData;
    }
    /**
     * 节点的执行逻辑
     * @overridable 可以自定义节点重写此方法
     * @param param.executionId 流程执行记录 ID
     * @param param.actionId 此节点执行记录 ID
     * @param param.nodeId 节点 ID
     * @return 返回下一步的执行参数
     * 当不返回时，表示此节点执行成功，流程会继续执行下一步。
     * 当返回时，返回格式为
     */
    action(param) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            console.log('action param --->>>', param);
            return undefined;
        });
    }
    /**
     * 节点重新恢复执行的逻辑
     * @overridable 可以自定义节点重写此方法
     * @param params.executionId 流程执行记录 ID
     * @param params.actionId 此节点执行记录 ID
     * @param params.nodeId 节点 ID
     */
    onResume(params) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            console.log('onResume params --->>>', params);
            return undefined;
        });
    }
    /**
     * 判断该节点是否满足条件
     */
    isPass(properties) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            if (!properties)
                return true;
            const { conditionExpression } = properties;
            if (!conditionExpression)
                return true;
            try {
                // bug：uuid 创建的 NodeId 为 xxxx-xxxx-xxxx-zzzz 格式，eval 执行时会将 - 识别为数学减号，导致执行报错
                // 解决方案： 赋值变量直接命名为 isPassResult, 因为每次执行 getExpressionResult 时，都会重新射程一个 context
                return yield (0, platform_1.getExpressionResult)(`
          const isPassResult = (${conditionExpression})
          return isPassResult
        `, Object.assign({}, this.globalData));
            }
            catch (error) {
                return false;
            }
        });
    }
    /**
     * 获取当前节点执行的下一个节点
     */
    getOutgoing() {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const outgoing = [];
            const expressions = [];
            for (const item of this.outgoing) {
                const { properties } = item;
                expressions.push(this.isPass(properties));
            }
            const result = yield Promise.all(expressions);
            result.forEach((item, index) => {
                const out = this.outgoing[index];
                out.result = item;
                outgoing.push(out);
            });
            return outgoing;
        });
    }
    /**
     * 节点的每一次执行都会生成一个唯一的 actionId
     */
    execute(params) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const { executionId, actionId } = params;
            const res = yield this.action({
                nodeId: this.nodeId,
                executionId,
                actionId,
            });
            const status = res ? res.status : 'success';
            if (status === constant_1.ActionStatus.SUCCESS) {
                const outgoing = yield this.getOutgoing();
                const detail = res ? res.detail : {};
                params.next({
                    status: constant_1.ActionStatus.SUCCESS,
                    detail,
                    nodeId: this.nodeId,
                    nodeType: this.type,
                    properties: this.properties,
                    executionId,
                    actionId,
                    outgoing,
                });
            }
            return {
                status,
                detail: res === null || res === void 0 ? void 0 : res.detail,
                executionId,
                actionId,
                nodeId: this.nodeId,
                nodeType: this.type,
                properties: this.properties,
                outgoing: [],
            };
        });
    }
    resume(params) {
        return tslib_1.__awaiter(this, void 0, void 0, function* () {
            const outgoing = yield this.getOutgoing();
            yield this.onResume({
                executionId: params.executionId,
                actionId: params.actionId,
                nodeId: params.nodeId,
                data: params.data,
            });
            params.next({
                executionId: params.executionId,
                actionId: params.actionId,
                nodeId: this.nodeId,
                nodeType: this.type,
                properties: this.properties,
                outgoing,
                status: constant_1.ActionStatus.SUCCESS,
            });
            return undefined;
        });
    }
}
exports.BaseNode = BaseNode;
BaseNode.nodeTypeName = 'BaseNode';
exports.default = BaseNode;
//# sourceMappingURL=base.js.map