n8n/packages/core/test/Helpers.ts

738 lines
21 KiB
TypeScript
Raw Normal View History

import { set } from 'lodash';
import {
ICredentialDataDecryptedObject,
ICredentialsHelper,
IDataObject,
2020-01-02 15:22:20 -08:00
IExecuteWorkflowInfo,
INodeExecutionData,
INodeParameters,
INodeType,
2019-08-09 03:19:28 -07:00
INodeTypeData,
2020-10-22 06:46:03 -07:00
INodeTypes,
IRun,
ITaskData,
2019-12-20 10:53:52 -08:00
IWorkflowBase,
IWorkflowExecuteAdditionalData,
NodeParameterValue,
2019-12-20 10:53:52 -08:00
WorkflowHooks,
} from 'n8n-workflow';
import {
Credentials,
IDeferredPromise,
IExecuteFunctions,
} from '../src';
export class CredentialsHelper extends ICredentialsHelper {
getDecrypted(name: string, type: string): ICredentialDataDecryptedObject {
return {};
}
getCredentials(name: string, type: string): Credentials {
return new Credentials('', '', [], '');
}
async updateCredentials(name: string, type: string, data: ICredentialDataDecryptedObject): Promise<void> {}
}
class NodeTypesClass implements INodeTypes {
2019-08-09 03:19:28 -07:00
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: ['main'],
outputs: ['main', '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': {
2019-08-09 03:19:28 -07:00
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',
},
2019-08-09 03:19:28 -07:00
inputs: ['main', 'main'],
outputs: ['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.',
},
2019-08-09 03:19:28 -07:00
{
displayName: 'Output Data',
name: 'output',
type: 'options',
displayOptions: {
show: {
mode: [
2020-10-22 06:46:03 -07:00
'passThrough',
2019-08-09 03:19:28 -07:00
],
},
},
2019-08-09 03:19:28 -07:00
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.',
},
2020-10-22 06:46:03 -07:00
],
2019-08-09 03:19:28 -07:00
},
async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
// const itemsInput2 = this.getInputData(1);
2019-08-09 03:19:28 -07:00
const returnData: INodeExecutionData[] = [];
2019-08-09 03:19:28 -07:00
const mode = this.getNodeParameter('mode', 0) as string;
2019-08-09 03:19:28 -07:00
if (mode === 'append') {
// Simply appends the data
for (let i = 0; i < 2; i++) {
returnData.push.apply(returnData, this.getInputData(i));
}
} else if (mode === 'passThrough') {
const output = this.getNodeParameter('output', 0) as string;
2019-08-09 03:19:28 -07:00
if (output === 'input1') {
returnData.push.apply(returnData, this.getInputData(0));
} else {
returnData.push.apply(returnData, this.getInputData(1));
}
} else if (mode === 'wait') {
returnData.push({ json: {} });
}
2019-08-09 03:19:28 -07:00
return [returnData];
2020-10-22 06:46:03 -07:00
},
2019-08-09 03:19:28 -07:00
},
},
'n8n-nodes-base.set': {
2019-08-09 03:19:28 -07:00
sourcePath: '',
type: {
description: {
displayName: 'Set',
name: 'set',
group: ['input'],
version: 1,
description: 'Sets a value',
defaults: {
name: 'Set',
color: '#0000FF',
},
2019-08-09 03:19:28 -07:00
inputs: ['main'],
outputs: ['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.',
},
2019-08-09 03:19:28 -07:00
{
displayName: 'Values to Set',
name: 'values',
placeholder: 'Add Value',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
2019-08-09 03:19:28 -07:00
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.',
},
],
},
2019-08-09 03:19:28 -07:00
{
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.',
},
2020-10-22 06:46:03 -07:00
],
2019-08-09 03:19:28 -07:00
},
{
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: `By default does dot-notation get used in property names..<br />
This means that "a.b" will set the property "b" underneath "a" so { "a": { "b": value} }.<br />
If that is not intended this can be deactivated, it will then set { "a.b": value } instead.
`,
},
2019-08-09 03:19:28 -07:00
],
},
2020-10-22 06:46:03 -07:00
],
2019-08-09 03:19:28 -07:00
},
execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
2019-08-09 03:19:28 -07:00
const items = this.getInputData();
if (items.length === 0) {
items.push({ json: {} });
}
2019-08-09 03:19:28 -07:00
const returnData: INodeExecutionData[] = [];
2019-08-09 03:19:28 -07:00
let item: INodeExecutionData;
let keepOnlySet: boolean;
2019-08-09 03:19:28 -07:00
for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
keepOnlySet = this.getNodeParameter('keepOnlySet', itemIndex, false) as boolean;
2019-08-09 03:19:28 -07:00
item = items[itemIndex];
const options = this.getNodeParameter('options', itemIndex, {}) as IDataObject;
2019-08-09 03:19:28 -07:00
const newItem: INodeExecutionData = {
json: {},
2019-08-09 03:19:28 -07:00
};
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);
}
});
2019-08-09 03:19:28 -07:00
// 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);
}
2019-08-09 03:19:28 -07:00
});
2019-08-09 03:19:28 -07:00
returnData.push(newItem);
}
return this.prepareOutputData(returnData);
2020-10-22 06:46:03 -07:00
},
2019-08-09 03:19:28 -07:00
},
},
'n8n-nodes-base.start': {
2019-08-09 03:19:28 -07:00
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'],
2020-10-22 06:46:03 -07:00
properties: [],
},
2019-08-09 03:19:28 -07:00
execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
const items = this.getInputData();
2019-08-09 03:19:28 -07:00
return this.prepareOutputData(items);
},
},
},
};
2019-08-09 03:19:28 -07:00
async init(nodeTypes: INodeTypeData): Promise<void> { }
getAll(): INodeType[] {
2019-08-09 03:19:28 -07:00
return Object.values(this.nodeTypes).map((data) => data.type);
}
getByName(nodeType: string): INodeType {
2019-08-09 03:19:28 -07:00
return this.nodeTypes[nodeType].type;
}
}
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 {
2019-12-20 10:53:52 -08:00
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 {
credentials: {},
credentialsHelper: new CredentialsHelper({}, ''),
2019-12-20 10:53:52 -08:00
hooks: new WorkflowHooks(hookFunctions, 'trigger', '1', workflowData),
2020-01-02 15:22:20 -08:00
executeWorkflow: async (workflowInfo: IExecuteWorkflowInfo): Promise<any> => {}, // tslint:disable-line:no-any
2019-12-20 10:53:52 -08:00
restApiUrl: '',
encryptionKey: 'test',
timezone: 'America/New_York',
webhookBaseUrl: 'webhook',
webhookTestBaseUrl: 'webhook-test',
};
}