@fsai-flow/core 0.0.4 → 0.1.0

package/dist/{src/lib → lib}/WorkflowExecute.js

@@ -1,11 +1,22 @@
 "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 tslib_1 = require("tslib");
-const PCancelable = require("p-cancelable");
 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;
@@ -13,12 +24,12 @@ class WorkflowExecute {
         this.runExecutionData = runExecutionData || {
             startData: {},
             resultData: {
-                runData: {},
+                runData: Object.create(null),
             },
             executionData: {
                 contextData: {},
                 nodeExecutionStack: [],
-                waitingExecution: {},
+                waitingExecution: Object.create(null),
             },
         };
     }
@@ -37,20 +48,20 @@ class WorkflowExecute {
     // 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!');
+        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);
+            runNodeFilter?.push(destinationNode);
         }
         // Initialize the data of the start nodes
         const nodeExecutionStack = [
             {
-                node: startNode,
+                node: resolvedStartNode,
                 data: {
                     main: [
                         [
@@ -68,12 +79,12 @@ class WorkflowExecute {
                 runNodeFilter,
             },
             resultData: {
-                runData: {},
+                runData: Object.create(null),
             },
             executionData: {
                 contextData: {},
                 nodeExecutionStack,
-                waitingExecution: {},
+                waitingExecution: Object.create(null),
             },
         };
         return this.processRunExecutionData(workflow);
@@ -99,9 +110,10 @@ class WorkflowExecute {
         // Initialize the nodeExecutionStack and waitingExecution with
         // the data from runData
         const nodeExecutionStack = [];
-        const waitingExecution = {};
+        const waitingExecution = Object.create(null);
         for (const startNode of startNodes) {
-            incomingNodeConnections = workflow.connectionsByDestinationNode[startNode];
+            incomingNodeConnections =
+                workflow.connectionsByDestinationNode[startNode];
             const incomingData = [];
             if (incomingNodeConnections === undefined) {
                 // If it has no incoming data add the default empty data
@@ -113,7 +125,7 @@ class WorkflowExecute {
             }
             else {
                 // Get the data of the incoming connections
-                for (const connections of incomingNodeConnections['main']) {
+                for (const connections of incomingNodeConnections["main"]) {
                     for (let inputIndex = 0; inputIndex < connections.length; inputIndex++) {
                         connection = connections[inputIndex];
                         incomingData.push(
@@ -131,18 +143,22 @@ class WorkflowExecute {
             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];
+            incomingNodeConnections =
+                workflow.connectionsByDestinationNode[destinationNode];
             if (incomingNodeConnections !== undefined) {
-                for (const connections of incomingNodeConnections['main']) {
+                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] = {};
+                            waitingExecution[destinationNode] = Object.create(null);
                         }
                         if (waitingExecution[destinationNode][runIndex] === undefined) {
-                            waitingExecution[destinationNode][runIndex] = {};
+                            waitingExecution[destinationNode][runIndex] = Object.create(null);
                         }
-                        if (waitingExecution[destinationNode][runIndex][connection.type] === undefined) {
+                        if (waitingExecution[destinationNode][runIndex][connection.type] ===
+                            undefined) {
                             waitingExecution[destinationNode][runIndex][connection.type] = [];
                         }
                         if (runData[connection.node] !== undefined) {
@@ -158,10 +174,8 @@ class WorkflowExecute {
             }
         }
         // Only run the parent nodes and no others
-        let runNodeFilter;
-        // eslint-disable-next-line prefer-const
-        runNodeFilter = workflow.getParentNodes(destinationNode);
-        runNodeFilter.push(destinationNode);
+        const runNodeFilter = workflow.getParentNodes(destinationNode);
+        runNodeFilter?.push(destinationNode);
         this.runExecutionData = {
             startData: {
                 destinationNode,
@@ -182,20 +196,16 @@ class WorkflowExecute {
      * Executes the hook with the given name
      *
      * @param {string} hookName
-     * @param {any[]} parameters
+     * @param {unknown[]} 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);
-        });
+    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
@@ -204,7 +214,8 @@ class WorkflowExecute {
         // 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) {
+            if (nodeIncomingData !== undefined &&
+                nodeIncomingData.length !== 0) {
                 return false;
             }
         }
@@ -214,40 +225,43 @@ class WorkflowExecute {
         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) {
+        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] = {};
+                this.runExecutionData.executionData.waitingExecution[connectionData.node] = Object.create(null);
                 nodeWasWaiting = false;
             }
-            if (this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex] ===
-                undefined) {
+            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);
+                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;
+                this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]["main"][connectionData.index] = null;
             }
             else {
-                this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]['main'][connectionData.index] = nodeSuccessData[outputIndex];
+                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++) {
+                this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]["main"].length; i++) {
                 thisExecutionData =
-                    this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]['main'][i];
+                    this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex]["main"][i];
                 if (thisExecutionData === null) {
                     allDataFound = false;
                     break;
@@ -262,8 +276,7 @@ class WorkflowExecute {
                 });
                 // Remove the data from waiting
                 delete this.runExecutionData.executionData.waitingExecution[connectionData.node][runIndex];
-                if (Object.keys(this.runExecutionData.executionData.waitingExecution[connectionData.node])
-                    .length === 0) {
+                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];
                 }
@@ -274,13 +287,11 @@ class WorkflowExecute {
                 // 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)) {
+                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]) {
+                    for (const connectionDataCheck of workflow.connectionsBySourceNode[parentNodeName]["main"][outputIndexParent]) {
                         checkOutputNodes.push(connectionDataCheck.node);
                     }
                 }
@@ -288,8 +299,10 @@ class WorkflowExecute {
                 // 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]) {
+                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;
@@ -297,12 +310,13 @@ class WorkflowExecute {
                         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)) {
+                        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)) {
+                            if (!this.incomingConnectionIsEmpty(this.runExecutionData.resultData.runData, workflow.connectionsByDestinationNode[inputData.node]["main"][0], runIndex)) {
                                 continue;
                             }
                         }
@@ -313,20 +327,22 @@ class WorkflowExecute {
                             continue;
                         }
                         // Check if node got processed already
-                        if (this.runExecutionData.resultData.runData[inputData.node] !== undefined) {
+                        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);
+                        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)) {
+                            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;
@@ -340,7 +356,8 @@ class WorkflowExecute {
                                 break;
                             }
                             // Check if node got processed already
-                            if (this.runExecutionData.resultData.runData[parentNode] !== undefined) {
+                            if (this.runExecutionData.resultData.runData[parentNode] !==
+                                undefined) {
                                 // Node got processed already so we can use the
                                 // output data as input of this node
                                 break;
@@ -364,7 +381,7 @@ class WorkflowExecute {
                             // 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)) {
+                        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;
                         }
@@ -402,10 +419,9 @@ class WorkflowExecute {
         }
         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] = {};
+            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,
@@ -433,17 +449,20 @@ class WorkflowExecute {
     //            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'}`);
+        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) {
+        if (this.runExecutionData.startData?.destinationNode) {
             destinationNode = this.runExecutionData.startData.destinationNode;
         }
-        const workflowIssues = workflow.checkReadyForExecution({ startNode, 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.');
+            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;
@@ -457,38 +476,44 @@ class WorkflowExecute {
             this.runExecutionData.startData = {};
         }
         if (this.runExecutionData.waitTill) {
-            const lastNodeExecuted = this.runExecutionData.resultData.lastNodeExecuted;
-            this.runExecutionData.executionData.nodeExecutionStack[0].node.disabled = true;
+            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 currentExecutionTry = "";
+        let lastExecutionTry = "";
+        return new p_cancelable_1.default((resolve, _reject, onCancel) => {
             let gotCancel = false;
             onCancel.shouldReject = false;
             onCancel(() => {
                 gotCancel = true;
             });
-            const returnPromise = (() => tslib_1.__awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d, _e;
+            const returnPromise = (async () => {
                 try {
-                    yield this.executeHook('workflowExecuteBefore', [workflow]);
+                    await 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 });
+                    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];
+                    executionData =
+                        this.runExecutionData.executionData.nodeExecutionStack[0];
                     this.runExecutionData.resultData = {
                         runData: {
                             [executionData.node.name]: [
                                 {
                                     startTime,
-                                    executionTime: new Date().getTime() - startTime,
+                                    executionTime: Date.now() - startTime,
                                     data: {
-                                        main: executionData.data['main'],
+                                        main: executionData.data["main"],
                                     },
                                 },
                             ],
@@ -515,16 +540,17 @@ class WorkflowExecute {
                         node: executionNode.name,
                         workflowId: workflow.id,
                     });
-                    yield this.executeHook('nodeExecuteBefore', [executionNode.name]);
+                    await 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;
+                    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.');
+                        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) {
@@ -534,21 +560,22 @@ class WorkflowExecute {
                         continue;
                     }
                     // Check if all the data which is needed to run the node is available
-                    if (Object.prototype.hasOwnProperty.call(workflow.connectionsByDestinationNode, executionNode.name)) {
+                    if (Object.hasOwn(workflow.connectionsByDestinationNode, executionNode.name)) {
                         // Check if the node has incoming connections
-                        if (Object.prototype.hasOwnProperty.call(workflow.connectionsByDestinationNode[executionNode.name], 'main')) {
+                        if (Object.hasOwn(workflow.connectionsByDestinationNode[executionNode.name], "main")) {
                             let inputConnections;
                             let connectionIndex;
                             // eslint-disable-next-line prefer-const
-                            inputConnections = workflow.connectionsByDestinationNode[executionNode.name]['main'];
+                            inputConnections =
+                                workflow.connectionsByDestinationNode[executionNode.name]["main"];
                             for (connectionIndex = 0; connectionIndex < inputConnections.length; connectionIndex++) {
-                                if (workflow.getHighestNode(executionNode.name, 'main', connectionIndex).length === 0) {
+                                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')) {
+                                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);
@@ -558,8 +585,8 @@ class WorkflowExecute {
                                 // 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) {
+                                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;
@@ -571,7 +598,7 @@ class WorkflowExecute {
                     // 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();
+                    startTime = Date.now();
                     let maxTries = 1;
                     if (executionData.node.retryOnFail === true) {
                         // TODO: Remove the hardcoded default-values here and also in NodeSettings.vue
@@ -594,7 +621,7 @@ class WorkflowExecute {
                                     // 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) => {
+                                    await new Promise((resolve) => {
                                         setTimeout(() => {
                                             resolve(undefined);
                                         }, waitBetweenTries);
@@ -605,7 +632,7 @@ class WorkflowExecute {
                                 node: executionNode.name,
                                 workflowId: workflow.id,
                             });
-                            nodeSuccessData = yield workflow.runNode(executionData.node, executionData.data, this.runExecutionData, runIndex, this.additionalData, __1.NodeExecuteFunctions, this.mode);
+                            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,
@@ -615,9 +642,11 @@ class WorkflowExecute {
                                 nodeSuccessData = null;
                             }
                             else {
-                                this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
+                                this.runExecutionData.resultData.lastNodeExecuted =
+                                    executionData.node.name;
                             }
-                            if (nodeSuccessData === null || nodeSuccessData[0][0] === undefined) {
+                            if (nodeSuccessData === null ||
+                                nodeSuccessData[0][0] === undefined) {
                                 if (executionData.node.alwaysOutputData === true) {
                                     nodeSuccessData = nodeSuccessData || [];
                                     nodeSuccessData[0] = [
@@ -627,7 +656,8 @@ class WorkflowExecute {
                                     ];
                                 }
                             }
-                            if (nodeSuccessData === null && !this.runExecutionData.waitTill) {
+                            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)
@@ -636,21 +666,27 @@ class WorkflowExecute {
                             break;
                         }
                         catch (error) {
-                            this.runExecutionData.resultData.lastNodeExecuted = executionData.node.name;
-                            executionError = Object.assign(Object.assign({}, error), { message: error.message, stack: error.stack });
+                            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 = ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('too many clients')) ||
-                                ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('Connection terminated')) ||
-                                ((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('connection is closed')) ||
-                                ((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('ECONNRESET')) ||
-                                ((_e = error.message) === null || _e === void 0 ? void 0 : _e.includes('ENOTFOUND')) ||
-                                error.code === 'ECONNRESET' ||
-                                error.code === 'ENOTFOUND';
+                            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}": ${error.message}`, {
+                                workflow_1.LoggerProxy.error(`Critical database connection error in node "${executionNode.name}": ${err.message}`, {
                                     node: executionNode.name,
                                     workflowId: workflow.id,
-                                    error: error.message
+                                    error: err.message,
                                 });
                                 // For critical connection errors, break out of retry loop immediately
                                 // This will cause the workflow to fail on this node
@@ -664,22 +700,24 @@ class WorkflowExecute {
                     }
                     // 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)) {
+                    assertSafeKey(executionNode.name);
+                    if (!Object.hasOwn(this.runExecutionData.resultData.runData, executionNode.name)) {
                         this.runExecutionData.resultData.runData[executionNode.name] = [];
                     }
                     taskData = {
                         startTime,
-                        executionTime: new Date().getTime() - 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.prototype.hasOwnProperty.call(executionData.data, 'main') && executionData.data['main'].length > 0) {
+                            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]];
+                                if (executionData.data["main"][0] !== null) {
+                                    nodeSuccessData = [executionData.data["main"][0]];
                                 }
                             }
                         }
@@ -688,7 +726,7 @@ class WorkflowExecute {
                             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', [
+                            await this.executeHook("nodeExecuteAfter", [
                                 executionNode.name,
                                 taskData,
                                 this.runExecutionData,
@@ -702,11 +740,11 @@ class WorkflowExecute {
                     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"] !== undefined &&
+                                lineResult.json["$error"] !== undefined) {
+                                lineResult.error = lineResult.json["$error"];
                                 lineResult.json = {
-                                    error: lineResult.json['$error'].message,
+                                    error: lineResult.json["$error"].message,
                                 };
                             }
                             else if (lineResult.error !== undefined) {
@@ -720,7 +758,7 @@ class WorkflowExecute {
                     };
                     this.runExecutionData.resultData.runData[executionNode.name].push(taskData);
                     if (this.runExecutionData.waitTill) {
-                        yield this.executeHook('nodeExecuteAfter', [
+                        await this.executeHook("nodeExecuteAfter", [
                             executionNode.name,
                             taskData,
                             this.runExecutionData,
@@ -729,12 +767,12 @@ class WorkflowExecute {
                         this.runExecutionData.executionData.nodeExecutionStack.unshift(executionData);
                         break;
                     }
-                    if (this.runExecutionData.startData &&
-                        this.runExecutionData.startData.destinationNode &&
-                        this.runExecutionData.startData.destinationNode === executionNode.name) {
+                    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.
-                        yield this.executeHook('nodeExecuteAfter', [
+                        await this.executeHook("nodeExecuteAfter", [
                             executionNode.name,
                             taskData,
                             this.runExecutionData,
@@ -744,26 +782,27 @@ class WorkflowExecute {
                     }
                     // 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')) {
+                    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.prototype.hasOwnProperty.call(workflow.connectionsBySourceNode[executionNode.name]['main'], outputIndex)) {
+                            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.prototype.hasOwnProperty.call(workflow.nodes, connectionData.node)) {
+                                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[outputIndex] &&
-                                        (nodeSuccessData[outputIndex].length !== 0 || connectionData.index > 0)) {
+                                    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, parseInt(outputIndex, 10), executionNode.name, nodeSuccessData, runIndex);
+                                        this.addNodeToBeExecuted(workflow, connectionData, Number.parseInt(outputIndex, 10), executionNode.name, nodeSuccessData, runIndex);
                                     }
                                 }
                             }
@@ -773,72 +812,86 @@ class WorkflowExecute {
                     // 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', [
+                    await this.executeHook("nodeExecuteAfter", [
                         executionNode.name,
                         taskData,
                         this.runExecutionData,
                     ]);
                 }
                 return Promise.resolve();
-            }))()
-                .then(() => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            })()
+                .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, 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* () {
+            })
+                .catch(async (error) => {
                 const fullRunData = this.getFullRunData(startedAt);
-                fullRunData.data.resultData.error = Object.assign(Object.assign({}, error), { message: error.message, stack: error.stack });
+                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) {
+                if (workflow.staticData["__dataChanged"] === true) {
                     // Static data of workflow changed
                     newStaticData = workflow.staticData;
                 }
-                yield this.executeHook('workflowExecuteAfter', [fullRunData, newStaticData]).catch(
+                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);
         });
     }
-    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;
-        });
+    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 = {
@@ -851,4 +904,3 @@ class WorkflowExecute {
     }
 }
 exports.WorkflowExecute = WorkflowExecute;
-//# sourceMappingURL=WorkflowExecute.js.map