@thoughtspot/visual-embed-sdk 1.50.0 → 1.50.1

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

@@ -7,6 +7,7 @@ import {
     init,
     AuthType,
     LiveboardEmbed,
+    AppEmbed,
     HostEvent,
     EmbedErrorCodes,
 } from '../index';
@@ -1633,3 +1634,126 @@ describe('context parameter forwarded in postMessage payload', () => {
         });
     });
 });
+
+// ---------------------------------------------------------------------------
+// SetVisibleVizs — array vizId injection (NOT in the parametrized arrayEvents)
+// ---------------------------------------------------------------------------
+describe('HostEvent.SetVisibleVizs — array payload vizId injection', () => {
+    test('vizId is added as a non-indexed property on the array — array.length unchanged', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard({ vizId });
+        const arrayPayload = ['viz1', 'viz2'];
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.SetVisibleVizs, arrayPayload as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            expect((sentData as any).vizId).toBe(vizId);
+            expect(sentData.length).toBe(2);
+        });
+    });
+
+    test('without viewConfig.vizId — array payload is sent as-is (no vizId property)', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard(); // no vizId
+        const arrayPayload = ['viz1'];
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.SetVisibleVizs, arrayPayload as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            expect((sentData as any).vizId).toBeUndefined();
+        });
+    });
+
+    test('returns null and calls handleError when !isRendered', async () => {
+        const lb = unrenderedLiveboard();
+        const result = await lb.trigger(HostEvent.SetVisibleVizs, ['viz1'] as any);
+        expect(result).toBeNull();
+        expect((lb as any).handleError).toHaveBeenCalledWith(
+            expect.objectContaining({ code: EmbedErrorCodes.RENDER_NOT_CALLED }),
+        );
+    });
+});
+
+// ---------------------------------------------------------------------------
+// UpdateRuntimeFilters — AppEmbed path (no vizId injection)
+// ---------------------------------------------------------------------------
+describe('HostEvent.UpdateRuntimeFilters — AppEmbed path', () => {
+    async function renderApp() {
+        const app = new AppEmbed(getRootEl(), {
+            frameParams: { width: '100%', height: '100%' },
+        });
+        await app.render();
+        const iframe = getIFrameEl();
+        jest.spyOn(iframe.contentWindow, 'postMessage');
+        return { app, iframe };
+    }
+
+    test('AppEmbed sends payload directly without vizId injection', async () => {
+        mockMessageChannel();
+        const { app, iframe } = await renderApp();
+        const filters = [{ columnName: 'col', operator: 'EQ', values: ['v1'] }];
+        await executeAfterWait(() => {
+            app.trigger(HostEvent.UpdateRuntimeFilters, filters as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            // Array payload with no vizId property injected
+            expect((sentData as any).vizId).toBeUndefined();
+            expect(sentData).toEqual(filters);
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Present — vizId injection on LiveboardEmbed
+// ---------------------------------------------------------------------------
+describe('HostEvent.Present — vizId injection on LiveboardEmbed', () => {
+    test('viewConfig.vizId is injected into the Present payload', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard({ vizId });
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.Present, {} as any);
+            expect(iframe.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    data: expect.objectContaining({ vizId }),
+                }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// DownloadAsCsv — additional cases
+// ---------------------------------------------------------------------------
+describe('HostEvent.DownloadAsCsv — additional cases', () => {
+    test('viewConfig.vizId overwrites an explicit payload vizId', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard({ vizId });
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.DownloadAsCsv, { vizId: 'explicit-id' } as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            expect(sentData.vizId).toBe(vizId); // viewConfig.vizId wins
+        });
+    });
+
+    test('returns null and calls handleError when !isRendered', async () => {
+        const lb = unrenderedLiveboard();
+        const result = await lb.trigger(HostEvent.DownloadAsCsv, {} as any);
+        expect(result).toBeNull();
+        expect((lb as any).handleError).toHaveBeenCalledWith(
+            expect.objectContaining({ code: EmbedErrorCodes.RENDER_NOT_CALLED }),
+        );
+    });
+
+    test('returns null and logs debug when !iFrame', async () => {
+        const lb = new LiveboardEmbed(getRootEl(), {
+            frameParams: { width: '100%', height: '100%' },
+            liveboardId,
+        });
+        (lb as any).isRendered = true;
+        const result = await lb.trigger(HostEvent.DownloadAsCsv, {} as any);
+        expect(result).toBeNull();
+    });
+});

package/src/embed/hostEventClient/contracts.ts

@@ -7,6 +7,43 @@ export interface LiveboardTab {
   [key: string]: any;
 }
 
+/**
+ * Levels at which a filter or parameter can be applied.
+ */
+export enum ApplicabilityLevel {
+  Liveboard = 'LIVEBOARD',
+  Tab = 'TAB',
+  Group = 'GROUP',
+}
+
+/**
+ * Scopes a filter or parameter to a specific target.
+ * At `LIVEBOARD` level the filter applies to the whole Liveboard, so `targetId`
+ * is not required.
+ */
+export interface Applicability {
+  level: ApplicabilityLevel;
+  targetId?: string;
+}
+
+export interface FilterUpdate {
+  column: string;
+  oper: string;
+  values: string[];
+  type?: string;
+  applicability?: Applicability;
+}
+
+export interface LiveboardFilter {
+  applicability?: Applicability;
+  [key: string]: any;
+}
+
+export interface LiveboardParameter {
+  applicability?: Applicability;
+  [key: string]: any;
+}
+
 export enum UIPassthroughEvent {
   PinAnswerToLiveboard = 'addVizToPinboard',
   SaveAnswer = 'saveAnswer',
@@ -103,7 +140,7 @@ export type UIPassthroughContractBase = {
       vizId?: string;
     };
     response: {
-      liveboardFilters: Record<string, any>[];
+      liveboardFilters: LiveboardFilter[];
       runtimeFilters: RuntimeFilter[];
     };
   };
@@ -116,7 +153,7 @@ export type UIPassthroughContractBase = {
   [UIPassthroughEvent.GetParameters]: {
     request: Record<string, never>;
     response: {
-      parameters: Record<string, any>[];
+      parameters: LiveboardParameter[];
     };
   };
   [UIPassthroughEvent.GetTML]: {
@@ -143,18 +180,8 @@ export type UIPassthroughContractBase = {
   };
   [UIPassthroughEvent.UpdateFilters]: {
     request: {
-      filter?: {
-        column: string;
-        oper: string;
-        values: string[];
-        type?: string;
-      };
-      filters?: {
-        column: string;
-        oper: string;
-        values: string[];
-        type?: string;
-      }[];
+      filter?: FilterUpdate;
+      filters?: FilterUpdate[];
     };
     response: unknown;
   };

package/src/embed/hostEventClient/host-event-client.spec.ts

@@ -311,6 +311,70 @@ describe('HostEventClient', () => {
             );
         });
 
+        it('should dispatch UpdateParameters over the legacy channel', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [
+                { name: 'param1', value: 10, applicability: { level: 'TAB', targetId: 'tab-guid-1' } },
+            ] as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            const result = await client.triggerHostEvent(HostEvent.UpdateParameters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                undefined,
+            );
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should forward UpdateParameters with null applicability', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [{ name: 'param1', value: 10, applicability: null }] as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            await client.triggerHostEvent(HostEvent.UpdateParameters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                undefined,
+            );
+        });
+
+        it('should throw when UpdateParameters entry has invalid applicability', async () => {
+            const { client } = createHostEventClient();
+            const invalidPayload = [
+                { name: 'param1', value: 10, applicability: { level: 'TAB' } }, // missing targetId
+            ] as any;
+
+            await expect(client.triggerHostEvent(HostEvent.UpdateParameters, invalidPayload))
+                .rejects.toThrow('UpdateParameters received an invalid applicability');
+            expect(mockProcessTrigger).not.toHaveBeenCalled();
+        });
+
+        it('should pass context to UpdateParameters event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [{ name: 'param1', value: 10 }] as any;
+            const context = { vizId: 'viz-1' } as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            await client.triggerHostEvent(HostEvent.UpdateParameters, payload, context);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                context,
+            );
+        });
+
         it('should throw when DrillDown payload has no valid points', async () => {
             const { client } = createHostEventClient();
             const invalidPayload = {} as any;
@@ -816,4 +880,266 @@ describe('HostEventClient', () => {
             expect(result).toEqual({ ok: true });
         });
     });
+
+    describe('availablePassthroughKeysCache reuse', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('GetFilters: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const filterResponse = [{ value: { liveboardFilters: [] as any[], runtimeFilters: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(filterResponse)
+                .mockResolvedValueOnce(filterResponse);
+
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            // 3 calls total: 1 GetAvailableUIPassthroughs + 2 GetFilters
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+            expect(mockProcessTrigger).not.toHaveBeenNthCalledWith(
+                3,
+                expect.anything(),
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                expect.objectContaining({ type: UIPassthroughEvent.GetAvailableUIPassthroughs }),
+                undefined,
+            );
+        });
+
+        it('GetTabs: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const tabResponse = [{ value: { orderedTabIds: [] as any[], numberOfTabs: 0, Tabs: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(tabResponse)
+                .mockResolvedValueOnce(tabResponse);
+
+            await client.triggerHostEvent(HostEvent.GetTabs, {});
+            await client.triggerHostEvent(HostEvent.GetTabs, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetParameters: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const paramResponse = [{ value: { parameters: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(paramResponse)
+                .mockResolvedValueOnce(paramResponse);
+
+            await client.triggerHostEvent(HostEvent.GetParameters, {});
+            await client.triggerHostEvent(HostEvent.GetParameters, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetAnswerSession: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const sessionResponse = [{ value: { session: 's1' } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(sessionResponse)
+                .mockResolvedValueOnce(sessionResponse);
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('UIPassthrough direct trigger does not populate the cache', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { result: 'ok' } }]);
+
+            await client.triggerHostEvent(HostEvent.UIPassthrough, {});
+            // Cache not populated — next GetFilters call must still fetch keys
+            mockProcessTrigger.mockResolvedValueOnce(allKeys());
+            mockProcessTrigger.mockResolvedValueOnce([{ value: { liveboardFilters: [], runtimeFilters: [] as any[] } }]);
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            // UIPassthrough call + GetAvailableUIPassthroughs + GetFilters = 3
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetAnswerSession: catch in getAvailableUIPassthroughKeys does not cache, so next call retries GetAvailableUIPassthroughs', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockReset();
+
+            // Flow per triggerHostEvent call when GetAvailableUIPassthroughs rejects:
+            //   1. getAvailableUIPassthroughKeys → processTrigger(UIPassthrough, GetAvailableUIPassthroughs) → rejects → returns []
+            //   2. keys=[] so getDataWithPassthroughFallback is called →
+            //      triggerUIPassthroughApi(GetAnswerSession) → processTrigger(UIPassthrough) → null → hostEventFallback called
+            //   3. hostEventFallback → processTrigger(GetAnswerSession) → legacy result
+
+            // First triggerHostEvent: 3 calls
+            mockProcessTrigger.mockRejectedValueOnce(new Error('network error')); // call 1
+            mockProcessTrigger.mockResolvedValueOnce(null);                       // call 2
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'leg1' });        // call 3
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '1' });
+
+            // Second triggerHostEvent: cache was NOT set, so GetAvailableUIPassthroughs is retried: 3 more calls
+            mockProcessTrigger.mockRejectedValueOnce(new Error('network error')); // call 4
+            mockProcessTrigger.mockResolvedValueOnce(null);                       // call 5
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'leg2' });        // call 6
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '2' });
+
+            // 6 total calls: GetAvailableUIPassthroughs was called TWICE (cache not set after catch)
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(6);
+            const availableCallsCount = mockProcessTrigger.mock.calls.filter(
+                (call) => call[3]?.type === UIPassthroughEvent.GetAvailableUIPassthroughs,
+            ).length;
+            expect(availableCallsCount).toBe(2);
+        });
+    });
+
+    describe('GetTML edge cases', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('includeNonExecutedSearchTokens flag is forwarded in UIPassthrough parameters', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([{ value: { tml: 'data' } }]);
+
+            await client.triggerHostEvent(HostEvent.GetTML, { includeNonExecutedSearchTokens: true } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                {
+                    type: UIPassthroughEvent.GetTML,
+                    parameters: { includeNonExecutedSearchTokens: true },
+                },
+                undefined,
+            );
+        });
+
+        it('value.error (singular) throws — distinct from value.errors', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([{ value: { error: 'TML fetch failed' } }]);
+
+            await expect(client.triggerHostEvent(HostEvent.GetTML, {}))
+                .rejects.toThrow('TML fetch failed');
+        });
+
+        it('GetTML key absent from non-empty keys array falls back to legacy hostEventFallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            // Return keys that do NOT include GetTML
+            mockProcessTrigger
+                .mockResolvedValueOnce([{ value: { keys: [UIPassthroughEvent.GetFilters] } }])
+                .mockResolvedValueOnce({ answer: { search_query: 'revenue' } });
+
+            const result = await client.triggerHostEvent(HostEvent.GetTML, {});
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.GetTML,
+                mockThoughtSpotHost,
+                {},
+                undefined,
+            );
+            expect(result).toEqual({ answer: { search_query: 'revenue' } });
+        });
+    });
+
+    describe('SaveAnswer key-presence edge cases', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+        const saveResponse = [{
+            value: {
+                saveResponse: {
+                    data: {
+                        Answer__save: {
+                            answer: { id: 'ans123' },
+                        },
+                    },
+                },
+            },
+            refId: 'viz1',
+        }];
+
+        it('name+description both empty string route through passthrough, not Save fallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(saveResponse);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { name: '', description: '' } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.SaveAnswer, parameters: { name: '', description: '' } },
+                undefined,
+            );
+        });
+
+        it('description: undefined (key present) routes through passthrough, not Save fallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(saveResponse);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { name: 'Test', description: undefined } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.SaveAnswer, parameters: { name: 'Test', description: undefined } },
+                undefined,
+            );
+        });
+
+        it('name key absent falls back to HostEvent.Save', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([saveResponse[0].value]);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { description: 'desc only' } as any);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.Save,
+                mockThoughtSpotHost,
+                { description: 'desc only' },
+                undefined,
+            );
+        });
+
+        it('answerId is undefined when saveResponse.data.Answer__save.answer.id is missing', async () => {
+            const { client } = createHostEventClient();
+            const noIdSaveResponse = [{
+                value: {
+                    saveResponse: {
+                        data: {
+                            Answer__save: {
+                                answer: {},
+                            },
+                        },
+                    },
+                },
+                refId: 'viz1',
+            }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(noIdSaveResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.SaveAnswer, { name: 'Test', description: 'Desc' } as any);
+
+            expect(result.answerId).toBeUndefined();
+        });
+    });
 });

package/src/embed/hostEventClient/host-event-client.ts

@@ -3,8 +3,10 @@ import { processTrigger as processTriggerService } from '../../utils/processTrig
 import { getEmbedConfig } from '../embedConfig';
 import {
     isValidUpdateFiltersPayload,
+    isValidUpdateParametersPayload,
     isValidDrillDownPayload,
     throwUpdateFiltersValidationError,
+    throwUpdateParametersValidationError,
     throwDrillDownValidationError,
 } from './utils';
 import {
@@ -58,6 +60,7 @@ export class HostEventClient {
           [HostEvent.Pin]: (p, c) => this.handlePinEvent(p, c),
           [HostEvent.SaveAnswer]: (p, c) => this.handleSaveAnswerEvent(p, c),
           [HostEvent.UpdateFilters]: (p, c) => this.handleUpdateFiltersEvent(p, c),
+          [HostEvent.UpdateParameters]: (p, c) => this.handleUpdateParametersEvent(p, c),
           [HostEvent.DrillDown]: (p, c) => this.handleDrillDownEvent(p, c),
       };
   }
@@ -243,6 +246,18 @@ export class HostEventClient {
     return this.handleHostEventWithParam(UIPassthroughEvent.UpdateFilters, payload, context as ContextType);
   }
 
+  protected handleUpdateParametersEvent(
+    payload: HostEventRequest<HostEvent.UpdateParameters>,
+    context?: ContextType,
+  ): Promise<any> {
+    if (!isValidUpdateParametersPayload(payload)) {
+      throwUpdateParametersValidationError();
+    }
+
+    // UpdateParameters has no UI passthrough contract; dispatch over the legacy channel
+    return this.hostEventFallback(HostEvent.UpdateParameters, payload, context);
+  }
+
   protected handleDrillDownEvent(
     payload: HostEventRequest<HostEvent.DrillDown>,
     context?: ContextType,