@fsai-flow/workflow 0.0.2 → 0.0.3

package/dist/src/lib/NodeHelpers.js

@@ -0,0 +1,1348 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cronNodeOptions = void 0;
+exports.getConnectionTypes = getConnectionTypes;
+exports.isSubNodeType = isSubNodeType;
+exports.getSpecialNodeParameters = getSpecialNodeParameters;
+exports.displayParameter = displayParameter;
+exports.displayParameterPath = displayParameterPath;
+exports.getContext = getContext;
+exports.getParamterDependencies = getParamterDependencies;
+exports.getParamterResolveOrder = getParamterResolveOrder;
+exports.getNodeParameters = getNodeParameters;
+exports.prepareOutputData = prepareOutputData;
+exports.getNodeWebhooks = getNodeWebhooks;
+exports.getNodeWebhooksBasic = getNodeWebhooksBasic;
+exports.getNodeWebhookPath = getNodeWebhookPath;
+exports.getNodeWebhookUrl = getNodeWebhookUrl;
+exports.getNodeParametersIssues = getNodeParametersIssues;
+exports.nodeIssuesToString = nodeIssuesToString;
+exports.addToIssuesIfMissing = addToIssuesIfMissing;
+exports.getParameterValueByPath = getParameterValueByPath;
+exports.getParameterIssues = getParameterIssues;
+exports.mergeIssues = mergeIssues;
+exports.mergeNodeProperties = mergeNodeProperties;
+exports.getVersionedNodeType = getVersionedNodeType;
+exports.getVersionedNodeTypeAll = getVersionedNodeTypeAll;
+exports.isNodeTypeVersioned = isNodeTypeVersioned;
+exports.getParameterValue = getParameterValue;
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable no-console */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
+/* eslint-disable no-param-reassign */
+/* eslint-disable no-continue */
+/* eslint-disable prefer-spread */
+/* eslint-disable no-restricted-syntax */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+/* eslint-disable import/no-cycle */
+// eslint-disable-next-line import/no-extraneous-dependencies
+const lodash_1 = require("lodash");
+const Interfaces_1 = require("./Interfaces");
+function getConnectionTypes(connections) {
+    return connections
+        .map((connection) => {
+        if (typeof connection === 'string') {
+            return connection;
+        }
+        return connection.type;
+    })
+        .filter((connection) => connection !== undefined);
+}
+exports.cronNodeOptions = [
+    {
+        name: 'item',
+        displayName: 'Item',
+        values: [
+            {
+                displayName: 'Mode',
+                name: 'mode',
+                type: 'options',
+                options: [
+                    {
+                        name: 'Every Minute',
+                        value: 'everyMinute',
+                    },
+                    {
+                        name: 'Every Hour',
+                        value: 'everyHour',
+                    },
+                    {
+                        name: 'Every Day',
+                        value: 'everyDay',
+                    },
+                    {
+                        name: 'Every Week',
+                        value: 'everyWeek',
+                    },
+                    {
+                        name: 'Every Month',
+                        value: 'everyMonth',
+                    },
+                    {
+                        name: 'Every X',
+                        value: 'everyX',
+                    },
+                    {
+                        name: 'Custom',
+                        value: 'custom',
+                    },
+                ],
+                default: 'everyDay',
+                description: 'How often to trigger.',
+            },
+            {
+                displayName: 'Hour',
+                name: 'hour',
+                type: 'number',
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 23,
+                },
+                displayOptions: {
+                    hide: {
+                        mode: ['custom', 'everyHour', 'everyMinute', 'everyX'],
+                    },
+                },
+                default: 14,
+                description: 'The hour of the day to trigger (24h format)',
+            },
+            {
+                displayName: 'Minute',
+                name: 'minute',
+                type: 'number',
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 59,
+                },
+                displayOptions: {
+                    hide: {
+                        mode: ['custom', 'everyMinute', 'everyX'],
+                    },
+                },
+                default: 0,
+                description: 'The minute of the day to trigger',
+            },
+            {
+                displayName: 'Day of Month',
+                name: 'dayOfMonth',
+                type: 'number',
+                displayOptions: {
+                    show: {
+                        mode: ['everyMonth'],
+                    },
+                },
+                typeOptions: {
+                    minValue: 1,
+                    maxValue: 31,
+                },
+                default: 1,
+                description: 'The day of the month to trigger',
+            },
+            {
+                displayName: 'Weekday',
+                name: 'weekday',
+                type: 'options',
+                displayOptions: {
+                    show: {
+                        mode: ['everyWeek'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Monday',
+                        value: '1',
+                    },
+                    {
+                        name: 'Tuesday',
+                        value: '2',
+                    },
+                    {
+                        name: 'Wednesday',
+                        value: '3',
+                    },
+                    {
+                        name: 'Thursday',
+                        value: '4',
+                    },
+                    {
+                        name: 'Friday',
+                        value: '5',
+                    },
+                    {
+                        name: 'Saturday',
+                        value: '6',
+                    },
+                    {
+                        name: 'Sunday',
+                        value: '0',
+                    },
+                ],
+                default: '1',
+                description: 'The weekday to trigger',
+            },
+            {
+                displayName: 'Cron Expression',
+                name: 'cronExpression',
+                type: 'string',
+                displayOptions: {
+                    show: {
+                        mode: ['custom'],
+                    },
+                },
+                default: '* * * * * *',
+                description: 'Use custom cron expression. Values and ranges as follows:<ul><li>Seconds: 0-59</li><li>Minutes: 0 - 59</li><li>Hours: 0 - 23</li><li>Day of Month: 1 - 31</li><li>Months: 0 - 11 (Jan - Dec)</li><li>Day of Week: 0 - 6 (Sun - Sat)</li></ul>',
+            },
+            {
+                displayName: 'Value',
+                name: 'value',
+                type: 'number',
+                typeOptions: {
+                    minValue: 0,
+                    maxValue: 1000,
+                },
+                displayOptions: {
+                    show: {
+                        mode: ['everyX'],
+                    },
+                },
+                default: 2,
+                description: 'All how many X minutes/hours it should trigger',
+            },
+            {
+                displayName: 'Unit',
+                name: 'unit',
+                type: 'options',
+                displayOptions: {
+                    show: {
+                        mode: ['everyX'],
+                    },
+                },
+                options: [
+                    {
+                        name: 'Minutes',
+                        value: 'minutes',
+                    },
+                    {
+                        name: 'Hours',
+                        value: 'hours',
+                    },
+                    {
+                        name: 'Seconds',
+                        value: 'seconds',
+                    },
+                ],
+                default: 'hours',
+                description: 'If it should trigger all X minutes or hours',
+            },
+        ],
+    },
+];
+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
+        : false;
+}
+/**
+ * Gets special parameters which should be added to nodeTypes depending
+ * on their type or configuration
+ *
+ * @export
+ * @param {INodeType} nodeType
+ * @returns
+ */
+function getSpecialNodeParameters(nodeType) {
+    if (nodeType.description.polling === true) {
+        return [
+            {
+                displayName: 'Poll Times',
+                name: 'pollTimes',
+                type: 'fixedCollection',
+                typeOptions: {
+                    multipleValues: true,
+                    multipleValueButtonText: 'Add Poll Time',
+                },
+                default: { item: [{ mode: 'everyMinute' }] },
+                description: 'Time at which polling should occur',
+                placeholder: 'Add Poll Time',
+                options: [
+                    {
+                        name: 'item',
+                        displayName: 'Item',
+                        values: [
+                            {
+                                displayName: 'Mode',
+                                name: 'mode',
+                                type: 'options',
+                                options: [
+                                    {
+                                        name: 'Every Minute',
+                                        value: 'everyMinute',
+                                    },
+                                    {
+                                        name: 'Every Hour',
+                                        value: 'everyHour',
+                                    },
+                                    {
+                                        name: 'Every Day',
+                                        value: 'everyDay',
+                                    },
+                                    {
+                                        name: 'Every Week',
+                                        value: 'everyWeek',
+                                    },
+                                    {
+                                        name: 'Every Month',
+                                        value: 'everyMonth',
+                                    },
+                                    {
+                                        name: 'Every X',
+                                        value: 'everyX',
+                                    },
+                                    {
+                                        name: 'Custom',
+                                        value: 'custom',
+                                    },
+                                ],
+                                default: 'everyDay',
+                                description: 'How often to trigger.',
+                            },
+                            {
+                                displayName: 'Hour',
+                                name: 'hour',
+                                type: 'number',
+                                typeOptions: {
+                                    minValue: 0,
+                                    maxValue: 23,
+                                },
+                                displayOptions: {
+                                    hide: {
+                                        mode: ['custom', 'everyHour', 'everyMinute', 'everyX'],
+                                    },
+                                },
+                                default: 14,
+                                description: 'The hour of the day to trigger (24h format)',
+                            },
+                            {
+                                displayName: 'Minute',
+                                name: 'minute',
+                                type: 'number',
+                                typeOptions: {
+                                    minValue: 0,
+                                    maxValue: 59,
+                                },
+                                displayOptions: {
+                                    hide: {
+                                        mode: ['custom', 'everyMinute', 'everyX'],
+                                    },
+                                },
+                                default: 0,
+                                description: 'The minute of the day to trigger',
+                            },
+                            {
+                                displayName: 'Day of Month',
+                                name: 'dayOfMonth',
+                                type: 'number',
+                                displayOptions: {
+                                    show: {
+                                        mode: ['everyMonth'],
+                                    },
+                                },
+                                typeOptions: {
+                                    minValue: 1,
+                                    maxValue: 31,
+                                },
+                                default: 1,
+                                description: 'The day of the month to trigger',
+                            },
+                            {
+                                displayName: 'Weekday',
+                                name: 'weekday',
+                                type: 'options',
+                                displayOptions: {
+                                    show: {
+                                        mode: ['everyWeek'],
+                                    },
+                                },
+                                options: [
+                                    {
+                                        name: 'Monday',
+                                        value: '1',
+                                    },
+                                    {
+                                        name: 'Tuesday',
+                                        value: '2',
+                                    },
+                                    {
+                                        name: 'Wednesday',
+                                        value: '3',
+                                    },
+                                    {
+                                        name: 'Thursday',
+                                        value: '4',
+                                    },
+                                    {
+                                        name: 'Friday',
+                                        value: '5',
+                                    },
+                                    {
+                                        name: 'Saturday',
+                                        value: '6',
+                                    },
+                                    {
+                                        name: 'Sunday',
+                                        value: '0',
+                                    },
+                                ],
+                                default: '1',
+                                description: 'The weekday to trigger',
+                            },
+                            {
+                                displayName: 'Cron Expression',
+                                name: 'cronExpression',
+                                type: 'string',
+                                displayOptions: {
+                                    show: {
+                                        mode: ['custom'],
+                                    },
+                                },
+                                default: '* * * * * *',
+                                description: 'Use custom cron expression. Values and ranges as follows:<ul><li>Seconds: 0-59</li><li>Minutes: 0 - 59</li><li>Hours: 0 - 23</li><li>Day of Month: 1 - 31</li><li>Months: 0 - 11 (Jan - Dec)</li><li>Day of Week: 0 - 6 (Sun - Sat)</li></ul>',
+                            },
+                            {
+                                displayName: 'Value',
+                                name: 'value',
+                                type: 'number',
+                                typeOptions: {
+                                    minValue: 0,
+                                    maxValue: 1000,
+                                },
+                                displayOptions: {
+                                    show: {
+                                        mode: ['everyX'],
+                                    },
+                                },
+                                default: 2,
+                                description: 'All how many X minutes/hours it should trigger',
+                            },
+                            {
+                                displayName: 'Unit',
+                                name: 'unit',
+                                type: 'options',
+                                displayOptions: {
+                                    show: {
+                                        mode: ['everyX'],
+                                    },
+                                },
+                                options: [
+                                    {
+                                        name: 'Minutes',
+                                        value: 'minutes',
+                                    },
+                                    {
+                                        name: 'Hours',
+                                        value: 'hours',
+                                    },
+                                    {
+                                        name: 'Seconds',
+                                        value: 'seconds',
+                                    },
+                                ],
+                                default: 'hours',
+                                description: 'If it should trigger all X minutes or hours',
+                            },
+                        ],
+                    },
+                ],
+            },
+        ];
+    }
+    return [];
+}
+/**
+ * Returns if the parameter should be displayed or not
+ *
+ * @export
+ * @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
+ * @returns
+ */
+function displayParameter(nodeValues, parameter, nodeValuesRoot) {
+    if (!parameter.displayOptions) {
+        return true;
+    }
+    nodeValuesRoot = nodeValuesRoot || nodeValues;
+    let value;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const values = [];
+    if (parameter.displayOptions.show) {
+        // All the defined rules have to match to display parameter
+        for (const propertyName of Object.keys(parameter.displayOptions.show)) {
+            if (propertyName.charAt(0) === '/') {
+                // Get the value from the root of the node
+                value = (0, lodash_1.get)(nodeValuesRoot, propertyName.slice(1));
+            }
+            else {
+                // Get the value from current level
+                value = (0, lodash_1.get)(nodeValues, propertyName);
+            }
+            values.length = 0;
+            if (!Array.isArray(value)) {
+                values.push(value);
+            }
+            else {
+                values.push.apply(values, value);
+            }
+            if (values.some((v) => typeof v === 'string' && v.charAt(0) === '=')) {
+                return true;
+            }
+            if (values.length === 0 ||
+                !parameter.displayOptions.show[propertyName].some((v) => values.includes(v))) {
+                return false;
+            }
+        }
+    }
+    if (parameter.displayOptions.hide) {
+        // Any of the defined hide rules have to match to hide the parameter
+        for (const propertyName of Object.keys(parameter.displayOptions.hide)) {
+            if (propertyName.charAt(0) === '/') {
+                // Get the value from the root of the node
+                value = (0, lodash_1.get)(nodeValuesRoot, propertyName.slice(1));
+            }
+            else {
+                // Get the value from current level
+                value = (0, lodash_1.get)(nodeValues, propertyName);
+            }
+            values.length = 0;
+            if (!Array.isArray(value)) {
+                values.push(value);
+            }
+            else {
+                values.push.apply(values, value);
+            }
+            if (values.length !== 0 &&
+                parameter.displayOptions.hide[propertyName].some((v) => values.includes(v))) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+/**
+ * Returns if the given parameter should be displayed or not considering the path
+ * to the properties
+ *
+ * @export
+ * @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
+ * @returns
+ */
+function displayParameterPath(nodeValues, parameter, path) {
+    let resolvedNodeValues = nodeValues;
+    if (path !== '') {
+        resolvedNodeValues = (0, lodash_1.get)(nodeValues, path);
+    }
+    // Get the root parameter data
+    let nodeValuesRoot = nodeValues;
+    if (path && path.split('.').indexOf('parameters') === 0) {
+        nodeValuesRoot = (0, lodash_1.get)(nodeValues, 'parameters');
+    }
+    return displayParameter(resolvedNodeValues, parameter, nodeValuesRoot);
+}
+/**
+ * Returns the context data
+ *
+ * @export
+ * @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
+ * @returns {IContextObject}
+ */
+function getContext(runExecutionData, type, node) {
+    if (runExecutionData.executionData === undefined) {
+        // TODO: Should not happen leave it for test now
+        throw new Error('The "executionData" is not initialized!');
+    }
+    let key;
+    if (type === 'flow') {
+        key = 'flow';
+    }
+    else if (type === 'node') {
+        if (node === undefined) {
+            throw new Error(`The request data of context type "node" the node parameter has to be set!`);
+        }
+        key = `node:${node.name}`;
+    }
+    else {
+        throw new Error(`The context type "${type}" is not know. Only "flow" and node" are supported!`);
+    }
+    if (runExecutionData.executionData.contextData[key] === undefined) {
+        // eslint-disable-next-line no-param-reassign
+        runExecutionData.executionData.contextData[key] = {};
+    }
+    return runExecutionData.executionData.contextData[key];
+}
+/**
+ * Returns which parameters are dependent on which
+ *
+ * @export
+ * @param {INodeProperties[]} nodePropertiesArray
+ * @returns {IParameterDependencies}
+ */
+function getParamterDependencies(nodePropertiesArray) {
+    const dependencies = {};
+    let displayRule;
+    let parameterName;
+    for (const nodeProperties of nodePropertiesArray) {
+        if (dependencies[nodeProperties.name] === undefined) {
+            dependencies[nodeProperties.name] = [];
+        }
+        if (nodeProperties.displayOptions === undefined) {
+            // Does not have any dependencies
+            continue;
+        }
+        for (displayRule of Object.keys(nodeProperties.displayOptions)) {
+            // @ts-ignore
+            for (parameterName of Object.keys(nodeProperties.displayOptions[displayRule])) {
+                if (!dependencies[nodeProperties.name].includes(parameterName)) {
+                    dependencies[nodeProperties.name].push(parameterName);
+                }
+            }
+        }
+    }
+    return dependencies;
+}
+/**
+ * Returns in which order the parameters should be resolved
+ * to have the parameters available they depend on
+ *
+ * @export
+ * @param {INodeProperties[]} nodePropertiesArray
+ * @param {IParameterDependencies} parameterDependencies
+ * @returns {number[]}
+ */
+function getParamterResolveOrder(nodePropertiesArray, parameterDependencies) {
+    const executionOrder = [];
+    const indexToResolve = Array.from({ length: nodePropertiesArray.length }, (v, k) => k);
+    const resolvedParamters = [];
+    let index;
+    let property;
+    let lastIndexLength = indexToResolve.length;
+    let lastIndexReduction = -1;
+    let iterations = 0;
+    while (indexToResolve.length !== 0) {
+        iterations += 1;
+        index = indexToResolve.shift();
+        property = nodePropertiesArray[index];
+        if (parameterDependencies[property.name].length === 0) {
+            // Does not have any dependencies so simply add
+            executionOrder.push(index);
+            resolvedParamters.push(property.name);
+            continue;
+        }
+        // Parameter has dependencies
+        for (const dependency of parameterDependencies[property.name]) {
+            if (!resolvedParamters.includes(dependency)) {
+                if (dependency.charAt(0) === '/') {
+                    // Assume that root level depenencies are resolved
+                    continue;
+                }
+                // Dependencies for that paramter are still missing so
+                // try to add again later
+                indexToResolve.push(index);
+                continue;
+            }
+        }
+        // All dependencies got found so add
+        executionOrder.push(index);
+        resolvedParamters.push(property.name);
+        if (indexToResolve.length < lastIndexLength) {
+            lastIndexReduction = iterations;
+        }
+        if (iterations > lastIndexReduction + nodePropertiesArray.length) {
+            throw new Error('Could not resolve parameter depenencies. 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;
+}
+/**
+ * Returns the node parameter values. Depending on the settings it either just returns the none
+ * default values or it applies all the default values.
+ *
+ * @export
+ * @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 {boolean} [onlySimpleTypes=false] If only simple types should be resolved
+ * @param {boolean} [dataIsResolved=false] If nodeValues are already fully resolved (so that all default values got added already)
+ * @param {INodeParameters} [nodeValuesRoot] The root node-parameter-data
+ * @returns {(INodeParameters | null)}
+ */
+function getNodeParameters(nodePropertiesArray, nodeValues, returnDefaults, returnNoneDisplayed, onlySimpleTypes = false, dataIsResolved = false, nodeValuesRoot, parentType, parameterDependencies) {
+    if (parameterDependencies === undefined) {
+        parameterDependencies = getParamterDependencies(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) {
+        if (parameterNames.includes(nodeProperties.name)) {
+            if (!duplicateParameterNames.includes(nodeProperties.name)) {
+                duplicateParameterNames.push(nodeProperties.name);
+            }
+        }
+        else {
+            parameterNames.push(nodeProperties.name);
+        }
+    }
+    const nodeParameters = {};
+    const nodeParametersFull = {};
+    let nodeValuesDisplayCheck = nodeParametersFull;
+    if (!dataIsResolved && !returnNoneDisplayed) {
+        nodeValuesDisplayCheck = getNodeParameters(nodePropertiesArray, nodeValues, true, true, true, true, nodeValuesRoot, parentType, parameterDependencies);
+    }
+    nodeValuesRoot = nodeValuesRoot || nodeValuesDisplayCheck;
+    // Go through the parameters in order of their dependencies
+    const parameterItterationOrderIndex = getParamterResolveOrder(nodePropertiesArray, parameterDependencies);
+    for (const parameterIndex of parameterItterationOrderIndex) {
+        const nodeProperties = nodePropertiesArray[parameterIndex];
+        if (nodeValues[nodeProperties.name] === undefined &&
+            (!returnDefaults || parentType === 'collection')) {
+            // The value is not defined so go to the next
+            continue;
+        }
+        if (!returnNoneDisplayed &&
+            !displayParameter(nodeValuesDisplayCheck, nodeProperties, nodeValuesRoot)) {
+            if (!returnNoneDisplayed || !returnDefaults) {
+                continue;
+            }
+        }
+        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, 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]
+                            : nodeProperties.default;
+                }
+                else {
+                    nodeParameters[nodeProperties.name] =
+                        nodeValues[nodeProperties.name] || nodeProperties.default;
+                }
+                nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
+            }
+            else if ((nodeValues[nodeProperties.name] !== nodeProperties.default &&
+                typeof nodeValues[nodeProperties.name] !== 'object') ||
+                (typeof nodeValues[nodeProperties.name] === 'object' &&
+                    !(0, lodash_1.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] = JSON.parse(JSON.stringify(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, false, false, nodeValuesRoot, nodeProperties.type);
+                if (tempNodeParameters !== null) {
+                    nodeParameters[nodeProperties.name] = tempNodeParameters;
+                    nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
+                }
+            }
+            else if (returnDefaults) {
+                // Does not have values defined but defaults should be returned
+                nodeParameters[nodeProperties.name] = JSON.parse(JSON.stringify(nodeProperties.default));
+                nodeParametersFull[nodeProperties.name] = nodeParameters[nodeProperties.name];
+            }
+        }
+        else if (nodeProperties.type === 'fixedCollection') {
+            // Is fixedCollection
+            const collectionValues = {};
+            let tempNodeParameters;
+            let tempNodePropertiesArray;
+            let nodePropertyOptions;
+            let propertyValues = nodeValues[nodeProperties.name];
+            if (returnDefaults) {
+                if (propertyValues === undefined) {
+                    propertyValues = JSON.parse(JSON.stringify(nodeProperties.default));
+                }
+            }
+            // 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(
+                        // eslint-disable-next-line @typescript-eslint/no-shadow
+                        (nodePropertyOptions) => nodePropertyOptions.name === itemName);
+                        if (nodePropertyOptions === undefined) {
+                            throw new Error(`Could not find property option "${itemName}" for "${nodeProperties.name}"`);
+                        }
+                        tempNodePropertiesArray = nodePropertyOptions.values;
+                        tempValue = getNodeParameters(tempNodePropertiesArray, nodeValue, returnDefaults, returnNoneDisplayed, false, false, nodeValuesRoot, nodeProperties.type);
+                        if (tempValue !== null) {
+                            tempArrayValue.push(tempValue);
+                        }
+                    }
+                    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;
+                        tempValue = getNodeParameters(tempNodePropertiesArray, nodeValues[nodeProperties.name][itemName], returnDefaults, returnNoneDisplayed, false, false, nodeValuesRoot, nodeProperties.type);
+                        if (tempValue !== null) {
+                            Object.assign(tempNodeParameters, tempValue);
+                        }
+                    }
+                    if (Object.keys(tempNodeParameters).length !== 0) {
+                        collectionValues[itemName] = tempNodeParameters;
+                    }
+                }
+            }
+            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] = JSON.parse(JSON.stringify(nodeProperties.default));
+                    }
+                    else {
+                        nodeParameters[nodeProperties.name] = collectionValues;
+                    }
+                    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];
+                }
+            }
+        }
+    }
+    return nodeParameters;
+}
+/**
+ * Brings the output data in a format that can be returned from a node
+ *
+ * @export
+ * @param {INodeExecutionData[]} outputData
+ * @param {number} [outputIndex=0]
+ * @returns {Promise<INodeExecutionData[][]>}
+ */
+async function prepareOutputData(outputData, outputIndex = 0) {
+    // TODO: Check if node has output with that index
+    const returnData = [];
+    for (let i = 0; i < outputIndex; i++) {
+        returnData.push([]);
+    }
+    returnData.push(outputData);
+    return returnData;
+}
+/**
+ * Returns all the webhooks which should be created for the give node
+ *
+ * @export
+ *
+ * @param {INode} node
+ * @returns {IWebhookData[]}
+ */
+function getNodeWebhooks(workflow, node, additionalData, ignoreRestartWehbooks = false) {
+    if (node.disabled === true) {
+        // Node is disabled so webhooks will also not be enabled
+        return [];
+    }
+    const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+    if (nodeType.description.webhooks === undefined) {
+        // Node does not have any webhooks so return
+        return [];
+    }
+    const workflowId = workflow.id || '__UNSAVED__';
+    const mode = 'internal';
+    const returnData = [];
+    for (const webhookDescription of nodeType.description.webhooks) {
+        if (ignoreRestartWehbooks && webhookDescription.restartWebhook === true) {
+            continue;
+        }
+        let nodeWebhookPath = workflow.expression.getSimpleParameterValue(node, webhookDescription.path, mode, {});
+        if (nodeWebhookPath === undefined) {
+            // TODO: Use a proper logger
+            console.error(`No webhook path could be found for node "${node.name}" in workflow "${workflowId}".`);
+            continue;
+        }
+        nodeWebhookPath = nodeWebhookPath.toString();
+        if (nodeWebhookPath.startsWith('/')) {
+            nodeWebhookPath = nodeWebhookPath.slice(1);
+        }
+        if (nodeWebhookPath.endsWith('/')) {
+            nodeWebhookPath = nodeWebhookPath.slice(0, -1);
+        }
+        const isFullPath = workflow.expression.getSimpleParameterValue(node, webhookDescription.isFullPath, 'internal', {}, false);
+        const restartWebhook = workflow.expression.getSimpleParameterValue(node, webhookDescription.restartWebhook, 'internal', {}, false);
+        const path = getNodeWebhookPath(workflowId, node, nodeWebhookPath, isFullPath, restartWebhook);
+        const httpMethod = workflow.expression.getSimpleParameterValue(node, webhookDescription.httpMethod, mode, {}, 'GET');
+        if (httpMethod === undefined) {
+            // TODO: Use a proper logger
+            console.error(`The webhook "${path}" for node "${node.name}" in workflow "${workflowId}" could not be added because the httpMethod is not defined.`);
+            continue;
+        }
+        let webhookId;
+        if ((path.startsWith(':') || path.includes('/:')) && node.webhookId) {
+            webhookId = node.webhookId;
+        }
+        returnData.push({
+            httpMethod: httpMethod.toString(),
+            node: node.name,
+            path,
+            webhookDescription,
+            workflowId,
+            workflowExecuteAdditionalData: additionalData,
+            webhookId,
+        });
+    }
+    return returnData;
+}
+function getNodeWebhooksBasic(workflow, node) {
+    if (node.disabled === true) {
+        // Node is disabled so webhooks will also not be enabled
+        return [];
+    }
+    const nodeType = workflow.nodeTypes.getByNameAndVersion(node.type, node.typeVersion);
+    if (nodeType.description.webhooks === undefined) {
+        // Node does not have any webhooks so return
+        return [];
+    }
+    const workflowId = workflow.id || '__UNSAVED__';
+    const mode = 'internal';
+    const returnData = [];
+    for (const webhookDescription of nodeType.description.webhooks) {
+        let nodeWebhookPath = workflow.expression.getSimpleParameterValue(node, webhookDescription.path, mode, {});
+        if (nodeWebhookPath === undefined) {
+            // TODO: Use a proper logger
+            console.error(`No webhook path could be found for node "${node.name}" in workflow "${workflowId}".`);
+            continue;
+        }
+        nodeWebhookPath = nodeWebhookPath.toString();
+        if (nodeWebhookPath.startsWith('/')) {
+            nodeWebhookPath = nodeWebhookPath.slice(1);
+        }
+        if (nodeWebhookPath.endsWith('/')) {
+            nodeWebhookPath = nodeWebhookPath.slice(0, -1);
+        }
+        const isFullPath = workflow.expression.getSimpleParameterValue(node, webhookDescription.isFullPath, mode, {}, false);
+        const path = getNodeWebhookPath(workflowId, node, nodeWebhookPath, isFullPath);
+        const httpMethod = workflow.expression.getSimpleParameterValue(node, webhookDescription.httpMethod, mode, {});
+        if (httpMethod === undefined) {
+            // TODO: Use a proper logger
+            console.error(`The webhook "${path}" for node "${node.name}" in workflow "${workflowId}" could not be added because the httpMethod is not defined.`);
+            continue;
+        }
+        // @ts-ignore
+        returnData.push({
+            httpMethod: httpMethod.toString(),
+            node: node.name,
+            path,
+            webhookDescription,
+            workflowId,
+        });
+    }
+    return returnData;
+}
+/**
+ * Returns the webhook path
+ *
+ * @export
+ * @param {string} workflowId
+ * @param {string} nodeTypeName
+ * @param {string} path
+ * @returns {string}
+ */
+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}`;
+    }
+    else {
+        if (isFullPath === true) {
+            return path;
+        }
+        webhookPath = `${node.webhookId}/${path}`;
+    }
+    return webhookPath;
+}
+/**
+ * Returns the webhook URL
+ *
+ * @export
+ * @param {string} baseUrl
+ * @param {string} workflowId
+ * @param {string} nodeTypeName
+ * @param {string} path
+ * @param {boolean} isFullPath
+ * @returns {string}
+ */
+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('/')) {
+        path = path.slice(1);
+    }
+    return `${baseUrl}/${getNodeWebhookPath(workflowId, node, path, isFullPath)}`;
+}
+/**
+ * Returns all the parameter-issues of the node
+ *
+ * @export
+ * @param {INodeProperties[]} nodePropertiesArray The properties of the node
+ * @param {INode} node The data of the node
+ * @returns {(INodeIssues | null)}
+ */
+function getNodeParametersIssues(nodePropertiesArray, node) {
+    const foundIssues = {};
+    let propertyIssues;
+    if (node.disabled === true) {
+        // Ignore issues on disabled nodes
+        return null;
+    }
+    for (const nodeProperty of nodePropertiesArray) {
+        propertyIssues = getParameterIssues(nodeProperty, node.parameters, '');
+        mergeIssues(foundIssues, propertyIssues);
+    }
+    if (Object.keys(foundIssues).length === 0) {
+        return null;
+    }
+    return foundIssues;
+}
+/**
+ * Returns the issues of the node as string
+ *
+ * @export
+ * @param {INodeIssues} issues The issues of the node
+ * @param {INode} node The node
+ * @returns {string[]}
+ */
+function nodeIssuesToString(issues, node) {
+    const nodeIssues = [];
+    if (issues.execution !== undefined) {
+        nodeIssues.push(`Execution Error.`);
+    }
+    const objectProperties = ['parameters', 'credentials'];
+    let issueText;
+    let parameterName;
+    for (const propertyName of objectProperties) {
+        if (issues[propertyName] !== undefined) {
+            for (parameterName of Object.keys(issues[propertyName])) {
+                for (issueText of issues[propertyName][parameterName]) {
+                    nodeIssues.push(issueText);
+                }
+            }
+        }
+    }
+    if (issues.typeUnknown !== undefined) {
+        if (node !== undefined) {
+            nodeIssues.push(`Node Type "${node.type}" is not known.`);
+        }
+        else {
+            nodeIssues.push(`Node Type is not known.`);
+        }
+    }
+    return nodeIssues;
+}
+/**
+ * Adds an issue if the parameter is not defined
+ *
+ * @export
+ * @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 === undefined)) {
+        // Parameter is requried but empty
+        if (foundIssues.parameters === undefined) {
+            foundIssues.parameters = {};
+        }
+        if (foundIssues.parameters[nodeProperties.name] === undefined) {
+            foundIssues.parameters[nodeProperties.name] = [];
+        }
+        foundIssues.parameters[nodeProperties.name].push(`Parameter "${nodeProperties.displayName}" is required.`);
+    }
+}
+/**
+ * Returns the parameter value
+ *
+ * @export
+ * @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
+ * @returns
+ */
+function getParameterValueByPath(nodeValues, parameterName, path) {
+    return (0, lodash_1.get)(nodeValues, path ? `${path}.${parameterName}` : parameterName);
+}
+/**
+ * Returns all the issues with the given node-values
+ *
+ * @export
+ * @param {INodeProperties} nodeProperties The properties of the node
+ * @param {INodeParameters} nodeValues The values of the node
+ * @param {string} path The path to the properties
+ * @returns {INodeIssues}
+ */
+function getParameterIssues(nodeProperties, nodeValues, path) {
+    const foundIssues = {};
+    let value;
+    if (nodeProperties.required === true) {
+        if (displayParameterPath(nodeValues, nodeProperties, path)) {
+            value = getParameterValueByPath(nodeValues, nodeProperties.name, path);
+            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);
+                    }
+                }
+            }
+            else {
+                // Only one can be set so will be a single value
+                addToIssuesIfMissing(foundIssues, nodeProperties, value);
+            }
+        }
+    }
+    // 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({
+                basePath,
+                data: option,
+            });
+        }
+    }
+    else if (nodeProperties.type === 'fixedCollection') {
+        basePath = basePath ? `${basePath}.` : `${nodeProperties.name}.`;
+        let propertyOptions;
+        for (propertyOptions of nodeProperties.options) {
+            // Check if the option got set and if not skip it
+            value = getParameterValueByPath(nodeValues, propertyOptions.name, basePath.slice(0, -1));
+            if (value === undefined) {
+                continue;
+            }
+            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) {
+                            checkChildNodeProperties.push({
+                                basePath: `${basePath}${propertyOptions.name}[${i}]`,
+                                data: option,
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                // Only one can be set so will be an object
+                for (const option of propertyOptions.values) {
+                    checkChildNodeProperties.push({
+                        basePath: basePath + propertyOptions.name,
+                        data: option,
+                    });
+                }
+            }
+        }
+    }
+    else {
+        // For all other types there is nothing to check so return
+        return foundIssues;
+    }
+    let propertyIssues;
+    for (const optionData of checkChildNodeProperties) {
+        propertyIssues = getParameterIssues(optionData.data, nodeValues, optionData.basePath);
+        mergeIssues(foundIssues, propertyIssues);
+    }
+    return foundIssues;
+}
+/**
+ * Merges multiple NodeIssues together
+ *
+ * @export
+ * @param {INodeIssues} destination The issues to merge into
+ * @param {(INodeIssues | null)} source The issues to merge
+ * @returns
+ */
+function mergeIssues(destination, source) {
+    if (source === null) {
+        // Nothing to merge
+        return;
+    }
+    if (source.execution === true) {
+        destination.execution = true;
+    }
+    const objectProperties = ['parameters', 'credentials'];
+    let destinationProperty;
+    for (const propertyName of objectProperties) {
+        if (source[propertyName] !== undefined) {
+            if (destination[propertyName] === undefined) {
+                destination[propertyName] = {};
+            }
+            let parameterName;
+            for (parameterName of Object.keys(source[propertyName])) {
+                destinationProperty = destination[propertyName];
+                if (destinationProperty[parameterName] === undefined) {
+                    destinationProperty[parameterName] = [];
+                }
+                destinationProperty[parameterName].push.apply(destinationProperty[parameterName], source[propertyName][parameterName]);
+            }
+        }
+    }
+    if (source.typeUnknown === true) {
+        destination.typeUnknown = true;
+    }
+}
+/**
+ * Merges the given node properties
+ *
+ * @export
+ * @param {INodeProperties[]} mainProperties
+ * @param {INodeProperties[]} addProperties
+ */
+function mergeNodeProperties(mainProperties, addProperties) {
+    let existingIndex;
+    for (const property of addProperties) {
+        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) {
+    if (isNodeTypeVersioned(object)) {
+        return object.getNodeType(version);
+    }
+    return object;
+}
+function getVersionedNodeTypeAll(object) {
+    if (isNodeTypeVersioned(object)) {
+        return Object.values(object.nodeVersions).map((element) => {
+            element.description.name = object.description.name;
+            return element;
+        });
+    }
+    return [object];
+}
+function isNodeTypeVersioned(object) {
+    return !!('getNodeType' in object);
+}
+/**
+ * Returns the parameter value from the node parameters
+ *
+ * @export
+ * @param {INodeParameters} nodeParameters The node parameters
+ * @param {string} parameterName The name of the parameter to get
+ * @param {number} [index=0] The index of the parameter value if it's an array
+ * @returns {NodeParameterValue | undefined} The parameter value
+ */
+function getParameterValue(nodeParameters, parameterName, index = 0) {
+    const value = nodeParameters[parameterName];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        const arrayValue = value[index];
+        return typeof arrayValue === 'object' ? undefined : arrayValue;
+    }
+    return typeof value === 'object' ? undefined : value;
+}
+//# sourceMappingURL=NodeHelpers.js.map