@thoughtspot/visual-embed-sdk 1.31.1 → 1.32.0-alpha.1

package/src/embed/embed.spec.ts

@@ -9,6 +9,7 @@ import {
     getIFrameEl,
     getRootEl,
 } from '../test/test-utils';
+import * as authInstance from '../auth';
 
 const thoughtSpotHost = 'tshost';
 const defaultViewConfig = {
@@ -24,6 +25,7 @@ beforeAll(() => {
         authType: AuthType.None,
     });
     spyOn(window, 'alert');
+    jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
 });
 
 describe('test view config', () => {

package/src/embed/events.spec.ts

@@ -20,6 +20,7 @@ import {
     postMessageToParent,
 } from '../test/test-utils';
 import { LiveboardViewConfig } from './liveboard';
+import * as authInstance from '../auth';
 
 const thoughtSpotHost = 'tshost';
 const defaultViewConfig = {
@@ -36,6 +37,7 @@ beforeAll(() => {
         authType: AuthType.None,
     });
     spyOn(window, 'alert');
+    jest.spyOn(authInstance, 'postLoginService').mockReturnValue(true);
 });
 
 describe('test communication between host app and ThoughtSpot', () => {

package/src/embed/liveboard.spec.ts

@@ -23,6 +23,7 @@ import {
 } from '../test/test-utils';
 import * as tsEmbed from './ts-embed';
 import * as processTriggerInstance from '../utils/processTrigger';
+import * as auth from '../auth';
 
 const defaultViewConfig = {
     frameParams: {
@@ -43,6 +44,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
 });
 
 describe('Liveboard/viz embed tests', () => {

package/src/embed/pinboard.spec.ts

@@ -13,6 +13,7 @@ import {
     expectUrlMatchesWithParams,
 } from '../test/test-utils';
 import { version } from '../../package.json';
+import * as auth from '../auth';
 
 const defaultViewConfig = {
     frameParams: {
@@ -30,6 +31,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(auth, 'postLoginService').mockReturnValue(true);
 });
 
 describe('Pinboard/viz embed tests', () => {

package/src/embed/sage.spec.ts

@@ -9,6 +9,8 @@ import {
     getRootEl,
 } from '../test/test-utils';
 
+import * as authInstance from '../auth';
+
 const defaultConfig: SageViewConfig = {
     disableWorksheetChange: false,
     hideWorksheetSelector: false,
@@ -26,6 +28,7 @@ beforeAll(() => {
         authType: AuthType.None,
     });
     spyOn(window, 'alert');
+    jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
 });
 
 describe('Sage  embed tests', () => {

package/src/embed/search.spec.ts

@@ -36,6 +36,7 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(authInstance, 'postLoginService').mockImplementation(() => Promise.resolve({}));
     spyOn(window, 'alert');
 });
 

package/src/embed/ts-embed-trigger.spec.ts

@@ -8,9 +8,12 @@ import {
     getRootEl,
 } from '../test/test-utils';
 
+import * as authInstance from '../auth';
+
 describe('Trigger', () => {
     beforeEach(() => {
         document.body.innerHTML = getDocumentBody();
+        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
     });
     test('should trigger the event', async (done) => {
         init({

package/src/embed/ts-embed.spec.ts

@@ -84,6 +84,10 @@ describe('Unit test case for ts embed', () => {
         resetCachedAuthToken();
     });
 
+    beforeAll(() => {
+        jest.spyOn(authInstance, 'postLoginService').mockResolvedValue(true);
+    });
+
     describe('AuthExpire embedEvent in cookieless authentication authType', () => {
         beforeAll(() => {
             jest.spyOn(authInstance, 'doCookielessTokenAuth').mockResolvedValueOnce(true);
@@ -730,6 +734,7 @@ describe('Unit test case for ts embed', () => {
             const mockPort: any = {
                 postMessage: jest.fn(),
             };
+            const loggerSpy = jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
             await executeAfterWait(() => {
                 const iframe = getIFrameEl();
                 postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
@@ -739,6 +744,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.notifyAuthFailure).toBeCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
+                expect(loggerSpy).toHaveBeenCalledTimes(1);
             });
 
             jest.spyOn(authService, 'verifyTokenService').mockClear();
@@ -757,6 +763,7 @@ describe('Unit test case for ts embed', () => {
             const searchEmbed = new SearchEmbed(getRootEl(), { ...defaultViewConfig, preRenderId: 'test' });
             jest.spyOn(baseInstance, 'notifyAuthFailure');
             searchEmbed.preRender();
+            const loggerSpy = jest.spyOn(logger, 'error').mockResolvedValueOnce(true);
             const mockPort: any = {
                 postMessage: jest.fn(),
             };
@@ -770,6 +777,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.notifyAuthFailure).toBeCalledWith(
                     authInstance.AuthFailureType.EXPIRY,
                 );
+                expect(loggerSpy).toHaveBeenCalledTimes(1);
             });
 
             jest.spyOn(authService, 'verifyTokenService').mockClear();

package/src/embed/ts-embed.ts

@@ -347,6 +347,7 @@ export class TsEmbed {
                     data: { authToken },
                 });
             } catch (e) {
+                logger.error(`Received invalid token. Error : ${e?.message}`);
                 processAuthFailure(e, this.isPreRendered ? this.preRenderWrapper : this.el);
             }
         } else if (autoLogin) {

package/src/index.ts

@@ -20,8 +20,9 @@ import { PinboardEmbed, LiveboardViewConfig, LiveboardEmbed } from './embed/live
 import { SearchEmbed, SearchViewConfig } from './embed/search';
 import { SearchBarEmbed, SearchBarViewConfig } from './embed/search-bar';
 import {
-    AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter, getSessionInfo,
+    AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter,
 } from './auth';
+import { getSessionInfo } from './utils/sessionInfoService';
 import {
     AuthType,
     RuntimeFilter,

package/src/mixpanel-service.spec.ts

@@ -6,6 +6,8 @@ import {
     testResetMixpanel,
 } from './mixpanel-service';
 import { AuthType } from './types';
+import { SessionInfo } from './utils/sessionInfoService';
+import { logger } from './utils/logger';
 
 const config = {
     thoughtSpotHost: 'https://10.87.89.232',
@@ -29,7 +31,7 @@ describe('Unit test for mixpanel', () => {
             mixpanelToken: 'abc123',
             userGUID: '12345',
             isPublicUser: false,
-        };
+        } as SessionInfo;
         initMixpanel(sessionInfo);
         expect(mixpanel.init).toHaveBeenCalledWith(sessionInfo.mixpanelToken, undefined, 'tsEmbed');
         expect(mixpanel.identify).toHaveBeenCalledWith(sessionInfo.userGUID);
@@ -49,7 +51,7 @@ describe('Unit test for mixpanel', () => {
             clusterId: 'newClusterId',
             clusterName: 'newClusterName',
             releaseVersion: 'newReleaseVersion',
-        };
+        } as SessionInfo;
         initMixpanel(sessionInfo);
 
         expect(mixpanel.init).toHaveBeenCalledWith(sessionInfo.mixpanelToken, undefined, 'tsEmbed');
@@ -74,8 +76,15 @@ describe('Unit test for mixpanel', () => {
             mixpanelToken: 'abc123',
             userGUID: '12345',
             isPublicUser: false,
-        };
+        } as SessionInfo;
         initMixpanel(sessionInfo);
         expect(mixpanel.track).toHaveBeenCalledTimes(2);
     });
+
+    test('init mixpanel with no mixpanel token', () => {
+        jest.spyOn(logger, 'error').mockReturnValueOnce(true);
+        initMixpanel({ test: 'dummy' } as any);
+        expect(logger.error).toHaveBeenCalled();
+        expect(mixpanel.register_once).not.toHaveBeenCalled();
+    });
 });

package/src/mixpanel-service.ts

@@ -1,5 +1,6 @@
 import * as mixpanel from 'mixpanel-browser';
 import { logger } from './utils/logger';
+import { SessionInfo } from './utils/sessionInfoService';
 
 export const EndPoints = {
     CONFIG: '/callosum/v1/system/config',
@@ -54,8 +55,9 @@ function emptyQueue() {
  *
  * @param sessionInfo
  */
-export function initMixpanel(sessionInfo: any): void {
+export function initMixpanel(sessionInfo: SessionInfo): void {
     if (!sessionInfo || !sessionInfo.mixpanelToken) {
+        logger.error('Mixpanel token not found in session info');
         return;
     }
     // On a public cluster the user is anonymous, so don't set the identify to

package/src/react/index.spec.tsx

@@ -24,6 +24,9 @@ import {
 
 import { version } from '../../package.json';
 
+import * as auth from '../auth';
+import * as sessionService from '../utils/sessionInfoService';
+
 const thoughtSpotHost = 'localhost';
 
 beforeAll(() => {
@@ -31,6 +34,10 @@ beforeAll(() => {
         thoughtSpotHost,
         authType: AuthType.None,
     });
+    jest.spyOn(auth, 'postLoginService').mockReturnValue(true);
+    jest.spyOn(sessionService, 'getSessionInfo').mockReturnValue({
+        userGUID: 'abcd',
+    });
     spyOn(window, 'alert');
 });
 

package/src/react/index.tsx

@@ -370,4 +370,5 @@ export {
     HomeLeftNavItem,
     HomepageModule,
     LogLevel,
+    getSessionInfo,
 } from '../index';

package/src/tokenizedFetch.ts

@@ -6,8 +6,16 @@ import { AuthType } from './types';
 /**
  * Fetch wrapper that adds the authentication token to the request.
  * Use this to call the ThoughtSpot APIs when using the visual embed sdk.
+ * The interface for this method is the same as Web `Fetch`.
+ *
  * @param input
  * @param init
+ * @example
+ * ```js
+ * tokenizedFetch("<TS_ORIGIN>/api/rest/2.0/auth/session/user", {
+ *   // .. fetch options ..
+ * });
+ *```
  * @version SDK: 1.28.0
  * @group Global methods
  */

package/src/types.ts

@@ -2105,13 +2105,12 @@ export enum EmbedEvent {
       * Emitted when parameter changes in an answer
       * or liveboard
       *
-      * @version SDK : 1.29.0 | Thoughtspot : 10.2.0.cl
-      * @example
       * ```js
       * liveboardEmbed.on(EmbedEvent.ParameterChanged, (payload) => {
       *     console.log('payload', payload);
       * })
       *```
+      * @version SDK : 1.29.0 | Thoughtspot : 10.2.0.cl
       */
      ParameterChanged = 'parameterChanged'
 }
@@ -2333,7 +2332,7 @@ export enum HostEvent {
      * sorting, toggling of legends, and data drill down.
      * @example
      * ```js
-     * liveboardEmbed.trigger(HostEvent.getexportrequestforcurrentpinboard).then(
+     * liveboardEmbed.trigger(HostEvent.getExportRequestForCurrentPinboard).then(
      * data=>console.log(data))
      * ```
      * @version SDK: 1.13.0 | ThoughtSpot: 8.5.0.cl, 8.8.1.sw
@@ -2943,15 +2942,6 @@ export enum HostEvent {
      * @version SDK: 1.29.0 | Thoughtspot: 10.1.0.cl
      */
     ResetLiveboardPersonalisedView = 'ResetLiveboardPersonalisedView',
-    /**
-     * Trigger CreateLiveboard for liveboard list page & Pin Modal
-     * @example
-     * ```js
-     * liveboardEmbed.trigger(HostEvent.CreateLiveboard);
-     *
-     * @version SDK: 1.29.0 | Thoughtspot: 10.1.0.cl
-     */
-    CreateLiveboard = 'CreateLiveboard',
     /**
      * Triggers Update RuntimeParameters for answers and liveboard
      * @example
@@ -3947,6 +3937,17 @@ export enum Action {
      */
     TML = 'tml',
 
+    /**
+     * Action Id for CreateLiveboard for liveboard list page & Pin Modal
+     * @example
+     * ```js
+     * hiddenAction: [Action.CreateLiveboard]
+     * disabledActions: [Action.CreateLiveboard]
+     *
+     * @version SDK: 1.31.1 | Thoughtspot: 10.1.0.cl
+     */
+    CreateLiveboard = 'CreateLiveboard',
+
     /**
      * Action ID for to hide Verified Liveboard Banner
      *  @example

package/src/utils/authService/authService.spec.ts

@@ -26,9 +26,10 @@ describe('Unit test for authService', () => {
             status: 200,
             ok: true,
         }));
-        const response = await fetchSessionInfoService(authVerificationUrl);
-        expect(response.status).toBe(200);
+        const response = await fetchSessionInfoService(thoughtSpotHost);
+        expect(response.success).toBe(true);
         expect(fetch).toHaveBeenCalledTimes(1);
+        expect(fetch).toBeCalledWith(`${thoughtSpotHost}${EndPoints.SESSION_INFO}`, {});
     });
 
     test('fetchAuthTokenService', async () => {
@@ -108,11 +109,15 @@ describe('Unit test for authService', () => {
             status: 500,
             ok: false,
         }));
-        await fetchSessionInfoService(authVerificationUrl);
-        expect(logger.error).toHaveBeenCalledWith('Failure', 'error');
+        try {
+            await fetchSessionInfoService(authVerificationUrl);
+        } catch (e) {
+            expect(e.message).toContain('Failed to fetch session info');
+        }
+        expect(logger.error).toHaveBeenCalledWith('Failed to fetch http://localhost:3000/callosum/v1/session/info', 'error');
     });
 
-    test('verifyTokenService', async () => {
+    test('verifyTokenService if token api works', async () => {
         global.fetch = jest.fn(() => Promise.resolve({ success: true, ok: true }));
         await verifyTokenService(thoughtSpotHost, authToken);
         expect(fetch).toBeCalledWith(`${thoughtSpotHost}${EndPoints.IS_ACTIVE}`, {
@@ -123,4 +128,12 @@ describe('Unit test for authService', () => {
             },
         });
     });
+
+    test('verifyTokenService if token api fails', async () => {
+        global.fetch = jest.fn(() => Promise.reject(new Error('error')));
+        jest.spyOn(logger, 'warn');
+        const status = await verifyTokenService(thoughtSpotHost, authToken);
+        expect(status).toBe(false);
+        expect(logger.warn).toHaveBeenCalledWith('Token Verification Service failed : error');
+    });
 });

package/src/utils/authService/authService.ts

@@ -2,6 +2,7 @@ import { logger } from '../logger';
 
 export const EndPoints = {
     AUTH_VERIFICATION: '/callosum/v1/session/info',
+    SESSION_INFO: '/callosum/v1/session/info',
     SAML_LOGIN_TEMPLATE: (targetUrl: string) => `/callosum/v1/saml/login?targetURLPath=${targetUrl}`,
     OIDC_LOGIN_TEMPLATE: (targetUrl: string) => `/callosum/v1/oidc/login?targetURLPath=${targetUrl}`,
     TOKEN_LOGIN: '/callosum/v1/session/login/token',

package/src/utils/authService/tokenizedAuthService.spec.ts

@@ -0,0 +1,36 @@
+import * as tokenizedFetchModule from '../../tokenizedFetch';
+import { isActiveService } from './tokenizedAuthService';
+import { logger } from '../logger';
+
+describe('tokenizedAuthService', () => {
+    test('isActiveService is fetch returns ok', async () => {
+        jest.spyOn(tokenizedFetchModule, 'tokenizedFetch').mockResolvedValueOnce({
+            ok: true,
+        });
+
+        const isActiveResp = await isActiveService('http://thoughtspotHost');
+
+        expect(isActiveResp).toEqual(true);
+    });
+    test('isActiveService if fetch returns not ok', async () => {
+        jest.spyOn(tokenizedFetchModule, 'tokenizedFetch').mockResolvedValueOnce({
+            ok: false,
+        });
+
+        const isActiveResp = await isActiveService('http://thoughtspotHost');
+
+        expect(isActiveResp).toEqual(false);
+    });
+
+    test('isActiveService if fetch fails', async () => {
+        jest.spyOn(tokenizedFetchModule, 'tokenizedFetch').mockRejectedValueOnce({
+            ok: false,
+        });
+        jest.spyOn(logger, 'warn');
+
+        const isActiveResp = await isActiveService('http://thoughtspotHost');
+
+        expect(isActiveResp).toEqual(false);
+        expect(logger.warn).toHaveBeenCalled();
+    });
+});

package/src/utils/authService/tokenizedAuthService.ts

@@ -7,23 +7,33 @@ import { EndPoints } from './authService';
  * @param url
  * @param options
  */
-function tokenisedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
+function tokenizedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
     return tokenizedFetch(url, options).then(async (r) => {
         if (!r.ok && r.type !== 'opaqueredirect' && r.type !== 'opaque') {
-            logger.error('Failure', await r.text?.());
+            logger.error(`Failed to fetch ${url}`, await r.text?.());
         }
         return r;
     });
 }
 
 /**
+ * Fetches the session info from the ThoughtSpot server.
  *
- * @param authVerificationUrl
+ * @param thoughtspotHost
+ * @returns {Promise<any>}
+ * @example
+ * ```js
+ *  const response = await sessionInfoService();
+ * ```
  */
-export function fetchSessionInfoService(authVerificationUrl: string): Promise<any> {
-    return tokenisedFailureLoggedFetch(authVerificationUrl, {
-        credentials: 'include',
-    });
+export async function fetchSessionInfoService(thoughtspotHost: string): Promise<any> {
+    const sessionInfoPath = `${thoughtspotHost}${EndPoints.SESSION_INFO}`;
+    const response = await tokenizedFailureLoggedFetch(sessionInfoPath);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch session info: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
 }
 
 /**
@@ -31,7 +41,7 @@ export function fetchSessionInfoService(authVerificationUrl: string): Promise<an
  * @param thoughtSpotHost
  */
 export async function fetchLogoutService(thoughtSpotHost: string): Promise<any> {
-    return tokenisedFailureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
+    return tokenizedFailureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
         credentials: 'include',
         method: 'POST',
         headers: {
@@ -39,3 +49,23 @@ export async function fetchLogoutService(thoughtSpotHost: string): Promise<any>
         },
     });
 }
+
+/**
+ * Is active service to check if the user is logged in.
+ *
+ * @param thoughtSpotHost
+ * @version SDK: 1.28.4 | ThoughtSpot: *
+ */
+export async function isActiveService(thoughtSpotHost: string): Promise<boolean> {
+    const isActiveUrl = `${thoughtSpotHost}${EndPoints.IS_ACTIVE}`;
+    try {
+        const res = await tokenizedFetch(isActiveUrl, {
+            credentials: 'include',
+        });
+        return res.ok;
+    } catch (e) {
+        logger.warn(`Is Logged In Service failed : ${e.message}`);
+    }
+
+    return false;
+}

package/src/utils/processData.spec.ts

@@ -4,9 +4,11 @@ import * as auth from '../auth';
 import * as base from '../embed/base';
 import * as embedConfigInstance from '../embed/embedConfig';
 import { EmbedEvent, AuthType } from '../types';
+import * as sessionInfoService from './sessionInfoService';
 
 describe('Unit test for process data', () => {
     beforeAll(() => {
+        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
         base.init({
             thoughtSpotHost: 'https://tshost',
             authType: AuthType.None,
@@ -58,15 +60,14 @@ describe('Unit test for process data', () => {
             isPublicUser: false,
         };
         const e = { type: EmbedEvent.AuthInit, data: sessionInfo };
-        jest.spyOn(auth, 'initSession').mockReturnValue(null);
         jest.spyOn(base, 'notifyAuthSuccess');
+        jest.spyOn(sessionInfoService, 'getSessionInfo').mockReturnValue(sessionInfo);
         expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
             type: e.type,
             data: {
                 userGUID: sessionInfo.userGUID,
             },
         });
-        expect(auth.initSession).toBeCalledWith(sessionInfo);
         expect(base.notifyAuthSuccess).toBeCalled();
     });
 

package/src/utils/processData.ts

@@ -5,7 +5,7 @@ import {
     notifyAuthSuccess,
     notifyLogout,
 } from '../embed/base';
-import { AuthFailureType, initSession } from '../auth';
+import { AuthFailureType } from '../auth';
 import { AuthType, CustomActionPayload, EmbedEvent } from '../types';
 import { AnswerService } from './graphql/answerService/answerService';
 import { resetCachedAuthToken } from '../authToken';
@@ -30,12 +30,12 @@ export function processCustomAction(e: any, thoughtSpotHost: string) {
 }
 
 /**
+ * Responds to AuthInit sent from host signifying successful authentication in host.
  *
  * @param e
+ * @returns {any}
  */
 function processAuthInit(e: any) {
-    // Store user session details sent by app.
-    initSession(e.data);
     notifyAuthSuccess();
 
     // Expose only allowed details (eg: userGUID) back to SDK users.

package/src/utils/sessionInfoService.ts

@@ -0,0 +1,101 @@
+import { getEmbedConfig } from '../embed/embedConfig';
+import { fetchSessionInfoService } from './authService';
+
+export type SessionInfo = {
+    releaseVersion: string;
+    userGUID: string;
+    currentOrgId: number;
+    privileges: string[];
+    mixpanelToken: string;
+    isPublicUser: boolean;
+    clusterId: string;
+    clusterName: string;
+    [key: string]: any;
+};
+
+let sessionInfo: null | SessionInfo = null;
+
+/**
+ * Returns the session info object and caches it for future use.
+ * Once fetched the session info object is cached and returned from the cache on
+ * subsequent calls.
+ *
+ * @example ```js
+ * const sessionInfo = await getSessionInfo();
+ * console.log(sessionInfo);
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ * @returns {Promise<SessionInfo>} The session info object.
+ */
+export async function getSessionInfo(): Promise<SessionInfo> {
+    if (!sessionInfo) {
+        const host = getEmbedConfig().thoughtSpotHost;
+        const sessionResponse = await fetchSessionInfoService(host);
+        const processedSessionInfo = getSessionDetails(sessionResponse);
+        sessionInfo = processedSessionInfo;
+    }
+    return sessionInfo;
+}
+
+/**
+ * Returns the cached session info object. If the client is not authenticated the
+ * function will return null.
+ *
+ * @example ```js
+ * const sessionInfo = getCachedSessionInfo();
+ * if (sessionInfo) {
+ *   console.log(sessionInfo);
+ * } else {
+ *   console.log('Not authenticated');
+ * }
+ * ```
+ * @returns {SessionInfo | null} The session info object.
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ */
+export function getCachedSessionInfo(): SessionInfo | null {
+    return sessionInfo;
+}
+
+/**
+ * Processes the session info response and returns the session info object.
+ *
+ *  @param sessionInfoResp {any} Response from the session info API.
+ *  @returns {SessionInfo} The session info object.
+ *  @example ```js
+ *  const sessionInfoResp = await fetch(sessionInfoPath);
+ *  const sessionInfo = getSessionDetails(sessionInfoResp);
+ *  console.log(sessionInfo);
+ *  ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ */
+export const getSessionDetails = (sessionInfoResp: any): SessionInfo => {
+    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,
+    };
+};
+
+/**
+ * Resets the cached session info object and forces a new fetch on the next call.
+ *
+ * @example ```js
+ * resetCachedSessionInfo();
+ * const sessionInfo = await getSessionInfo();
+ * console.log(sessionInfo);
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot ts7.april.cl, 7.2.1
+ * @returns {void}
+ */
+export function resetCachedSessionInfo(): void {
+    sessionInfo = null;
+}