@anmiles/google-api-wrapper 1.0.1

package/src/lib/__tests__/secrets.test.ts

@@ -0,0 +1,304 @@
+import http from 'http';
+import path from 'path';
+import * as colorette from 'colorette';
+import type GoogleApis from 'googleapis';
+import jsonLib from '../jsonLib';
+import logger from '../logger';
+import type { Secrets } from '../../types';
+
+import secrets from '../secrets';
+const original = jest.requireActual('../secrets').default as typeof secrets;
+jest.mock<typeof secrets>('../secrets', () => ({
+	getSecrets        : jest.fn(),
+	getCredentials    : jest.fn(),
+	createCredentials : jest.fn(),
+	checkSecrets      : jest.fn(),
+	getSecretsError   : jest.fn().mockImplementation(() => secretsError),
+}));
+
+jest.mock<Partial<typeof http>>('http', () => ({
+	createServer : jest.fn().mockImplementation((callback) => {
+		serverCallback = callback;
+
+		return {
+			listen,
+			close,
+		};
+	}),
+}));
+
+jest.mock<Partial<typeof path>>('path', () => ({
+	join : jest.fn().mockImplementation((...args) => args.join('/')),
+}));
+
+jest.mock<Partial<typeof colorette>>('colorette', () => ({
+	yellow : jest.fn().mockImplementation((text) => `yellow:${text}`),
+}));
+
+jest.mock<Partial<typeof jsonLib>>('../jsonLib', () => ({
+	getJSON      : jest.fn().mockImplementation(() => json),
+	getJSONAsync : jest.fn().mockImplementation(async () => json),
+}));
+
+jest.mock<Partial<typeof logger>>('../logger', () => ({
+	info  : jest.fn(),
+	error : jest.fn().mockImplementation((error) => {
+		throw error;
+	}) as jest.Mock<never, any>,
+}));
+
+const profile          = 'username1';
+const secretsFile      = 'secrets/username1.json';
+const credentialsFile  = 'secrets/username1.credentials.json';
+const wrongRedirectURI = 'wrong_redirect_uri';
+
+const secretsError = 'secretsError';
+
+const secretsJSON: Secrets = {
+	web : {
+		/* eslint-disable camelcase */
+		client_id                   : 'client_id.apps.googleusercontent.com',
+		project_id                  : 'project_id',
+		auth_uri                    : 'https://accounts.google.com/o/oauth2/auth',
+		token_uri                   : 'https://oauth2.googleapis.com/token',
+		auth_provider_x509_cert_url : 'https://www.googleapis.com/oauth2/v1/certs',
+		client_secret               : 'client_secret',
+		redirect_uris               : [ 'http://localhost:6006/oauthcallback' ],
+		/* eslint-enable camelcase */
+	},
+};
+
+const credentialsJSON = {
+	token : {},
+};
+
+let json: object;
+
+const code    = 'code';
+const authUrl = 'https://authUrl';
+const auth    = {
+	generateAuthUrl : jest.fn().mockReturnValue(authUrl),
+	getToken        : jest.fn().mockReturnValue({ tokens : credentialsJSON }),
+} as unknown as GoogleApis.Common.OAuth2Client;
+
+let request: http.IncomingMessage;
+
+const response = {
+	end : jest.fn(),
+} as unknown as http.ServerResponse;
+
+let serverCallback: (
+	request: http.IncomingMessage,
+	response: http.ServerResponse
+) => Promise<typeof credentialsJSON>;
+
+let closedTime: number;
+
+const listen = jest.fn();
+const close  = jest.fn().mockImplementation(() => {
+	closedTime = new Date().getTime();
+});
+
+describe('src/lib/secrets', () => {
+	describe('getSecrets', () => {
+		const getJSONSpy = jest.spyOn(jsonLib, 'getJSON');
+
+		beforeEach(() => {
+			json = secretsJSON;
+		});
+
+		it('should get json from secrets file', async () => {
+			await original.getSecrets(profile);
+
+			expect(getJSONSpy).toBeCalled();
+			expect(getJSONSpy.mock.calls[0][0]).toEqual(secretsFile);
+		});
+
+		it('should fallback to error', async () => {
+			await original.getSecrets(profile);
+
+			expect(getJSONSpy.mock.calls[0][1]).toThrowError(secretsError);
+		});
+
+		it('should check secrets', async () => {
+			await original.getSecrets(profile);
+
+			expect(secrets.checkSecrets).toBeCalledWith(profile, json, secretsFile);
+		});
+
+		it('should return secrets', async () => {
+			const result = await original.getSecrets(profile);
+
+			expect(result).toEqual(secretsJSON);
+		});
+	});
+
+	describe('getCredentials', () => {
+		const getJSONAsyncSpy = jest.spyOn(jsonLib, 'getJSONAsync');
+
+		beforeEach(() => {
+			json = credentialsJSON;
+		});
+
+		it('should get json from credentials file', async () => {
+			await original.getCredentials(profile, auth);
+
+			expect(getJSONAsyncSpy).toBeCalled();
+			expect(getJSONAsyncSpy.mock.calls[0][0]).toEqual(credentialsFile);
+		});
+
+		it('should fallback to createCredentials', async () => {
+			await original.getCredentials(profile, auth);
+
+			const fallback = getJSONAsyncSpy.mock.calls[0][1];
+			await fallback();
+
+			expect(secrets.createCredentials).toBeCalledWith(profile, auth);
+		});
+
+		it('should return credentials', async () => {
+			const result = await original.getCredentials(profile, auth);
+
+			expect(result).toEqual(credentialsJSON);
+		});
+	});
+
+	describe('createCredentials', () => {
+		function willOpen(request: http.IncomingMessage, timeout: number) {
+			setTimeout(async () => {
+				await serverCallback(request, response);
+			}, timeout);
+		}
+
+		beforeEach(() => {
+			request = {
+				url     : `/request.url?code=${code}`,
+				headers : {
+					host : 'localhost:6006',
+				},
+			} as http.IncomingMessage;
+		});
+
+		it('should generate authUrl', async () => {
+			willOpen(request, 100);
+
+			await original.createCredentials(profile, auth);
+
+			expect(auth.generateAuthUrl).toBeCalledWith({
+				// eslint-disable-next-line camelcase
+				access_type : 'offline',
+				scope       : [ 'https://www.googleapis.com/auth/youtube.readonly' ],
+			});
+		});
+
+		it('should create server on 6006 port', async () => {
+			willOpen(request, 100);
+
+			await original.createCredentials(profile, auth);
+
+			expect(http.createServer).toBeCalled();
+			expect(listen).toBeCalledWith(6006);
+		});
+
+		it('should ask to open browser page', async () => {
+			willOpen(request, 100);
+
+			await original.createCredentials(profile, auth);
+
+			expect(logger.info).toBeCalledWith(`Please open yellow:https://authUrl in your browser using google profile for yellow:${profile} and allow access to yellow:https://www.googleapis.com/auth/youtube.readonly`);
+		});
+
+		it('should ask to close webpage', async () => {
+			willOpen(request, 100);
+
+			await original.createCredentials(profile, auth);
+
+			expect(response.end).toBeCalledWith('<h1>Please close this page and return to application</h1>');
+		});
+
+		it('should close server if request.url is truthy', async () => {
+			willOpen(request, 100);
+
+			await original.createCredentials(profile, auth);
+
+			expect(close).toBeCalled();
+		});
+
+		it('should only resolve when request.url is truthy', async () => {
+			const emptyRequestTime = 100;
+			const requestTime      = 200;
+			const emptyRequest     = { ...request } as http.IncomingMessage;
+			emptyRequest.url       = undefined;
+
+			const before = new Date().getTime();
+			willOpen(emptyRequest, emptyRequestTime);
+			willOpen(request, requestTime);
+
+			const result = await original.createCredentials(profile, auth);
+			const after  = new Date().getTime();
+
+			expect(close).toBeCalledTimes(1);
+			expect(closedTime - before).toBeGreaterThanOrEqual(requestTime - 1);
+			expect(after - before).toBeGreaterThanOrEqual(requestTime - 1);
+			expect(result).toEqual(credentialsJSON);
+		});
+
+		it('should only resolve when request.url contains no code', async () => {
+			const noCodeRequestTime = 100;
+			const requestTime       = 200;
+			const noCodeRequest     = { ...request } as http.IncomingMessage;
+			noCodeRequest.url       = '/request.url?param=value';
+
+			const before = new Date().getTime();
+			willOpen(noCodeRequest, noCodeRequestTime);
+			willOpen(request, requestTime);
+
+			const result = await original.createCredentials(profile, auth);
+			const after  = new Date().getTime();
+
+			expect(close).toBeCalledTimes(1);
+			expect(closedTime - before).toBeGreaterThanOrEqual(requestTime - 1);
+			expect(after - before).toBeGreaterThanOrEqual(requestTime - 1);
+			expect(result).toEqual(credentialsJSON);
+		});
+
+		it('should return credentials JSON', async () => {
+			willOpen(request, 100);
+
+			const result = await original.createCredentials(profile, auth);
+
+			expect(result).toEqual(credentialsJSON);
+		});
+	});
+
+	describe('checkSecrets', () => {
+		it('should return true if redirect_uri is correct', () => {
+			const result = original.checkSecrets(profile, secretsJSON, secretsFile);
+
+			expect(result).toBe(true);
+		});
+
+		it('should output error if redirect_uri is incorrect', () => {
+			const wrongSecretsJSON                = { ...secretsJSON };
+			wrongSecretsJSON.web.redirect_uris[0] = wrongRedirectURI;
+			const func                            = () => original.checkSecrets(profile, wrongSecretsJSON, secretsFile);
+
+			expect(func).toThrowError('Error in credentials file: redirect URI should be http://localhost:6006/oauthcallback.\nsecretsError');
+		});
+	});
+
+	describe('getSecretsError', () => {
+		it('should return error message with instructions', () => {
+			const result = original.getSecretsError(profile, secretsFile);
+			expect(result).toEqual(`File ${secretsFile} not found!\n\
+To obtain it, please create correct OAuth client ID:\n\
+\tGo to https://console.cloud.google.com/apis/credentials/oauthclient\n\
+\t[if applicable] Click "+ Create credentials" and choose "OAuth client ID\n\
+\tSet application type "Web application"\n\
+\tAdd authorized redirect URI: http://localhost:6006/oauthcallback\n\
+\tClick "Create"\n\
+\tClick "Download JSON" and download credentials to ./secrets/${profile}.json\n\
+Then start this script again`);
+		});
+	});
+});

package/src/lib/__tests__/sleep.test.ts

@@ -0,0 +1,17 @@
+import sleep from '../sleep';
+
+const sleepMilliseconds = 300;
+
+describe('src/lib/sleep', () => {
+	describe('sleep', () => {
+
+		it('should wait specified timeout', async () => {
+			const before = new Date().getTime();
+
+			await sleep.sleep(sleepMilliseconds);
+
+			const after = new Date().getTime();
+			expect(after - before).toBeGreaterThanOrEqual(sleepMilliseconds - 1);
+		});
+	});
+});

package/src/lib/auth.ts

@@ -0,0 +1,31 @@
+import { google } from 'googleapis';
+import type GoogleApis from 'googleapis';
+import { getProfiles } from './profiles';
+import { getCredentials, getSecrets } from './secrets';
+
+import auth from './auth';
+
+export { login, getAuth };
+export default { login, getAuth };
+
+async function login(profile?: string): Promise<void> {
+	const profiles = getProfiles().filter((p) => !profile || p === profile);
+
+	for (const profile of profiles) {
+		await auth.getAuth(profile);
+	}
+}
+
+async function getAuth(profile: string): Promise<GoogleApis.Common.OAuth2Client> {
+	const secrets = await getSecrets(profile);
+
+	const googleAuth = new google.auth.OAuth2(
+		secrets.web.client_id,
+		secrets.web.client_secret,
+		secrets.web.redirect_uris[0],
+	);
+
+	const tokens = await getCredentials(profile, googleAuth);
+	googleAuth.setCredentials(tokens);
+	return googleAuth;
+}

package/src/lib/data.ts

@@ -0,0 +1,81 @@
+import { google } from 'googleapis';
+import type GoogleApis from 'googleapis';
+import { getAuth } from './auth';
+import data from './data';
+import { log } from './logger';
+import { sleep } from './sleep';
+
+export { getItems, getCalendarAPI, getYoutubeAPI, getEvents, getVideos, setEvent };
+export default { getItems, getCalendarAPI, getYoutubeAPI, getEvents, getVideos, setEvent };
+
+type CommonApi<TArgs, TResponse> = {
+	list: (
+		params: TArgs & {pageToken: string | undefined},
+		options?: GoogleApis.Common.MethodOptions | undefined
+	) => Promise<GoogleApis.Common.GaxiosResponse<TResponse>>
+};
+
+type CommonResponse<TItem> = {
+	items?: TItem[],
+	pageInfo?: {
+		totalResults?: number | null | undefined
+	},
+	nextPageToken?: string | null | undefined
+};
+
+const requestInterval = 300;
+
+async function getItems<
+	TApi extends CommonApi<TArgs, TResponse>,
+	TItem,
+	TArgs,
+	TResponse extends CommonResponse<TItem>
+>(api: TApi, args: TArgs): Promise<TItem[]> {
+	const items: TItem[] = [];
+
+	let pageToken: string | null | undefined = undefined;
+
+	do {
+		const response: GoogleApis.Common.GaxiosResponse<TResponse> = await api.list({ ...args, pageToken });
+		response.data.items?.forEach((item) => items.push(item));
+		log(`Getting items (${items.length} of ${response.data.pageInfo?.totalResults || 'many'})...`);
+		pageToken = response.data.nextPageToken;
+
+		await sleep(requestInterval);
+	} while (pageToken);
+
+	return items;
+}
+
+async function getCalendarAPI(profile: string): Promise<GoogleApis.calendar_v3.Calendar> {
+	const googleAuth = await getAuth(profile);
+
+	return google.calendar({
+		version : 'v3',
+		auth    : googleAuth,
+	});
+}
+
+async function getYoutubeAPI(profile: string): Promise<GoogleApis.youtube_v3.Youtube> {
+	const googleAuth = await getAuth(profile);
+
+	return google.youtube({
+		version : 'v3',
+		auth    : googleAuth,
+	});
+}
+
+async function getEvents(profile: string, args: GoogleApis.calendar_v3.Params$Resource$Events$List) {
+	const api = await data.getCalendarAPI(profile);
+	return getItems(api.events, args);
+}
+
+async function getVideos(profile: string, args: GoogleApis.youtube_v3.Params$Resource$Playlistitems$List) {
+	const api = await data.getYoutubeAPI(profile);
+	return getItems(api.playlistItems, args);
+}
+
+async function setEvent(profile: string, eventId: string | undefined, args: GoogleApis.calendar_v3.Params$Resource$Events$Update) {
+	const api = await data.getCalendarAPI(profile);
+	api.events.update({ eventId, ...args });
+}

package/src/lib/jsonLib.ts

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import { error } from './logger';
+import { ensureFile } from './paths';
+
+import jsonLib from './jsonLib';
+
+export { getJSON, getJSONAsync, writeJSON };
+export default { getJSON, getJSONAsync, writeJSON, readJSON, checkJSON };
+
+function getJSON<T>(filename: string, createCallback: () => Exclude<T, Promise<any>>): T {
+	if (fs.existsSync(filename)) {
+		return jsonLib.readJSON(filename);
+	}
+
+	const json = createCallback();
+	jsonLib.checkJSON(filename, json);
+	ensureFile(filename);
+	jsonLib.writeJSON(filename, json);
+	return json;
+}
+
+async function getJSONAsync<T>(filename: string, createCallbackAsync: () => Promise<T>): Promise<T> {
+	if (fs.existsSync(filename)) {
+		return jsonLib.readJSON(filename);
+	}
+
+	const json = await createCallbackAsync();
+	jsonLib.checkJSON(filename, json);
+	jsonLib.writeJSON(filename, json);
+	return json;
+}
+
+function writeJSON<T>(filename: string, json: T): void {
+	const jsonString = JSON.stringify(json, null, '    ');
+	fs.writeFileSync(filename, jsonString);
+}
+
+function readJSON<T>(filename: string): T {
+	const jsonString = fs.readFileSync(filename).toString();
+	return JSON.parse(jsonString) as T;
+}
+
+function checkJSON<T>(filename: string, json: T): void {
+	if (json) {
+		return;
+	}
+	error(`File ${filename} doesn't exist and should be created with initial data, but function createCallback returned nothing`);
+}

package/src/lib/logger.ts

@@ -0,0 +1,21 @@
+import * as colorette from 'colorette';
+
+export { log, info, warn, error };
+export default { log, info, warn, error };
+
+function log(message: string): void {
+	console.log(message);
+}
+
+function info(message: string): void {
+	console.log(colorette.greenBright(message));
+}
+
+function warn(message: string): void {
+	console.warn(colorette.yellowBright(message));
+}
+
+function error(message: string): never {
+	console.error(`${colorette.redBright(message)}\n`);
+	process.exit(1);
+}

package/src/lib/paths.ts

@@ -0,0 +1,39 @@
+import fs from 'fs';
+import path from 'path';
+import paths from './paths';
+
+export { ensureDir, ensureFile, getProfilesFile, getSecretsFile, getCredentialsFile };
+export default { ensureDir, ensureFile, getProfilesFile, getSecretsFile, getCredentialsFile };
+
+const dirPaths = {
+	input   : 'input',
+	secrets : 'secrets',
+};
+
+function ensureDir(dirPath: string) {
+	if (!fs.existsSync(dirPath)) {
+		fs.mkdirSync(dirPath, { recursive : true });
+	}
+	return dirPath;
+}
+
+function ensureFile(filePath: string) {
+	paths.ensureDir(path.dirname(filePath));
+
+	if (!fs.existsSync(filePath)) {
+		fs.writeFileSync(filePath, '');
+	}
+	return filePath;
+}
+
+function getProfilesFile() {
+	return path.join(dirPaths.input, 'profiles.json');
+}
+
+function getSecretsFile(profile: string) {
+	return path.join(dirPaths.secrets, `${profile}.json`);
+}
+
+function getCredentialsFile(profile: string) {
+	return path.join(dirPaths.secrets, `${profile}.credentials.json`);
+}

package/src/lib/profiles.ts

@@ -0,0 +1,33 @@
+import { getJSON, writeJSON } from './jsonLib';
+import { error } from './logger';
+import { getProfilesFile } from './paths';
+
+import profiles from './profiles';
+
+export { getProfiles, setProfiles, createProfile };
+export default { getProfiles, setProfiles, createProfile };
+
+function getProfiles(): string[] {
+	const profilesFile = getProfilesFile();
+	return getJSON(profilesFile, () => []);
+}
+
+function setProfiles(profiles: string[]): void {
+	const profilesFile = getProfilesFile();
+	writeJSON(profilesFile, profiles);
+}
+
+function createProfile(profile: string): void {
+	if (!profile) {
+		error('Usage: `npm run create <profile>` where `profile` - is any profile name you want');
+	}
+
+	const existingProfiles = profiles.getProfiles();
+
+	if (existingProfiles.includes(profile)) {
+		return;
+	}
+
+	existingProfiles.push(profile);
+	profiles.setProfiles(existingProfiles);
+}

package/src/lib/secrets.ts

@@ -0,0 +1,79 @@
+import http from 'http';
+import * as colorette from 'colorette';
+import type GoogleApis from 'googleapis';
+import type { Secrets } from '../types';
+import { getJSON, getJSONAsync } from './jsonLib';
+import { info, error } from './logger';
+import { getSecretsFile, getCredentialsFile } from './paths';
+
+import secrets from './secrets';
+
+export { getSecrets, getCredentials };
+export default { getSecrets, getCredentials, createCredentials, checkSecrets, getSecretsError };
+
+const callbackPort = 6006;
+const callbackURI  = `http://localhost:${callbackPort}/oauthcallback`;
+const scope        = [ 'https://www.googleapis.com/auth/youtube.readonly' ];
+
+async function getSecrets(profile: string): Promise<Secrets> {
+	const secretsFile   = getSecretsFile(profile);
+	const secretsObject = getJSON<Secrets>(secretsFile, () => error(secrets.getSecretsError(profile, secretsFile)) as never);
+	secrets.checkSecrets(profile, secretsObject, secretsFile);
+	return secretsObject;
+}
+
+async function getCredentials(profile: string, auth: GoogleApis.Common.OAuth2Client): Promise<GoogleApis.Auth.Credentials> {
+	const credentialsFile = getCredentialsFile(profile);
+	return getJSONAsync(credentialsFile, () => secrets.createCredentials(profile, auth));
+}
+
+async function createCredentials(profile: string, auth: GoogleApis.Auth.OAuth2Client): Promise<GoogleApis.Auth.Credentials> {
+	return new Promise((resolve) => {
+		const authUrl = auth.generateAuthUrl({
+			// eslint-disable-next-line camelcase
+			access_type : 'offline',
+			scope,
+		});
+
+		const server = http.createServer(async (request, response) => {
+			response.end('<h1>Please close this page and return to application</h1>');
+
+			if (request.url) {
+				const url  = new URL(`http://${request.headers.host}${request.url}`);
+				const code = url.searchParams.get('code');
+
+				if (!code) {
+					return;
+				}
+
+				server.close();
+				const { tokens } = await auth.getToken(code);
+				resolve(tokens);
+			}
+		});
+
+		server.listen(callbackPort);
+		info(`Please open ${colorette.yellow(authUrl)} in your browser using google profile for ${colorette.yellow(profile)} and allow access to ${colorette.yellow(scope.join(','))}`);
+	});
+}
+
+function checkSecrets(profile: string, secretsObject: Secrets, secretsFile: string): true | void {
+	if (secretsObject.web.redirect_uris[0] === callbackURI) {
+		return true;
+	}
+	error(`Error in credentials file: redirect URI should be ${callbackURI}.\n${secrets.getSecretsError(profile, secretsFile)}`);
+}
+
+function getSecretsError(profile: string, secretsFile: string) {
+	return [
+		`File ${secretsFile} not found!`,
+		'To obtain it, please create correct OAuth client ID:',
+		'\tGo to https://console.cloud.google.com/apis/credentials/oauthclient',
+		'\t[if applicable] Click "+ Create credentials" and choose "OAuth client ID',
+		'\tSet application type "Web application"',
+		`\tAdd authorized redirect URI: ${callbackURI}`,
+		'\tClick "Create"',
+		`\tClick "Download JSON" and download credentials to ./secrets/${profile}.json`,
+		'Then start this script again',
+	].join('\n');
+}

package/src/lib/sleep.ts

@@ -0,0 +1,8 @@
+export { sleep };
+export default { sleep };
+
+async function sleep(milliSeconds: number) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, milliSeconds);
+	});
+}

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './secrets';

package/src/types/secrets.ts

@@ -0,0 +1,11 @@
+export interface Secrets {
+	web: {
+		client_id: `${string}.apps.googleusercontent.com`;
+		project_id: string;
+		auth_uri: 'https://accounts.google.com/o/oauth2/auth';
+		token_uri: 'https://oauth2.googleapis.com/token';
+		auth_provider_x509_cert_url: 'https://www.googleapis.com/oauth2/v1/certs';
+		client_secret: string;
+		redirect_uris: string[];
+	};
+}