n8n/packages/nodes-base/nodes/ExecuteWorkflowTrigger/ExecuteWorkflowTrigger.node.ts

import {
	type INodeExecutionData,
	NodeConnectionType,
	NodeOperationError,
	type IExecuteFunctions,
	type INodeType,
	type INodeTypeDescription,
} from 'n8n-workflow';

const INPUT_SOURCE = 'inputSource';
const FIELDS = 'fields';
const WORKFLOW_INPUTS = 'workflowInputs';
const VALUES = 'values';

function hasFields(context: IExecuteFunctions, index: number): boolean {
	const inputSource = context.getNodeParameter(INPUT_SOURCE, index) as string;
	if (inputSource === FIELDS) {
		const fields = context.getNodeParameter(`${WORKFLOW_INPUTS}.${VALUES}`, index, []) as Array<{
			name: string;
		}>;
		return fields.length > 0;
	} else {
		return false;
	}
}

function parseJson(
	context: IExecuteFunctions,
	index: number,
): Array<{
	name: string;
}> {
	return [{ name: 'dummy' }];
}

function getSchema(
	context: IExecuteFunctions,
	index: number,
): Array<{
	name: string;
}> {
	const inputSource = context.getNodeParameter(INPUT_SOURCE, index) as string;
	if (inputSource === FIELDS) {
		const fields = context.getNodeParameter(`${WORKFLOW_INPUTS}.${VALUES}`, index, []) as Array<{
			name: string;
		}>;
		return fields;
	} else {
		return parseJson(context, index);
	}
}

export class ExecuteWorkflowTrigger implements INodeType {
	description: INodeTypeDescription = {
		displayName: 'Execute Workflow Trigger',
		name: 'executeWorkflowTrigger',
		icon: 'fa:sign-out-alt',
		group: ['trigger'],
		version: [1, 1.1],
		description:
			'Helpers for calling other n8n workflows. Used for designing modular, microservice-like workflows.',
		eventTriggerDescription: '',
		maxNodes: 1,
		defaults: {
			name: 'Workflow Input Trigger',
			color: '#ff6d5a',
		},
		inputs: [],
		outputs: [NodeConnectionType.Main],
		properties: [
			{
				displayName:
					"When an ‘execute workflow’ node calls this workflow, the execution starts here. Any data passed into the 'execute workflow' node will be output by this node.",
				name: 'notice',
				type: 'notice',
				default: '',
			},
			{
				displayName: 'Events',
				name: 'events',
				type: 'hidden',
				noDataExpression: true,
				options: [
					{
						name: 'Workflow Call',
						value: 'worklfow_call',
						description: 'When called by another workflow using Execute Workflow Trigger',
						action: 'When Called by Another Workflow',
					},
				],
				default: 'worklfow_call',
			},
			{
				displayName: 'Input Source',
				name: 'inputSource',
				type: 'options',
				options: [
					{
						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
						name: 'Using fields below',
						value: FIELDS,
						description: 'Provide via UI',
					},
					{
						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
						name: 'Using JSON',
						value: 'json',
						description: 'Provide via JSON schema',
					},
				],
				default: FIELDS,
			},
			{
				displayName: 'Workflow Inputs',
				name: WORKFLOW_INPUTS,
				placeholder: 'Add Field',
				type: 'fixedCollection',
				description:
					'Define expected input fields. If no inputs are provided, all data from the calling workflow will be passed through.',
				typeOptions: {
					multipleValues: true,
					sortable: true,
				},
				displayOptions: {
					show: { '@version': [{ _cnd: { gte: 1.1 } }], inputSource: [FIELDS] },
				},
				default: {},
				options: [
					{
						name: VALUES,
						displayName: 'Values',
						values: [
							{
								displayName: 'Name',
								name: 'name',
								type: 'string',
								default: '',
								placeholder: 'e.g. fieldName',
								description: 'Name of the field',
								noDataExpression: true,
							},
							// {
							// 	displayName: 'Type',
							// 	name: 'type',
							// 	type: 'options',
							// 	description: 'The field value type',
							// 	// eslint-disable-next-line n8n-nodes-base/node-param-options-type-unsorted-items
							// 	options: [
							// 		{
							// 			name: 'String',
							// 			value: 'stringValue',
							// 		},
							// 		{
							// 			name: 'Number',
							// 			value: 'numberValue',
							// 		},
							// 		{
							// 			name: 'Boolean',
							// 			value: 'booleanValue',
							// 		},
							// 		{
							// 			name: 'Array',
							// 			value: 'arrayValue',
							// 		},
							// 		{
							// 			name: 'Object',
							// 			value: 'objectValue',
							// 		},
							// 	],
							// 	default: 'stringValue',
							// },
						],
					},
				],
			},
		],
	};

	async execute(this: IExecuteFunctions) {
		const inputData = this.getInputData();

		if (this.getNode().typeVersion < 1.1) {
			return [inputData];
		} else {
			if (!hasFields(this, 0)) {
				return [inputData];
			}

			const items: INodeExecutionData[] = [];

			for (const [itemIndex, item] of inputData.entries()) {
				// Fields listed here will explicitly overwrite original fields
				const newItem: INodeExecutionData = {
					json: {},
					// TODO: Ensure we handle sub-execution jumps correctly.
					// metadata: {
					// 	subExecution: {
					// 		executionId: 'uhh',
					// 		workflowId: 'maybe?',
					// 	},
					// },
					pairedItem: { item: itemIndex },
				};
				try {
					const newParams = getSchema(this, itemIndex);

					for (const { name } of newParams) {
						/** TODO type check goes here */
						newItem.json[name] = name in item.json ? item.json[name] : /* TODO default */ null;
					}

					// TODO Do we want to copy non-json data (e.g. binary) as well?
					items.push(Object.assign({}, item, newItem));
				} catch (error) {
					if (this.continueOnFail()) {
						/** todo error case? */
					} else {
						throw new NodeOperationError(this.getNode(), error, {
							itemIndex,
						});
					}
				}
			}

			return [items];
		}
	}
}