n8n-workflow 1.98.0 → 1.99.1

package/dist/{workflow.js → esm/workflow.js}

@@ -1,78 +1,73 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Workflow = void 0;
-const constants_1 = require("./constants");
-const errors_1 = require("./errors");
-const application_error_1 = require("./errors/application.error");
-const expression_1 = require("./expression");
-const global_state_1 = require("./global-state");
-const interfaces_1 = require("./interfaces");
-const NodeHelpers = __importStar(require("./node-helpers"));
-const rename_node_utils_1 = require("./node-parameters/rename-node-utils");
-const node_reference_parser_utils_1 = require("./node-reference-parser-utils");
-const ObservableObject = __importStar(require("./observable-object"));
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-for-in-array */
+import { MANUAL_CHAT_TRIGGER_LANGCHAIN_NODE_TYPE, NODES_WITH_RENAMABLE_CONTENT, NODES_WITH_RENAMABLE_FORM_HTML_CONTENT, NODES_WITH_RENAMEABLE_TOPLEVEL_HTML_CONTENT, STARTING_NODE_TYPES, } from './constants';
+import { UserError } from './errors';
+import { ApplicationError } from './errors/application.error';
+import { Expression } from './expression';
+import { getGlobalState } from './global-state';
+import { NodeConnectionTypes } from './interfaces';
+import * as NodeHelpers from './node-helpers';
+import { renameFormFields } from './node-parameters/rename-node-utils';
+import { applyAccessPatterns } from './node-reference-parser-utils';
+import * as ObservableObject from './observable-object';
 function dedupe(arr) {
     return [...new Set(arr)];
 }
-class Workflow {
+export class Workflow {
+    id;
+    name;
+    nodes = {};
+    connectionsBySourceNode;
+    connectionsByDestinationNode;
+    nodeTypes;
+    expression;
+    active;
+    settings;
+    timezone;
+    // To save workflow specific static data like for example
+    // ids of registered webhooks of nodes
+    staticData;
+    testStaticData;
+    pinData;
     constructor(parameters) {
-        this.nodes = {};
-        this.id = parameters.id;
+        this.id = parameters.id; // @tech_debt Ensure this is not optional
         this.name = parameters.name;
         this.nodeTypes = parameters.nodeTypes;
         this.pinData = parameters.pinData;
+        // Save nodes in workflow as object to be able to get the
+        // nodes easily by its name.
+        // Also directly add the default values of the node type.
         let nodeType;
         for (const node of parameters.nodes) {
             this.nodes[node.name] = node;
             nodeType = this.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
             if (nodeType === undefined) {
+                // Go on to next node when its type is not known.
+                // For now do not error because that causes problems with
+                // expression resolution also then when the unknown node
+                // does not get used.
                 continue;
+                // throw new ApplicationError(`Node with unknown node type`, {
+                // 	tags: { nodeType: node.type },
+                // 	extra: { node },
+                // });
             }
+            // Add default values
             const nodeParameters = NodeHelpers.getNodeParameters(nodeType.description.properties, node.parameters, true, false, node, nodeType.description);
             node.parameters = nodeParameters !== null ? nodeParameters : {};
         }
         this.connectionsBySourceNode = parameters.connections;
+        // Save also the connections by the destination nodes
         this.connectionsByDestinationNode = Workflow.getConnectionsByDestination(parameters.connections);
         this.active = parameters.active || false;
         this.staticData = ObservableObject.create(parameters.staticData || {}, undefined, {
             ignoreEmptyOnFirstChild: true,
         });
         this.settings = parameters.settings || {};
-        this.timezone = this.settings.timezone ?? (0, global_state_1.getGlobalState)().defaultTimezone;
-        this.expression = new expression_1.Expression(this);
+        this.timezone = this.settings.timezone ?? getGlobalState().defaultTimezone;
+        this.expression = new Expression(this);
     }
     overrideStaticData(staticData) {
         this.staticData = ObservableObject.create(staticData || {}, undefined, {
@@ -80,6 +75,11 @@ class Workflow {
         });
         this.staticData.__dataChanged = true;
     }
+    /**
+     * The default connections are by source node. This function rewrites them by destination nodes
+     * to easily find parent nodes.
+     *
+     */
     static getConnectionsByDestination(connections) {
         const returnConnection = {};
         let connectionInfo;
@@ -118,6 +118,14 @@ class Workflow {
         }
         return returnConnection;
     }
+    /**
+     * Returns the static data of the workflow.
+     * It gets saved with the workflow and will be the same for
+     * all workflow-executions.
+     *
+     * @param {string} type The type of data to return ("global"|"node")
+     * @param {INode} [node] If type is set to "node" then the node has to be provided
+     */
     getStaticData(type, node) {
         let key;
         if (type === 'global') {
@@ -125,18 +133,20 @@ class Workflow {
         }
         else if (type === 'node') {
             if (node === undefined) {
-                throw new application_error_1.ApplicationError('The request data of context type "node" the node parameter has to be set!');
+                throw new ApplicationError('The request data of context type "node" the node parameter has to be set!');
             }
             key = `node:${node.name}`;
         }
         else {
-            throw new application_error_1.ApplicationError('Unknown context type. Only `global` and `node` are supported.', {
+            throw new ApplicationError('Unknown context type. Only `global` and `node` are supported.', {
                 extra: { contextType: type },
             });
         }
         if (this.testStaticData?.[key])
             return this.testStaticData[key];
         if (this.staticData[key] === undefined) {
+            // Create it as ObservableObject that we can easily check if the data changed
+            // to know if the workflow with its data has to be saved afterwards or not.
             this.staticData[key] = ObservableObject.create({}, this.staticData);
         }
         return this.staticData[key];
@@ -144,14 +154,29 @@ class Workflow {
     setTestStaticData(testStaticData) {
         this.testStaticData = testStaticData;
     }
+    /**
+     * Returns all the trigger nodes in the workflow.
+     *
+     */
     getTriggerNodes() {
         return this.queryNodes((nodeType) => !!nodeType.trigger);
     }
+    /**
+     * Returns all the poll nodes in the workflow
+     *
+     */
     getPollNodes() {
         return this.queryNodes((nodeType) => !!nodeType.poll);
     }
+    /**
+     * Returns all the nodes in the workflow for which the given
+     * checkFunction return true
+     *
+     * @param {(nodeType: INodeType) => boolean} checkFunction
+     */
     queryNodes(checkFunction) {
         const returnNodes = [];
+        // Check if it has any of them
         let node;
         let nodeType;
         for (const nodeName of Object.keys(this.nodes)) {
@@ -166,12 +191,22 @@ class Workflow {
         }
         return returnNodes;
     }
+    /**
+     * Returns the node with the given name if it exists else null
+     *
+     * @param {string} nodeName Name of the node to return
+     */
     getNode(nodeName) {
         if (this.nodes.hasOwnProperty(nodeName)) {
             return this.nodes[nodeName];
         }
         return null;
     }
+    /**
+     * Returns the nodes with the given names if they exist.
+     * If a node cannot be found it will be ignored, meaning the returned array
+     * of nodes can be smaller than the array of names.
+     */
     getNodes(nodeNames) {
         const nodes = [];
         for (const name of nodeNames) {
@@ -184,31 +219,47 @@ class Workflow {
         }
         return nodes;
     }
+    /**
+     * Returns the pinData of the node with the given name if it exists
+     *
+     * @param {string} nodeName Name of the node to return the pinData of
+     */
     getPinDataOfNode(nodeName) {
         return this.pinData ? this.pinData[nodeName] : undefined;
     }
     renameNodeInParameterValue(parameterValue, currentName, newName, { hasRenamableContent } = { hasRenamableContent: false }) {
         if (typeof parameterValue !== 'object') {
+            // Reached the actual value
             if (typeof parameterValue === 'string' &&
                 (parameterValue.charAt(0) === '=' || hasRenamableContent)) {
-                parameterValue = (0, node_reference_parser_utils_1.applyAccessPatterns)(parameterValue, currentName, newName);
+                parameterValue = applyAccessPatterns(parameterValue, currentName, newName);
             }
             return parameterValue;
         }
         if (Array.isArray(parameterValue)) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const returnArray = [];
             for (const currentValue of parameterValue) {
                 returnArray.push(this.renameNodeInParameterValue(currentValue, currentName, newName));
             }
             return returnArray;
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const returnData = {};
         for (const parameterName of Object.keys(parameterValue || {})) {
             returnData[parameterName] = this.renameNodeInParameterValue(parameterValue[parameterName], currentName, newName, { hasRenamableContent });
         }
         return returnData;
     }
+    /**
+     * Rename a node in the workflow
+     *
+     * @param {string} currentName The current name of the node
+     * @param {string} newName The new name
+     */
     renameNode(currentName, newName) {
+        // These keys are excluded to prevent accidental modification of inherited properties and
+        // to avoid any issues related to JavaScript's built-in methods that can cause unexpected behavior
         const restrictedKeys = [
             'hasOwnProperty',
             'isPrototypeOf',
@@ -225,33 +276,38 @@ class Workflow {
             '__lookupSetter__',
         ];
         if (restrictedKeys.map((k) => k.toLowerCase()).includes(newName.toLowerCase())) {
-            throw new errors_1.UserError(`Node name "${newName}" is a restricted name.`, {
+            throw new UserError(`Node name "${newName}" is a restricted name.`, {
                 description: `Node names cannot be any of the following: ${restrictedKeys.join(', ')}`,
             });
         }
+        // Rename the node itself
         if (this.nodes[currentName] !== undefined) {
             this.nodes[newName] = this.nodes[currentName];
             this.nodes[newName].name = newName;
             delete this.nodes[currentName];
         }
+        // Update the expressions which reference the node
+        // with its old name
         for (const node of Object.values(this.nodes)) {
             node.parameters = this.renameNodeInParameterValue(node.parameters, currentName, newName);
-            if (constants_1.NODES_WITH_RENAMABLE_CONTENT.has(node.type)) {
+            if (NODES_WITH_RENAMABLE_CONTENT.has(node.type)) {
                 node.parameters.jsCode = this.renameNodeInParameterValue(node.parameters.jsCode, currentName, newName, { hasRenamableContent: true });
             }
-            if (constants_1.NODES_WITH_RENAMEABLE_TOPLEVEL_HTML_CONTENT.has(node.type)) {
+            if (NODES_WITH_RENAMEABLE_TOPLEVEL_HTML_CONTENT.has(node.type)) {
                 node.parameters.html = this.renameNodeInParameterValue(node.parameters.html, currentName, newName, { hasRenamableContent: true });
             }
-            if (constants_1.NODES_WITH_RENAMABLE_FORM_HTML_CONTENT.has(node.type)) {
-                (0, rename_node_utils_1.renameFormFields)(node, (p) => this.renameNodeInParameterValue(p, currentName, newName, {
+            if (NODES_WITH_RENAMABLE_FORM_HTML_CONTENT.has(node.type)) {
+                renameFormFields(node, (p) => this.renameNodeInParameterValue(p, currentName, newName, {
                     hasRenamableContent: true,
                 }));
             }
         }
+        // Change all source connections
         if (this.connectionsBySourceNode.hasOwnProperty(currentName)) {
             this.connectionsBySourceNode[newName] = this.connectionsBySourceNode[currentName];
             delete this.connectionsBySourceNode[currentName];
         }
+        // Change all destination connections
         let sourceNode;
         let type;
         let sourceIndex;
@@ -270,21 +326,31 @@ class Workflow {
                 }
             }
         }
+        // Use the updated connections to create updated connections by destination nodes
         this.connectionsByDestinationNode = Workflow.getConnectionsByDestination(this.connectionsBySourceNode);
     }
+    /**
+     * Finds the highest parent nodes of the node with the given name
+     *
+     * @param {NodeConnectionType} [type='main']
+     */
     getHighestNode(nodeName, nodeConnectionIndex, checkedNodes) {
         const currentHighest = [];
         if (this.nodes[nodeName].disabled === false) {
+            // If the current node is not disabled itself is the highest
             currentHighest.push(nodeName);
         }
         if (!this.connectionsByDestinationNode.hasOwnProperty(nodeName)) {
+            // Node does not have incoming connections
             return currentHighest;
         }
-        if (!this.connectionsByDestinationNode[nodeName].hasOwnProperty(interfaces_1.NodeConnectionTypes.Main)) {
+        if (!this.connectionsByDestinationNode[nodeName].hasOwnProperty(NodeConnectionTypes.Main)) {
+            // Node does not have incoming connections of given type
             return currentHighest;
         }
         checkedNodes = checkedNodes || [];
         if (checkedNodes.includes(nodeName)) {
+            // Node got checked already before
             return currentHighest;
         }
         checkedNodes.push(nodeName);
@@ -292,25 +358,32 @@ class Workflow {
         let addNodes;
         let connectionsByIndex;
         for (let connectionIndex = 0; connectionIndex <
-            this.connectionsByDestinationNode[nodeName][interfaces_1.NodeConnectionTypes.Main].length; connectionIndex++) {
+            this.connectionsByDestinationNode[nodeName][NodeConnectionTypes.Main].length; connectionIndex++) {
             if (nodeConnectionIndex !== undefined && nodeConnectionIndex !== connectionIndex) {
+                // If a connection-index is given ignore all other ones
                 continue;
             }
             connectionsByIndex =
-                this.connectionsByDestinationNode[nodeName][interfaces_1.NodeConnectionTypes.Main][connectionIndex];
+                this.connectionsByDestinationNode[nodeName][NodeConnectionTypes.Main][connectionIndex];
+            // eslint-disable-next-line @typescript-eslint/no-loop-func
             connectionsByIndex?.forEach((connection) => {
                 if (checkedNodes.includes(connection.node)) {
+                    // Node got checked already before
                     return;
                 }
+                // Ignore connections for nodes that don't exist in this workflow
                 if (!(connection.node in this.nodes))
                     return;
                 addNodes = this.getHighestNode(connection.node, undefined, checkedNodes);
                 if (addNodes.length === 0) {
+                    // The checked node does not have any further parents so add it
+                    // if it is not disabled
                     if (this.nodes[connection.node].disabled !== true) {
                         addNodes = [connection.node];
                     }
                 }
                 addNodes.forEach((name) => {
+                    // Only add if node is not on the list already anyway
                     if (returnNodes.indexOf(name) === -1) {
                         returnNodes.push(name);
                     }
@@ -319,19 +392,40 @@ class Workflow {
         }
         return returnNodes;
     }
-    getChildNodes(nodeName, type = interfaces_1.NodeConnectionTypes.Main, depth = -1) {
+    /**
+     * Returns all the after the given one
+     *
+     * @param {string} [type='main']
+     * @param {*} [depth=-1]
+     */
+    getChildNodes(nodeName, type = NodeConnectionTypes.Main, depth = -1) {
         return this.getConnectedNodes(this.connectionsBySourceNode, nodeName, type, depth);
     }
-    getParentNodes(nodeName, type = interfaces_1.NodeConnectionTypes.Main, depth = -1) {
+    /**
+     * Returns all the nodes before the given one
+     *
+     * @param {NodeConnectionType} [type='main']
+     * @param {*} [depth=-1]
+     */
+    getParentNodes(nodeName, type = NodeConnectionTypes.Main, depth = -1) {
         return this.getConnectedNodes(this.connectionsByDestinationNode, nodeName, type, depth);
     }
-    getConnectedNodes(connections, nodeName, connectionType = interfaces_1.NodeConnectionTypes.Main, depth = -1, checkedNodesIncoming) {
+    /**
+     * Gets all the nodes which are connected nodes starting from
+     * the given one
+     *
+     * @param {NodeConnectionType} [type='main']
+     * @param {*} [depth=-1]
+     */
+    getConnectedNodes(connections, nodeName, connectionType = NodeConnectionTypes.Main, depth = -1, checkedNodesIncoming) {
         depth = depth === -1 ? -1 : depth;
         const newDepth = depth === -1 ? depth : depth - 1;
         if (depth === 0) {
+            // Reached max depth
             return [];
         }
         if (!connections.hasOwnProperty(nodeName)) {
+            // Node does not have incoming connections
             return [];
         }
         let types;
@@ -351,24 +445,32 @@ class Workflow {
         const returnNodes = [];
         types.forEach((type) => {
             if (!connections[nodeName].hasOwnProperty(type)) {
+                // Node does not have incoming connections of given type
                 return;
             }
             const checkedNodes = checkedNodesIncoming ? [...checkedNodesIncoming] : [];
             if (checkedNodes.includes(nodeName)) {
+                // Node got checked already before
                 return;
             }
             checkedNodes.push(nodeName);
             connections[nodeName][type].forEach((connectionsByIndex) => {
                 connectionsByIndex?.forEach((connection) => {
                     if (checkedNodes.includes(connection.node)) {
+                        // Node got checked already before
                         return;
                     }
                     returnNodes.unshift(connection.node);
                     addNodes = this.getConnectedNodes(connections, connection.node, connectionType, newDepth, checkedNodes);
                     for (i = addNodes.length; i--; i > 0) {
+                        // Because nodes can have multiple parents it is possible that
+                        // parts of the tree is parent of both and to not add nodes
+                        // twice check first if they already got added before.
                         parentNodeName = addNodes[i];
                         nodeIndex = returnNodes.indexOf(parentNodeName);
                         if (nodeIndex !== -1) {
+                            // Node got found before so remove it from current location
+                            // that node-order stays correct
                             returnNodes.splice(nodeIndex, 1);
                         }
                         returnNodes.unshift(parentNodeName);
@@ -378,12 +480,24 @@ class Workflow {
         });
         return returnNodes;
     }
+    /**
+     * Returns all the nodes before the given one
+     *
+     * @param {*} [maxDepth=-1]
+     */
     getParentNodesByDepth(nodeName, maxDepth = -1) {
         return this.searchNodesBFS(this.connectionsByDestinationNode, nodeName, maxDepth);
     }
+    /**
+     * Gets all the nodes which are connected nodes starting from
+     * the given one
+     * Uses BFS traversal
+     *
+     * @param {*} [maxDepth=-1]
+     */
     searchNodesBFS(connections, sourceNode, maxDepth = -1) {
         const returnConns = [];
-        const type = interfaces_1.NodeConnectionTypes.Main;
+        const type = NodeConnectionTypes.Main;
         let queue = [];
         queue.push({
             name: sourceNode,
@@ -399,6 +513,7 @@ class Workflow {
             depth++;
             const toAdd = [...queue];
             queue = [];
+            // eslint-disable-next-line @typescript-eslint/no-loop-func
             toAdd.forEach((curr) => {
                 if (visited[curr.name]) {
                     visited[curr.name].indicies = dedupe(visited[curr.name].indicies.concat(curr.indicies));
@@ -429,7 +544,8 @@ class Workflow {
         if (node) {
             const nodeType = this.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
             const outputs = NodeHelpers.getNodeOutputs(this, node, nodeType.description);
-            if (!!outputs.find((output) => (output?.type ?? output) !== interfaces_1.NodeConnectionTypes.Main)) {
+            if (!!outputs.find((output) => (output?.type ?? output) !== NodeConnectionTypes.Main)) {
+                // Get the first node which is connected to a non-main output
                 const nonMainNodesConnected = outputs?.reduce((acc, outputName) => {
                     const parentNodes = this.getChildNodes(node.name, outputName?.type ?? outputName);
                     if (parentNodes.length > 0) {
@@ -440,15 +556,28 @@ class Workflow {
                 if (nonMainNodesConnected.length) {
                     const returnNode = this.getNode(nonMainNodesConnected[0]);
                     if (returnNode === null) {
-                        throw new application_error_1.ApplicationError(`Node "${nonMainNodesConnected[0]}" not found`);
+                        // This should theoretically never happen as the node is connected
+                        // but who knows and it makes TS happy
+                        throw new ApplicationError(`Node "${nonMainNodesConnected[0]}" not found`);
                     }
+                    // The chain of non-main nodes is potentially not finished yet so
+                    // keep on going
                     return this.getParentMainInputNode(returnNode);
                 }
             }
         }
         return node;
     }
-    getNodeConnectionIndexes(nodeName, parentNodeName, type = interfaces_1.NodeConnectionTypes.Main, depth = -1, checkedNodes) {
+    /**
+     * Returns via which output of the parent-node and index the current node
+     * they are connected
+     *
+     * @param {string} nodeName The node to check how it is connected with parent node
+     * @param {string} parentNodeName The parent node to get the output index of
+     * @param {string} [type='main']
+     * @param {*} [depth=-1]
+     */
+    getNodeConnectionIndexes(nodeName, parentNodeName, type = NodeConnectionTypes.Main, depth = -1, checkedNodes) {
         const node = this.getNode(parentNodeName);
         if (node === null) {
             return undefined;
@@ -456,16 +585,20 @@ class Workflow {
         depth = depth === -1 ? -1 : depth;
         const newDepth = depth === -1 ? depth : depth - 1;
         if (depth === 0) {
+            // Reached max depth
             return undefined;
         }
         if (!this.connectionsByDestinationNode.hasOwnProperty(nodeName)) {
+            // Node does not have incoming connections
             return undefined;
         }
         if (!this.connectionsByDestinationNode[nodeName].hasOwnProperty(type)) {
+            // Node does not have incoming connections of given type
             return undefined;
         }
         checkedNodes = checkedNodes || [];
         if (checkedNodes.includes(nodeName)) {
+            // Node got checked already before
             return undefined;
         }
         checkedNodes.push(nodeName);
@@ -483,6 +616,7 @@ class Workflow {
                     };
                 }
                 if (checkedNodes.includes(connection.node)) {
+                    // Node got checked already before so continue with the next one
                     continue;
                 }
                 outputIndex = this.getNodeConnectionIndexes(connection.node, parentNodeName, type, newDepth, checkedNodes);
@@ -493,7 +627,13 @@ class Workflow {
         }
         return undefined;
     }
+    /**
+     * Returns from which of the given nodes the workflow should get started from
+     *
+     * @param {string[]} nodeNames The potential start nodes
+     */
     __getStartNode(nodeNames) {
+        // Check if there are any trigger or poll nodes and then return the first one
         let node;
         let nodeType;
         for (const nodeName of nodeNames) {
@@ -502,7 +642,8 @@ class Workflow {
                 return node;
             }
             nodeType = this.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
-            if (nodeType.description.name === constants_1.MANUAL_CHAT_TRIGGER_LANGCHAIN_NODE_TYPE) {
+            // TODO: Identify later differently
+            if (nodeType.description.name === MANUAL_CHAT_TRIGGER_LANGCHAIN_NODE_TYPE) {
                 continue;
             }
             if (nodeType && (nodeType.trigger !== undefined || nodeType.poll !== undefined)) {
@@ -513,11 +654,11 @@ class Workflow {
             }
         }
         const sortedNodeNames = Object.values(this.nodes)
-            .sort((a, b) => constants_1.STARTING_NODE_TYPES.indexOf(a.type) - constants_1.STARTING_NODE_TYPES.indexOf(b.type))
+            .sort((a, b) => STARTING_NODE_TYPES.indexOf(a.type) - STARTING_NODE_TYPES.indexOf(b.type))
             .map((n) => n.name);
         for (const nodeName of sortedNodeNames) {
             node = this.nodes[nodeName];
-            if (constants_1.STARTING_NODE_TYPES.includes(node.type)) {
+            if (STARTING_NODE_TYPES.includes(node.type)) {
                 if (node.disabled === true) {
                     continue;
                 }
@@ -526,16 +667,26 @@ class Workflow {
         }
         return undefined;
     }
+    /**
+     * Returns the start node to start the workflow from
+     *
+     */
     getStartNode(destinationNode) {
         if (destinationNode) {
+            // Find the highest parent nodes of the given one
             const nodeNames = this.getHighestNode(destinationNode);
             if (nodeNames.length === 0) {
+                // If no parent nodes have been found then only the destination-node
+                // is in the tree so add that one
                 nodeNames.push(destinationNode);
             }
+            // Check which node to return as start node
             const node = this.__getStartNode(nodeNames);
             if (node !== undefined) {
                 return node;
             }
+            // If none of the above did find anything simply return the
+            // first parent node in the list
             return this.nodes[nodeNames[0]];
         }
         return this.__getStartNode(Object.keys(this.nodes));
@@ -564,5 +715,4 @@ class Workflow {
         return result;
     }
 }
-exports.Workflow = Workflow;
 //# sourceMappingURL=workflow.js.map