@qikdev/sdk 0.1.169 → 0.1.180

package/src/api/qik.auth.js

@@ -0,0 +1,938 @@
+import axios from 'axios';
+import { EventDispatcher } from './qik.utils.js';
+
+///////////////////////////////////////////////////
+
+/**
+ * Creates a new instance of QikAuth a module of the SDK
+ * that contains all helper functions to do with authentication and user session management
+ * @alias auth
+ * @constructor
+ * @hideconstructor
+ * @param {QikAPI} qik A reference to the parent instance of the QikCore module. This module is usually created by a QikCore instance that passes itself in as the first argument.
+ */
+
+var QikAuth = function(qik) {
+
+    if (!qik.api) {
+        throw new Error(`Please ensure that QikAPI exists before QikAuth`);
+    }
+
+    //Keep track of any refresh requests
+    var inflightRefreshRequest;
+
+    ///////////////////////////////////////////////////
+
+    var sessionStorage = {};
+    var store = sessionStorage;
+    const tokenBufferSeconds = 10;
+
+    ///////////////////////////////////////////////////
+
+    const service = {
+        debug: false,
+    }
+
+    Object.defineProperty(service, 'store', {
+        value: store,
+        writable: false,
+    });
+
+    //Create a new dispatcher
+    const dispatcher = new EventDispatcher();
+    dispatcher.bootstrap(service);
+
+    ///////////////////////////////////////////////////
+
+    function dispatch(parameters) {
+
+        //Get the current user
+        var user = store.user;
+
+        //Dispatch the change to the listeners
+        if (service.onChange) {
+            service.onChange(user);
+        }
+
+        //Dispatch the change event
+        dispatcher.dispatch('change', user, parameters);
+    }
+
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.set
+     * @description Manually set current user session
+     * @param  {Object} user The user session object to set as the current user session
+     * @param  {Object} parameters Additional parameters to dispatch
+     * @param  {Boolean} stopDispatch Whether to supress dispatching a 'change' event.
+     * @example
+     * 
+     * const userSession = {_id:'61eca4746971e75c1fc670cf', firstName:'Daffy', lastName:'Duck' ...};
+     * sdk.auth.set(userSession);
+     */
+
+    service.set = function(user, parameters, stopDispatch) {
+
+        if (JSON.stringify(store.user) != JSON.stringify(user)) {
+            store.user = user;
+            if (!stopDispatch) {
+                return dispatch(parameters)
+            }
+        }
+
+    }
+
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.logout
+     * @description Clear the current user session from memory and erase all caches
+     * @example
+     * sdk.auth.logout();
+     */
+
+    service.logout = function() {
+        delete store.user;
+        qik.cache.reset();
+        return dispatch()
+    }
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.changeOrganisation
+     * @description Manually set current user session
+     * @param  {(String|Object)} organisation The id of the organisation to switch into
+     * @param  {Object} options Additional options
+     * @param  {Boolean} options.disableAutoAuthentication By default when switching organisation, the current user session
+     * will be updated to reflect a session in the new organisation, you can use this option to disable that behavior and instead return the 
+     * user session without dispatching any events
+     * @example
+     *
+     * sdk.auth.changeOrganisation('61eca4746971e75c1fc670cf');
+     * // Current user session will be automatically updated
+     *
+     * const newSession = await sdk.auth.changeOrganisation('61eca4746971e75c1fc670cf', {disableAutoAuthentication:true});
+     * // Current user session will not be updated
+     * sdk.auth.set(newSession);
+     */
+    service.changeOrganisation = function(organisationID, options) {
+
+        //Ensure we just have the ID
+        organisationID = qik.utils.id(organisationID);
+
+        //////////////////////////
+
+        if (!options) {
+            options = {};
+        }
+
+        //////////////////////////
+
+        //Change the users current tokens straight away
+        var autoAuthenticate = true;
+
+        if (options.disableAutoAuthentication) {
+            autoAuthenticate = false;
+        }
+
+        //////////////////////////
+
+        return new Promise(function(resolve, reject) {
+
+
+            qik.api.post(`/user/switch/${organisationID}`)
+                .then(function(response) {
+
+                    if (autoAuthenticate) {
+                        qik.cache.reset();
+                        service.set(response.data);
+                    }
+
+                    resolve(response.data);
+                })
+                .catch(reject)
+
+        })
+    }
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.impersonate
+     * @description Impersonate another user within your organisation
+     * @param  {(String|Object)} persona The id of the user persona you want to impersonate
+     * @param  {Object} options Additional options
+     * @param  {Boolean} options.disableAutoAuthentication By default when impersonating a user, the current user session
+     * will be updated automatically to reflect the new session, you can use this option to disable that behavior and instead return the 
+     * new impersonation user session without dispatching any events
+     * @example
+     *
+     * sdk.auth.impersonate('61eca4746971e75c1fc670cf');
+     * // Current user session will be automatically updated
+     *
+     * const newSession = await sdk.auth.impersonate('61eca4746971e75c1fc670cf', {disableAutoAuthentication:true});
+     * // Current user session will not be updated
+     * sdk.auth.set(newSession);
+     */
+    service.impersonate = function(personaID, options) {
+
+        //Ensure we just have the ID
+        personaID = qik.utils.id(personaID);
+
+        //////////////////////////
+
+        if (!options) {
+            options = {};
+        }
+
+        //////////////////////////
+
+        //Change the users current tokens straight away
+        var autoAuthenticate = true;
+
+        if (options.disableAutoAuthentication) {
+            autoAuthenticate = false;
+        }
+
+        //////////////////////////
+
+        var promise = qik.api.post(`/user/impersonate/${personaID}`)
+
+        promise.then(function(res) {
+
+            if (autoAuthenticate) {
+                qik.cache.reset();
+                service.set(res.data);
+            }
+        }, function(err) {});
+
+
+        return promise;
+
+    }
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.login
+     * @description Login and authenticate as a user
+     * @param  {Object} credentials The credentials used to login
+     * @param  {String} credentials.email The email address to login to
+     * @param  {String} credentials.password The password to login with
+     * @param  {String} credentials.mfa The MFA (Multi Factor Authentication) code
+     * @param  {Object} options Additional options
+     * @param  {Boolean} options.disableAutoAuthentication By default when logging in the current user session
+     * will be updated automatically to reflect the new session, you can use this option to disable that behavior and instead return the 
+     * session that was logged in to without dispatching any events
+     * @example
+     *
+     * const credentials = {
+     *     email:'me@email.com', 
+     *     password:'******',
+     *     mfa:'1234',
+     * }
+     * 
+     * sdk.auth.login(credentials);
+     * // Current user session will be automatically updated
+     *
+     * const newSession = await sdk.auth.login(credentials, {disableAutoAuthentication:true});
+     * // Current user session will not be updated
+     * sdk.auth.set(newSession);
+     */
+    service.login = async function(credentials, options) {
+
+        if (!options) {
+            options = {};
+        }
+
+        //////////////////////////
+
+        //Change the users current tokens straight away
+        var autoAuthenticate = true;
+
+        if (options.disableAutoAuthentication) {
+            autoAuthenticate = false;
+        }
+
+        //////////////////////////////////////
+
+        var promise = new Promise(loginCheck)
+
+        function loginCheck(resolve, reject) {
+
+            if (!credentials) {
+                return reject({
+                    message: 'Missing credentials!',
+                })
+            }
+
+            if (!credentials.email || !credentials.email.length) {
+                return reject({
+                    message: 'Username was not provided',
+                })
+            }
+
+            if (!credentials.password || !credentials.password.length) {
+                return reject({
+                    message: 'Password was not provided',
+                })
+            }
+
+            /////////////////////////////////////////////
+
+            var postOptions = {
+                bypassInterceptor: true
+            }
+
+            /////////////////////////////////////////////
+
+            var url = `${qik.apiURL}/user/login`;
+
+            /////////////////////////////////////////////
+
+            //If we have a specified url
+            if (options.url) {
+                url = options.url;
+            }
+
+            /////////////////////////////////////////////
+
+            qik.api.post(url, credentials, postOptions).then(function(res) {
+
+                if (autoAuthenticate) {
+                    service.set(res.data);
+
+                }
+
+                resolve(res);
+            }, reject);
+        }
+
+        //////////////////////////////////////
+
+        return promise;
+
+    }
+
+    ///////////////////////////////////////////////////
+
+    service.signup = async function(credentials, options) {
+
+        if (!options) {
+            options = {};
+        }
+
+
+        //////////////////////////
+
+        //Change the users current tokens straight away
+        var autoAuthenticate = true;
+
+        if (options.disableAutoAuthentication) {
+            autoAuthenticate = false;
+        }
+
+        //////////////////////////////////////
+
+        var promise = new Promise(signupCheck)
+
+        function signupCheck(resolve, reject) {
+
+            if (!credentials) {
+                return reject({
+                    message: 'No details provided',
+                })
+            }
+
+            if (!credentials.firstName || !credentials.firstName.length) {
+                return reject({
+                    message: 'First Name was not provided',
+                })
+            }
+
+            if (!credentials.lastName || !credentials.lastName.length) {
+                return reject({
+                    message: 'Last Name was not provided',
+                })
+            }
+
+            if (!credentials.email || !credentials.email.length) {
+                return reject({
+                    message: 'Email/Username was not provided',
+                })
+            }
+
+
+            if (!credentials.password || !credentials.password.length) {
+                return reject({
+                    message: 'Password was not provided',
+                })
+            }
+
+            if (!credentials.confirmPassword || !credentials.confirmPassword.length) {
+                return reject({
+                    message: 'Confirm Password was not provided',
+                })
+            }
+
+            if (credentials.confirmPassword != credentials.password) {
+                return reject({
+                    message: 'Your passwords do not match',
+                })
+            }
+
+            /////////////////////////////////////////////
+
+            var postOptions = {
+                bypassInterceptor: true
+            }
+
+            /////////////////////////////////////////////
+
+            var url = `${qik.apiURL}/user/signup`;
+
+            /////////////////////////////////////////////
+
+            //If we are authenticating as an application
+            if (options.application) {
+
+                //The url is relative to the domain
+                url = `${qik.domain || ''}/qik/application/signup`;
+            }
+
+            //If we have a specified url
+            if (options.url) {
+                url = options.url;
+            }
+
+            /////////////////////////////////////////////
+
+            qik.api.post(url, credentials, postOptions).then(function(res) {
+
+                if (autoAuthenticate) {
+                    service.set(res.data);
+                }
+
+                resolve(res);
+            }, reject);
+        }
+
+        //////////////////////////////////////
+
+        return promise;
+
+    }
+
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.retrieveUserFromResetToken
+     * @description Retrieve user session through use of a valid reset token, 
+     * Reset tokens are short lived tokens that can be generated when a user has forgotten their password or their
+     * password has been reset by an administrator
+     * @param  {String} resetToken The token to use to authenticate
+     * @param  {Object} options Additional options for the request
+     * @example
+     *
+     * const resetToken = 'XXX-324623-$$...';
+     *
+     * // Retrieve the user session by providing a reset token
+     * const user = await sdk.auth.retrieveUserFromResetToken(resetToken);
+     */
+    service.retrieveUserFromResetToken = async function(resetToken, options) {
+
+        if (!options) {
+            options = {};
+        }
+
+        var postOptions = {
+                bypassInterceptor: true
+            }
+
+        return new Promise(function(resolve, reject) {
+            qik.api.get(options.url || `${qik.apiURL}/user/reset/${resetToken}`, postOptions).then(function(res) {
+                return resolve(res.data);
+            }, reject);
+        });
+
+    }
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.updateUserWithToken
+     * @description Update a user's credentials through use of a reset token
+     * @param  {String} resetToken The token to use to authenticate
+     * @param  {Object} body Updates to be made to the user
+     * @param  {Object} options Additional options for the request
+     * @param  {Boolean} options.disableAutoAuthentication By default the current user session
+     * will be updated automatically to reflect the new updated session, you can use this option to disable that behavior 
+     * and instead return the result without dispatching any events
+     * @example
+     *
+     * const resetToken = 'XXX-324623-$$...';
+     *
+     * // Retrieve the user session by providing a reset token
+     * const user = await sdk.auth.retrieveUserFromResetToken(resetToken);
+     */
+    service.updateUserWithToken = async function(resetToken, body, options) {
+
+        if (!options) {
+            options = {};
+        }
+
+        //////////////////////////
+
+        //Change the users current tokens straight away
+        var autoAuthenticate = true;
+
+        if (options.disableAutoAuthentication) {
+            autoAuthenticate = false;
+        }
+
+        //////////////////////////////////////
+
+        return new Promise(function(resolve, reject) {
+
+            var postOptions = {
+                bypassInterceptor: true
+            }
+
+            qik.api.post(options.url || `${qik.apiURL}/user/reset/${resetToken}`, body, postOptions)
+            .then(function(res) {
+
+                //If we should automatically authenticate
+                //once the request is successful
+                //Then clear caches and update the session
+                if (autoAuthenticate) {
+                    qik.cache.reset();
+                    service.set(res.data);
+                }
+
+                return resolve(res.data);
+            }, reject);
+        });
+
+    }
+
+    /**
+     * @alias auth.sendResetPasswordRequest
+     * @description This function allows a reset token to be generated and emailed to the requesting user
+     * allowing them to modify their user details
+     * @param  {Object} body Details for the reset request
+     * @param  {String} body.email The email of the user to generate a token for
+     * @example
+     *
+     * const resetToken = 'XXX-324623-$$...';
+     *
+     * // Retrieve the user session by providing a reset token
+     * const user = await sdk.auth.retrieveUserFromResetToken(resetToken);
+     */
+    service.sendResetPasswordRequest = function(details, options) {
+
+        if (!options) {
+            options = {};
+        }
+
+        if (!details) {
+            return Promise.reject({
+                message: 'No details were provided for password reset request',
+            })
+        }
+
+        if (!details.email || !details.email.length) {
+            return Promise.reject({
+                message: 'Email is required but was not provided',
+            })
+        }
+
+        return new Promise(function(resolve, reject) {
+
+            var postOptions = {
+                bypassInterceptor: true
+            }
+
+            qik.api.post(options.url || `${qik.apiURL}/user/forgot`, details, postOptions).then(resolve, reject);
+        })
+    }
+
+
+    ///////////////////////////////////////////////////
+
+    /**
+     * @alias auth.ensureValidToken
+     * @description This function forces a check to ensure that the current access token has not expired.
+     * If the token has expired, the user session will be refreshed with a new token.
+     * @param  {Boolean} forceRefresh Whether to force the current token to be refreshed, even if it has not yet expired.
+     * @example
+     *
+     * // Check to ensure that the current access token is valid
+     * sdk.auth.ensureValidToken();
+     *
+     * // Force the token to be refreshed, even if the current token in use has not yet expired.
+     * sdk.auth.ensureValidToken(true);
+     */
+    service.ensureValidToken = async function(forceRefresh) {
+
+        var currentUser = service.getCurrentUser();
+        if (!currentUser) {
+
+            return Promise.reject('No user');
+        }
+
+        var { token } = currentUser;
+        if (!token) {
+
+            return Promise.reject('No token');
+        }
+
+        /////////////////////////////////////////////////////
+
+        //Check our date
+        var now = new Date();
+
+        //Give us a bit of buffer so that the backend doesn't beat us to
+        //retiring the token
+        now.setSeconds(now.getSeconds() + tokenBufferSeconds);
+
+        /////////////////////////////////////////////////////
+
+        var expires = new Date(token.expires);
+
+        if (forceRefresh) {
+            console.log('force refresh valid token', token.refreshToken)
+            return await service.refreshAccessToken(token.refreshToken);
+        }
+
+        //If the token is still fresh
+        if (now < expires) {
+
+            return token;
+        } else {
+
+            return await service.refreshAccessToken(token.refreshToken);
+        }
+
+
+    }
+
+    ///////////////////////////////////////////////////
+
+    const refreshContext = {};
+
+    service.refreshAccessToken = async function(refreshToken) {
+
+        // /////////////////////////////////////////////
+
+        // if (appContext) {
+
+        // } else {
+
+        // }
+
+        // /////////////////////////////////////////////
+
+        //If there is already a request in progress
+        if (refreshContext.inflightRefreshRequest) {
+
+            return refreshContext.inflightRefreshRequest;
+        }
+
+        /////////////////////////////////////////////////////
+
+        //Create an refresh request
+
+        refreshContext.inflightRefreshRequest = new Promise(function(resolve, reject) {
+
+            //Bypass the interceptor on all token refresh calls
+            //Because we don't need to add the access token etc onto it
+
+            qik.api.post(`/user/refresh`, {
+                    refreshToken: refreshToken
+                }, {
+                    bypassInterceptor: true,
+                    withoutToken: true,
+                })
+                .then(function tokenRefreshComplete(res) {
+
+                    //Update the user with any changes 
+                    //returned back from the refresh request
+                    if (!res) {
+
+                        refreshContext.inflightRefreshRequest = null;
+                        return reject();
+
+                    } else {
+                        //Update with our new session
+                        service.set(res.data);
+
+
+                        dispatch();
+                    }
+
+                    //Resolve with the new token
+                    resolve(res.data.token);
+
+                    //Remove the inflight request
+                    setTimeout(function() {
+                        refreshContext.inflightRefreshRequest = null;
+                    })
+
+
+                })
+                .catch(function(err) {
+
+
+                    //TODO Check if invalid_refresh_token
+
+
+
+                    setTimeout(function() {
+                        refreshContext.inflightRefreshRequest = null;
+                    });
+                    reject(err);
+
+
+
+                });
+        });
+
+        //Return the refresh request
+        return refreshContext.inflightRefreshRequest;
+    }
+
+    ///////////////////////////////////////////////////
+
+    var retryCount = 0;
+
+    /**
+     * @alias auth.sync
+     * @description A useful function to sync the current user session with the server.
+     * @example
+     *
+     * // Makes request to the API and updates the current user session to match the response
+     * sdk.auth.sync();
+     */
+    service.sync = function() {
+
+        return qik.api.get('/user')
+            .then(function(res) {
+
+
+                if (res.data) {
+                    if (store.user) {
+                        Object.assign(store.user.session, res.data);
+                    }
+                } else {
+                    service.set(null);
+                }
+
+
+                retryCount = 0;
+
+                dispatch();
+            })
+            .catch(function(err) {
+
+                // if (retryCount > 2) {
+                service.set(null);
+                retryCount = 0;
+                dispatch();
+                // } else {
+
+                // retryCount++;
+                // service.sync();
+                // }
+
+
+            });
+    }
+
+    /////////////////////////////////////////////////////
+
+    /**
+     * @alias auth.getCurrentUser
+     * @description Retrieves the current user session
+     * @example
+     *
+     * const me = sdk.auth.getCurrentUser();
+     */
+    service.getCurrentUser = function() {
+        return store.user;
+    }
+
+
+    /**
+     * @alias auth.getCurrentToken
+     * @description Retrieves the current access token. If the user is authenticated
+     * the response will be the current user's access token, otherwise will fall back to the 
+     * applications token.
+     * @example
+     * const currentAccessToken = sdk.auth.getCurrentToken();
+     */
+    service.getCurrentToken = function() {
+
+
+        var user = service.getCurrentUser();
+
+        //User is not logged in
+        if (!user) {
+
+            //But there is an application token
+            if (qik.applicationToken) {
+                //use that instead
+                return qik.applicationToken;
+            }
+
+            //No token
+            return;
+        }
+
+        var { token } = user;
+        if (!token) {
+            return;
+        }
+
+        return token.accessToken;
+
+    }
+
+    /////////////////////////////////////////////////////
+
+    qik.api.interceptors.request.use(async function(config) {
+
+            //If we want to bypass the interceptor
+            //then just return the request
+            if (config.bypassInterceptor) {
+                return config;
+            }
+
+            //////////////////////////////
+
+            //Get the original request
+            var originalRequest = config;
+
+            //////////////////////////////
+
+            var userDetails = await service.getCurrentUser();
+            var accessToken;
+            var refreshToken;
+            var expiryDate;
+
+            if (userDetails) {
+                var { token } = userDetails;
+                if (token) {
+                    accessToken = token.accessToken;
+                    refreshToken = token.refreshToken;
+                    expiryDate = token.expires;
+                }
+            }
+
+            //////////////////////////////
+
+            //If there is a user token
+            if (accessToken) {
+                //Set the token of the request as the user's access token
+                originalRequest.headers['Authorization'] = `Bearer ${accessToken}`;
+
+
+            } else {
+                //Return the original request without a token
+
+                return originalRequest;
+            }
+
+            /////////////////////////////////////////////////////
+
+            //If no refresh token
+            if (!refreshToken) {
+
+
+                //Continue with the original request
+                return originalRequest;
+            }
+
+            /////////////////////////////////////////////////////
+
+            //We have a refresh token so we need to check
+            //whether our access token is stale and needs to be refreshed
+            var now = new Date();
+
+            //Give us a bit of buffer so that the backend doesn't beat us to
+            //retiring the token
+            now.setSeconds(now.getSeconds() + tokenBufferSeconds);
+
+            /////////////////////////////////////////////////////
+
+            var expires = new Date(expiryDate);
+
+            //If the token is still fresh
+            if (now < expires) {
+                //Return the original request
+                return originalRequest;
+            }
+
+            /////////////////////////////////////////////////////
+
+            return new Promise(async function(resolve, reject) {
+
+                //Refresh the token
+                await service.refreshAccessToken(refreshToken)
+                    .then(function(newToken) {
+
+                        //Update the original request with our new token
+                        originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
+                        //And continue onward
+                        return resolve(originalRequest);
+                    })
+                    .catch(function(err) {
+
+                        return reject(err);
+                    });
+            });
+
+
+        },
+        function(error) {
+            return Promise.reject(error);
+        })
+
+
+
+    /////////////////////////////////////////////////////
+
+    qik.api.interceptors.response.use(function(response) {
+        return response;
+    }, function(err) {
+
+        //////////////////////////////
+
+        //Get the response status
+        var status = (err && err.response && err.response.status) || err.status;
+
+
+        switch (status) {
+            case 401:
+                service.logout();
+                break;
+            default:
+                //Some other error
+                break;
+        }
+
+        /////////////////////////////////////////////////////
+
+        return Promise.reject(err);
+    })
+
+    return service;
+
+}
+
+
+export default QikAuth;