✨ Microsoft Excel node

packages/cli/src/Server.ts

@@ -203,7 +203,9 @@ class App {
 					});
 				}
 
-				jwt.verify(token, getKey, {}, (err: Error, decoded: string) => {
+				jwt.verify(token, getKey, {}, (err: Error,
+					//decoded: string
+					) => {
 					if (err) return ResponseHelper.jwtAuthAuthorizationError(res, "Invalid token");
 
 					next();

packages/nodes-base/credentials/MicrosoftOAuth2Api.credentials.ts

@@ -0,0 +1,45 @@
+import {
+	ICredentialType,
+	NodePropertyTypes,
+} from 'n8n-workflow';
+
+export class MicrosoftOAuth2Api implements ICredentialType {
+	name = 'microsoftOAuth2Api';
+	extends = [
+		'oAuth2Api',
+	];
+	displayName = 'Microsoft OAuth2 API';
+	properties = [
+		{
+			displayName: 'Authorization URL',
+			name: 'authUrl',
+			type: 'string' as NodePropertyTypes,
+			default: 'https://login.microsoftonline.com/{yourtenantid}/oauth2/v2.0/authorize',
+		},
+		{
+			displayName: 'Access Token URL',
+			name: 'accessTokenUrl',
+			type: 'string' as NodePropertyTypes,
+			default: 'https://login.microsoftonline.com/{yourtenantid}/oauth2/v2.0/token',
+		},
+		//https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-permissions-and-consent
+		{
+			displayName: 'Scope',
+			name: 'scope',
+			type: 'hidden' as NodePropertyTypes,
+			default: 'openid offline_access Files.ReadWrite',
+		},
+		{
+			displayName: 'Auth URI Query Parameters',
+			name: 'authQueryParameters',
+			type: 'hidden' as NodePropertyTypes,
+			default: 'response_mode=query',
+		},
+		{
+			displayName: 'Authentication',
+			name: 'authentication',
+			type: 'hidden' as NodePropertyTypes,
+			default: 'body',
+		},
+	];
+}

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

@@ -0,0 +1,73 @@
+import { OptionsWithUri } from 'request';
+import {
+	IExecuteFunctions,
+	IExecuteSingleFunctions,
+	ILoadOptionsFunctions,
+} from 'n8n-core';
+import {
+	IDataObject
+} from 'n8n-workflow';
+
+export async function microsoftApiRequest(this: IExecuteFunctions | IExecuteSingleFunctions | ILoadOptionsFunctions, method: string, resource: string, body: any = {}, qs: IDataObject = {}, uri?: string, headers: IDataObject = {}): Promise<any> { // tslint:disable-line:no-any
+	const options: OptionsWithUri = {
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		method,
+		body,
+		qs,
+		uri: uri || `https://graph.microsoft.com/v1.0/me${resource}`,
+		json: true
+	};
+	try {
+		if (Object.keys(headers).length !== 0) {
+			options.headers = Object.assign({}, options.headers, headers);
+		}
+		//@ts-ignore
+		return await this.helpers.requestOAuth.call(this, 'microsoftOAuth2Api', options);
+	} catch (error) {
+		if (error.response && error.response.body && error.response.body.error && error.response.body.error.message) {
+			// Try to return the error prettier
+			throw new Error(`Microsoft error response [${error.statusCode}]: ${error.response.body.error.message}`);
+		}
+		throw error;
+	}
+}
+
+export async function microsoftApiRequestAllItems(this: IExecuteFunctions | ILoadOptionsFunctions, propertyName: string ,method: string, endpoint: string, body: any = {}, query: IDataObject = {}): Promise<any> { // tslint:disable-line:no-any
+
+	const returnData: IDataObject[] = [];
+
+	let responseData;
+	let uri: string | undefined;
+	query['$top'] = 100;
+
+	do {
+		responseData = await microsoftApiRequest.call(this, method, endpoint, body, query, uri);
+		uri = responseData['@odata.nextLink'];
+		returnData.push.apply(returnData, responseData[propertyName]);
+	} while (
+		responseData['@odata.nextLink'] !== undefined
+	);
+
+	return returnData;
+}
+
+export async function microsoftApiRequestAllItemsSkip(this: IExecuteFunctions | ILoadOptionsFunctions, propertyName: string ,method: string, endpoint: string, body: any = {}, query: IDataObject = {}): Promise<any> { // tslint:disable-line:no-any
+
+	const returnData: IDataObject[] = [];
+
+	let responseData;
+	query['$top'] = 100;
+	query['$skip'] = 0;
+
+	do {
+		responseData = await microsoftApiRequest.call(this, method, endpoint, body, query);
+		query['$skip'] += query['$top'];
+		returnData.push.apply(returnData, responseData[propertyName]);
+	} while (
+		responseData['value'].length !== 0
+	);
+
+	return returnData;
+}

packages/nodes-base/nodes/Microsoft/MicrosoftExcel.node.ts

@@ -0,0 +1,335 @@
+import {
+	IExecuteFunctions,
+} from 'n8n-core';
+
+import {
+	IDataObject,
+	INodeExecutionData,
+	INodeTypeDescription,
+	INodeType,
+	ILoadOptionsFunctions,
+	INodePropertyOptions,
+} from 'n8n-workflow';
+
+import {
+	microsoftApiRequest,
+	microsoftApiRequestAllItems,
+	microsoftApiRequestAllItemsSkip,
+} from './GenericFunctions';
+
+import {
+	workbookOperations,
+	workbookFields,
+} from './WorkbookDescription';
+
+import {
+	worksheetOperations,
+	worksheetFields,
+} from './WorksheetDescription';
+
+import {
+	tableOperations,
+	tableFields,
+} from './TableDescription';
+
+export class MicrosoftExcel implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Microsoft Excel',
+		name: 'microsoftExcel',
+		icon: 'file:excel.png',
+		group: ['input'],
+		version: 1,
+		subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+		description: 'Consume Microsoft Excel API.',
+		defaults: {
+			name: 'Microsoft Excel',
+			color: '#1c6d40',
+		},
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: 'microsoftOAuth2Api',
+				required: true,
+			},
+		],
+		properties: [
+			{
+				displayName: 'Resource',
+				name: 'resource',
+				type: 'options',
+				options: [
+					{
+						name: 'Table',
+						value: 'table',
+						description: 'Represents an Excel table.',
+					},
+					{
+						name: 'Workbook',
+						value: 'workbook',
+						description: 'Workbook is the top level object which contains related workbook objects such as worksheets, tables, ranges, etc.',
+					},
+					{
+						name: 'Worksheet',
+						value: 'worksheet',
+						description: 'An Excel worksheet is a grid of cells. It can contain data, tables, charts, etc.',
+					},
+				],
+				default: 'workbook',
+				description: 'The resource to operate on.',
+			},
+			...workbookOperations,
+			...workbookFields,
+			...worksheetOperations,
+			...worksheetFields,
+			...tableOperations,
+			...tableFields,
+		],
+	};
+
+	methods = {
+		loadOptions: {
+			// Get all the workbooks to display them to user so that he can
+			// select them easily
+			async getWorkbooks(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+				const qs: IDataObject = {
+					select: 'id,name',
+				};
+				const returnData: INodePropertyOptions[] = [];
+				const workbooks = await microsoftApiRequestAllItems.call(this, 'value', 'GET', `/drive/root/search(q='.xlsx')`, {}, qs);
+				for (const workbook of workbooks) {
+					const workbookName = workbook.name;
+					const workbookId = workbook.id;
+					returnData.push({
+						name: workbookName,
+						value: workbookId,
+					});
+				}
+				return returnData;
+			},
+			// Get all the worksheets to display them to user so that he can
+			// select them easily
+			async getworksheets(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+				const workbookId = this.getCurrentNodeParameter('workbook');
+				const qs: IDataObject = {
+					select: 'id,name',
+				};
+				const returnData: INodePropertyOptions[] = [];
+				const worksheets = await microsoftApiRequestAllItems.call(this, 'value', 'GET', `/drive/items/${workbookId}/workbook/worksheets`, {}, qs);
+				for (const worksheet of worksheets) {
+					const worksheetName = worksheet.name;
+					const worksheetId = worksheet.id;
+					returnData.push({
+						name: worksheetName,
+						value: worksheetId,
+					});
+				}
+				return returnData;
+			},
+			// Get all the tables to display them to user so that he can
+			// select them easily
+			async getTables(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+				const workbookId = this.getCurrentNodeParameter('workbook');
+				const worksheetId = this.getCurrentNodeParameter('worksheet');
+				const qs: IDataObject = {
+					select: 'id,name',
+				};
+				const returnData: INodePropertyOptions[] = [];
+				const tables = await microsoftApiRequestAllItems.call(this, 'value', 'GET', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/tables`, {}, qs);
+				for (const table of tables) {
+					const tableName = table.name;
+					const tableId = table.id;
+					returnData.push({
+						name: tableName,
+						value: tableId,
+					});
+				}
+				return returnData;
+			},
+		}
+	};
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const items = this.getInputData();
+		const returnData: IDataObject[] = [];
+		const length = items.length as unknown as number;
+		const qs: IDataObject = {};
+		const result: IDataObject[] = [];
+		const object: IDataObject = {};
+		let responseData;
+		const resource = this.getNodeParameter('resource', 0) as string;
+		const operation = this.getNodeParameter('operation', 0) as string;
+		if (resource === 'table') {
+			//https://docs.microsoft.com/en-us/graph/api/table-post-rows?view=graph-rest-1.0&tabs=http
+			if (operation === 'addRow') {
+				const workbookId = this.getNodeParameter('workbook', 0) as string;
+				const worksheetId = this.getNodeParameter('worksheet', 0) as string;
+				const tableId = this.getNodeParameter('table', 0) as string;
+				const additionalFields = this.getNodeParameter('additionalFields', 0) as IDataObject;
+				const body: IDataObject = {};
+				if (Object.keys(items[0].json).length === 0) {
+					throw new Error('Input cannot be empty');
+				}
+				if (additionalFields.index) {
+					body.index = additionalFields.index as number;
+				}
+				const values: any[][] = [];
+				for (const item of items) {
+					values.push(Object.values(item.json));
+				}
+				body.values = values;
+				const { id } = await microsoftApiRequest.call(this, 'POST', `/drive/items/${workbookId}/workbook/createSession`, { persistChanges: true });
+				responseData = await microsoftApiRequest.call(this, 'POST', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/tables/${tableId}/rows/add`, body, {}, '', { 'workbook-session-id': id });
+				await microsoftApiRequest.call(this, 'POST', `/drive/items/${workbookId}/workbook/closeSession`, {}, {}, '', { 'workbook-session-id': id });
+			}
+			//https://docs.microsoft.com/en-us/graph/api/table-list-columns?view=graph-rest-1.0&tabs=http
+			if (operation === 'getColumns') {
+				for (let i = 0; i < length; i++) {
+					const workbookId = this.getNodeParameter('workbook', 0) as string;
+					const worksheetId = this.getNodeParameter('worksheet', 0) as string;
+					const tableId = this.getNodeParameter('table', 0) as string;
+					const returnAll = this.getNodeParameter('returnAll', i) as boolean;
+					const rawData = this.getNodeParameter('rawData', i) as boolean;
+					if (rawData) {
+						const filters = this.getNodeParameter('filters', i) as IDataObject;
+						if (filters.fields) {
+							qs['$select'] = filters.fields;
+						}
+					}
+					if (returnAll === true) {
+						responseData = await microsoftApiRequestAllItemsSkip.call(this, 'value', 'GET', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/tables/${tableId}/columns`, {}, qs);
+					} else {
+						qs['$top'] = this.getNodeParameter('limit', i) as number;
+						responseData = await microsoftApiRequest.call(this, 'GET', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/tables/${tableId}/columns`, {}, qs);
+						responseData = responseData.value;
+					}
+					if (!rawData) {
+						//@ts-ignore
+						responseData = responseData.map(column => ({ name: column.name }));
+					}
+				}
+			}
+			//https://docs.microsoft.com/en-us/graph/api/table-list-rows?view=graph-rest-1.0&tabs=http
+			if (operation === 'getRows') {
+				for (let i = 0; i < length; i++) {
+					const workbookId = this.getNodeParameter('workbook', 0) as string;
+					const worksheetId = this.getNodeParameter('worksheet', 0) as string;
+					const tableId = this.getNodeParameter('table', 0) as string;
+					const returnAll = this.getNodeParameter('returnAll', i) as boolean;
+					const rawData = this.getNodeParameter('rawData', i) as boolean;
+					if (rawData) {
+						const filters = this.getNodeParameter('filters', i) as IDataObject;
+						if (filters.fields) {
+							qs['$select'] = filters.fields;
+						}
+					}
+					if (returnAll === true) {
+						responseData = await microsoftApiRequestAllItemsSkip.call(this, 'value', 'GET', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/tables/${tableId}/rows`, {}, qs);
+					} else {
+						qs['$top'] = this.getNodeParameter('limit', i) as number;
+						responseData = await microsoftApiRequest.call(this, 'GET', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/tables/${tableId}/rows`, {}, qs);
+						responseData = responseData.value;
+					}
+					if (!rawData) {
+						qs['$select'] = 'name';
+						let columns = await microsoftApiRequestAllItemsSkip.call(this, 'value', 'GET', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/tables/${tableId}/columns`, {}, qs);
+						//@ts-ignore
+						columns = columns.map(column => column.name);
+						for (let i = 0; i < responseData.length; i++) {
+							for (let y = 0; y < columns.length; y++) {
+								object[columns[y]] = responseData[i].values[0][y];
+							}
+							result.push({ ...object });
+						}
+						responseData = result;
+					}
+				}
+			}
+		}
+		if (resource === 'workbook') {
+			for (let i = 0; i < length; i++) {
+				//https://docs.microsoft.com/en-us/graph/api/worksheetcollection-add?view=graph-rest-1.0&tabs=http
+				if (operation === 'addWorksheet') {
+					const workbookId = this.getNodeParameter('workbook', i) as string;
+					const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;
+					const body: IDataObject = {};
+					if (additionalFields.name) {
+						body.name = additionalFields.name;
+					}
+					const { id } = await microsoftApiRequest.call(this, 'POST', `/drive/items/${workbookId}/workbook/createSession`, { persistChanges: true });
+					responseData = await microsoftApiRequest.call(this, 'POST', `/drive/items/${workbookId}/workbook/worksheets/add`, body, {}, '', { 'workbook-session-id': id });
+					await microsoftApiRequest.call(this, 'POST', `/drive/items/${workbookId}/workbook/closeSession`, {}, {}, '', { 'workbook-session-id': id });
+				}
+				if (operation === 'getAll') {
+					const returnAll = this.getNodeParameter('returnAll', i) as boolean;
+					const filters = this.getNodeParameter('filters', i) as IDataObject;
+					if (filters.fields) {
+						qs['$select'] = filters.fields;
+					}
+					if (returnAll === true) {
+						responseData = await microsoftApiRequestAllItems.call(this, 'value', 'GET', `/drive/root/search(q='.xlsx')`, {}, qs);
+					} else {
+						qs['$top'] = this.getNodeParameter('limit', i) as number;
+						responseData = await microsoftApiRequest.call(this, 'GET', `/drive/root/search(q='.xlsx')`, {}, qs);
+						responseData = responseData.value;
+					}
+				}
+			}
+		}
+		if (resource === 'worksheet') {
+			for (let i = 0; i < length; i++) {
+				//https://docs.microsoft.com/en-us/graph/api/workbook-list-worksheets?view=graph-rest-1.0&tabs=http
+				if (operation === 'getAll') {
+					const returnAll = this.getNodeParameter('returnAll', i) as boolean;
+					const workbookId = this.getNodeParameter('workbook', i) as string;
+					const filters = this.getNodeParameter('filters', i) as IDataObject;
+					if (filters.fields) {
+						qs['$select'] = filters.fields;
+					}
+					if (returnAll === true) {
+						responseData = await microsoftApiRequestAllItems.call(this, 'value', 'GET', `/drive/items/${workbookId}/workbook/worksheets`, {}, qs);
+					} else {
+						qs['$top'] = this.getNodeParameter('limit', i) as number;
+						responseData = await microsoftApiRequest.call(this, 'GET', `/drive/items/${workbookId}/workbook/worksheets`, {}, qs);
+						responseData = responseData.value;
+					}
+				}
+				//https://docs.microsoft.com/en-us/graph/api/worksheet-range?view=graph-rest-1.0&tabs=http
+				if (operation === 'getContent') {
+					const workbookId = this.getNodeParameter('workbook', i) as string;
+					const worksheetId = this.getNodeParameter('worksheet', i) as string;
+					const range = this.getNodeParameter('range', i) as string;
+					const rawData = this.getNodeParameter('rawData', i) as boolean;
+					if (rawData) {
+						const filters = this.getNodeParameter('filters', i) as IDataObject;
+						if (filters.fields) {
+							qs['$select'] = filters.fields;
+						}
+					}
+					responseData = await microsoftApiRequest.call(this, 'GET', `/drive/items/${workbookId}/workbook/worksheets/${worksheetId}/range(address='${range}')`, {}, qs);
+					if (!rawData) {
+						const keyRow = this.getNodeParameter('keyRow', i) as number;
+						const dataStartRow = this.getNodeParameter('dataStartRow', i) as number;
+						if (responseData.values === null) {
+							throw new Error('Range did not return data');
+						}
+						const keyValues = responseData.values[keyRow];
+						for (let i = dataStartRow; i < responseData.values.length; i++) {
+							for (let y = 0; y < keyValues.length; y++) {
+								object[keyValues[y]] = responseData.values[i][y];
+							}
+							result.push({ ...object });
+						}
+						responseData = result;
+					}
+				}
+			}
+		}
+		if (Array.isArray(responseData)) {
+			returnData.push.apply(returnData, responseData as IDataObject[]);
+		} else if (responseData !== undefined) {
+			returnData.push(responseData as IDataObject);
+		}
+		return [this.helpers.returnJsonArray(returnData)];
+	}
+}

packages/nodes-base/nodes/Microsoft/TableDescription.ts

@@ -0,0 +1,447 @@
+import { INodeProperties } from "n8n-workflow";
+
+export const tableOperations = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		displayOptions: {
+			show: {
+				resource: [
+					'table',
+				],
+			},
+		},
+		options: [
+			{
+				name: 'Add Row',
+				value: 'addRow',
+				description: 'Adds rows to the end of the table'
+			},
+			{
+				name: 'Get Columns',
+				value: 'getColumns',
+				description: 'Retrieve a list of tablecolumns',
+			},
+			{
+				name: 'Get Rows',
+				value: 'getRows',
+				description: 'Retrieve a list of tablerows',
+			},
+		],
+		default: 'addRow',
+		description: 'The operation to perform.',
+	},
+] as INodeProperties[];
+
+export const tableFields = [
+
+/* -------------------------------------------------------------------------- */
+/*                                 table:addRow                               */
+/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Workbook',
+		name: 'workbook',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWorkbooks',
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'addRow',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Worksheet',
+		name: 'worksheet',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getworksheets',
+			loadOptionsDependsOn: [
+				'workbook',
+			],
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'addRow',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Table',
+		name: 'table',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getTables',
+			loadOptionsDependsOn: [
+				'worksheet',
+			],
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'addRow',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: [
+					'addRow',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		options: [
+			{
+				displayName: 'Index',
+				name: 'index',
+				type: 'number',
+				default: 0,
+				typeOptions: {
+					minValue: 0,
+				},
+				description: `Specifies the relative position of the new row. If not defined,</br>
+				 the addition happens at the end. Any rows below the inserted row are shifted downwards. Zero-indexed`,
+			},
+		],
+	},
+/* -------------------------------------------------------------------------- */
+/*                                 table:getRows                              */
+/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Workbook',
+		name: 'workbook',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWorkbooks',
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getRows',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Worksheet',
+		name: 'worksheet',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getworksheets',
+			loadOptionsDependsOn: [
+				'workbook',
+			],
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getRows',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Table',
+		name: 'table',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getTables',
+			loadOptionsDependsOn: [
+				'worksheet',
+			],
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getRows',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: [
+					'getRows',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: false,
+		description: 'If all results should be returned or only up to a given limit.',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: [
+					'getRows',
+				],
+				resource: [
+					'table',
+				],
+				returnAll: [
+					false,
+				],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 100,
+		description: 'How many results to return.',
+	},
+	{
+		displayName: 'RAW Data',
+		name: 'rawData',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: [
+					'getRows',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: false,
+		description: 'If the data should be returned RAW instead of parsed into keys according to their header.',
+	},
+	{
+		displayName: 'Filters',
+		name: 'filters',
+		type: 'collection',
+		placeholder: 'Add Filter',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: [
+					'getRows',
+				],
+				resource: [
+					'table',
+				],
+				rawData: [
+					true,
+				],
+			},
+		},
+		options: [
+			{
+				displayName: 'Fields',
+				name: 'fields',
+				type: 'string',
+				default: '',
+				description: `Fields the response will containt. Multiple can be added separated by ,.`,
+			},
+		]
+	},
+/* -------------------------------------------------------------------------- */
+/*                                 table:getColumns                           */
+/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Workbook',
+		name: 'workbook',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWorkbooks',
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getColumns',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Worksheet',
+		name: 'worksheet',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getworksheets',
+			loadOptionsDependsOn: [
+				'workbook',
+			],
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getColumns',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Table',
+		name: 'table',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getTables',
+			loadOptionsDependsOn: [
+				'worksheet',
+			],
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getColumns',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: [
+					'getColumns',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: false,
+		description: 'If all results should be returned or only up to a given limit.',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: [
+					'getColumns',
+				],
+				resource: [
+					'table',
+				],
+				returnAll: [
+					false,
+				],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 100,
+		description: 'How many results to return.',
+	},
+	{
+		displayName: 'RAW Data',
+		name: 'rawData',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: [
+					'getColumns',
+				],
+				resource: [
+					'table',
+				],
+			},
+		},
+		default: false,
+		description: 'If the data should be returned RAW instead of parsed into keys according to their header.',
+	},
+	{
+		displayName: 'Filters',
+		name: 'filters',
+		type: 'collection',
+		placeholder: 'Add Filter',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: [
+					'getColumns',
+				],
+				resource: [
+					'table',
+				],
+				rawData: [
+					true
+				],
+			},
+		},
+		options: [
+			{
+				displayName: 'Fields',
+				name: 'fields',
+				type: 'string',
+				default: '',
+				description: `Fields the response will containt. Multiple can be added separated by ,.`,
+			},
+		]
+	},
+] as INodeProperties[];

packages/nodes-base/nodes/Microsoft/WorkbookDescription.ts

@@ -0,0 +1,154 @@
+import { INodeProperties } from "n8n-workflow";
+
+export const workbookOperations = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		displayOptions: {
+			show: {
+				resource: [
+					'workbook',
+				],
+			},
+		},
+		options: [
+			{
+				name: 'Add Worksheet',
+				value: 'addWorksheet',
+				description: 'Adds a new worksheet to the workbook.',
+			},
+			{
+				name: 'Get All',
+				value: 'getAll',
+				description: 'Get data of all workbooks',
+			},
+		],
+		default: 'create',
+		description: 'The operation to perform.',
+	},
+] as INodeProperties[];
+
+export const workbookFields = [
+
+/* -------------------------------------------------------------------------- */
+/*                                 workbook:addWorksheet                      */
+/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Workbook',
+		name: 'workbook',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getWorkbooks',
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'addWorksheet',
+				],
+				resource: [
+					'workbook',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Additional Fields',
+		name: 'additionalFields',
+		type: 'collection',
+		placeholder: 'Add Field',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: [
+					'addWorksheet',
+				],
+				resource: [
+					'workbook',
+				],
+			},
+		},
+		options: [
+			{
+				displayName: 'Name',
+				name: 'name',
+				type: 'string',
+				default: '',
+				description: `The name of the worksheet to be added. If specified, name should be unqiue. </BR>
+				If not specified, Excel determines the name of the new worksheet.`,
+			},
+		]
+	},
+/* -------------------------------------------------------------------------- */
+/*                                 workbook:getAll                            */
+/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: [
+					'getAll',
+				],
+				resource: [
+					'workbook',
+				],
+			},
+		},
+		default: false,
+		description: 'If all results should be returned or only up to a given limit.',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: [
+					'getAll',
+				],
+				resource: [
+					'workbook',
+				],
+				returnAll: [
+					false,
+				],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 100,
+		description: 'How many results to return.',
+	},
+	{
+		displayName: 'Filters',
+		name: 'filters',
+		type: 'collection',
+		placeholder: 'Add Filter',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: [
+					'getAll',
+				],
+				resource: [
+					'workbook',
+				],
+			},
+		},
+		options: [
+			{
+				displayName: 'Fields',
+				name: 'fields',
+				type: 'string',
+				default: '',
+				description: `Fields the response will containt. Multiple can be added separated by ,.`,
+			},
+		]
+	},
+] as INodeProperties[];

packages/nodes-base/nodes/Microsoft/WorksheetDescription.ts

@@ -0,0 +1,283 @@
+import { INodeProperties } from "n8n-workflow";
+
+export const worksheetOperations = [
+	{
+		displayName: 'Operation',
+		name: 'operation',
+		type: 'options',
+		displayOptions: {
+			show: {
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		options: [
+			{
+				name: 'Get All',
+				value: 'getAll',
+				description: 'Get all worksheets',
+			},
+			{
+				name: 'Get Content',
+				value: 'getContent',
+				description: 'Get worksheet content',
+			},
+		],
+		default: 'create',
+		description: 'The operation to perform.',
+	},
+] as INodeProperties[];
+
+export const worksheetFields = [
+
+/* -------------------------------------------------------------------------- */
+/*                                 worksheet:getAll                           */
+/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Workbook',
+		name: 'workbook',
+		type: 'options',
+		typeOptions: {
+			loadOptionsMethod: 'getWorkbooks',
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getAll',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Return All',
+		name: 'returnAll',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: [
+					'getAll',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		default: false,
+		description: 'If all results should be returned or only up to a given limit.',
+	},
+	{
+		displayName: 'Limit',
+		name: 'limit',
+		type: 'number',
+		displayOptions: {
+			show: {
+				operation: [
+					'getAll',
+				],
+				resource: [
+					'worksheet',
+				],
+				returnAll: [
+					false,
+				],
+			},
+		},
+		typeOptions: {
+			minValue: 1,
+			maxValue: 500,
+		},
+		default: 100,
+		description: 'How many results to return.',
+	},
+	{
+		displayName: 'Filters',
+		name: 'filters',
+		type: 'collection',
+		placeholder: 'Add Filter',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: [
+					'getAll',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		options: [
+			{
+				displayName: 'Fields',
+				name: 'fields',
+				type: 'string',
+				default: '',
+				description: `Fields the response will containt. Multiple can be added separated by ,.`,
+			},
+		]
+	},
+/* -------------------------------------------------------------------------- */
+/*                                 worksheet:getContent                       */
+/* -------------------------------------------------------------------------- */
+	{
+		displayName: 'Workbook',
+		name: 'workbook',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getWorkbooks',
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getContent',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Worksheet',
+		name: 'worksheet',
+		type: 'options',
+		required: true,
+		typeOptions: {
+			loadOptionsMethod: 'getworksheets',
+			loadOptionsDependsOn: [
+				'workbook',
+			],
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getContent',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		default: '',
+	},
+	{
+		displayName: 'Range',
+		name: 'range',
+		type: 'string',
+		displayOptions: {
+			show: {
+				operation: [
+					'getContent',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		default: 'A1:C3',
+		required: true,
+		description: 'The address or the name of the range. If not specified, the entire worksheet range is returned.',
+	},
+	{
+		displayName: 'RAW Data',
+		name: 'rawData',
+		type: 'boolean',
+		displayOptions: {
+			show: {
+				operation: [
+					'getContent',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+		},
+		default: false,
+		description: 'If the data should be returned RAW instead of parsed into keys according to their header.',
+	},
+	{
+		displayName: 'Data Start Row',
+		name: 'dataStartRow',
+		type: 'number',
+		typeOptions: {
+			minValue: 1,
+		},
+		default: 1,
+		displayOptions: {
+			show: {
+				operation: [
+					'getContent',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+			hide: {
+				rawData: [
+					true
+				],
+			},
+		},
+		description: 'Index of the first row which contains<br />the actual data and not the keys. Starts with 0.',
+	},
+	{
+		displayName: 'Key Row',
+		name: 'keyRow',
+		type: 'number',
+		typeOptions: {
+			minValue: 0,
+		},
+		displayOptions: {
+			show: {
+				operation: [
+					'getContent',
+				],
+				resource: [
+					'worksheet',
+				],
+			},
+			hide: {
+				rawData: [
+					true
+				],
+			},
+		},
+		default: 0,
+		description: 'Index of the row which contains the keys. Starts at 0.<br />The incoming node data is matched to the keys for assignment. The matching is case sensitve.',
+	},
+	{
+		displayName: 'Filters',
+		name: 'filters',
+		type: 'collection',
+		placeholder: 'Add Filter',
+		default: {},
+		displayOptions: {
+			show: {
+				operation: [
+					'getContent',
+				],
+				resource: [
+					'worksheet',
+				],
+				rawData: [
+					true,
+				],
+			},
+		},
+		options: [
+			{
+				displayName: 'Fields',
+				name: 'fields',
+				type: 'string',
+				default: '',
+				description: `Fields the response will containt. Multiple can be added separated by ,.`,
+			},
+		]
+	},
+] as INodeProperties[];

packages/nodes-base/package.json

@@ -55,6 +55,7 @@
             "dist/credentials/MailgunApi.credentials.js",
             "dist/credentials/MandrillApi.credentials.js",
 			"dist/credentials/MattermostApi.credentials.js",
+			"dist/credentials/MicrosoftOAuth2Api.credentials.js",
             "dist/credentials/MongoDb.credentials.js",
             "dist/credentials/MySql.credentials.js",
             "dist/credentials/NextCloudApi.credentials.js",
@@ -133,6 +134,7 @@
             "dist/nodes/Mandrill/Mandrill.node.js",
             "dist/nodes/Mattermost/Mattermost.node.js",
 			"dist/nodes/Merge.node.js",
+			"dist/nodes/Microsoft/MicrosoftExcel.node.js",
             "dist/nodes/MoveBinaryData.node.js",
             "dist/nodes/MongoDb/MongoDb.node.js",
             "dist/nodes/MySql/MySql.node.js",