n8n-workflow 1.98.0 → 1.99.0

package/dist/{node-helpers.js → esm/node-helpers.js}

@@ -1,44 +1,18 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getUpdatedToolDescription = exports.cronNodeOptions = void 0;
-exports.isSubNodeType = isSubNodeType;
-exports.displayParameter = displayParameter;
-exports.displayParameterPath = displayParameterPath;
-exports.getContext = getContext;
-exports.getNodeParameters = getNodeParameters;
-exports.getNodeWebhookPath = getNodeWebhookPath;
-exports.getNodeWebhookUrl = getNodeWebhookUrl;
-exports.getConnectionTypes = getConnectionTypes;
-exports.getNodeInputs = getNodeInputs;
-exports.getNodeOutputs = getNodeOutputs;
-exports.getNodeParametersIssues = getNodeParametersIssues;
-exports.getParameterValueByPath = getParameterValueByPath;
-exports.getParameterIssues = getParameterIssues;
-exports.mergeIssues = mergeIssues;
-exports.mergeNodeProperties = mergeNodeProperties;
-exports.getVersionedNodeType = getVersionedNodeType;
-exports.isTriggerNode = isTriggerNode;
-exports.isExecutable = isExecutable;
-exports.isNodeWithWorkflowSelector = isNodeWithWorkflowSelector;
-exports.makeDescription = makeDescription;
-exports.isTool = isTool;
-exports.makeNodeName = makeNodeName;
-exports.isDefaultNodeName = isDefaultNodeName;
-exports.getToolDescriptionForNode = getToolDescriptionForNode;
-exports.getSubworkflowId = getSubworkflowId;
-const get_1 = __importDefault(require("lodash/get"));
-const isEqual_1 = __importDefault(require("lodash/isEqual"));
-const constants_1 = require("./constants");
-const application_error_1 = require("./errors/application.error");
-const interfaces_1 = require("./interfaces");
-const filter_parameter_1 = require("./node-parameters/filter-parameter");
-const type_guards_1 = require("./type-guards");
-const type_validation_1 = require("./type-validation");
-const utils_1 = require("./utils");
-exports.cronNodeOptions = [
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
+/* eslint-disable prefer-spread */
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+import { EXECUTE_WORKFLOW_NODE_TYPE, WORKFLOW_TOOL_LANGCHAIN_NODE_TYPE } from './constants';
+import { ApplicationError } from './errors/application.error';
+import { NodeConnectionTypes } from './interfaces';
+import { validateFilterParameter } from './node-parameters/filter-parameter';
+import { isFilterValue, isINodePropertyOptionsList, isResourceLocatorValue, isResourceMapperValue, isValidResourceLocatorParameterValue, } from './type-guards';
+import { validateFieldType } from './type-validation';
+import { deepCopy } from './utils';
+export const cronNodeOptions = [
     {
         name: 'item',
         displayName: 'Item',
@@ -223,19 +197,24 @@ exports.cronNodeOptions = [
         ],
     },
 ];
-function isSubNodeType(typeDescription) {
+/**
+ * Determines if the provided node type has any output types other than the main connection type.
+ * @param typeDescription The node's type description to check.
+ */
+export function isSubNodeType(typeDescription) {
     if (!typeDescription?.outputs || typeof typeDescription.outputs === 'string') {
         return false;
     }
     const outputTypes = getConnectionTypes(typeDescription.outputs);
     return outputTypes
-        ? outputTypes.filter((output) => output !== interfaces_1.NodeConnectionTypes.Main).length > 0
+        ? outputTypes.filter((output) => output !== NodeConnectionTypes.Main).length > 0
         : false;
 }
 const getPropertyValues = (nodeValues, propertyName, node, nodeTypeDescription, nodeValuesRoot) => {
     let value;
     if (propertyName.charAt(0) === '/') {
-        value = (0, get_1.default)(nodeValuesRoot, propertyName.slice(1));
+        // Get the value from the root of the node
+        value = get(nodeValuesRoot, propertyName.slice(1));
     }
     else if (propertyName === '@version') {
         value = node?.typeVersion || 0;
@@ -244,7 +223,8 @@ const getPropertyValues = (nodeValues, propertyName, node, nodeTypeDescription,
         value = nodeTypeDescription?.name.endsWith('Tool') ?? false;
     }
     else {
-        value = (0, get_1.default)(nodeValues, propertyName);
+        // Get the value from current level
+        value = get(nodeValues, propertyName);
     }
     if (value && typeof value === 'object' && '__rl' in value && value.__rl) {
         value = value.value;
@@ -265,10 +245,10 @@ const checkConditions = (conditions, actualValues) => {
             const [key, targetValue] = Object.entries(condition._cnd)[0];
             return actualValues.every((propertyValue) => {
                 if (key === 'eq') {
-                    return (0, isEqual_1.default)(propertyValue, targetValue);
+                    return isEqual(propertyValue, targetValue);
                 }
                 if (key === 'not') {
-                    return !(0, isEqual_1.default)(propertyValue, targetValue);
+                    return !isEqual(propertyValue, targetValue);
                 }
                 if (key === 'gte') {
                     return propertyValue >= targetValue;
@@ -307,13 +287,23 @@ const checkConditions = (conditions, actualValues) => {
         return actualValues.includes(condition);
     });
 };
-function displayParameter(nodeValues, parameter, node, nodeTypeDescription, nodeValuesRoot, displayKey = 'displayOptions') {
+/**
+ * Returns if the parameter should be displayed or not
+ *
+ * @param {INodeParameters} nodeValues The data on the node which decides if the parameter
+ *                                    should be displayed
+ * @param {(INodeProperties | INodeCredentialDescription)} parameter The parameter to check if it should be displayed
+ * @param {INodeParameters} [nodeValuesRoot] The root node-parameter-data
+ */
+export function displayParameter(nodeValues, parameter, node, // Allow null as it does also get used by credentials and they do not have versioning yet
+nodeTypeDescription, nodeValuesRoot, displayKey = 'displayOptions') {
     if (!parameter[displayKey]) {
         return true;
     }
     const { show, hide } = parameter[displayKey];
     nodeValuesRoot = nodeValuesRoot || nodeValues;
     if (show) {
+        // All the defined rules have to match to display parameter
         for (const propertyName of Object.keys(show)) {
             const values = getPropertyValues(nodeValues, propertyName, node, nodeTypeDescription, nodeValuesRoot);
             if (values.some((v) => typeof v === 'string' && v.charAt(0) === '=')) {
@@ -325,6 +315,7 @@ function displayParameter(nodeValues, parameter, node, nodeTypeDescription, node
         }
     }
     if (hide) {
+        // Any of the defined hide rules have to match to hide the parameter
         for (const propertyName of Object.keys(hide)) {
             const values = getPropertyValues(nodeValues, propertyName, node, nodeTypeDescription, nodeValuesRoot);
             if (values.length !== 0 && checkConditions(hide[propertyName], values)) {
@@ -334,20 +325,38 @@ function displayParameter(nodeValues, parameter, node, nodeTypeDescription, node
     }
     return true;
 }
-function displayParameterPath(nodeValues, parameter, path, node, nodeTypeDescription, displayKey = 'displayOptions') {
+/**
+ * Returns if the given parameter should be displayed or not considering the path
+ * to the properties
+ *
+ * @param {INodeParameters} nodeValues The data on the node which decides if the parameter
+ *                                    should be displayed
+ * @param {(INodeProperties | INodeCredentialDescription)} parameter The parameter to check if it should be displayed
+ * @param {string} path The path to the property
+ */
+export function displayParameterPath(nodeValues, parameter, path, node, nodeTypeDescription, displayKey = 'displayOptions') {
     let resolvedNodeValues = nodeValues;
     if (path !== '') {
-        resolvedNodeValues = (0, get_1.default)(nodeValues, path);
+        resolvedNodeValues = get(nodeValues, path);
     }
+    // Get the root parameter data
     let nodeValuesRoot = nodeValues;
     if (path && path.split('.').indexOf('parameters') === 0) {
-        nodeValuesRoot = (0, get_1.default)(nodeValues, 'parameters');
+        nodeValuesRoot = get(nodeValues, 'parameters');
     }
     return displayParameter(resolvedNodeValues, parameter, node, nodeTypeDescription, nodeValuesRoot, displayKey);
 }
-function getContext(runExecutionData, type, node) {
+/**
+ * Returns the context data
+ *
+ * @param {IRunExecutionData} runExecutionData The run execution data
+ * @param {string} type The data type. "node"/"flow"
+ * @param {INode} [node] If type "node" is set the node to return the context of has to be supplied
+ */
+export function getContext(runExecutionData, type, node) {
     if (runExecutionData.executionData === undefined) {
-        throw new application_error_1.ApplicationError('`executionData` is not initialized');
+        // TODO: Should not happen leave it for test now
+        throw new ApplicationError('`executionData` is not initialized');
     }
     let key;
     if (type === 'flow') {
@@ -355,12 +364,13 @@ function getContext(runExecutionData, type, node) {
     }
     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!');
+            // @TODO: What does this mean?
+            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 `flow` and `node` are supported.', {
+        throw new ApplicationError('Unknown context type. Only `flow` and `node` are supported.', {
             extra: { contextType: type },
         });
     }
@@ -369,6 +379,9 @@ function getContext(runExecutionData, type, node) {
     }
     return runExecutionData.executionData.contextData[key];
 }
+/**
+ * Returns which parameters are dependent on which
+ */
 function getParameterDependencies(nodePropertiesArray) {
     const dependencies = {};
     for (const nodeProperties of nodePropertiesArray) {
@@ -377,12 +390,14 @@ function getParameterDependencies(nodePropertiesArray) {
             dependencies[name] = [];
         }
         if (!displayOptions) {
+            // Does not have any dependencies
             continue;
         }
         for (const displayRule of Object.values(displayOptions)) {
             for (const parameterName of Object.keys(displayRule)) {
                 if (!dependencies[name].includes(parameterName)) {
                     if (parameterName.charAt(0) === '@') {
+                        // Is a special parameter so can be skipped
                         continue;
                     }
                     dependencies[name].push(parameterName);
@@ -392,6 +407,10 @@ function getParameterDependencies(nodePropertiesArray) {
     }
     return dependencies;
 }
+/**
+ * Returns in which order the parameters should be resolved
+ * to have the parameters available they depend on
+ */
 function getParameterResolveOrder(nodePropertiesArray, parameterDependencies) {
     const executionOrder = [];
     const indexToResolve = Array.from({ length: nodePropertiesArray.length }, (_, k) => k);
@@ -406,37 +425,56 @@ function getParameterResolveOrder(nodePropertiesArray, parameterDependencies) {
         index = indexToResolve.shift();
         property = nodePropertiesArray[index];
         if (parameterDependencies[property.name].length === 0) {
+            // Does not have any dependencies so simply add
             executionOrder.push(index);
             resolvedParameters.push(property.name);
             continue;
         }
+        // Parameter has dependencies
         for (const dependency of parameterDependencies[property.name]) {
             if (!resolvedParameters.includes(dependency)) {
                 if (dependency.charAt(0) === '/') {
+                    // Assume that root level dependencies are resolved
                     continue;
                 }
+                // Dependencies for that parameter are still missing so
+                // try to add again later
                 indexToResolve.push(index);
                 continue;
             }
         }
+        // All dependencies got found so add
         executionOrder.push(index);
         resolvedParameters.push(property.name);
         if (indexToResolve.length < lastIndexLength) {
             lastIndexReduction = iterations;
         }
         if (iterations > lastIndexReduction + nodePropertiesArray.length) {
-            throw new application_error_1.ApplicationError('Could not resolve parameter dependencies. Max iterations reached! Hint: If `displayOptions` are specified in any child parameter of a parent `collection` or `fixedCollection`, remove the `displayOptions` from the child parameter.');
+            throw new ApplicationError('Could not resolve parameter dependencies. Max iterations reached! Hint: If `displayOptions` are specified in any child parameter of a parent `collection` or `fixedCollection`, remove the `displayOptions` from the child parameter.');
         }
         lastIndexLength = indexToResolve.length;
     }
     return executionOrder;
 }
-function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, returnNoneDisplayed, node, nodeTypeDescription, options) {
+/**
+ * Returns the node parameter values. Depending on the settings it either just returns the none
+ * default values or it applies all the default values.
+ *
+ * @param {INodeProperties[]} nodePropertiesArray The properties which exist and their settings
+ * @param {INodeParameters} nodeValues The node parameter data
+ * @param {boolean} returnDefaults If default values get added or only none default values returned
+ * @param {boolean} returnNoneDisplayed If also values which should not be displayed should be returned
+ * @param {GetNodeParametersOptions} options Optional properties
+ */
+// eslint-disable-next-line complexity
+export function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, returnNoneDisplayed, node, nodeTypeDescription, options) {
     let { nodeValuesRoot, parameterDependencies } = options ?? {};
     const { onlySimpleTypes = false, dataIsResolved = false, parentType } = options ?? {};
     if (parameterDependencies === undefined) {
         parameterDependencies = getParameterDependencies(nodePropertiesArray);
     }
+    // Get the parameter names which get used multiple times as for this
+    // ones we have to always check which ones get displayed and which ones not
     const duplicateParameterNames = [];
     const parameterNames = [];
     for (const nodeProperties of nodePropertiesArray) {
@@ -462,12 +500,14 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
         });
     }
     nodeValuesRoot = nodeValuesRoot || nodeValuesDisplayCheck;
+    // Go through the parameters in order of their dependencies
     const parameterIterationOrderIndex = getParameterResolveOrder(nodePropertiesArray, parameterDependencies);
     for (const parameterIndex of parameterIterationOrderIndex) {
         const nodeProperties = nodePropertiesArray[parameterIndex];
         if (!nodeValues ||
             (nodeValues[nodeProperties.name] === undefined &&
                 (!returnDefaults || parentType === 'collection'))) {
+            // The value is not defined so go to the next
             continue;
         }
         if (!returnNoneDisplayed &&
@@ -477,13 +517,17 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
             }
         }
         if (!['collection', 'fixedCollection'].includes(nodeProperties.type)) {
+            // Is a simple property so can be set as it is
             if (duplicateParameterNames.includes(nodeProperties.name)) {
                 if (!displayParameter(nodeValuesDisplayCheck, nodeProperties, node, nodeTypeDescription, nodeValuesRoot)) {
                     continue;
                 }
             }
             if (returnDefaults) {
+                // Set also when it has the default value
                 if (['boolean', 'number', 'options'].includes(nodeProperties.type)) {
+                    // Boolean, numbers and options are special as false and 0 are valid values
+                    // and should not be replaced with default value
                     nodeParameters[nodeProperties.name] =
                         nodeValues[nodeProperties.name] !== undefined
                             ? nodeValues[nodeProperties.name]
@@ -505,34 +549,44 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
             else if ((nodeValues[nodeProperties.name] !== nodeProperties.default &&
                 typeof nodeValues[nodeProperties.name] !== 'object') ||
                 (typeof nodeValues[nodeProperties.name] === 'object' &&
-                    !(0, isEqual_1.default)(nodeValues[nodeProperties.name], nodeProperties.default)) ||
+                    !isEqual(nodeValues[nodeProperties.name], nodeProperties.default)) ||
                 (nodeValues[nodeProperties.name] !== undefined && parentType === 'collection')) {
+                // Set only if it is different to the default value
                 nodeParameters[nodeProperties.name] = nodeValues[nodeProperties.name];
                 nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
                 continue;
             }
         }
         if (onlySimpleTypes) {
+            // It is only supposed to resolve the simple types. So continue.
             continue;
         }
+        // Is a complex property so check lower levels
         let tempValue;
         if (nodeProperties.type === 'collection') {
+            // Is collection
             if (nodeProperties.typeOptions !== undefined &&
                 nodeProperties.typeOptions.multipleValues === true) {
+                // Multiple can be set so will be an array
+                // Return directly the values like they are
                 if (nodeValues[nodeProperties.name] !== undefined) {
                     nodeParameters[nodeProperties.name] = nodeValues[nodeProperties.name];
                 }
                 else if (returnDefaults) {
+                    // Does not have values defined but defaults should be returned
                     if (Array.isArray(nodeProperties.default)) {
-                        nodeParameters[nodeProperties.name] = (0, utils_1.deepCopy)(nodeProperties.default);
+                        nodeParameters[nodeProperties.name] = deepCopy(nodeProperties.default);
                     }
                     else {
+                        // As it is probably wrong for many nodes, do we keep on returning an empty array if
+                        // anything else than an array is set as default
                         nodeParameters[nodeProperties.name] = [];
                     }
                 }
                 nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
             }
             else if (nodeValues[nodeProperties.name] !== undefined) {
+                // Has values defined so get them
                 const tempNodeParameters = getNodeParameters(nodeProperties.options, nodeValues[nodeProperties.name], returnDefaults, returnNoneDisplayed, node, nodeTypeDescription, {
                     onlySimpleTypes: false,
                     dataIsResolved: false,
@@ -545,11 +599,13 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
                 }
             }
             else if (returnDefaults) {
-                nodeParameters[nodeProperties.name] = (0, utils_1.deepCopy)(nodeProperties.default);
+                // Does not have values defined but defaults should be returned
+                nodeParameters[nodeProperties.name] = deepCopy(nodeProperties.default);
                 nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
             }
         }
         else if (nodeProperties.type === 'fixedCollection') {
+            // Is fixedCollection
             const collectionValues = {};
             let tempNodeParameters;
             let tempNodePropertiesArray;
@@ -557,23 +613,31 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
             let propertyValues = nodeValues[nodeProperties.name];
             if (returnDefaults) {
                 if (propertyValues === undefined) {
-                    propertyValues = (0, utils_1.deepCopy)(nodeProperties.default);
+                    propertyValues = deepCopy(nodeProperties.default);
                 }
             }
             if (!returnDefaults &&
                 nodeProperties.typeOptions?.multipleValues === false &&
                 propertyValues &&
                 Object.keys(propertyValues).length === 0) {
+                // For fixedCollections, which only allow one value, it is important to still return
+                // the empty object which indicates that a value got added, even if it does not have
+                // anything set. If that is not done, the value would get lost.
                 return nodeValues;
             }
+            // Iterate over all collections
             for (const itemName of Object.keys(propertyValues || {})) {
                 if (nodeProperties.typeOptions !== undefined &&
                     nodeProperties.typeOptions.multipleValues === true) {
+                    // Multiple can be set so will be an array
                     const tempArrayValue = [];
+                    // Iterate over all items as it contains multiple ones
                     for (const nodeValue of propertyValues[itemName]) {
-                        nodePropertyOptions = nodeProperties.options.find((nodePropertyOptions) => nodePropertyOptions.name === itemName);
+                        nodePropertyOptions = nodeProperties.options.find(
+                        // eslint-disable-next-line @typescript-eslint/no-shadow
+                        (nodePropertyOptions) => nodePropertyOptions.name === itemName);
                         if (nodePropertyOptions === undefined) {
-                            throw new application_error_1.ApplicationError('Could not find property option', {
+                            throw new ApplicationError('Could not find property option', {
                                 extra: { propertyOption: itemName, property: nodeProperties.name },
                             });
                         }
@@ -591,7 +655,10 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
                     collectionValues[itemName] = tempArrayValue;
                 }
                 else {
+                    // Only one can be set so is an object of objects
                     tempNodeParameters = {};
+                    // Get the options of the current item
+                    // eslint-disable-next-line @typescript-eslint/no-shadow
                     const nodePropertyOptions = nodeProperties.options.find((data) => data.name === itemName);
                     if (nodePropertyOptions !== undefined) {
                         tempNodePropertiesArray = nodePropertyOptions.values;
@@ -617,6 +684,9 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
                 propertyValues &&
                 propertyValues?.constructor.name === 'Object' &&
                 Object.keys(propertyValues).length !== 0) {
+                // For fixedCollections, which only allow one value, it is important to still return
+                // the object with an empty collection property which indicates that a value got added
+                // which contains all default values. If that is not done, the value would get lost.
                 const returnValue = {};
                 Object.keys(propertyValues || {}).forEach((value) => {
                     returnValue[value] = {};
@@ -624,9 +694,11 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
                 nodeParameters[nodeProperties.name] = returnValue;
             }
             if (Object.keys(collectionValues).length !== 0 || returnDefaults) {
+                // Set only if value got found
                 if (returnDefaults) {
+                    // Set also when it has the default value
                     if (collectionValues === undefined) {
-                        nodeParameters[nodeProperties.name] = (0, utils_1.deepCopy)(nodeProperties.default);
+                        nodeParameters[nodeProperties.name] = deepCopy(nodeProperties.default);
                     }
                     else {
                         nodeParameters[nodeProperties.name] = collectionValues;
@@ -634,6 +706,7 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
                     nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
                 }
                 else if (collectionValues !== nodeProperties.default) {
+                    // Set only if values got found and it is not the default
                     nodeParameters[nodeProperties.name] = collectionValues;
                     nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
                 }
@@ -642,24 +715,32 @@ function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, retu
     }
     return nodeParameters;
 }
-function getNodeWebhookPath(workflowId, node, path, isFullPath, restartWebhook) {
+/**
+ * Returns the webhook path
+ */
+export function getNodeWebhookPath(workflowId, node, path, isFullPath, restartWebhook) {
     let webhookPath = '';
     if (restartWebhook === true) {
         return path;
     }
     if (node.webhookId === undefined) {
-        webhookPath = `${workflowId}/${encodeURIComponent(node.name.toLowerCase())}/${path}`;
+        const nodeName = encodeURIComponent(node.name.toLowerCase());
+        webhookPath = `${workflowId}/${nodeName}/${path}`;
     }
     else {
         if (isFullPath === true) {
-            return path;
+            return path || node.webhookId;
         }
         webhookPath = `${node.webhookId}/${path}`;
     }
     return webhookPath;
 }
-function getNodeWebhookUrl(baseUrl, workflowId, node, path, isFullPath) {
+/**
+ * Returns the webhook URL
+ */
+export function getNodeWebhookUrl(baseUrl, workflowId, node, path, isFullPath) {
     if ((path.startsWith(':') || path.includes('/:')) && node.webhookId) {
+        // setting this to false to prefix the webhookId
         isFullPath = false;
     }
     if (path.startsWith('/')) {
@@ -667,7 +748,7 @@ function getNodeWebhookUrl(baseUrl, workflowId, node, path, isFullPath) {
     }
     return `${baseUrl}/${getNodeWebhookPath(workflowId, node, path, isFullPath)}`;
 }
-function getConnectionTypes(connections) {
+export function getConnectionTypes(connections) {
     return connections
         .map((connection) => {
         if (typeof connection === 'string') {
@@ -677,10 +758,11 @@ function getConnectionTypes(connections) {
     })
         .filter((connection) => connection !== undefined);
 }
-function getNodeInputs(workflow, node, nodeTypeData) {
+export function getNodeInputs(workflow, node, nodeTypeData) {
     if (Array.isArray(nodeTypeData?.inputs)) {
         return nodeTypeData.inputs;
     }
+    // Calculate the outputs dynamically
     try {
         return (workflow.expression.getSimpleParameterValue(node, nodeTypeData.inputs, 'internal', {}) || []);
     }
@@ -689,12 +771,13 @@ function getNodeInputs(workflow, node, nodeTypeData) {
         return [];
     }
 }
-function getNodeOutputs(workflow, node, nodeTypeData) {
+export function getNodeOutputs(workflow, node, nodeTypeData) {
     let outputs = [];
     if (Array.isArray(nodeTypeData.outputs)) {
         outputs = nodeTypeData.outputs;
     }
     else {
+        // Calculate the outputs dynamically
         try {
             outputs = (workflow.expression.getSimpleParameterValue(node, nodeTypeData.outputs, 'internal', {}) || []);
         }
@@ -703,8 +786,11 @@ function getNodeOutputs(workflow, node, nodeTypeData) {
         }
     }
     if (node.onError === 'continueErrorOutput') {
-        outputs = (0, utils_1.deepCopy)(outputs);
+        // Copy the data to make sure that we do not change the data of the
+        // node type and so change the displayNames for all nodes in the flow
+        outputs = deepCopy(outputs);
         if (outputs.length === 1) {
+            // Set the displayName to "Success"
             if (typeof outputs[0] === 'string') {
                 outputs[0] = {
                     type: outputs[0],
@@ -716,17 +802,24 @@ function getNodeOutputs(workflow, node, nodeTypeData) {
             ...outputs,
             {
                 category: 'error',
-                type: interfaces_1.NodeConnectionTypes.Main,
+                type: NodeConnectionTypes.Main,
                 displayName: 'Error',
             },
         ];
     }
     return outputs;
 }
-function getNodeParametersIssues(nodePropertiesArray, node, nodeTypeDescription, pinDataNodeNames) {
+/**
+ * Returns all the parameter-issues of the node
+ *
+ * @param {INodeProperties[]} nodePropertiesArray The properties of the node
+ * @param {INode} node The data of the node
+ */
+export function getNodeParametersIssues(nodePropertiesArray, node, nodeTypeDescription, pinDataNodeNames) {
     const foundIssues = {};
     let propertyIssues;
     if (node.disabled === true || pinDataNodeNames?.includes(node.name)) {
+        // Ignore issues on disabled and pindata nodes
         return null;
     }
     for (const nodeProperty of nodePropertiesArray) {
@@ -738,12 +831,16 @@ function getNodeParametersIssues(nodePropertiesArray, node, nodeTypeDescription,
     }
     return foundIssues;
 }
+/*
+ * Validates resource locator node parameters based on validation ruled defined in each parameter mode
+ */
 const validateResourceLocatorParameter = (value, parameterMode) => {
     const valueToValidate = value?.value?.toString() || '';
     if (valueToValidate.startsWith('=')) {
         return [];
     }
     const validationErrors = [];
+    // Each mode can have multiple validations specified
     if (parameterMode.validation) {
         for (const validation of parameterMode.validation) {
             if (validation && validation.type === 'regex') {
@@ -757,7 +854,11 @@ const validateResourceLocatorParameter = (value, parameterMode) => {
     }
     return validationErrors;
 };
+/*
+ * Validates resource mapper values based on service schema
+ */
 const validateResourceMapperParameter = (nodeProperties, value, skipRequiredCheck = false) => {
+    // No issues to raise in automatic mapping mode, no user input to validate
     if (value.mappingMode === 'autoMapInputData') {
         return {};
     }
@@ -775,7 +876,7 @@ const validateResourceMapperParameter = (nodeProperties, value, skipRequiredChec
             }
         }
         if (!fieldValue?.toString().startsWith('=') && field.type) {
-            const validationResult = (0, type_validation_1.validateFieldType)(field.id, fieldValue, field.type, {
+            const validationResult = validateFieldType(field.id, fieldValue, field.type, {
                 valueOptions: field.options,
             });
             if (!validationResult.valid && validationResult.errorMessage) {
@@ -792,7 +893,7 @@ const validateParameter = (nodeProperties, value, type) => {
     const nodeName = nodeProperties.name;
     const options = type === 'options' ? nodeProperties.options : undefined;
     if (!value?.toString().startsWith('=')) {
-        const validationResult = (0, type_validation_1.validateFieldType)(nodeName, value, type, {
+        const validationResult = validateFieldType(nodeName, value, type, {
             valueOptions: options,
         });
         if (!validationResult.valid && validationResult.errorMessage) {
@@ -801,13 +902,22 @@ const validateParameter = (nodeProperties, value, type) => {
     }
     return undefined;
 };
+/**
+ * Adds an issue if the parameter is not defined
+ *
+ * @param {INodeIssues} foundIssues The already found issues
+ * @param {INodeProperties} nodeProperties The properties of the node
+ * @param {NodeParameterValue} value The value of the parameter
+ */
 function addToIssuesIfMissing(foundIssues, nodeProperties, value) {
+    // TODO: Check what it really has when undefined
     if ((nodeProperties.type === 'string' && (value === '' || value === undefined)) ||
         (nodeProperties.type === 'multiOptions' && Array.isArray(value) && value.length === 0) ||
         (nodeProperties.type === 'dateTime' && (value === '' || value === undefined)) ||
         (nodeProperties.type === 'options' && (value === '' || value === undefined)) ||
         ((nodeProperties.type === 'resourceLocator' || nodeProperties.type === 'workflowSelector') &&
-            !(0, type_guards_1.isValidResourceLocatorParameterValue)(value))) {
+            !isValidResourceLocatorParameterValue(value))) {
+        // Parameter is required but empty
         if (foundIssues.parameters === undefined) {
             foundIssues.parameters = {};
         }
@@ -817,20 +927,38 @@ function addToIssuesIfMissing(foundIssues, nodeProperties, value) {
         foundIssues.parameters[nodeProperties.name].push(`Parameter "${nodeProperties.displayName}" is required.`);
     }
 }
-function getParameterValueByPath(nodeValues, parameterName, path) {
-    return (0, get_1.default)(nodeValues, path ? `${path}.${parameterName}` : parameterName);
+/**
+ * Returns the parameter value
+ *
+ * @param {INodeParameters} nodeValues The values of the node
+ * @param {string} parameterName The name of the parameter to return the value of
+ * @param {string} path The path to the properties
+ */
+export function getParameterValueByPath(nodeValues, parameterName, path) {
+    return get(nodeValues, path ? `${path}.${parameterName}` : parameterName);
 }
 function isINodeParameterResourceLocator(value) {
     return typeof value === 'object' && value !== null && 'value' in value && 'mode' in value;
 }
-function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDescription) {
+/**
+ * Returns all the issues with the given node-values
+ *
+ * @param {INodeProperties} nodeProperties The properties of the node
+ * @param {INodeParameters} nodeValues The values of the node
+ * @param {string} path The path to the properties
+ */
+// eslint-disable-next-line complexity
+export function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDescription) {
     const foundIssues = {};
     const isDisplayed = displayParameterPath(nodeValues, nodeProperties, path, node, nodeTypeDescription);
     if (nodeProperties.required === true) {
         if (isDisplayed) {
             const value = getParameterValueByPath(nodeValues, nodeProperties.name, path);
-            if (nodeProperties.typeOptions !== undefined &&
+            if (
+            // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+            nodeProperties.typeOptions !== undefined &&
                 nodeProperties.typeOptions.multipleValues !== undefined) {
+                // Multiple can be set so will be an array
                 if (Array.isArray(value)) {
                     for (const singleValue of value) {
                         addToIssuesIfMissing(foundIssues, nodeProperties, singleValue);
@@ -838,6 +966,7 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
                 }
             }
             else {
+                // Only one can be set so will be a single value
                 addToIssuesIfMissing(foundIssues, nodeProperties, value);
             }
         }
@@ -864,7 +993,7 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
     else if (nodeProperties.type === 'resourceMapper' && isDisplayed) {
         const skipRequiredCheck = nodeProperties.typeOptions?.resourceMapper?.mode !== 'add';
         const value = getParameterValueByPath(nodeValues, nodeProperties.name, path);
-        if ((0, type_guards_1.isResourceMapperValue)(value)) {
+        if (isResourceMapperValue(value)) {
             const issues = validateResourceMapperParameter(nodeProperties, value, skipRequiredCheck);
             if (Object.keys(issues).length > 0) {
                 if (foundIssues.parameters === undefined) {
@@ -879,8 +1008,8 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
     }
     else if (nodeProperties.type === 'filter' && isDisplayed) {
         const value = getParameterValueByPath(nodeValues, nodeProperties.name, path);
-        if ((0, type_guards_1.isFilterValue)(value)) {
-            const issues = (0, filter_parameter_1.validateFilterParameter)(nodeProperties, value);
+        if (isFilterValue(value)) {
+            const issues = validateFilterParameter(nodeProperties, value);
             if (Object.keys(issues).length > 0) {
                 foundIssues.parameters = { ...foundIssues.parameters, ...issues };
             }
@@ -899,11 +1028,20 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
             foundIssues.parameters[nodeProperties.name].push(error);
         }
     }
+    // Check if there are any child parameters
     if (nodeProperties.options === undefined) {
+        // There are none so nothing else to check
         return foundIssues;
     }
+    // Check the child parameters
+    // Important:
+    // Checks the child properties only if the property is defined on current level.
+    // That means that the required flag works only for the current level only. If
+    // it is set on a lower level it means that the property is only required in case
+    // the parent property got set.
     let basePath = path ? `${path}.` : '';
     const checkChildNodeProperties = [];
+    // Collect all the properties to check
     if (nodeProperties.type === 'collection') {
         for (const option of nodeProperties.options) {
             checkChildNodeProperties.push({
@@ -916,7 +1054,9 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
         basePath = basePath ? `${basePath}.` : `${nodeProperties.name}.`;
         let propertyOptions;
         for (propertyOptions of nodeProperties.options) {
+            // Check if the option got set and if not skip it
             const value = getParameterValueByPath(nodeValues, propertyOptions.name, basePath.slice(0, -1));
+            // Validate allowed field counts
             const valueArray = Array.isArray(value) ? value : [];
             const { minRequiredFields, maxAllowedFields } = nodeProperties.typeOptions ?? {};
             let error = '';
@@ -934,8 +1074,11 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
             if (value === undefined) {
                 continue;
             }
-            if (nodeProperties.typeOptions !== undefined &&
+            if (
+            // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+            nodeProperties.typeOptions !== undefined &&
                 nodeProperties.typeOptions.multipleValues !== undefined) {
+                // Multiple can be set so will be an array of objects
                 if (Array.isArray(value)) {
                     for (let i = 0; i < value.length; i++) {
                         for (const option of propertyOptions.values) {
@@ -948,6 +1091,7 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
                 }
             }
             else {
+                // Only one can be set so will be an object
                 for (const option of propertyOptions.values) {
                     checkChildNodeProperties.push({
                         basePath: basePath + propertyOptions.name,
@@ -958,6 +1102,7 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
         }
     }
     else {
+        // For all other types there is nothing to check so return
         return foundIssues;
     }
     let propertyIssues;
@@ -967,8 +1112,15 @@ function getParameterIssues(nodeProperties, nodeValues, path, node, nodeTypeDesc
     }
     return foundIssues;
 }
-function mergeIssues(destination, source) {
+/**
+ * Merges multiple NodeIssues together
+ *
+ * @param {INodeIssues} destination The issues to merge into
+ * @param {(INodeIssues | null)} source The issues to merge
+ */
+export function mergeIssues(destination, source) {
     if (source === null) {
+        // Nothing to merge
         return;
     }
     if (source.execution === true) {
@@ -995,44 +1147,54 @@ function mergeIssues(destination, source) {
         destination.typeUnknown = true;
     }
 }
-function mergeNodeProperties(mainProperties, addProperties) {
+/**
+ * Merges the given node properties
+ */
+export function mergeNodeProperties(mainProperties, addProperties) {
     let existingIndex;
     for (const property of addProperties) {
         if (property.doNotInherit)
             continue;
         existingIndex = mainProperties.findIndex((element) => element.name === property.name);
         if (existingIndex === -1) {
+            // Property does not exist yet, so add
             mainProperties.push(property);
         }
         else {
+            // Property exists already, so overwrite
             mainProperties[existingIndex] = property;
         }
     }
 }
-function getVersionedNodeType(object, version) {
+export function getVersionedNodeType(object, version) {
     if ('nodeVersions' in object) {
         return object.getNodeType(version);
     }
     return object;
 }
-function isTriggerNode(nodeTypeData) {
+export function isTriggerNode(nodeTypeData) {
     return nodeTypeData.group.includes('trigger');
 }
-function isExecutable(workflow, node, nodeTypeData) {
+export function isExecutable(workflow, node, nodeTypeData) {
     const outputs = getNodeOutputs(workflow, node, nodeTypeData);
     const outputNames = getConnectionTypes(outputs);
-    return (outputNames.includes(interfaces_1.NodeConnectionTypes.Main) ||
-        outputNames.includes(interfaces_1.NodeConnectionTypes.AiTool) ||
+    return (outputNames.includes(NodeConnectionTypes.Main) ||
+        outputNames.includes(NodeConnectionTypes.AiTool) ||
         isTriggerNode(nodeTypeData));
 }
-function isNodeWithWorkflowSelector(node) {
-    return [constants_1.EXECUTE_WORKFLOW_NODE_TYPE, constants_1.WORKFLOW_TOOL_LANGCHAIN_NODE_TYPE].includes(node.type);
+export function isNodeWithWorkflowSelector(node) {
+    return [EXECUTE_WORKFLOW_NODE_TYPE, WORKFLOW_TOOL_LANGCHAIN_NODE_TYPE].includes(node.type);
 }
+/**
+ * @returns An object containing either the resolved operation's action if available,
+ * else the resource and operation if both exist.
+ * If neither can be resolved, returns an empty object.
+ */
 function resolveResourceAndOperation(nodeParameters, nodeTypeDescription) {
     const resource = nodeParameters.resource;
     const operation = nodeParameters.operation;
     const nodeTypeOperation = nodeTypeDescription.properties.find((p) => p.name === 'operation' && p.displayOptions?.show?.resource?.includes(resource));
-    if (nodeTypeOperation?.options && (0, type_guards_1.isINodePropertyOptionsList)(nodeTypeOperation.options)) {
+    if (nodeTypeOperation?.options && isINodePropertyOptionsList(nodeTypeOperation.options)) {
         const foundOperation = nodeTypeOperation.options.find((option) => option.value === operation);
         if (foundOperation?.action) {
             return { action: foundOperation.action };
@@ -1045,7 +1207,18 @@ function resolveResourceAndOperation(nodeParameters, nodeTypeDescription) {
         return {};
     }
 }
-function makeDescription(nodeParameters, nodeTypeDescription) {
+/**
+ * Generates a human-readable description for a node based on its parameters and type definition.
+ *
+ * This function creates a descriptive string that represents what the node does,
+ * based on its resource, operation, and node type information. The description is
+ * formatted in one of the following ways:
+ *
+ * 1. "{action} in {displayName}" if the operation has a defined action
+ * 2. "{operation} {resource} in {displayName}" if resource and operation exist
+ * 3. The node type's description field as a fallback
+ */
+export function makeDescription(nodeParameters, nodeTypeDescription) {
     const { action, operation, resource } = resolveResourceAndOperation(nodeParameters, nodeTypeDescription);
     if (action) {
         return `${action} in ${nodeTypeDescription.defaults.name}`;
@@ -1055,22 +1228,33 @@ function makeDescription(nodeParameters, nodeTypeDescription) {
     }
     return nodeTypeDescription.description;
 }
-function isTool(nodeTypeDescription, parameters) {
+export function isTool(nodeTypeDescription, parameters) {
+    // Check if node is a vector store in retrieve-as-tool mode
     if (nodeTypeDescription.name.includes('vectorStore')) {
         const mode = parameters.mode;
         return mode === 'retrieve-as-tool';
     }
+    // Check for other tool nodes
     for (const output of nodeTypeDescription.outputs) {
         if (typeof output === 'string') {
-            return output === interfaces_1.NodeConnectionTypes.AiTool;
+            return output === NodeConnectionTypes.AiTool;
         }
-        else if (output?.type && output.type === interfaces_1.NodeConnectionTypes.AiTool) {
+        else if (output?.type && output.type === NodeConnectionTypes.AiTool) {
             return true;
         }
     }
     return false;
 }
-function makeNodeName(nodeParameters, nodeTypeDescription) {
+/**
+ * Generates a resource and operation aware node name.
+ *
+ * Appends `in {nodeTypeDisplayName}` if nodeType is a tool
+ *
+ * 1. "{action}" if the operation has a defined action
+ * 2. "{operation} {resource}" if resource and operation exist
+ * 3. The node type's defaults.name field or displayName as a fallback
+ */
+export function makeNodeName(nodeParameters, nodeTypeDescription) {
     const { action, operation, resource } = resolveResourceAndOperation(nodeParameters, nodeTypeDescription);
     const postfix = isTool(nodeTypeDescription, nodeParameters)
         ? ` in ${nodeTypeDescription.defaults.name}`
@@ -1084,7 +1268,10 @@ function makeNodeName(nodeParameters, nodeTypeDescription) {
     }
     return nodeTypeDescription.defaults.name ?? nodeTypeDescription.displayName;
 }
-function isDefaultNodeName(name, nodeType, parameters) {
+/**
+ * Returns true if the node name is of format `<defaultNodeName>\d*` , which includes auto-renamed nodes
+ */
+export function isDefaultNodeName(name, nodeType, parameters) {
     const legacyDefaultName = nodeType.defaults.name ?? nodeType.displayName;
     const currentDefaultName = makeNodeName(parameters, nodeType);
     for (const defaultName of [legacyDefaultName, currentDefaultName]) {
@@ -1093,7 +1280,11 @@ function isDefaultNodeName(name, nodeType, parameters) {
     }
     return false;
 }
-const getUpdatedToolDescription = (currentNodeType, newParameters, currentParameters) => {
+/**
+ * Determines whether a tool description should be updated and returns the new description if needed.
+ * Returns undefined if no update is needed.
+ */
+export const getUpdatedToolDescription = (currentNodeType, newParameters, currentParameters) => {
     if (!currentNodeType)
         return;
     if (newParameters?.descriptionType === 'manual' && currentParameters) {
@@ -1107,8 +1298,10 @@ const getUpdatedToolDescription = (currentNodeType, newParameters, currentParame
     }
     return;
 };
-exports.getUpdatedToolDescription = getUpdatedToolDescription;
-function getToolDescriptionForNode(node, nodeType) {
+/**
+ * Generates a tool description for a given node based on its parameters and type.
+ */
+export function getToolDescriptionForNode(node, nodeType) {
     let toolDescription;
     if (node.parameters.descriptionType === 'auto' ||
         !node?.parameters.toolDescription?.toString().trim()) {
@@ -1122,8 +1315,11 @@ function getToolDescriptionForNode(node, nodeType) {
     }
     return toolDescription;
 }
-function getSubworkflowId(node) {
-    if (isNodeWithWorkflowSelector(node) && (0, type_guards_1.isResourceLocatorValue)(node.parameters.workflowId)) {
+/**
+ * Attempts to retrieve the ID of a subworkflow from a execute workflow node.
+ */
+export function getSubworkflowId(node) {
+    if (isNodeWithWorkflowSelector(node) && isResourceLocatorValue(node.parameters.workflowId)) {
         return node.parameters.workflowId.value;
     }
     return;