feat(Microsoft Outlook Node): Node overhaul (#4449)

[N8N-4995](https://linear.app/n8n/issue/N8N-4995)

---------

Co-authored-by: Giulio Andreini <g.andreini@gmail.com>

packages/nodes-base/nodes/Microsoft/Outlook/v1/GenericFunctions.ts

@@ -0,0 +1,244 @@
+import type { OptionsWithUri } from 'request';
+
+import type {
+	IDataObject,
+	IExecuteFunctions,
+	ILoadOptionsFunctions,
+	INodeExecutionData,
+	JsonObject,
+} from 'n8n-workflow';
+import { BINARY_ENCODING, NodeApiError } from 'n8n-workflow';
+
+export async function microsoftApiRequest(
+	this: IExecuteFunctions | ILoadOptionsFunctions,
+	method: string,
+	resource: string,
+
+	body: any = {},
+	qs: IDataObject = {},
+	uri?: string,
+	headers: IDataObject = {},
+	option: IDataObject = { json: true },
+): Promise<any> {
+	const credentials = await this.getCredentials('microsoftOutlookOAuth2Api');
+
+	let apiUrl = `https://graph.microsoft.com/v1.0/me${resource}`;
+	// If accessing shared mailbox
+	if (credentials.useShared && credentials.userPrincipalName) {
+		apiUrl = `https://graph.microsoft.com/v1.0/users/${credentials.userPrincipalName}${resource}`;
+	}
+
+	const options: OptionsWithUri = {
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		method,
+		body,
+		qs,
+		uri: uri || apiUrl,
+	};
+	try {
+		Object.assign(options, option);
+
+		if (Object.keys(headers).length !== 0) {
+			options.headers = Object.assign({}, options.headers, headers);
+		}
+
+		if (Object.keys(body as IDataObject).length === 0) {
+			delete options.body;
+		}
+
+		return await this.helpers.requestOAuth2.call(this, 'microsoftOutlookOAuth2Api', options);
+	} catch (error) {
+		throw new NodeApiError(this.getNode(), error as JsonObject);
+	}
+}
+
+export async function microsoftApiRequestAllItems(
+	this: IExecuteFunctions | ILoadOptionsFunctions,
+	propertyName: string,
+	method: string,
+	endpoint: string,
+
+	body: any = {},
+	query: IDataObject = {},
+	headers: IDataObject = {},
+): Promise<any> {
+	const returnData: IDataObject[] = [];
+
+	let responseData;
+	let uri: string | undefined;
+	query.$top = 100;
+
+	do {
+		responseData = await microsoftApiRequest.call(
+			this,
+			method,
+			endpoint,
+			body,
+			query,
+			uri,
+			headers,
+		);
+		uri = responseData['@odata.nextLink'];
+		returnData.push.apply(returnData, responseData[propertyName] as IDataObject[]);
+	} while (responseData['@odata.nextLink'] !== undefined);
+
+	return returnData;
+}
+
+export async function microsoftApiRequestAllItemsSkip(
+	this: IExecuteFunctions | ILoadOptionsFunctions,
+	propertyName: string,
+	method: string,
+	endpoint: string,
+
+	body: any = {},
+	query: IDataObject = {},
+	headers: IDataObject = {},
+): Promise<any> {
+	const returnData: IDataObject[] = [];
+
+	let responseData;
+	query.$top = 100;
+	query.$skip = 0;
+
+	do {
+		responseData = await microsoftApiRequest.call(
+			this,
+			method,
+			endpoint,
+			body,
+			query,
+			undefined,
+			headers,
+		);
+		query.$skip += query.$top;
+		returnData.push.apply(returnData, responseData[propertyName] as IDataObject[]);
+	} while (responseData.value.length !== 0);
+
+	return returnData;
+}
+
+export function makeRecipient(email: string) {
+	return {
+		emailAddress: {
+			address: email,
+		},
+	};
+}
+
+export function createMessage(fields: IDataObject) {
+	const message: IDataObject = {};
+
+	// Create body object
+	if (fields.bodyContent || fields.bodyContentType) {
+		const bodyObject = {
+			content: fields.bodyContent,
+			contentType: fields.bodyContentType,
+		};
+
+		message.body = bodyObject;
+		delete fields.bodyContent;
+		delete fields.bodyContentType;
+	}
+
+	// Handle custom headers
+	if (
+		'internetMessageHeaders' in fields &&
+		'headers' in (fields.internetMessageHeaders as IDataObject)
+	) {
+		fields.internetMessageHeaders = (fields.internetMessageHeaders as IDataObject).headers;
+	}
+
+	// Handle recipient fields
+	['bccRecipients', 'ccRecipients', 'replyTo', 'sender', 'toRecipients'].forEach((key) => {
+		if (Array.isArray(fields[key])) {
+			fields[key] = (fields[key] as string[]).map((email) => makeRecipient(email));
+		} else if (fields[key] !== undefined) {
+			fields[key] = (fields[key] as string)
+				.split(',')
+				.map((recipient: string) => makeRecipient(recipient));
+		}
+	});
+
+	['from', 'sender'].forEach((key) => {
+		if (fields[key] !== undefined) {
+			fields[key] = makeRecipient(fields[key] as string);
+		}
+	});
+
+	Object.assign(message, fields);
+
+	return message;
+}
+
+export async function downloadAttachments(
+	this: IExecuteFunctions,
+	messages: IDataObject[] | IDataObject,
+	prefix: string,
+) {
+	const elements: INodeExecutionData[] = [];
+	if (!Array.isArray(messages)) {
+		messages = [messages];
+	}
+	for (const message of messages) {
+		const element: INodeExecutionData = {
+			json: message,
+			binary: {},
+		};
+		if (message.hasAttachments === true) {
+			const attachments = await microsoftApiRequestAllItems.call(
+				this,
+				'value',
+				'GET',
+				`/messages/${message.id}/attachments`,
+				{},
+			);
+			for (const [index, attachment] of attachments.entries()) {
+				const response = await microsoftApiRequest.call(
+					this,
+					'GET',
+					`/messages/${message.id}/attachments/${attachment.id}/$value`,
+					undefined,
+					{},
+					undefined,
+					{},
+					{ encoding: null, resolveWithFullResponse: true },
+				);
+
+				const data = Buffer.from(response.body as string, 'utf8');
+				element.binary![`${prefix}${index}`] = await this.helpers.prepareBinaryData(
+					data as unknown as Buffer,
+					attachment.name as string,
+					attachment.contentType as string,
+				);
+			}
+		}
+		if (Object.keys(element.binary!).length === 0) {
+			delete element.binary;
+		}
+		elements.push(element);
+	}
+	return elements;
+}
+
+export async function binaryToAttachments(
+	this: IExecuteFunctions,
+	attachments: IDataObject[],
+	items: INodeExecutionData[],
+	i: number,
+) {
+	return Promise.all(
+		attachments.map(async (attachment) => {
+			const binaryPropertyName = attachment.binaryPropertyName as string;
+			const binaryData = this.helpers.assertBinaryData(i, binaryPropertyName);
+			const dataBuffer = await this.helpers.getBinaryDataBuffer(i, binaryPropertyName);
+			return {
+				'@odata.type': '#microsoft.graph.fileAttachment',
+				name: binaryData.fileName,
+				contentBytes: dataBuffer.toString(BINARY_ENCODING),
+			};
+		}),
+	);
+}