@anmiles/google-api-wrapper 1.0.1 → 2.0.0

package/CHANGELOG.md

@@ -5,6 +5,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.0](../../tags/v2.0.0) - 2023-03-12
+### Changed
+- Split APIs
+
 ## [1.0.0](../../tags/v1.0.0) - 2023-03-12
 ### Changed
 - First release

package/README.md

@@ -25,10 +25,10 @@ login("username");
 ``` js
 /* videos.js */
 
-import { getProfiles, getVideos } from '@anmiles/google-api-wrapper';
+import { getProfiles, youtube } from '@anmiles/google-api-wrapper';
 
 getProfiles().map(async (profile) => {
-	const videos = await getVideos(profile, { playlistId : 'LL', part : [ 'snippet' ], maxResults : 50 });
+	const videos = await youtube.getPlaylistItems(profile, { playlistId : 'LL', part : [ 'snippet' ], maxResults : 50 });
 	videos.forEach((video) => console.log(`Downloaded: ${video.snippet?.title}`));
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anmiles/google-api-wrapper",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "Provides quick interface for getting google API data",
   "keywords": [
     "google",

package/src/index.ts

@@ -1,3 +1,4 @@
-export { getEvents, getVideos } from './lib/data';
+export * as calendar from './lib/api/calendar';
+export * as youtube from './lib/api/youtube';
 export { createProfile, getProfiles } from './lib/profiles';
 export { login } from './lib/auth';

package/src/lib/api/__tests__/apiHelpers.ts

@@ -0,0 +1,18 @@
+const getAPI = <T>(items: Array<Array<T> | null>, pageTokens: Array<string | undefined>) => ({
+	list : jest.fn().mockImplementation(async ({ pageToken }: {pageToken?: string}) => {
+		const index = pageTokens.indexOf(pageToken);
+
+		return {
+			data : {
+				items         : items[index],
+				nextPageToken : pageTokens[index + 1],
+				pageInfo      : !items[index] ? null : {
+					totalResults : items.reduce((sum, list) => sum + (list?.length || 0), 0),
+				},
+			},
+		};
+	}),
+	update : jest.fn(),
+});
+
+export default { getAPI };

package/src/lib/api/__tests__/calendar.test.ts

@@ -0,0 +1,116 @@
+import fs from 'fs';
+import { google } from 'googleapis';
+import auth from '../../auth';
+import calendar from '../calendar';
+import shared from '../shared';
+import apiHelpers from './apiHelpers';
+
+const original = jest.requireActual('../calendar').default as typeof calendar;
+jest.mock<Partial<typeof calendar>>('../calendar', () => ({
+	getAPI : jest.fn().mockImplementation(async () => ({ events : api })),
+}));
+
+jest.mock<Partial<typeof shared>>('../shared', () => ({
+	getItems : jest.fn().mockImplementation(async () => events),
+}));
+
+jest.mock<Partial<typeof fs>>('fs', () => ({
+	writeFileSync : jest.fn(),
+}));
+
+jest.mock('googleapis', () => ({
+	google : {
+		calendar : jest.fn().mockImplementation(() => ({ events : api })),
+	},
+}));
+
+jest.mock<Partial<typeof auth>>('../../auth', () => ({
+	getAuth : jest.fn().mockImplementation(() => googleAuth),
+}));
+
+const profile = 'username';
+
+const googleAuth = {
+	setCredentials : jest.fn(),
+};
+
+const events: Array<{ summary?: string, source?: { url?: string, title?: string} }> = [
+	{ summary : 'event 1', source : { title : 'source 1', url : 'https://example.com' } },
+	{ summary : 'event 2', source : { title : 'source 2', url : undefined } },
+	{ summary : 'event 3', source : { title : undefined, url : undefined } },
+	{ summary : 'event 4', source : undefined },
+];
+
+const eventsResponse = [
+	[ events[0], events[1] ],
+	null,
+	[ events[2], events[3] ],
+];
+
+const pageTokens = [
+	undefined,
+	'token1',
+	'token2',
+];
+
+const api  = apiHelpers.getAPI(eventsResponse, pageTokens);
+const args = { timeMin : '2010-01-01T00:00:00', timeMax : '2019-12-31T23:59:59' };
+
+describe('src/lib/api/calendar', () => {
+	describe('getAPI', () => {
+		it('should call getAuth', async () => {
+			await original.getAPI(profile);
+
+			expect(auth.getAuth).toBeCalledWith(profile);
+		});
+
+		it('should get calendar api', async () => {
+			await original.getAPI(profile);
+
+			expect(google.calendar).toBeCalledWith({ version : 'v3', auth : googleAuth });
+		});
+
+		it('should return calendar api', async () => {
+			const result = await original.getAPI(profile);
+
+			expect(result).toEqual({ events : api });
+		});
+	});
+
+	describe('getEvents', () => {
+		it('should get api', async () => {
+			await original.getEvents(profile, args);
+
+			expect(calendar.getAPI).toBeCalledWith(profile);
+		});
+
+		it('should get items', async () => {
+			await original.getEvents(profile, args);
+
+			expect(shared.getItems).toBeCalledWith(api, args);
+		});
+
+		it('should return events', async () => {
+			const result = await original.getEvents(profile, args);
+
+			expect(result).toEqual(events);
+		});
+	});
+
+	describe('setEvent', () => {
+		const eventId    = 'eventId';
+		const updateArgs = { requestBody : { summary : 'summary' } };
+
+		it('should get api', async () => {
+			await original.setEvent(profile, eventId, updateArgs);
+
+			expect(calendar.getAPI).toBeCalledWith(profile);
+		});
+
+		it('should set items', async () => {
+			await original.setEvent(profile, eventId, updateArgs);
+
+			expect(api.update).toBeCalledWith({ eventId, ...updateArgs });
+		});
+	});
+});

package/src/lib/api/__tests__/shared.test.ts

@@ -0,0 +1,73 @@
+import logger from '../../logger';
+import sleep from '../../sleep';
+import shared from '../shared';
+import apiHelpers from './apiHelpers';
+
+const original = jest.requireActual('../shared').default as typeof shared;
+jest.mock<Partial<typeof shared>>('../shared', () => ({
+	getItems : jest.fn().mockImplementation(async () => items),
+}));
+
+jest.mock<Partial<typeof logger>>('../../logger', () => ({
+	log : jest.fn(),
+}));
+
+jest.mock<Partial<typeof sleep>>('../../sleep', () => ({
+	sleep : jest.fn(),
+}));
+
+const items: Array<{ data: string}> = [
+	{ data : 'first' },
+	{ data : 'second' },
+	{ data : 'third' },
+	{ data : 'forth' },
+];
+
+const response = [
+	[ items[0], items[1] ],
+	null,
+	[ items[2], items[3] ],
+];
+
+const pageTokens = [
+	undefined,
+	'token1',
+	'token2',
+];
+
+const api  = apiHelpers.getAPI(response, pageTokens);
+const args = { key : 'value' };
+
+describe('src/lib/api/shared', () => {
+	describe('getItems', () => {
+		it('should call API list method for each page', async () => {
+			await original.getItems(api, args);
+
+			pageTokens.forEach((pageToken) => {
+				expect(api.list).toBeCalledWith({ ...args, pageToken });
+			});
+		});
+
+		it('should output progress', async () => {
+			await original.getItems(api, args);
+
+			expect(logger.log).toBeCalledTimes(response.length);
+			expect(logger.log).toBeCalledWith('Getting items (2 of 4)...');
+			expect(logger.log).toBeCalledWith('Getting items (2 of many)...');
+			expect(logger.log).toBeCalledWith('Getting items (4 of 4)...');
+		});
+
+		it('should sleep after reach request', async () => {
+			await original.getItems(api, args);
+
+			expect(sleep.sleep).toBeCalledTimes(response.length);
+			expect(sleep.sleep).toBeCalledWith(300);
+		});
+
+		it('should return items data', async () => {
+			const items = await original.getItems(api, args);
+
+			expect(items).toEqual(items);
+		});
+	});
+});

package/src/lib/api/__tests__/youtube.test.ts

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import { google } from 'googleapis';
+import auth from '../../auth';
+import youtube from '../youtube';
+import shared from '../shared';
+import apiHelpers from './apiHelpers';
+
+const original = jest.requireActual('../youtube').default as typeof youtube;
+jest.mock<Partial<typeof youtube>>('../youtube', () => ({
+	getAPI : jest.fn().mockImplementation(async () => ({ playlistItems : api })),
+}));
+
+jest.mock<Partial<typeof shared>>('../shared', () => ({
+	getItems : jest.fn().mockImplementation(async () => playlistItems),
+}));
+
+jest.mock<Partial<typeof fs>>('fs', () => ({
+	writeFileSync : jest.fn(),
+}));
+
+jest.mock('googleapis', () => ({
+	google : {
+		youtube : jest.fn().mockImplementation(() => ({ playlistItems : api })),
+	},
+}));
+
+jest.mock<Partial<typeof auth>>('../../auth', () => ({
+	getAuth : jest.fn().mockImplementation(() => googleAuth),
+}));
+
+const profile = 'username';
+
+const googleAuth = {
+	setCredentials : jest.fn(),
+};
+
+const playlistItems: Array<{ snippet?: { title?: string, resourceId?: { videoId?: string } } }> = [
+	{ snippet : { title : 'video1', resourceId : { videoId : 'video1Id' } } },
+	{ snippet : { title : 'video2', resourceId : { videoId : undefined } } },
+	{ snippet : { title : undefined, resourceId : undefined } },
+	{ snippet : undefined },
+];
+
+const playlistItemsResponse = [
+	[ playlistItems[0], playlistItems[1] ],
+	null,
+	[ playlistItems[2], playlistItems[3] ],
+];
+
+const pageTokens = [
+	undefined,
+	'token1',
+	'token2',
+];
+
+const api  = apiHelpers.getAPI(playlistItemsResponse, pageTokens);
+const args = { playlistId : 'LL', part : [ 'snippet' ], maxResults : 50 };
+
+describe('src/lib/api/youtube', () => {
+	describe('getAPI', () => {
+		it('should call getAuth', async () => {
+			await original.getAPI(profile);
+
+			expect(auth.getAuth).toBeCalledWith(profile);
+		});
+
+		it('should get youtube api', async () => {
+			await original.getAPI(profile);
+
+			expect(google.youtube).toBeCalledWith({ version : 'v3', auth : googleAuth });
+		});
+
+		it('should return youtube api', async () => {
+			const result = await original.getAPI(profile);
+
+			expect(result).toEqual({ playlistItems : api });
+		});
+	});
+
+	describe('getPlaylistItems', () => {
+		it('should get api', async () => {
+			await original.getPlaylistItems(profile, args);
+
+			expect(youtube.getAPI).toBeCalledWith(profile);
+		});
+
+		it('should call getItems', async () => {
+			await original.getPlaylistItems(profile, args);
+
+			expect(shared.getItems).toBeCalledWith(api, args);
+		});
+
+		it('should return videos', async () => {
+			const result = await original.getPlaylistItems(profile, args);
+
+			expect(result).toEqual(playlistItems);
+		});
+	});
+});

package/src/lib/api/calendar.ts

@@ -0,0 +1,26 @@
+import { google } from 'googleapis';
+import type GoogleApis from 'googleapis';
+import { getAuth } from '../auth';
+import { getItems } from './shared';
+import calendar from './calendar';
+
+export { getAPI, getEvents, setEvent };
+export default { getAPI, getEvents, setEvent };
+
+async function getAPI(profile: string): Promise<GoogleApis.calendar_v3.Calendar> {
+	const googleAuth = await getAuth(profile);
+
+	return google.calendar({
+		version : 'v3',
+		auth    : googleAuth,
+	});
+}
+async function getEvents(profile: string, args: GoogleApis.calendar_v3.Params$Resource$Events$List) {
+	const api = await calendar.getAPI(profile);
+	return getItems(api.events, args);
+}
+
+async function setEvent(profile: string, eventId: string | undefined, args: GoogleApis.calendar_v3.Params$Resource$Events$Update) {
+	const api = await calendar.getAPI(profile);
+	api.events.update({ eventId, ...args });
+}

package/src/lib/api/shared.ts

@@ -0,0 +1,44 @@
+import type GoogleApis from 'googleapis';
+import { log } from '../logger';
+import { sleep } from '../sleep';
+
+export { getItems };
+export default { getItems };
+
+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;
+}

package/src/lib/api/youtube.ts

@@ -0,0 +1,22 @@
+import { google } from 'googleapis';
+import type GoogleApis from 'googleapis';
+import { getAuth } from '../auth';
+import { getItems } from './shared';
+import youtube from './youtube';
+
+export { getAPI, getPlaylistItems };
+export default { getAPI, getPlaylistItems };
+
+async function getAPI(profile: string): Promise<GoogleApis.youtube_v3.Youtube> {
+	const googleAuth = await getAuth(profile);
+
+	return google.youtube({
+		version : 'v3',
+		auth    : googleAuth,
+	});
+}
+
+async function getPlaylistItems(profile: string, args: GoogleApis.youtube_v3.Params$Resource$Playlistitems$List) {
+	const api = await youtube.getAPI(profile);
+	return getItems(api.playlistItems, args);
+}

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

@@ -1,154 +0,0 @@
-import fs from 'fs';
-import auth from '../auth';
-import data from '../data';
-import logger from '../logger';
-import sleep from '../sleep';
-
-const original = jest.requireActual('../data').default as typeof data;
-jest.mock<Partial<typeof data>>('../data', () => ({
-	getItems : jest.fn().mockImplementation(async () => videosList),
-}));
-
-jest.mock<Partial<typeof fs>>('fs', () => ({
-	writeFileSync : jest.fn(),
-}));
-
-jest.mock('googleapis', () => ({
-	google : {
-		calendar : jest.fn().mockImplementation(() => ({ events : eventsAPI })),
-		youtube  : jest.fn().mockImplementation(() => ({ playlistItems : videosAPI })),
-	},
-}));
-
-jest.mock<Partial<typeof auth>>('../auth', () => ({
-	getAuth : jest.fn().mockImplementation(() => googleAuth),
-}));
-
-jest.mock<Partial<typeof logger>>('../logger', () => ({
-	log : jest.fn(),
-}));
-
-jest.mock<Partial<typeof sleep>>('../sleep', () => ({
-	sleep : jest.fn(),
-}));
-
-const profile = 'username';
-
-const googleAuth = {
-	setCredentials : jest.fn(),
-};
-
-const videosList: Array<{ snippet?: { title?: string, resourceId?: { videoId?: string } } }> = [
-	{ snippet : { title : 'video1', resourceId : { videoId : 'video1Id' } } },
-	{ snippet : { title : 'video2', resourceId : { videoId : undefined } } },
-	{ snippet : { title : undefined, resourceId : undefined } },
-	{ snippet : undefined },
-];
-
-const videos = [
-	[ videosList[0], videosList[1] ],
-	null,
-	[ videosList[2], videosList[3] ],
-];
-
-const eventsList: Array<{ snippet?: { title?: string, resourceId?: { videoId?: string } } }> = [
-	{ snippet : { title : 'video1', resourceId : { videoId : 'video1Id' } } },
-	{ snippet : { title : 'video2', resourceId : { videoId : undefined } } },
-	{ snippet : { title : undefined, resourceId : undefined } },
-	{ snippet : undefined },
-];
-
-const events = [
-	[ eventsList[0], eventsList[1] ],
-	null,
-	[ eventsList[2], eventsList[3] ],
-];
-
-const pageTokens = [
-	undefined,
-	'token1',
-	'token2',
-];
-
-const getAPI = <T>(items: Array<Array<T> | null>) => ({
-	list : jest.fn().mockImplementation(async ({ pageToken }: {pageToken?: string}) => {
-		const index = pageTokens.indexOf(pageToken);
-
-		return {
-			data : {
-				items         : items[index],
-				nextPageToken : pageTokens[index + 1],
-				pageInfo      : !items[index] ? null : {
-					totalResults : items.reduce((sum, list) => sum + (list?.length || 0), 0),
-				},
-			},
-		};
-	}),
-});
-
-const eventsAPI = getAPI(events);
-const videosAPI = getAPI(videos);
-
-const args = { playlistId : 'LL', part : [ 'snippet' ], maxResults : 50 };
-
-describe('src/lib/data', () => {
-	describe('getItems', () => {
-		it('should call API list method for each page', async () => {
-			await original.getItems(videosAPI, args);
-
-			pageTokens.forEach((pageToken) => {
-				expect(videosAPI.list).toBeCalledWith({ ...args, pageToken });
-			});
-		});
-
-		it('should output progress', async () => {
-			await original.getItems(videosAPI, args);
-
-			expect(logger.log).toBeCalledTimes(videos.length);
-			expect(logger.log).toBeCalledWith('Getting items (2 of 4)...');
-			expect(logger.log).toBeCalledWith('Getting items (2 of many)...');
-			expect(logger.log).toBeCalledWith('Getting items (4 of 4)...');
-		});
-
-		it('should sleep after reach request', async () => {
-			await original.getItems(videosAPI, args);
-
-			expect(sleep.sleep).toBeCalledTimes(videos.length);
-			expect(sleep.sleep).toBeCalledWith(300);
-		});
-
-		it('should return items data', async () => {
-			const items = await original.getItems(videosAPI, args);
-
-			expect(items).toEqual(videosList);
-		});
-	});
-
-	describe('getEvents', () => {
-		it('should call getItems', async () => {
-			await original.getEvents(profile, args);
-
-			expect(data.getItems).toBeCalledWith(eventsAPI, args);
-		});
-
-		it('should return events', async () => {
-			const events = await original.getEvents(profile, args);
-
-			expect(events).toEqual(eventsList);
-		});
-	});
-
-	describe('getVideos', () => {
-		it('should call getItems', async () => {
-			await original.getVideos(profile, args);
-
-			expect(data.getItems).toBeCalledWith(videosAPI, args);
-		});
-
-		it('should return videos', async () => {
-			const videos = await original.getVideos(profile, args);
-
-			expect(videos).toEqual(videosList);
-		});
-	});
-});

package/src/lib/data.ts

@@ -1,81 +0,0 @@
-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 });
-}