@anmiles/google-api-wrapper 18.0.3 → 19.0.1

package/src/lib/api.ts

@@ -1,15 +1,17 @@
-import type GoogleApis from 'googleapis';
 import { log, warn } from '@anmiles/logger';
+import '@anmiles/prototypes';
 import sleep from '@anmiles/sleep';
+import type GoogleApis from 'googleapis';
+
 import type { AuthOptions, CommonOptions } from '../types/options';
+
 import { getAuth } from './auth';
-import { deleteCredentials } from './secrets';
-import '@anmiles/prototypes';
+import { deleteCredentials } from './credentials';
 
 const requestInterval = 300;
 
 type ListParams = Record<string, unknown> & {
-	pageToken : string | undefined;
+	pageToken: string | undefined;
 };
 
 interface CommonAPI<TItem> {
@@ -17,27 +19,27 @@ interface CommonAPI<TItem> {
 		(
 			params?: ListParams,
 			options?: GoogleApis.Common.MethodOptions
-		) : Promise<GoogleApis.Common.GaxiosResponse<CommonResponse<TItem>>>;
+		): Promise<GoogleApis.Common.GaxiosResponse<CommonResponse<TItem>>>;
 		(
-			callback: (err: Error | null, res?: GoogleApis.Common.GaxiosResponse<CommonResponse<TItem>> | null) => void
+			callback: (err: Error | null, res?: GoogleApis.Common.GaxiosResponse<CommonResponse<TItem>> | null)=> void
 		): void;
 	};
 }
 
-interface CommonResponse<TItem> {
-	items?    : TItem[];
+export interface CommonResponse<TItem> {
+	items?: TItem[];
 	pageInfo?: {
-		totalResults? : number | null | undefined;
+		totalResults?: number | null | undefined;
 	};
-	nextPageToken? : string | null | undefined;
+	nextPageToken?: string | null | undefined;
 }
 
-class API<TGoogleAPI> {
-	api          : TGoogleAPI | undefined;
-	private auth : GoogleApis.Common.OAuth2Client | undefined;
+export class API<TGoogleAPI> {
+	api: TGoogleAPI | undefined;
+	private auth: GoogleApis.Common.OAuth2Client | undefined;
 
 	constructor(
-		private readonly getter: (auth: GoogleApis.Common.OAuth2Client) => TGoogleAPI,
+		private readonly getter: (auth: GoogleApis.Common.OAuth2Client)=> TGoogleAPI,
 		private readonly profile: string,
 		private readonly authOptions?: AuthOptions,
 	) {	}
@@ -47,7 +49,7 @@ class API<TGoogleAPI> {
 		this.api  = this.getter(this.auth);
 	}
 
-	async getItems<TItem>(selectAPI: (api: TGoogleAPI) => CommonAPI<TItem>, params: object, options?: CommonOptions): Promise<TItem[]> {
+	async getItems<TItem>(selectAPI: (api: TGoogleAPI)=> CommonAPI<TItem>, params: object, options?: CommonOptions): Promise<TItem[]> {
 		const items: TItem[] = [];
 
 		let pageToken: string | null | undefined = undefined;
@@ -90,8 +92,8 @@ class API<TGoogleAPI> {
 	}
 }
 
-async function getAPI<TGoogleAPI>(
-	getter: (auth: GoogleApis.Common.OAuth2Client) => TGoogleAPI,
+export async function getAPI<TGoogleAPI>(
+	getter: (auth: GoogleApis.Common.OAuth2Client)=> TGoogleAPI,
 	profile: string,
 	authOptions?: AuthOptions,
 ): Promise<API<TGoogleAPI>> {
@@ -107,7 +109,3 @@ async function getAPI<TGoogleAPI>(
 	await instance.init();
 	return instance;
 }
-
-export { getAPI, API };
-export type { CommonResponse };
-export default { getAPI, API };

package/src/lib/auth.ts

@@ -1,29 +1,12 @@
 import { google } from 'googleapis';
 import type GoogleApis from 'googleapis';
-import { info, warn } from '@anmiles/logger';
-import type { CommonOptions, AuthOptions } from '../types/options';
-import { getProfiles } from './profiles';
-import { getCredentials, getSecrets } from './secrets';
 
-import auth from './auth';
+import type { AuthOptions } from '../types/options';
 
-async function login(profile?: string, options?: AuthOptions & CommonOptions): Promise<void> {
-	const profiles = getProfiles().filter((p) => !profile || p === profile);
+import { getCredentials } from './credentials';
+import { getSecrets } from './secrets';
 
-	for (const profile of profiles) {
-		if (!options?.hideProgress) {
-			warn(`${profile} - logging in...`);
-		}
-
-		await auth.getAuth(profile, options);
-
-		if (!options?.hideProgress) {
-			info(`${profile} - logged in successfully`);
-		}
-	}
-}
-
-async function getAuth(profile: string, options?: AuthOptions): Promise<GoogleApis.Common.OAuth2Client> {
+export async function getAuth(profile: string, options?: AuthOptions): Promise<GoogleApis.Common.OAuth2Client> {
 	const secrets = getSecrets(profile);
 
 	const googleAuth = new google.auth.OAuth2(
@@ -34,9 +17,6 @@ async function getAuth(profile: string, options?: AuthOptions): Promise<GoogleAp
 
 	const tokens = await getCredentials(profile, googleAuth, options);
 	googleAuth.setCredentials(tokens);
-	google.options({ auth : googleAuth });
+	google.options({ auth: googleAuth });
 	return googleAuth;
 }
-
-export { login, getAuth };
-export default { login, getAuth };

package/src/lib/credentials/__tests__/generator.test.ts

@@ -0,0 +1,249 @@
+import EventEmitter from 'events';
+import http from 'http';
+
+import logger from '@anmiles/logger';
+import '@anmiles/prototypes';
+import type GoogleApis from 'googleapis';
+import mockFs from 'mock-fs';
+import { open } from 'out-url';
+
+import { renderAuth, renderDone } from '../../renderer';
+import { getScopes } from '../../scopes';
+import { getCredentialsFile } from '../../utils/paths';
+import { generateCredentials } from '../generator';
+
+jest.mock('http');
+jest.mock('@anmiles/logger');
+jest.mock('out-url');
+jest.mock('../../renderer');
+jest.mock('../../scopes');
+
+jest.mock<Partial<typeof http>>('http', () => ({
+	createServer: jest.fn().mockImplementation(() => server),
+}));
+
+let server: http.Server;
+let response: http.ServerResponse;
+
+function makeRequest(url: string | undefined): void {
+	server.emit('request', { // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+		url,
+		headers: {
+			host,
+		},
+	} as http.IncomingMessage, response);
+}
+
+const port = 6006;
+const host = `localhost:${port}`;
+
+const profile         = 'username1';
+const credentialsFile = getCredentialsFile(profile);
+
+const credentials: GoogleApis.Auth.Credentials = {
+	access_token: 'access_token_123',
+};
+
+const code = 'code';
+
+const authUrl = 'https://authUrl';
+const auth    = { // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+	generateAuthUrl: jest.fn().mockReturnValue(authUrl),
+	getToken       : jest.fn().mockResolvedValue({ tokens: credentials }),
+} as unknown as GoogleApis.Common.OAuth2Client;
+
+server = new EventEmitter() as typeof server; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+
+jest.mocked(http.createServer).mockImplementation(() => server);
+// eslint-disable-next-line @typescript-eslint/require-await
+jest.mocked(open).mockImplementation(async (url: string) => makeRequest(url.replace('http://localhost:6006', '')));
+
+jest.useFakeTimers();
+
+jest.mocked(renderAuth).mockImplementation((
+	{ profile, authUrl, scope }: { profile: string; authUrl: string; scope: string[] },
+) => `content = profile = ${profile} authUrl = ${authUrl} scope = ${scope.join('|')}`);
+
+jest.mocked(renderDone).mockImplementation(() => 'content = done');
+
+jest.mocked(getScopes).mockReturnValue([ 'scope1', 'scope2' ]);
+
+beforeEach(() => {
+	mockFs({
+		[credentialsFile]: JSON.stringify(credentials),
+	});
+});
+
+afterAll(() => {
+	mockFs.restore();
+});
+
+describe('src/lib/credentials/generator', () => {
+	describe('generateCredentials', () => {
+		const tokenUrl = `/request.url?code=${code}`;
+
+		const connections = [
+			{ remoteAddress: 'server', remotePort: '1001', on: jest.fn(), destroy: jest.fn() },
+			{ remoteAddress: 'server', remotePort: '1002', on: jest.fn(), destroy: jest.fn() },
+			{ remoteAddress: 'server', remotePort: '1003', on: jest.fn(), destroy: jest.fn() },
+		];
+
+		let endSpy: jest.SpyInstance;
+
+		beforeEach(() => {
+			server         = new EventEmitter() as typeof server; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+			server.listen  = jest.fn().mockImplementation(() => {
+				// always simulate opening several connections once connections are meant to be listened
+				connections.forEach((connection) => server.emit('connection', connection));
+			});
+			server.close   = jest.fn();
+			server.destroy = jest.fn();
+
+			response     = new EventEmitter() as typeof response; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+			response.end = jest.fn();
+
+			endSpy = jest.spyOn(response, 'end');
+		});
+
+		afterAll(() => {
+			endSpy.mockRestore();
+		});
+
+		it('should generate authUrl', async () => {
+			void generateCredentials(profile, auth);
+			await Promise.resolve();
+
+			expect(auth.generateAuthUrl).toHaveBeenCalledWith({ // eslint-disable-line @typescript-eslint/unbound-method
+				access_type: 'offline',
+				prompt     : undefined,
+				scope     	: [ 'scope1', 'scope2' ],
+			});
+		});
+
+		it('should generate authUrl and require consent if explicitly asked', async () => {
+			void generateCredentials(profile, auth, { temporary: true }, 'consent');
+			await Promise.resolve();
+
+			expect(auth.generateAuthUrl).toHaveBeenCalledWith({ // eslint-disable-line @typescript-eslint/unbound-method
+				access_type: 'offline',
+				prompt     : 'consent',
+				scope     	: [ 'scope1', 'scope2' ],
+			});
+		});
+
+		it('should generate authUrl with custom scopes', async () => {
+			void generateCredentials(profile, auth, { scopes: [ 'scope1', 'scope2' ] });
+			await Promise.resolve();
+
+			expect(auth.generateAuthUrl).toHaveBeenCalledWith({ // eslint-disable-line @typescript-eslint/unbound-method
+				access_type: 'offline',
+				prompt     : undefined,
+				scope     	: [ 'scope1', 'scope2' ],
+			});
+		});
+
+		it('should create server on 6006 port', async () => {
+			void generateCredentials(profile, auth);
+			await Promise.resolve();
+
+			expect(http.createServer).toHaveBeenCalled();
+			expect(server.listen).toHaveBeenCalledWith(6006); // eslint-disable-line @typescript-eslint/unbound-method
+		});
+
+		it('should open browser page and warn about it once listening', async () => {
+			void generateCredentials(profile, auth);
+			await Promise.resolve();
+
+			server.emit('listening');
+
+			expect(open).toHaveBeenCalledWith('http://localhost:6006/');
+			expect(logger.warn).toHaveBeenCalledWith('Please check your browser for further actions');
+		});
+
+		it('should not open browser page and warn about it until listening', async () => {
+			void generateCredentials(profile, auth);
+			await Promise.resolve();
+
+			expect(open).not.toHaveBeenCalled();
+			expect(logger.warn).not.toHaveBeenCalled();
+		});
+
+		it('should show nothing on the browser page if request.url is empty', async () => {
+			void generateCredentials(profile, auth);
+			makeRequest('');
+			await Promise.resolve();
+
+			expect(endSpy).toHaveBeenCalledWith('');
+		});
+
+		it('should show opening instructions if opened the home page', async () => {
+			void generateCredentials(profile, auth);
+			makeRequest('/');
+			await Promise.resolve();
+
+			expect(endSpy).toHaveBeenCalledWith('content = profile = username1 authUrl = https://authUrl scope = scope1|scope2');
+		});
+
+		it('should ask to close webpage', async () => {
+			void generateCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			await Promise.resolve();
+
+			expect(endSpy).toHaveBeenCalledWith('content = done');
+		});
+
+		it('should close server and destroy all connections if request.url is truthy', async () => {
+			void generateCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			await Promise.resolve();
+
+			expect(server.close).toHaveBeenCalled(); // eslint-disable-line @typescript-eslint/unbound-method
+
+			connections.forEach((connection) => {
+				expect(connection.destroy).toHaveBeenCalled();
+			});
+		});
+
+		it('should close server and resolve if request.url is truthy', async () => {
+			const promise = generateCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			const result = await Promise.resolve(promise);
+			expect(result).toEqual(credentials);
+			expect(server.close).toHaveBeenCalledTimes(1); // eslint-disable-line @typescript-eslint/unbound-method
+		});
+
+		it('should not close server if request.url is falsy', async () => {
+			void generateCredentials(profile, auth);
+			makeRequest(undefined);
+			await Promise.resolve();
+
+			expect(server.close).not.toHaveBeenCalled(); // eslint-disable-line @typescript-eslint/unbound-method
+		});
+
+		it('should re-throw a server error if error is not EADDRINUSE', () => {
+			const error = { code: 'RANDOM', message: 'random error' } as NodeJS.ErrnoException; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+
+			void generateCredentials(profile, auth);
+			expect(() => server.emit('error', error)).toThrow(error.message);
+		});
+
+		it('should not re-throw a server error and try to listen again in 1000 seconds if error is EADDRINUSE', () => {
+			const error = { code: 'EADDRINUSE' } as NodeJS.ErrnoException; // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+
+			void generateCredentials(profile, auth);
+			expect(server.listen).toHaveBeenCalledTimes(1); // eslint-disable-line @typescript-eslint/unbound-method
+			expect(() => server.emit('error', error)).not.toThrow();
+			expect(server.listen).toHaveBeenCalledTimes(1); // eslint-disable-line @typescript-eslint/unbound-method
+			jest.advanceTimersByTime(1000);
+			expect(server.listen).toHaveBeenCalledTimes(2); // eslint-disable-line @typescript-eslint/unbound-method
+		});
+
+		it('should return credentials JSON', async () => {
+			const promise = generateCredentials(profile, auth);
+			makeRequest(tokenUrl);
+			const result = await promise;
+
+			expect(result).toEqual(credentials);
+		});
+	});
+});

package/src/lib/credentials/__tests__/index.test.ts

@@ -0,0 +1,213 @@
+import fs from 'fs';
+
+import '@anmiles/prototypes';
+import type GoogleApis from 'googleapis';
+import mockFs from 'mock-fs';
+
+import { getCredentialsFile } from '../../utils/paths';
+import { generateCredentials } from '../generator';
+import { deleteCredentials, getCredentials } from '../index';
+import { validateCredentials } from '../validator';
+
+jest.mock('../generator');
+jest.mock('../validator');
+
+const profile         = 'username1';
+const credentialsFile = getCredentialsFile(profile);
+
+const credentials: GoogleApis.Auth.Credentials = {
+	access_token: 'access_token_123',
+};
+
+const generatedCredentials: GoogleApis.Auth.Credentials = {
+	access_token : 'access_token_new',
+	refresh_token: 'refresh_token_new',
+};
+
+const scopes = [ 'scope1', 'scope2' ];
+
+const authUrl = 'https://authUrl';
+const auth    = { // eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
+	generateAuthUrl: jest.fn().mockReturnValue(authUrl),
+	getToken       : jest.fn().mockResolvedValue({ tokens: credentials }),
+} as unknown as GoogleApis.Common.OAuth2Client;
+
+const generateCredentialsMock = jest.mocked(generateCredentials);
+const validateCredentialsMock = jest.mocked(validateCredentials);
+
+beforeEach(() => {
+	mockFs({
+		[credentialsFile]: JSON.stringify(credentials),
+	});
+
+	generateCredentialsMock.mockResolvedValue(generatedCredentials);
+	validateCredentialsMock.mockReturnValue({ isValid: true });
+});
+
+afterAll(() => {
+	mockFs.restore();
+});
+
+describe('src/lib/credentials/index', () => {
+	describe('getCredentials', () => {
+		describe('on existing file', () => {
+			it('should return saved credentials', async () => {
+				const result = await getCredentials(profile, auth);
+
+				expect(result).toEqual(credentials);
+			});
+
+			it('should not generate credentials', async () => {
+				await getCredentials(profile, auth);
+
+				expect(generateCredentialsMock).not.toHaveBeenCalled();
+			});
+
+			it('should call validation on saved credentials', async () => {
+				await getCredentials(profile, auth);
+
+				expect(validateCredentialsMock).toHaveBeenCalledWith(credentials);
+			});
+		});
+
+		describe('on missing file', () => {
+			beforeEach(() => {
+				mockFs({});
+			});
+
+			it('should return generated credentials', async () => {
+				const result = await getCredentials(profile, auth);
+
+				expect(result).toEqual(generatedCredentials);
+			});
+
+			it('should generate credentials with consent', async () => {
+				await getCredentials(profile, auth);
+
+				expect(generateCredentialsMock).toHaveBeenCalledWith(profile, auth, undefined, 'consent');
+			});
+			it('should generate credentials with consent and scopes', async () => {
+				await getCredentials(profile, auth, { scopes });
+
+				expect(generateCredentialsMock).toHaveBeenCalledWith(profile, auth, { scopes }, 'consent');
+			});
+
+			it('should call validation on generated credentials', async () => {
+				await getCredentials(profile, auth);
+
+				expect(validateCredentialsMock).toHaveBeenCalledWith(generatedCredentials);
+			});
+
+			it('should throw if saved credentials do not pass validation', async () => {
+				validateCredentialsMock.mockReturnValueOnce({ isValid: false, validationError: 'Test error' });
+
+				const promise = getCredentials(profile, auth);
+
+				await expect(promise).rejects.toEqual(new Error(`JSON created for ${credentialsFile} is not valid: Test error`));
+			});
+		});
+
+		describe('on existing file with failed validation', () => {
+			beforeEach(() => {
+				validateCredentialsMock.mockReturnValueOnce({ isValid: false });
+			});
+
+			it('should return generated credentials', async () => {
+				const result = await getCredentials(profile, auth);
+
+				expect(result).toEqual(generatedCredentials);
+			});
+
+			it('should generate credentials with consent', async () => {
+				await getCredentials(profile, auth);
+
+				expect(generateCredentialsMock).toHaveBeenCalledWith(profile, auth, undefined, 'consent');
+			});
+
+			it('should generate credentials with consent and scopes', async () => {
+				await getCredentials(profile, auth, { scopes });
+
+				expect(generateCredentialsMock).toHaveBeenCalledWith(profile, auth, { scopes }, 'consent');
+			});
+
+			it('should generate credentials with no consent if existing credentials have refresh token', async () => {
+				mockFs({
+					[credentialsFile]: JSON.stringify({
+						...credentials,
+						refresh_token: 'refresh_token_123',
+					}),
+				});
+
+				await getCredentials(profile, auth);
+
+				expect(generateCredentialsMock).toHaveBeenCalledWith(profile, auth, undefined, undefined);
+			});
+
+			it('should call validation on generated credentials', async () => {
+				await getCredentials(profile, auth);
+
+				expect(validateCredentialsMock).toHaveBeenCalledWith(generatedCredentials);
+			});
+
+			it('should throw if generated credentials do not pass validation', async () => {
+				validateCredentialsMock.mockReturnValueOnce({ isValid: false, validationError: 'Test error' });
+
+				const promise = getCredentials(profile, auth);
+
+				await expect(promise).rejects.toEqual(new Error(`JSON created for ${credentialsFile} is not valid: Test error`));
+			});
+		});
+
+		describe('temporary', () => {
+			it('should return generated credentials', async () => {
+				const result = await getCredentials(profile, auth, { temporary: true });
+
+				expect(result).toEqual(generatedCredentials);
+			});
+
+			it('should generate credentials with no consent', async () => {
+				await getCredentials(profile, auth, { temporary: true });
+
+				expect(generateCredentialsMock).toHaveBeenCalledWith(profile, auth, { temporary: true });
+			});
+
+			it('should generate credentials with scopes', async () => {
+				await getCredentials(profile, auth, { scopes, temporary: true });
+
+				expect(generateCredentialsMock).toHaveBeenCalledWith(profile, auth, { scopes, temporary: true });
+			});
+
+			it('should call validation on generated credentials', async () => {
+				await getCredentials(profile, auth, { temporary: true });
+
+				expect(validateCredentialsMock).toHaveBeenCalledWith(generatedCredentials, { temporary: true });
+			});
+
+			it('should throw if generated credentials do not pass validation', async () => {
+				validateCredentialsMock.mockReturnValueOnce({ isValid: false, validationError: 'Test error' });
+
+				const promise = getCredentials(profile, auth, { temporary: true });
+
+				await expect(promise).rejects.toEqual(new Error('Test error'));
+			});
+		});
+	});
+
+	describe('deleteCredentials', () => {
+		it('should delete credentials file if exists', () => {
+			expect(fs.existsSync(credentialsFile)).toEqual(true);
+
+			deleteCredentials(profile);
+
+			expect(fs.existsSync(credentialsFile)).toEqual(false);
+		});
+
+		it('should do nothing if credentials file does not exist', () => {
+			mockFs({});
+
+			deleteCredentials(profile);
+
+			expect(fs.existsSync(credentialsFile)).toEqual(false);
+		});
+	});
+});

package/src/lib/credentials/__tests__/validator.test.ts

@@ -0,0 +1,43 @@
+import { validateCredentials } from '../validator';
+
+describe('src/lib/credentials/validator', () => {
+	describe('validateCredentials', () => {
+		let expiryDate: Date;
+
+		beforeEach(() => {
+			expiryDate = new Date();
+			expiryDate.setDate(expiryDate.getDate() - 6);
+		});
+
+		it('should return false if no access token', () => {
+			expect(validateCredentials({ refresh_token: 'token', expiry_date: expiryDate.getTime() }))
+				.toEqual({ isValid: false, validationError: 'Credentials does not have access_token' });
+		});
+
+		it('should return false if no refresh token', () => {
+			expect(validateCredentials({ access_token: 'token', expiry_date: expiryDate.getTime() }))
+				.toEqual({ isValid: false, validationError: 'Credentials does not have refresh_token' });
+		});
+
+		it('should return true if no refresh token for temporary credentials', () => {
+			expect(validateCredentials({ access_token: 'token', expiry_date: expiryDate.getTime() }, { temporary: true }))
+				.toEqual({ isValid: true });
+		});
+
+		it('should return false if no expiration date', () => {
+			expect(validateCredentials({ access_token: 'token', refresh_token: 'token' }))
+				.toEqual({ isValid: false, validationError: 'Credentials does not have expiry_date' });
+		});
+
+		it('should return true if credentials are not more than 1 week ago', () => {
+			expect(validateCredentials({ access_token: 'token', refresh_token: 'token', expiry_date: expiryDate.getTime() }))
+				.toEqual({ isValid: true });
+		});
+
+		it('should return false if credentials are more than 1 week ago', () => {
+			expiryDate.setDate(expiryDate.getDate() - 2);
+			expect(validateCredentials({ access_token: 'token', refresh_token: 'token', expiry_date: expiryDate.getTime() }))
+				.toEqual({ isValid: false, validationError: 'Credentials expired' });
+		});
+	});
+});