@anmiles/google-api-wrapper 18.0.3 → 19.0.1

package/src/lib/credentials/generator.ts

@@ -0,0 +1,70 @@
+import http from 'http';
+
+import { warn } from '@anmiles/logger';
+import type GoogleApis from 'googleapis';
+import { open } from 'out-url';
+import enableDestroy from 'server-destroy';
+
+import type { AuthOptions } from '../../types/options';
+import { renderAuth, renderDone } from '../renderer';
+import { getScopes } from '../scopes';
+
+const port                = 6006;
+const host                = `localhost:${port}`;
+const startURI            = `http://${host}/`;
+const serverRetryInterval = 1000;
+
+export async function generateCredentials(
+	profile: string,
+	auth: GoogleApis.Auth.OAuth2Client,
+	options?: AuthOptions,
+	prompt?: GoogleApis.Auth.GenerateAuthUrlOpts['prompt'],
+): Promise<GoogleApis.Auth.Credentials> {
+	const scope = options?.scopes ?? getScopes();
+
+	return new Promise((resolve) => {
+		const authUrl = auth.generateAuthUrl({
+			access_type: 'offline',
+			prompt,
+			scope,
+		});
+
+		const server = http.createServer();
+		enableDestroy(server);
+
+		server.on('request', (request, response) => {
+			if (!request.url) {
+				response.end('');
+				return;
+			}
+
+			const url  = new URL(`http://${request.headers.host}${request.url}`);
+			const code = url.searchParams.get('code');
+
+			if (!code) {
+				response.end(renderAuth({ profile, authUrl, scope }));
+				return;
+			}
+
+			response.end(renderDone({ profile }));
+			server.destroy();
+
+			void (async () => {
+				const { tokens } = await auth.getToken(code);
+				resolve(tokens);
+			})();
+		});
+		server.on('error', (error: NodeJS.ErrnoException) => {
+			if (error.code === 'EADDRINUSE') {
+				setTimeout(() => server.listen(port), serverRetryInterval);
+			} else {
+				throw error;
+			}
+		});
+		server.once('listening', () => {
+			warn('Please check your browser for further actions');
+			void open(startURI);
+		});
+		server.listen(port);
+	});
+}

package/src/lib/credentials/index.ts

@@ -0,0 +1,50 @@
+import fs from 'fs';
+
+import type GoogleApis from 'googleapis';
+
+import type { AuthOptions } from '../../types/options';
+import { getCredentialsFile } from '../utils/paths';
+
+import { generateCredentials } from './generator';
+import { validateCredentials } from './validator';
+
+export async function getCredentials(profile: string, auth: GoogleApis.Common.OAuth2Client, options?: AuthOptions): Promise<GoogleApis.Auth.Credentials> {
+	const credentialsFile = getCredentialsFile(profile);
+
+	if (options?.temporary) {
+		const credentials      = await generateCredentials(profile, auth, options);
+		const validationResult = validateCredentials(credentials, options);
+
+		if (!validationResult.isValid) {
+			throw new Error(validationResult.validationError);
+		}
+
+		return credentials;
+	}
+
+	return fs.getJSONAsync(credentialsFile, async () => {
+		const refreshToken = fs.existsSync(credentialsFile)
+			? fs.readJSON<GoogleApis.Auth.Credentials>(credentialsFile).refresh_token
+			: undefined;
+
+		const credentials = await generateCredentials(profile, auth, options,
+			refreshToken
+				? undefined
+				: 'consent',
+		);
+
+		return {
+			refresh_token: refreshToken,
+			...credentials,
+		};
+	// eslint-disable-next-line @typescript-eslint/require-await
+	}, async (credentials) => validateCredentials(credentials));
+}
+
+export function deleteCredentials(profile: string): void {
+	const credentialsFile = getCredentialsFile(profile);
+
+	if (fs.existsSync(credentialsFile)) {
+		fs.rmSync(credentialsFile);
+	}
+}

package/src/lib/credentials/validator.ts

@@ -0,0 +1,29 @@
+import type GoogleApis from 'googleapis';
+
+import type { AuthOptions } from '../../types/options';
+
+const tokenExpiration = 7 * 24 * 60 * 60 * 1000;
+
+export function validateCredentials(
+	credentials: GoogleApis.Auth.Credentials,
+	options?: AuthOptions,
+): { isValid: boolean; validationError?: string } {
+
+	if (!credentials.access_token) {
+		return { isValid: false, validationError: 'Credentials does not have access_token' };
+	}
+
+	if (!credentials.refresh_token && !options?.temporary) {
+		return { isValid: false, validationError: 'Credentials does not have refresh_token' };
+	}
+
+	if (!credentials.expiry_date) {
+		return { isValid: false, validationError: 'Credentials does not have expiry_date' };
+	}
+
+	if (new Date().getTime() - credentials.expiry_date >= tokenExpiration) {
+		return { isValid: false, validationError: 'Credentials expired' };
+	}
+
+	return { isValid: true };
+}

package/src/lib/login.ts

@@ -0,0 +1,22 @@
+import { info, warn } from '@anmiles/logger';
+
+import type { AuthOptions, CommonOptions } from '../types/options';
+
+import { getAuth } from './auth';
+import { getProfiles } from './profiles';
+
+export async function login(profile?: string, options?: AuthOptions & CommonOptions): Promise<void> {
+	const profiles = getProfiles().filter((p) => !profile || p === profile);
+
+	for (const profile of profiles) {
+		if (!options?.hideProgress) {
+			warn(`${profile} - logging in...`);
+		}
+
+		await getAuth(profile, options);
+
+		if (!options?.hideProgress) {
+			info(`${profile} - logged in successfully`);
+		}
+	}
+}

package/src/lib/profiles.ts

@@ -1,36 +1,36 @@
 import fs from 'fs';
+
 import '@anmiles/prototypes';
-import { getProfilesFile } from './paths';
 
-import profiles from './profiles';
+import { getProfilesFile } from './utils/paths';
 
-function getProfiles(): string[] {
+export function getProfiles(): string[] {
 	const profilesFile = getProfilesFile();
 	return fs.getJSON(profilesFile, () => []);
 }
 
-function setProfiles(profiles: string[]): void {
+export function setProfiles(profiles: string[]): void {
 	const profilesFile = getProfilesFile();
 	fs.writeJSON(profilesFile, profiles);
 }
 
-function createProfile(profile?: string): void {
+export function createProfile(profile?: string): void {
 	if (!profile) {
 		throw new Error('Usage: `npm run create <profile>` where `profile` - is any profile name you want');
 	}
 
-	const existingProfiles = profiles.getProfiles();
+	const existingProfiles = getProfiles();
 
 	if (existingProfiles.includes(profile)) {
 		return;
 	}
 
 	existingProfiles.push(profile);
-	profiles.setProfiles(existingProfiles);
+	setProfiles(existingProfiles);
 }
 
-function filterProfiles(profile?: string): string[] {
-	const existingProfiles = profiles.getProfiles();
+export function filterProfiles(profile?: string): string[] {
+	const existingProfiles = getProfiles();
 
 	if (existingProfiles.length === 0) {
 		throw new Error('Please `npm run create` at least one profile');
@@ -46,6 +46,3 @@ function filterProfiles(profile?: string): string[] {
 
 	throw new Error(`Profile '${profile}' does not exist`);
 }
-
-export { getProfiles, setProfiles, createProfile, filterProfiles };
-export default { getProfiles, setProfiles, createProfile, filterProfiles };

package/src/lib/renderer.ts

@@ -1,48 +1,56 @@
 import fs from 'fs';
-import renderer from './renderer';
-import { getTemplateFile } from './paths';
-
-const templates = {
-	index : [ 'page' ] as const,
-	page  : [ 'css', 'content' ] as const,
-	css   : [ ] as const,
-	auth  : [ 'profile', 'authUrl', 'scopesList' ],
+
+import { getTemplateFile } from './utils/paths';
+
+export const templates = {
+	index : [ 'style', 'page', 'script' ] as const,
+	page  : [ 'content' ] as const,
+	style : [ ] as const,
+	script: [ ] as const,
+	auth  : [ 'profile', 'authUrl', 'scopesList' ] as const,
 	scope : [ 'type', 'title', 'name' ] as const,
 	done  : [ 'profile' ] as const,
 } as const;
 
 type TemplateName = keyof typeof templates;
 
-const allHTML = {} as Record<TemplateName, string>;
+const allHTML = {} as Record<TemplateName, string>;	// eslint-disable-line @typescript-eslint/no-unsafe-type-assertion
 
-function renderAuth({ profile, authUrl, scope }: { profile : string; authUrl : string; scope : string[] }): string {
+export function renderAuth({ profile, authUrl, scope }: { profile: string; authUrl: string; scope: string[] }): string {
 	const scopesList = scope.map((s) => render('scope', {
-		name  : s.split('/').pop()!,
-		title : s.endsWith('.readonly') ? 'Readonly (cannot change or delete your data)' : 'Writable (can change or delete your data)',
-		type  : s.endsWith('.readonly') ? 'readonly' : '',
+		name : s.split('/').pop()!,
+		title: s.endsWith('.readonly') ? 'Readonly (cannot change or delete your data)' : 'Writable (can change or delete your data)',
+		type : s.endsWith('.readonly') ? 'readonly' : '',
 	})).join('\n');
 
-	const css     = render('css', {});
+	const style   = render('style', {});
+	const script  = render('script', {});
 	const content = render('auth', { profile, authUrl, scopesList });
-	const page    = render('page', { css, content });
-	return render('index', { page });
+	const page    = render('page', { content });
+	return render('index', { style, page, script });
 }
 
-function renderDone({ profile }: { profile : string }): string {
-	const css     = render('css', {});
+export function renderDone({ profile }: { profile: string }): string {
+	const style   = render('style', {});
+	const script  = render('script', {});
 	const content = render('done', { profile });
-	const page    = render('page', { css, content });
-	return render('index', { page });
+	const page    = render('page', { content });
+	return render('index', { style, page, script });
 }
 
 // TODO: Use react
 function render<T extends TemplateName>(templateName: T, values: Record<typeof templates[T][number], string | undefined>): string {
-	let html        = renderer.getTemplate(templateName);
+	let html        = getTemplate(templateName);
 	const allValues = values as Record<typeof templates[TemplateName][number], string | undefined>;
 
 	for (const variable of templates[templateName]) {
-		const value = allValues[variable] ?? '';
-		html        = html.replace(`\${${variable}}`, value);
+		const value = allValues[variable];
+
+		if (typeof value === 'undefined') {
+			throw new Error(`Missing required value '${variable}' while rendering template '${templateName}'`);
+		}
+
+		html = html.replaceAll(`\${${variable}}`, value);
 	}
 
 	return html;
@@ -51,12 +59,9 @@ function render<T extends TemplateName>(templateName: T, values: Record<typeof t
 function getTemplate(templateName: TemplateName): string {
 	if (!(templateName in allHTML)) {
 		const file            = getTemplateFile(templateName);
-		const template        = fs.readFileSync(file).toString();
+		const template        = fs.readFileSync(file).toString().trim();
 		allHTML[templateName] = template;
 	}
 
 	return allHTML[templateName];
 }
-
-export { templates, renderAuth, renderDone };
-export default { templates, render, getTemplate, renderAuth, renderDone };

package/src/lib/scopes.ts

@@ -0,0 +1,18 @@
+import fs from 'fs';
+
+import { getScopesFile } from './utils/paths';
+
+export function getScopes(): string[] {
+	const scopesFile = getScopesFile();
+	const scopes     = fs.getJSON<string[]>(scopesFile, () => {
+		throw new Error(getScopesError(scopesFile));
+	});
+	return scopes;
+}
+
+function getScopesError(scopesFile: string): string {
+	return [
+		`File ${scopesFile} not found!`,
+		`This application had to have pre-defined file ${scopesFile} that will declare needed scopes`,
+	].join('\n');
+}

package/src/lib/secrets.ts

@@ -1,154 +1,37 @@
 import fs from 'fs';
-import http from 'http';
-import { open } from 'out-url';
-import enableDestroy from 'server-destroy';
-import type GoogleApis from 'googleapis';
-import { warn } from '@anmiles/logger';
-import type { Secrets } from '../types/secrets';
-import type { AuthOptions } from '../types/options';
+
 import '@anmiles/prototypes';
-import { getScopesFile, getSecretsFile, getCredentialsFile } from './paths';
-import { renderAuth, renderDone } from './renderer';
 
-import secrets from './secrets';
+import type { Secrets } from '../types/secrets';
 
-const port                = 6006;
-const host                = `localhost:${port}`;
-const startURI            = `http://${host}/`;
-const callbackURI         = `http://${host}/oauthcallback`;
-const tokenExpiration     = 7 * 24 * 60 * 60 * 1000;
-const serverRetryInterval = 1000;
+import { getScopes } from './scopes';
+import { getSecretsFile } from './utils/paths';
 
-function getScopes(): string[] {
-	const scopesFile = getScopesFile();
-	const scopes     = fs.getJSON<string[]>(scopesFile, () => {
-		throw new Error(secrets.getScopesError(scopesFile));
-	});
-	return scopes;
+const port        = 6006;
+const host        = `localhost:${port}`;
+const callbackURI = `http://${host}/oauthcallback`;
+
+function checkSecrets(secretsObject: Secrets): true {
+	if (secretsObject.web.redirect_uris[0] === callbackURI) {
+		return true;
+	}
+	throw new Error(`Error in credentials file: redirect URI should be ${callbackURI}`);
 }
 
-function getSecrets(profile: string): Secrets {
+export function getSecrets(profile: string): Secrets {
 	const secretsFile   = getSecretsFile(profile);
 	const secretsObject = fs.getJSON<Secrets>(secretsFile, () => {
-		throw new Error(secrets.getSecretsError(profile, secretsFile));
+		throw new Error(getSecretsError(secretsFile));
 	});
-	secrets.checkSecrets(profile, secretsObject, secretsFile);
+	checkSecrets(secretsObject);
 	return secretsObject;
 }
 
-async function getCredentials(profile: string, auth: GoogleApis.Common.OAuth2Client, options?: AuthOptions): Promise<GoogleApis.Auth.Credentials> {
-	const credentialsFile = getCredentialsFile(profile);
-
-	if (options?.temporary) {
-		return secrets.createCredentials(profile, auth, options);
-	}
-
-	return fs.getJSONAsync(credentialsFile, async () => {
-		const refreshToken = fs.existsSync(credentialsFile) ? fs.readJSON<GoogleApis.Auth.Credentials>(credentialsFile).refresh_token : undefined;
-		const credentials  = await secrets.createCredentials(profile, auth, options, refreshToken ? undefined : 'consent');
-		return { refresh_token : refreshToken, ...credentials };
-	}, secrets.validateCredentials);
-}
-
-// eslint-disable-next-line @typescript-eslint/require-await -- pass sync function into async context
-async function validateCredentials(credentials: GoogleApis.Auth.Credentials): Promise<{ isValid : boolean; validationError? : string }> {
-	if (!credentials.access_token) {
-		return { isValid : false, validationError : 'Credentials does not have access_token' };
-	}
-
-	if (!credentials.refresh_token) {
-		return { isValid : false, validationError : 'Credentials does not have refresh_token' };
-	}
-
-	if (!credentials.expiry_date) {
-		return { isValid : false, validationError : 'Credentials does not have expiry_date' };
-	}
-
-	if (new Date().getTime() - credentials.expiry_date >= tokenExpiration) {
-		return { isValid : false, validationError : 'Credentials expired' };
-	}
-
-	return { isValid : true };
-}
-
-async function createCredentials(profile: string, auth: GoogleApis.Auth.OAuth2Client, options?: AuthOptions, prompt?: GoogleApis.Auth.GenerateAuthUrlOpts['prompt']): Promise<GoogleApis.Auth.Credentials> {
-	const scope = options?.scopes ?? secrets.getScopes();
-
-	return new Promise((resolve) => {
-		const authUrl = auth.generateAuthUrl({
-			access_type : 'offline',
-			prompt,
-			scope,
-		});
-
-		const server = http.createServer();
-		enableDestroy(server);
+function getSecretsError(secretsFile: string): string {
+	const relativePath = secretsFile.replace('\\', '/');
 
-		server.on('request', (request, response) => {
-			if (!request.url) {
-				response.end('');
-				return;
-			}
-
-			const url  = new URL(`http://${request.headers.host}${request.url}`);
-			const code = url.searchParams.get('code');
-
-			if (!code) {
-				response.end(renderAuth({ profile, authUrl, scope }));
-				return;
-			}
-
-			response.end(renderDone({ profile }));
-			server.destroy();
-
-			void (async () => {
-				const { tokens } = await auth.getToken(code);
-				resolve(tokens);
-			})();
-		});
-
-		server.on('error', (error: NodeJS.ErrnoException) => {
-			if (error.code === 'EADDRINUSE') {
-				setTimeout(() => server.listen(port), serverRetryInterval);
-			} else {
-				throw error;
-			}
-		});
-
-		server.once('listening', () => {
-			warn('Please check your browser for further actions');
-			void open(startURI);
-		});
-
-		server.listen(port);
-	});
-}
-
-function deleteCredentials(profile: string): void {
-	const credentialsFile = getCredentialsFile(profile);
-
-	if (fs.existsSync(credentialsFile)) {
-		fs.rmSync(credentialsFile);
-	}
-}
-
-function checkSecrets(profile: string, secretsObject: Secrets, secretsFile: string): true {
-	if (secretsObject.web.redirect_uris[0] === callbackURI) {
-		return true;
-	}
-	throw new Error(`Error in credentials file: redirect URI should be ${callbackURI}.\n${secrets.getSecretsError(profile, secretsFile)}`);
-}
-
-function getScopesError(scopesFile: string): string {
-	return [
-		`File ${scopesFile} not found!`,
-		`This application had to have pre-defined file ${scopesFile} that will declare needed scopes`,
-	].join('\n');
-}
-
-function getSecretsError(profile: string, secretsFile: string): string {
 	return [
-		`File ${secretsFile} not found!`,
+		`File ${relativePath} not found!`,
 		'Here is how to obtain it:',
 		'\tGo to https://console.cloud.google.com/projectcreate',
 		'\t\tChoose project name',
@@ -166,7 +49,7 @@ function getSecretsError(profile: string, secretsFile: string): string {
 		'\t\t\t\tSpecify your email as user support email and as developer contact information on the very bottom',
 		'\t\t\t\tClick "Save and continue"',
 		'\t\t\tClick "Add or remove scopes"',
-		`\t\t\t\tAdd scopes: ${secrets.getScopes().join(',')}`,
+		`\t\t\t\tAdd scopes: ${getScopes().join(',')}`,
 		'\t\t\t\tClick "Save and continue"',
 		'\t\t\tClick "Add users"',
 		'\t\t\t\tAdd your email',
@@ -178,10 +61,7 @@ function getSecretsError(profile: string, secretsFile: string): string {
 		'\t\t\t\tSpecify app name, i.e. "NodeJS"',
 		`\t\t\t\tAdd authorized redirect URI: ${callbackURI}`,
 		'\t\t\t\tClick "CREATE"',
-		`\t\t\t\tClick "DOWNLOAD JSON" and download credentials to ./secrets/${profile}.json`,
+		`\t\t\t\tClick "DOWNLOAD JSON" and download credentials to ${relativePath}`,
 		'Then start this script again',
 	].join('\n');
 }
-
-export { getSecrets, getCredentials, deleteCredentials };
-export default { getScopes, getSecrets, getCredentials, validateCredentials, createCredentials, deleteCredentials, checkSecrets, getSecretsError, getScopesError };

package/src/lib/utils/paths.ts

@@ -0,0 +1,30 @@
+import path from 'path';
+
+import type { templates } from '../renderer';
+
+const dirPaths = {
+	input    : 'input',
+	secrets  : 'secrets',
+	// TODO: Remove this hack after moving to React
+	templates: path.relative(process.cwd(), path.join(__dirname, '../../templates')),
+};
+
+export function getProfilesFile(): string {
+	return path.join(dirPaths.input, 'profiles.json');
+}
+
+export function getScopesFile(): string {
+	return 'scopes.json';
+}
+
+export function getSecretsFile(profile: string): string {
+	return path.join(dirPaths.secrets, `${profile}.json`);
+}
+
+export function getCredentialsFile(profile: string): string {
+	return path.join(dirPaths.secrets, `${profile}.credentials.json`);
+}
+
+export function getTemplateFile(templateName: keyof typeof templates): string {
+	return path.join(dirPaths.templates, `${templateName}.html`);
+}

package/src/templates/auth.html

@@ -1,7 +1,7 @@
 <h1>Welcome ${profile}!</h1>
 <p>Please authorize:</p>
 <ul>
-	${scopesList}
+${scopesList}
 </ul>
 <a id="button" href="${authUrl}">Continue</a>
 <script type="text/javascript">document.addEventListener('DOMContentLoaded', function(){ document.getElementById('button').focus(); });</script>

package/src/templates/index.html

@@ -1,12 +1,17 @@
 <!DOCTYPE html>
 <html>
 <head>
-	<title>Google API sign-in</title>
+	<title>Google API sign-in'</title>
 	<meta charset="utf-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
 </head>
 <body>
 
+${style}
+
 ${page}
 
+${script}
+
 </body>
 </html>

package/src/templates/page.html

@@ -1,4 +1,3 @@
-${css}
 <div class="box">
-	${content}
+${content}
 </div>

package/{dist/templates/css.html → src/templates/style.html}

@@ -11,8 +11,8 @@
 	}
 
 	body {
-		font-family: Arial, sans-serif;
-		font-size: 17px;
+		font-family: "Segoe UI", "Roboto", "Helvetica", sans-serif;
+		font-size: 16px;
 		display: flex;
 		align-items: center;
 		justify-content: center;

package/src/types/options.ts

@@ -1,10 +1,8 @@
-interface CommonOptions {
-	hideProgress? : boolean;
+export interface CommonOptions {
+	hideProgress?: boolean;
 }
 
-interface AuthOptions {
-	temporary? : boolean;
-	scopes?    : string[];
+export interface AuthOptions {
+	temporary?: boolean;
+	scopes?: string[];
 }
-
-export type { CommonOptions, AuthOptions };

package/src/types/secrets.ts

@@ -1,13 +1,11 @@
-interface Secrets {
+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[];
+		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[];
 	};
 }
-
-export type { Secrets };

package/tsconfig.build.json

@@ -3,5 +3,11 @@
 
 	"exclude" : [
 		"**/__tests__/",
+		"**/__mocks__/",
 	],
+
+	"compilerOptions" : {
+		"rootDir" : "./src",
+		"outDir" : "./dist",
+	},
 }