@authorizerdev/authorizer-js 1.1.0 → 1.1.1

package/src/index.ts

@@ -52,69 +52,6 @@ export class Authorizer {
 		this.config.clientID = config.clientID.trim();
 	}
 
-	revokeToken = async (data: { refresh_token: string }) => {
-		if (!data.refresh_token && !data.refresh_token.trim()) {
-			throw new Error(`Invalid refresh_token`);
-		}
-
-		const fetcher = getFetcher();
-		const res = await fetcher(this.config.authorizerURL + '/oauth/revoke', {
-			method: 'POST',
-			headers: {
-				...this.config.extraHeaders,
-			},
-			body: JSON.stringify({
-				refresh_token: data.refresh_token,
-				client_id: this.config.clientID,
-			}),
-		});
-
-		return await res.json();
-	};
-
-	getToken = async (
-		data: Types.GetTokenInput,
-	): Promise<Types.GetTokenResponse> => {
-		if (!data.grant_type) {
-			data.grant_type = 'authorization_code';
-		}
-
-		if (data.grant_type === 'refresh_token' && !data.refresh_token) {
-			throw new Error(`Invalid refresh_token`);
-		}
-		if (data.grant_type === 'authorization_code' && !this.codeVerifier) {
-			throw new Error(`Invalid code verifier`);
-		}
-
-		const requestData = {
-			client_id: this.config.clientID,
-			code: data.code || '',
-			code_verifier: this.codeVerifier || '',
-			grant_type: data.grant_type || '',
-			refresh_token: data.refresh_token || '',
-		};
-
-		try {
-			const fetcher = getFetcher();
-			const res = await fetcher(`${this.config.authorizerURL}/oauth/token`, {
-				method: 'POST',
-				body: JSON.stringify(requestData),
-				headers: {
-					...this.config.extraHeaders,
-				},
-				credentials: 'include',
-			});
-
-			const json = await res.json();
-			if (res.status >= 400) {
-				throw new Error(json);
-			}
-			return json;
-		} catch (err) {
-			throw err;
-		}
-	};
-
 	authorize = async (data: Types.AuthorizeInput) => {
 		if (!hasWindow()) {
 			throw new Error(`this feature is only supported in browser`);
@@ -174,31 +111,45 @@ export class Authorizer {
 		}
 	};
 
-	// helper to execute graphql queries
-	// takes in any query or mutation string as input
-	graphqlQuery = async (data: Types.GraphqlQueryInput) => {
-		const fetcher = getFetcher();
-		const res = await fetcher(this.config.authorizerURL + '/graphql', {
-			method: 'POST',
-			body: JSON.stringify({
-				query: data.query,
-				variables: data.variables || {},
-			}),
-			headers: {
-				...this.config.extraHeaders,
-				...(data.headers || {}),
-			},
-			credentials: 'include',
-		});
+	browserLogin = async (): Promise<Types.AuthToken | void> => {
+		try {
+			const token = await this.getSession();
+			return token;
+		} catch (err) {
+			if (!hasWindow()) {
+				throw new Error(`browserLogin is only supported for browsers`);
+			}
+			window.location.replace(
+				`${this.config.authorizerURL}/app?state=${encode(
+					JSON.stringify(this.config),
+				)}&redirect_uri=${this.config.redirectURL}`,
+			);
+		}
+	};
 
-		const json = await res.json();
+	forgotPassword = async (
+		data: Types.ForgotPasswordInput,
+	): Promise<Types.Response | void> => {
+		if (!data.state) {
+			data.state = encode(createRandomString());
+		}
 
-		if (json.errors && json.errors.length) {
-			console.error(json.errors);
-			throw new Error(json.errors[0].message);
+		if (!data.redirect_uri) {
+			data.redirect_uri = this.config.redirectURL;
 		}
 
-		return json.data;
+		try {
+			const forgotPasswordRes = await this.graphqlQuery({
+				query: `mutation forgotPassword($data: ForgotPasswordInput!) {	forgot_password(params: $data) { message } }`,
+				variables: {
+					data,
+				},
+			});
+
+			return forgotPasswordRes.forgot_password;
+		} catch (error) {
+			throw error;
+		}
 	};
 
 	getMetaData = async (): Promise<Types.MetaData | void> => {
@@ -213,6 +164,19 @@ export class Authorizer {
 		}
 	};
 
+	getProfile = async (headers?: Types.Headers): Promise<Types.User | void> => {
+		try {
+			const profileRes = await this.graphqlQuery({
+				query: `query {	profile { ${userFragment} } }`,
+				headers,
+			});
+
+			return profileRes.profile;
+		} catch (error) {
+			throw error;
+		}
+	};
+
 	// this is used to verify / get session using cookie by default. If using nodejs pass authorization header
 	getSession = async (
 		headers?: Types.Headers,
@@ -232,61 +196,74 @@ export class Authorizer {
 		}
 	};
 
-	magicLinkLogin = async (
-		data: Types.MagicLinkLoginInput,
-	): Promise<Types.Response> => {
-		try {
-			if (!data.state) {
-				data.state = encode(createRandomString());
-			}
-
-			if (!data.redirect_uri) {
-				data.redirect_uri = this.config.redirectURL;
-			}
-
-			const res = await this.graphqlQuery({
-				query: `
-					mutation magicLinkLogin($data: MagicLinkLoginInput!) { magic_link_login(params: $data) { message }}
-				`,
-				variables: { data },
-			});
+	getToken = async (
+		data: Types.GetTokenInput,
+	): Promise<Types.GetTokenResponse> => {
+		if (!data.grant_type) {
+			data.grant_type = 'authorization_code';
+		}
 
-			return res.magic_link_login;
-		} catch (err) {
-			throw err;
+		if (data.grant_type === 'refresh_token' && !data.refresh_token) {
+			throw new Error(`Invalid refresh_token`);
+		}
+		if (data.grant_type === 'authorization_code' && !this.codeVerifier) {
+			throw new Error(`Invalid code verifier`);
 		}
-	};
 
-	signup = async (data: Types.SignupInput): Promise<Types.AuthToken | void> => {
+		const requestData = {
+			client_id: this.config.clientID,
+			code: data.code || '',
+			code_verifier: this.codeVerifier || '',
+			grant_type: data.grant_type || '',
+			refresh_token: data.refresh_token || '',
+		};
+
 		try {
-			const res = await this.graphqlQuery({
-				query: `
-					mutation signup($data: SignUpInput!) { signup(params: $data) { ${authTokenFragment}}}
-				`,
-				variables: { data },
+			const fetcher = getFetcher();
+			const res = await fetcher(`${this.config.authorizerURL}/oauth/token`, {
+				method: 'POST',
+				body: JSON.stringify(requestData),
+				headers: {
+					...this.config.extraHeaders,
+				},
+				credentials: 'include',
 			});
 
-			return res.signup;
+			const json = await res.json();
+			if (res.status >= 400) {
+				throw new Error(json);
+			}
+			return json;
 		} catch (err) {
 			throw err;
 		}
 	};
 
-	verifyEmail = async (
-		data: Types.VerifyEmailInput,
-	): Promise<Types.AuthToken | void> => {
-		try {
-			const res = await this.graphqlQuery({
-				query: `
-					mutation verifyEmail($data: VerifyEmailInput!) { verify_email(params: $data) { ${authTokenFragment}}}
-				`,
-				variables: { data },
-			});
+	// helper to execute graphql queries
+	// takes in any query or mutation string as input
+	graphqlQuery = async (data: Types.GraphqlQueryInput) => {
+		const fetcher = getFetcher();
+		const res = await fetcher(this.config.authorizerURL + '/graphql', {
+			method: 'POST',
+			body: JSON.stringify({
+				query: data.query,
+				variables: data.variables || {},
+			}),
+			headers: {
+				...this.config.extraHeaders,
+				...(data.headers || {}),
+			},
+			credentials: 'include',
+		});
 
-			return res.verify_email;
-		} catch (err) {
-			throw err;
+		const json = await res.json();
+
+		if (json.errors && json.errors.length) {
+			console.error(json.errors);
+			throw new Error(json.errors[0].message);
 		}
+
+		return json.data;
 	};
 
 	login = async (data: Types.LoginInput): Promise<Types.AuthToken | void> => {
@@ -304,92 +281,40 @@ export class Authorizer {
 		}
 	};
 
-	getProfile = async (headers?: Types.Headers): Promise<Types.User | void> => {
-		try {
-			const profileRes = await this.graphqlQuery({
-				query: `query {	profile { ${userFragment} } }`,
-				headers,
-			});
-
-			return profileRes.profile;
-		} catch (error) {
-			throw error;
-		}
-	};
-
-	updateProfile = async (
-		data: Types.UpdateProfileInput,
-		headers?: Types.Headers,
-	): Promise<Types.Response | void> => {
+	logout = async (headers?: Types.Headers): Promise<Types.Response | void> => {
 		try {
-			const updateProfileRes = await this.graphqlQuery({
-				query: `mutation updateProfile($data: UpdateProfileInput!) {	update_profile(params: $data) { message } }`,
+			const res = await this.graphqlQuery({
+				query: ` mutation { logout { message } } `,
 				headers,
-				variables: {
-					data,
-				},
 			});
-
-			return updateProfileRes.update_profile;
-		} catch (error) {
-			throw error;
+			return res.logout;
+		} catch (err) {
+			console.error(err);
 		}
 	};
 
-	forgotPassword = async (
-		data: Types.ForgotPasswordInput,
-	): Promise<Types.Response | void> => {
-		if (!data.state) {
-			data.state = encode(createRandomString());
-		}
-
-		if (!data.redirect_uri) {
-			data.redirect_uri = this.config.redirectURL;
-		}
-
+	magicLinkLogin = async (
+		data: Types.MagicLinkLoginInput,
+	): Promise<Types.Response> => {
 		try {
-			const forgotPasswordRes = await this.graphqlQuery({
-				query: `mutation forgotPassword($data: ForgotPasswordInput!) {	forgot_password(params: $data) { message } }`,
-				variables: {
-					data,
-				},
-			});
+			if (!data.state) {
+				data.state = encode(createRandomString());
+			}
 
-			return forgotPasswordRes.forgot_password;
-		} catch (error) {
-			throw error;
-		}
-	};
+			if (!data.redirect_uri) {
+				data.redirect_uri = this.config.redirectURL;
+			}
 
-	resetPassword = async (
-		data: Types.ResetPasswordInput,
-	): Promise<Types.Response | void> => {
-		try {
-			const resetPasswordRes = await this.graphqlQuery({
-				query: `mutation resetPassword($data: ResetPasswordInput!) {	reset_password(params: $data) { message } }`,
-				variables: {
-					data,
-				},
+			const res = await this.graphqlQuery({
+				query: `
+					mutation magicLinkLogin($data: MagicLinkLoginInput!) { magic_link_login(params: $data) { message }}
+				`,
+				variables: { data },
 			});
-			return resetPasswordRes.reset_password;
-		} catch (error) {
-			throw error;
-		}
-	};
 
-	browserLogin = async (): Promise<Types.AuthToken | void> => {
-		try {
-			const token = await this.getSession();
-			return token;
+			return res.magic_link_login;
 		} catch (err) {
-			if (!hasWindow()) {
-				throw new Error(`browserLogin is only supported for browsers`);
-			}
-			window.location.replace(
-				`${this.config.authorizerURL}/app?state=${encode(
-					JSON.stringify(this.config),
-				)}&redirect_uri=${this.config.redirectURL}`,
-			);
+			throw err;
 		}
 	};
 
@@ -423,15 +348,90 @@ export class Authorizer {
 		);
 	};
 
-	logout = async (headers?: Types.Headers): Promise<Types.Response | void> => {
+	resendOtp = async (
+		data: Types.ResendOtpInput,
+	): Promise<Types.Response | void> => {
 		try {
 			const res = await this.graphqlQuery({
-				query: ` mutation { logout { message } } `,
-				headers,
+				query: `
+					mutation resendOtp($data: ResendOTPRequest!) { resend_otp(params: $data) { message }}
+				`,
+				variables: { data },
 			});
-			return res.logout;
+
+			return res.resend_otp;
 		} catch (err) {
-			console.error(err);
+			throw err;
+		}
+	};
+
+	resetPassword = async (
+		data: Types.ResetPasswordInput,
+	): Promise<Types.Response | void> => {
+		try {
+			const resetPasswordRes = await this.graphqlQuery({
+				query: `mutation resetPassword($data: ResetPasswordInput!) {	reset_password(params: $data) { message } }`,
+				variables: {
+					data,
+				},
+			});
+			return resetPasswordRes.reset_password;
+		} catch (error) {
+			throw error;
+		}
+	};
+
+	revokeToken = async (data: { refresh_token: string }) => {
+		if (!data.refresh_token && !data.refresh_token.trim()) {
+			throw new Error(`Invalid refresh_token`);
+		}
+
+		const fetcher = getFetcher();
+		const res = await fetcher(this.config.authorizerURL + '/oauth/revoke', {
+			method: 'POST',
+			headers: {
+				...this.config.extraHeaders,
+			},
+			body: JSON.stringify({
+				refresh_token: data.refresh_token,
+				client_id: this.config.clientID,
+			}),
+		});
+
+		return await res.json();
+	};
+
+	signup = async (data: Types.SignupInput): Promise<Types.AuthToken | void> => {
+		try {
+			const res = await this.graphqlQuery({
+				query: `
+					mutation signup($data: SignUpInput!) { signup(params: $data) { ${authTokenFragment}}}
+				`,
+				variables: { data },
+			});
+
+			return res.signup;
+		} catch (err) {
+			throw err;
+		}
+	};
+
+	updateProfile = async (
+		data: Types.UpdateProfileInput,
+		headers?: Types.Headers,
+	): Promise<Types.Response | void> => {
+		try {
+			const updateProfileRes = await this.graphqlQuery({
+				query: `mutation updateProfile($data: UpdateProfileInput!) {	update_profile(params: $data) { message } }`,
+				headers,
+				variables: {
+					data,
+				},
+			});
+
+			return updateProfileRes.update_profile;
+		} catch (error) {
+			throw error;
 		}
 	};
 
@@ -440,7 +440,7 @@ export class Authorizer {
 	): Promise<Types.ValidateJWTTokenResponse> => {
 		try {
 			const res = await this.graphqlQuery({
-				query: `query validateJWTToken($params: ValidateJWTTokenInput!){validate_jwt_token(params: $params) { is_valid } }`,
+				query: `query validateJWTToken($params: ValidateJWTTokenInput!){validate_jwt_token(params: $params) { is_valid claims } }`,
 				variables: {
 					params,
 				},
@@ -452,35 +452,35 @@ export class Authorizer {
 		}
 	};
 
-	verifyOtp = async (
-		data: Types.VerifyOtpInput,
+	verifyEmail = async (
+		data: Types.VerifyEmailInput,
 	): Promise<Types.AuthToken | void> => {
 		try {
 			const res = await this.graphqlQuery({
 				query: `
-					mutation verifyOtp($data: VerifyOTPRequest!) { verify_otp(params: $data) { ${authTokenFragment}}}
+					mutation verifyEmail($data: VerifyEmailInput!) { verify_email(params: $data) { ${authTokenFragment}}}
 				`,
 				variables: { data },
 			});
 
-			return res.verify_otp;
+			return res.verify_email;
 		} catch (err) {
 			throw err;
 		}
 	};
 
-	resendOtp = async (
-		data: Types.ResendOtpInput,
-	): Promise<Types.Response | void> => {
+	verifyOtp = async (
+		data: Types.VerifyOtpInput,
+	): Promise<Types.AuthToken | void> => {
 		try {
 			const res = await this.graphqlQuery({
 				query: `
-					mutation resendOtp($data: ResendOTPRequest!) { resend_otp(params: $data) { message }}
+					mutation verifyOtp($data: VerifyOTPRequest!) { verify_otp(params: $data) { ${authTokenFragment}}}
 				`,
 				variables: { data },
 			});
 
-			return res.resend_otp;
+			return res.verify_otp;
 		} catch (err) {
 			throw err;
 		}