first commit

packages/nodes-base/nodes/EmailSend/v2/EmailSendV2.node.ts

@@ -0,0 +1,115 @@
+import type {
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeBaseDescription,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+import { NodeConnectionTypes, SEND_AND_WAIT_OPERATION } from 'n8n-workflow';
+
+import * as send from './send.operation';
+import * as sendAndWait from './sendAndWait.operation';
+import { smtpConnectionTest } from './utils';
+import { sendAndWaitWebhooksDescription } from '../../../utils/sendAndWait/descriptions';
+import {
+	SEND_AND_WAIT_WAITING_TOOLTIP,
+	sendAndWaitWebhook,
+} from '../../../utils/sendAndWait/utils';
+
+export const versionDescription: INodeTypeDescription = {
+	displayName: 'Send Email',
+	name: 'emailSend',
+	icon: 'fa:envelope',
+	group: ['output'],
+	version: [2, 2.1],
+	description: 'Sends an email using SMTP protocol',
+	defaults: {
+		name: 'Send Email',
+		color: '#00bb88',
+	},
+	inputs: [NodeConnectionTypes.Main],
+	outputs: [NodeConnectionTypes.Main],
+	usableAsTool: true,
+	credentials: [
+		{
+			name: 'smtp',
+			required: true,
+			testedBy: 'smtpConnectionTest',
+		},
+	],
+	waitingNodeTooltip: SEND_AND_WAIT_WAITING_TOOLTIP,
+	webhooks: sendAndWaitWebhooksDescription,
+	properties: [
+		{
+			displayName: 'Resource',
+			name: 'resource',
+			type: 'hidden',
+			noDataExpression: true,
+			default: 'email',
+			options: [
+				{
+					name: 'Email',
+					value: 'email',
+				},
+			],
+		},
+		{
+			displayName: 'Operation',
+			name: 'operation',
+			type: 'options',
+			noDataExpression: true,
+			default: 'send',
+			options: [
+				{
+					name: 'Send',
+					value: 'send',
+					action: 'Send an Email',
+				},
+				{
+					name: 'Send and Wait for Response',
+					value: SEND_AND_WAIT_OPERATION,
+					action: 'Send message and wait for response',
+				},
+			],
+			displayOptions: {
+				show: {
+					resource: ['email'],
+				},
+			},
+		},
+		...send.description,
+		...sendAndWait.description,
+	],
+};
+
+export class EmailSendV2 implements INodeType {
+	description: INodeTypeDescription;
+
+	constructor(baseDescription: INodeTypeBaseDescription) {
+		this.description = {
+			...baseDescription,
+			...versionDescription,
+		};
+	}
+
+	methods = {
+		credentialTest: { smtpConnectionTest },
+	};
+
+	webhook = sendAndWaitWebhook;
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		let returnData: INodeExecutionData[][] = [];
+		const operation = this.getNodeParameter('operation', 0);
+
+		if (operation === SEND_AND_WAIT_OPERATION) {
+			returnData = await sendAndWait.execute.call(this);
+		}
+
+		if (operation === 'send') {
+			returnData = await send.execute.call(this);
+		}
+
+		return returnData;
+	}
+}

packages/nodes-base/nodes/EmailSend/v2/descriptions.ts

@@ -0,0 +1,23 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const fromEmailProperty: INodeProperties = {
+	displayName: 'From Email',
+	name: 'fromEmail',
+	type: 'string',
+	default: '',
+	required: true,
+	placeholder: 'admin@example.com',
+	description:
+		'Email address of the sender. You can also specify a name: Nathan Doe <nate@n8n.io>.',
+};
+
+export const toEmailProperty: INodeProperties = {
+	displayName: 'To Email',
+	name: 'toEmail',
+	type: 'string',
+	default: '',
+	required: true,
+	placeholder: 'info@example.com',
+	description:
+		'Email address of the recipient. You can also specify a name: Nathan Doe <nate@n8n.io>.',
+};

packages/nodes-base/nodes/EmailSend/v2/send.operation.ts

@@ -0,0 +1,281 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+	JsonObject,
+} from 'n8n-workflow';
+import { NodeApiError } from 'n8n-workflow';
+
+import { createUtmCampaignLink, updateDisplayOptions } from '@utils/utilities';
+
+import { fromEmailProperty, toEmailProperty } from './descriptions';
+import { configureTransport, type EmailSendOptions } from './utils';
+import { appendAttributionOption } from '../../../utils/descriptions';
+import { prepareBinariesDataList } from '../../../utils/binary';
+
+const properties: INodeProperties[] = [
+	// TODO: Add choice for text as text or html  (maybe also from name)
+	fromEmailProperty,
+	toEmailProperty,
+
+	{
+		displayName: 'Subject',
+		name: 'subject',
+		type: 'string',
+		default: '',
+		placeholder: 'My subject line',
+		description: 'Subject line of the email',
+	},
+	{
+		displayName: 'Email Format',
+		name: 'emailFormat',
+		type: 'options',
+		options: [
+			{
+				name: 'Text',
+				value: 'text',
+				description: 'Send email as plain text',
+			},
+			{
+				name: 'HTML',
+				value: 'html',
+				description: 'Send email as HTML',
+			},
+			{
+				name: 'Both',
+				value: 'both',
+				description: "Send both formats, recipient's client selects version to display",
+			},
+		],
+		default: 'html',
+		displayOptions: {
+			hide: {
+				'@version': [2],
+			},
+		},
+	},
+	{
+		displayName: 'Email Format',
+		name: 'emailFormat',
+		type: 'options',
+		options: [
+			{
+				name: 'Text',
+				value: 'text',
+			},
+			{
+				name: 'HTML',
+				value: 'html',
+			},
+			{
+				name: 'Both',
+				value: 'both',
+			},
+		],
+		default: 'text',
+		displayOptions: {
+			show: {
+				'@version': [2],
+			},
+		},
+	},
+	{
+		displayName: 'Text',
+		name: 'text',
+		type: 'string',
+		typeOptions: {
+			rows: 5,
+		},
+		default: '',
+		description: 'Plain text message of email',
+		displayOptions: {
+			show: {
+				emailFormat: ['text', 'both'],
+			},
+		},
+	},
+	{
+		displayName: 'HTML',
+		name: 'html',
+		type: 'string',
+		typeOptions: {
+			rows: 5,
+		},
+		default: '',
+		description: 'HTML text message of email',
+		displayOptions: {
+			show: {
+				emailFormat: ['html', 'both'],
+			},
+		},
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		default: {},
+		options: [
+			{
+				...appendAttributionOption,
+				description:
+					'Whether to include the phrase “This email was sent automatically with n8n” to the end of the email',
+			},
+			{
+				displayName: 'Attachments',
+				name: 'attachments',
+				type: 'string',
+				default: '',
+				description:
+					'Name of the binary properties that contain data to add to email as attachment. Multiple ones can be comma-separated. Reference embedded images or other content within the body of an email message, e.g. <img src="cid:image_1">',
+			},
+			{
+				displayName: 'CC Email',
+				name: 'ccEmail',
+				type: 'string',
+				default: '',
+				placeholder: 'cc@example.com',
+				description: 'Email address of CC recipient',
+			},
+			{
+				displayName: 'BCC Email',
+				name: 'bccEmail',
+				type: 'string',
+				default: '',
+				placeholder: 'bcc@example.com',
+				description: 'Email address of BCC recipient',
+			},
+			{
+				displayName: 'Ignore SSL Issues (Insecure)',
+				name: 'allowUnauthorizedCerts',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to connect even if SSL certificate validation is not possible',
+			},
+			{
+				displayName: 'Reply To',
+				name: 'replyTo',
+				type: 'string',
+				default: '',
+				placeholder: 'info@example.com',
+				description: 'The email address to send the reply to',
+			},
+		],
+	},
+];
+
+const displayOptions = {
+	show: {
+		resource: ['email'],
+		operation: ['send'],
+	},
+};
+
+export const description = updateDisplayOptions(displayOptions, properties);
+
+export async function execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+	const items = this.getInputData();
+	const nodeVersion = this.getNode().typeVersion;
+	const instanceId = this.getInstanceId();
+	const credentials = await this.getCredentials('smtp');
+
+	const returnData: INodeExecutionData[] = [];
+	let item: INodeExecutionData;
+
+	for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+		try {
+			item = items[itemIndex];
+
+			const fromEmail = this.getNodeParameter('fromEmail', itemIndex) as string;
+			const toEmail = this.getNodeParameter('toEmail', itemIndex) as string;
+			const subject = this.getNodeParameter('subject', itemIndex) as string;
+			const emailFormat = this.getNodeParameter('emailFormat', itemIndex) as string;
+			const options = this.getNodeParameter('options', itemIndex, {}) as EmailSendOptions;
+
+			const transporter = configureTransport(credentials, options);
+
+			const mailOptions: IDataObject = {
+				from: fromEmail,
+				to: toEmail,
+				cc: options.ccEmail,
+				bcc: options.bccEmail,
+				subject,
+				replyTo: options.replyTo,
+			};
+
+			if (emailFormat === 'text' || emailFormat === 'both') {
+				mailOptions.text = this.getNodeParameter('text', itemIndex, '');
+			}
+
+			if (emailFormat === 'html' || emailFormat === 'both') {
+				mailOptions.html = this.getNodeParameter('html', itemIndex, '');
+			}
+
+			let appendAttribution = options.appendAttribution;
+			if (appendAttribution === undefined) {
+				appendAttribution = nodeVersion >= 2.1;
+			}
+
+			if (appendAttribution) {
+				const attributionText = 'This email was sent automatically with ';
+				const link = createUtmCampaignLink('n8n-nodes-base.emailSend', instanceId);
+				if (emailFormat === 'html' || (emailFormat === 'both' && mailOptions.html)) {
+					mailOptions.html = `
+					${mailOptions.html}
+					<br>
+					<br>
+					---
+					<br>
+					<em>${attributionText}<a href="${link}" target="_blank">n8n</a></em>
+					`;
+				} else {
+					mailOptions.text = `${mailOptions.text}\n\n---\n${attributionText}n8n\n${'https://n8n.io'}`;
+				}
+			}
+
+			if (options.attachments && item.binary) {
+				const attachments = [];
+				const attachmentProperties = prepareBinariesDataList(options.attachments);
+
+				for (const propertyName of attachmentProperties) {
+					const binaryData = this.helpers.assertBinaryData(itemIndex, propertyName);
+					attachments.push({
+						filename: binaryData.fileName || 'unknown',
+						content: await this.helpers.getBinaryDataBuffer(itemIndex, propertyName),
+						cid: propertyName,
+					});
+				}
+
+				if (attachments.length) {
+					mailOptions.attachments = attachments;
+				}
+			}
+
+			const info = await transporter.sendMail(mailOptions);
+
+			returnData.push({
+				json: info as unknown as IDataObject,
+				pairedItem: {
+					item: itemIndex,
+				},
+			});
+		} catch (error) {
+			if (this.continueOnFail()) {
+				returnData.push({
+					json: {
+						error: error.message,
+					},
+					pairedItem: {
+						item: itemIndex,
+					},
+				});
+				continue;
+			}
+			delete error.cert;
+			throw new NodeApiError(this.getNode(), error as JsonObject);
+		}
+	}
+
+	return [returnData];
+}

packages/nodes-base/nodes/EmailSend/v2/sendAndWait.operation.ts

@@ -0,0 +1,61 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeProperties,
+} from 'n8n-workflow';
+
+import { fromEmailProperty, toEmailProperty } from './descriptions';
+import { configureTransport } from './utils';
+import { configureWaitTillDate } from '../../../utils/sendAndWait/configureWaitTillDate.util';
+import {
+	createEmailBodyWithN8nAttribution,
+	createEmailBodyWithoutN8nAttribution,
+} from '../../../utils/sendAndWait/email-templates';
+import {
+	createButton,
+	getSendAndWaitConfig,
+	getSendAndWaitProperties,
+} from '../../../utils/sendAndWait/utils';
+
+export const description: INodeProperties[] = getSendAndWaitProperties(
+	[fromEmailProperty, toEmailProperty],
+	'email',
+);
+
+export async function execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+	const fromEmail = this.getNodeParameter('fromEmail', 0) as string;
+	const toEmail = this.getNodeParameter('toEmail', 0) as string;
+
+	const config = getSendAndWaitConfig(this);
+	const buttons: string[] = [];
+	for (const option of config.options) {
+		buttons.push(createButton(option.url, option.label, option.style));
+	}
+
+	let htmlBody: string;
+
+	if (config.appendAttribution !== false) {
+		const instanceId = this.getInstanceId();
+		htmlBody = createEmailBodyWithN8nAttribution(config.message, buttons.join('\n'), instanceId);
+	} else {
+		htmlBody = createEmailBodyWithoutN8nAttribution(config.message, buttons.join('\n'));
+	}
+
+	const mailOptions: IDataObject = {
+		from: fromEmail,
+		to: toEmail,
+		subject: config.title,
+		html: htmlBody,
+	};
+
+	const credentials = await this.getCredentials('smtp');
+	const transporter = configureTransport(credentials, {});
+
+	await transporter.sendMail(mailOptions);
+
+	const waitTill = configureWaitTillDate(this);
+
+	await this.putExecutionToWait(waitTill);
+	return [this.getInputData()];
+}

packages/nodes-base/nodes/EmailSend/v2/utils.ts

@@ -0,0 +1,70 @@
+import type {
+	IDataObject,
+	ICredentialsDecrypted,
+	ICredentialTestFunctions,
+	INodeCredentialTestResult,
+} from 'n8n-workflow';
+import { createTransport } from 'nodemailer';
+import type SMTPTransport from 'nodemailer/lib/smtp-transport';
+
+export type EmailSendOptions = {
+	appendAttribution?: boolean;
+	allowUnauthorizedCerts?: boolean;
+	attachments?: string;
+	ccEmail?: string;
+	bccEmail?: string;
+	replyTo?: string;
+};
+
+export function configureTransport(credentials: IDataObject, options: EmailSendOptions) {
+	const connectionOptions: SMTPTransport.Options = {
+		host: credentials.host as string,
+		port: credentials.port as number,
+		secure: credentials.secure as boolean,
+	};
+
+	if (credentials.secure === false) {
+		connectionOptions.ignoreTLS = credentials.disableStartTls as boolean;
+	}
+
+	if (typeof credentials.hostName === 'string' && credentials.hostName) {
+		connectionOptions.name = credentials.hostName;
+	}
+
+	if (credentials.user || credentials.password) {
+		connectionOptions.auth = {
+			user: credentials.user as string,
+			pass: credentials.password as string,
+		};
+	}
+
+	if (options.allowUnauthorizedCerts === true) {
+		connectionOptions.tls = {
+			rejectUnauthorized: false,
+		};
+	}
+
+	return createTransport(connectionOptions);
+}
+
+export async function smtpConnectionTest(
+	this: ICredentialTestFunctions,
+	credential: ICredentialsDecrypted,
+): Promise<INodeCredentialTestResult> {
+	const credentials = credential.data!;
+	const transporter = configureTransport(credentials, {});
+	try {
+		await transporter.verify();
+		return {
+			status: 'OK',
+			message: 'Connection successful!',
+		};
+	} catch (error) {
+		return {
+			status: 'Error',
+			message: error.message,
+		};
+	} finally {
+		transporter.close();
+	}
+}