@fsai-flow/workflow 0.0.2 → 0.1.0

package/src/lib/RoutingNode.ts

@@ -1,862 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-/* eslint-disable import/no-cycle */
-/* eslint-disable @typescript-eslint/prefer-nullish-coalescing */
-/* eslint-disable no-param-reassign */
-/* eslint-disable no-continue */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable no-await-in-loop */
-/* eslint-disable no-restricted-syntax */
-const get = require('lodash.get');
-const merge = require('lodash.merge');
-
-import {
-	ICredentialDataDecryptedObject,
-	ICredentialsDecrypted,
-	IHttpRequestOptions,
-	IN8nHttpFullResponse,
-	INode,
-	INodeExecuteFunctions,
-	INodeExecutionData,
-	INodeParameters,
-	INodePropertyOptions,
-	INodeType,
-	IRequestOptionsFromParameters,
-	IRunExecutionData,
-	ITaskDataConnections,
-	IWorkflowDataProxyAdditionalKeys,
-	IWorkflowExecuteAdditionalData,
-	NodeHelpers,
-	NodeParameterValue,
-	Workflow,
-	WorkflowExecuteMode,
-} from '..';
-
-import {
-	CloseFunction,
-	IDataObject,
-	IExecuteSingleFunctions,
-	IN8nRequestOperations,
-	INodeProperties,
-	INodePropertyCollection,
-	PostReceiveAction,
-} from './Interfaces';
-
-export class RoutingNode {
-	additionalData: IWorkflowExecuteAdditionalData;
-
-	connectionInputData: INodeExecutionData[];
-
-	node: INode;
-
-	mode: WorkflowExecuteMode;
-
-	runExecutionData: IRunExecutionData;
-
-	workflow: Workflow;
-
-	constructor(
-		workflow: Workflow,
-		node: INode,
-		connectionInputData: INodeExecutionData[],
-		runExecutionData: IRunExecutionData,
-		additionalData: IWorkflowExecuteAdditionalData,
-		mode: WorkflowExecuteMode,
-	) {
-		this.additionalData = additionalData;
-		this.connectionInputData = connectionInputData;
-		this.runExecutionData = runExecutionData;
-		this.mode = mode;
-		this.node = node;
-		this.workflow = workflow;
-	}
-
-	async runNode(
-		inputData: ITaskDataConnections,
-		runIndex: number,
-		nodeType: INodeType,
-		nodeExecuteFunctions: INodeExecuteFunctions,
-		credentialsDecrypted?: ICredentialsDecrypted,
-	): Promise<INodeExecutionData[][] | null | undefined> {
-		const items = inputData['main'][0] as INodeExecutionData[];
-		const returnData: INodeExecutionData[] = [];
-		const closeFunctions: CloseFunction[] = [];
-		let responseData;
-
-		let credentialType: string | undefined;
-
-		if (nodeType.description.credentials?.length) {
-			credentialType = nodeType.description.credentials[0].name;
-		}
-		const executeFunctions = nodeExecuteFunctions.getExecuteFunctions(
-			this.workflow,
-			this.runExecutionData,
-			runIndex,
-			this.connectionInputData,
-			inputData,
-			this.node,
-			this.additionalData,
-			this.mode,
-			nodeType,
-			closeFunctions,
-		);
-
-		let credentials: ICredentialDataDecryptedObject | undefined;
-		if (credentialsDecrypted) {
-			credentials = credentialsDecrypted.data;
-		} else if (credentialType) {
-			credentials = (await executeFunctions.getCredentials(credentialType)) || {};
-		}
-
-		// TODO: Think about how batching could be handled for REST APIs which support it
-		for (let i = 0; i < items.length; i++) {
-			try {
-				const thisArgs = nodeExecuteFunctions.getExecuteSingleFunctions(
-					this.workflow,
-					this.runExecutionData,
-					runIndex,
-					this.connectionInputData,
-					inputData,
-					this.node,
-					i,
-					this.additionalData,
-					this.mode,
-				);
-
-				const requestData: IRequestOptionsFromParameters = {
-					options: {
-						qs: {},
-						body: {},
-					},
-					preSend: [],
-					postReceive: [],
-					requestOperations: {},
-				};
-
-				if (nodeType.description.requestOperations) {
-					requestData.requestOperations = { ...nodeType.description.requestOperations };
-				}
-
-				if (nodeType.description.requestDefaults) {
-					for (const key of Object.keys(nodeType.description.requestDefaults)) {
-						// eslint-disable-next-line @typescript-eslint/no-explicit-any
-						let value = (nodeType.description.requestDefaults as Record<string, any>)[key];
-						// If the value is an expression resolve it
-						value = this.getParameterValue(
-							value,
-							i,
-							runIndex,
-							{ $credentials: credentials },
-							true,
-						) as string;
-						// eslint-disable-next-line @typescript-eslint/no-explicit-any
-						(requestData.options as Record<string, any>)[key] = value;
-					}
-				}
-
-				for (const property of nodeType.description.properties) {
-					let value = get(this.node.parameters, property.name, []) as string | NodeParameterValue;
-					// If the value is an expression resolve it
-					value = this.getParameterValue(
-						value,
-						i,
-						runIndex,
-						{ $credentials: credentials },
-						true,
-					) as string | NodeParameterValue;
-
-					const tempOptions = this.getRequestOptionsFromParameters(
-						thisArgs,
-						property,
-						i,
-						runIndex,
-						'',
-						{ $credentials: credentials, $value: value },
-					);
-
-					this.mergeOptions(requestData, tempOptions);
-				}
-
-				// TODO: Change to handle some requests in parallel (should be configurable)
-				responseData = await this.makeRoutingRequest(
-					requestData,
-					thisArgs,
-					i,
-					runIndex,
-					credentialType,
-					requestData.requestOperations,
-					credentialsDecrypted,
-				);
-
-				if (requestData.maxResults) {
-					// Remove not needed items in case APIs return to many
-					responseData.splice(requestData.maxResults as number);
-				}
-
-				returnData.push(...responseData);
-			} catch (error: any) {
-				if (get(this.node, 'continueOnFail', false)) {
-					returnData.push({ json: {}, error: error.message });
-					continue;
-				}
-				
-				const closeFunctionsResults = await Promise.allSettled(
-					closeFunctions.map(async (fn) => await fn()),
-				);
-
-				const closingErrors = closeFunctionsResults
-					.filter((result): result is PromiseRejectedResult => result.status === 'rejected')
-					.map((result) => result.reason);
-
-				if (closingErrors.length > 0) {
-					if (closingErrors[0] instanceof Error) throw closingErrors[0];
-					throw new Error(`Error on execution node's close function(s). Node Name: ${this.node.name}, Node Type: ${this.node.type}, Errors: ${closingErrors.join(', ')}`);
-				}
-				
-				throw error;
-			}
-		}
-
-		const closeFunctionsResults = await Promise.allSettled(
-			closeFunctions.map(async (fn) => await fn()),
-		);
-
-		const closingErrors = closeFunctionsResults
-			.filter((result): result is PromiseRejectedResult => result.status === 'rejected')
-			.map((result) => result.reason);
-
-		if (closingErrors.length > 0) {
-			if (closingErrors[0] instanceof Error) throw closingErrors[0];
-			throw new Error(`Error on execution node's close function(s). Node Name: ${this.node.name}, Node Type: ${this.node.type}, Errors: ${closingErrors.join(', ')}`);
-		}
-
-		return [returnData];
-	}
-
-	mergeOptions(
-		destinationOptions: IRequestOptionsFromParameters,
-		sourceOptions?: IRequestOptionsFromParameters,
-	): void {
-		if (sourceOptions) {
-			destinationOptions.paginate = destinationOptions.paginate ?? sourceOptions.paginate;
-			destinationOptions.maxResults = sourceOptions.maxResults
-				? sourceOptions.maxResults
-				: destinationOptions.maxResults;
-			merge(destinationOptions.options, sourceOptions.options);
-			destinationOptions.preSend.push(...sourceOptions.preSend);
-			destinationOptions.postReceive.push(...sourceOptions.postReceive);
-			if (sourceOptions.requestOperations) {
-				destinationOptions.requestOperations = Object.assign(
-					destinationOptions.requestOperations || {},
-					sourceOptions.requestOperations || {},
-				);
-			}
-		}
-	}
-
-	async runPostReceiveAction(
-		executeSingleFunctions: IExecuteSingleFunctions,
-		action: PostReceiveAction,
-		inputData: INodeExecutionData[],
-		responseData: IN8nHttpFullResponse,
-		parameterValue: string | IDataObject | undefined,
-		itemIndex: number,
-		runIndex: number,
-	): Promise<INodeExecutionData[]> {
-		if (typeof action === 'function') {
-			return action.call(executeSingleFunctions, inputData, responseData);
-		}
-		if (action.type === 'rootProperty') {
-			try {
-				return inputData.flatMap((item) => {
-					// let itemContent = item.json[action.properties.property];
-					let itemContent = get(item.json, action.properties.property);
-
-					if (!Array.isArray(itemContent)) {
-						itemContent = [itemContent];
-					}
-					return (itemContent as IDataObject[]).map((json) => {
-						return {
-							json,
-						};
-					});
-				});
-			} catch (e) {
-				throw new Error(
-					// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-					`The rootProperty "${action.properties.property}" could not be found on item.`,
-				);
-			}
-		}
-		if (action.type === 'set') {
-			const { value } = action.properties;
-			// If the value is an expression resolve it
-			return [
-				{
-					json: this.getParameterValue(
-						value,
-						itemIndex,
-						runIndex,
-						{ $response: responseData, $value: parameterValue },
-						false,
-					) as IDataObject,
-				},
-			];
-		}
-		if (action.type === 'sort') {
-			// Sort the returned options
-			const sortKey = action.properties.key;
-			inputData.sort((a, b) => {
-				const aSortValue = a.json[sortKey]
-					? (a.json[sortKey]?.toString().toLowerCase() as string)
-					: '';
-				const bSortValue = b.json[sortKey]
-					? (b.json[sortKey]?.toString().toLowerCase() as string)
-					: '';
-				if (aSortValue < bSortValue) {
-					return -1;
-				}
-				if (aSortValue > bSortValue) {
-					return 1;
-				}
-				return 0;
-			});
-
-			return inputData;
-		}
-		if (action.type === 'setKeyValue') {
-			const returnData: INodeExecutionData[] = [];
-
-			// eslint-disable-next-line @typescript-eslint/no-loop-func
-			inputData.forEach((item) => {
-				const returnItem: IDataObject = {};
-				for (const key of Object.keys(action.properties)) {
-					let propertyValue = (
-						action.properties as Record<
-							string,
-							// eslint-disable-next-line @typescript-eslint/no-explicit-any
-							any
-						>
-					)[key];
-					// If the value is an expression resolve it
-					propertyValue = this.getParameterValue(
-						propertyValue,
-						itemIndex,
-						runIndex,
-						{
-							$response: responseData,
-							$responseItem: item.json,
-							$value: parameterValue,
-						},
-						true,
-					) as string;
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					(returnItem as Record<string, any>)[key] = propertyValue;
-				}
-				returnData.push({ json: returnItem });
-			});
-
-			return returnData;
-		}
-		if (action.type === 'binaryData') {
-			responseData.body = Buffer.from(responseData.body as string);
-			let { destinationProperty } = action.properties;
-
-			destinationProperty = this.getParameterValue(
-				destinationProperty,
-				itemIndex,
-				runIndex,
-				{ $response: responseData, $value: parameterValue },
-				false,
-			) as string;
-
-			const binaryData = await executeSingleFunctions.helpers['prepareBinaryData'](responseData.body);
-
-			return inputData.map((item) => {
-				if (typeof item.json === 'string') {
-					// By default is probably the binary data as string set, in this case remove it
-					item.json = {};
-				}
-
-				item.binary = {
-					[destinationProperty]: binaryData,
-				};
-
-				return item;
-			});
-		}
-
-		return [];
-	}
-
-	async rawRoutingRequest(
-		executeSingleFunctions: IExecuteSingleFunctions,
-		requestData: IRequestOptionsFromParameters,
-		itemIndex: number,
-		runIndex: number,
-		credentialType?: string,
-		credentialsDecrypted?: ICredentialsDecrypted,
-	): Promise<INodeExecutionData[]> {
-		let responseData: IN8nHttpFullResponse;
-		requestData.options.returnFullResponse = true;
-
-		if (credentialType) {
-			responseData = (await executeSingleFunctions.helpers.httpRequestWithAuthentication.call(
-				executeSingleFunctions,
-				credentialType,
-				requestData.options as IHttpRequestOptions,
-				{ credentialsDecrypted },
-			)) as IN8nHttpFullResponse;
-		} else {
-			responseData = (await executeSingleFunctions.helpers.httpRequest(
-				requestData.options as IHttpRequestOptions,
-			)) as IN8nHttpFullResponse;
-		}
-
-		let returnData: INodeExecutionData[] = [
-			{
-				json: responseData.body as IDataObject,
-			},
-		];
-
-		if (requestData.postReceive.length) {
-			// If postReceive functionality got defined execute all of them
-			for (const postReceiveMethod of requestData.postReceive) {
-				for (const action of postReceiveMethod.actions) {
-					returnData = await this.runPostReceiveAction(
-						executeSingleFunctions,
-						action,
-						returnData,
-						responseData,
-						postReceiveMethod.data.parameterValue,
-						itemIndex,
-						runIndex,
-					);
-				}
-			}
-		} else {
-			// No postReceive functionality got defined so simply add data as it is
-			// eslint-disable-next-line no-lonely-if
-			if (Array.isArray(responseData.body)) {
-				returnData = responseData.body.map((json) => {
-					return {
-						json,
-					} as INodeExecutionData;
-				});
-			} else {
-				returnData[0].json = responseData.body as IDataObject;
-			}
-		}
-
-		return returnData;
-	}
-
-	async makeRoutingRequest(
-		requestData: IRequestOptionsFromParameters,
-		executeSingleFunctions: IExecuteSingleFunctions,
-		itemIndex: number,
-		runIndex: number,
-		credentialType?: string,
-		requestOperations?: IN8nRequestOperations,
-		credentialsDecrypted?: ICredentialsDecrypted,
-	): Promise<INodeExecutionData[]> {
-		let responseData: INodeExecutionData[];
-		for (const preSendMethod of requestData.preSend) {
-			requestData.options = await preSendMethod.call(
-				executeSingleFunctions,
-				requestData.options as IHttpRequestOptions,
-			);
-		}
-
-		const executePaginationFunctions = {
-			...executeSingleFunctions,
-			makeRoutingRequest: async (requestOptions: IRequestOptionsFromParameters) => {
-				return this.rawRoutingRequest(
-					executeSingleFunctions,
-					requestOptions,
-					itemIndex,
-					runIndex,
-					credentialType,
-					credentialsDecrypted,
-				);
-			},
-		};
-
-		if (requestData.paginate && requestOperations?.pagination) {
-			// Has pagination
-
-			if (typeof requestOperations.pagination === 'function') {
-				// Pagination via function
-				responseData = await requestOperations.pagination.call(
-					executePaginationFunctions,
-					requestData,
-				);
-			} else {
-				// Pagination via JSON properties
-				const { properties } = requestOperations.pagination;
-				responseData = [];
-				if (!requestData.options.qs) {
-					requestData.options.qs = {};
-				}
-
-				// Different predefined pagination types
-				if (requestOperations.pagination.type === 'offset') {
-					const optionsType = properties.type === 'body' ? 'body' : 'qs';
-					if (properties.type === 'body' && !requestData.options.body) {
-						requestData.options.body = {};
-					}
-
-					(requestData.options[optionsType] as IDataObject)[properties.limitParameter] =
-						properties.pageSize;
-					(requestData.options[optionsType] as IDataObject)[properties.offsetParameter] = 0;
-					let tempResponseData: INodeExecutionData[];
-					do {
-						if (requestData?.maxResults) {
-							// Only request as many results as needed
-							const resultsMissing = (requestData?.maxResults as number) - responseData.length;
-							if (resultsMissing < 1) {
-								break;
-							}
-							(requestData.options[optionsType] as IDataObject)[properties.limitParameter] =
-								Math.min(properties.pageSize, resultsMissing);
-						}
-
-						tempResponseData = await this.rawRoutingRequest(
-							executeSingleFunctions,
-							requestData,
-							itemIndex,
-							runIndex,
-							credentialType,
-							credentialsDecrypted,
-						);
-
-						(requestData.options[optionsType] as IDataObject)[properties.offsetParameter] =
-							((requestData.options[optionsType] as IDataObject)[
-								properties.offsetParameter
-							] as number) + properties.pageSize;
-
-						if (properties.rootProperty) {
-							const tempResponseValue = get(tempResponseData[0].json, properties.rootProperty) as
-								| IDataObject[]
-								| undefined;
-							if (tempResponseValue === undefined) {
-								throw new Error(
-									`The rootProperty "${properties.rootProperty}" could not be found on item.`,
-								);
-							}
-
-							tempResponseData = tempResponseValue.map((item) => {
-								return {
-									json: item,
-								};
-							});
-						}
-
-						responseData.push(...tempResponseData);
-					} while (tempResponseData.length && tempResponseData.length === properties.pageSize);
-				}
-			}
-		} else {
-			// No pagination
-			responseData = await this.rawRoutingRequest(
-				executeSingleFunctions,
-				requestData,
-				itemIndex,
-				runIndex,
-				credentialType,
-				credentialsDecrypted,
-			);
-		}
-		return responseData;
-	}
-
-	getParameterValue(
-		parameterValue: NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[],
-		itemIndex: number,
-		runIndex: number,
-		additionalKeys?: IWorkflowDataProxyAdditionalKeys,
-		returnObjectAsString = false,
-	): NodeParameterValue | INodeParameters | NodeParameterValue[] | INodeParameters[] | string {
-		if (typeof parameterValue === 'string' && parameterValue.charAt(0) === '=') {
-			return this.workflow.expression.getParameterValue(
-				parameterValue,
-				this.runExecutionData ?? null,
-				runIndex,
-				itemIndex,
-				this.node.name,
-				this.connectionInputData,
-				this.mode,
-				additionalKeys ?? {},
-				returnObjectAsString,
-			);
-		}
-
-		return parameterValue;
-	}
-
-	getRequestOptionsFromParameters(
-		executeSingleFunctions: IExecuteSingleFunctions,
-		nodeProperties: INodeProperties | INodePropertyOptions,
-		itemIndex: number,
-		runIndex: number,
-		path: string,
-		additionalKeys?: IWorkflowDataProxyAdditionalKeys,
-	): IRequestOptionsFromParameters | undefined {
-		const returnData: IRequestOptionsFromParameters = {
-			options: {
-				qs: {},
-				body: {},
-			},
-			preSend: [],
-			postReceive: [],
-			requestOperations: {},
-		};
-		let basePath = path ? `${path}.` : '';
-
-		if (!NodeHelpers.displayParameter(this.node.parameters, nodeProperties, this.node.parameters)) {
-			return undefined;
-		}
-		if (nodeProperties.routing) {
-			let parameterValue: IDataObject | undefined;
-			if (basePath + nodeProperties.name && 'type' in nodeProperties) {
-				parameterValue = executeSingleFunctions.getNodeParameter(
-					basePath + nodeProperties.name,
-				) as IDataObject;
-			}
-
-			if (nodeProperties.routing.operations) {
-				returnData.requestOperations = { ...nodeProperties.routing.operations };
-			}
-
-			if (nodeProperties.routing.request) {
-				for (const key of Object.keys(nodeProperties.routing.request)) {
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					let propertyValue = (nodeProperties.routing.request as Record<string, any>)[key];
-					// If the value is an expression resolve it
-					propertyValue = this.getParameterValue(
-						propertyValue,
-						itemIndex,
-						runIndex,
-						{ ...additionalKeys, $value: parameterValue },
-						true,
-					) as string;
-					// eslint-disable-next-line @typescript-eslint/no-explicit-any
-					(returnData.options as Record<string, any>)[key] = propertyValue;
-				}
-			}
-
-			if (nodeProperties.routing.send) {
-				let propertyName = nodeProperties.routing.send.property;
-				if (propertyName !== undefined) {
-					// If the propertyName is an expression resolve it
-					propertyName = this.getParameterValue(
-						propertyName,
-						itemIndex,
-						runIndex,
-						additionalKeys,
-						true,
-					) as string;
-
-					let value = parameterValue;
-
-					if (nodeProperties.routing.send.value) {
-						const valueString = nodeProperties.routing.send.value;
-						// Special value got set
-						// If the valueString is an expression resolve it
-						value = this.getParameterValue(
-							valueString,
-							itemIndex,
-							runIndex,
-							{ ...additionalKeys, $value: value },
-							true,
-						) as IDataObject;
-					}
-
-					if (nodeProperties.routing.send.type === 'body') {
-						// Send in "body"
-						// eslint-disable-next-line no-lonely-if
-						if (nodeProperties.routing.send.propertyInDotNotation === false) {
-							// eslint-disable-next-line @typescript-eslint/no-explicit-any
-							(returnData.options.body as Record<string, any>)![propertyName] = value;
-						} else {
-							const keys = propertyName.split('.');
-							let obj = returnData.options.body as object;
-							while (keys.length > 1) {
-								const key = keys.shift()!;
-								if (!(key in obj)) {
-									(obj as any)[key] = {};
-								}
-								obj = (obj as any)[key];
-							}
-							(obj as any)[keys[0]] = value;
-						}
-					} else {
-						// Send in "query"
-						// eslint-disable-next-line no-lonely-if
-						if (nodeProperties.routing.send.propertyInDotNotation === false) {
-							returnData.options.qs![propertyName] = value;
-						} else {
-							const keys = propertyName.split('.');
-							let obj = returnData.options.qs as object;
-							while (keys.length > 1) {
-								const key = keys.shift()!;
-								if (!(key in obj)) {
-									(obj as any)[key] = {};
-								}
-								obj = (obj as any)[key];
-							}
-							(obj as any)[keys[0]] = value;
-						}
-					}
-				}
-
-				if (nodeProperties.routing.send.paginate !== undefined) {
-					let paginateValue = nodeProperties.routing.send.paginate;
-					if (typeof paginateValue === 'string' && paginateValue.charAt(0) === '=') {
-						// If the propertyName is an expression resolve it
-						paginateValue = this.getParameterValue(
-							paginateValue,
-							itemIndex,
-							runIndex,
-							{ ...additionalKeys, $value: parameterValue },
-							true,
-						) as string;
-					}
-
-					returnData.paginate = !!paginateValue;
-				}
-
-				if (nodeProperties.routing.send.preSend) {
-					returnData.preSend.push(...nodeProperties.routing.send.preSend);
-				}
-			}
-			if (nodeProperties.routing.output) {
-				if (nodeProperties.routing.output.maxResults !== undefined) {
-					let maxResultsValue = nodeProperties.routing.output.maxResults;
-					if (typeof maxResultsValue === 'string' && maxResultsValue.charAt(0) === '=') {
-						// If the propertyName is an expression resolve it
-						maxResultsValue = this.getParameterValue(
-							maxResultsValue,
-							itemIndex,
-							runIndex,
-							{ ...additionalKeys, $value: parameterValue },
-							true,
-						) as string;
-					}
-
-					returnData.maxResults = maxResultsValue;
-				}
-
-				if (nodeProperties.routing.output.postReceive) {
-					returnData.postReceive.push({
-						data: {
-							parameterValue,
-						},
-						actions: nodeProperties.routing.output.postReceive,
-					});
-				}
-			}
-		}
-
-		// Check if there are any child properties
-		if (!Object.prototype.hasOwnProperty.call(nodeProperties, 'options')) {
-			// There are none so nothing else to check
-			return returnData;
-		}
-
-		// Everything after this point can only be of type INodeProperties
-		nodeProperties = nodeProperties as INodeProperties;
-
-		// Check the child parameters
-		let value;
-		if (nodeProperties.type === 'options') {
-			const optionValue = NodeHelpers.getParameterValueByPath(
-				this.node.parameters,
-				nodeProperties.name,
-				basePath.slice(0, -1),
-			);
-
-			// Find the selected option
-			const selectedOption = (nodeProperties.options as INodePropertyOptions[]).filter(
-				(option) => option.value === optionValue,
-			);
-
-			if (selectedOption.length) {
-				// Check only if option is set and if of type INodeProperties
-				const tempOptions = this.getRequestOptionsFromParameters(
-					executeSingleFunctions,
-					selectedOption[0],
-					itemIndex,
-					runIndex,
-					`${basePath}${nodeProperties.name}`,
-					{ $value: optionValue },
-				);
-
-				this.mergeOptions(returnData, tempOptions);
-			}
-		} else if (nodeProperties.type === 'collection') {
-			value = NodeHelpers.getParameterValueByPath(
-				this.node.parameters,
-				nodeProperties.name,
-				basePath.slice(0, -1),
-			);
-
-			for (const propertyOption of nodeProperties.options as INodeProperties[]) {
-				if (
-					Object.keys(value as IDataObject).includes(propertyOption.name) &&
-					propertyOption.type !== undefined
-				) {
-					// Check only if option is set and if of type INodeProperties
-					const tempOptions = this.getRequestOptionsFromParameters(
-						executeSingleFunctions,
-						propertyOption,
-						itemIndex,
-						runIndex,
-						`${basePath}${nodeProperties.name}`,
-					);
-
-					this.mergeOptions(returnData, tempOptions);
-				}
-			}
-		} else if (nodeProperties.type === 'fixedCollection') {
-			basePath = `${basePath}${nodeProperties.name}.`;
-			for (const propertyOptions of nodeProperties.options as INodePropertyCollection[]) {
-				// Check if the option got set and if not skip it
-				value = NodeHelpers.getParameterValueByPath(
-					this.node.parameters,
-					propertyOptions.name,
-					basePath.slice(0, -1),
-				);
-
-				if (value === undefined) {
-					continue;
-				}
-
-				// Make sure that it is always an array to be able to use the same code for multi and single
-				if (!Array.isArray(value)) {
-					value = [value];
-				}
-
-				const loopBasePath = `${basePath}${propertyOptions.name}`;
-				for (let i = 0; i < (value as INodeParameters[]).length; i++) {
-					for (const option of propertyOptions.values) {
-						const tempOptions = this.getRequestOptionsFromParameters(
-							executeSingleFunctions,
-							option,
-							itemIndex,
-							runIndex,
-							nodeProperties.typeOptions?.multipleValues ? `${loopBasePath}[${i}]` : loopBasePath,
-							{ ...(additionalKeys || {}), $index: i, $parent: value[i] },
-						);
-
-						this.mergeOptions(returnData, tempOptions);
-					}
-				}
-			}
-		}
-
-		return returnData;
-	}
-}