@authorizerdev/authorizer-js 0.1.0-beta.8 → 0.2.1

package/lib/esm/index.d.ts

@@ -1,77 +1,123 @@
-declare type ConfigType = {
+export declare type ConfigType = {
     authorizerURL: string;
-    redirectURL?: string;
+    redirectURL: string;
 };
-declare type User = {
+export declare 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;
 };
-declare type AuthToken = {
+export declare type AuthToken = {
     message?: string;
-    accessToken: string;
-    accessTokenExpiresAt: number;
+    access_token: string;
+    expires_at: number;
     user?: User;
 };
-declare type Response = {
+export declare type Response = {
     message: string;
 };
-declare type Headers = Record<string, string>;
-declare type LoginInput = {
+export declare type Headers = Record<string, string>;
+export declare type LoginInput = {
     email: string;
     password: string;
+    roles?: string[];
 };
-declare type SignupInput = {
+export declare 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[];
 };
-declare type VerifyEmailInput = {
+export declare type MagicLinkLoginInput = {
+    email: string;
+    roles?: string[];
+};
+export declare type VerifyEmailInput = {
     token: string;
 };
-declare type GraphqlQueryInput = {
+export declare type GraphqlQueryInput = {
     query: string;
     variables?: Record<string, any>;
     headers?: Headers;
 };
-declare type MetaData = {
+export declare type MetaData = {
     version: string;
-    isGoogleLoginEnabled: boolean;
-    isFacebookLoginEnabled: boolean;
-    isTwitterLoginEnabled: boolean;
-    isGithubLoginEnabled: boolean;
-    isEmailVerificationEnabled: boolean;
-    isBasicAuthenticationEnabled: boolean;
-};
-declare type UpdateProfileInput = {
-    oldPassword?: string;
-    newPassword?: string;
-    confirmNewPassword?: string;
-    firstName?: string;
-    lastName?: string;
-    image?: string;
+    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;
+};
+export declare 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;
 };
-declare type ForgotPasswordInput = {
+export declare type ForgotPasswordInput = {
     email: string;
 };
-declare type ResetPasswordInput = {
+export declare type ResetPasswordInput = {
     token: string;
     password: string;
-    confirmPassword: string;
+    confirm_password: string;
+};
+export declare type SessionQueryInput = {
+    roles?: string[];
 };
-export default class Authorizer {
+export declare type IsValidJWTQueryInput = {
+    jwt: string;
+    roles?: string[];
+};
+export declare type ValidJWTResponse = {
+    valid: string;
+    message: string;
+};
+export declare enum OAuthProviders {
+    Github = "github",
+    Google = "google",
+    Facebook = "facebook"
+}
+export declare class Authorizer {
     config: ConfigType;
     constructor(config: ConfigType);
     graphqlQuery: (data: GraphqlQueryInput) => Promise<any>;
     getMetaData: () => Promise<MetaData | void>;
-    getSession: (headers?: Headers | undefined) => Promise<AuthToken>;
+    getSession: (headers?: Headers | undefined, params?: SessionQueryInput | undefined) => Promise<AuthToken>;
+    isValidJWT: (data: {
+        jwt: string;
+        roles?: string[];
+    }) => Promise<ValidJWTResponse>;
+    magicLinkLogin: (data: MagicLinkLoginInput) => Promise<Response>;
     signup: (data: SignupInput) => Promise<AuthToken | void>;
     verifyEmail: (data: VerifyEmailInput) => Promise<AuthToken | void>;
     login: (data: LoginInput) => Promise<AuthToken | void>;
@@ -79,8 +125,7 @@ export default class Authorizer {
     updateProfile: (data: UpdateProfileInput, headers?: Headers | undefined) => Promise<Response | void>;
     forgotPassword: (data: ForgotPasswordInput) => Promise<Response | void>;
     resetPassword: (data: ResetPasswordInput) => Promise<Response | void>;
-    fingertipLogin: () => Promise<AuthToken | void>;
-    oauthLogin: (oauthProvider: string) => Promise<void>;
+    browserLogin: () => Promise<AuthToken | void>;
+    oauthLogin: (oauthProvider: string, roles?: string[] | undefined) => Promise<void>;
     logout: (headers?: Headers | undefined) => Promise<Response | void>;
 }
-export {};

package/lib/esm/index.js

@@ -1,208 +1,273 @@
 import nodeFetch from 'node-fetch';
 
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
 var OAuthProviders;
 (function (OAuthProviders) {
     OAuthProviders["Github"] = "github";
     OAuthProviders["Google"] = "google";
+    OAuthProviders["Facebook"] = "facebook";
 })(OAuthProviders || (OAuthProviders = {}));
 const hasWindow = () => typeof window !== 'undefined';
-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) => {
+    let trimmedData = url.trim();
+    const lastChar = trimmedData[trimmedData.length - 1];
+    if (lastChar === '/') {
+        trimmedData = trimmedData.slice(0, -1);
+    }
+    else {
+        trimmedData = trimmedData;
+    }
+    return trimmedData;
+};
 class Authorizer {
-    config;
     constructor(config) {
+        this.graphqlQuery = (data) => __awaiter(this, void 0, void 0, function* () {
+            const f = hasWindow() ? window.fetch : nodeFetch;
+            const res = yield f(this.config.authorizerURL + '/graphql', {
+                method: 'POST',
+                body: JSON.stringify({
+                    query: data.query,
+                    variables: data.variables || {},
+                }),
+                headers: Object.assign({ 'Content-Type': 'application/json' }, (data.headers || {})),
+                credentials: 'include',
+            });
+            const json = yield res.json();
+            if (json.errors && json.errors.length) {
+                console.error(json.errors);
+                throw new Error(json.errors[0].message);
+            }
+            return json.data;
+        });
+        this.getMetaData = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    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;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        this.getSession = (headers, params) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    query: `query getSession($params: SessionQueryInput){session(params: $params) { ${authTokenFragment} } }`,
+                    headers,
+                    variables: {
+                        params,
+                    },
+                });
+                return res.session;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        this.isValidJWT = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    query: `query isValidJWT($params: IsValidJWTQueryInput){ is_valid_jwt(params: $params) { message valid } }`,
+                    variables: {
+                        params: data,
+                    },
+                });
+                return res.is_valid_jwt;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        this.magicLinkLogin = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    query: `
+					mutation magicLinkLogin($data: MagicLinkLoginInput!) { magic_link_login(params: $data) { message }}
+				`,
+                    variables: { data },
+                });
+                return res.magic_link_login;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        this.signup = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    query: `
+					mutation signup($data: SignUpInput!) { signup(params: $data) { ${authTokenFragment}}}
+				`,
+                    variables: { data },
+                });
+                return res.signup;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        this.verifyEmail = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    query: `
+					mutation verifyEmail($data: VerifyEmailInput!) { verify_email(params: $data) { ${authTokenFragment}}}
+				`,
+                    variables: { data },
+                });
+                return res.verify_email;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        this.login = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    query: `
+					mutation login($data: LoginInput!) { login(params: $data) { ${authTokenFragment}}}
+				`,
+                    variables: { data },
+                });
+                return res.login;
+            }
+            catch (err) {
+                throw err;
+            }
+        });
+        this.getProfile = (headers) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const profileRes = yield this.graphqlQuery({
+                    query: `query {	profile { ${userFragment} } }`,
+                    headers,
+                });
+                return profileRes.profile;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.updateProfile = (data, headers) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const updateProfileRes = yield this.graphqlQuery({
+                    query: `mutation updateProfile($data: UpdateProfileInput!) {	update_profile(params: $data) { message } }`,
+                    headers,
+                    variables: {
+                        data,
+                    },
+                });
+                return updateProfileRes.update_profile;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.forgotPassword = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const forgotPasswordRes = yield this.graphqlQuery({
+                    query: `mutation forgotPassword($data: ForgotPasswordInput!) {	forgot_password(params: $data) { message } }`,
+                    variables: {
+                        data,
+                    },
+                });
+                return forgotPasswordRes.forgot_password;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.resetPassword = (data) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const resetPasswordRes = yield this.graphqlQuery({
+                    query: `mutation resetPassword($data: ResetPasswordInput!) {	reset_password(params: $data) { message } }`,
+                    variables: {
+                        data,
+                    },
+                });
+                return resetPasswordRes.reset_password;
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+        this.browserLogin = () => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const token = yield 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=${btoa(JSON.stringify(this.config))}`);
+            }
+        });
+        this.oauthLogin = (oauthProvider, roles) => __awaiter(this, void 0, void 0, function* () {
+            if (!Object.values(OAuthProviders).includes(oauthProvider)) {
+                throw new Error(`only following oauth providers are supported: ${Object.values(oauthProvider).toString()}`);
+            }
+            if (!hasWindow()) {
+                throw new Error(`oauthLogin is only supported for browsers`);
+            }
+            window.location.replace(`${this.config.authorizerURL}/oauth_login/${oauthProvider}?redirectURL=${this.config.redirectURL || window.location.origin}${roles && roles.length ? `&roles=${roles.join(',')}` : ``}`);
+        });
+        this.logout = (headers) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this.graphqlQuery({
+                    query: ` mutation { logout { message } } `,
+                    headers,
+                });
+                return res.logout;
+            }
+            catch (err) {
+                console.log(`logout err:`, err);
+                console.error(err);
+            }
+        });
         if (!config) {
             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`);
         }
-    }
-    graphqlQuery = async (data) => {
-        const f = hasWindow() ? window.fetch : nodeFetch;
-        const res = await f(this.config.authorizerURL + '/graphql', {
-            method: 'POST',
-            body: JSON.stringify({
-                query: data.query,
-                variables: data.variables || {},
-            }),
-            headers: {
-                'Content-Type': 'application/json',
-                ...(data.headers || {}),
-            },
-            credentials: 'include',
-        });
-        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;
-    };
-    getMetaData = async () => {
-        try {
-            const res = await this.graphqlQuery({
-                query: `query { meta { version isGoogleLoginEnabled isGithubLoginEnabled isBasicAuthenticationEnabled isEmailVerificationEnabled isFacebookLoginEnabled isTwitterLoginEnabled } }`,
-            });
-            return res.meta;
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    getSession = async (headers) => {
-        try {
-            const res = await this.graphqlQuery({
-                query: `query {token { ${userTokenFragment} } }`,
-                headers,
-            });
-            return res.token;
-        }
-        catch (err) {
-            throw err;
-        }
-    };
-    signup = async (data) => {
-        try {
-            const res = await this.graphqlQuery({
-                query: `
-		mutation signup($data: SignUpInput!) { signup(params: $data) { ${userTokenFragment}}}`,
-                variables: { data },
-            });
-            return res.signup;
-        }
-        catch (err) {
-            console.error(err);
-        }
-    };
-    verifyEmail = async (data) => {
-        try {
-            const res = await this.graphqlQuery({
-                query: `
-		mutation verifyEmail($data: VerifyEmailInput!) { verifyEmail(params: $data) { ${userTokenFragment}}}`,
-                variables: { data },
-            });
-            return res.verifyEmail;
-        }
-        catch (err) {
-            console.error(err);
-        }
-    };
-    login = async (data) => {
-        try {
-            const res = await this.graphqlQuery({
-                query: `
-		mutation login($data: LoginInput!) { login(params: $data) { ${userTokenFragment}}}`,
-                variables: { data },
-            });
-            return res.login;
-        }
-        catch (err) {
-            console.error(err);
+        else {
+            this.config.redirectURL = trimURL(config.redirectURL);
         }
-    };
-    getProfile = async (headers) => {
-        try {
-            const profileRes = await this.graphqlQuery({
-                query: `query {	profile { id email image firstName lastName emailVerifiedAt signupMethod } }`,
-                headers,
-            });
-            return profileRes.profile;
-        }
-        catch (error) {
-            throw error;
-        }
-    };
-    updateProfile = async (data, headers) => {
-        try {
-            const updateProfileRes = await this.graphqlQuery({
-                query: `mutation updateProfile($data: UpdateProfileInput!) {	updateProfile(params: $data) { message } }`,
-                headers,
-                variables: {
-                    data,
-                },
-            });
-            return updateProfileRes.updateProfile;
-        }
-        catch (error) {
-            throw error;
-        }
-    };
-    forgotPassword = async (data) => {
-        try {
-            const forgotPasswordRes = await this.graphqlQuery({
-                query: `mutation forgotPassword($data: ForgotPasswordInput!) {	forgotPassword(params: $data) { message } }`,
-                variables: {
-                    data,
-                },
-            });
-            return forgotPasswordRes.forgotPassword;
-        }
-        catch (error) {
-            throw error;
-        }
-    };
-    resetPassword = async (data) => {
-        try {
-            const resetPasswordRes = await this.graphqlQuery({
-                query: `mutation resetPassword($data: ResetPasswordInput!) {	resetPassword(params: $data) { message } }`,
-                variables: {
-                    data,
-                },
-            });
-            return resetPasswordRes.resetPassword;
-        }
-        catch (error) {
-            throw error;
-        }
-    };
-    fingertipLogin = async () => {
-        try {
-            const token = await this.getSession();
-            return token;
-        }
-        catch (err) {
-            if (!hasWindow()) {
-                throw new Error(`fingertipLogin is only supported for browsers`);
-            }
-            window.location.href = `${this.config.authorizerURL}/app?state=${btoa(JSON.stringify(this.config))}`;
-        }
-    };
-    oauthLogin = async (oauthProvider) => {
-        if (!Object.values(OAuthProviders).includes(oauthProvider)) {
-            throw new Error(`only following oauth providers are supported: ${Object.values(oauthProvider).toString()}`);
-        }
-        if (!hasWindow()) {
-            throw new Error(`oauthLogin is only supported for browsers`);
-        }
-        window.location.href = `${this.config.authorizerURL}/oauth_login/${oauthProvider}`;
-    };
-    logout = async (headers) => {
-        try {
-            const res = await this.graphqlQuery({
-                query: ` mutation { logout { message } } `,
-                headers,
-            });
-            return res.logout;
-        }
-        catch (err) {
-            console.error(err);
-        }
-    };
+    }
 }
 
-export { Authorizer as default };
+export { Authorizer, OAuthProviders };
 //# sourceMappingURL=index.js.map