first commit

packages/nodes-base/nodes/Google/Gmail/v2/DraftDescription.ts

@@ -0,0 +1,311 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const draftOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		displayOptions: {
+			show: {
+				resource: ['draft'],
+			},
+		},
+		options: [
+			{
+				name: 'Create',
+				value: 'create',
+				action: 'Create a draft',
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				action: 'Delete a draft',
+			},
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a draft',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many drafts',
+			},
+		],
+		default: 'create',
+	},
+];
+
+export const draftFields: INodeProperties[] = [
+	{
+		displayName: 'Draft ID',
+		name: 'messageId',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['draft'],
+				operation: ['delete', 'get'],
+			},
+		},
+		placeholder: 'r-3254521568507167962',
+	},
+	{
+		displayName: 'Subject',
+		name: 'subject',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['draft'],
+				operation: ['create'],
+			},
+		},
+		placeholder: 'Hello World!',
+	},
+	{
+		displayName: 'To reply to an existing thread, specify the exact subject title of that thread.',
+		name: 'threadNotice',
+		type: 'notice',
+		default: '',
+		displayOptions: { show: { resource: ['draft'], operation: ['create'] } },
+	},
+	{
+		displayName: 'Email Type',
+		name: 'emailType',
+		type: 'options',
+		default: 'text',
+		required: true,
+		noDataExpression: true,
+		options: [
+			{
+				name: 'HTML',
+				value: 'html',
+			},
+			{
+				name: 'Text',
+				value: 'text',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['draft'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Message',
+		name: 'message',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['draft'],
+				operation: ['create'],
+			},
+		},
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		displayOptions: {
+			show: {
+				resource: ['draft'],
+				operation: ['create'],
+			},
+		},
+		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 (in Input)',
+								name: 'property',
+								type: 'string',
+								default: '',
+								description:
+									'Add the field name from the input node. Multiple properties can be set separated by comma.',
+							},
+						],
+					},
+				],
+				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. e.g. jay@getsby.com, jon@smith.com.',
+				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. e.g. jay@getsby.com, jon@smith.com.',
+				placeholder: 'info@example.com',
+				default: '',
+			},
+			{
+				displayName: 'From Alias Name or ID',
+				name: 'fromAlias',
+				type: 'options',
+				default: '',
+				description:
+					'Select the alias to send the email from. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+				typeOptions: {
+					loadOptionsMethod: 'getGmailAliases',
+				},
+			},
+			{
+				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: 'Thread ID',
+				name: 'threadId',
+				type: 'string',
+				placeholder: '18cc573e2431878f',
+				default: '',
+				description: 'The identifier of the thread to attach the draft',
+			},
+			{
+				displayName: 'To Email',
+				name: 'sendTo',
+				type: 'string',
+				default: '',
+				placeholder: 'info@example.com',
+				description:
+					'The email addresses of the recipients. Multiple addresses can be separated by a comma. e.g. jay@getsby.com, jon@smith.com.',
+			},
+		],
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		displayOptions: {
+			show: {
+				resource: ['draft'],
+				operation: ['get'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Attachment Prefix',
+				name: 'dataPropertyAttachmentsPrefixName',
+				type: 'string',
+				default: 'attachment_',
+				description:
+					"Prefix for name of the binary property to which to write the attachment. An index starting with 0 will be added. So if name is 'attachment_' the first attachment is saved to 'attachment_0'.",
+			},
+			{
+				displayName: 'Download Attachments',
+				name: 'downloadAttachments',
+				type: 'boolean',
+				default: false,
+				description: "Whether the draft's attachments will be downloaded",
+			},
+		],
+	},
+
+	/* -------------------------------------------------------------------------- */
+	/*                                 draft:getAll                               */
+	/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['draft'],
+			},
+		},
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['draft'],
+				returnAll: [false],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 50,
+		description: 'Max number of results to return',
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['draft'],
+			},
+		},
+		options: [
+			{
+				displayName: 'Attachment Prefix',
+				name: 'dataPropertyAttachmentsPrefixName',
+				type: 'string',
+				default: 'attachment_',
+				description:
+					"Prefix for name of the binary property to which to write the attachments. An index starting with 0 will be added. So if name is 'attachment_' the first attachment is saved to 'attachment_0'.",
+			},
+			{
+				displayName: 'Download Attachments',
+				name: 'downloadAttachments',
+				type: 'boolean',
+				default: false,
+				description: "Whether the draft's attachments will be downloaded",
+			},
+			{
+				displayName: 'Include Spam and Trash',
+				name: 'includeSpamTrash',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to include messages from SPAM and TRASH in the results',
+			},
+		],
+	},
+];

packages/nodes-base/nodes/Google/Gmail/v2/GmailV2.node.ts

@@ -0,0 +1,832 @@
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	INodeExecutionData,
+	INodeType,
+	INodeTypeBaseDescription,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+import { NodeConnectionTypes, NodeOperationError, SEND_AND_WAIT_OPERATION } from 'n8n-workflow';
+
+import { draftFields, draftOperations } from './DraftDescription';
+import { labelFields, labelOperations } from './LabelDescription';
+import { getGmailAliases, getLabels, getThreadMessages } from './loadOptions';
+import { messageFields, messageOperations } from './MessageDescription';
+import { threadFields, threadOperations } from './ThreadDescription';
+import { addThreadHeadersToEmail } from './utils/draft';
+import { configureWaitTillDate } from '../../../../utils/sendAndWait/configureWaitTillDate.util';
+import { sendAndWaitWebhooksDescription } from '../../../../utils/sendAndWait/descriptions';
+import type { IEmail } from '../../../../utils/sendAndWait/interfaces';
+import {
+	createEmail,
+	getSendAndWaitProperties,
+	SEND_AND_WAIT_WAITING_TOOLTIP,
+	sendAndWaitWebhook,
+} from '../../../../utils/sendAndWait/utils';
+import {
+	encodeEmail,
+	googleApiRequest,
+	googleApiRequestAllItems,
+	parseRawEmail,
+	prepareEmailAttachments,
+	prepareEmailBody,
+	prepareEmailsInput,
+	prepareQuery,
+	simplifyOutput,
+	unescapeSnippets,
+} from '../GenericFunctions';
+import { replyToEmail } from '../utils/replyToEmail';
+
+const versionDescription: INodeTypeDescription = {
+	displayName: 'Gmail',
+	name: 'gmail',
+	icon: 'file:gmail.svg',
+	group: ['transform'],
+	version: [2, 2.1, 2.2],
+	subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+	description: 'Consume the Gmail API',
+	defaults: {
+		name: 'Gmail',
+	},
+	inputs: [NodeConnectionTypes.Main],
+	outputs: [NodeConnectionTypes.Main],
+	usableAsTool: true,
+	credentials: [
+		{
+			name: 'googleApi',
+			required: true,
+			displayOptions: {
+				show: {
+					authentication: ['serviceAccount'],
+				},
+			},
+		},
+		{
+			name: 'gmailOAuth2',
+			required: true,
+			displayOptions: {
+				show: {
+					authentication: ['oAuth2'],
+				},
+			},
+		},
+	],
+	waitingNodeTooltip: SEND_AND_WAIT_WAITING_TOOLTIP,
+	webhooks: sendAndWaitWebhooksDescription,
+	properties: [
+		{
+			displayName: 'Authentication',
+			name: 'authentication',
+			type: 'options',
+			options: [
+				{
+					// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+					name: 'OAuth2 (recommended)',
+					value: 'oAuth2',
+				},
+				{
+					name: 'Service Account',
+					value: 'serviceAccount',
+				},
+			],
+			default: 'oAuth2',
+		},
+		{
+			displayName: 'Resource',
+			name: 'resource',
+			type: 'options',
+			noDataExpression: true,
+			options: [
+				{
+					name: 'Message',
+					value: 'message',
+				},
+				{
+					name: 'Label',
+					value: 'label',
+				},
+				{
+					name: 'Draft',
+					value: 'draft',
+				},
+				{
+					name: 'Thread',
+					value: 'thread',
+				},
+			],
+			default: 'message',
+		},
+		//-------------------------------
+		// Draft Operations
+		//-------------------------------
+		...draftOperations,
+		...draftFields,
+		//-------------------------------
+		// Label Operations
+		//-------------------------------
+		...labelOperations,
+		...labelFields,
+		//-------------------------------
+		// Message Operations
+		//-------------------------------
+		...messageOperations,
+		...messageFields,
+		...getSendAndWaitProperties([
+			{
+				displayName: 'To',
+				name: 'sendTo',
+				type: 'string',
+				default: '',
+				required: true,
+				placeholder: 'e.g. info@example.com',
+			},
+		]),
+		//-------------------------------
+		// Thread Operations
+		//-------------------------------
+		...threadOperations,
+		...threadFields,
+		//-------------------------------
+	],
+};
+
+export class GmailV2 implements INodeType {
+	description: INodeTypeDescription;
+
+	constructor(baseDescription: INodeTypeBaseDescription) {
+		this.description = {
+			...baseDescription,
+			...versionDescription,
+		};
+	}
+
+	methods = {
+		loadOptions: {
+			getLabels,
+			getThreadMessages,
+			getGmailAliases,
+		},
+	};
+
+	webhook = sendAndWaitWebhook;
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const returnData: INodeExecutionData[] = [];
+		const resource = this.getNodeParameter('resource', 0);
+		const operation = this.getNodeParameter('operation', 0);
+		const nodeVersion = this.getNode().typeVersion;
+		const instanceId = this.getInstanceId();
+
+		if (resource === 'message' && operation === SEND_AND_WAIT_OPERATION) {
+			const email: IEmail = createEmail(this);
+
+			await googleApiRequest.call(this, 'POST', '/gmail/v1/users/me/messages/send', {
+				raw: await encodeEmail(email),
+			});
+
+			const waitTill = configureWaitTillDate(this);
+
+			await this.putExecutionToWait(waitTill);
+			return [this.getInputData()];
+		}
+
+		let responseData;
+
+		for (let i = 0; i < items.length; i++) {
+			try {
+				//------------------------------------------------------------------//
+				//                            labels                                //
+				//------------------------------------------------------------------//
+				if (resource === 'label') {
+					if (operation === 'create') {
+						//https://developers.google.com/gmail/api/v1/reference/users/labels/create
+						const labelName = this.getNodeParameter('name', i) as string;
+						const labelListVisibility = this.getNodeParameter(
+							'options.labelListVisibility',
+							i,
+							'labelShow',
+						) as string;
+						const messageListVisibility = this.getNodeParameter(
+							'options.messageListVisibility',
+							i,
+							'show',
+						) as string;
+
+						const body = {
+							labelListVisibility,
+							messageListVisibility,
+							name: labelName,
+						};
+
+						responseData = await googleApiRequest.call(
+							this,
+							'POST',
+							'/gmail/v1/users/me/labels',
+							body,
+						);
+					}
+					if (operation === 'delete') {
+						//https://developers.google.com/gmail/api/v1/reference/users/labels/delete
+						const labelId = this.getNodeParameter('labelId', i) as string[];
+						const endpoint = `/gmail/v1/users/me/labels/${labelId}`;
+
+						responseData = await googleApiRequest.call(this, 'DELETE', endpoint);
+						responseData = { success: true };
+					}
+					if (operation === 'get') {
+						// https://developers.google.com/gmail/api/v1/reference/users/labels/get
+						const labelId = this.getNodeParameter('labelId', i);
+						const endpoint = `/gmail/v1/users/me/labels/${labelId}`;
+
+						responseData = await googleApiRequest.call(this, 'GET', endpoint);
+					}
+					if (operation === 'getAll') {
+						const returnAll = this.getNodeParameter('returnAll', i);
+
+						responseData = await googleApiRequest.call(this, 'GET', '/gmail/v1/users/me/labels');
+
+						responseData = this.helpers.returnJsonArray(responseData.labels as IDataObject[]);
+
+						if (!returnAll) {
+							const limit = this.getNodeParameter('limit', i);
+							responseData = responseData.splice(0, limit);
+						}
+					}
+				}
+				//------------------------------------------------------------------//
+				//                            messages                              //
+				//------------------------------------------------------------------//
+				if (resource === 'message') {
+					if (operation === 'send') {
+						// https://developers.google.com/gmail/api/v1/reference/users/messages/send
+						const options = this.getNodeParameter('options', i);
+						const sendTo = this.getNodeParameter('sendTo', i) as string;
+						let qs: IDataObject = {};
+
+						const to = prepareEmailsInput.call(this, sendTo, 'To', i);
+						let cc = '';
+						let bcc = '';
+						let replyTo = '';
+
+						if (options.ccList) {
+							cc = prepareEmailsInput.call(this, options.ccList as string, 'CC', i);
+						}
+
+						if (options.bccList) {
+							bcc = prepareEmailsInput.call(this, options.bccList as string, 'BCC', i);
+						}
+
+						if (options.replyTo) {
+							replyTo = prepareEmailsInput.call(this, options.replyTo as string, 'ReplyTo', i);
+						}
+
+						let attachments: IDataObject[] = [];
+
+						if (options.attachmentsUi) {
+							attachments = await prepareEmailAttachments.call(
+								this,
+								options.attachmentsUi as IDataObject,
+								i,
+							);
+							if (attachments.length) {
+								qs = {
+									userId: 'me',
+									uploadType: 'media',
+								};
+							}
+						}
+
+						let from = '';
+						if (options.senderName) {
+							const { emailAddress } = await googleApiRequest.call(
+								this,
+								'GET',
+								'/gmail/v1/users/me/profile',
+							);
+							from = `${options.senderName as string} <${emailAddress}>`;
+						}
+
+						let appendAttribution = options.appendAttribution;
+						if (appendAttribution === undefined) {
+							appendAttribution = nodeVersion >= 2.1;
+						}
+
+						const email: IEmail = {
+							from,
+							to,
+							cc,
+							bcc,
+							replyTo,
+							subject: this.getNodeParameter('subject', i) as string,
+							...prepareEmailBody.call(this, i, appendAttribution as boolean, instanceId),
+							attachments,
+						};
+
+						const endpoint = '/gmail/v1/users/me/messages/send';
+
+						const body = {
+							raw: await encodeEmail(email),
+						};
+
+						responseData = await googleApiRequest.call(this, 'POST', endpoint, body, qs);
+					}
+					if (operation === 'reply') {
+						const messageIdGmail = this.getNodeParameter('messageId', i) as string;
+						const options = this.getNodeParameter('options', i);
+
+						responseData = await replyToEmail.call(this, messageIdGmail, options, i, nodeVersion);
+					}
+					if (operation === 'get') {
+						//https://developers.google.com/gmail/api/v1/reference/users/messages/get
+						const id = this.getNodeParameter('messageId', i);
+						const endpoint = `/gmail/v1/users/me/messages/${id}`;
+						const qs: IDataObject = {};
+
+						const options = this.getNodeParameter('options', i, {});
+						const simple = this.getNodeParameter('simple', i) as boolean;
+
+						if (simple) {
+							qs.format = 'metadata';
+							qs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject'];
+						} else {
+							qs.format = 'raw';
+						}
+
+						responseData = await googleApiRequest.call(this, 'GET', endpoint, {}, qs);
+
+						let nodeExecutionData: INodeExecutionData;
+						if (!simple) {
+							const dataPropertyNameDownload =
+								(options.dataPropertyAttachmentsPrefixName as string) || 'attachment_';
+
+							nodeExecutionData = await parseRawEmail.call(
+								this,
+								responseData,
+								dataPropertyNameDownload,
+							);
+						} else {
+							const [json, _] = await simplifyOutput.call(this, [responseData as IDataObject]);
+							nodeExecutionData = { json };
+						}
+
+						responseData = [nodeExecutionData];
+					}
+					if (operation === 'getAll') {
+						const returnAll = this.getNodeParameter('returnAll', i);
+						const options = this.getNodeParameter('options', i, {});
+						const filters = this.getNodeParameter('filters', i, {});
+						const qs: IDataObject = {};
+						Object.assign(qs, prepareQuery.call(this, filters, i));
+
+						if (returnAll) {
+							responseData = await googleApiRequestAllItems.call(
+								this,
+								'messages',
+								'GET',
+								'/gmail/v1/users/me/messages',
+								{},
+								qs,
+							);
+						} else {
+							qs.maxResults = this.getNodeParameter('limit', i);
+							responseData = await googleApiRequest.call(
+								this,
+								'GET',
+								'/gmail/v1/users/me/messages',
+								{},
+								qs,
+							);
+							responseData = responseData.messages;
+						}
+
+						if (responseData === undefined) {
+							responseData = [];
+						}
+
+						const simple = this.getNodeParameter('simple', i) as boolean;
+
+						if (simple) {
+							qs.format = 'metadata';
+							qs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject'];
+						} else {
+							qs.format = 'raw';
+						}
+
+						for (let index = 0; index < responseData.length; index++) {
+							responseData[index] = await googleApiRequest.call(
+								this,
+								'GET',
+								`/gmail/v1/users/me/messages/${responseData[index].id}`,
+								{},
+								qs,
+							);
+
+							if (!simple) {
+								const dataPropertyNameDownload =
+									(options.dataPropertyAttachmentsPrefixName as string) || 'attachment_';
+
+								responseData[index] = await parseRawEmail.call(
+									this,
+									responseData[index],
+									dataPropertyNameDownload,
+								);
+							}
+						}
+
+						if (simple) {
+							responseData = this.helpers.returnJsonArray(
+								await simplifyOutput.call(this, responseData as IDataObject[]),
+							);
+						}
+					}
+					if (operation === 'delete') {
+						// https://developers.google.com/gmail/api/v1/reference/users/messages/delete
+						const id = this.getNodeParameter('messageId', i);
+						const endpoint = `/gmail/v1/users/me/messages/${id}`;
+
+						responseData = await googleApiRequest.call(this, 'DELETE', endpoint);
+
+						responseData = { success: true };
+					}
+					if (operation === 'markAsRead') {
+						// https://developers.google.com/gmail/api/reference/rest/v1/users.messages/modify
+						const id = this.getNodeParameter('messageId', i);
+						const endpoint = `/gmail/v1/users/me/messages/${id}/modify`;
+
+						const body = {
+							removeLabelIds: ['UNREAD'],
+						};
+
+						responseData = await googleApiRequest.call(this, 'POST', endpoint, body);
+					}
+
+					if (operation === 'markAsUnread') {
+						// https://developers.google.com/gmail/api/reference/rest/v1/users.messages/modify
+						const id = this.getNodeParameter('messageId', i);
+						const endpoint = `/gmail/v1/users/me/messages/${id}/modify`;
+
+						const body = {
+							addLabelIds: ['UNREAD'],
+						};
+
+						responseData = await googleApiRequest.call(this, 'POST', endpoint, body);
+					}
+
+					if (operation === 'addLabels') {
+						const id = this.getNodeParameter('messageId', i);
+						const labelIds = this.getNodeParameter('labelIds', i) as string[];
+
+						const endpoint = `/gmail/v1/users/me/messages/${id}/modify`;
+
+						const body = {
+							addLabelIds: labelIds,
+						};
+
+						responseData = await googleApiRequest.call(this, 'POST', endpoint, body);
+					}
+					if (operation === 'removeLabels') {
+						const id = this.getNodeParameter('messageId', i);
+						const labelIds = this.getNodeParameter('labelIds', i) as string[];
+
+						const endpoint = `/gmail/v1/users/me/messages/${id}/modify`;
+
+						const body = {
+							removeLabelIds: labelIds,
+						};
+						responseData = await googleApiRequest.call(this, 'POST', endpoint, body);
+					}
+				}
+				//------------------------------------------------------------------//
+				//                            drafts                                //
+				//------------------------------------------------------------------//
+				if (resource === 'draft') {
+					if (operation === 'create') {
+						// https://developers.google.com/gmail/api/v1/reference/users/drafts/create
+						const options = this.getNodeParameter('options', i);
+						let qs: IDataObject = {};
+
+						let to = '';
+						let cc = '';
+						let bcc = '';
+						let replyTo = '';
+						let fromAlias = '';
+						let threadId = null;
+
+						if (options.sendTo) {
+							to += prepareEmailsInput.call(this, options.sendTo as string, 'To', i);
+						}
+
+						if (options.ccList) {
+							cc = prepareEmailsInput.call(this, options.ccList as string, 'CC', i);
+						}
+
+						if (options.bccList) {
+							bcc = prepareEmailsInput.call(this, options.bccList as string, 'BCC', i);
+						}
+
+						if (options.replyTo) {
+							replyTo = prepareEmailsInput.call(this, options.replyTo as string, 'ReplyTo', i);
+						}
+
+						if (options.fromAlias) {
+							fromAlias = options.fromAlias as string;
+						}
+
+						if (options.threadId && typeof options.threadId === 'string') {
+							threadId = options.threadId;
+						}
+
+						let attachments: IDataObject[] = [];
+						if (options.attachmentsUi) {
+							attachments = await prepareEmailAttachments.call(
+								this,
+								options.attachmentsUi as IDataObject,
+								i,
+							);
+							if (attachments.length) {
+								qs = {
+									userId: 'me',
+									uploadType: 'media',
+								};
+							}
+						}
+
+						const email: IEmail = {
+							from: fromAlias,
+							to,
+							cc,
+							bcc,
+							replyTo,
+							subject: this.getNodeParameter('subject', i) as string,
+							...prepareEmailBody.call(this, i),
+							attachments,
+						};
+
+						if (threadId) {
+							// If a threadId is set, we need to add the Message-ID of the last message in the thread
+							// to the email so that Gmail can correctly associate the draft with the thread
+							await addThreadHeadersToEmail.call(this, email, threadId as string);
+						}
+
+						const body = {
+							message: {
+								raw: await encodeEmail(email),
+								threadId: threadId || undefined,
+							},
+						};
+
+						responseData = await googleApiRequest.call(
+							this,
+							'POST',
+							'/gmail/v1/users/me/drafts',
+							body,
+							qs,
+						);
+					}
+					if (operation === 'get') {
+						// https://developers.google.com/gmail/api/v1/reference/users/drafts/get
+						const id = this.getNodeParameter('messageId', i);
+						const endpoint = `/gmail/v1/users/me/drafts/${id}`;
+						const qs: IDataObject = {};
+
+						const options = this.getNodeParameter('options', i);
+						qs.format = 'raw';
+
+						responseData = await googleApiRequest.call(this, 'GET', endpoint, {}, qs);
+
+						const dataPropertyNameDownload =
+							(options.dataPropertyAttachmentsPrefixName as string) || 'attachment_';
+
+						const nodeExecutionData = await parseRawEmail.call(
+							this,
+							responseData.message,
+							dataPropertyNameDownload,
+						);
+
+						// Add the draft-id
+						nodeExecutionData.json.messageId = nodeExecutionData.json.id;
+						nodeExecutionData.json.id = responseData.id;
+
+						responseData = [nodeExecutionData];
+					}
+					if (operation === 'delete') {
+						// https://developers.google.com/gmail/api/v1/reference/users/drafts/delete
+						const id = this.getNodeParameter('messageId', i);
+						const endpoint = `/gmail/v1/users/me/drafts/${id}`;
+
+						responseData = await googleApiRequest.call(this, 'DELETE', endpoint);
+
+						responseData = { success: true };
+					}
+					if (operation === 'getAll') {
+						const returnAll = this.getNodeParameter('returnAll', i);
+						const options = this.getNodeParameter('options', i);
+						const qs: IDataObject = {};
+						Object.assign(qs, options);
+
+						if (returnAll) {
+							responseData = await googleApiRequestAllItems.call(
+								this,
+								'drafts',
+								'GET',
+								'/gmail/v1/users/me/drafts',
+								{},
+								qs,
+							);
+						} else {
+							qs.maxResults = this.getNodeParameter('limit', i);
+							responseData = await googleApiRequest.call(
+								this,
+								'GET',
+								'/gmail/v1/users/me/drafts',
+								{},
+								qs,
+							);
+							responseData = responseData.drafts;
+						}
+
+						if (responseData === undefined) {
+							responseData = [];
+						}
+
+						qs.format = 'raw';
+
+						for (let index = 0; index < responseData.length; index++) {
+							responseData[index] = await googleApiRequest.call(
+								this,
+								'GET',
+								`/gmail/v1/users/me/drafts/${responseData[index].id}`,
+								{},
+								qs,
+							);
+
+							const dataPropertyNameDownload =
+								(options.dataPropertyAttachmentsPrefixName as string) || 'attachment_';
+							const id = responseData[index].id;
+							responseData[index] = await parseRawEmail.call(
+								this,
+								responseData[index].message,
+								dataPropertyNameDownload,
+							);
+
+							// Add the draft-id
+							responseData[index].json.messageId = responseData[index].json.id;
+							responseData[index].json.id = id;
+						}
+					}
+				}
+				//------------------------------------------------------------------//
+				//                           threads                                //
+				//------------------------------------------------------------------//
+				if (resource === 'thread') {
+					if (operation === 'delete') {
+						//https://developers.google.com/gmail/api/reference/rest/v1/users.threads/delete
+						const id = this.getNodeParameter('threadId', i);
+						const endpoint = `/gmail/v1/users/me/threads/${id}`;
+
+						responseData = await googleApiRequest.call(this, 'DELETE', endpoint);
+
+						responseData = { success: true };
+					}
+					if (operation === 'get') {
+						//https://developers.google.com/gmail/api/reference/rest/v1/users.threads/get
+						const id = this.getNodeParameter('threadId', i);
+						const endpoint = `/gmail/v1/users/me/threads/${id}`;
+
+						const options = this.getNodeParameter('options', i);
+						const onlyMessages = options.returnOnlyMessages || false;
+						const qs: IDataObject = {};
+
+						const simple = this.getNodeParameter('simple', i) as boolean;
+
+						if (simple) {
+							qs.format = 'metadata';
+							qs.metadataHeaders = ['From', 'To', 'Cc', 'Bcc', 'Subject'];
+						} else {
+							qs.format = 'full';
+						}
+
+						responseData = await googleApiRequest.call(this, 'GET', endpoint, {}, qs);
+
+						if (onlyMessages) {
+							responseData = this.helpers.returnJsonArray(
+								await simplifyOutput.call(this, responseData.messages as IDataObject[]),
+							);
+						} else {
+							responseData.messages = await simplifyOutput.call(
+								this,
+								responseData.messages as IDataObject[],
+							);
+							responseData = [{ json: responseData }];
+						}
+					}
+					if (operation === 'getAll') {
+						//https://developers.google.com/gmail/api/reference/rest/v1/users.threads/list
+						const returnAll = this.getNodeParameter('returnAll', i);
+						const filters = this.getNodeParameter('filters', i);
+						const qs: IDataObject = {};
+						Object.assign(qs, prepareQuery.call(this, filters, i));
+
+						if (returnAll) {
+							responseData = await googleApiRequestAllItems.call(
+								this,
+								'threads',
+								'GET',
+								'/gmail/v1/users/me/threads',
+								{},
+								qs,
+							);
+						} else {
+							qs.maxResults = this.getNodeParameter('limit', i);
+							responseData = await googleApiRequest.call(
+								this,
+								'GET',
+								'/gmail/v1/users/me/threads',
+								{},
+								qs,
+							);
+							responseData = responseData.threads;
+						}
+
+						if (responseData === undefined) {
+							responseData = [];
+						}
+
+						responseData = this.helpers.returnJsonArray(responseData as IDataObject[]);
+					}
+					if (operation === 'reply') {
+						const messageIdGmail = this.getNodeParameter('messageId', i) as string;
+						const options = this.getNodeParameter('options', i);
+
+						responseData = await replyToEmail.call(this, messageIdGmail, options, i, nodeVersion);
+					}
+					if (operation === 'trash') {
+						//https://developers.google.com/gmail/api/reference/rest/v1/users.threads/trash
+						const id = this.getNodeParameter('threadId', i);
+						const endpoint = `/gmail/v1/users/me/threads/${id}/trash`;
+
+						responseData = await googleApiRequest.call(this, 'POST', endpoint);
+					}
+					if (operation === 'untrash') {
+						//https://developers.google.com/gmail/api/reference/rest/v1/users.threads/untrash
+						const id = this.getNodeParameter('threadId', i);
+
+						const endpoint = `/gmail/v1/users/me/threads/${id}/untrash`;
+
+						responseData = await googleApiRequest.call(this, 'POST', endpoint);
+					}
+					if (operation === 'addLabels') {
+						const id = this.getNodeParameter('threadId', i);
+						const labelIds = this.getNodeParameter('labelIds', i) as string[];
+
+						const endpoint = `/gmail/v1/users/me/threads/${id}/modify`;
+
+						const body = {
+							addLabelIds: labelIds,
+						};
+
+						responseData = await googleApiRequest.call(this, 'POST', endpoint, body);
+					}
+					if (operation === 'removeLabels') {
+						const id = this.getNodeParameter('threadId', i);
+						const labelIds = this.getNodeParameter('labelIds', i) as string[];
+
+						const endpoint = `/gmail/v1/users/me/threads/${id}/modify`;
+
+						const body = {
+							removeLabelIds: labelIds,
+						};
+						responseData = await googleApiRequest.call(this, 'POST', endpoint, body);
+					}
+				}
+				//------------------------------------------------------------------//
+
+				const executionData = this.helpers.constructExecutionMetaData(
+					this.helpers.returnJsonArray(responseData as IDataObject[]),
+					{
+						itemData: { item: i },
+					},
+				);
+				returnData.push(...executionData);
+			} catch (error) {
+				error.message = `${error.message} (item ${i})`;
+				if (this.continueOnFail()) {
+					returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+					continue;
+				}
+				throw new NodeOperationError(this.getNode(), error as Error, {
+					description: error.description,
+					itemIndex: i,
+				});
+			}
+		}
+		if (
+			['draft', 'message', 'thread'].includes(resource) &&
+			['get', 'getAll'].includes(operation)
+		) {
+			return [unescapeSnippets(returnData)];
+		}
+		return [returnData];
+	}
+}

packages/nodes-base/nodes/Google/Gmail/v2/LabelDescription.ts

@@ -0,0 +1,159 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const labelOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		displayOptions: {
+			show: {
+				resource: ['label'],
+			},
+		},
+
+		options: [
+			{
+				name: 'Create',
+				value: 'create',
+				action: 'Create a label',
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				action: 'Delete a label',
+			},
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a label info',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many labels',
+			},
+		],
+		default: 'getAll',
+	},
+];
+
+export const labelFields: INodeProperties[] = [
+	{
+		displayName: 'Name',
+		name: 'name',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['label'],
+				operation: ['create'],
+			},
+		},
+		placeholder: 'invoices',
+		description: 'Label Name',
+	},
+	{
+		displayName: 'Label ID',
+		name: 'labelId',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['label'],
+				operation: ['get', 'delete'],
+			},
+		},
+		description: 'The ID of the label',
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		displayOptions: {
+			show: {
+				resource: ['label'],
+				operation: ['create'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Label List Visibility',
+				name: 'labelListVisibility',
+				type: 'options',
+				options: [
+					{
+						name: 'Hide',
+						value: 'labelHide',
+					},
+					{
+						name: 'Show',
+						value: 'labelShow',
+					},
+					{
+						name: 'Show If Unread',
+						value: 'labelShowIfUnread',
+					},
+				],
+				default: 'labelShow',
+				description: 'The visibility of the label in the label list in the Gmail web interface',
+			},
+			{
+				displayName: 'Message List Visibility',
+				name: 'messageListVisibility',
+				type: 'options',
+				options: [
+					{
+						name: 'Hide',
+						value: 'hide',
+					},
+					{
+						name: 'Show',
+						value: 'show',
+					},
+				],
+				default: 'show',
+				description:
+					'The visibility of messages with this label in the message list in the Gmail web interface',
+			},
+		],
+	},
+	/* -------------------------------------------------------------------------- */
+	/*                                 label:getAll                               */
+	/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['label'],
+			},
+		},
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['label'],
+				returnAll: [false],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 50,
+		description: 'Max number of results to return',
+	},
+];

packages/nodes-base/nodes/Google/Gmail/v2/MessageDescription.ts

@@ -0,0 +1,559 @@
+import { SEND_AND_WAIT_OPERATION, type INodeProperties } from 'n8n-workflow';
+
+import { appendAttributionOption } from '../../../../utils/descriptions';
+
+export const messageOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+			},
+		},
+		options: [
+			{
+				name: 'Add Label',
+				value: 'addLabels',
+				action: 'Add label to message',
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				action: 'Delete a message',
+			},
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a message',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many messages',
+			},
+			{
+				name: 'Mark as Read',
+				value: 'markAsRead',
+				action: 'Mark a message as read',
+			},
+			{
+				name: 'Mark as Unread',
+				value: 'markAsUnread',
+				action: 'Mark a message as unread',
+			},
+			{
+				name: 'Remove Label',
+				value: 'removeLabels',
+				action: 'Remove label from message',
+			},
+			{
+				name: 'Reply',
+				value: 'reply',
+				action: 'Reply to a message',
+			},
+			{
+				name: 'Send',
+				value: 'send',
+				action: 'Send a message',
+			},
+			{
+				name: 'Send and Wait for Response',
+				value: SEND_AND_WAIT_OPERATION,
+				action: 'Send message and wait for response',
+			},
+		],
+		default: 'send',
+	},
+];
+
+export const messageFields: INodeProperties[] = [
+	{
+		displayName: 'Message ID',
+		name: 'messageId',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['get', 'delete', 'markAsRead', 'markAsUnread'],
+			},
+		},
+		placeholder: '172ce2c4a72cc243',
+	},
+	{
+		displayName: 'Message ID',
+		name: 'messageId',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['reply'],
+			},
+		},
+		placeholder: '172ce2c4a72cc243',
+	},
+	{
+		displayName: 'To',
+		name: 'sendTo',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['send'],
+			},
+		},
+		placeholder: 'info@example.com',
+		description:
+			'The email addresses of the recipients. Multiple addresses can be separated by a comma. e.g. jay@getsby.com, jon@smith.com.',
+	},
+	{
+		displayName: 'Subject',
+		name: 'subject',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['send'],
+			},
+		},
+		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',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['send', 'reply'],
+			},
+			hide: {
+				'@version': [2],
+			},
+		},
+	},
+	{
+		displayName: 'Email Type',
+		name: 'emailType',
+		type: 'options',
+		default: 'html',
+		required: true,
+		noDataExpression: true,
+		options: [
+			{
+				name: 'Text',
+				value: 'text',
+			},
+			{
+				name: 'HTML',
+				value: 'html',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['send', 'reply'],
+				'@version': [2],
+			},
+		},
+	},
+	{
+		displayName: 'Message',
+		name: 'message',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['reply', 'send'],
+			},
+		},
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['send', 'reply'],
+			},
+		},
+		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: '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. e.g. jay@getsby.com, jon@smith.com.',
+				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. e.g. jay@getsby.com, jon@smith.com.',
+				placeholder: 'info@example.com',
+				default: '',
+			},
+			{
+				displayName: 'Sender Name',
+				name: 'senderName',
+				type: 'string',
+				placeholder: 'e.g. Nathan',
+				default: '',
+				description: "The name that will be shown in recipients' inboxes",
+			},
+			{
+				displayName: 'Send Replies To',
+				name: 'replyTo',
+				type: 'string',
+				placeholder: 'reply@example.com',
+				default: '',
+				description: 'The email address that the reply message is sent to',
+				displayOptions: {
+					hide: {
+						'/operation': ['reply'],
+					},
+				},
+			},
+			{
+				displayName: 'Reply to Sender Only',
+				name: 'replyToSenderOnly',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to reply to the sender only or to the entire list of recipients',
+			},
+		],
+	},
+	{
+		displayName: 'Simplify',
+		name: 'simple',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: ['get'],
+				resource: ['message'],
+			},
+		},
+		default: true,
+		description: 'Whether to return a simplified version of the response instead of the raw data',
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['get'],
+			},
+			hide: {
+				simple: [true],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Attachment Prefix',
+				name: 'dataPropertyAttachmentsPrefixName',
+				type: 'string',
+				default: 'attachment_',
+				description:
+					"Prefix for name of the binary property to which to write the attachment. An index starting with 0 will be added. So if name is 'attachment_' the first attachment is saved to 'attachment_0'.",
+			},
+			{
+				displayName: 'Download Attachments',
+				name: 'downloadAttachments',
+				type: 'boolean',
+				default: false,
+				description:
+					"Whether the email's attachments will be downloaded and included in the output",
+			},
+		],
+	},
+
+	/* -------------------------------------------------------------------------- */
+	/*                                 message:getAll                             */
+	/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['message'],
+			},
+		},
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['message'],
+				returnAll: [false],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 50,
+		description: 'Max number of results to return',
+	},
+	{
+		displayName: 'Simplify',
+		name: 'simple',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['message'],
+			},
+		},
+		default: true,
+		description: 'Whether to return a simplified version of the response instead of the raw data',
+	},
+	{
+		displayName:
+			'Fetching a lot of messages may take a long time. Consider using filters to speed things up',
+		name: 'filtersNotice',
+		type: 'notice',
+		default: '',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['message'],
+				returnAll: [true],
+			},
+		},
+	},
+	{
+		displayName: 'Filters',
+		name: 'filters',
+		type: 'collection',
+		placeholder: 'Add Filter',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['message'],
+			},
+		},
+		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: 'Label Names or IDs',
+				name: 'labelIds',
+				type: 'multiOptions',
+				typeOptions: {
+					loadOptionsMethod: 'getLabels',
+				},
+				default: [],
+				description:
+					'Only return messages with labels that match all of the specified label IDs. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+			},
+			{
+				displayName: 'Search',
+				name: 'q',
+				type: 'string',
+				default: '',
+				placeholder: 'has:attachment',
+				hint: 'Use the same format as in the Gmail search box. <a href="https://support.google.com/mail/answer/7190?hl=en">More info</a>.',
+				description: 'Only return messages matching the specified query',
+			},
+			{
+				displayName: 'Read Status',
+				name: 'readStatus',
+				type: 'options',
+				default: 'unread',
+				hint: 'Filter emails by whether they have been read or not',
+				options: [
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'Unread and read emails',
+						value: 'both',
+					},
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'Unread emails only',
+						value: 'unread',
+					},
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'Read emails only',
+						value: 'read',
+					},
+				],
+			},
+			{
+				displayName: 'Received After',
+				name: 'receivedAfter',
+				type: 'dateTime',
+				default: '',
+				description:
+					'Get all emails received after the specified date. In an expression you can set date using string in ISO format or a timestamp in miliseconds.',
+			},
+			{
+				displayName: 'Received Before',
+				name: 'receivedBefore',
+				type: 'dateTime',
+				default: '',
+				description:
+					'Get all emails received before the specified date. In an expression you can set date using string in ISO format or a timestamp in miliseconds.',
+			},
+			{
+				displayName: 'Sender',
+				name: 'sender',
+				type: 'string',
+				default: '',
+				description: 'Sender name or email to filter by',
+				hint: 'Enter an email or part of a sender name',
+			},
+		],
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['message'],
+			},
+			hide: {
+				simple: [true],
+			},
+		},
+		options: [
+			{
+				displayName: 'Attachment Prefix',
+				name: 'dataPropertyAttachmentsPrefixName',
+				type: 'string',
+				default: 'attachment_',
+				description:
+					"Prefix for name of the binary property to which to write the attachment. An index starting with 0 will be added. So if name is 'attachment_' the first attachment is saved to 'attachment_0'.",
+			},
+			{
+				displayName: 'Download Attachments',
+				name: 'downloadAttachments',
+				type: 'boolean',
+				default: false,
+				description:
+					"Whether the email's attachments will be downloaded and included in the output",
+			},
+		],
+	},
+
+	/* -------------------------------------------------------------------------- */
+	/*                      label:addLabel, removeLabel                           */
+	/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Message ID',
+		name: 'messageId',
+		type: 'string',
+		default: '',
+		required: true,
+		placeholder: '172ce2c4a72cc243',
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['addLabels', 'removeLabels'],
+			},
+		},
+	},
+	{
+		displayName: 'Label Names or IDs',
+		name: 'labelIds',
+		type: 'multiOptions',
+		typeOptions: {
+			loadOptionsMethod: 'getLabels',
+		},
+		default: [],
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['message'],
+				operation: ['addLabels', 'removeLabels'],
+			},
+		},
+		description:
+			'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+	},
+];

packages/nodes-base/nodes/Google/Gmail/v2/ThreadDescription.ts

@@ -0,0 +1,432 @@
+import type { INodeProperties } from 'n8n-workflow';
+
+export const threadOperations: INodeProperties[] = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		noDataExpression: true,
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+			},
+		},
+		options: [
+			{
+				name: 'Add Label',
+				value: 'addLabels',
+				action: 'Add label to thread',
+			},
+			{
+				name: 'Delete',
+				value: 'delete',
+				action: 'Delete a thread',
+			},
+			{
+				name: 'Get',
+				value: 'get',
+				action: 'Get a thread',
+			},
+			{
+				name: 'Get Many',
+				value: 'getAll',
+				action: 'Get many threads',
+			},
+			{
+				name: 'Remove Label',
+				value: 'removeLabels',
+				action: 'Remove label from thread',
+			},
+			{
+				name: 'Reply',
+				value: 'reply',
+				action: 'Reply to a message',
+			},
+			{
+				name: 'Trash',
+				value: 'trash',
+				action: 'Trash a thread',
+			},
+			{
+				name: 'Untrash',
+				value: 'untrash',
+				action: 'Untrash a thread',
+			},
+		],
+		default: 'getAll',
+	},
+];
+
+export const threadFields: INodeProperties[] = [
+	{
+		displayName: 'Thread ID',
+		name: 'threadId',
+		type: 'string',
+		default: '',
+		required: true,
+		description: 'The ID of the thread you are operating on',
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['get', 'delete', 'reply', 'trash', 'untrash'],
+			},
+		},
+	},
+
+	/* -------------------------------------------------------------------------- */
+	/*                                 thread:reply                               */
+	/* -------------------------------------------------------------------------- */
+	{
+		// eslint-disable-next-line n8n-nodes-base/node-param-display-name-wrong-for-dynamic-options
+		displayName: 'Message Snippet or ID',
+		name: 'messageId',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getThreadMessages',
+			loadOptionsDependsOn: ['threadId'],
+		},
+		default: '',
+		description:
+			'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['reply'],
+			},
+		},
+	},
+	{
+		displayName: 'Email Type',
+		name: 'emailType',
+		type: 'options',
+		default: 'text',
+		required: true,
+		noDataExpression: true,
+		options: [
+			{
+				name: 'Text',
+				value: 'text',
+			},
+			{
+				name: 'HTML',
+				value: 'html',
+			},
+		],
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['reply'],
+			},
+		},
+	},
+	{
+		displayName: 'Message',
+		name: 'message',
+		type: 'string',
+		default: '',
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['reply'],
+			},
+		},
+		hint: 'Get better Text and Expressions writing experience by using the expression editor',
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add option',
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['reply'],
+			},
+		},
+		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: '',
+								description:
+									'Add the field name from the input node. Multiple properties can be set separated by comma.',
+							},
+						],
+					},
+				],
+				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. e.g. jay@getsby.com, jon@smith.com.',
+				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. e.g. jay@getsby.com, jon@smith.com.',
+				placeholder: 'info@example.com',
+				default: '',
+			},
+			{
+				displayName: 'Sender Name',
+				name: 'senderName',
+				type: 'string',
+				placeholder: 'e.g. Nathan',
+				default: '',
+				description: 'The name displayed in your contacts inboxes',
+			},
+			{
+				displayName: 'Reply to Sender Only',
+				name: 'replyToSenderOnly',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to reply to the sender only or to the entire list of recipients',
+				displayOptions: {
+					hide: {
+						replyToRecipientsOnly: [true],
+					},
+				},
+			},
+			{
+				displayName: 'Reply to Recipients Only',
+				name: 'replyToRecipientsOnly',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to exclude the sender from the reply',
+				displayOptions: {
+					hide: {
+						replyToSenderOnly: [true],
+					},
+				},
+			},
+		],
+	},
+	/* -------------------------------------------------------------------------- */
+	/*                                 thread:get                                 */
+	/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Simplify',
+		name: 'simple',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: ['get'],
+				resource: ['thread'],
+			},
+		},
+		default: true,
+		description: 'Whether to return a simplified version of the response instead of the raw data',
+	},
+	{
+		displayName: 'Options',
+		name: 'options',
+		type: 'collection',
+		placeholder: 'Add Field',
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['get'],
+			},
+		},
+		default: {},
+		options: [
+			{
+				displayName: 'Return Only Messages',
+				name: 'returnOnlyMessages',
+				type: 'boolean',
+				default: true,
+				description: 'Whether to return only thread messages',
+			},
+		],
+	},
+
+	/* -------------------------------------------------------------------------- */
+	/*                                 thread:getAll                              */
+	/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['thread'],
+			},
+		},
+		default: false,
+		description: 'Whether to return all results or only up to a given limit',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['thread'],
+				returnAll: [false],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 50,
+		description: 'Max number of results to return',
+	},
+	{
+		displayName:
+			'Fetching a lot of messages may take a long time. Consider using filters to speed things up',
+		name: 'filtersNotice',
+		type: 'notice',
+		default: '',
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['thread'],
+				returnAll: [true],
+			},
+		},
+	},
+	{
+		displayName: 'Filters',
+		name: 'filters',
+		type: 'collection',
+		placeholder: 'Add Filter',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: ['getAll'],
+				resource: ['thread'],
+			},
+		},
+		options: [
+			{
+				displayName: 'Include Spam and Trash',
+				name: 'includeSpamTrash',
+				type: 'boolean',
+				default: false,
+				description: 'Whether to include threads from SPAM and TRASH in the results',
+			},
+			{
+				displayName: 'Label ID Names or IDs',
+				name: 'labelIds',
+				type: 'multiOptions',
+				typeOptions: {
+					loadOptionsMethod: 'getLabels',
+				},
+				default: [],
+				description:
+					'Only return threads with labels that match all of the specified label IDs. Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+			},
+			{
+				displayName: 'Search',
+				name: 'q',
+				type: 'string',
+				default: '',
+				placeholder: 'has:attachment',
+				hint: 'Use the same format as in the Gmail search box. <a href="https://support.google.com/mail/answer/7190?hl=en">More info</a>.',
+				description: 'Only return messages matching the specified query',
+			},
+			{
+				displayName: 'Read Status',
+				name: 'readStatus',
+				type: 'options',
+				default: 'unread',
+				hint: 'Filter emails by whether they have been read or not',
+				options: [
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'Unread and read emails',
+						value: 'both',
+					},
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'Unread emails only',
+						value: 'unread',
+					},
+					{
+						// eslint-disable-next-line n8n-nodes-base/node-param-display-name-miscased
+						name: 'Read emails only',
+						value: 'read',
+					},
+				],
+			},
+			{
+				displayName: 'Received After',
+				name: 'receivedAfter',
+				type: 'dateTime',
+				default: '',
+				description:
+					'Get all emails received after the specified date. In an expression you can set date using string in ISO format or a timestamp in miliseconds.',
+			},
+			{
+				displayName: 'Received Before',
+				name: 'receivedBefore',
+				type: 'dateTime',
+				default: '',
+				description:
+					'Get all emails received before the specified date. In an expression you can set date using string in ISO format or a timestamp in miliseconds.',
+			},
+		],
+	},
+	/* -------------------------------------------------------------------------- */
+	/*                      label:addLabel, removeLabel                           */
+	/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Thread ID',
+		name: 'threadId',
+		type: 'string',
+		default: '',
+		required: true,
+		placeholder: '172ce2c4a72cc243',
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['addLabels', 'removeLabels'],
+			},
+		},
+	},
+	{
+		displayName: 'Label Names or IDs',
+		name: 'labelIds',
+		type: 'multiOptions',
+		typeOptions: {
+			loadOptionsMethod: 'getLabels',
+		},
+		default: [],
+		required: true,
+		displayOptions: {
+			show: {
+				resource: ['thread'],
+				operation: ['addLabels', 'removeLabels'],
+			},
+		},
+		description:
+			'Choose from the list, or specify IDs using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+	},
+];

packages/nodes-base/nodes/Google/Gmail/v2/loadOptions.ts

@@ -0,0 +1,46 @@
+import type { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+
+import { googleApiRequest, getLabels } from '../GenericFunctions';
+
+export async function getThreadMessages(
+	this: ILoadOptionsFunctions,
+): Promise<INodePropertyOptions[]> {
+	const returnData: INodePropertyOptions[] = [];
+
+	const id = this.getNodeParameter('threadId', 0) as string;
+	const { messages } = await googleApiRequest.call(
+		this,
+		'GET',
+		`/gmail/v1/users/me/threads/${id}`,
+		{},
+		{ format: 'minimal' },
+	);
+
+	for (const message of messages || []) {
+		returnData.push({
+			name: message.snippet,
+			value: message.id,
+		});
+	}
+
+	return returnData;
+}
+
+export async function getGmailAliases(
+	this: ILoadOptionsFunctions,
+): Promise<INodePropertyOptions[]> {
+	const returnData: INodePropertyOptions[] = [];
+	const { sendAs } = await googleApiRequest.call(this, 'GET', '/gmail/v1/users/me/settings/sendAs');
+
+	for (const alias of sendAs || []) {
+		const displayName = alias.isDefault ? `${alias.sendAsEmail} (Default)` : alias.sendAsEmail;
+		returnData.push({
+			name: displayName,
+			value: alias.sendAsEmail,
+		});
+	}
+
+	return returnData;
+}
+
+export { getLabels };

packages/nodes-base/nodes/Google/Gmail/v2/utils/draft.ts

@@ -0,0 +1,46 @@
+import type { IExecuteFunctions } from 'n8n-workflow';
+
+import type { IEmail } from '@utils/sendAndWait/interfaces';
+
+import { googleApiRequest } from '../../GenericFunctions';
+
+function setEmailReplyHeaders(email: IEmail, messageId: string | undefined): void {
+	if (messageId) {
+		email.inReplyTo = messageId;
+		email.references = messageId;
+	}
+}
+
+function setThreadHeaders(
+	email: IEmail,
+	thread: { messages: Array<{ payload: { headers: Array<{ name: string; value: string }> } }> },
+): void {
+	if (thread?.messages) {
+		const lastMessage = thread.messages.length - 1;
+		const messageId = thread.messages[lastMessage].payload.headers.find(
+			(header: { name: string; value: string }) =>
+				header.name.toLowerCase().includes('message') && header.name.toLowerCase().includes('id'),
+		)?.value;
+
+		setEmailReplyHeaders(email, messageId);
+	}
+}
+
+/**
+ * Adds inReplyTo and reference headers to the email if threadId is provided.
+ */
+export async function addThreadHeadersToEmail(
+	this: IExecuteFunctions,
+	email: IEmail,
+	threadId: string,
+): Promise<void> {
+	const thread = await googleApiRequest.call(
+		this,
+		'GET',
+		`/gmail/v1/users/me/threads/${threadId}`,
+		{},
+		{ format: 'metadata', metadataHeaders: ['Message-ID'] },
+	);
+
+	setThreadHeaders(email, thread);
+}