@thoughtspot/visual-embed-sdk 1.47.2 → 1.48.0

package/src/embed/spotter-utils.ts

@@ -2,6 +2,7 @@ import { DefaultAppInitData, ErrorDetailsTypes, EmbedErrorCodes } from '../types
 import { validateHttpUrl } from '../utils';
 import { ERROR_MESSAGE } from '../errors';
 import type { SpotterSidebarViewConfig } from './conversation';
+import type { VisualizationOverrides } from '../types';
 
 /**
  * Resolves enablePastConversationsSidebar with
@@ -22,10 +23,16 @@ export function buildSpotterSidebarAppInitData<T extends DefaultAppInitData>(
     viewConfig: {
         spotterSidebarConfig?: SpotterSidebarViewConfig;
         enablePastConversationsSidebar?: boolean;
+        visualOverrides?: VisualizationOverrides;
     },
     handleError: (err: any) => void,
-): T & { embedParams?: { spotterSidebarConfig?: SpotterSidebarViewConfig } } {
-    const { spotterSidebarConfig, enablePastConversationsSidebar } = viewConfig;
+): T & {
+    embedParams?: {
+        spotterSidebarConfig?: SpotterSidebarViewConfig;
+        visualOverridesParams?: VisualizationOverrides | null;
+    };
+} {
+    const { spotterSidebarConfig, enablePastConversationsSidebar, visualOverrides } = viewConfig;
 
     const resolvedEnablePastConversations = resolveEnablePastConversationsSidebar({
         spotterSidebarConfigValue: spotterSidebarConfig?.enablePastConversationsSidebar,
@@ -33,7 +40,15 @@ export function buildSpotterSidebarAppInitData<T extends DefaultAppInitData>(
     });
 
     const hasConfig = spotterSidebarConfig || resolvedEnablePastConversations !== undefined;
-    if (!hasConfig) return defaultAppInitData;
+    if (!hasConfig) {
+        if (visualOverrides === undefined) {
+            return defaultAppInitData;
+        }
+        return {
+            ...defaultAppInitData,
+            embedParams: { visualOverridesParams: visualOverrides },
+        };
+    }
 
     const resolvedSidebarConfig: SpotterSidebarViewConfig = {
         ...spotterSidebarConfig,
@@ -60,6 +75,7 @@ export function buildSpotterSidebarAppInitData<T extends DefaultAppInitData>(
         embedParams: {
             ...((defaultAppInitData as any).embedParams || {}),
             spotterSidebarConfig: resolvedSidebarConfig,
+            ...(visualOverrides !== undefined ? { visualOverridesParams: visualOverrides } : {}),
         },
     };
 }

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

@@ -97,6 +97,7 @@ beforeAll(() => {
 const customisations = {
     style: {
         customCSS: {},
+        customCSSUrl: undefined as string | undefined,
     },
     content: {},
 };
@@ -132,6 +133,9 @@ const getMockAppInitPayload = (data: any) => {
         customVariablesForThirdPartyTools,
         interceptTimeout: undefined,
         interceptUrls: [],
+        shouldBypassPayloadValidation:undefined,
+        useHostEventsV2:undefined,
+        embedExpiryInAuthToken:true
     };
     return {
         type: EmbedEvent.APP_INIT,
@@ -641,6 +645,37 @@ describe('Unit test case for ts embed', () => {
             });
         });
 
+        test.each([
+            ['not set', undefined, true],
+            ['false', false, false],
+            ['true', true, true],
+        ] as [string, boolean | undefined, boolean][])(
+            'embedExpiryInAuthToken is %s when refreshAuthTokenOnNearExpiry is %s',
+            async (_label, refreshAuthTokenOnNearExpiry, expectedEmbedExpiry) => {
+                const mockEmbedEventPayload = {
+                    type: EmbedEvent.APP_INIT,
+                    data: {},
+                };
+                const searchEmbed = new AppEmbed(getRootEl(), {
+                    ...defaultViewConfig,
+                    refreshAuthTokenOnNearExpiry,
+                });
+                searchEmbed.render();
+                const mockPort: any = {
+                    postMessage: jest.fn(),
+                };
+                await executeAfterWait(() => {
+                    const iframe = getIFrameEl();
+                    postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+                });
+                await executeAfterWait(() => {
+                    expect(mockPort.postMessage).toHaveBeenCalledWith(
+                        getMockAppInitPayload({ embedExpiryInAuthToken: expectedEmbedExpiry }),
+                    );
+                });
+            },
+        );
+
         test('when Embed event status have start status', (done) => {
             const mockEmbedEventPayload = {
                 type: EmbedEvent.Save,
@@ -4504,4 +4539,189 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         expect(iframe.allow).toContain('clipboard-read');
         expect(iframe.allow).toContain('clipboard-write');
     });
+
+    describe('shouldSkipEvent', () => {
+        beforeAll(() => {
+            init({
+                thoughtSpotHost: 'tshost',
+                authType: AuthType.None,
+            });
+        });
+
+        // Matches the structure produced by createValidationError / embedErrorDetails
+        const makeNestedValidationData = (message = 'invalid payload') => ({
+            type: EmbedEvent.Error,
+            data: {
+                errorType: 'VALIDATION_ERROR',
+                message,
+                code: EmbedErrorCodes.HOST_EVENT_VALIDATION,
+                error: message,
+            },
+        });
+
+        // Matches the flat structure where errorType sits at the top level of data
+        const makeFlatValidationData = (message = 'invalid payload') => ({
+            errorType: EmbedErrorCodes.HOST_EVENT_VALIDATION,
+            message,
+            code: EmbedErrorCodes.HOST_EVENT_VALIDATION,
+        });
+
+        const makeEmbed = (viewConfig: Partial<SearchViewConfig>) => {
+            const embed = new SearchEmbed(getRootEl(), {
+                ...defaultViewConfig,
+                ...viewConfig,
+            });
+            return embed;
+        };
+
+        test('skips Error event and logs warning when useHostEventsV2 is true and shouldBypassPayloadValidation is true', () => {
+            jest.spyOn(logger, 'warn');
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: true });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeNestedValidationData());
+
+            expect(errorHandler).not.toHaveBeenCalled();
+            expect(logger.warn).toHaveBeenCalledWith(
+                'Host Event Validation failed: invalid payload',
+            );
+        });
+
+        test('skips Error event when errorType is resolved from data.data.code (nested format)', () => {
+            jest.spyOn(logger, 'warn');
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: true });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeNestedValidationData('nested error'));
+
+            expect(errorHandler).not.toHaveBeenCalled();
+            expect(logger.warn).toHaveBeenCalledWith(
+                'Host Event Validation failed: nested error',
+            );
+        });
+
+        test('skips Error event when errorType is resolved from data.errorType (flat format)', () => {
+            jest.spyOn(logger, 'warn');
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: true });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeFlatValidationData());
+
+            expect(errorHandler).not.toHaveBeenCalled();
+        });
+
+        test('delivers Error event to handler when useHostEventsV2 is true and shouldBypassPayloadValidation is undefined', () => {
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: undefined });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeNestedValidationData());
+
+            expect(errorHandler).toHaveBeenCalled();
+        });
+
+        test('delivers Error event to handler when useHostEventsV2 is true and shouldBypassPayloadValidation is false', () => {
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: false });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeNestedValidationData());
+
+            expect(errorHandler).toHaveBeenCalled();
+        });
+
+        test('skips Error event when useHostEventsV2 is false regardless of shouldBypassPayloadValidation', () => {
+            jest.spyOn(logger, 'warn');
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: false, shouldBypassPayloadValidation: undefined });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeNestedValidationData());
+
+            expect(errorHandler).not.toHaveBeenCalled();
+            expect(logger.warn).toHaveBeenCalledWith(
+                'Host Event Validation failed: invalid payload',
+            );
+        });
+
+        test('logs warning with undefined message when flat format has no nested data', () => {
+            jest.spyOn(logger, 'warn');
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: true });
+            embed.on(EmbedEvent.Error, jest.fn());
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeFlatValidationData());
+
+            expect(logger.warn).toHaveBeenCalledWith('Host Event Validation failed: undefined');
+        });
+
+        test('skips Error event when useHostEventsV2 is false and shouldBypassPayloadValidation is true', () => {
+            jest.spyOn(logger, 'warn');
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: false, shouldBypassPayloadValidation: true });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeNestedValidationData());
+
+            expect(errorHandler).not.toHaveBeenCalled();
+            expect(logger.warn).toHaveBeenCalledWith('Host Event Validation failed: invalid payload');
+        });
+
+        test('skips via handleError when shouldBypassPayloadValidation is true', () => {
+            jest.spyOn(logger, 'warn');
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: true });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).handleError({
+                type: EmbedEvent.Error,
+                data: {
+                    errorType: 'VALIDATION_ERROR',
+                    message: 'bad payload',
+                    code: EmbedErrorCodes.HOST_EVENT_VALIDATION,
+                    error: 'bad payload',
+                },
+            });
+
+            expect(errorHandler).not.toHaveBeenCalled();
+            expect(logger.warn).toHaveBeenCalledWith('Host Event Validation failed: bad payload');
+        });
+
+        test('delivers Error event to EmbedEvent.ALL handler when not skipped', () => {
+            const allHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: false });
+            embed.on(EmbedEvent.ALL, allHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, makeNestedValidationData());
+
+            expect(allHandler).toHaveBeenCalled();
+        });
+
+        test('does not skip non-Error events even with HOST_EVENT_VALIDATION error code', () => {
+            const customActionHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: false });
+            embed.on(EmbedEvent.CustomAction, customActionHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.CustomAction, {
+                data: { code: EmbedErrorCodes.HOST_EVENT_VALIDATION },
+            });
+
+            expect(customActionHandler).toHaveBeenCalled();
+        });
+
+        test('does not skip Error events with unrelated error codes', () => {
+            const errorHandler = jest.fn();
+            const embed = makeEmbed({ useHostEventsV2: true, shouldBypassPayloadValidation: false });
+            embed.on(EmbedEvent.Error, errorHandler);
+
+            (embed as any).executeCallbacks(EmbedEvent.Error, {
+                errorType: 'SOME_OTHER_ERROR',
+                message: 'something else failed',
+            });
+
+            expect(errorHandler).toHaveBeenCalled();
+        });
+    });
 });

package/src/embed/ts-embed.ts

@@ -67,7 +67,7 @@ import {
 } from '../types';
 import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
 import { processEventData, processAuthFailure } from '../utils/processData';
-import pkgInfo from '../../package.json';
+import { version } from '../../package.json';
 import {
     getAuthPromise, renderInQueue, handleAuth, notifyAuthFailure,
     getInitPromise,
@@ -80,8 +80,6 @@ import { getPreauthInfo } from '../utils/sessionInfoService';
 import { HostEventClient } from './hostEventClient/host-event-client';
 import { getInterceptInitData, handleInterceptEvent, processApiInterceptResponse, processLegacyInterceptResponse } from '../api-intercept';
 
-const { version } = pkgInfo;
-
 /**
  * Global prefix for all ThoughtSpot postHash Params.
  */
@@ -483,7 +481,7 @@ export class TsEmbed {
                 this.embedConfig.customVariablesForThirdPartyTools || {},
             hiddenListColumns: this.viewConfig.hiddenListColumns || [],
             customActions: customActionsResult.actions,
-            embedExpiryInAuthToken: this.viewConfig.refreshAuthTokenOnNearExpiry,
+            embedExpiryInAuthToken: this.viewConfig.refreshAuthTokenOnNearExpiry ?? true,
             ...getInterceptInitData(this.viewConfig),
             ...getHostEventsConfig(this.viewConfig),
         };
@@ -1151,6 +1149,18 @@ export class TsEmbed {
         }
     }
 
+    private shouldSkipEvent(eventType: EmbedEvent, data: any): boolean {                                                                                                         
+        const errorType = data?.errorType ?? data?.data?.code;                                                                                                              
+        if (                                                                                                                                                                     
+            eventType === EmbedEvent.Error
+            && errorType === EmbedErrorCodes.HOST_EVENT_VALIDATION                                                                                                                  
+            && (!getHostEventsConfig(this.viewConfig).useHostEventsV2 || getHostEventsConfig(this.viewConfig).shouldBypassPayloadValidation)                                                                                                                                
+        ) {
+            logger.warn(`Host Event Validation failed: ${data?.data?.message}`);
+            return true;                                                                                                                                                         
+        }           
+        return false;
+    }                                                                                                                                                                            
     /**
      * Executes all registered event handlers for a particular event type
      * @param eventType The event type
@@ -1162,6 +1172,7 @@ export class TsEmbed {
         data: any,
         eventPort?: MessagePort | void,
     ): void {
+        if (this.shouldSkipEvent(eventType, data)) return;
         const eventHandlers = this.eventHandlerMap.get(eventType) || [];
         const allHandlers = this.eventHandlerMap.get(EmbedEvent.ALL) || [];
         const callbacks = [...eventHandlers, ...allHandlers];

package/src/index.ts

@@ -71,6 +71,14 @@ import {
     ErrorDetailsTypes,
     ContextType,
     AutoMCPFrameRendererViewConfig,
+    LegendPosition,
+    BackgroundFormatType,
+    ConditionalFormattingComparisonType,
+    ConditionalFormattingOperator,
+    DataLabelFilterOperator,
+    TableTheme,
+    TableContentDensity,
+    VisualizationOverrides,
 } from './types';
 import { CustomCssVariables } from './css-variables';
 import { AnswerService, SessionInterface, UnderlyingDataPoint } from './utils/graphql/answerService/answerService';
@@ -165,6 +173,14 @@ export {
     EmbedErrorDetailsEvent,
     ErrorDetailsTypes,
     AutoMCPFrameRendererViewConfig,
+    VisualizationOverrides,
+    LegendPosition,
+    BackgroundFormatType,
+    ConditionalFormattingComparisonType,
+    ConditionalFormattingOperator,
+    DataLabelFilterOperator,
+    TableTheme,
+    TableContentDensity,
 };
 
 export { resetCachedAuthToken } from './authToken';

package/src/mixpanel-service.spec.ts

@@ -8,6 +8,7 @@ import {
 import { AuthType } from './types';
 import { SessionInfo } from './utils/sessionInfoService';
 import { logger } from './utils/logger';
+import { version } from '../package.json';
 
 const config = {
     thoughtSpotHost: 'https://10.87.89.232',
@@ -60,6 +61,7 @@ describe('Unit test for mixpanel', () => {
             clusterName: sessionInfo.clusterName,
             releaseVersion: sessionInfo.releaseVersion,
             hostAppUrl: 'localhost',
+            sdkVersion: version,
         });
         expect(mixpanel.identify).not.toHaveBeenCalledWith(sessionInfo.userGUID);
     });

package/src/mixpanel-service.ts

@@ -2,6 +2,7 @@ import * as mixpanel from 'mixpanel-browser';
 import { logger } from './utils/logger';
 import { SessionInfo } from './utils/sessionInfoService';
 import { ERROR_MESSAGE } from './errors';
+import { version } from '../package.json';
 
 export const EndPoints = {
     CONFIG: '/callosum/v1/system/config',
@@ -80,6 +81,7 @@ export function initMixpanel(sessionInfo: SessionInfo): void {
                 clusterName: sessionInfo.clusterName,
                 releaseVersion: sessionInfo.releaseVersion,
                 hostAppUrl: window?.location?.host || '',
+                sdkVersion: version,
             });
             isMixpanelInitialized = true;
             emptyQueue();

package/src/test/test-utils.ts

@@ -1,6 +1,6 @@
 import { has } from 'lodash';
 import { version } from '../../package.json';
-import { Action, AuthType } from '../types';
+import { Action, AuthType, EmbedEvent } from '../types';
 
 /**
  Initialises fetch to the global object
@@ -166,3 +166,35 @@ export const mockSessionInfo = {
         genNo: 5,
     },
 };
+
+export const testVisualOverridesInEmbed = async (
+    embed: any,
+    visualOverrides: any,
+) => {
+    const mockEmbedEventPayload = {
+        type: EmbedEvent.APP_INIT,
+        data: {},
+    };
+
+    embed.render();
+
+    const mockPort: any = {
+        postMessage: jest.fn(),
+    };
+
+    await executeAfterWait(() => {
+        const iframe = getIFrameEl();
+        postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+    });
+
+    await executeAfterWait(() => {
+        expect(mockPort.postMessage).toHaveBeenCalledWith({
+            type: EmbedEvent.APP_INIT,
+            data: expect.objectContaining({
+                embedParams: expect.objectContaining({
+                    visualOverridesParams: visualOverrides,
+                }),
+            }),
+        });
+    });
+};

package/src/tokenizedFetch.spec.ts

@@ -0,0 +1,81 @@
+import 'jest-fetch-mock';
+import * as embedConfigModule from './embed/embedConfig';
+import * as authTokenModule from './authToken';
+import { AuthType } from './types';
+import { tokenizedFetch } from './tokenizedFetch';
+
+jest.mock('./embed/embedConfig');
+jest.mock('./authToken');
+
+const mockGetEmbedConfig = embedConfigModule.getEmbedConfig as jest.Mock;
+const mockGetAuthenticationToken = authTokenModule.getAuthenticationToken as jest.Mock;
+const mockGetCacheAuthToken = authTokenModule.getCacheAuthToken as jest.Mock;
+
+describe('tokenizedFetch', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fetchMock.resetMocks();
+    });
+
+    describe('non-cookieless auth', () => {
+        beforeEach(() => {
+            mockGetEmbedConfig.mockReturnValue({ authType: AuthType.TrustedAuthToken });
+        });
+
+        it('should add Authorization Bearer header when cachedAuthToken exists', async () => {
+            mockGetCacheAuthToken.mockReturnValue('my-cached-token');
+            fetchMock.mockResponseOnce(JSON.stringify({}));
+
+            await tokenizedFetch('https://example.com/api', { method: 'GET' });
+
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+            const request = fetchMock.mock.calls[0][0] as Request;
+            expect(request).toBeInstanceOf(Request);
+            expect(request.headers.get('Authorization')).toBe('Bearer my-cached-token');
+        });
+
+        it('should fetch with credentials include when no cachedAuthToken', async () => {
+            mockGetCacheAuthToken.mockReturnValue(null);
+            fetchMock.mockResponseOnce(JSON.stringify({}));
+
+            await tokenizedFetch('https://example.com/api', { method: 'GET' });
+
+            expect(fetchMock).toHaveBeenCalledWith('https://example.com/api', {
+                credentials: 'include',
+                method: 'GET',
+            });
+        });
+    });
+
+    describe('cookieless auth (TrustedAuthTokenCookieless)', () => {
+        beforeEach(() => {
+            mockGetEmbedConfig.mockReturnValue({
+                authType: AuthType.TrustedAuthTokenCookieless,
+                thoughtSpotHost: 'https://example.com',
+            });
+        });
+
+        it('should add Authorization Bearer header from getAuthenticationToken', async () => {
+            mockGetAuthenticationToken.mockResolvedValue('cookieless-token');
+            fetchMock.mockResponseOnce(JSON.stringify({}));
+
+            await tokenizedFetch('https://example.com/api', { method: 'POST' });
+
+            expect(mockGetAuthenticationToken).toHaveBeenCalled();
+            const request = fetchMock.mock.calls[0][0] as Request;
+            expect(request).toBeInstanceOf(Request);
+            expect(request.headers.get('Authorization')).toBe('Bearer cookieless-token');
+        });
+
+        it('should not add Authorization header when getAuthenticationToken returns null', async () => {
+            mockGetAuthenticationToken.mockResolvedValue(null);
+            fetchMock.mockResponseOnce(JSON.stringify({}));
+
+            await tokenizedFetch('https://example.com/api', { method: 'POST' });
+
+            const request = fetchMock.mock.calls[0][0] as Request;
+            expect(request).toBeInstanceOf(Request);
+            expect(request.headers.get('Authorization')).toBeNull();
+        });
+    });
+});

package/src/tokenizedFetch.ts

@@ -1,4 +1,4 @@
-import { getAuthenticationToken } from './authToken';
+import { getAuthenticationToken, getCacheAuthToken } from './authToken';
 import { getEmbedConfig } from './embed/embedConfig';
 
 import { AuthType } from './types';
@@ -20,18 +20,21 @@ import { AuthType } from './types';
  */
 export const tokenizedFetch: typeof fetch = async (input, init): Promise<Response> => {
     const embedConfig = getEmbedConfig();
+    const options: RequestInit = { ...init };
+    let token: string | undefined;
     if (embedConfig.authType !== AuthType.TrustedAuthTokenCookieless) {
-        return fetch(input, {
-            // ensure cookies are included for the non cookie-less api calls.
-            credentials: 'include',
-            ...init,
-        });
+        token = getCacheAuthToken();
+        if (!token) {
+            return fetch(input, { ...options, credentials: 'include' });
+        }
+    } else {
+        token = await getAuthenticationToken(embedConfig);
     }
+    const req = new Request(input, options);
 
-    const req = new Request(input, init);
-    const authToken = await getAuthenticationToken(embedConfig);
-    if (authToken) {
-        req.headers.append('Authorization', `Bearer ${authToken}`);
+    if (token) {
+        req.headers.append('Authorization', `Bearer ${token}`);
     }
+
     return fetch(req);
-};
+};