Merge branch 'oauth-support' into feature/oauth1-support

packages/nodes-base/nodes/Google/Sheet/GenericFunctions.ts

@@ -0,0 +1,129 @@
+import {
+	OptionsWithUri,
+ } from 'request';
+
+import {
+	IExecuteFunctions,
+	IExecuteSingleFunctions,
+	ILoadOptionsFunctions,
+} from 'n8n-core';
+
+import {
+	IDataObject,
+} from 'n8n-workflow';
+
+import * as moment from 'moment-timezone';
+
+import * as jwt from 'jsonwebtoken';
+
+export async function googleApiRequest(this: IExecuteFunctions | IExecuteSingleFunctions | ILoadOptionsFunctions, method: string, resource: string, body: any = {}, qs: IDataObject = {}, uri?: string, headers: IDataObject = {}): Promise<any> { // tslint:disable-line:no-any
+	const authenticationMethod = this.getNodeParameter('authentication', 0, 'serviceAccount') as string;
+	const options: OptionsWithUri = {
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		method,
+		body,
+		qs,
+		uri: uri || `https://sheets.googleapis.com${resource}`,
+		json: true
+	};
+	try {
+		if (Object.keys(headers).length !== 0) {
+			options.headers = Object.assign({}, options.headers, headers);
+		}
+		if (Object.keys(body).length === 0) {
+			delete options.body;
+		}
+
+		if (authenticationMethod === 'serviceAccount') {
+			const credentials = this.getCredentials('googleApi');
+
+			if (credentials === undefined) {
+				throw new Error('No credentials got returned!');
+			}
+
+			const { access_token } = await getAccessToken.call(this, credentials as IDataObject);
+
+			options.headers!.Authorization = `Bearer ${access_token}`;
+			//@ts-ignore
+			return await this.helpers.request(options);
+		} else {
+			//@ts-ignore
+			return await this.helpers.requestOAuth2.call(this, 'googleSheetsOAuth2Api', options);
+		}
+	} catch (error) {
+		if (error.response && error.response.body && error.response.body.message) {
+			// Try to return the error prettier
+			throw new Error(`Google Sheet error response [${error.statusCode}]: ${error.response.body.message}`);
+		}
+		throw error;
+	}
+}
+
+export async function googleApiRequestAllItems(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.maxResults = 100;
+
+	do {
+		responseData = await googleApiRequest.call(this, method, endpoint, body, query);
+		query.pageToken = responseData['nextPageToken'];
+		returnData.push.apply(returnData, responseData[propertyName]);
+	} while (
+		responseData['nextPageToken'] !== undefined &&
+		responseData['nextPageToken'] !== ''
+	);
+
+	return returnData;
+}
+
+function getAccessToken(this: IExecuteFunctions | IExecuteSingleFunctions | ILoadOptionsFunctions, credentials: IDataObject) : Promise<IDataObject> {
+	//https://developers.google.com/identity/protocols/oauth2/service-account#httprest
+
+	const scopes = [
+		'https://www.googleapis.com/auth/drive',
+		'https://www.googleapis.com/auth/drive.file',
+		'https://www.googleapis.com/auth/spreadsheets',
+	];
+
+	const now = moment().unix();
+
+	const signature = jwt.sign(
+		{
+		  'iss': credentials.email as string,
+		  'sub': credentials.email as string,
+		  'scope': scopes.join(' '),
+		  'aud': `https://oauth2.googleapis.com/token`,
+		  'iat': now,
+		  'exp': now + 3600,
+		},
+		credentials.privateKey as string,
+		{
+		  algorithm: 'RS256',
+		  header: {
+			'kid': credentials.privateKey as string,
+			'typ': 'JWT',
+			'alg': 'RS256',
+		  },
+		}
+	  );
+
+	  const options: OptionsWithUri = {
+		headers: {
+			'Content-Type': 'application/x-www-form-urlencoded',
+		},
+		method: 'POST',
+		form: {
+			grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+			assertion: signature,
+		},
+		uri: 'https://oauth2.googleapis.com/token',
+		json: true
+	};
+
+	//@ts-ignore
+	return this.helpers.request(options);
+}

packages/nodes-base/nodes/Google/Sheet/GoogleSheet.ts

@@ -0,0 +1,468 @@
+import {
+	IDataObject,
+} from 'n8n-workflow';
+
+import {
+	IExecuteFunctions,
+	ILoadOptionsFunctions,
+ } from 'n8n-core';
+
+import {
+	googleApiRequest,
+ } from './GenericFunctions';
+
+import {
+	utils as xlsxUtils,
+} from 'xlsx';
+
+export interface ISheetOptions {
+	scope: string[];
+}
+
+export interface IGoogleAuthCredentials {
+	email: string;
+	privateKey: string;
+}
+
+export interface ISheetUpdateData {
+	range: string;
+	values: string[][];
+}
+
+export interface ILookupValues {
+	lookupColumn: string;
+	lookupValue: string;
+}
+
+export interface IToDeleteRange {
+	amount: number;
+	startIndex: number;
+	sheetId: number;
+}
+
+export interface IToDelete {
+	[key: string]: IToDeleteRange[] | undefined;
+	columns?: IToDeleteRange[];
+	rows?: IToDeleteRange[];
+}
+
+export type ValueInputOption = 'RAW' | 'USER_ENTERED';
+
+export type ValueRenderOption = 'FORMATTED_VALUE' | 'FORMULA' | 'UNFORMATTED_VALUE';
+
+export class GoogleSheet {
+	id: string;
+	executeFunctions: IExecuteFunctions | ILoadOptionsFunctions;
+
+	constructor(spreadsheetId: string, executeFunctions: IExecuteFunctions | ILoadOptionsFunctions, options?: ISheetOptions | undefined) {
+		// options = <SheetOptions>options || {};
+		if (!options) {
+			options = {} as ISheetOptions;
+		}
+
+		this.executeFunctions = executeFunctions;
+		this.id = spreadsheetId;
+	}
+
+
+	/**
+	 * Clears values from a sheet
+	 *
+	 * @param {string} range
+	 * @returns {Promise<object>}
+	 * @memberof GoogleSheet
+	 */
+	async clearData(range: string): Promise<object> {
+
+		const body = {
+			spreadsheetId: this.id,
+			range,
+		};
+
+		const response = await googleApiRequest.call(this.executeFunctions, 'POST', `/v4/spreadsheets/${this.id}/values/${range}:clear`, body);
+
+		return response;
+	}
+
+    /**
+     * Returns the cell values
+     */
+	async getData(range: string, valueRenderMode: ValueRenderOption): Promise<string[][] | undefined> {
+
+		const query = {
+			valueRenderOption: valueRenderMode,
+		};
+
+		const response = await googleApiRequest.call(this.executeFunctions, 'GET', `/v4/spreadsheets/${this.id}/values/${range}`, {}, query);
+
+		return response.values as string[][] | undefined;
+	}
+
+
+	/**
+	 * Returns the sheets in a Spreadsheet
+	 */
+	async spreadsheetGetSheets() {
+
+		const query = {
+			fields: 'sheets.properties',
+		};
+
+		const response = await googleApiRequest.call(this.executeFunctions, 'GET', `/v4/spreadsheets/${this.id}`, {}, query);
+
+		return response;
+	}
+
+
+	/**
+	 * Sets values in one or more ranges of a spreadsheet.
+	 */
+	async spreadsheetBatchUpdate(requests: IDataObject[]) { // tslint:disable-line:no-any
+
+		const body = {
+			requests
+		};
+
+		const response = await googleApiRequest.call(this.executeFunctions, 'POST', `/v4/spreadsheets/${this.id}:batchUpdate`, body);
+
+		return response;
+	}
+
+
+    /**
+     * Sets the cell values
+     */
+	async batchUpdate(updateData: ISheetUpdateData[], valueInputMode: ValueInputOption) {
+
+		const body = {
+			data: updateData,
+			valueInputOption: valueInputMode,
+		};
+
+		const response = await googleApiRequest.call(this.executeFunctions, 'POST', `/v4/spreadsheets/${this.id}/values:batchUpdate`, body);
+
+		return response;
+	}
+
+
+    /**
+     * Sets the cell values
+     */
+	async setData(range: string, data: string[][], valueInputMode: ValueInputOption) {
+
+		const body = {
+			valueInputOption: valueInputMode,
+			values: data,
+		};
+
+		const response = await googleApiRequest.call(this.executeFunctions, 'POST', `/v4/spreadsheets/${this.id}/values/${range}`, body);
+
+		return response;
+	}
+
+
+    /**
+     * Appends the cell values
+     */
+	async appendData(range: string, data: string[][], valueInputMode: ValueInputOption) {
+
+		const body = {
+			range,
+			values: data,
+		};
+
+		const query = {
+			valueInputOption: valueInputMode,
+		};
+
+		const response = await googleApiRequest.call(this.executeFunctions, 'POST', `/v4/spreadsheets/${this.id}/values/${range}:append`, body, query);
+
+		return response;
+	}
+
+    /**
+     * Returns the given sheet data in a strucutred way
+     */
+	structureData(inputData: string[][], startRow: number, keys: string[], addEmpty?: boolean): IDataObject[] {
+		const returnData = [];
+
+		let tempEntry: IDataObject, rowIndex: number, columnIndex: number, key: string;
+
+		for (rowIndex = startRow; rowIndex < inputData.length; rowIndex++) {
+			tempEntry = {};
+			for (columnIndex = 0; columnIndex < inputData[rowIndex].length; columnIndex++) {
+				key = keys[columnIndex];
+				if (key) {
+					// Only add the data for which a key was given and ignore all others
+					tempEntry[key] = inputData[rowIndex][columnIndex];
+				}
+			}
+			if (Object.keys(tempEntry).length || addEmpty === true) {
+				// Only add the entry if data got found to not have empty ones
+				returnData.push(tempEntry);
+			}
+		}
+
+		return returnData;
+	}
+
+
+    /**
+     * Returns the given sheet data in a strucutred way using
+     * the startRow as the one with the name of the key
+     */
+	structureArrayDataByColumn(inputData: string[][], keyRow: number, dataStartRow: number): IDataObject[] {
+
+		const keys: string[] = [];
+
+		if (keyRow < 0 || dataStartRow < keyRow || keyRow >= inputData.length) {
+			// The key row does not exist so it is not possible to strucutre data
+			return [];
+		}
+
+		// Create the keys array
+		for (let columnIndex = 0; columnIndex < inputData[keyRow].length; columnIndex++) {
+			keys.push(inputData[keyRow][columnIndex]);
+		}
+
+		return this.structureData(inputData, dataStartRow, keys);
+	}
+
+
+	async appendSheetData(inputData: IDataObject[], range: string, keyRowIndex: number, valueInputMode: ValueInputOption): Promise<string[][]> {
+		const data = await this.convertStructuredDataToArray(inputData, range, keyRowIndex);
+		return this.appendData(range, data, valueInputMode);
+	}
+
+
+	getColumnWithOffset (startColumn: string, offset: number): string {
+		const columnIndex = xlsxUtils.decode_col(startColumn) + offset;
+		return xlsxUtils.encode_col(columnIndex);
+	}
+
+
+	/**
+	 * Updates data in a sheet
+	 *
+	 * @param {IDataObject[]} inputData Data to update Sheet with
+	 * @param {string} indexKey The name of the key which gets used to know which rows to update
+	 * @param {string} range The range to look for data
+	 * @param {number} keyRowIndex Index of the row which contains the keys
+	 * @param {number} dataStartRowIndex Index of the first row which contains data
+	 * @returns {Promise<string[][]>}
+	 * @memberof GoogleSheet
+	 */
+	async updateSheetData(inputData: IDataObject[], indexKey: string, range: string, keyRowIndex: number, dataStartRowIndex: number, valueInputMode: ValueInputOption, valueRenderMode: ValueRenderOption): Promise<string[][]> {
+		// Get current data in Google Sheet
+		let rangeStart: string, rangeEnd: string;
+		let sheet: string | undefined = undefined;
+		if (range.includes('!')) {
+			[sheet, range] = range.split('!');
+		}
+		[rangeStart, rangeEnd] = range.split(':');
+
+		const rangeStartSplit = rangeStart.match(/([a-zA-Z]{1,10})([0-9]{0,10})/);
+		const rangeEndSplit = rangeEnd.match(/([a-zA-Z]{1,10})([0-9]{0,10})/);
+
+		if (rangeStartSplit === null || rangeStartSplit.length !== 3 || rangeEndSplit === null || rangeEndSplit.length !== 3) {
+			throw new Error(`The range "${range}" is not valid.`);
+		}
+
+		const keyRowRange = `${sheet ? sheet + '!' : ''}${rangeStartSplit[1]}${dataStartRowIndex}:${rangeEndSplit[1]}${dataStartRowIndex}`;
+
+		const sheetDatakeyRow = await this.getData(keyRowRange, valueRenderMode);
+
+		if (sheetDatakeyRow === undefined) {
+			throw new Error('Could not retrieve the key row!');
+		}
+
+		const keyColumnOrder = sheetDatakeyRow[0];
+
+		const keyIndex = keyColumnOrder.indexOf(indexKey);
+
+		if (keyIndex === -1) {
+			throw new Error(`Could not find column for key "${indexKey}"!`);
+		}
+
+		const startRowIndex = rangeStartSplit[2] || '';
+		const endRowIndex = rangeEndSplit[2] || '';
+
+		const keyColumn = this.getColumnWithOffset(rangeStartSplit[1], keyIndex);
+		const keyColumnRange = `${sheet ? sheet + '!' : ''}${keyColumn}${startRowIndex}:${keyColumn}${endRowIndex}`;
+
+		const sheetDataKeyColumn = await this.getData(keyColumnRange, valueRenderMode);
+
+		if (sheetDataKeyColumn === undefined) {
+			throw new Error('Could not retrieve the key column!');
+		}
+
+		// TODO: The data till here can be cached optionally. Maybe add an option which can
+		//       can be activated if it is used in a loop and nothing else updates the data.
+
+		// Remove the first row which contains the key
+		sheetDataKeyColumn.shift();
+
+		// Create an Array which all the key-values of the Google Sheet
+		const keyColumnIndexLookup = sheetDataKeyColumn.map((rowContent) => rowContent[0] );
+
+		const updateData: ISheetUpdateData[] = [];
+		let itemKey: string | number | undefined | null;
+		let propertyName: string;
+		let itemKeyIndex: number;
+		let updateRowIndex: number;
+		let updateColumnName: string;
+		for (const inputItem of inputData) {
+			itemKey = inputItem[indexKey] as string;
+			// if ([undefined, null].includes(inputItem[indexKey] as string | undefined | null)) {
+			if (itemKey === undefined || itemKey === null) {
+				// Item does not have the indexKey so we can ignore it
+				continue;
+			}
+
+			// Item does have the key so check if it exists in Sheet
+			itemKeyIndex = keyColumnIndexLookup.indexOf(itemKey as string);
+			if (itemKeyIndex === -1) {
+				// Key does not exist in the Sheet so it can not be updated so skip it
+				continue;
+			}
+
+			// Get the row index in which the data should be updated
+			updateRowIndex = keyColumnIndexLookup.indexOf(itemKey) + dataStartRowIndex + 1;
+
+			// Check all the properties in the sheet and check which ones exist on the
+			// item and should be updated
+			for (propertyName of keyColumnOrder) {
+				if (propertyName === indexKey) {
+					// Ignore the key itself as that does not get changed it gets
+					// only used to find the correct row to update
+					continue;
+				}
+				if (inputItem[propertyName] === undefined || inputItem[propertyName] === null) {
+					// Property does not exist so skip it
+					continue;
+				}
+
+				// Property exists so add it to the data to update
+
+				// Get the column name in which the property data can be found
+				updateColumnName = this.getColumnWithOffset(rangeStartSplit[1], keyColumnOrder.indexOf(propertyName));
+
+				updateData.push({
+					range: `${sheet ? sheet + '!' : ''}${updateColumnName}${updateRowIndex}`,
+					values: [
+						[
+							inputItem[propertyName] as string,
+						],
+					],
+				});
+
+			}
+		}
+
+		return this.batchUpdate(updateData, valueInputMode);
+	}
+
+
+	/**
+	 * Looks for a specific value in a column and if it gets found it returns the whole row
+	 *
+	 * @param {string[][]} inputData Data to to check for lookup value in
+	 * @param {number} keyRowIndex Index of the row which contains the keys
+	 * @param {number} dataStartRowIndex Index of the first row which contains data
+	 * @param {ILookupValues[]} lookupValues The lookup values which decide what data to return
+	 * @param {boolean} [returnAllMatches] Returns all the found matches instead of only the first one
+	 * @returns {Promise<IDataObject[]>}
+	 * @memberof GoogleSheet
+	 */
+	async lookupValues(inputData: string[][], keyRowIndex: number, dataStartRowIndex: number, lookupValues: ILookupValues[], returnAllMatches?: boolean): Promise<IDataObject[]> {
+		const keys: string[] = [];
+
+		if (keyRowIndex < 0 || dataStartRowIndex < keyRowIndex || keyRowIndex >= inputData.length) {
+			// The key row does not exist so it is not possible to look up the data
+			throw new Error(`The key row does not exist!`);
+		}
+
+		// Create the keys array
+		for (let columnIndex = 0; columnIndex < inputData[keyRowIndex].length; columnIndex++) {
+			keys.push(inputData[keyRowIndex][columnIndex]);
+		}
+
+		const returnData = [
+			inputData[keyRowIndex],
+		];
+
+		// Loop over all the lookup values and try to find a row to return
+		let rowIndex: number;
+		let returnColumnIndex: number;
+		lookupLoop:
+		for (const lookupValue of lookupValues) {
+			returnColumnIndex = keys.indexOf(lookupValue.lookupColumn);
+
+			if (returnColumnIndex === -1) {
+				throw new Error(`The column "${lookupValue.lookupColumn}" could not be found!`);
+			}
+
+			// Loop over all the items and find the one with the matching value
+			for (rowIndex = dataStartRowIndex; rowIndex < inputData.length; rowIndex++) {
+				if (inputData[rowIndex][returnColumnIndex]?.toString() === lookupValue.lookupValue.toString()) {
+					returnData.push(inputData[rowIndex]);
+
+					if (returnAllMatches !== true) {
+						continue lookupLoop;
+					}
+				}
+			}
+
+			// If value could not be found add an empty one that the order of
+			// the returned items stays the same
+			if (returnAllMatches !== true) {
+				returnData.push([]);
+			}
+		}
+
+		return this.structureData(returnData, 1, keys, true);
+	}
+
+
+	async convertStructuredDataToArray(inputData: IDataObject[], range: string, keyRowIndex: number): Promise<string[][]> {
+		let startColumn, endColumn;
+		let sheet: string | undefined = undefined;
+		if (range.includes('!')) {
+			[sheet, range] = range.split('!');
+		}
+		[startColumn, endColumn] = range.split(':');
+
+
+		let getRange = `${startColumn}${keyRowIndex + 1}:${endColumn}${keyRowIndex + 1}`;
+
+		if (sheet !== undefined) {
+			getRange = `${sheet}!${getRange}`;
+		}
+
+		const keyColumnData = await this.getData(getRange, 'UNFORMATTED_VALUE');
+
+		if (keyColumnData === undefined) {
+			throw new Error('Could not retrieve the column data!');
+		}
+
+		const keyColumnOrder = keyColumnData[0];
+
+		const setData: string[][] = [];
+
+		let rowData: string[] = [];
+		inputData.forEach((item) => {
+			rowData = [];
+			keyColumnOrder.forEach((key) => {
+				if (item.hasOwnProperty(key) && item[key]) {
+					rowData.push(item[key]!.toString());
+				} else {
+					rowData.push('');
+				}
+			});
+
+			setData.push(rowData);
+		});
+
+		return setData;
+	}
+}

packages/nodes-base/nodes/Google/Sheet/GoogleSheets.node.ts

@@ -0,0 +1,791 @@
+
+import {
+	IExecuteFunctions,
+ } from 'n8n-core';
+
+import {
+	IDataObject,
+	ILoadOptionsFunctions,
+	INodeExecutionData,
+	INodePropertyOptions,
+	INodeType,
+	INodeTypeDescription,
+} from 'n8n-workflow';
+
+import {
+	GoogleSheet,
+	ILookupValues,
+	ISheetUpdateData,
+	IToDelete,
+	ValueInputOption,
+	ValueRenderOption,
+} from './GoogleSheet';
+
+export class GoogleSheets implements INodeType {
+	description: INodeTypeDescription = {
+		displayName: 'Google Sheets ',
+		name: 'googleSheets',
+		icon: 'file:googlesheets.png',
+		group: ['input', 'output'],
+		version: 1,
+		description: 'Read, update and write data to Google Sheets',
+		defaults: {
+			name: 'Google Sheets',
+			color: '#0aa55c',
+		},
+		inputs: ['main'],
+		outputs: ['main'],
+		credentials: [
+			{
+				name: 'googleApi',
+				required: true,
+				displayOptions: {
+					show: {
+						authentication: [
+							'serviceAccount',
+						],
+					},
+				},
+			},
+			{
+				name: 'googleSheetsOAuth2Api',
+				required: true,
+				displayOptions: {
+					show: {
+						authentication: [
+							'oAuth2',
+						],
+					},
+				},
+			},
+		],
+		properties: [
+			{
+				displayName: 'Authentication',
+				name: 'authentication',
+				type: 'options',
+				options: [
+					{
+						name: 'Service Account',
+						value: 'serviceAccount',
+					},
+					{
+						name: 'OAuth2',
+						value: 'oAuth2',
+					},
+				],
+				default: 'serviceAccount',
+			},
+			{
+				displayName: 'Operation',
+				name: 'operation',
+				type: 'options',
+				options: [
+					{
+						name: 'Append',
+						value: 'append',
+						description: 'Appends the data to a Sheet',
+					},
+					{
+						name: 'Clear',
+						value: 'clear',
+						description: 'Clears data from a Sheet',
+					},
+					{
+						name: 'Delete',
+						value: 'delete',
+						description: 'Delete columns and rows from a Sheet',
+					},
+					{
+						name: 'Lookup',
+						value: 'lookup',
+						description: 'Looks for a specific column value and then returns the matching row'
+					},
+					{
+						name: 'Read',
+						value: 'read',
+						description: 'Reads data from a Sheet'
+					},
+					{
+						name: 'Update',
+						value: 'update',
+						description: 'Updates rows in a sheet'
+					},
+				],
+				default: 'read',
+				description: 'The operation to perform.',
+			},
+
+			// ----------------------------------
+			//         All
+			// ----------------------------------
+			{
+				displayName: 'Sheet ID',
+				name: 'sheetId',
+				type: 'string',
+				default: '',
+				required: true,
+				description: 'The ID of the Google Sheet.<br />Found as part of the sheet URL https://docs.google.com/spreadsheets/d/{ID}/',
+			},
+			{
+				displayName: 'Range',
+				name: 'range',
+				type: 'string',
+				displayOptions: {
+					hide: {
+						operation: [
+							'delete'
+						],
+					},
+				},
+				default: 'A:F',
+				required: true,
+				description: 'The table range to read from or to append data to. See the Google <a href="https://developers.google.com/sheets/api/guides/values#writing">documentation</a> for the details.<br />If it contains multiple sheets it can also be<br />added like this: "MySheet!A:F"',
+			},
+
+
+			// ----------------------------------
+			//         Delete
+			// ----------------------------------
+			{
+				displayName: 'To Delete',
+				name: 'toDelete',
+				placeholder: 'Add Columns/Rows to delete',
+				description: 'Deletes colums and rows from a sheet.',
+				type: 'fixedCollection',
+				typeOptions: {
+					multipleValues: true,
+				},
+				displayOptions: {
+					show: {
+						operation: [
+							'delete'
+						],
+					},
+				},
+				default: {},
+				options: [
+					{
+						displayName: 'Columns',
+						name: 'columns',
+						values: [
+							{
+								displayName: 'Sheet',
+								name: 'sheetId',
+								type: 'options',
+								typeOptions: {
+									loadOptionsMethod: 'getSheets',
+								},
+								options: [],
+								default: '',
+								required: true,
+								description: 'The sheet to delete columns from',
+							},
+							{
+								displayName: 'Start Index',
+								name: 'startIndex',
+								type: 'number',
+								typeOptions: {
+									minValue: 0,
+								},
+								default: 0,
+								description: 'The start index (0 based and inclusive) of column to delete.',
+							},
+							{
+								displayName: 'Amount',
+								name: 'amount',
+								type: 'number',
+								typeOptions: {
+									minValue: 1,
+								},
+								default: 1,
+								description: 'Number of columns to delete.',
+							},
+						]
+					},
+					{
+						displayName: 'Rows',
+						name: 'rows',
+						values: [
+							{
+								displayName: 'Sheet',
+								name: 'sheetId',
+								type: 'options',
+								typeOptions: {
+									loadOptionsMethod: 'getSheets',
+								},
+								options: [],
+								default: '',
+								required: true,
+								description: 'The sheet to delete columns from',
+							},
+							{
+								displayName: 'Start Index',
+								name: 'startIndex',
+								type: 'number',
+								typeOptions: {
+									minValue: 0,
+								},
+								default: 0,
+								description: 'The start index (0 based and inclusive) of row to delete.',
+							},
+							{
+								displayName: 'Amount',
+								name: 'amount',
+								type: 'number',
+								typeOptions: {
+									minValue: 1,
+								},
+								default: 1,
+								description: 'Number of rows to delete.',
+							},
+						]
+					},
+				],
+			},
+
+
+			// ----------------------------------
+			//         Read
+			// ----------------------------------
+			{
+				displayName: 'RAW Data',
+				name: 'rawData',
+				type: 'boolean',
+				displayOptions: {
+					show: {
+						operation: [
+							'read'
+						],
+					},
+				},
+				default: false,
+				description: 'If the data should be returned RAW instead of parsed into keys according to their header.',
+			},
+			{
+				displayName: 'Data Property',
+				name: 'dataProperty',
+				type: 'string',
+				default: 'data',
+				displayOptions: {
+					show: {
+						operation: [
+							'read'
+						],
+						rawData: [
+							true
+						],
+					},
+				},
+				description: 'The name of the property into which to write the RAW data.',
+			},
+
+			// ----------------------------------
+			//         Update
+			// ----------------------------------
+			{
+				displayName: 'RAW Data',
+				name: 'rawData',
+				type: 'boolean',
+				displayOptions: {
+					show: {
+						operation: [
+							'update'
+						],
+					},
+				},
+				default: false,
+				description: 'If the data supplied is RAW instead of parsed into keys.',
+			},
+			{
+				displayName: 'Data Property',
+				name: 'dataProperty',
+				type: 'string',
+				default: 'data',
+				displayOptions: {
+					show: {
+						operation: [
+							'update'
+						],
+						rawData: [
+							true
+						],
+					},
+				},
+				description: 'The name of the property from which to read the RAW data.',
+			},
+
+			// ----------------------------------
+			//         Read & Update & lookupColumn
+			// ----------------------------------
+			{
+				displayName: 'Data Start Row',
+				name: 'dataStartRow',
+				type: 'number',
+				typeOptions: {
+					minValue: 1,
+				},
+				default: 1,
+				displayOptions: {
+					hide: {
+						operation: [
+							'append',
+							'clear',
+							'delete',
+						],
+						rawData: [
+							true
+						],
+					},
+				},
+				description: 'Index of the first row which contains<br />the actual data and not the keys. Starts with 0.',
+			},
+
+			// ----------------------------------
+			//         Mixed
+			// ----------------------------------
+			{
+				displayName: 'Key Row',
+				name: 'keyRow',
+				type: 'number',
+				typeOptions: {
+					minValue: 0,
+				},
+				displayOptions: {
+					hide: {
+						operation: [
+							'clear',
+							'delete',
+						],
+						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.',
+			},
+
+
+			// ----------------------------------
+			//         lookup
+			// ----------------------------------
+			{
+				displayName: 'Lookup Column',
+				name: 'lookupColumn',
+				type: 'string',
+				default: '',
+				placeholder: 'Email',
+				required: true,
+				displayOptions: {
+					show: {
+						operation: [
+							'lookup'
+						],
+					},
+				},
+				description: 'The name of the column in which to look for value.',
+			},
+			{
+				displayName: 'Lookup Value',
+				name: 'lookupValue',
+				type: 'string',
+				default: '',
+				placeholder: 'frank@example.com',
+				displayOptions: {
+					show: {
+						operation: [
+							'lookup'
+						],
+					},
+				},
+				description: 'The value to look for in column.',
+			},
+
+			// ----------------------------------
+			//         Update
+			// ----------------------------------
+			{
+				displayName: 'Key',
+				name: 'key',
+				type: 'string',
+				default: 'id',
+				displayOptions: {
+					show: {
+						operation: [
+							'update'
+						],
+						rawData: [
+							false
+						],
+					},
+				},
+				description: 'The name of the key to identify which<br />data should be updated in the sheet.',
+			},
+
+			{
+				displayName: 'Options',
+				name: 'options',
+				type: 'collection',
+				placeholder: 'Add Option',
+				default: {},
+				displayOptions: {
+					show: {
+						operation: [
+							'append',
+							'lookup',
+							'read',
+							'update',
+						],
+					},
+				},
+				options: [
+					{
+						displayName: 'Continue If Empty',
+						name: 'continue',
+						type: 'boolean',
+						default: false,
+						displayOptions: {
+							show: {
+								'/operation': [
+									'lookup',
+									'read',
+								],
+							},
+						},
+						description: 'By default, the workflow stops executing if the lookup/read does not return values.',
+					},
+					{
+						displayName: 'Return All Matches',
+						name: 'returnAllMatches',
+						type: 'boolean',
+						default: false,
+						displayOptions: {
+							show: {
+								'/operation': [
+									'lookup',
+								],
+							},
+						},
+						description: 'By default only the first result gets returned. If options gets set all found matches get returned.',
+					},
+					{
+						displayName: 'Value Input Mode',
+						name: 'valueInputMode',
+						type: 'options',
+						displayOptions: {
+							show: {
+								'/operation': [
+									'append',
+									'update',
+								],
+							},
+						},
+						options: [
+							{
+								name: 'RAW',
+								value: 'RAW',
+								description: 'The values will not be parsed and will be stored as-is.',
+							},
+							{
+								name: 'User Entered',
+								value: 'USER_ENTERED',
+								description: 'The values will be parsed as if the user typed them into the UI. Numbers will stay as numbers, but strings may be converted to numbers, dates, etc. following the same rules that are applied when entering text into a cell via the Google Sheets UI.'
+							},
+						],
+						default: 'RAW',
+						description: 'Determines how data should be interpreted.',
+					},
+					{
+						displayName: 'Value Render Mode',
+						name: 'valueRenderMode',
+						type: 'options',
+						displayOptions: {
+							show: {
+								'/operation': [
+									'lookup',
+									'read',
+								],
+							},
+						},
+						options: [
+							{
+								name: 'Formatted Value',
+								value: 'FORMATTED_VALUE',
+								description: 'Values will be calculated & formatted in the reply according to the cell\'s formatting.Formatting is based on the spreadsheet\'s locale, not the requesting user\'s locale.For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, then A2 would return "$1.23".',
+							},
+							{
+								name: 'Formula',
+								value: 'FORMULA',
+								description: '	Values will not be calculated. The reply will include the formulas. For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, then A2 would return "=A1".',
+							},
+							{
+								name: 'Unformatted Value',
+								value: 'UNFORMATTED_VALUE',
+								description: 'Values will be calculated, but not formatted in the reply. For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, then A2 would return the number 1.23.'
+							},
+						],
+						default: 'UNFORMATTED_VALUE',
+						description: 'Determines how values should be rendered in the output.',
+					},
+					{
+						displayName: 'Value Render Mode',
+						name: 'valueRenderMode',
+						type: 'options',
+						displayOptions: {
+							show: {
+								'/operation': [
+									'update',
+								],
+								'/rawData': [
+									false
+								],
+							},
+						},
+						options: [
+							{
+								name: 'Formatted Value',
+								value: 'FORMATTED_VALUE',
+								description: 'Values will be calculated & formatted in the reply according to the cell\'s formatting.Formatting is based on the spreadsheet\'s locale, not the requesting user\'s locale.For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, then A2 would return "$1.23".',
+							},
+							{
+								name: 'Formula',
+								value: 'FORMULA',
+								description: '	Values will not be calculated. The reply will include the formulas. For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, then A2 would return "=A1".',
+							},
+							{
+								name: 'Unformatted Value',
+								value: 'UNFORMATTED_VALUE',
+								description: 'Values will be calculated, but not formatted in the reply. For example, if A1 is 1.23 and A2 is =A1 and formatted as currency, then A2 would return the number 1.23.'
+							},
+						],
+						default: 'UNFORMATTED_VALUE',
+						description: 'Determines how values should be rendered in the output.',
+					},
+
+				],
+			}
+
+		],
+	};
+
+
+	methods = {
+		loadOptions: {
+			// Get all the sheets in a Spreadsheet
+			async getSheets(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
+				const spreadsheetId = this.getCurrentNodeParameter('sheetId') as string;
+
+				const sheet = new GoogleSheet(spreadsheetId, this);
+				const responseData = await sheet.spreadsheetGetSheets();
+
+				if (responseData === undefined) {
+					throw new Error('No data got returned');
+				}
+
+				const returnData: INodePropertyOptions[] = [];
+				for (const sheet of responseData.sheets!) {
+					if (sheet.properties!.sheetType !== 'GRID') {
+						continue;
+					}
+
+					returnData.push({
+						name: sheet.properties!.title as string,
+						value: sheet.properties!.sheetId as unknown as string,
+					});
+				}
+
+				return returnData;
+			},
+		},
+	};
+
+
+	async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
+		const spreadsheetId = this.getNodeParameter('sheetId', 0) as string;
+
+		const sheet = new GoogleSheet(spreadsheetId, this);
+
+		const operation = this.getNodeParameter('operation', 0) as string;
+
+		let range = '';
+		if (operation !== 'delete') {
+			range = this.getNodeParameter('range', 0) as string;
+		}
+
+		const options = this.getNodeParameter('options', 0, {}) as IDataObject;
+
+		const valueInputMode = (options.valueInputMode || 'RAW') as ValueInputOption;
+		const valueRenderMode = (options.valueRenderMode || 'UNFORMATTED_VALUE') as ValueRenderOption;
+
+		if (operation === 'append') {
+			// ----------------------------------
+			//         append
+			// ----------------------------------
+			const keyRow = this.getNodeParameter('keyRow', 0) as number;
+
+			const items = this.getInputData();
+
+			const setData: IDataObject[] = [];
+			items.forEach((item) => {
+				setData.push(item.json);
+			});
+
+			// Convert data into array format
+			const data = await sheet.appendSheetData(setData, range, keyRow, valueInputMode);
+
+			// TODO: Should add this data somewhere
+			// TODO: Should have something like add metadata which does not get passed through
+
+			return this.prepareOutputData(items);
+		} else if (operation === 'clear') {
+			// ----------------------------------
+			//         clear
+			// ----------------------------------
+
+			await sheet.clearData(range);
+
+			const items = this.getInputData();
+			return this.prepareOutputData(items);
+		} else if (operation === 'delete') {
+			// ----------------------------------
+			//         delete
+			// ----------------------------------
+
+			const requests: IDataObject[] = [];
+
+			const toDelete = this.getNodeParameter('toDelete', 0) as IToDelete;
+
+			const deletePropertyToDimensions: IDataObject = {
+				'columns': 'COLUMNS',
+				'rows': 'ROWS',
+			};
+
+			for (const propertyName of Object.keys(deletePropertyToDimensions)) {
+				if (toDelete[propertyName] !== undefined) {
+					toDelete[propertyName]!.forEach(range => {
+						requests.push({
+							deleteDimension: {
+								range: {
+									sheetId: range.sheetId,
+									dimension: deletePropertyToDimensions[propertyName] as string,
+									startIndex: range.startIndex,
+									endIndex: range.startIndex + range.amount,
+								}
+							}
+						});
+					});
+				}
+			}
+
+			const data = await sheet.spreadsheetBatchUpdate(requests);
+
+			const items = this.getInputData();
+			return this.prepareOutputData(items);
+		} else if (operation === 'lookup') {
+			// ----------------------------------
+			//         lookup
+			// ----------------------------------
+
+			const sheetData = await sheet.getData(range, valueRenderMode);
+
+			if (sheetData === undefined) {
+				return [];
+			}
+
+			const dataStartRow = this.getNodeParameter('dataStartRow', 0) as number;
+			const keyRow = this.getNodeParameter('keyRow', 0) as number;
+
+			const items = this.getInputData();
+
+			const lookupValues: ILookupValues[] = [];
+			for (let i = 0; i < items.length; i++) {
+				lookupValues.push({
+					lookupColumn: this.getNodeParameter('lookupColumn', i) as string,
+					lookupValue: this.getNodeParameter('lookupValue', i) as string,
+				});
+			}
+
+			let returnData = await sheet.lookupValues(sheetData, keyRow, dataStartRow, lookupValues, options.returnAllMatches as boolean | undefined);
+
+			if (returnData.length === 0 && options.continue && options.returnAllMatches) {
+				returnData = [{}];
+			} else if (returnData.length === 1 && Object.keys(returnData[0]).length === 0 && !options.continue && !options.returnAllMatches) {
+				returnData = [];
+			}
+
+			return [this.helpers.returnJsonArray(returnData)];
+		} else if (operation === 'read') {
+			// ----------------------------------
+			//         read
+			// ----------------------------------
+
+			const rawData = this.getNodeParameter('rawData', 0) as boolean;
+
+			const sheetData = await sheet.getData(range, valueRenderMode);
+
+			let returnData: IDataObject[];
+			if (!sheetData) {
+				returnData = [];
+			} else if (rawData === true) {
+				const dataProperty = this.getNodeParameter('dataProperty', 0) as string;
+				returnData = [
+					{
+						[dataProperty]: sheetData,
+					}
+				];
+			} else {
+				const dataStartRow = this.getNodeParameter('dataStartRow', 0) as number;
+				const keyRow = this.getNodeParameter('keyRow', 0) as number;
+
+				returnData = sheet.structureArrayDataByColumn(sheetData, keyRow, dataStartRow);
+			}
+
+			if (returnData.length === 0 && options.continue) {
+				returnData = [{}];
+			}
+
+			return [this.helpers.returnJsonArray(returnData)];
+		} else if (operation === 'update') {
+			// ----------------------------------
+			//         update
+			// ----------------------------------
+
+			const rawData = this.getNodeParameter('rawData', 0) as boolean;
+
+			const items = this.getInputData();
+
+			if (rawData === true) {
+				const dataProperty = this.getNodeParameter('dataProperty', 0) as string;
+
+				const updateData: ISheetUpdateData[] = [];
+				for (let i = 0; i < items.length; i++) {
+					updateData.push({
+						range,
+						values: items[i].json[dataProperty] as string[][],
+					});
+				}
+
+				const data = await sheet.batchUpdate(updateData, valueInputMode);
+			} else {
+				const keyName = this.getNodeParameter('key', 0) as string;
+				const keyRow = this.getNodeParameter('keyRow', 0) as number;
+				const dataStartRow = this.getNodeParameter('dataStartRow', 0) as number;
+
+				const setData: IDataObject[] = [];
+				items.forEach((item) => {
+					setData.push(item.json);
+				});
+
+				const data = await sheet.updateSheetData(setData, keyName, range, keyRow, dataStartRow, valueInputMode, valueRenderMode);
+			}
+			// TODO: Should add this data somewhere
+			// TODO: Should have something like add metadata which does not get passed through
+
+
+			return this.prepareOutputData(items);
+		}
+
+		return [];
+	}
+}