@fsai-flow/core 0.0.5 → 0.1.1

package/dist/lib/WorkflowExecute.js

@@ -0,0 +1,906 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowExecute = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+const lodash_1 = require("lodash");
+const p_cancelable_1 = __importDefault(require("p-cancelable"));
+const __1 = require("..");
+/**
+ * Guards against prototype-polluting property keys.
+ * Throws if the key would modify Object.prototype when used in a bracket assignment.
+ */
+function assertSafeKey(key) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+        throw new workflow_1.WorkflowOperationError(`Refusing to use unsafe property key "${key}"`);
+    }
+}
+class WorkflowExecute {
+    constructor(additionalData, mode, runExecutionData) {
+        this.additionalData = additionalData;
+        this.mode = mode;
+        this.runExecutionData = runExecutionData || {
+            startData: {},
+            resultData: {
+                runData: Object.create(null),
+            },
+            executionData: {
+                contextData: {},
+                nodeExecutionStack: [],
+                waitingExecution: Object.create(null),
+            },
+        };
+    }
+    /**
+     * 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
+        const resolvedStartNode = startNode || workflow.getStartNode(destinationNode);
+        if (resolvedStartNode === 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: resolvedStartNode,
+                data: {
+                    main: [
+                        [
+                            {
+                                json: {},
+                            },
+                        ],
+                    ],
+                },
+            },
+        ];
+        this.runExecutionData = {
+            startData: {
+                destinationNode,
+                runNodeFilter,
+            },
+            resultData: {
+                runData: Object.create(null),
+            },
+            executionData: {
+                contextData: {},
+                nodeExecutionStack,
+                waitingExecution: Object.create(null),
+            },
+        };
+        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 = Object.create(null);
+        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];
+                        assertSafeKey(destinationNode);
+                        assertSafeKey(connection.type);
+                        if (waitingExecution[destinationNode] === undefined) {
+                            waitingExecution[destinationNode] = Object.create(null);
+                        }
+                        if (waitingExecution[destinationNode][runIndex] === undefined) {
+                            waitingExecution[destinationNode][runIndex] = Object.create(null);
+                        }
+                        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
+        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 {unknown[]} parameters
+     * @returns {Promise<IRun>}
+     * @memberof WorkflowExecute
+     */
+    async executeHook(hookName, parameters) {
+        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
+            assertSafeKey(connectionData.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] = Object.create(null);
+                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 (!Object.hasOwn(workflow.connectionsBySourceNode[parentNodeName]["main"], 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
+            assertSafeKey(connectionData.node);
+            if (!Object.hasOwn(this.runExecutionData.executionData.waitingExecution, connectionData.node)) {
+                this.runExecutionData.executionData.waitingExecution[connectionData.node] = Object.create(null);
+            }
+            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?.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 p_cancelable_1.default((resolve, _reject, onCancel) => {
+            let gotCancel = false;
+            onCancel.shouldReject = false;
+            onCancel(() => {
+                gotCancel = true;
+            });
+            const returnPromise = (async () => {
+                try {
+                    await this.executeHook("workflowExecuteBefore", [workflow]);
+                }
+                catch (error) {
+                    // Set the error that it can be saved correctly
+                    executionError = {
+                        ...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: Date.now() - 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,
+                    });
+                    await this.executeHook("nodeExecuteBefore", [executionNode.name]);
+                    // Get the index of the current run
+                    runIndex = 0;
+                    if (Object.hasOwn(this.runExecutionData.resultData.runData, 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.hasOwn(workflow.connectionsByDestinationNode, executionNode.name)) {
+                        // Check if the node has incoming connections
+                        if (Object.hasOwn(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.hasOwn(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 = Date.now();
+                    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
+                                    await new Promise((resolve) => {
+                                        setTimeout(() => {
+                                            resolve(undefined);
+                                        }, waitBetweenTries);
+                                    });
+                                }
+                            }
+                            workflow_1.LoggerProxy.debug(`Running node "${executionNode.name}" started`, {
+                                node: executionNode.name,
+                                workflowId: workflow.id,
+                            });
+                            nodeSuccessData = await workflow.runNode(executionData.node, executionData.data, this.runExecutionData, runIndex, this.additionalData, __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;
+                            const err = error;
+                            executionError = {
+                                ...err,
+                                message: err.message,
+                                stack: err.stack,
+                            };
+                            // Check if it's a critical database connection error that should fail immediately
+                            const isCriticalConnectionError = err.message?.includes("too many clients") ||
+                                err.message?.includes("Connection terminated") ||
+                                err.message?.includes("connection is closed") ||
+                                err.message?.includes("ECONNRESET") ||
+                                err.message?.includes("ENOTFOUND") ||
+                                err.code === "ECONNRESET" ||
+                                err.code === "ENOTFOUND";
+                            if (isCriticalConnectionError) {
+                                workflow_1.LoggerProxy.error(`Critical database connection error in node "${executionNode.name}": ${err.message}`, {
+                                    node: executionNode.name,
+                                    workflowId: workflow.id,
+                                    error: err.message,
+                                });
+                                // For critical connection errors, break out of retry loop immediately
+                                // This will cause the workflow to fail on this node
+                                break;
+                            }
+                            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?!?!)
+                    assertSafeKey(executionNode.name);
+                    if (!Object.hasOwn(this.runExecutionData.resultData.runData, executionNode.name)) {
+                        this.runExecutionData.resultData.runData[executionNode.name] = [];
+                    }
+                    taskData = {
+                        startTime,
+                        executionTime: Date.now() - startTime,
+                    };
+                    if (executionError !== undefined) {
+                        taskData.error = executionError;
+                        if (executionData.node.continueOnFail === true) {
+                            // Workflow should continue running even if node errors
+                            if (Object.hasOwn(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);
+                            await 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) {
+                        await 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?.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.
+                        await 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.hasOwn(workflow.connectionsBySourceNode, executionNode.name)) {
+                        if (Object.hasOwn(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.hasOwn(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.hasOwn(workflow.nodes, connectionData.node)) {
+                                        return Promise.reject(new Error(`The node "${executionNode.name}" connects to not found node "${connectionData.node}"`));
+                                    }
+                                    if (nodeSuccessData[Number(outputIndex)] &&
+                                        (nodeSuccessData[Number(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, Number.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
+                    await this.executeHook("nodeExecuteAfter", [
+                        executionNode.name,
+                        taskData,
+                        this.runExecutionData,
+                    ]);
+                }
+                return Promise.resolve();
+            })()
+                .then(async () => {
+                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(async (error) => {
+                const fullRunData = this.getFullRunData(startedAt);
+                fullRunData.data.resultData.error = {
+                    ...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;
+                }
+                await 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);
+        });
+    }
+    async processSuccessExecution(startedAt, workflow, executionError) {
+        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 = {
+                ...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;
+        }
+        await 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;