@thoughtspot/visual-embed-sdk 1.26.0-token-cache.2 → 1.26.1-alpha.0

package/src/auth.spec.ts

@@ -1,5 +1,6 @@
 import * as authInstance from './auth';
-import * as authService from './utils/authService';
+import * as authService from './utils/authService/authService';
+import * as tokenAuthService from './utils/authService/tokenizedAuthService';
 import * as checkReleaseVersionInBetaInstance from './utils';
 import * as mixPanelService from './mixpanel-service';
 import { AuthType, EmbedEvent } from './types';
@@ -152,19 +153,19 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is loggedIn', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(async () => ({
+        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(authService.fetchSessionInfoService).toBeCalled();
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authInstance.loggedInStatus).toBe(true);
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken have response', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),
         }));
@@ -173,7 +174,7 @@ describe('Unit test for auth', () => {
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'));
-        expect(authService.fetchSessionInfoService).toBeCalled();
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -182,7 +183,7 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken not present, isLoggedIn should called', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => false);
+        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,
@@ -192,7 +193,7 @@ describe('Unit test for auth', () => {
         await authInstance.doTokenAuth(embedConfig.doTokenAuthFailureWithoutGetAuthToken);
         await executeAfterWait(() => {
             expect(authInstance.loggedInStatus).toBe(true);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authService.fetchAuthService).toBeCalledWith(
                 thoughtSpotHost,
                 username,
@@ -202,7 +203,7 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: Should raise error when duplicate token is used', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockResolvedValue({
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockResolvedValue({
             status: 401,
         });
         jest.spyOn(window, 'alert').mockClear();
@@ -230,7 +231,7 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: Should set loggedInStatus if detectThirdPartyCookieAccess is true and the second info call fails', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService')
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService')
             .mockResolvedValue({
                 status: 401,
             })
@@ -244,13 +245,13 @@ describe('Unit test for auth', () => {
         }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         const isLoggedIn = await authInstance.doTokenAuth(embedConfig.doTokenAuthWithCookieDetect);
-        expect(authService.fetchSessionInfoService).toHaveBeenCalledTimes(2);
+        expect(tokenAuthService.fetchSessionInfoService).toHaveBeenCalledTimes(2);
         expect(isLoggedIn).toBe(false);
     });
 
     test('doTokenAuth: when user is not loggedIn & fetchAuthPostService failed than fetchAuthService should call', async () => {
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),
         }));
@@ -267,7 +268,7 @@ describe('Unit test for auth', () => {
         expect(await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'))).toBe(
             true,
         );
-        expect(authService.fetchSessionInfoService).toBeCalled();
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthPostService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -289,26 +290,28 @@ describe('Unit test for auth', () => {
             spyOn(checkReleaseVersionInBetaInstance, 'checkReleaseVersionInBeta');
             jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
             jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(async () => ({
-                json: () => mockSessionInfo,
-                status: 200,
-            }));
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(
+                async () => ({
+                    json: () => mockSessionInfo,
+                    status: 200,
+                }),
+            );
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
             expect(authInstance.getSessionDetails).toBeCalled();
             expect(authInstance.initSession).toBeCalled();
         });
 
         it('when user is not loggedIn', async () => {
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             jest.spyOn(authService, 'fetchBasicAuthService').mockImplementation(() => ({
                 status: 200,
                 ok: true,
             }));
 
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authService.fetchBasicAuthService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
         });
@@ -330,22 +333,24 @@ describe('Unit test for auth', () => {
                     hash: '',
                 },
             });
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(async () => ({
-                json: () => mockSessionInfo,
-                status: 200,
-            }));
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(
+                async () => ({
+                    json: () => mockSessionInfo,
+                    status: 200,
+                }),
+            );
             jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
             jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(true);
         });
 
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });
@@ -357,9 +362,9 @@ describe('Unit test for auth', () => {
                     hash: '',
                 },
             });
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(global.window.location.href).toBe(samalLoginUrl);
         });
 
@@ -372,7 +377,7 @@ describe('Unit test for auth', () => {
             });
             spyOn(authInstance, 'samlCompletionPromise');
             global.window.open = jest.fn();
-            jest.spyOn(authService, 'fetchSessionInfoService')
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService')
                 .mockImplementationOnce(() => Promise.reject())
                 .mockImplementationOnce(async () => ({
                     json: () => mockSessionInfo,
@@ -389,7 +394,7 @@ describe('Unit test for auth', () => {
             document.getElementById('ts-auth-btn').click();
             window.postMessage({ type: EmbedEvent.SAMLComplete }, '*');
             await authInstance.samlCompletionPromise;
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authInstance.getSessionDetails).toBeCalled();
             expect(authInstance.initSession).toBeCalled();
         });
@@ -405,9 +410,9 @@ describe('Unit test for auth', () => {
         });
 
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doOIDCAuth(embedConfig.doOidcAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });

package/src/auth.ts

@@ -203,7 +203,6 @@ export const initSession = (sessionDetails: sessionInfoInterface) => {
 };
 
 export const getSessionDetails = (sessionInfoResp: any): sessionInfoInterface => {
-    console.log('helloooo');
     const devMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.devSdkKey;
     const prodMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.prodSdkKey;
     const mixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.production
@@ -319,14 +318,17 @@ export const doCookielessTokenAuth = async (embedConfig: EmbedConfig): Promise<b
     if (!authEndpoint && !getAuthToken) {
         throw new Error('Either auth endpoint or getAuthToken function must be provided');
     }
+    let authSuccess = false;
     try {
         const authToken = await getAuthenticationToken(embedConfig);
-        if (authToken) return true;
+        if (authToken) {
+            authSuccess = true;
+        }
     } catch {
-        // return false if getAuthenticationToken fails
+        authSuccess = false;
     }
 
-    return false;
+    return authSuccess;
 };
 
 /**

package/src/authToken.ts

@@ -1,5 +1,5 @@
 import { EmbedConfig } from './types';
-import { fetchAuthTokenService, verifyTokenService } from './utils/authService';
+import { fetchAuthTokenService, verifyTokenService } from './utils/authService/authService';
 
 const DUPLICATE_TOKEN_ERR = 'Duplicate token, please issue a new token every time getAuthToken callback is called.'
     + 'See https://developers.thoughtspot.com/docs/?pageid=embed-auth#trusted-auth-embed for more details.';
@@ -11,16 +11,14 @@ let cachedAuthToken: string | null = null;
 // This method can be used to get the authToken using the embedConfig
 export const getAuthenticationToken = async (embedConfig: EmbedConfig): Promise<string> => {
     if (cachedAuthToken) {
+        let isCachedTokenStillValid;
         try {
-            const isCachedTokenStillValid = await validateAuthToken(
-                embedConfig,
-                cachedAuthToken,
-                true,
-            );
-            if (isCachedTokenStillValid) return cachedAuthToken;
+            isCachedTokenStillValid = await validateAuthToken(embedConfig, cachedAuthToken, true);
         } catch {
-            // Continue to get a new token if validation fails
+            isCachedTokenStillValid = false;
         }
+
+        if (isCachedTokenStillValid) return cachedAuthToken;
     }
 
     const { authEndpoint, getAuthToken } = embedConfig;

package/src/types.ts

@@ -533,12 +533,14 @@ export interface EmbedConfig {
 
     /**
      * If passed as true all alerts will be suppressed in the embedded app.
+     *
+     * @version SDK: 1.26.1 | ThoughtSpot: *
      */
     suppressErrorAlerts?: boolean;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface LayoutConfig { }
+export interface LayoutConfig {}
 
 /**
  * Embedded iFrame configuration
@@ -3216,40 +3218,44 @@ export enum ContextMenuTriggerOptions {
 
 export interface ColumnValue {
     column: {
-        id: string,
-        name: string,
-        dataType: string,
-        [key: string]: any
-    },
-    value: string | number | boolean | {
-        v: {
-            s: number;
-            e: number;
-        }
+        id: string;
+        name: string;
+        dataType: string;
+        [key: string]: any;
     };
+    value:
+        | string
+        | number
+        | boolean
+        | {
+              v: {
+                  s: number;
+                  e: number;
+              };
+          };
 }
 
 export interface VizPoint {
-    selectedAttributes: ColumnValue[],
-    selectedMeasures: ColumnValue[]
+    selectedAttributes: ColumnValue[];
+    selectedMeasures: ColumnValue[];
 }
 
 export interface CustomActionPayload {
     contextMenuPoints?: {
-        clickedPoint: VizPoint
-        selectedPoints: VizPoint[]
+        clickedPoint: VizPoint;
+        selectedPoints: VizPoint[];
     };
     embedAnswerData: {
-        name: string,
-        id: string,
+        name: string;
+        id: string;
         sources: {
             header: {
-                guid: string
-            }
-        },
-        columns: any[],
-        data: any[],
-        [key: string]: any
+                guid: string;
+            };
+        };
+        columns: any[];
+        data: any[];
+        [key: string]: any;
     };
     session: SessionInterface;
     vizId?: string;

package/src/utils/authService/index.ts

@@ -6,4 +6,4 @@ export {
     fetchBasicAuthService,
     verifyTokenService,
 } from './authService';
-export { fetchLogoutService, fetchSessionInfoService } from './tokenisedAuthSerice';
+export { fetchLogoutService, fetchSessionInfoService } from './tokenizedAuthService';