@thoughtspot/visual-embed-sdk 1.45.0 → 1.45.2

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

@@ -15,6 +15,8 @@ import {
     SageViewConfig,
     SearchViewConfig,
     AnswerService,
+    SpotterEmbed,
+    SpotterEmbedViewConfig,
 } from '../index';
 import {
     Action,
@@ -31,6 +33,7 @@ import {
     DefaultAppInitData,
     ErrorDetailsTypes,
     EmbedErrorCodes,
+    ContextObject,
 } from '../types';
 import {
     executeAfterWait,
@@ -64,6 +67,7 @@ import { UIPassthroughEvent } from './hostEventClient/contracts';
 import * as sessionInfoService from '../utils/sessionInfoService';
 import * as authToken from '../authToken';
 import * as apiIntercept from '../api-intercept';
+import * as processData from '../utils/processData';
 
 jest.mock('../utils/processTrigger');
 
@@ -204,6 +208,7 @@ describe('Unit test case for ts embed', () => {
                         parameters: payload,
                         type: UIPassthroughEvent.PinAnswerToLiveboard,
                     },
+                    undefined,
                 );
             });
         });
@@ -224,6 +229,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.Save,
                     'http://tshost',
                     {},
+                    undefined,
                 );
             });
         });
@@ -245,6 +251,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.Save,
                     'http://tshost',
                     false,
+                    undefined,
                 );
             });
         });
@@ -1332,6 +1339,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1468,6 +1476,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1482,6 +1491,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1496,6 +1506,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -1510,6 +1521,7 @@ describe('Unit test case for ts embed', () => {
                     HostEvent.InfoSuccess,
                     'http://tshost',
                     expect.objectContaining({ info: expect.any(Object) }),
+                    undefined,
                 );
             });
         });
@@ -2800,7 +2812,7 @@ describe('Unit test case for ts embed', () => {
             jest.clearAllMocks();
             document.body.innerHTML = getDocumentBody();
             mockPort.postMessage.mockClear();
-            jest.spyOn(authToken, 'getAuthenticationToken').mockResolvedValue('test-token');
+            jest.spyOn(authToken, 'getAuthenticationToken').mockResolvedValue('mock-test-token-placeholder');
 
             jest.spyOn(baseInstance, 'handleAuth').mockImplementation(() => Promise.resolve(true));
             jest.spyOn(baseInstance, 'notifyAuthFailure').mockImplementation(() => { });
@@ -2829,7 +2841,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.handleAuth).toHaveBeenCalledTimes(1);
                 expect(mockPort.postMessage).toHaveBeenCalledWith({
                     type: EmbedEvent.AuthExpire,
-                    data: { authToken: 'test-token' },
+                    data: { authToken: 'mock-test-token-placeholder' },
                 });
             });
         });
@@ -2864,7 +2876,7 @@ describe('Unit test case for ts embed', () => {
                 expect(baseInstance.handleAuth).toHaveBeenCalledTimes(1);
                 expect(mockPort.postMessage).toHaveBeenCalledWith({
                     type: EmbedEvent.AuthExpire,
-                    data: { authToken: 'test-token' },
+                    data: { authToken: 'mock-test-token-placeholder' },
                 });
             });
         });
@@ -2921,6 +2933,113 @@ describe('Unit test case for ts embed', () => {
         });
     });
 
+    describe('AutoLogin behavior in tokenRefresh', () => {
+        const mockPort = { postMessage: jest.fn() };
+        const mockEmbedEventPayload = { type: EmbedEvent.RefreshAuthToken, data: {} };
+
+        beforeEach(() => {
+            jest.clearAllMocks();
+            document.body.innerHTML = getDocumentBody();
+            mockPort.postMessage.mockClear();
+            jest.spyOn(authToken, 'getAuthenticationToken').mockResolvedValue('mock-test-token-placeholder');
+            jest.spyOn(processData, 'processAuthFailure').mockImplementation(() => ({} as any));
+            jest.spyOn(logger, 'error').mockImplementation(() => {});
+        });
+
+        const renderAndTriggerRefreshAuthToken = async () => {
+            const spotterEmbed = new SpotterEmbed(getRootEl(), {
+                worksheetId: 'test-worksheet',
+                searchOptions: {
+                    searchQuery: 'test query',
+                },
+            } as SpotterEmbedViewConfig);
+            await spotterEmbed.render();
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+        };
+
+        test('Cookieless with autoLogin undefined should default to true and refresh token', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                // autoLogin undefined
+            });
+
+            await renderAndTriggerRefreshAuthToken();
+
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).toHaveBeenCalledWith(
+                    expect.any(Object),
+                    true
+                );
+            });
+        });
+
+        test('Cookieless with autoLogin true should refresh token', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                autoLogin: true,
+            });
+
+            await renderAndTriggerRefreshAuthToken();
+
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).toHaveBeenCalledWith(
+                    expect.any(Object),
+                    true
+                );
+            });
+        });
+
+        test('Cookieless with autoLogin false should not refresh token', async () => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                autoLogin: false,
+            });
+
+            await renderAndTriggerRefreshAuthToken();
+
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).not.toHaveBeenCalled();
+                expect(mockPort.postMessage).not.toHaveBeenCalled();
+            });
+        });
+
+        test('Should handle error when getAuthenticationToken fails', async () => {
+            const error = new Error('Token fetch failed');
+            jest.spyOn(authToken, 'getAuthenticationToken').mockRejectedValue(error);
+
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                autoLogin: true,
+            });
+
+            await renderAndTriggerRefreshAuthToken();
+
+            await executeAfterWait(() => {
+                expect(authToken.getAuthenticationToken).toHaveBeenCalledWith(
+                    expect.any(Object),
+                    true
+                );
+                // Check that logger.error was called with the token refresh error
+                const errorCalls = (logger.error as jest.Mock).mock.calls.filter(
+                    (call) => call[0]?.includes(ERROR_MESSAGE.INVALID_TOKEN_ERROR) && call[0]?.includes('Token fetch failed')
+                );
+                expect(errorCalls.length).toBeGreaterThan(0);
+                expect(processData.processAuthFailure).toHaveBeenCalledWith(
+                    error,
+                    expect.any(Element)
+                );
+                expect(mockPort.postMessage).not.toHaveBeenCalled();
+            });
+        });
+    });
+
     describe('Fullscreen Change Handler', () => {
         beforeEach(() => {
             document.body.innerHTML = getDocumentBody();
@@ -3159,6 +3278,59 @@ describe('Unit test case for ts embed', () => {
             expect(callback3).toHaveBeenCalledTimes(1);
         });
 
+        describe('getCurrentContext', () => {
+            const mockContext: ContextObject = {
+                stack: [
+                    {
+                        name: 'Liveboard',
+                        type: 'Liveboard' as any,
+                        objectIds: { liveboardId: 'lb-123' },
+                    },
+                ],
+                currentContext: {
+                    name: 'Liveboard',
+                    type: 'Liveboard' as any,
+                    objectIds: { liveboardId: 'lb-123' },
+                },
+            };
+
+            test('should return context when embed container is already loaded', async () => {
+                const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+                searchEmbed.isEmbedContainerLoaded = true;
+
+                const triggerSpy = jest.spyOn(searchEmbed, 'trigger')
+                    .mockResolvedValue(mockContext);
+
+                const context = await searchEmbed.getCurrentContext();
+
+                expect(context).toEqual(mockContext);
+                expect(triggerSpy).toHaveBeenCalledWith(HostEvent.GetPageContext, {});
+            });
+
+            test('should wait for embed container to load before returning context', async () => {
+                const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+                searchEmbed.isEmbedContainerLoaded = false;
+
+                const triggerSpy = jest.spyOn(searchEmbed, 'trigger')
+                    .mockResolvedValue(mockContext);
+
+                const contextPromise = searchEmbed.getCurrentContext();
+
+                // Context should not be resolved yet
+                await executeAfterWait(() => {
+                    expect(triggerSpy).not.toHaveBeenCalled();
+                }, 10);
+
+                // Simulate embed container becoming ready
+                searchEmbed['executeEmbedContainerReadyCallbacks']();
+
+                const context = await contextPromise;
+
+                expect(context).toEqual(mockContext);
+                expect(triggerSpy).toHaveBeenCalledWith(HostEvent.GetPageContext, {});
+            });
+        });
+
         test('should register embed container event handlers during construction', () => {
             const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
 
@@ -4056,7 +4228,7 @@ describe('Destroy error handling', () => {
         }).not.toThrow();
         
         expect(logSpy).toHaveBeenCalledWith('Error destroying TS Embed', expect.any(Error));
-        logSpy.mockRestore();
+        logSpy.mockReset();
     });
 });
 
@@ -4099,11 +4271,12 @@ describe('Fullscreen change handler behavior', () => {
         document.dispatchEvent(event);
         
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
                 expect.any(Object),
                 HostEvent.ExitPresentMode,
                 expect.any(String),
                 expect.any(Object),
+                undefined,
             );
         });
     });
@@ -4196,13 +4369,14 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         embed2.showPreRender();
 
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
                 expect.any(Object),
                 HostEvent.UpdateEmbedParams,
                 expect.any(String),
                 expect.objectContaining({
                     liveboardId: 'updated-lb',
                 }),
+                undefined,
             );
         });
     });
@@ -4231,7 +4405,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         embed2.showPreRender();
 
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
                 expect.any(Object),
                 HostEvent.UpdateEmbedParams,
                 expect.any(String),
@@ -4251,6 +4425,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
                         },
                     ],
                 }),
+                undefined,
             );
         });
     });
@@ -4283,7 +4458,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         embed2.showPreRender();
 
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
+            expect(mockProcessTrigger).toHaveBeenLastCalledWith(
                 expect.any(Object),
                 HostEvent.UpdateEmbedParams,
                 expect.any(String),
@@ -4298,6 +4473,7 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
                         },
                     ],
                 }),
+                undefined,
             );
         });
     });

package/src/embed/ts-embed.ts

@@ -60,6 +60,9 @@ import {
     EmbedErrorDetailsEvent,
     ErrorDetailsTypes,
     EmbedErrorCodes,
+    MessagePayload,
+    ContextType,
+    ContextObject,
 } from '../types';
 import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
 import { processEventData, processAuthFailure } from '../utils/processData';
@@ -75,6 +78,7 @@ import { ERROR_MESSAGE } from '../errors';
 import { getPreauthInfo } from '../utils/sessionInfoService';
 import { HostEventClient } from './hostEventClient/host-event-client';
 import { getInterceptInitData, handleInterceptEvent, processApiInterceptResponse, processLegacyInterceptResponse } from '../api-intercept';
+import { getHostEventsConfig } from '../utils';
 
 const { version } = pkgInfo;
 
@@ -479,7 +483,9 @@ export class TsEmbed {
                 this.embedConfig.customVariablesForThirdPartyTools || {},
             hiddenListColumns: this.viewConfig.hiddenListColumns || [],
             customActions: customActionsResult.actions,
+            embedExpiryInAuthToken: this.viewConfig.refreshAuthTokenOnNearExpiry,
             ...getInterceptInitData(this.viewConfig),
+            ...getHostEventsConfig(this.viewConfig),
         };
 
         return baseInitData;
@@ -507,29 +513,65 @@ export class TsEmbed {
         }
     };
 
+    /**
+     * Helper method to refresh/update auth token for TrustedAuthTokenCookieless auth type
+     * @param responder - Function to send response back
+     * @param eventType - The embed event type to send
+     * @param forceRefresh - Whether to force refresh the token
+     * @returns Promise that resolves if token was refreshed, rejects otherwise
+     */
+    private async refreshAuthTokenForCookieless(
+        responder: (data: any) => void,
+        eventType: EmbedEvent,
+        forceRefresh: boolean = false
+    ): Promise<void> {
+        const { authType, autoLogin } = this.embedConfig;
+        const isAutoLoginTrue = autoLogin ?? (authType === AuthType.TrustedAuthTokenCookieless);
+        
+        if (isAutoLoginTrue && authType === AuthType.TrustedAuthTokenCookieless) {
+            const authToken = await getAuthenticationToken(this.embedConfig, forceRefresh);
+            responder({
+                type: eventType,
+                data: { authToken },
+            });
+        }
+    }
+
+    private handleAuthFailure = (error: Error) => {
+        logger.error(`${ERROR_MESSAGE.INVALID_TOKEN_ERROR} Error : ${error?.message}`);
+        processAuthFailure(error, this.isPreRendered ? this.preRenderWrapper : this.el);
+    }
+
+    /**
+     * Refresh the auth token if the autoLogin is true and the authType is TrustedAuthTokenCookieless
+     * @param _
+     * @param responder
+     */
+    private tokenRefresh = async (_: MessagePayload, responder: (data: {type: EmbedEvent, data: {authToken: string}}) => void) => {
+        try {
+            await this.refreshAuthTokenForCookieless(responder, EmbedEvent.RefreshAuthToken, true);
+        } catch (e) {
+            this.handleAuthFailure(e);
+        }
+    }
+
     /**
      * Sends updated auth token to the iFrame to avoid user logout
      * @param _
      * @param responder
      */
-    private updateAuthToken = async (_: any, responder: any) => {
-        const { authType } = this.embedConfig;
-        let { autoLogin } = this.embedConfig;
-        // Default autoLogin: true for cookieless if undefined/null, otherwise
-        // false
-        autoLogin = autoLogin ?? (authType === AuthType.TrustedAuthTokenCookieless);
-        if (autoLogin && authType === AuthType.TrustedAuthTokenCookieless) {
-            try {
-                const authToken = await getAuthenticationToken(this.embedConfig);
-                responder({
-                    type: EmbedEvent.AuthExpire,
-                    data: { authToken },
-                });
-            } catch (e) {
-                logger.error(`${ERROR_MESSAGE.INVALID_TOKEN_ERROR} Error : ${e?.message}`);
-                processAuthFailure(e, this.isPreRendered ? this.preRenderWrapper : this.el);
-            }
-        } else if (autoLogin) {
+    private updateAuthToken = async (_: MessagePayload, responder: any) => {
+        const { authType, autoLogin: autoLoginConfig } = this.embedConfig;
+        // Default autoLogin: true for cookieless if undefined/null, otherwise false
+        const autoLogin = autoLoginConfig ?? (authType === AuthType.TrustedAuthTokenCookieless);
+        
+        try {
+            await this.refreshAuthTokenForCookieless(responder, EmbedEvent.AuthExpire, false);
+        } catch (e) {
+            this.handleAuthFailure(e);
+        }
+        
+        if (autoLogin && authType !== AuthType.TrustedAuthTokenCookieless) {
             handleAuth();
         }
         notifyAuthFailure(AuthFailureType.EXPIRY);
@@ -550,8 +592,7 @@ export class TsEmbed {
                     data: { authToken },
                 });
             } catch (e) {
-                logger.error(`${ERROR_MESSAGE.INVALID_TOKEN_ERROR} Error : ${e?.message}`);
-                processAuthFailure(e, this.isPreRendered ? this.preRenderWrapper : this.el);
+                this.handleAuthFailure(e);
             }
         }).catch((e) => {
             logger.error(`Auto Login failed, Error : ${e?.message}`);
@@ -569,9 +610,10 @@ export class TsEmbed {
 
         const embedListenerReadyHandler = this.createEmbedContainerHandler(EmbedEvent.EmbedListenerReady);
         this.on(EmbedEvent.EmbedListenerReady, embedListenerReadyHandler, { start: false }, true);
-
+        
         const authInitHandler = this.createEmbedContainerHandler(EmbedEvent.AuthInit);
         this.on(EmbedEvent.AuthInit, authInitHandler, { start: false }, true);
+        this.on(EmbedEvent.RefreshAuthToken, this.tokenRefresh, { start: false }, true);
     };
 
     /**
@@ -1347,10 +1389,11 @@ export class TsEmbed {
      * @param {any} data The payload to send with the message
      * @returns A promise that resolves with the response from the embedded app
      */
-    public async trigger<HostEventT extends HostEvent, PayloadT>(
+    public async trigger<HostEventT extends HostEvent, PayloadT, ContextT extends ContextType>(
         messageType: HostEventT,
         data: TriggerPayload<PayloadT, HostEventT> = {} as any,
-    ): Promise<TriggerResponse<PayloadT, HostEventT>> {
+        context?: ContextT,
+    ): Promise<TriggerResponse<PayloadT, HostEventT, ContextT>> {
         uploadMixpanelEvent(`${MIXPANEL_EVENT.VISUAL_SDK_TRIGGER}-${messageType}`);
 
         if (!this.isRendered) {
@@ -1383,7 +1426,7 @@ export class TsEmbed {
         }
 
         // send an empty object, this is needed for liveboard default handlers
-        return this.hostEventClient.triggerHostEvent(messageType, data);
+        return this.hostEventClient.triggerHostEvent(messageType, data, context);
     }
 
     /**
@@ -1425,6 +1468,20 @@ export class TsEmbed {
         return this.render();
     }
 
+    /**
+     * Get the current context of the embedded TS component.
+     * @returns The current context object containing the page type and object ids.
+     * @version SDK: 1.45.2 | ThoughtSpot: 26.3.0.cl
+     */
+    public async getCurrentContext(): Promise<ContextObject> {
+        return new Promise((resolve) => {
+            this.executeAfterEmbedContainerLoaded(async () => {
+                const context = await this.trigger(HostEvent.GetPageContext, {});
+                resolve(context);
+            });
+        });
+    }
+
     /**
      * Creates the preRender shell
      * @param showPreRenderByDefault - Show the preRender after render, hidden by default

package/src/index.ts

@@ -68,6 +68,7 @@ import {
     InterceptedApiType,
     EmbedErrorCodes,
     ErrorDetailsTypes,
+    ContextType,
 } from './types';
 import { CustomCssVariables } from './css-variables';
 import { SageEmbed, SageViewConfig } from './embed/sage';
@@ -121,6 +122,7 @@ export {
     RuntimeFilterOp,
     EmbedEvent,
     HostEvent,
+    ContextType,
     DataSourceVisualMode,
     Action,
     ContextMenuTriggerOptions,