@fsai-flow/core 0.0.1

package/tests/Helpers.ts

@@ -0,0 +1,808 @@
+/* eslint-disable @typescript-eslint/no-empty-function */
+import { set } from 'lodash';
+
+import {
+	ICredentialDataDecryptedObject,
+	ICredentialsHelper,
+	IDataObject,
+	IDeferredPromise,
+	IExecuteWorkflowInfo,
+	IHttpRequestOptions,
+	INodeCredentialsDetails,
+	INodeExecutionData,
+	INodeParameters,
+	INodeType,
+	INodeTypeData,
+	INodeTypes,
+	IRun,
+	ITaskData,
+	IWorkflowBase,
+	IWorkflowExecuteAdditionalData,
+	NodeConnectionTypes,
+	NodeHelpers,
+	NodeParameterValue,
+	WorkflowHooks,
+} from '@fsai-flow/workflow';
+
+import { Credentials, IExecuteFunctions } from '../src';
+
+export class CredentialsHelper extends ICredentialsHelper {
+	async authenticate(
+		credentials: ICredentialDataDecryptedObject,
+		typeName: string,
+		requestParams: IHttpRequestOptions,
+	): Promise<IHttpRequestOptions> {
+		return requestParams;
+	}
+
+	getParentTypes(name: string): string[] {
+		return [];
+	}
+
+	async getDecrypted(
+		nodeCredentials: INodeCredentialsDetails,
+		type: string,
+	): Promise<ICredentialDataDecryptedObject> {
+		return {};
+	}
+
+	async getCredentials(
+		nodeCredentials: INodeCredentialsDetails,
+		type: string,
+	): Promise<Credentials> {
+		return new Credentials({ id: null, name: '' }, '', [], '');
+	}
+
+	async updateCredentials(
+		nodeCredentials: INodeCredentialsDetails,
+		type: string,
+		data: ICredentialDataDecryptedObject,
+	// eslint-disable-next-line @typescript-eslint/no-empty-function
+	): Promise<void> {}
+}
+
+class NodeTypesClass implements INodeTypes {
+	nodeTypes: INodeTypeData = {
+		'n8n-nodes-base.if': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'If',
+					name: 'if',
+					group: ['transform'],
+					version: 1,
+					description: 'Splits a stream depending on defined compare operations.',
+					defaults: {
+						name: 'IF',
+						color: '#408000',
+					},
+					inputs: [NodeConnectionTypes.Main],
+					outputs: [NodeConnectionTypes.Main, NodeConnectionTypes.Main],
+					properties: [
+						{
+							displayName: 'Conditions',
+							name: 'conditions',
+							placeholder: 'Add Condition',
+							type: 'fixedCollection',
+							typeOptions: {
+								multipleValues: true,
+							},
+							description: 'The type of values to compare.',
+							default: {},
+							options: [
+								{
+									name: 'boolean',
+									displayName: 'Boolean',
+									values: [
+										{
+											displayName: 'Value 1',
+											name: 'value1',
+											type: 'boolean',
+											default: false,
+											description: 'The value to compare with the second one.',
+										},
+										{
+											displayName: 'Operation',
+											name: 'operation',
+											type: 'options',
+											options: [
+												{
+													name: 'Equal',
+													value: 'equal',
+												},
+												{
+													name: 'Not Equal',
+													value: 'notEqual',
+												},
+											],
+											default: 'equal',
+											description: 'Operation to decide where the the data should be mapped to.',
+										},
+										{
+											displayName: 'Value 2',
+											name: 'value2',
+											type: 'boolean',
+											default: false,
+											description: 'The value to compare with the first one.',
+										},
+									],
+								},
+								{
+									name: 'number',
+									displayName: 'Number',
+									values: [
+										{
+											displayName: 'Value 1',
+											name: 'value1',
+											type: 'number',
+											default: 0,
+											description: 'The value to compare with the second one.',
+										},
+										{
+											displayName: 'Operation',
+											name: 'operation',
+											type: 'options',
+											options: [
+												{
+													name: 'Smaller',
+													value: 'smaller',
+												},
+												{
+													name: 'Smaller Equal',
+													value: 'smallerEqual',
+												},
+												{
+													name: 'Equal',
+													value: 'equal',
+												},
+												{
+													name: 'Not Equal',
+													value: 'notEqual',
+												},
+												{
+													name: 'Larger',
+													value: 'larger',
+												},
+												{
+													name: 'Larger Equal',
+													value: 'largerEqual',
+												},
+												{
+													name: 'Is Empty',
+													value: 'isEmpty',
+												},
+											],
+											default: 'smaller',
+											description: 'Operation to decide where the the data should be mapped to.',
+										},
+										{
+											displayName: 'Value 2',
+											name: 'value2',
+											type: 'number',
+											displayOptions: {
+												hide: {
+													operation: ['isEmpty'],
+												},
+											},
+											default: 0,
+											description: 'The value to compare with the first one.',
+										},
+									],
+								},
+								{
+									name: 'string',
+									displayName: 'String',
+									values: [
+										{
+											displayName: 'Value 1',
+											name: 'value1',
+											type: 'string',
+											default: '',
+											description: 'The value to compare with the second one.',
+										},
+										{
+											displayName: 'Operation',
+											name: 'operation',
+											type: 'options',
+											options: [
+												{
+													name: 'Contains',
+													value: 'contains',
+												},
+												{
+													name: 'Ends With',
+													value: 'endsWith',
+												},
+												{
+													name: 'Equal',
+													value: 'equal',
+												},
+												{
+													name: 'Not Contains',
+													value: 'notContains',
+												},
+												{
+													name: 'Not Equal',
+													value: 'notEqual',
+												},
+												{
+													name: 'Regex',
+													value: 'regex',
+												},
+												{
+													name: 'Starts With',
+													value: 'startsWith',
+												},
+												{
+													name: 'Is Empty',
+													value: 'isEmpty',
+												},
+											],
+											default: 'equal',
+											description: 'Operation to decide where the the data should be mapped to.',
+										},
+										{
+											displayName: 'Value 2',
+											name: 'value2',
+											type: 'string',
+											displayOptions: {
+												hide: {
+													operation: ['isEmpty', 'regex'],
+												},
+											},
+											default: '',
+											description: 'The value to compare with the first one.',
+										},
+										{
+											displayName: 'Regex',
+											name: 'value2',
+											type: 'string',
+											displayOptions: {
+												show: {
+													operation: ['regex'],
+												},
+											},
+											default: '',
+											placeholder: '/text/i',
+											description: 'The regex which has to match.',
+										},
+									],
+								},
+							],
+						},
+						{
+							displayName: 'Combine',
+							name: 'combineOperation',
+							type: 'options',
+							options: [
+								{
+									name: 'ALL',
+									description: 'Only if all conditions are meet it goes into "true" branch.',
+									value: 'all',
+								},
+								{
+									name: 'ANY',
+									description: 'If any of the conditions is meet it goes into "true" branch.',
+									value: 'any',
+								},
+							],
+							default: 'all',
+							description:
+								'If multiple rules got set this settings decides if it is true as soon as ANY condition matches or only if ALL get meet.',
+						},
+					],
+				},
+				async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					const returnDataTrue: INodeExecutionData[] = [];
+					const returnDataFalse: INodeExecutionData[] = [];
+
+					const items = this.getInputData();
+
+					let item: INodeExecutionData;
+					let combineOperation: string;
+
+					// The compare operations
+					const compareOperationFunctions: {
+						[key: string]: (value1: NodeParameterValue, value2: NodeParameterValue) => boolean;
+					} = {
+						contains: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							(value1 || '').toString().includes((value2 || '').toString()),
+						notContains: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							!(value1 || '').toString().includes((value2 || '').toString()),
+						endsWith: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							(value1 as string).endsWith(value2 as string),
+						equal: (value1: NodeParameterValue, value2: NodeParameterValue) => value1 === value2,
+						notEqual: (value1: NodeParameterValue, value2: NodeParameterValue) => value1 !== value2,
+						larger: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							(value1 || 0) > (value2 || 0),
+						largerEqual: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							(value1 || 0) >= (value2 || 0),
+						smaller: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							(value1 || 0) < (value2 || 0),
+						smallerEqual: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							(value1 || 0) <= (value2 || 0),
+						startsWith: (value1: NodeParameterValue, value2: NodeParameterValue) =>
+							(value1 as string).startsWith(value2 as string),
+						isEmpty: (value1: NodeParameterValue) =>
+							[undefined, null, ''].includes(value1 as string),
+						regex: (value1: NodeParameterValue, value2: NodeParameterValue) => {
+							const regexMatch = (value2 || '')
+								.toString()
+								.match(new RegExp('^/(.*?)/([gimusy]*)$'));
+
+							let regex: RegExp;
+							if (!regexMatch) {
+								regex = new RegExp((value2 || '').toString());
+							} else if (regexMatch.length === 1) {
+								regex = new RegExp(regexMatch[1]);
+							} else {
+								regex = new RegExp(regexMatch[1], regexMatch[2]);
+							}
+
+							return !!(value1 || '').toString().match(regex);
+						},
+					};
+
+					// The different dataTypes to check the values in
+					const dataTypes = ['boolean', 'number', 'string'];
+
+					// Itterate over all items to check which ones should be output as via output "true" and
+					// which ones via output "false"
+					let dataType: string;
+					let compareOperationResult: boolean;
+					itemLoop: for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+						item = items[itemIndex];
+
+						let compareData: INodeParameters;
+
+						combineOperation = this.getNodeParameter('combineOperation', itemIndex) as string;
+
+						// Check all the values of the different dataTypes
+						for (dataType of dataTypes) {
+							// Check all the values of the current dataType
+							for (compareData of this.getNodeParameter(
+								`conditions.${dataType}`,
+								itemIndex,
+								[],
+							) as INodeParameters[]) {
+								// Check if the values passes
+								compareOperationResult = compareOperationFunctions[compareData['operation'] as string](
+									compareData['value1'] as NodeParameterValue,
+									compareData['value2'] as NodeParameterValue,
+								);
+
+								if (compareOperationResult === true && combineOperation === 'any') {
+									// If it passes and the operation is "any" we do not have to check any
+									// other ones as it should pass anyway. So go on with the next item.
+									returnDataTrue.push(item);
+									continue itemLoop;
+								} else if (compareOperationResult === false && combineOperation === 'all') {
+									// If it fails and the operation is "all" we do not have to check any
+									// other ones as it should be not pass anyway. So go on with the next item.
+									returnDataFalse.push(item);
+									continue itemLoop;
+								}
+							}
+						}
+
+						if (combineOperation === 'all') {
+							// If the operation is "all" it means the item did match all conditions
+							// so it passes.
+							returnDataTrue.push(item);
+						} else {
+							// If the operation is "any" it means the the item did not match any condition.
+							returnDataFalse.push(item);
+						}
+					}
+
+					return [returnDataTrue, returnDataFalse];
+				},
+			},
+		},
+		'n8n-nodes-base.merge': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'Merge',
+					name: 'merge',
+					icon: 'fa:clone',
+					group: ['transform'],
+					version: 1,
+					description: 'Merges data of multiple streams once data of both is available',
+					defaults: {
+						name: 'Merge',
+						color: '#00cc22',
+					},
+					inputs: [NodeConnectionTypes.Main, NodeConnectionTypes.Main],
+					outputs: [NodeConnectionTypes.Main],
+					properties: [
+						{
+							displayName: 'Mode',
+							name: 'mode',
+							type: 'options',
+							options: [
+								{
+									name: 'Append',
+									value: 'append',
+									description:
+										'Combines data of both inputs. The output will contain items of input 1 and input 2.',
+								},
+								{
+									name: 'Pass-through',
+									value: 'passThrough',
+									description:
+										'Passes through data of one input. The output will conain only items of the defined input.',
+								},
+								{
+									name: 'Wait',
+									value: 'wait',
+									description:
+										'Waits till data of both inputs is available and will then output a single empty item.',
+								},
+							],
+							default: 'append',
+							description:
+								'How data should be merged. If it should simply<br />be appended or merged depending on a property.',
+						},
+						{
+							displayName: 'Output Data',
+							name: 'output',
+							type: 'options',
+							displayOptions: {
+								show: {
+									mode: ['passThrough'],
+								},
+							},
+							options: [
+								{
+									name: 'Input 1',
+									value: 'input1',
+								},
+								{
+									name: 'Input 2',
+									value: 'input2',
+								},
+							],
+							default: 'input1',
+							description: 'Defines of which input the data should be used as output of node.',
+						},
+					],
+				},
+				async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					// const itemsInput2 = this.getInputData(1);
+
+					const returnData: INodeExecutionData[] = [];
+
+					const mode = this.getNodeParameter('mode', 0) as string;
+
+					if (mode === 'append') {
+						// Simply appends the data
+						for (let i = 0; i < 2; i++) {
+							// eslint-disable-next-line prefer-spread
+							returnData.push.apply(returnData, this.getInputData(i));
+						}
+					} else if (mode === 'passThrough') {
+						const output = this.getNodeParameter('output', 0) as string;
+
+						if (output === 'input1') {
+							// eslint-disable-next-line prefer-spread
+							returnData.push.apply(returnData, this.getInputData(0));
+						} else {
+							// eslint-disable-next-line prefer-spread
+							returnData.push.apply(returnData, this.getInputData(1));
+						}
+					} else if (mode === 'wait') {
+						returnData.push({ json: {} });
+					}
+
+					return [returnData];
+				},
+			},
+		},
+		'n8n-nodes-base.noOp': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'No Operation, do nothing',
+					name: 'noOp',
+					icon: 'fa:arrow-right',
+					group: ['organization'],
+					version: 1,
+					description: 'No Operation',
+					defaults: {
+						name: 'NoOp',
+						color: '#b0b0b0',
+					},
+					inputs: [NodeConnectionTypes.Main],
+					outputs: [NodeConnectionTypes.Main],
+					properties: [],
+				},
+				execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					const items = this.getInputData();
+					return this.prepareOutputData(items);
+				},
+			},
+		},
+		'n8n-nodes-base.set': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'Set',
+					name: 'set',
+					group: ['input'],
+					version: 1,
+					description: 'Sets a value',
+					defaults: {
+						name: 'Set',
+						color: '#0000FF',
+					},
+					inputs: [NodeConnectionTypes.Main],
+					outputs: [NodeConnectionTypes.Main],
+					properties: [
+						{
+							displayName: 'Keep Only Set',
+							name: 'keepOnlySet',
+							type: 'boolean',
+							default: false,
+							description:
+								'If only the values set on this node should be<br />kept and all others removed.',
+						},
+						{
+							displayName: 'Values to Set',
+							name: 'values',
+							placeholder: 'Add Value',
+							type: 'fixedCollection',
+							typeOptions: {
+								multipleValues: true,
+							},
+							description: 'The value to set.',
+							default: {},
+							options: [
+								{
+									name: 'boolean',
+									displayName: 'Boolean',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											description:
+												'Name of the property to write data to.<br />Supports dot-notation.<br />Example: "data.person[0].name"',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'boolean',
+											default: false,
+											description: 'The boolean value to write in the property.',
+										},
+									],
+								},
+								{
+									name: 'number',
+									displayName: 'Number',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											description:
+												'Name of the property to write data to.<br />Supports dot-notation.<br />Example: "data.person[0].name"',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'number',
+											default: 0,
+											description: 'The number value to write in the property.',
+										},
+									],
+								},
+								{
+									name: 'string',
+									displayName: 'String',
+									values: [
+										{
+											displayName: 'Name',
+											name: 'name',
+											type: 'string',
+											default: 'propertyName',
+											description:
+												'Name of the property to write data to.<br />Supports dot-notation.<br />Example: "data.person[0].name"',
+										},
+										{
+											displayName: 'Value',
+											name: 'value',
+											type: 'string',
+											default: '',
+											description: 'The string value to write in the property.',
+										},
+									],
+								},
+							],
+						},
+
+						{
+							displayName: 'Options',
+							name: 'options',
+							type: 'collection',
+							placeholder: 'Add Option',
+							default: {},
+							options: [
+								{
+									displayName: 'Dot Notation',
+									name: 'dotNotation',
+									type: 'boolean',
+									default: true,
+									description: `<p>By default, dot-notation is used in property names. This means that "a.b" will set the property "b" underneath "a" so { "a": { "b": value} }.</p><p>If that is not intended this can be deactivated, it will then set { "a.b": value } instead.</p>`,
+								},
+							],
+						},
+					],
+				},
+				execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					const items = this.getInputData();
+
+					if (items.length === 0) {
+						items.push({ json: {} });
+					}
+
+					const returnData: INodeExecutionData[] = [];
+
+					let item: INodeExecutionData;
+					let keepOnlySet: boolean;
+					for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+						keepOnlySet = this.getNodeParameter('keepOnlySet', itemIndex, false) as boolean;
+						item = items[itemIndex];
+						const options = this.getNodeParameter('options', itemIndex, {}) as IDataObject;
+
+						const newItem: INodeExecutionData = {
+							json: {},
+						};
+
+						if (keepOnlySet !== true) {
+							if (item.binary !== undefined) {
+								// Create a shallow copy of the binary data so that the old
+								// data references which do not get changed still stay behind
+								// but the incoming data does not get changed.
+								newItem.binary = {};
+								Object.assign(newItem.binary, item.binary);
+							}
+
+							newItem.json = JSON.parse(JSON.stringify(item.json));
+						}
+
+						// Add boolean values
+						(this.getNodeParameter('values.boolean', itemIndex, []) as INodeParameters[]).forEach(
+							(setItem) => {
+								if (options['dotNotation'] === false) {
+									newItem.json[setItem['name'] as string] = !!setItem['value'];
+								} else {
+									set(newItem.json, setItem['name'] as string, !!setItem['value']);
+								}
+							},
+						);
+
+						// Add number values
+						(this.getNodeParameter('values.number', itemIndex, []) as INodeParameters[]).forEach(
+							(setItem) => {
+								if (options['dotNotation'] === false) {
+									newItem.json[setItem['name'] as string] = setItem['value'];
+								} else {
+									set(newItem.json, setItem['name'] as string, setItem['value']);
+								}
+							},
+						);
+
+						// Add string values
+						(this.getNodeParameter('values.string', itemIndex, []) as INodeParameters[]).forEach(
+							(setItem) => {
+								if (options['dotNotation'] === false) {
+									newItem.json[setItem['name'] as string] = setItem['value'];
+								} else {
+									set(newItem.json, setItem['name'] as string, setItem['value']);
+								}
+							},
+						);
+
+						returnData.push(newItem);
+					}
+
+					return this.prepareOutputData(returnData);
+				},
+			},
+		},
+		'n8n-nodes-base.start': {
+			sourcePath: '',
+			type: {
+				description: {
+					displayName: 'Start',
+					name: 'start',
+					group: ['input'],
+					version: 1,
+					description: 'Starts the workflow execution from this node',
+					defaults: {
+						name: 'Start',
+						color: '#553399',
+					},
+					inputs: [],
+					outputs: ['main'],
+					properties: [],
+				},
+				execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+					const items = this.getInputData();
+
+					return this.prepareOutputData(items);
+				},
+			},
+		},
+	};
+
+	async init(nodeTypes: INodeTypeData): Promise<void> {}
+
+	getAll(): INodeType[] {
+		return Object.values(this.nodeTypes).map((data) => NodeHelpers.getVersionedNodeType(data.type));
+	}
+
+	getByName(nodeType: string): INodeType {
+		return this.getByNameAndVersion(nodeType);
+	}
+
+	getByNameAndVersion(nodeType: string, version?: number): INodeType {
+		return NodeHelpers.getVersionedNodeType(this.nodeTypes[nodeType].type, version);
+	}
+}
+
+let nodeTypesInstance: NodeTypesClass | undefined;
+
+export function NodeTypes(): NodeTypesClass {
+	if (nodeTypesInstance === undefined) {
+		nodeTypesInstance = new NodeTypesClass();
+		nodeTypesInstance.init({});
+	}
+
+	return nodeTypesInstance;
+}
+
+export function WorkflowExecuteAdditionalData(
+	waitPromise: IDeferredPromise<IRun>,
+	nodeExecutionOrder: string[],
+): IWorkflowExecuteAdditionalData {
+	const hookFunctions = {
+		nodeExecuteAfter: [
+			async (nodeName: string, data: ITaskData): Promise<void> => {
+				nodeExecutionOrder.push(nodeName);
+			},
+		],
+		workflowExecuteAfter: [
+			async (fullRunData: IRun): Promise<void> => {
+				waitPromise.resolve(fullRunData);
+			},
+		],
+	};
+
+	const workflowData: IWorkflowBase = {
+		name: '',
+		createdAt: new Date(),
+		updatedAt: new Date(),
+		active: true,
+		nodes: [],
+		connections: {},
+	};
+
+	return {
+		credentialsHelper: new CredentialsHelper(''),
+		hooks: new WorkflowHooks(hookFunctions, 'trigger', '1', workflowData),
+		executeWorkflow: async (workflowInfo: IExecuteWorkflowInfo): Promise<any> => {},
+		sendMessageToUI: (message: string) => {},
+		restApiUrl: '',
+		encryptionKey: 'test',
+		timezone: 'America/New_York',
+		webhookBaseUrl: 'webhook',
+		webhookWaitingBaseUrl: 'webhook-waiting',
+		webhookTestBaseUrl: 'webhook-test',
+		userId: '123',
+	};
+}