n8n-nodes-gmail-custom 0.4.0 → 0.5.0

package/nodes/GmailCustom/GmailCustom.node.js

@@ -1,28 +1,5 @@
 const crypto = require('crypto');
-
-let jwtLib;
-try { jwtLib = require('jsonwebtoken'); } catch (e) {}
-
-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, '_');
-}
+const { getOrRefreshAccessToken } = require('./utils');
 
 function generateBoundary() {
 	return '----=_Part_' + crypto.randomBytes(16).toString('hex');
@@ -166,58 +143,6 @@ async function buildMimeMessage(options) {
 		.replace(/=+$/, '');
 }
 
-async function getOrRefreshAccessToken(ctx, serviceAccountEmail, privateKeyRaw, fromEmail) {
-	const cacheKey = `${serviceAccountEmail}:${fromEmail}`;
-	let token = TOKEN_CACHE[cacheKey];
-	if (token && token.expiresAt > Date.now()) {
-		return token.accessToken;
-	}
-
-	const privateKey = formatPrivateKey(privateKeyRaw);
-	const now = Math.floor(Date.now() / 1000);
-
-	let jwt;
-	const payload = {
-		iss: serviceAccountEmail,
-		scope: 'https://mail.google.com/',
-		aud: 'https://oauth2.googleapis.com/token',
-		exp: now + 3600,
-		iat: now,
-		sub: fromEmail,
-	};
-
-	if (jwtLib) {
-		jwt = jwtLib.sign(payload, privateKey, {
-			algorithm: 'RS256',
-			header: { kid: privateKey, typ: 'JWT', alg: 'RS256' },
-		});
-	} else {
-		const header = { alg: 'RS256', typ: 'JWT', kid: privateKey };
-		const signatureInput = base64UrlEncode(JSON.stringify(header)) + '.' + base64UrlEncode(JSON.stringify(payload));
-		const signer = crypto.createSign('RSA-SHA256');
-		signer.update(signatureInput);
-		const sig = signer.sign(privateKey);
-		jwt = signatureInput + '.' + base64urlEscape(sig.toString('base64'));
-	}
-
-	const response = await ctx.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(),
-	});
-
-	TOKEN_CACHE[cacheKey] = {
-		accessToken: response.access_token,
-		expiresAt: Date.now() + 3500 * 1000,
-	};
-
-	return response.access_token;
-}
-
 class GmailCustom {
 
 	constructor() {

package/nodes/GmailCustom/GmailTriggerCustom.node.js

@@ -0,0 +1,285 @@
+const { getOrRefreshAccessToken } = require('./utils');
+
+class GmailTriggerCustom {
+	constructor() {
+		this.description = {
+			displayName: 'Gmail Trigger Custom',
+			name: 'gmailTriggerCustom',
+			icon: 'fa:envelope',
+			group: ['trigger'],
+			version: 1,
+			subtitle: 'Gmail Trigger',
+			description: 'Fetches emails from Gmail on polling intervals with token caching',
+			defaults: { name: 'Gmail Trigger Custom' },
+			polling: true,
+			inputs: [],
+			outputs: ['main'],
+			properties: [
+				{
+					displayName: 'Service Account Email',
+					name: 'serviceAccountEmail',
+					type: 'string',
+					default: '',
+					required: true,
+					placeholder: 'sa-name@project.iam.gserviceaccount.com',
+					description: 'The service account client_email (issuer for JWT)',
+				},
+				{
+					displayName: 'Private Key',
+					name: 'privateKey',
+					type: 'string',
+					typeOptions: { password: true },
+					default: '',
+					required: true,
+					description: 'The service account RSA private key in PEM format',
+				},
+				{
+					displayName: 'Delegated Email',
+					name: 'delegatedEmail',
+					type: 'string',
+					default: '',
+					required: true,
+					placeholder: 'user@domain.com',
+					description: 'The Gmail mailbox to access (user to impersonate via domain-wide delegation)',
+				},
+				{
+					displayName: 'Simplify',
+					name: 'simple',
+					type: 'boolean',
+					default: true,
+					description: 'Whether to return a simplified version of the response instead of the raw data',
+				},
+				{
+					displayName: 'Filters',
+					name: 'filters',
+					type: 'collection',
+					placeholder: 'Add Filter',
+					default: {},
+					options: [
+						{
+							displayName: 'Include Spam and Trash',
+							name: 'includeSpamTrash',
+							type: 'boolean',
+							default: false,
+							description: 'Whether to include messages from SPAM and TRASH in the results',
+						},
+						{
+							displayName: 'Include Drafts',
+							name: 'includeDrafts',
+							type: 'boolean',
+							default: false,
+							description: 'Whether to include email drafts in the results',
+						},
+						{
+							displayName: 'Label Names or IDs',
+							name: 'labelIds',
+							type: 'string',
+							default: '',
+							description: 'Comma-separated label IDs to filter',
+						},
+						{
+							displayName: 'Search',
+							name: 'q',
+							type: 'string',
+							default: '',
+							placeholder: 'has:attachment',
+							description: 'Gmail search query. See <a href="https://support.google.com/mail/answer/7190">Gmail search syntax</a>.',
+						},
+						{
+							displayName: 'Read Status',
+							name: 'readStatus',
+							type: 'options',
+							default: 'unread',
+							options: [
+								{ name: 'Unread and read emails', value: 'both' },
+								{ name: 'Unread emails only', value: 'unread' },
+								{ name: 'Read emails only', value: 'read' },
+							],
+						},
+						{
+							displayName: 'Sender',
+							name: 'sender',
+							type: 'string',
+							default: '',
+							hint: 'Enter an email or part of a sender name',
+						},
+					],
+				},
+			],
+		};
+	}
+
+	async poll() {
+		const webhookName = 'default';
+		const workflowStaticData = this.getWorkflowStaticData('node') || {};
+		if (!workflowStaticData[webhookName]) {
+			workflowStaticData[webhookName] = {};
+		}
+		const nodeStaticData = workflowStaticData[webhookName];
+
+		const now = Math.floor(Date.now() / 1000);
+
+		if (this.getMode() !== 'manual') {
+			nodeStaticData.lastTimeChecked = nodeStaticData.lastTimeChecked || now;
+		}
+		const startDate = nodeStaticData.lastTimeChecked || now;
+
+		const serviceAccountEmail = this.getNodeParameter('serviceAccountEmail', 0) || '';
+		const privateKey = this.getNodeParameter('privateKey', 0) || '';
+		const delegatedEmail = this.getNodeParameter('delegatedEmail', 0) || '';
+		const simple = this.getNodeParameter('simple', 0);
+		const filters = this.getNodeParameter('filters', 0, {});
+
+		const accessToken = await getOrRefreshAccessToken(this, serviceAccountEmail, privateKey, delegatedEmail);
+
+		const responseData = [];
+		const allFetchedMessages = [];
+
+		const getEmailDateAsSeconds = (email) => {
+			let date;
+			if (email.internalDate) {
+				date = Math.floor(parseInt(email.internalDate, 10) / 1000);
+			}
+			if (!date || isNaN(date)) {
+				return startDate;
+			}
+			return date;
+		};
+
+		const fetchAndProcessMessage = async (messageId, fetchQs) => {
+			const fullMessage = await this.helpers.httpRequest({
+				method: 'GET',
+				url: `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}`,
+				headers: { Authorization: `Bearer ${accessToken}` },
+				qs: fetchQs,
+			});
+
+			allFetchedMessages.push({
+				id: fullMessage.id,
+				date: getEmailDateAsSeconds(fullMessage),
+			});
+
+			if (!filters.includeDrafts && fullMessage.labelIds && fullMessage.labelIds.includes('DRAFT')) {
+				return;
+			}
+			if (fullMessage.labelIds && fullMessage.labelIds.includes('SENT') && !fullMessage.labelIds.includes('INBOX')) {
+				return;
+			}
+
+			if (simple) {
+				responseData.push({ json: fullMessage });
+			} else {
+				responseData.push({ json: fullMessage });
+			}
+		};
+
+		try {
+			const qs = {};
+			const parts = [];
+
+			if (!simple) {
+				qs.format = 'raw';
+			} else {
+				qs.format = 'metadata';
+				qs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject'];
+			}
+
+			if (this.getMode() !== 'manual') {
+				parts.push(`after:${startDate}`);
+			}
+
+			if (filters.includeSpamTrash) {
+				parts.push('in:anywhere');
+			} else {
+				parts.push('-in:spam -in:trash');
+			}
+
+			if (filters.readStatus === 'unread') {
+				parts.push('is:unread');
+			} else if (filters.readStatus === 'read') {
+				parts.push('is:read');
+			}
+
+			if (filters.sender) {
+				parts.push(`from:${filters.sender}`);
+			}
+
+			if (filters.labelIds) {
+				for (const labelId of filters.labelIds.split(',')) {
+					parts.push(`label:${labelId.trim()}`);
+				}
+			}
+
+			if (filters.q) {
+				parts.push(filters.q);
+			}
+
+			parts.push('-in:scheduled');
+
+			qs.q = parts.join(' ');
+
+			if (this.getMode() === 'manual') {
+				qs.maxResults = 1;
+			}
+
+			const messagesResponse = await this.helpers.httpRequest({
+				method: 'GET',
+				url: 'https://gmail.googleapis.com/gmail/v1/users/me/messages',
+				headers: { Authorization: `Bearer ${accessToken}` },
+				qs,
+			});
+
+			const messages = messagesResponse.messages || [];
+
+			if (!messages.length && !allFetchedMessages.length) {
+				return null;
+			}
+
+			const possibleDuplicates = new Set(nodeStaticData.possibleDuplicates || []);
+			const filteredMessages = possibleDuplicates.size > 0
+				? messages.filter((m) => !possibleDuplicates.has(m.id))
+				: messages;
+
+			if (!filteredMessages.length && !allFetchedMessages.length) {
+				return null;
+			}
+
+			const fetchQs = {};
+			if (!simple) {
+				fetchQs.format = 'raw';
+			} else {
+				fetchQs.format = 'metadata';
+				fetchQs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject'];
+			}
+
+			for (const message of filteredMessages) {
+				await fetchAndProcessMessage(message.id, fetchQs);
+			}
+		} catch (error) {
+			if (this.getMode() === 'manual' || !nodeStaticData.lastTimeChecked) {
+				throw error;
+			}
+			try {
+				this.logger.error(`Gmail Trigger Custom poll error: ${error.message}`);
+			} catch (e) {}
+		}
+
+		if (!allFetchedMessages.length) {
+			return null;
+		}
+
+		const lastEmailDate = allFetchedMessages.reduce(
+			(last, m) => (m.date > last ? m.date : last), 0,
+		);
+
+		nodeStaticData.possibleDuplicates = allFetchedMessages.map((m) => m.id);
+		nodeStaticData.lastTimeChecked = Math.max(lastEmailDate || startDate, startDate);
+
+		return responseData.length > 0 ? [responseData] : null;
+	}
+}
+
+module.exports = {
+	nodeTypes: [GmailTriggerCustom],
+	GmailTriggerCustom,
+};

package/nodes/GmailCustom/utils.js

@@ -0,0 +1,90 @@
+const crypto = require('crypto');
+
+let jwtLib;
+try { jwtLib = require('jsonwebtoken'); } catch (e) {}
+
+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, '_');
+}
+
+async function getOrRefreshAccessToken(ctx, serviceAccountEmail, privateKeyRaw, delegatedEmail) {
+	const cacheKey = `${serviceAccountEmail}:${delegatedEmail}`;
+	let token = TOKEN_CACHE[cacheKey];
+	if (token && token.expiresAt > Date.now()) {
+		return token.accessToken;
+	}
+
+	const privateKey = formatPrivateKey(privateKeyRaw);
+	const now = Math.floor(Date.now() / 1000);
+
+	let jwt;
+	const payload = {
+		iss: serviceAccountEmail,
+		scope: 'https://mail.google.com/',
+		aud: 'https://oauth2.googleapis.com/token',
+		exp: now + 3600,
+		iat: now,
+		sub: delegatedEmail,
+	};
+
+	if (jwtLib) {
+		jwt = jwtLib.sign(payload, privateKey, {
+			algorithm: 'RS256',
+			header: { kid: privateKey, typ: 'JWT', alg: 'RS256' },
+		});
+	} else {
+		const header = { alg: 'RS256', typ: 'JWT', kid: privateKey };
+		const signatureInput = base64UrlEncode(JSON.stringify(header)) + '.' + base64UrlEncode(JSON.stringify(payload));
+		const signer = crypto.createSign('RSA-SHA256');
+		signer.update(signatureInput);
+		const sig = signer.sign(privateKey);
+		jwt = signatureInput + '.' + base64urlEscape(sig.toString('base64'));
+	}
+
+	const response = await ctx.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(),
+	});
+
+	TOKEN_CACHE[cacheKey] = {
+		accessToken: response.access_token,
+		expiresAt: Date.now() + 3500 * 1000,
+	};
+
+	return response.access_token;
+}
+
+function clearTokenCache(serviceAccountEmail, delegatedEmail) {
+	delete TOKEN_CACHE[`${serviceAccountEmail}:${delegatedEmail}`];
+}
+
+module.exports = {
+	formatPrivateKey,
+	base64UrlEncode,
+	base64urlEscape,
+	getOrRefreshAccessToken,
+	clearTokenCache,
+	TOKEN_CACHE,
+};

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "n8n-nodes-gmail-custom",
-	"version": "0.4.0",
-	"description": "Custom Gmail node for n8n with token caching and 429 retry",
+	"version": "0.5.0",
+	"description": "Custom Gmail nodes for n8n with token caching — Send and Trigger, self-contained credentials",
 	"keywords": [
 		"n8n-community-node-package",
 		"n8n",
@@ -19,7 +19,8 @@
 		"n8nNodesApiVersion": 1,
 		"credentials": [],
 		"nodes": [
-			"nodes/GmailCustom/GmailCustom.node.js"
+			"nodes/GmailCustom/GmailCustom.node.js",
+			"nodes/GmailCustom/GmailTriggerCustom.node.js"
 		]
 	}
 }