@authorizerdev/authorizer-js 0.1.0-beta.7 → 0.2.0

package/src/index.ts

@@ -1,93 +1,132 @@
 // Note: write gql query in single line to reduce bundle size
 import nodeFetch from 'node-fetch';
 
-type ConfigType = {
+export type ConfigType = {
 	authorizerURL: string;
-	redirectURL?: string;
+	redirectURL: string;
 };
 
-type User = {
+export type User = {
 	id: string;
 	email: string;
-	firstName?: string | null;
-	lastName?: string | null;
-	image?: string | null;
-	signupMethod?: string | null;
-	emailVerifiedAt?: number | null;
+	preferred_username: string;
+	email_verified: boolean;
+	signup_methods: string;
+	given_name?: string | null;
+	family_name?: string | null;
+	middle_name?: string | null;
+	picture?: string | null;
+	gender?: string | null;
+	birthdate?: string | null;
+	phone_number?: string | null;
+	phone_number_verified?: boolean | null;
+	roles?: string[];
+	created_at: number;
+	updated_at: number;
 };
 
-type AuthToken = {
+export type AuthToken = {
 	message?: string;
-	accessToken: string;
-	accessTokenExpiresAt: number;
+	access_token: string;
+	expires_at: number;
 	user?: User;
 };
 
-type Response = {
+export type Response = {
 	message: string;
 };
 
-type Headers = Record<string, string>;
+export type Headers = Record<string, string>;
 
-type LoginInput = { email: string; password: string };
+export type LoginInput = { email: string; password: string; roles?: string[] };
 
-type SignupInput = {
+export type SignupInput = {
 	email: string;
 	password: string;
-	confirmPassword: string;
-	firstName?: string;
-	lastName?: string;
+	confirm_password: string;
+	given_name?: string;
+	family_name?: string;
+	middle_name?: string;
+	picture?: string;
+	gender?: string;
+	birthdate?: string;
+	phone_number?: string;
+	roles?: string[];
 };
 
-type VerifyEmailInput = { token: string };
+export type MagicLinkLoginInput = {
+	email: string;
+	roles?: string[];
+};
 
-type GraphqlQueryInput = {
+export type VerifyEmailInput = { token: string };
+
+export type GraphqlQueryInput = {
 	query: string;
 	variables?: Record<string, any>;
 	headers?: Headers;
 };
 
-type MetaData = {
+export type MetaData = {
 	version: string;
-	isGoogleLoginEnabled: boolean;
-	isFacebookLoginEnabled: boolean;
-	isTwitterLoginEnabled: boolean;
-	isGithubLoginEnabled: boolean;
-	isEmailVerificationEnabled: boolean;
-	isBasicAuthenticationEnabled: boolean;
+	is_google_login_enabled: boolean;
+	is_facebook_login_enabled: boolean;
+	is_github_login_enabled: boolean;
+	is_email_verification_enabled: boolean;
+	is_basic_authentication_enabled: boolean;
+	is_magic_link_login_enabled: boolean;
 };
 
-type UpdateProfileInput = {
-	oldPassword?: string;
-	newPassword?: string;
-	confirmNewPassword?: string;
-	firstName?: string;
-	lastName?: string;
-	image?: string;
+export type UpdateProfileInput = {
+	old_password?: string;
+	new_password?: string;
+	confirm_new_password?: string;
 	email?: string;
+	given_name?: string;
+	family_name?: string;
+	middle_name?: string;
+	nickname?: string;
+	gender?: string;
+	birthdate?: string;
+	phone_number?: string;
+	picture?: string;
 };
 
-type ForgotPasswordInput = {
+export type ForgotPasswordInput = {
 	email: string;
 };
 
-type ResetPasswordInput = {
+export type ResetPasswordInput = {
 	token: string;
 	password: string;
-	confirmPassword: string;
+	confirm_password: string;
 };
 
-enum OAuthProviders {
+export enum OAuthProviders {
 	Github = 'github',
 	Google = 'google',
+	Facebook = 'facebook',
 }
 
 const hasWindow = (): boolean => typeof window !== 'undefined';
 
 // re-usable gql response fragment
-const userTokenFragment = `message accessToken accessTokenExpiresAt user { id email firstName lastName image }`;
+const userFragment = `id email email_verified given_name family_name middle_name nickname preferred_username picture signup_methods gender birthdate phone_number phone_number_verified roles created_at updated_at `;
+const authTokenFragment = `message access_token expires_at user { ${userFragment} }`;
+
+const trimURL = (url: string): string => {
+	let trimmedData = url.trim();
+	const lastChar = trimmedData[trimmedData.length - 1];
+	if (lastChar === '/') {
+		trimmedData = trimmedData.slice(0, -1);
+	} else {
+		trimmedData = trimmedData;
+	}
 
-export default class Authorizer {
+	return trimmedData;
+};
+
+export class Authorizer {
 	// class variable
 	config: ConfigType;
 
@@ -97,20 +136,16 @@ export default class Authorizer {
 			throw new Error(`Configuration is required`);
 		}
 		this.config = config;
-		if (!config.authorizerURL.trim()) {
+		if (!config.authorizerURL && !config.authorizerURL.trim()) {
 			throw new Error(`Invalid authorizerURL`);
 		}
 		if (config.authorizerURL) {
-			const trimmedData = config.authorizerURL.trim();
-			const lastChar = trimmedData[trimmedData.length - 1];
-			if (lastChar === '/') {
-				this.config.authorizerURL = trimmedData.slice(0, -1);
-			} else {
-				this.config.authorizerURL = trimmedData;
-			}
+			this.config.authorizerURL = trimURL(config.authorizerURL);
 		}
-		if (!config.redirectURL) {
+		if (!config.redirectURL && !config.redirectURL.trim()) {
 			throw new Error(`Invalid redirectURL`);
+		} else {
+			this.config.redirectURL = trimURL(config.redirectURL);
 		}
 	}
 
@@ -146,7 +181,7 @@ export default class Authorizer {
 	getMetaData = async (): Promise<MetaData | void> => {
 		try {
 			const res = await this.graphqlQuery({
-				query: `query { meta { version isGoogleLoginEnabled isGithubLoginEnabled isBasicAuthenticationEnabled isEmailVerificationEnabled isFacebookLoginEnabled isTwitterLoginEnabled } }`,
+				query: `query { meta { version is_google_login_enabled is_facebook_login_enabled is_github_login_enabled is_email_verification_enabled is_basic_authentication_enabled is_magic_link_login_enabled } }`,
 			});
 
 			return res.meta;
@@ -156,13 +191,34 @@ export default class Authorizer {
 	};
 
 	// this is used to verify / get session using cookie by default. If using nodejs pass authorization header
-	getSession = async (headers?: Headers): Promise<AuthToken> => {
+	getSession = async (
+		headers?: Headers,
+		roles?: string[],
+	): Promise<AuthToken> => {
 		try {
 			const res = await this.graphqlQuery({
-				query: `query {token { ${userTokenFragment} } }`,
+				query: `query getSession($roles: [String!]){session(roles: $roles) { ${authTokenFragment} } }`,
 				headers,
+				variables: {
+					roles,
+				},
 			});
-			return res.token;
+			return res.session;
+		} catch (err) {
+			throw err;
+		}
+	};
+
+	magicLinkLogin = async (data: MagicLinkLoginInput): Promise<Response> => {
+		try {
+			const res = await this.graphqlQuery({
+				query: `
+					mutation magicLinkLogin($data: MagicLinkLoginInput!) { magic_link_login(params: $data) { message }}
+				`,
+				variables: { data },
+			});
+
+			return res.magic_link_login;
 		} catch (err) {
 			throw err;
 		}
@@ -172,13 +228,14 @@ export default class Authorizer {
 		try {
 			const res = await this.graphqlQuery({
 				query: `
-		mutation signup($data: SignUpInput!) { signup(params: $data) { ${userTokenFragment}}}`,
+					mutation signup($data: SignUpInput!) { signup(params: $data) { ${authTokenFragment}}}
+				`,
 				variables: { data },
 			});
 
 			return res.signup;
 		} catch (err) {
-			console.error(err);
+			throw err;
 		}
 	};
 
@@ -186,13 +243,14 @@ export default class Authorizer {
 		try {
 			const res = await this.graphqlQuery({
 				query: `
-		mutation verifyEmail($data: VerifyEmailInput!) { verifyEmail(params: $data) { ${userTokenFragment}}}`,
+					mutation verifyEmail($data: VerifyEmailInput!) { verify_email(params: $data) { ${authTokenFragment}}}
+				`,
 				variables: { data },
 			});
 
-			return res.verifyEmail;
+			return res.verify_email;
 		} catch (err) {
-			console.error(err);
+			throw err;
 		}
 	};
 
@@ -200,20 +258,21 @@ export default class Authorizer {
 		try {
 			const res = await this.graphqlQuery({
 				query: `
-		mutation login($data: LoginInput!) { login(params: $data) { ${userTokenFragment}}}`,
+					mutation login($data: LoginInput!) { login(params: $data) { ${authTokenFragment}}}
+				`,
 				variables: { data },
 			});
 
 			return res.login;
 		} catch (err) {
-			console.error(err);
+			throw err;
 		}
 	};
 
 	getProfile = async (headers?: Headers): Promise<User | void> => {
 		try {
 			const profileRes = await this.graphqlQuery({
-				query: `query {	profile { id email image firstName lastName emailVerifiedAt signupMethod } }`,
+				query: `query {	profile { ${userFragment} } }`,
 				headers,
 			});
 
@@ -229,14 +288,14 @@ export default class Authorizer {
 	): Promise<Response | void> => {
 		try {
 			const updateProfileRes = await this.graphqlQuery({
-				query: `mutation updateProfile($data: UpdateProfileInput!) {	updateProfile(params: $data) { message } }`,
+				query: `mutation updateProfile($data: UpdateProfileInput!) {	update_profile(params: $data) { message } }`,
 				headers,
 				variables: {
 					data,
 				},
 			});
 
-			return updateProfileRes.updateProfile;
+			return updateProfileRes.update_profile;
 		} catch (error) {
 			throw error;
 		}
@@ -247,13 +306,13 @@ export default class Authorizer {
 	): Promise<Response | void> => {
 		try {
 			const forgotPasswordRes = await this.graphqlQuery({
-				query: `mutation forgotPassword($data: ForgotPasswordInput!) {	forgotPassword(params: $data) { message } }`,
+				query: `mutation forgotPassword($data: ForgotPasswordInput!) {	forgot_password(params: $data) { message } }`,
 				variables: {
 					data,
 				},
 			});
 
-			return forgotPasswordRes.forgotPassword;
+			return forgotPasswordRes.forgot_password;
 		} catch (error) {
 			throw error;
 		}
@@ -264,24 +323,24 @@ export default class Authorizer {
 	): Promise<Response | void> => {
 		try {
 			const resetPasswordRes = await this.graphqlQuery({
-				query: `mutation resetPassword($data: ResetPasswordInput!) {	resetPassword(params: $data) { message } }`,
+				query: `mutation resetPassword($data: ResetPasswordInput!) {	reset_password(params: $data) { message } }`,
 				variables: {
 					data,
 				},
 			});
-			return resetPasswordRes.resetPassword;
+			return resetPasswordRes.reset_password;
 		} catch (error) {
 			throw error;
 		}
 	};
 
-	fingertipLogin = async (): Promise<AuthToken | void> => {
+	browserLogin = async (): Promise<AuthToken | void> => {
 		try {
 			const token = await this.getSession();
 			return token;
 		} catch (err) {
 			if (!hasWindow()) {
-				throw new Error(`fingertipLogin is only supported for browsers`);
+				throw new Error(`browserLogin is only supported for browsers`);
 			}
 			window.location.href = `${this.config.authorizerURL}/app?state=${btoa(
 				JSON.stringify(this.config),
@@ -289,7 +348,10 @@ export default class Authorizer {
 		}
 	};
 
-	oauthLogin = async (oauthProvider: string): Promise<void> => {
+	oauthLogin = async (
+		oauthProvider: string,
+		roles?: string[],
+	): Promise<void> => {
 		// @ts-ignore
 		if (!Object.values(OAuthProviders).includes(oauthProvider)) {
 			throw new Error(
@@ -301,7 +363,11 @@ export default class Authorizer {
 		if (!hasWindow()) {
 			throw new Error(`oauthLogin is only supported for browsers`);
 		}
-		window.location.href = `${this.config.authorizerURL}/oauth_login/${oauthProvider}`;
+		window.location.href = `${
+			this.config.authorizerURL
+		}/oauth_login/${oauthProvider}?redirectURL=${
+			this.config.redirectURL || window.location.origin
+		}${roles && roles.length ? `&roles=${roles.join(',')}` : ``}`;
 	};
 
 	logout = async (headers?: Headers): Promise<Response | void> => {
@@ -312,6 +378,7 @@ export default class Authorizer {
 			});
 			return res.logout;
 		} catch (err) {
+			console.log(`logout err:`, err);
 			console.error(err);
 		}
 	};