@fsai-flow/core 0.0.1

package/dist/src/lib/WorkflowExecute.js

@@ -0,0 +1,835 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowExecute = void 0;
+const tslib_1 = require("tslib");
+const PCancelable = require("p-cancelable");
+const workflow_1 = require("@fsai-flow/workflow");
+const lodash_1 = require("lodash");
+const src_1 = require("../../src");
+class WorkflowExecute {
+    constructor(additionalData, mode, runExecutionData) {
+        this.additionalData = additionalData;
+        this.mode = mode;
+        this.runExecutionData = runExecutionData || {
+            startData: {},
+            resultData: {
+                runData: {},
+            },
+            executionData: {
+                contextData: {},
+                nodeExecutionStack: [],
+                waitingExecution: {},
+            },
+        };
+    }
+    /**
+     * Executes the given workflow.
+     *
+     * @param {Workflow} workflow The workflow to execute
+     * @param {INode[]} [startNodes] Node to start execution from
+     * @param {string} [destinationNode] Node to stop execution at
+     * @returns {(Promise<string>)}
+     * @memberof WorkflowExecute
+     */
+    // IMPORTANT: Do not add "async" to this function, it will then convert the
+    //            PCancelable to a regular Promise and does so not allow canceling
+    //            active executions anymore
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    run(workflow, startNode, destinationNode) {
+        // Get the nodes to start workflow execution from
+        startNode = startNode || workflow.getStartNode(destinationNode);
+        if (startNode === undefined) {
+            throw new Error('No node to start the workflow from could be found!');
+        }
+        // If a destination node is given we only run the direct parent nodes and no others
+        let runNodeFilter;
+        if (destinationNode) {
+            runNodeFilter = workflow.getParentNodes(destinationNode);
+            runNodeFilter.push(destinationNode);
+        }
+        // Initialize the data of the start nodes
+        const nodeExecutionStack = [
+            {
+                node: startNode,
+                data: {
+                    main: [
+                        [
+                            {
+                                json: {},
+                            },
+                        ],
+                    ],
+                },
+            },
+        ];
+        this.runExecutionData = {
+            startData: {
+                destinationNode,
+                runNodeFilter,
+            },
+            resultData: {
+                runData: {},
+            },
+            executionData: {
+                contextData: {},
+                nodeExecutionStack,
+                waitingExecution: {},
+            },
+        };
+        return this.processRunExecutionData(workflow);
+    }
+    /**
+     * Executes the given workflow but only
+     *
+     * @param {Workflow} workflow The workflow to execute
+     * @param {IRunData} runData
+     * @param {string[]} startNodes Nodes to start execution from
+     * @param {string} destinationNode Node to stop execution at
+     * @returns {(Promise<string>)}
+     * @memberof WorkflowExecute
+     */
+    // IMPORTANT: Do not add "async" to this function, it will then convert the
+    //            PCancelable to a regular Promise and does so not allow canceling
+    //            active executions anymore
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    runPartialWorkflow(workflow, runData, startNodes, destinationNode) {
+        let incomingNodeConnections;
+        let connection;
+        const runIndex = 0;
+        // Initialize the nodeExecutionStack and waitingExecution with
+        // the data from runData
+        const nodeExecutionStack = [];
+        const waitingExecution = {};
+        for (const startNode of startNodes) {
+            incomingNodeConnections = workflow.connectionsByDestinationNode[startNode];
+            const incomingData = [];
+            if (incomingNodeConnections === undefined) {
+                // If it has no incoming data add the default empty data
+                incomingData.push([
+                    {
+                        json: {},
+                    },
+                ]);
+            }
+            else {
+                // Get the data of the incoming connections
+                for (const connections of incomingNodeConnections['main']) {
+                    for (let inputIndex = 0; inputIndex < connections.length; inputIndex++) {
+                        connection = connections[inputIndex];
+                        incomingData.push(
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        runData[connection.node][runIndex].data[connection.type][connection.index]);
+                    }
+                }
+            }
+            const executeData = {
+                node: workflow.getNode(startNode),
+                data: {
+                    main: incomingData,
+                },
+            };
+            nodeExecutionStack.push(executeData);
+            // Check if the destinationNode has to be added as waiting
+            // because some input data is already fully available
+            incomingNodeConnections = workflow.connectionsByDestinationNode[destinationNode];
+            if (incomingNodeConnections !== undefined) {
+                for (const connections of incomingNodeConnections['main']) {
+                    for (let inputIndex = 0; inputIndex < connections.length; inputIndex++) {
+                        connection = connections[inputIndex];
+                        if (waitingExecution[destinationNode] === undefined) {
+                            waitingExecution[destinationNode] = {};
+                        }
+                        if (waitingExecution[destinationNode][runIndex] === undefined) {
+                            waitingExecution[destinationNode][runIndex] = {};
+                        }
+                        if (waitingExecution[destinationNode][runIndex][connection.type] === undefined) {
+                            waitingExecution[destinationNode][runIndex][connection.type] = [];
+                        }
+                        if (runData[connection.node] !== undefined) {
+                            // Input data exists so add as waiting
+                            // incomingDataDestination.push(runData[connection.node!][runIndex].data![connection.type][connection.index]);
+                            waitingExecution[destinationNode][runIndex][connection.type].push(runData[connection.node][runIndex].data[connection.type][connection.index]);
+                        }
+                        else {
+                            waitingExecution[destinationNode][runIndex][connection.type].push(null);
+                        }
+                    }
+                }
+            }
+        }
+        // Only run the parent nodes and no others
+        let runNodeFilter;
+        // eslint-disable-next-line prefer-const
+        runNodeFilter = workflow.getParentNodes(destinationNode);
+        runNodeFilter.push(destinationNode);
+        this.runExecutionData = {
+            startData: {
+                destinationNode,
+                runNodeFilter,
+            },
+            resultData: {
+                runData,
+            },
+            executionData: {
+                contextData: {},
+                nodeExecutionStack,
+                waitingExecution,
+            },
+        };
+        return this.processRunExecutionData(workflow);
+    }
+    /**
+     * Executes the hook with the given name
+     *
+     * @param {string} hookName
+     * @param {any[]} parameters
+     * @returns {Promise<IRun>}
+     * @memberof WorkflowExecute
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    executeHook(hookName, parameters) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            // tslint:disable-line:no-any
+            if (this.additionalData.hooks === undefined) {
+                return;
+            }
+            // eslint-disable-next-line consistent-return
+            return this.additionalData.hooks.executeHookFunctions(hookName, parameters);
+        });
+    }
+    /**
+     * Checks the incoming connection does not receive any data
+     */
+    incomingConnectionIsEmpty(runData, inputConnections, runIndex) {
+        // for (const inputConnection of workflow.connectionsByDestinationNode[nodeToAdd].main[0]) {
+        for (const inputConnection of inputConnections) {
+            const nodeIncomingData = (0, lodash_1.get)(runData, `[${inputConnection.node}][${runIndex}].data.main[${inputConnection.index}]`);
+            if (nodeIncomingData !== undefined && nodeIncomingData.length !== 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    addNodeToBeExecuted(workflow, connectionData, outputIndex, parentNodeName, nodeSuccessData, runIndex) {
+        let stillDataMissing = false;
+        // Check if node has multiple inputs as then we have to wait for all input data
+        // to be present before we can add it to the node-execution-stack
+        if (workflow.connectionsByDestinationNode[connectionData.node]['main'].length > 1) {
+            // Node has multiple inputs
+            let nodeWasWaiting = true;
+            // Check if there is already data for the node
+            if (this.runExecutionData.executionData.waitingExecution[connectionData.node] === undefined) {
+                // Node does not have data yet so create a new empty one
+                this.runExecutionData.executionData.waitingExecution[connectionData.node] = {};
+                nodeWasWaiting = false;
+            }
+            if (this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex] ===
+                undefined) {
+                // Node does not have data for runIndex yet so create also empty one and init it
+                this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex] = {
+                    main: [],
+                };
+                for (let i = 0; i < workflow.connectionsByDestinationNode[connectionData.node]['main'].length; i++) {
+                    this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]['main'].push(null);
+                }
+            }
+            // Add the new data
+            if (nodeSuccessData === null) {
+                this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]['main'][connectionData.index] = null;
+            }
+            else {
+                this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]['main'][connectionData.index] = nodeSuccessData[outputIndex];
+            }
+            // Check if all data exists now
+            let thisExecutionData;
+            let allDataFound = true;
+            for (let i = 0; i <
+                this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]['main']
+                    .length; i++) {
+                thisExecutionData =
+                    this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]['main'][i];
+                if (thisExecutionData === null) {
+                    allDataFound = false;
+                    break;
+                }
+            }
+            if (allDataFound) {
+                // All data exists for node to be executed
+                // So add it to the execution stack
+                this.runExecutionData.executionData.nodeExecutionStack.push({
+                    node: workflow.nodes[connectionData.node],
+                    data: this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex],
+                });
+                // Remove the data from waiting
+                delete this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex];
+                if (Object.keys(this.runExecutionData.executionData.waitingExecution[connectionData.node])
+                    .length === 0) {
+                    // No more data left for the node so also delete that one
+                    delete this.runExecutionData.executionData.waitingExecution[connectionData.node];
+                }
+                return;
+            }
+            stillDataMissing = true;
+            if (!nodeWasWaiting) {
+                // Get a list of all the output nodes that we can check for siblings easier
+                const checkOutputNodes = [];
+                // eslint-disable-next-line @typescript-eslint/no-for-in-array
+                for (const outputIndexParent in workflow.connectionsBySourceNode[parentNodeName]['main']) {
+                    if (
+                    // eslint-disable-next-line no-prototype-builtins
+                    !workflow.connectionsBySourceNode[parentNodeName]['main'].hasOwnProperty(outputIndexParent)) {
+                        continue;
+                    }
+                    for (const connectionDataCheck of workflow.connectionsBySourceNode[parentNodeName]['main'][outputIndexParent]) {
+                        checkOutputNodes.push(connectionDataCheck.node);
+                    }
+                }
+                // Node was not on "waitingExecution" so it is the first time it gets
+                // checked. So we have to go through all the inputs and check if they
+                // are already on the list to be processed.
+                // If that is not the case add it.
+                for (let inputIndex = 0; inputIndex < workflow.connectionsByDestinationNode[connectionData.node]['main'].length; inputIndex++) {
+                    for (const inputData of workflow.connectionsByDestinationNode[connectionData.node]['main'][inputIndex]) {
+                        if (inputData.node === parentNodeName) {
+                            // Is the node we come from so its data will be available for sure
+                            continue;
+                        }
+                        const executionStackNodes = this.runExecutionData.executionData.nodeExecutionStack.map((stackData) => stackData.node.name);
+                        // Check if that node is also an output connection of the
+                        // previously processed one
+                        if (inputData.node !== parentNodeName && checkOutputNodes.includes(inputData.node)) {
+                            // So the parent node will be added anyway which
+                            // will then process this node next. So nothing to do
+                            // unless the incoming data of the node is empty
+                            // because then it would not be executed
+                            if (!this.incomingConnectionIsEmpty(this.runExecutionData.resultData.runData, workflow.connectionsByDestinationNode[inputData.node]['main'][0], runIndex)) {
+                                continue;
+                            }
+                        }
+                        // Check if it is already in the execution stack
+                        if (executionStackNodes.includes(inputData.node)) {
+                            // Node is already on the list to be executed
+                            // so there is nothing to do
+                            continue;
+                        }
+                        // Check if node got processed already
+                        if (this.runExecutionData.resultData.runData[inputData.node] !== undefined) {
+                            // Node got processed already so no need to add it
+                            continue;
+                        }
+                        // Check if any of the parent nodes does not have any inputs. That
+                        // would mean that it has to get added to the list of nodes to process.
+                        const parentNodes = workflow.getParentNodes(inputData.node, 'main', -1);
+                        let nodeToAdd = inputData.node;
+                        parentNodes.push(inputData.node);
+                        parentNodes.reverse();
+                        for (const parentNode of parentNodes) {
+                            // Check if that node is also an output connection of the
+                            // previously processed one
+                            if (inputData.node !== parentNode && checkOutputNodes.includes(parentNode)) {
+                                // So the parent node will be added anyway which
+                                // will then process this node next. So nothing to do.
+                                nodeToAdd = undefined;
+                                break;
+                            }
+                            // Check if it is already in the execution stack
+                            if (executionStackNodes.includes(parentNode)) {
+                                // Node is already on the list to be executed
+                                // so there is nothing to do
+                                nodeToAdd = undefined;
+                                break;
+                            }
+                            // Check if node got processed already
+                            if (this.runExecutionData.resultData.runData[parentNode] !== undefined) {
+                                // Node got processed already so we can use the
+                                // output data as input of this node
+                                break;
+                            }
+                            nodeToAdd = parentNode;
+                        }
+                        const parentNodesNodeToAdd = workflow.getParentNodes(nodeToAdd);
+                        if (parentNodesNodeToAdd.includes(parentNodeName) &&
+                            nodeSuccessData[outputIndex].length === 0) {
+                            // We do not add the node if there is no input data and the node that should be connected
+                            // is a child of the parent node. Because else it would run a node even though it should be
+                            // specifically not run, as it did not receive any data.
+                            nodeToAdd = undefined;
+                        }
+                        if (nodeToAdd === undefined) {
+                            // No node has to get added so process
+                            continue;
+                        }
+                        let addEmptyItem = false;
+                        if (workflow.connectionsByDestinationNode[nodeToAdd] === undefined) {
+                            // Add empty item if the node does not have any input connections
+                            addEmptyItem = true;
+                        }
+                        else if (this.incomingConnectionIsEmpty(this.runExecutionData.resultData.runData, workflow.connectionsByDestinationNode[nodeToAdd]['main'][0], runIndex)) {
+                            // Add empty item also if the input data is empty
+                            addEmptyItem = true;
+                        }
+                        if (addEmptyItem) {
+                            // Add only node if it does not have any inputs because else it will
+                            // be added by its input node later anyway.
+                            this.runExecutionData.executionData.nodeExecutionStack.push({
+                                node: workflow.getNode(nodeToAdd),
+                                data: {
+                                    main: [
+                                        [
+                                            {
+                                                json: {},
+                                            },
+                                        ],
+                                    ],
+                                },
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Make sure the array has all the values
+        const connectionDataArray = [];
+        for (let i = connectionData.index; i >= 0; i--) {
+            connectionDataArray[i] = null;
+        }
+        // Add the data of the current execution
+        if (nodeSuccessData === null) {
+            connectionDataArray[connectionData.index] = null;
+        }
+        else {
+            connectionDataArray[connectionData.index] = nodeSuccessData[outputIndex];
+        }
+        if (stillDataMissing) {
+            // Additional data is needed to run node so add it to waiting
+            if (
+            // eslint-disable-next-line no-prototype-builtins
+            !this.runExecutionData.executionData.waitingExecution.hasOwnProperty(connectionData.node)) {
+                this.runExecutionData.executionData.waitingExecution[connectionData.node] = {};
+            }
+            this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex] = {
+                main: connectionDataArray,
+            };
+        }
+        else {
+            // All data is there so add it directly to stack
+            this.runExecutionData.executionData.nodeExecutionStack.push({
+                node: workflow.nodes[connectionData.node],
+                data: {
+                    main: connectionDataArray,
+                },
+            });
+        }
+    }
+    /**
+     * Runs the given execution data.
+     *
+     * @param {Workflow} workflow
+     * @returns {Promise<string>}
+     * @memberof WorkflowExecute
+     */
+    // IMPORTANT: Do not add "async" to this function, it will then convert the
+    //            PCancelable to a regular Promise and does so not allow canceling
+    //            active executions anymore
+    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    processRunExecutionData(workflow) {
+        workflow_1.LoggerProxy.verbose('Workflow execution started', { workflowId: workflow.id });
+        console.log(`Workflow execution started: ID: ${workflow.id} - Name: ${workflow.name} - Active: ${workflow.active ? 'active' : 'inactive'}`);
+        const startedAt = new Date();
+        const startNode = this.runExecutionData.executionData.nodeExecutionStack[0].node.name;
+        let destinationNode;
+        if (this.runExecutionData.startData && this.runExecutionData.startData.destinationNode) {
+            destinationNode = this.runExecutionData.startData.destinationNode;
+        }
+        const workflowIssues = workflow.checkReadyForExecution({ startNode, destinationNode });
+        if (workflowIssues !== null) {
+            throw new Error('The workflow has issues and can for that reason not be executed. Please fix them first.');
+        }
+        // Variables which hold temporary data for each node-execution
+        let executionData;
+        let executionError;
+        let executionNode;
+        let nodeSuccessData;
+        let runIndex;
+        let startTime;
+        let taskData;
+        if (this.runExecutionData.startData === undefined) {
+            this.runExecutionData.startData = {};
+        }
+        if (this.runExecutionData.waitTill) {
+            const lastNodeExecuted = this.runExecutionData.resultData.lastNodeExecuted;
+            this.runExecutionData.executionData.nodeExecutionStack[0].node.disabled = true;
+            this.runExecutionData.waitTill = undefined;
+            this.runExecutionData.resultData.runData[lastNodeExecuted].pop();
+        }
+        let currentExecutionTry = '';
+        let lastExecutionTry = '';
+        return new PCancelable((resolve, reject, onCancel) => {
+            let gotCancel = false;
+            onCancel.shouldReject = false;
+            onCancel(() => {
+                gotCancel = true;
+            });
+            const returnPromise = (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                try {
+                    yield this.executeHook('workflowExecuteBefore', [workflow]);
+                }
+                catch (error) {
+                    // Set the error that it can be saved correctly
+                    executionError = Object.assign(Object.assign({}, error), { message: error.message, stack: error.stack });
+                    // Set the incoming data of the node that it can be saved correctly
+                    // eslint-disable-next-line prefer-destructuring
+                    executionData = this.runExecutionData.executionData.nodeExecutionStack[0];
+                    this.runExecutionData.resultData = {
+                        runData: {
+                            [executionData.node.name]: [
+                                {
+                                    startTime,
+                                    executionTime: new Date().getTime() - startTime,
+                                    data: {
+                                        main: executionData.data['main'],
+                                    },
+                                },
+                            ],
+                        },
+                        lastNodeExecuted: executionData.node.name,
+                        error: executionError,
+                    };
+                    throw error;
+                }
+                executionLoop: while (this.runExecutionData.executionData.nodeExecutionStack.length !== 0) {
+                    if (this.additionalData.executionTimeoutTimestamp !== undefined &&
+                        Date.now() >= this.additionalData.executionTimeoutTimestamp) {
+                        gotCancel = true;
+                    }
+                    if (gotCancel) {
+                        return Promise.resolve();
+                    }
+                    nodeSuccessData = null;
+                    executionError = undefined;
+                    executionData =
+                        this.runExecutionData.executionData.nodeExecutionStack.shift();
+                    executionNode = executionData.node;
+                    workflow_1.LoggerProxy.debug(`Start processing node "${executionNode.name}"`, {
+                        node: executionNode.name,
+                        workflowId: workflow.id,
+                    });
+                    yield this.executeHook('nodeExecuteBefore', [executionNode.name]);
+                    // Get the index of the current run
+                    runIndex = 0;
+                    // eslint-disable-next-line no-prototype-builtins
+                    if (this.runExecutionData.resultData.runData.hasOwnProperty(executionNode.name)) {
+                        runIndex = this.runExecutionData.resultData.runData[executionNode.name].length;
+                    }
+                    currentExecutionTry = `${executionNode.name}:${runIndex}`;
+                    if (currentExecutionTry === lastExecutionTry) {
+                        throw new Error('Did stop execution because execution seems to be in endless loop.');
+                    }
+                    if (this.runExecutionData.startData.runNodeFilter !== undefined &&
+                        this.runExecutionData.startData.runNodeFilter.indexOf(executionNode.name) === -1) {
+                        // If filter is set and node is not on filter skip it, that avoids the problem that it executes
+                        // leafs that are parallel to a selected destinationNode. Normally it would execute them because
+                        // they have the same parent and it executes all child nodes.
+                        continue;
+                    }
+                    // Check if all the data which is needed to run the node is available
+                    if (Object.prototype.hasOwnProperty.call(workflow.connectionsByDestinationNode, executionNode.name)) {
+                        // Check if the node has incoming connections
+                        if (Object.prototype.hasOwnProperty.call(workflow.connectionsByDestinationNode[executionNode.name], 'main')) {
+                            let inputConnections;
+                            let connectionIndex;
+                            // eslint-disable-next-line prefer-const
+                            inputConnections = workflow.connectionsByDestinationNode[executionNode.name]['main'];
+                            for (connectionIndex = 0; connectionIndex < inputConnections.length; connectionIndex++) {
+                                if (workflow.getHighestNode(executionNode.name, 'main', connectionIndex).length === 0) {
+                                    // If there is no valid incoming node (if all are disabled)
+                                    // then ignore that it has inputs and simply execute it as it is without
+                                    // any data
+                                    continue;
+                                }
+                                if (!Object.prototype.hasOwnProperty.call(executionData.data, 'main')) {
+                                    // ExecutionData does not even have the connection set up so can
+                                    // not have that data, so add it again to be executed later
+                                    this.runExecutionData.executionData.nodeExecutionStack.push(executionData);
+                                    lastExecutionTry = currentExecutionTry;
+                                    continue executionLoop;
+                                }
+                                // Check if it has the data for all the inputs
+                                // The most nodes just have one but merge node for example has two and data
+                                // of both inputs has to be available to be able to process the node.
+                                if (executionData.data['main'].length < connectionIndex ||
+                                    executionData.data['main'][connectionIndex] === null) {
+                                    // Does not have the data of the connections so add back to stack
+                                    this.runExecutionData.executionData.nodeExecutionStack.push(executionData);
+                                    lastExecutionTry = currentExecutionTry;
+                                    continue executionLoop;
+                                }
+                            }
+                        }
+                    }
+                    // Clone input data that nodes can not mess up data of parallel nodes which receive the same data
+                    // TODO: Should only clone if multiple nodes get the same data or when it gets returned to frontned
+                    //       is very slow so only do if needed
+                    startTime = new Date().getTime();
+                    let maxTries = 1;
+                    if (executionData.node.retryOnFail === true) {
+                        // TODO: Remove the hardcoded default-values here and also in NodeSettings.vue
+                        maxTries = Math.min(5, Math.max(2, executionData.node.maxTries || 3));
+                    }
+                    let waitBetweenTries = 0;
+                    if (executionData.node.retryOnFail === true) {
+                        // TODO: Remove the hardcoded default-values here and also in NodeSettings.vue
+                        waitBetweenTries = Math.min(5000, Math.max(0, executionData.node.waitBetweenTries || 1000));
+                    }
+                    for (let tryIndex = 0; tryIndex < maxTries; tryIndex++) {
+                        if (gotCancel) {
+                            return Promise.resolve();
+                        }
+                        try {
+                            if (tryIndex !== 0) {
+                                // Reset executionError from previous error try
+                                executionError = undefined;
+                                if (waitBetweenTries !== 0) {
+                                    // TODO: Improve that in the future and check if other nodes can
+                                    //       be executed in the meantime
+                                    // eslint-disable-next-line @typescript-eslint/no-shadow
+                                    yield new Promise((resolve) => {
+                                        setTimeout(() => {
+                                            resolve(undefined);
+                                        }, waitBetweenTries);
+                                    });
+                                }
+                            }
+                            workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" started`, {
+                                node: executionNode.name,
+                                workflowId: workflow.id,
+                            });
+                            nodeSuccessData = yield workflow.runNode(executionData.node, executionData.data, this.runExecutionData, runIndex, this.additionalData, src_1.NodeExecuteFunctions, this.mode);
+                            workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" finished successfully`, {
+                                node: executionNode.name,
+                                workflowId: workflow.id,
+                            });
+                            if (nodeSuccessData === undefined) {
+                                // Node did not get executed
+                                nodeSuccessData = null;
+                            }
+                            else {
+                                this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
+                            }
+                            if (nodeSuccessData === null || nodeSuccessData[0][0] === undefined) {
+                                if (executionData.node.alwaysOutputData === true) {
+                                    nodeSuccessData = nodeSuccessData || [];
+                                    nodeSuccessData[0] = [
+                                        {
+                                            json: {},
+                                        },
+                                    ];
+                                }
+                            }
+                            if (nodeSuccessData === null && !this.runExecutionData.waitTill) {
+                                // If null gets returned it means that the node did succeed
+                                // but did not have any data. So the branch should end
+                                // (meaning the nodes afterwards should not be processed)
+                                continue executionLoop;
+                            }
+                            break;
+                        }
+                        catch (error) {
+                            this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
+                            executionError = Object.assign(Object.assign({}, error), { message: error.message, stack: error.stack });
+                            workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" finished with error`, {
+                                node: executionNode.name,
+                                workflowId: workflow.id,
+                            });
+                        }
+                    }
+                    // Add the data to return to the user
+                    // (currently does not get cloned as data does not get changed, maybe later we should do that?!?!)
+                    if (!Object.prototype.hasOwnProperty.call(this.runExecutionData.resultData.runData, executionNode.name)) {
+                        this.runExecutionData.resultData.runData[executionNode.name] = [];
+                    }
+                    taskData = {
+                        startTime,
+                        executionTime: new Date().getTime() - startTime,
+                    };
+                    if (executionError !== undefined) {
+                        taskData.error = executionError;
+                        if (executionData.node.continueOnFail === true) {
+                            // Workflow should continue running even if node errors
+                            if (Object.prototype.hasOwnProperty.call(executionData.data, 'main') && executionData.data['main'].length > 0) {
+                                // Simply get the input data of the node if it has any and pass it through
+                                // to the next node
+                                if (executionData.data['main'][0] !== null) {
+                                    nodeSuccessData = [executionData.data['main'][0]];
+                                }
+                            }
+                        }
+                        else {
+                            // Node execution did fail so add error and stop execution
+                            this.runExecutionData.resultData.runData[executionNode.name].push(taskData);
+                            // Add the execution data again so that it can get restarted
+                            this.runExecutionData.executionData.nodeExecutionStack.unshift(executionData);
+                            yield this.executeHook('nodeExecuteAfter', [
+                                executionNode.name,
+                                taskData,
+                                this.runExecutionData,
+                            ]);
+                            break;
+                        }
+                    }
+                    // Merge error information to default output for now
+                    // As the new nodes can report the errors in
+                    // the `error` property.
+                    for (const execution of nodeSuccessData) {
+                        for (const lineResult of execution) {
+                            if (lineResult.json !== undefined &&
+                                lineResult.json['$error'] !== undefined &&
+                                lineResult.json['$error'] !== undefined) {
+                                lineResult.error = lineResult.json['$error'];
+                                lineResult.json = {
+                                    error: lineResult.json['$error'].message,
+                                };
+                            }
+                            else if (lineResult.error !== undefined) {
+                                lineResult.json = { error: lineResult.error.message };
+                            }
+                        }
+                    }
+                    // Node executed successfully. So add data and go on.
+                    taskData.data = {
+                        main: nodeSuccessData,
+                    };
+                    this.runExecutionData.resultData.runData[executionNode.name].push(taskData);
+                    if (this.runExecutionData.waitTill) {
+                        yield this.executeHook('nodeExecuteAfter', [
+                            executionNode.name,
+                            taskData,
+                            this.runExecutionData,
+                        ]);
+                        // Add the node back to the stack that the workflow can start to execute again from that node
+                        this.runExecutionData.executionData.nodeExecutionStack.unshift(executionData);
+                        break;
+                    }
+                    if (this.runExecutionData.startData &&
+                        this.runExecutionData.startData.destinationNode &&
+                        this.runExecutionData.startData.destinationNode === executionNode.name) {
+                        // Before stopping, make sure we are executing hooks so
+                        // That frontend is notified for example for manual executions.
+                        yield this.executeHook('nodeExecuteAfter', [
+                            executionNode.name,
+                            taskData,
+                            this.runExecutionData,
+                        ]);
+                        // If destination node is defined and got executed stop execution
+                        continue;
+                    }
+                    // Add the nodes to which the current node has an output connection to that they can
+                    // be executed next
+                    if (Object.prototype.hasOwnProperty.call(workflow.connectionsBySourceNode, executionNode.name)) {
+                        if (Object.prototype.hasOwnProperty.call(workflow.connectionsBySourceNode[executionNode.name], 'main')) {
+                            let outputIndex;
+                            let connectionData;
+                            // Iterate over all the outputs
+                            // Add the nodes to be executed
+                            // eslint-disable-next-line @typescript-eslint/no-for-in-array
+                            for (outputIndex in workflow.connectionsBySourceNode[executionNode.name]['main']) {
+                                if (!Object.prototype.hasOwnProperty.call(workflow.connectionsBySourceNode[executionNode.name]['main'], outputIndex)) {
+                                    continue;
+                                }
+                                // Iterate over all the different connections of this output
+                                for (connectionData of workflow.connectionsBySourceNode[executionNode.name]['main'][outputIndex]) {
+                                    if (!Object.prototype.hasOwnProperty.call(workflow.nodes, connectionData.node)) {
+                                        return Promise.reject(new Error(`The node "${executionNode.name}" connects to not found node "${connectionData.node}"`));
+                                    }
+                                    if (nodeSuccessData[outputIndex] &&
+                                        (nodeSuccessData[outputIndex].length !== 0 || connectionData.index > 0)) {
+                                        // Add the node only if it did execute or if connected to second "optional" input
+                                        this.addNodeToBeExecuted(workflow, connectionData, parseInt(outputIndex, 10), executionNode.name, nodeSuccessData, runIndex);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // If we got here, it means that we did not stop executing from manual executions / destination.
+                    // Execute hooks now to make sure that all hooks are executed properly
+                    // Await is needed to make sure that we don't fall into concurrency problems
+                    // When saving node execution data
+                    yield this.executeHook('nodeExecuteAfter', [
+                        executionNode.name,
+                        taskData,
+                        this.runExecutionData,
+                    ]);
+                }
+                return Promise.resolve();
+            }))()
+                .then(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                if (gotCancel && executionError === undefined) {
+                    return this.processSuccessExecution(startedAt, workflow, new workflow_1.WorkflowOperationError('Workflow has been canceled or timed out!'));
+                }
+                return this.processSuccessExecution(startedAt, workflow, executionError);
+            }))
+                .catch((error) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                const fullRunData = this.getFullRunData(startedAt);
+                fullRunData.data.resultData.error = Object.assign(Object.assign({}, error), { message: error.message, stack: error.stack });
+                // Check if static data changed
+                let newStaticData;
+                // eslint-disable-next-line no-underscore-dangle
+                if (workflow.staticData['__dataChanged'] === true) {
+                    // Static data of workflow changed
+                    newStaticData = workflow.staticData;
+                }
+                yield this.executeHook('workflowExecuteAfter', [fullRunData, newStaticData]).catch(
+                // eslint-disable-next-line @typescript-eslint/no-shadow
+                (error) => {
+                    // eslint-disable-next-line no-console
+                    console.error('There was a problem running hook "workflowExecuteAfter"', error);
+                });
+                return fullRunData;
+            }));
+            return returnPromise.then(resolve);
+        });
+    }
+    processSuccessExecution(startedAt, workflow, executionError) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const fullRunData = this.getFullRunData(startedAt);
+            if (executionError !== undefined) {
+                workflow_1.LoggerProxy.verbose(`Workflow execution finished with error`, {
+                    error: executionError,
+                    workflowId: workflow.id,
+                });
+                fullRunData.data.resultData.error = Object.assign(Object.assign({}, executionError), { message: executionError.message, stack: executionError.stack });
+            }
+            else if (this.runExecutionData.waitTill) {
+                // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+                workflow_1.LoggerProxy.verbose(`Workflow execution will wait until ${this.runExecutionData.waitTill}`, {
+                    workflowId: workflow.id,
+                });
+                fullRunData.waitTill = this.runExecutionData.waitTill;
+            }
+            else {
+                workflow_1.LoggerProxy.verbose(`Workflow execution finished successfully`, { workflowId: workflow.id });
+                fullRunData.finished = true;
+            }
+            // Check if static data changed
+            let newStaticData;
+            // eslint-disable-next-line no-underscore-dangle
+            if (workflow.staticData['__dataChanged'] === true) {
+                // Static data of workflow changed
+                newStaticData = workflow.staticData;
+            }
+            yield this.executeHook('workflowExecuteAfter', [fullRunData, newStaticData]);
+            return fullRunData;
+        });
+    }
+    getFullRunData(startedAt) {
+        const fullRunData = {
+            data: this.runExecutionData,
+            mode: this.mode,
+            startedAt,
+            stoppedAt: new Date(),
+        };
+        return fullRunData;
+    }
+}
+exports.WorkflowExecute = WorkflowExecute;
+//# sourceMappingURL=WorkflowExecute.js.map