n8n-nodes-gmail-custom 0.1.1

package/nodes/GmailCustom/GmailCustom.node.js

@@ -0,0 +1,474 @@
+const crypto = require('crypto');
+
+const TOKEN_CACHE = {};
+
+function formatPrivateKey(privateKey) {
+	if (privateKey.includes('\\n')) {
+		return privateKey.replace(/\\n/g, '\n');
+	}
+	return privateKey;
+}
+
+function base64UrlEncode(str) {
+	return Buffer.from(str)
+		.toString('base64')
+		.replace(/=/g, '')
+		.replace(/\+/g, '-')
+		.replace(/\//g, '_');
+}
+
+function base64urlEscape(base64) {
+	return base64.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+
+function generateBoundary() {
+	return '----=_Part_' + crypto.randomBytes(16).toString('hex');
+}
+
+async function buildMimeMessage(options) {
+	let MailComposer;
+	try {
+		MailComposer = require('nodemailer/lib/mail-composer');
+	} catch (e) {
+	}
+
+	if (MailComposer) {
+		const mailOptions = {
+			from: options.from || undefined,
+			to: options.to || undefined,
+			cc: options.cc || undefined,
+			bcc: options.bcc || undefined,
+			replyTo: options.replyTo || undefined,
+			subject: options.subject || '',
+			text: options.textBody || '',
+			keepBcc: true,
+		};
+
+		if (options.htmlBody) {
+			mailOptions.html = options.htmlBody;
+		}
+
+		if (options.attachments && options.attachments.length > 0) {
+			mailOptions.attachments = options.attachments.map((att) => ({
+				filename: att.fileName || 'attachment',
+				content: att.content,
+				contentType: att.mimeType || 'application/octet-stream',
+				encoding: 'base64',
+			}));
+		}
+
+		const mail = new MailComposer(mailOptions).compile();
+		mail.keepBcc = true;
+		const mailBody = await mail.build();
+		return mailBody.toString('base64')
+			.replace(/\+/g, '-')
+			.replace(/\//g, '_')
+			.replace(/=+$/, '');
+	}
+
+	const hasAttachments = options.attachments && options.attachments.length > 0;
+	const hasHtml = !!options.htmlBody;
+	const from = options.from || '';
+	const to = options.to || '';
+	const cc = options.cc || '';
+	const bcc = options.bcc || '';
+	const replyTo = options.replyTo || '';
+	const subject = options.subject || '';
+	const textBody = options.textBody || '';
+	const htmlBody = options.htmlBody || '';
+
+	const boundaryMixed = generateBoundary();
+	const boundaryAlt = generateBoundary();
+	const lines = [];
+
+	if (from) lines.push(`From: ${from}`);
+	if (to) lines.push(`To: ${to}`);
+	if (cc) lines.push(`CC: ${cc}`);
+	if (bcc) lines.push(`BCC: ${bcc}`);
+	if (replyTo) lines.push(`Reply-To: ${replyTo}`);
+	lines.push(`Subject: ${subject}`);
+	lines.push('MIME-Version: 1.0');
+
+	if (hasAttachments) {
+		lines.push(`Content-Type: multipart/mixed; boundary="${boundaryMixed}"`);
+		lines.push('');
+		lines.push(`--${boundaryMixed}`);
+		if (hasHtml) {
+			lines.push(`Content-Type: multipart/alternative; boundary="${boundaryAlt}"`);
+			lines.push('');
+			lines.push(`--${boundaryAlt}`);
+			lines.push('Content-Type: text/plain; charset="UTF-8"');
+			lines.push('Content-Transfer-Encoding: 7bit');
+			lines.push('');
+			lines.push(textBody);
+			lines.push('');
+			lines.push(`--${boundaryAlt}`);
+			lines.push('Content-Type: text/html; charset="UTF-8"');
+			lines.push('Content-Transfer-Encoding: 7bit');
+			lines.push('');
+			lines.push(htmlBody);
+			lines.push('');
+			lines.push(`--${boundaryAlt}--`);
+		} else {
+			lines.push('Content-Type: text/plain; charset="UTF-8"');
+			lines.push('Content-Transfer-Encoding: 7bit');
+			lines.push('');
+			lines.push(textBody);
+		}
+		lines.push('');
+		for (const att of options.attachments) {
+			lines.push(`--${boundaryMixed}`);
+			lines.push(`Content-Type: ${att.mimeType || 'application/octet-stream'}; name="${att.fileName}"`);
+			lines.push('Content-Transfer-Encoding: base64');
+			lines.push(`Content-Disposition: attachment; filename="${att.fileName}"`);
+			lines.push('');
+			const base64Data = typeof att.content === 'string' ? att.content : att.content.toString('base64');
+			const lines64 = base64Data.match(/.{1,76}/g) || [''];
+			lines.push(lines64.join('\r\n'));
+		}
+		lines.push(`--${boundaryMixed}--`);
+	} else if (hasHtml) {
+		lines.push(`Content-Type: multipart/alternative; boundary="${boundaryAlt}"`);
+		lines.push('');
+		lines.push(`--${boundaryAlt}`);
+		lines.push('Content-Type: text/plain; charset="UTF-8"');
+		lines.push('Content-Transfer-Encoding: 7bit');
+		lines.push('');
+		lines.push(textBody);
+		lines.push('');
+		lines.push(`--${boundaryAlt}`);
+		lines.push('Content-Type: text/html; charset="UTF-8"');
+		lines.push('Content-Transfer-Encoding: 7bit');
+		lines.push('');
+		lines.push(htmlBody);
+		lines.push('');
+		lines.push(`--${boundaryAlt}--`);
+	} else {
+		lines.push('Content-Type: text/plain; charset="UTF-8"');
+		lines.push('Content-Transfer-Encoding: 7bit');
+		lines.push('');
+		lines.push(textBody);
+	}
+
+	const rawMessage = lines.join('\r\n');
+	return Buffer.from(rawMessage, 'utf-8')
+		.toString('base64')
+		.replace(/\+/g, '-')
+		.replace(/\//g, '_')
+		.replace(/=+$/, '');
+}
+
+class GmailCustom {
+
+	constructor() {
+		this.description = {
+			displayName: 'Gmail Custom',
+			name: 'gmailCustom',
+			icon: 'fa:envelope',
+			group: ['output'],
+			version: 1,
+			subtitle: '={{$parameter["subject"] || "Send Email"}}',
+			description: 'Send email via Gmail API with token caching and 429 retry',
+			defaults: {
+				name: 'Gmail Custom',
+				color: '#1a73e8',
+			},
+			inputs: ['main'],
+			outputs: ['main'],
+			credentials: [
+				{
+					name: 'googleApi',
+					required: true,
+				},
+			],
+			properties: [
+				{
+					displayName: 'From Email',
+					name: 'fromEmail',
+					type: 'string',
+					default: '',
+					required: true,
+					placeholder: 'name@domain.com',
+					description: 'Email address of the sender (must have Google Workspace account with domain-wide delegation)',
+				},
+				{
+					displayName: 'To',
+					name: 'sendTo',
+					type: 'string',
+					default: '',
+					required: true,
+					placeholder: 'info@example.com',
+					description: 'The email addresses of the recipients. Multiple addresses can be separated by a comma.',
+				},
+				{
+					displayName: 'Subject',
+					name: 'subject',
+					type: 'string',
+					default: '',
+					required: true,
+					placeholder: 'Hello World!',
+				},
+				{
+					displayName: 'Email Type',
+					name: 'emailType',
+					type: 'options',
+					default: 'html',
+					required: true,
+					noDataExpression: true,
+					options: [
+						{ name: 'Text', value: 'text' },
+						{ name: 'HTML', value: 'html' },
+					],
+				},
+				{
+					displayName: 'Message',
+					name: 'message',
+					type: 'string',
+					default: '',
+					required: true,
+					typeOptions: {
+						rows: 8,
+					},
+				},
+				{
+					displayName: 'Options',
+					name: 'options',
+					type: 'collection',
+					placeholder: 'Add option',
+					default: {},
+					options: [
+						{
+							displayName: 'Attachments',
+							name: 'attachmentsUi',
+							placeholder: 'Add Attachment',
+							type: 'fixedCollection',
+							typeOptions: {
+								multipleValues: true,
+							},
+							options: [
+								{
+									name: 'attachmentsBinary',
+									displayName: 'Attachment Binary',
+									values: [
+										{
+											displayName: 'Attachment Field Name',
+											name: 'property',
+											type: 'string',
+											default: 'data',
+											description: 'Add the field name from the input node. Multiple properties can be set separated by comma.',
+											hint: 'The name of the field with the attachment in the node input',
+										},
+									],
+								},
+							],
+							default: {},
+							description: 'Array of supported attachments to add to the message',
+						},
+						{
+							displayName: 'BCC',
+							name: 'bccList',
+							type: 'string',
+							description: 'The email addresses of the blind copy recipients. Multiple addresses can be separated by a comma.',
+							placeholder: 'info@example.com',
+							default: '',
+						},
+						{
+							displayName: 'CC',
+							name: 'ccList',
+							type: 'string',
+							description: 'The email addresses of the copy recipients. Multiple addresses can be separated by a comma.',
+							placeholder: 'info@example.com',
+							default: '',
+						},
+						{
+							displayName: 'Send Replies To',
+							name: 'replyTo',
+							type: 'string',
+							placeholder: 'reply@example.com',
+							default: '',
+							description: 'The email address that the reply message is sent to',
+						},
+						{
+							displayName: 'Append n8n Attribution',
+							name: 'appendAttribution',
+							type: 'boolean',
+							default: true,
+							description: 'Whether to include the phrase "This email was sent automatically with n8n" to the end of the email',
+						},
+					],
+				},
+			],
+		};
+	}
+
+	async execute() {
+		const items = this.getInputData();
+		const returnData = [];
+
+		for (let i = 0; i < items.length; i++) {
+			try {
+				const fromEmail = this.getNodeParameter('fromEmail', i, '');
+				const sendTo = this.getNodeParameter('sendTo', i, '');
+				const subject = this.getNodeParameter('subject', i, '');
+				const emailType = this.getNodeParameter('emailType', i, 'html');
+				const message = this.getNodeParameter('message', i, '');
+				const options = this.getNodeParameter('options', i, {});
+
+				if (!fromEmail) throw new Error('From Email is required');
+				if (!sendTo) throw new Error('To is required');
+				if (!subject) throw new Error('Subject is required');
+				if (!message) throw new Error('Message is required');
+
+				let cc = options.ccList || '';
+				let bcc = options.bccList || '';
+				let replyTo = options.replyTo || '';
+				const appendAttribution = options.appendAttribution === undefined ? true : options.appendAttribution;
+
+				let bodyText = message;
+				let bodyHtml = '';
+
+				if (emailType === 'html') {
+					bodyHtml = message;
+					bodyText = message.replace(/<[^>]*>/g, '').replace(/\n\s*\n/g, '\n').trim();
+					if (!bodyText) bodyText = '';
+				} else {
+					bodyText = message;
+				}
+
+				if (appendAttribution) {
+					const attributionText = '\n\n---\nThis email was sent automatically with n8n';
+					if (emailType === 'html') {
+						bodyHtml += '<br><br>---<br><em>This email was sent automatically with n8n</em>';
+					} else {
+						bodyText += attributionText;
+					}
+				}
+
+				const credentials = await this.getCredentials('googleApi');
+				const cacheKey = `${credentials.email}:${fromEmail}`;
+				let accessToken;
+				let expiresAt = 0;
+
+				if (TOKEN_CACHE[cacheKey]) {
+					expiresAt = TOKEN_CACHE[cacheKey].expiresAt;
+					accessToken = TOKEN_CACHE[cacheKey].accessToken;
+				}
+
+				if (!accessToken || Date.now() >= expiresAt) {
+					const privateKey = formatPrivateKey(credentials.privateKey);
+					const now = Math.floor(Date.now() / 1000);
+					const header = { alg: 'RS256', typ: 'JWT' };
+					const payload = {
+						iss: credentials.email,
+						scope: 'https://mail.google.com/',
+						aud: 'https://oauth2.googleapis.com/token',
+						exp: now + 3600,
+						iat: now,
+						sub: fromEmail,
+					};
+
+					const signatureInput = base64UrlEncode(JSON.stringify(header)) + '.' + base64UrlEncode(JSON.stringify(payload));
+					const signer = crypto.createSign('RSA-SHA256');
+					signer.update(signatureInput);
+					const sig = signer.sign(privateKey);
+					const jwt = signatureInput + '.' + base64urlEscape(sig.toString('base64'));
+
+					const response = await this.helpers.httpRequest({
+						method: 'POST',
+						url: 'https://oauth2.googleapis.com/token',
+						headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+						body: new URLSearchParams({
+							grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+							assertion: jwt,
+						}).toString(),
+					});
+
+					accessToken = response.access_token;
+					TOKEN_CACHE[cacheKey] = {
+						accessToken,
+						expiresAt: Date.now() + 3500 * 1000,
+					};
+				}
+
+				let attachments = [];
+				if (options.attachmentsUi && options.attachmentsUi.attachmentsBinary) {
+					for (const { property } of options.attachmentsUi.attachmentsBinary) {
+						for (const name of property.split(',')) {
+							const binaryData = this.helpers.assertBinaryData(i, name.trim());
+							const binaryDataBuffer = await this.helpers.getBinaryDataBuffer(i, name.trim());
+							attachments.push({
+								fileName: binaryData.fileName || 'attachment',
+								mimeType: binaryData.mimeType || 'application/octet-stream',
+								content: binaryDataBuffer,
+							});
+						}
+					}
+				}
+
+				const base64UrlMessage = await buildMimeMessage({
+					from: fromEmail,
+					to: sendTo,
+					cc,
+					bcc,
+					replyTo,
+					subject,
+					textBody: bodyText,
+					htmlBody: bodyHtml,
+					attachments,
+				});
+
+				const maxRetries = 4;
+				let lastError;
+
+				for (let attempt = 0; attempt <= maxRetries; attempt++) {
+					try {
+						const sendResponse = await this.helpers.httpRequest({
+							method: 'POST',
+							url: 'https://gmail.googleapis.com/gmail/v1/users/me/messages/send',
+							headers: {
+								Authorization: `Bearer ${accessToken}`,
+								'Content-Type': 'application/json',
+							},
+							body: { raw: base64UrlMessage },
+						});
+
+						returnData.push({
+							json: sendResponse,
+							pairedItem: { item: i },
+						});
+						lastError = null;
+						break;
+					} catch (error) {
+						lastError = error;
+						const statusCode = error.statusCode || error.response?.statusCode;
+						if (statusCode === 429 && attempt < maxRetries) {
+							const delay = Math.min(Math.pow(2, attempt) * 1000 + Math.random() * 1000, 30000);
+							await new Promise(resolve => setTimeout(resolve, delay));
+							continue;
+						}
+						throw error;
+					}
+				}
+
+				if (lastError) throw lastError;
+
+			} catch (error) {
+				const continueOnFail = typeof this.continueOnFail === 'function' ? this.continueOnFail() : false;
+				if (continueOnFail) {
+					returnData.push({
+						json: { error: error.message },
+						pairedItem: { item: i },
+					});
+					continue;
+				}
+				throw error;
+			}
+		}
+
+		return [returnData];
+	}
+}
+
+module.exports = {
+	nodeTypes: [GmailCustom],
+};

package/package.json

@@ -0,0 +1,21 @@
+{
+	"name": "n8n-nodes-gmail-custom",
+	"version": "0.1.1",
+	"description": "Custom Gmail node for n8n with token caching and 429 retry",
+	"keywords": [
+		"n8n-community-node-package",
+		"n8n",
+		"gmail",
+		"google"
+	],
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"n8n": {
+		"n8nNodesApiVersion": 1,
+		"nodes": [
+			"nodes/GmailCustom/GmailCustom.node.js"
+		]
+	}
+}