n8n-nodes-gmail-custom 0.5.0 → 0.6.0

package/nodes/GmailCustom/GmailGetCustom.node.js

@@ -0,0 +1,238 @@
+const { getOrRefreshAccessToken } = require('./utils');
+
+class GmailGetCustom {
+	constructor() {
+		this.description = {
+			displayName: 'Gmail Get Custom',
+			name: 'gmailGetCustom',
+			icon: 'fa:envelope',
+			group: ['output'],
+			version: 1,
+			subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+			description: 'Get a Message or Thread from Gmail with token caching',
+			defaults: {
+				name: 'Gmail Get Custom',
+				color: '#1a73e8',
+			},
+			inputs: ['main'],
+			outputs: ['main'],
+			properties: [
+				{
+					displayName: 'Service Account Email',
+					name: 'serviceAccountEmail',
+					type: 'string',
+					default: '',
+					required: true,
+					placeholder: 'sa-name@project.iam.gserviceaccount.com',
+				},
+				{
+					displayName: 'Private Key',
+					name: 'privateKey',
+					type: 'string',
+					typeOptions: { password: true },
+					default: '',
+					required: true,
+				},
+				{
+					displayName: 'Delegated Email',
+					name: 'delegatedEmail',
+					type: 'string',
+					default: '',
+					required: true,
+					placeholder: 'user@domain.com',
+					description: 'The Gmail mailbox to access (user to impersonate)',
+				},
+				{
+					displayName: 'Resource',
+					name: 'resource',
+					type: 'options',
+					noDataExpression: true,
+					options: [
+						{ name: 'Message', value: 'message' },
+						{ name: 'Thread', value: 'thread' },
+					],
+					default: 'message',
+				},
+				{
+					displayName: 'Operation',
+					name: 'operation',
+					type: 'options',
+					noDataExpression: true,
+					options: [{ name: 'Get', value: 'get' }],
+					default: 'get',
+					displayOptions: {
+						show: { resource: ['message'] },
+					},
+				},
+				{
+					displayName: 'Operation',
+					name: 'operation',
+					type: 'options',
+					noDataExpression: true,
+					options: [{ name: 'Get', value: 'get' }],
+					default: 'get',
+					displayOptions: {
+						show: { resource: ['thread'] },
+					},
+				},
+				{
+					displayName: 'Message ID',
+					name: 'messageId',
+					type: 'string',
+					default: '',
+					required: true,
+					displayOptions: {
+						show: { resource: ['message'] },
+					},
+					placeholder: '172ce2c4a72cc243',
+				},
+				{
+					displayName: 'Thread ID',
+					name: 'threadId',
+					type: 'string',
+					default: '',
+					required: true,
+					displayOptions: {
+						show: { resource: ['thread'] },
+					},
+					placeholder: '172ce2c4a72cc243',
+				},
+				{
+					displayName: 'Simplify',
+					name: 'simple',
+					type: 'boolean',
+					default: true,
+					displayOptions: {
+						show: { resource: ['message', 'thread'] },
+					},
+					description: 'Whether to return a simplified version (metadata headers only) instead of raw data',
+				},
+				{
+					displayName: 'Options',
+					name: 'options',
+					type: 'collection',
+					placeholder: 'Add option',
+					default: {},
+					displayOptions: {
+						show: { resource: ['thread'] },
+					},
+					options: [
+						{
+							displayName: 'Return Only Messages',
+							name: 'returnOnlyMessages',
+							type: 'boolean',
+							default: false,
+							description: 'Whether to return only the messages array without thread metadata',
+						},
+					],
+				},
+			],
+		};
+	}
+
+	async execute() {
+		const items = this.getInputData();
+		if (!items || items.length === 0) {
+			return [[]];
+		}
+
+		const returnData = [];
+
+		for (let i = 0; i < items.length; i++) {
+			try {
+				const serviceAccountEmail = this.getNodeParameter('serviceAccountEmail', i, '');
+				const privateKey = this.getNodeParameter('privateKey', i, '');
+				const delegatedEmail = this.getNodeParameter('delegatedEmail', i, '');
+				const resource = this.getNodeParameter('resource', i, 'message');
+				const simple = this.getNodeParameter('simple', i, true);
+				const options = this.getNodeParameter('options', i, {});
+
+				const accessToken = await getOrRefreshAccessToken(this, serviceAccountEmail, privateKey, delegatedEmail);
+
+				const qs = {};
+				if (simple) {
+					qs.format = 'metadata';
+					qs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject'];
+				} else {
+					qs.format = resource === 'thread' ? 'full' : 'raw';
+				}
+
+				let url;
+				if (resource === 'message') {
+					const messageId = this.getNodeParameter('messageId', i, '');
+					if (!messageId) throw new Error('Message ID is required');
+					url = `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}`;
+				} else {
+					const threadId = this.getNodeParameter('threadId', i, '');
+					if (!threadId) throw new Error('Thread ID is required');
+					url = `https://gmail.googleapis.com/gmail/v1/users/me/threads/${threadId}`;
+				}
+
+				const response = await this.helpers.httpRequest({
+					method: 'GET',
+					url,
+					headers: { Authorization: `Bearer ${accessToken}` },
+					qs,
+				});
+
+				let result;
+				if (resource === 'thread') {
+					if (simple) {
+						if (response.messages) {
+							response.messages = response.messages.map((msg) => {
+								const flat = { ...msg };
+								if (flat.payload && flat.payload.headers) {
+									for (const h of flat.payload.headers) {
+										flat[h.name] = h.value;
+									}
+								}
+								return flat;
+							});
+						}
+					}
+
+					if (options.returnOnlyMessages) {
+						result = response.messages || [];
+					} else {
+						result = { json: response };
+					}
+				} else {
+					// Message
+					if (simple && response.payload && response.payload.headers) {
+						for (const h of response.payload.headers) {
+							response[h.name] = h.value;
+						}
+					}
+					result = { json: response };
+				}
+
+				const isArray = Array.isArray(result);
+				if (isArray) {
+					for (const item of result) {
+						returnData.push({ json: item, pairedItem: { item: i } });
+					}
+				} else {
+					returnData.push({ ...result, pairedItem: { item: i } });
+				}
+			} catch (error) {
+				let continueOnFail = false;
+				try { continueOnFail = this.continueOnFail(); } catch (e) {}
+				if (continueOnFail) {
+					returnData.push({
+						json: { error: error.message || 'Unknown error' },
+						pairedItem: { item: i },
+					});
+					continue;
+				}
+				throw error;
+			}
+		}
+
+		return [returnData];
+	}
+}
+
+module.exports = {
+	nodeTypes: [GmailGetCustom],
+	GmailGetCustom,
+};

package/nodes/GmailCustom/GmailTriggerCustom.node.js

@@ -49,6 +49,24 @@ class GmailTriggerCustom {
 					default: true,
 					description: 'Whether to return a simplified version of the response instead of the raw data',
 				},
+				{
+					displayName: 'Max Emails per Poll',
+					name: 'maxResults',
+					type: 'number',
+					default: 10,
+					typeOptions: {
+						minValue: 1,
+						maxValue: 50,
+					},
+					description: 'Maximum number of emails to fetch each time the node polls. Remaining emails are picked up in subsequent polls.',
+				},
+				{
+					displayName: 'Mark as Read',
+					name: 'markAsRead',
+					type: 'boolean',
+					default: false,
+					description: 'Whether to mark processed emails as read (adds 1 API call per email)',
+				},
 				{
 					displayName: 'Filters',
 					name: 'filters',
@@ -128,6 +146,8 @@ class GmailTriggerCustom {
 		const privateKey = this.getNodeParameter('privateKey', 0) || '';
 		const delegatedEmail = this.getNodeParameter('delegatedEmail', 0) || '';
 		const simple = this.getNodeParameter('simple', 0);
+		let maxResults = this.getNodeParameter('maxResults', 0) || 10;
+		const markAsRead = this.getNodeParameter('markAsRead', 0);
 		const filters = this.getNodeParameter('filters', 0, {});
 
 		const accessToken = await getOrRefreshAccessToken(this, serviceAccountEmail, privateKey, delegatedEmail);
@@ -166,11 +186,18 @@ class GmailTriggerCustom {
 				return;
 			}
 
-			if (simple) {
-				responseData.push({ json: fullMessage });
-			} else {
-				responseData.push({ json: fullMessage });
+			if (markAsRead) {
+				try {
+					await this.helpers.httpRequest({
+						method: 'POST',
+						url: `https://gmail.googleapis.com/gmail/v1/users/me/messages/${messageId}/modify`,
+						headers: { Authorization: `Bearer ${accessToken}` },
+						body: { removeLabelIds: ['UNREAD'] },
+					});
+				} catch (e) {}
 			}
+
+			responseData.push({ json: fullMessage });
 		};
 
 		try {
@@ -219,41 +246,58 @@ class GmailTriggerCustom {
 			qs.q = parts.join(' ');
 
 			if (this.getMode() === 'manual') {
-				qs.maxResults = 1;
+				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,
-			});
+			let budget = maxResults;
 
-			const messages = messagesResponse.messages || [];
+			// Process pending messages from previous poll first.
+			const pendingIds = nodeStaticData.pendingMessageIds || [];
+			if (pendingIds.length > 0) {
+				const idsToFetch = pendingIds.slice(0, budget);
+				nodeStaticData.pendingMessageIds = pendingIds.slice(budget);
 
-			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;
+				const fetchQs = {};
+				if (!simple) { fetchQs.format = 'raw'; }
+				else { fetchQs.format = 'metadata'; fetchQs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject']; }
 
-			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 id of idsToFetch) {
+					await fetchAndProcessMessage(id, fetchQs);
+				}
+				budget -= idsToFetch.length;
 			}
 
-			for (const message of filteredMessages) {
-				await fetchAndProcessMessage(message.id, fetchQs);
+			// Only list new messages if budget remains.
+			if (budget > 0) {
+				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 > 0) {
+					const possibleDuplicates = new Set(nodeStaticData.possibleDuplicates || []);
+					const filteredMessages = possibleDuplicates.size > 0
+						? messages.filter((m) => !possibleDuplicates.has(m.id))
+						: messages;
+
+					let messagesToProcess = filteredMessages;
+					if (filteredMessages.length > budget) {
+						messagesToProcess = filteredMessages.slice(0, budget);
+						nodeStaticData.pendingMessageIds = filteredMessages.slice(budget).map((m) => m.id);
+					}
+
+					const fetchQs = {};
+					if (!simple) { fetchQs.format = 'raw'; }
+					else { fetchQs.format = 'metadata'; fetchQs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject']; }
+
+					for (const message of messagesToProcess) {
+						await fetchAndProcessMessage(message.id, fetchQs);
+					}
+				}
 			}
 		} catch (error) {
 			if (this.getMode() === 'manual' || !nodeStaticData.lastTimeChecked) {
@@ -273,7 +317,9 @@ class GmailTriggerCustom {
 		);
 
 		nodeStaticData.possibleDuplicates = allFetchedMessages.map((m) => m.id);
-		nodeStaticData.lastTimeChecked = Math.max(lastEmailDate || startDate, startDate);
+		if (!nodeStaticData.pendingMessageIds || nodeStaticData.pendingMessageIds.length === 0) {
+			nodeStaticData.lastTimeChecked = Math.max(lastEmailDate || startDate, startDate);
+		}
 
 		return responseData.length > 0 ? [responseData] : null;
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "n8n-nodes-gmail-custom",
-	"version": "0.5.0",
-	"description": "Custom Gmail nodes for n8n with token caching — Send and Trigger, self-contained credentials",
+	"version": "0.6.0",
+	"description": "Custom Gmail nodes for n8n — Send, Trigger, Get (Message+Thread) — token caching, self-contained",
 	"keywords": [
 		"n8n-community-node-package",
 		"n8n",
@@ -20,7 +20,8 @@
 		"credentials": [],
 		"nodes": [
 			"nodes/GmailCustom/GmailCustom.node.js",
-			"nodes/GmailCustom/GmailTriggerCustom.node.js"
+			"nodes/GmailCustom/GmailTriggerCustom.node.js",
+			"nodes/GmailCustom/GmailGetCustom.node.js"
 		]
 	}
 }