@thoughtspot/visual-embed-sdk 1.29.1-alpha.1 → 1.29.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thoughtspot/visual-embed-sdk",
-    "version": "1.29.1-alpha.1",
+    "version": "1.29.2",
     "description": "ThoughtSpot Embed SDK",
     "module": "lib/src/index.js",
     "main": "dist/tsembed.js",
@@ -175,6 +175,7 @@
     "keywords": [
         "thoughtspot",
         "everywhere",
+        "embedded",
         "embed",
         "sdk",
         "analytics"

package/src/auth.spec.ts

@@ -1,14 +1,12 @@
 import * as authInstance from './auth';
-import * as authTokenService from './authToken';
-import * as EmbedConfig from './embed/embedConfig';
-import * as mixPanelService from './mixpanel-service';
-import { executeAfterWait } from './test/test-utils';
-import { AuthType, EmbedEvent } from './types';
-import * as checkReleaseVersionInBetaInstance from './utils';
 import * as authService from './utils/authService/authService';
 import * as tokenAuthService from './utils/authService/tokenizedAuthService';
-import { logger } from './utils/logger';
-import * as SessionService from './utils/sessionInfoService';
+import * as checkReleaseVersionInBetaInstance from './utils';
+import * as mixPanelService from './mixpanel-service';
+import * as EmbedConfig from './embed/embedConfig';
+import { AuthType, EmbedEvent } from './types';
+import { executeAfterWait } from './test/test-utils';
+import { resetCachedAuthToken } from './authToken';
 
 const thoughtSpotHost = 'http://localhost:3000';
 const username = 'tsuser';
@@ -20,7 +18,7 @@ export const embedConfig: any = {
         thoughtSpotHost,
         username,
         authEndpoint: 'auth',
-        authType: AuthType.TrustedAuthToken,
+        authType: AuthType.AuthServer,
         getAuthToken: jest.fn(() => Promise.resolve(token)),
     }),
     doTokenAuthWithCookieDetect: {
@@ -114,47 +112,31 @@ export const mockSessionInfo = {
     },
 };
 
-export const mockSessionInfoApiResponse = {
-    userGUID: '1234',
-    releaseVersion: 'test',
-    configInfo: {
-        isPublicUser: false,
-        mixpanelConfig: {
-            production: true,
-            devSdkKey: 'devKey',
-            prodSdkKey: 'prodKey',
-        },
-    },
-};
-
 describe('Unit test for auth', () => {
     beforeEach(() => {
-        jest.resetAllMocks();
         global.fetch = window.fetch;
     });
     afterEach(() => {
-        authTokenService.resetCachedAuthToken();
-        SessionService.resetCachedSessionInfo();
+        resetCachedAuthToken();
     });
     test('endpoints, SAML_LOGIN_TEMPLATE', () => {
         const ssoTemplateUrl = authService.EndPoints.SAML_LOGIN_TEMPLATE(thoughtSpotHost);
         expect(ssoTemplateUrl).toBe(`/callosum/v1/saml/login?targetURLPath=${thoughtSpotHost}`);
     });
 
-    test('when session info giving response, it is cached', async () => {
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockResolvedValueOnce(mockSessionInfoApiResponse);
-        const sessionInfo = await SessionService.getSessionInfo();
-        expect(sessionInfo.mixpanelToken).toEqual('prodKey');
-        expect(sessionInfo.isPublicUser).toEqual(false);
-        await SessionService.getSessionInfo();
-        expect(tokenAuthService.fetchSessionInfoService).toHaveBeenCalledTimes(1);
+    test('when session info giving response', async () => {
+        jest.spyOn(mixPanelService, 'initMixpanel').mockImplementation(() => Promise.resolve());
+        authInstance.initSession(mockSessionInfo);
+        const sessionInfo = await authInstance.getSessionInfo();
+        expect(sessionInfo).toStrictEqual(mockSessionInfo);
     });
 
     test('Disable mixpanel when disableSDKTracking flag is set', () => {
+        jest.clearAllMocks();
+        jest.resetAllMocks();
         jest.spyOn(mixPanelService, 'initMixpanel');
-        jest.spyOn(SessionService, 'getSessionInfo').mockReturnValue(mockSessionInfo);
         jest.spyOn(EmbedConfig, 'getEmbedConfig').mockReturnValue({ disableSDKTracking: true });
-        authInstance.postLoginService();
+        authInstance.initSession(mockSessionInfo);
         expect(mixPanelService.initMixpanel).not.toBeCalled();
     });
 
@@ -181,22 +163,28 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is loggedIn', async () => {
-        const getAuthenticationTokenMock = jest.spyOn(authTokenService, 'getAuthenticationToken');
-        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => true);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(async () => ({
+            json: () => mockSessionInfo,
+            status: 200,
+        }));
+        jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
+        jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken'));
-        expect(authTokenService.getAuthenticationToken).not.toBeCalled();
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authInstance.loggedInStatus).toBe(true);
-        getAuthenticationTokenMock.mockRestore();
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken have response', async () => {
-        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
+            text: () => Promise.resolve('abc'),
+        }));
         jest.spyOn(authService, 'fetchAuthService').mockImplementation(() => Promise.resolve({
             status: 200,
-            ok: true,
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'));
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -205,25 +193,26 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken not present, isLoggedIn should called', async () => {
-        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
-        jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
-            text: () => Promise.resolve('abc'),
-        }));
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => Promise.resolve({ text: () => Promise.resolve('abc') }));
         jest.spyOn(authService, 'fetchAuthService').mockImplementation(() => Promise.resolve({
             status: 200,
             ok: true,
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthFailureWithoutGetAuthToken);
-        expect(authService.fetchAuthTokenService).toBeCalledWith('auth');
         await executeAfterWait(() => {
             expect(authInstance.loggedInStatus).toBe(true);
-            expect(authService.fetchAuthService).toBeCalledWith(thoughtSpotHost, username, 'abc');
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
+            expect(authService.fetchAuthService).toBeCalledWith(
+                thoughtSpotHost,
+                username,
+                'authToken2',
+            );
         });
     });
 
     test('doTokenAuth: Should raise error when duplicate token is used', async () => {
-        jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
         jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockResolvedValue({
             status: 401,
         });
@@ -265,10 +254,8 @@ describe('Unit test for auth', () => {
             ok: true,
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
-        jest.spyOn(tokenAuthService, 'isActiveService').mockResolvedValueOnce(false);
-        jest.spyOn(tokenAuthService, 'isActiveService').mockResolvedValueOnce(false);
         const isLoggedIn = await authInstance.doTokenAuth(embedConfig.doTokenAuthWithCookieDetect);
-        expect(tokenAuthService.isActiveService).toHaveBeenCalledTimes(2);
+        expect(tokenAuthService.fetchSessionInfoService).toHaveBeenCalledTimes(2);
         expect(isLoggedIn).toBe(false);
     });
 
@@ -291,6 +278,7 @@ describe('Unit test for auth', () => {
         expect(await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'))).toBe(
             true,
         );
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthPostService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -309,9 +297,20 @@ describe('Unit test for auth', () => {
         });
 
         it('when user is loggedIn', async () => {
-            jest.spyOn(tokenAuthService, 'isActiveService').mockResolvedValueOnce(true);
+            spyOn(checkReleaseVersionInBetaInstance, 'checkReleaseVersionInBeta');
+            jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
+            jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(
+                async () => ({
+                    json: () => mockSessionInfo,
+                    status: 200,
+                }),
+            );
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
+            expect(authInstance.getSessionDetails).toBeCalled();
+            expect(authInstance.initSession).toBeCalled();
         });
 
         it('when user is not loggedIn', async () => {
@@ -322,7 +321,7 @@ describe('Unit test for auth', () => {
             }));
 
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            // expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authService.fetchBasicAuthService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
         });
@@ -350,8 +349,10 @@ describe('Unit test for auth', () => {
                     status: 200,
                 }),
             );
-            jest.spyOn(tokenAuthService, 'isActiveService').mockReturnValue(true);
+            jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
+            jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(true);
         });
@@ -359,6 +360,7 @@ describe('Unit test for auth', () => {
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
             jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });
@@ -372,6 +374,7 @@ describe('Unit test for auth', () => {
             });
             jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(global.window.location.href).toBe(samalLoginUrl);
         });
 
@@ -384,9 +387,14 @@ describe('Unit test for auth', () => {
             });
             spyOn(authInstance, 'samlCompletionPromise');
             global.window.open = jest.fn();
-            jest.spyOn(tokenAuthService, 'isActiveService')
-                .mockReturnValueOnce(false)
-                .mockReturnValueOnce(true);
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService')
+                .mockImplementationOnce(() => Promise.reject())
+                .mockImplementationOnce(async () => ({
+                    json: () => mockSessionInfo,
+                    status: 200,
+                }));
+            jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
+            jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
             expect(await authInstance.samlCompletionPromise).not.toBe(null);
             expect(
                 await authInstance.doSamlAuth({
@@ -396,13 +404,15 @@ describe('Unit test for auth', () => {
             document.getElementById('ts-auth-btn').click();
             window.postMessage({ type: EmbedEvent.SAMLComplete }, '*');
             await authInstance.samlCompletionPromise;
-            expect(authInstance.loggedInStatus).toBe(true);
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
+            expect(authInstance.getSessionDetails).toBeCalled();
+            expect(authInstance.initSession).toBeCalled();
         });
     });
 
     describe('doOIDCAuth', () => {
         afterEach(() => {
-            authTokenService.resetCachedAuthToken();
+            resetCachedAuthToken();
             delete global.window;
             global.window = Object.create(originalWindow);
             global.window.open = jest.fn();
@@ -412,6 +422,7 @@ describe('Unit test for auth', () => {
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
             jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doOIDCAuth(embedConfig.doOidcAuth);
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });
@@ -454,7 +465,6 @@ describe('Unit test for auth', () => {
 
     it('authenticate: when authType is Basic', async () => {
         jest.spyOn(authInstance, 'doBasicAuth');
-        jest.spyOn(authService, 'fetchBasicAuthService').mockImplementation(() => Promise.resolve({ status: 200, ok: true }));
         await authInstance.authenticate(embedConfig.basicAuthSuccess);
         expect(authInstance.doBasicAuth).toBeCalled();
         expect(authInstance.loggedInStatus).toBe(true);
@@ -471,7 +481,6 @@ describe('Unit test for auth', () => {
     });
 
     it('doCookielessTokenAuth should resolve to true if valid token is passed', async () => {
-        jest.clearAllMocks();
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         const isLoggedIn = await authInstance.doCookielessTokenAuth(
             embedConfig.doCookielessAuth('testToken'),
@@ -491,11 +500,11 @@ describe('Unit test for auth', () => {
         authInstance.setAuthEE(testObject as any);
         expect(authInstance.getAuthEE()).toBe(testObject);
     });
-    it('getSessionDetails returns the correct details given sessionInfo', async () => {
+    it('getSessionDetails returns the correct details given sessionInfo', () => {
         jest.clearAllMocks();
         jest.restoreAllMocks();
 
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockReturnValue({
+        const details = authInstance.getSessionDetails({
             userGUID: '1234',
             releaseVersion: '1',
             configInfo: {
@@ -506,14 +515,13 @@ describe('Unit test for auth', () => {
                 },
             },
         });
-        const details = await SessionService.getSessionInfo();
         expect(details).toEqual(
             expect.objectContaining({
                 mixpanelToken: 'devKey',
             }),
         );
 
-        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockReturnValue({
+        const details2 = authInstance.getSessionDetails({
             configInfo: {
                 mixpanelConfig: {
                     devSdkKey: 'devKey',
@@ -522,38 +530,10 @@ describe('Unit test for auth', () => {
                 },
             },
         });
-
-        SessionService.resetCachedSessionInfo();
-        const details2 = await SessionService.getSessionInfo();
         expect(details2).toEqual(
             expect.objectContaining({
                 mixpanelToken: 'prodKey',
             }),
         );
     });
-
-    test('notifyAuthSuccess if getSessionInfo returns data', async () => {
-        const dummyInfo = { test: 'dummy' };
-        jest.spyOn(SessionService, 'getSessionInfo').mockResolvedValueOnce(dummyInfo);
-        jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
-        const emitSpy = jest.fn();
-        authInstance.setAuthEE({ emit: emitSpy } as any);
-        await authInstance.notifyAuthSuccess();
-        expect(logger.error).not.toBeCalled();
-        expect(emitSpy).toBeCalledWith(authInstance.AuthStatus.SUCCESS, dummyInfo);
-        authInstance.setAuthEE(null);
-    });
-
-    test('notifyAuthSuccess if getSessionInfo fails', async () => {
-        jest.spyOn(SessionService, 'getSessionInfo').mockImplementation(() => {
-            throw new Error('error');
-        });
-        jest.spyOn(logger, 'error');
-        const emitSpy = jest.fn();
-        authInstance.setAuthEE({ emit: emitSpy } as any);
-        await authInstance.notifyAuthSuccess();
-        expect(logger.error).toBeCalled();
-        expect(emitSpy).not.toBeCalled();
-        authInstance.setAuthEE(null);
-    });
 });

package/src/auth.ts

@@ -1,6 +1,5 @@
 import EventEmitter from 'eventemitter3';
 import { getAuthenticationToken, resetCachedAuthToken } from './authToken';
-import { getEmbedConfig } from './embed/embedConfig';
 import { initMixpanel } from './mixpanel-service';
 import {
     AuthType, DOMSelector, EmbedConfig, EmbedEvent,
@@ -12,10 +11,10 @@ import {
     fetchAuthService,
     fetchBasicAuthService,
     fetchLogoutService,
+    fetchSessionInfoService,
 } from './utils/authService';
-import { isActiveService } from './utils/authService/tokenizedAuthService';
 import { logger } from './utils/logger';
-import { getSessionInfo } from './utils/sessionInfoService';
+import { getEmbedConfig } from './embed/embedConfig';
 
 // eslint-disable-next-line import/no-mutable-exports
 export let loggedInStatus = false;
@@ -23,15 +22,25 @@ export let loggedInStatus = false;
 export let samlAuthWindow: Window = null;
 // eslint-disable-next-line import/no-mutable-exports
 export let samlCompletionPromise: Promise<void> = null;
-
+let sessionInfo: sessionInfoInterface = null;
+let sessionInfoResolver: (value: sessionInfoInterface) => void = null;
+const sessionInfoPromise = new Promise((resolve: (value: sessionInfoInterface) => void) => {
+    sessionInfoResolver = resolve;
+});
 let releaseVersion = '';
 
 export const SSO_REDIRECTION_MARKER_GUID = '5e16222e-ef02-43e9-9fbd-24226bf3ce5b';
 
+interface sessionInfoInterface {
+    userGUID: any;
+    isPublicUser: any;
+    mixpanelToken: any;
+    [key: string]: any;
+}
+
 /**
  * Enum for auth failure types. This is the parameter passed to the listner
  * of {@link AuthStatus.FAILURE}.
- *
  * @group Authentication / Init
  */
 export enum AuthFailureType {
@@ -43,7 +52,6 @@ export enum AuthFailureType {
 
 /**
  * Enum for auth status emitted by the emitter returned from {@link init}.
- *
  * @group Authentication / Init
  */
 export enum AuthStatus {
@@ -67,7 +75,6 @@ export enum AuthStatus {
      * Emitted when inPopup is true in the SAMLRedirect flow and the
      * popup is waiting to be triggered either programmatically
      * or by the trigger button.
-     *
      * @version SDK: 1.19.0
      */
     WAITING_FOR_POPUP = 'WAITING_FOR_POPUP',
@@ -75,20 +82,17 @@ export enum AuthStatus {
 
 /**
  * Event emitter returned from {@link init}.
- *
  * @group Authentication / Init
  */
 export interface AuthEventEmitter {
     /**
      * Register a listener on Auth failure.
-     *
      * @param event
      * @param listener
      */
     on(event: AuthStatus.FAILURE, listener: (failureType: AuthFailureType) => void): this;
     /**
      * Register a listener on Auth SDK success.
-     *
      * @param event
      * @param listener
      */
@@ -105,13 +109,11 @@ export interface AuthEventEmitter {
     once(event: AuthStatus.SUCCESS, listener: (sessionInfo: any) => void): this;
     /**
      * Trigger an event on the emitter returned from init.
-     *
      * @param {@link AuthEvent}
      */
     emit(event: AuthEvent, ...args: any[]): boolean;
     /**
      * Remove listener from the emitter returned from init.
-     *
      * @param event
      * @param listener
      * @param context
@@ -120,7 +122,6 @@ export interface AuthEventEmitter {
     off(event: AuthStatus, listener: (...args: any[]) => void, context: any, once: boolean): this;
     /**
      * Remove all the event listeners
-     *
      * @param event
      */
     removeAllListeners(event: AuthStatus): this;
@@ -128,7 +129,6 @@ export interface AuthEventEmitter {
 
 /**
  * Events which can be triggered on the emitter returned from {@link init}.
- *
  * @group Authentication / Init
  */
 export enum AuthEvent {
@@ -170,17 +170,12 @@ export function notifyAuthSDKSuccess(): void {
 /**
  *
  */
-export async function notifyAuthSuccess(): Promise<void> {
+export function notifyAuthSuccess(): void {
     if (!authEE) {
         logger.error('SDK not initialized');
         return;
     }
-    try {
-        const sessionInfo = await getSessionInfo();
-        authEE.emit(AuthStatus.SUCCESS, sessionInfo);
-    } catch (e) {
-        logger.error('Failed to get session info');
-    }
+    authEE.emit(AuthStatus.SUCCESS, sessionInfo);
 }
 
 /**
@@ -206,46 +201,68 @@ export function notifyLogout(): void {
     authEE.emit(AuthStatus.LOGOUT);
 }
 
+export const initSession = (sessionDetails: sessionInfoInterface) => {
+    const embedConfig = getEmbedConfig();
+    if (sessionInfo == null) {
+        sessionInfo = sessionDetails;
+        if (!embedConfig.disableSDKTracking) {
+            initMixpanel(sessionInfo);
+        }
+        sessionInfoResolver(sessionInfo);
+    }
+};
+
+export const getSessionDetails = (sessionInfoResp: any): sessionInfoInterface => {
+    const devMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.devSdkKey;
+    const prodMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.prodSdkKey;
+    const mixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.production
+        ? prodMixpanelToken
+        : devMixpanelToken;
+    return {
+        userGUID: sessionInfoResp.userGUID,
+        mixpanelToken,
+        isPublicUser: sessionInfoResp.configInfo.isPublicUser,
+        releaseVersion: sessionInfoResp.releaseVersion,
+        clusterId: sessionInfoResp.configInfo.selfClusterId,
+        clusterName: sessionInfoResp.configInfo.selfClusterName,
+        ...sessionInfoResp,
+    };
+};
+
 /**
  * Check if we are logged into the ThoughtSpot cluster
- *
  * @param thoughtSpotHost The ThoughtSpot cluster hostname or IP
  */
 async function isLoggedIn(thoughtSpotHost: string): Promise<boolean> {
+    const authVerificationUrl = `${thoughtSpotHost}${EndPoints.AUTH_VERIFICATION}`;
+    let response = null;
     try {
-        const response = await isActiveService(thoughtSpotHost);
-        return response;
+        response = await fetchSessionInfoService(authVerificationUrl);
+        const sessionInfoResp = await response.json();
+        const sessionDetails = getSessionDetails(sessionInfoResp);
+        // Store user session details from session info
+        initSession(sessionDetails);
+        releaseVersion = sessionInfoResp.releaseVersion;
     } catch (e) {
         return false;
     }
+    return response.status === 200;
 }
 
 /**
- * Services to be called after the login is successful,
- * This should be called after the cookie is set for cookie auth or
- * after the token is set for cookieless.
- *
- * @return {Promise<void>}
- * @example
- * ```js
- * await postLoginService();
- * ```
- * @version SDK: 1.28.3 | ThoughtSpot: *
+ * Return releaseVersion if available
  */
-export async function postLoginService(): Promise<void> {
-    const sessionInfo = await getSessionInfo();
-    releaseVersion = sessionInfo.releaseVersion;
-    const embedConfig = getEmbedConfig();
-    if (!embedConfig.disableSDKTracking) {
-        initMixpanel(sessionInfo);
-    }
+export function getReleaseVersion() {
+    return releaseVersion;
 }
 
 /**
- * Return releaseVersion if available
+ * Return a promise that resolves with the session information when
+ * authentication is successful. And info is available.
+ * @group Global methods
  */
-export function getReleaseVersion() {
-    return releaseVersion;
+export function getSessionInfo(): Promise<sessionInfoInterface> {
+    return sessionInfoPromise;
 }
 
 /**
@@ -269,7 +286,6 @@ function removeSSORedirectUrlMarker(): void {
 
 /**
  * Perform token based authentication
- *
  * @param embedConfig The embed configuration
  */
 export const doTokenAuth = async (embedConfig: EmbedConfig): Promise<boolean> => {
@@ -280,15 +296,8 @@ export const doTokenAuth = async (embedConfig: EmbedConfig): Promise<boolean> =>
         throw new Error('Either auth endpoint or getAuthToken function must be provided');
     }
     loggedInStatus = await isLoggedIn(thoughtSpotHost);
-
     if (!loggedInStatus) {
-        let authToken: string;
-        try {
-            authToken = await getAuthenticationToken(embedConfig);
-        } catch (e) {
-            loggedInStatus = false;
-            throw e;
-        }
+        const authToken = await getAuthenticationToken(embedConfig);
         let resp;
         try {
             resp = await fetchAuthPostService(thoughtSpotHost, username, authToken);
@@ -308,7 +317,6 @@ export const doTokenAuth = async (embedConfig: EmbedConfig): Promise<boolean> =>
 
 /**
  * Validate embedConfig parameters required for cookielessTokenAuth
- *
  * @param embedConfig The embed configuration
  */
 export const doCookielessTokenAuth = async (embedConfig: EmbedConfig): Promise<boolean> => {
@@ -335,7 +343,6 @@ export const doCookielessTokenAuth = async (embedConfig: EmbedConfig): Promise<b
  *
  * Warning: This feature is primarily intended for developer testing. It is
  * strongly advised not to use this authentication method in production.
- *
  * @param embedConfig The embed configuration
  */
 export const doBasicAuth = async (embedConfig: EmbedConfig): Promise<boolean> => {
@@ -395,7 +402,6 @@ async function samlPopupFlow(ssoURL: string, triggerContainer: DOMSelector, trig
 
 /**
  * Perform SAML authentication
- *
  * @param embedConfig The embed configuration
  * @param ssoEndPoint
  */
@@ -482,7 +488,6 @@ export const logout = async (embedConfig: EmbedConfig): Promise<boolean> => {
 
 /**
  * Perform authentication on the ThoughtSpot cluster
- *
  * @param embedConfig The embed configuration
  */
 export const authenticate = async (embedConfig: EmbedConfig): Promise<boolean> => {