⚡ Google Drive OAuth2 support

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

@@ -0,0 +1,26 @@
+import {
+	ICredentialType,
+	NodePropertyTypes,
+} from 'n8n-workflow';
+
+const scopes = [
+	'https://www.googleapis.com/auth/drive',
+	'https://www.googleapis.com/auth/drive.appdata',
+	'https://www.googleapis.com/auth/drive.photos.readonly',
+];
+
+export class GoogleDriveOAuth2Api implements ICredentialType {
+	name = 'googleDriveOAuth2Api';
+	extends = [
+		'googleOAuth2Api',
+	];
+	displayName = 'Google Drive OAuth2 API';
+	properties = [
+		{
+			displayName: 'Scope',
+			name: 'scope',
+			type: 'hidden' as NodePropertyTypes,
+			default: scopes.join(' '),
+		},
+	];
+}

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

@@ -0,0 +1,142 @@
+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, option: IDataObject = {}): Promise<any> { // tslint:disable-line:no-any
+	const authenticationMethod = this.getNodeParameter('authentication', 0, 'serviceAccount') as string;
+
+	let options: OptionsWithUri = {
+		headers: {
+			'Content-Type': 'application/json',
+		},
+		method,
+		body,
+		qs,
+		uri: uri || `https://www.googleapis.com${resource}`,
+		json: true,
+	};
+	options = Object.assign({}, options, option);
+	try {
+		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, 'googleDriveOAuth2Api', options);
+		}
+	} catch (error) {
+		if (error.response && error.response.body && error.response.body.error) {
+
+			let errorMessages;
+
+			if (error.response.body.error.errors) {
+				// Try to return the error prettier
+				errorMessages = error.response.body.error.errors;
+
+				errorMessages = errorMessages.map((errorItem: IDataObject) => errorItem.message);
+
+				errorMessages = errorMessages.join('|');
+
+			} else if (error.response.body.error.message){
+				errorMessages = error.response.body.error.message;
+			}
+
+			throw new Error(`Google Drive error response [${error.statusCode}]: ${errorMessages}`);
+		}
+		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.appdata',
+		'https://www.googleapis.com/auth/drive.photos.readonly',
+	];
+
+	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/Drive/GoogleDrive.node.ts

@@ -1,10 +1,8 @@
-import { google } from 'googleapis';
-const { Readable } = require('stream');
-
 import {
 	BINARY_ENCODING,
 	IExecuteFunctions,
 } from 'n8n-core';
+
 import {
 	IDataObject,
 	INodeTypeDescription,
@@ -12,8 +10,9 @@ import {
 	INodeType,
 } from 'n8n-workflow';
 
-import { getAuthenticationClient } from '../GoogleApi';
-
+import {
+	googleApiRequest,
+} from './GenericFunctions';
 
 export class GoogleDrive implements INodeType {
 	description: INodeTypeDescription = {
@@ -34,9 +33,43 @@ export class GoogleDrive implements INodeType {
 			{
 				name: 'googleApi',
 				required: true,
-			}
+				displayOptions: {
+					show: {
+						authentication: [
+							'serviceAccount',
+						],
+					},
+				},
+			},
+			{
+				name: 'googleDriveOAuth2Api',
+				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: 'Resource',
 				name: 'resource',
@@ -813,26 +846,6 @@ export class GoogleDrive implements INodeType {
 		const items = this.getInputData();
 		const returnData: IDataObject[] = [];
 
-		const credentials = this.getCredentials('googleApi');
-
-		if (credentials === undefined) {
-			throw new Error('No credentials got returned!');
-		}
-
-		const scopes = [
-			'https://www.googleapis.com/auth/drive',
-			'https://www.googleapis.com/auth/drive.appdata',
-			'https://www.googleapis.com/auth/drive.photos.readonly',
-		];
-
-		const client = await getAuthenticationClient(credentials.email as string, credentials.privateKey as string, scopes);
-
-		const drive = google.drive({
-			version: 'v3',
-			// @ts-ignore
-			auth: client,
-		});
-
 		const resource = this.getNodeParameter('resource', 0) as string;
 		const operation = this.getNodeParameter('operation', 0) as string;
 
@@ -857,22 +870,20 @@ export class GoogleDrive implements INodeType {
 
 					const fileId = this.getNodeParameter('fileId', i) as string;
 
-					const copyOptions = {
-						fileId,
+					const body: IDataObject = {
 						fields: queryFields,
-						requestBody: {} as IDataObject,
 					};
 
 					const optionProperties = ['name', 'parents'];
 					for (const propertyName of optionProperties) {
 						if (options[propertyName] !== undefined) {
-							copyOptions.requestBody[propertyName] = options[propertyName];
+							body[propertyName] = options[propertyName];
 						}
 					}
 
-					const response = await drive.files.copy(copyOptions);
+					const response = await googleApiRequest.call(this, 'POST', `/drive/v3/files/${fileId}/copy`, body);
 
-					returnData.push(response.data as IDataObject);
+					returnData.push(response as IDataObject);
 
 				} else if (operation === 'download') {
 					// ----------------------------------
@@ -881,15 +892,13 @@ export class GoogleDrive implements INodeType {
 
 					const fileId = this.getNodeParameter('fileId', i) as string;
 
-					const response = await drive.files.get(
-						{
-							fileId,
-							alt: 'media',
-						},
-						{
-							responseType: 'arraybuffer',
-						},
-					);
+					const requestOptions = {
+						resolveWithFullResponse: true,
+						encoding: null,
+						json: false,
+					};
+
+					const response = await googleApiRequest.call(this, 'GET', `/drive/v3/files/${fileId}`, {}, { alt: 'media' }, undefined, requestOptions);
 
 					let mimeType: string | undefined;
 					if (response.headers['content-type']) {
@@ -912,7 +921,7 @@ export class GoogleDrive implements INodeType {
 
 					const dataPropertyNameDownload = this.getNodeParameter('binaryPropertyName', i) as string;
 
-					const data = Buffer.from(response.data as string);
+					const data = Buffer.from(response.body as string);
 
 					items[i].binary![dataPropertyNameDownload] = await this.helpers.prepareBinaryData(data as unknown as Buffer, undefined, mimeType);
 
@@ -988,20 +997,19 @@ export class GoogleDrive implements INodeType {
 
 					const pageSize = this.getNodeParameter('limit', i) as number;
 
-					const res = await drive.files.list({
+					const qs = {
 						pageSize,
 						orderBy: 'modifiedTime',
 						fields: `nextPageToken, files(${queryFields})`,
 						spaces: querySpaces,
-						corpora: queryCorpora,
-						driveId,
 						q: queryString,
-						includeItemsFromAllDrives: (queryCorpora !== '' || driveId !== ''), // Actually depracated,
-						supportsAllDrives: (queryCorpora !== '' || driveId !== ''), 		// see https://developers.google.com/drive/api/v3/reference/files/list
-																							// However until June 2020 still needs to be set, to avoid API errors.
-					});
+						includeItemsFromAllDrives: (queryCorpora !== '' || driveId !== ''),
+						supportsAllDrives: (queryCorpora !== '' || driveId !== ''),
+					};
 
-					const files = res!.data.files;
+					const response = await googleApiRequest.call(this, 'GET', `/drive/v3/files`, {}, qs);
+
+					const files = response!.files;
 
 					return [this.helpers.returnJsonArray(files as IDataObject[])];
 
@@ -1044,29 +1052,35 @@ export class GoogleDrive implements INodeType {
 					const name = this.getNodeParameter('name', i) as string;
 					const parents = this.getNodeParameter('parents', i) as string[];
 
-					const response = await drive.files.create({
-						requestBody: {
-							name,
-							originalFilename,
-							parents,
-						},
+					let qs: IDataObject = {
 						fields: queryFields,
-						media: {
-							mimeType,
-							body: ((buffer: Buffer) => {
-								const readableInstanceStream = new Readable({
-									read() {
-										this.push(buffer);
-										this.push(null);
-									}
-								});
+						uploadType: 'media',
+					};
 
-								return readableInstanceStream;
-							})(body),
+					const requestOptions = {
+						headers: {
+							'Content-Type': mimeType,
+							'Content-Length': body.byteLength,
 						},
-					});
+						encoding: null,
+						json: false,
+					};
 
-					returnData.push(response.data as IDataObject);
+					let response = await googleApiRequest.call(this, 'POST', `/upload/drive/v3/files`, body, qs, undefined, requestOptions);
+
+					body = {
+						mimeType,
+						name,
+						originalFilename,
+					};
+
+					qs = {
+						addParents: parents.join(','),
+					};
+
+					response = await googleApiRequest.call(this, 'PATCH', `/drive/v3/files/${JSON.parse(response).id}`, body, qs);
+
+					returnData.push(response as IDataObject);
 				}
 
 			} else if (resource === 'folder') {
@@ -1077,19 +1091,19 @@ export class GoogleDrive implements INodeType {
 
 					const name = this.getNodeParameter('name', i) as string;
 
-					const fileMetadata = {
+					const body = {
 						name,
 						mimeType: 'application/vnd.google-apps.folder',
 						parents: options.parents || [],
 					};
 
-					const response = await drive.files.create({
-						// @ts-ignore
-						resource: fileMetadata,
+					const qs = {
 						fields: queryFields,
-					});
+					};
 
-					returnData.push(response.data as IDataObject);
+					const response = await googleApiRequest.call(this, 'POST', '/drive/v3/files', body, qs);
+
+					returnData.push(response as IDataObject);
 				}
 			}
 			if (['file', 'folder'].includes(resource)) {
@@ -1100,9 +1114,7 @@ export class GoogleDrive implements INodeType {
 
 					const fileId = this.getNodeParameter('fileId', i) as string;
 
-					await drive.files.delete({
-						fileId,
-					});
+					const response = await googleApiRequest.call(this, 'DELETE', `/drive/v3/files/${fileId}`);
 
 					// If we are still here it did succeed
 					returnData.push({

packages/nodes-base/nodes/Google/GoogleApi.ts

@@ -1,23 +0,0 @@
-
-import { JWT } from 'google-auth-library';
-import { google } from 'googleapis';
-
-
-/**
- * Returns the authentication client needed to access spreadsheet
- */
-export async function getAuthenticationClient(email: string, privateKey: string, scopes: string[]): Promise <JWT> {
-	const client = new google.auth.JWT(
-		email,
-		undefined,
-		privateKey,
-		scopes,
-		undefined
-	);
-
-	// TODO: Check later if this or the above should be cached
-	await client.authorize();
-
-	// @ts-ignore
-	return client;
-}

packages/nodes-base/package.json

@@ -58,6 +58,7 @@
             "dist/credentials/GitlabApi.credentials.js",
             "dist/credentials/GoogleApi.credentials.js",
             "dist/credentials/GoogleCalendarOAuth2Api.credentials.js",
+            "dist/credentials/GoogleDriveOAuth2Api.credentials.js",
             "dist/credentials/GoogleOAuth2Api.credentials.js",
             "dist/credentials/GoogleSheetsOAuth2Api.credentials.js",
             "dist/credentials/GumroadApi.credentials.js",
@@ -319,7 +320,6 @@
         "formidable": "^1.2.1",
         "glob-promise": "^3.4.0",
         "gm": "^1.23.1",
-        "googleapis": "~50.0.0",
         "imap-simple": "^4.3.0",
         "jsonwebtoken": "^8.5.1",
         "lodash.get": "^4.4.2",