@thoughtspot/visual-embed-sdk 1.46.4 → 1.46.5

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

@@ -125,6 +125,8 @@ describe('HostEventClient', () => {
     });
 
     describe('executeHostEvent', () => {
+        const mockGetAvailablePassthroughs = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
         it('should call handleUIPassthroughForHostEvent for Pin event', async () => {
             const { client, mockIframe } = createHostEventClient();
             const hostEvent = HostEvent.Pin;
@@ -140,7 +142,9 @@ describe('HostEventClient', () => {
                 },
             };
 
-            mockProcessTrigger.mockResolvedValue([mockResponse]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([mockResponse]);
 
             const result = await client.triggerHostEvent(hostEvent, payload);
 
@@ -176,7 +180,9 @@ describe('HostEventClient', () => {
                 },
                 refId: 'testVizId',
             }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
             const result = await client.triggerHostEvent(hostEvent, payload);
 
             expect(mockProcessTrigger).toHaveBeenCalledWith(
@@ -192,6 +198,168 @@ describe('HostEventClient', () => {
             expect(result).toEqual({ answerId: 'newAnswer', ...mockResponse[0].value });
         });
 
+        it('should call handleHostEventWithParam for UpdateFilters event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const hostEvent = HostEvent.UpdateFilters;
+            const payload: HostEventRequest<typeof hostEvent> = {
+                vizId: 'viz-123',
+                filter: {
+                    column: 'region',
+                    oper: 'EQ',
+                    values: ['North'],
+                },
+            } as any;
+            const mockResponse = [{ value: { success: true } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(hostEvent, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                {
+                    type: UIPassthroughEvent.UpdateFilters,
+                    parameters: payload,
+                },
+                undefined,
+            );
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should call handleHostEventWithParam for DrillDown event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const hostEvent = HostEvent.DrillDown;
+            const payload: HostEventRequest<typeof hostEvent> = {
+                points: { clickedPoint: 'point-1', selectedPoints: ['sel-1'] },
+                autoDrillDown: true,
+            } as any;
+            const mockResponse = [{ value: { drillDownApplied: true } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(hostEvent, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                {
+                    type: UIPassthroughEvent.Drilldown,
+                    parameters: payload,
+                },
+                undefined,
+            );
+            expect(result).toEqual({ drillDownApplied: true });
+        });
+
+        it('should accept UpdateFilters with filters array', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = {
+                filters: [
+                    { column: '(Sample) Retail - Apparel::city', oper: 'IN', values: ['atlanta'] },
+                    { column: '(Sample) Retail - Apparel::Region', oper: 'IN', values: ['West', 'Midwest'] },
+                ],
+            } as any;
+            const mockResponse = [{ value: { success: true } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.UpdateFilters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.UpdateFilters, parameters: payload },
+                undefined,
+            );
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should throw when UpdateFilters payload has no valid filter', async () => {
+            const { client } = createHostEventClient();
+            const invalidPayload = {} as any;
+            mockProcessTrigger.mockResolvedValueOnce(mockGetAvailablePassthroughs());
+
+            await expect(client.triggerHostEvent(HostEvent.UpdateFilters, invalidPayload))
+                .rejects.toThrow('UpdateFilters requires a valid filter or filters array');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should pass context to UpdateFilters event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = { vizId: 'viz-1', filter: { column: 'x', oper: 'EQ', values: ['a'] } } as any;
+            const context = { answerId: 'ans-1' } as any;
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: {} }]);
+
+            await client.triggerHostEvent(HostEvent.UpdateFilters, payload, context);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.UpdateFilters, parameters: payload },
+                context,
+            );
+        });
+
+        it('should throw when DrillDown payload has no valid points', async () => {
+            const { client } = createHostEventClient();
+            const invalidPayload = {} as any;
+            mockProcessTrigger.mockResolvedValueOnce(mockGetAvailablePassthroughs());
+
+            await expect(client.triggerHostEvent(HostEvent.DrillDown, invalidPayload))
+                .rejects.toThrow('DrillDown requires a valid points object');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should pass context to DrillDown event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = { points: { clickedPoint: 'point-1' }, vizId: 'viz-2' } as any;
+            const context = { liveboardId: 'lb-1' } as any;
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: {} }]);
+
+            await client.triggerHostEvent(HostEvent.DrillDown, payload, context);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.Drilldown, parameters: payload },
+                context,
+            );
+        });
+
+        it('should skip to fallback when passthrough is not in available keys', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce([{ value: { keys: ['getFilters'] } }])
+                .mockResolvedValueOnce({ session: 'legacySession' });
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.GetAnswerSession,
+                mockThoughtSpotHost,
+                { vizId: '123' },
+                undefined,
+            );
+            expect(result).toEqual({ session: 'legacySession' });
+        });
+
         it('should call hostEventFallback for unmapped events', async () => {
             const { client } = createHostEventClient();
             const hostEvent = 'testEvent' as HostEvent;
@@ -205,6 +373,147 @@ describe('HostEventClient', () => {
             expect(result).toEqual(mockResponse);
         });
 
+        it('should route GetAnswerSession through passthrough and return data', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const mockResponse = [{ value: { session: 'testSession', embedAnswerData: { id: '1' } } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.GetAnswerSession, parameters: { vizId: '123' } },
+                undefined,
+            );
+            expect(result).toEqual({ session: 'testSession', embedAnswerData: { id: '1' } });
+        });
+
+        it('should fall back to legacy host event when passthrough returns no data for GetAnswerSession', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce({ session: 'fallbackSession' });
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                3,
+                expect.anything(),
+                HostEvent.GetAnswerSession,
+                mockThoughtSpotHost,
+                { vizId: '123' },
+                undefined,
+            );
+            expect(result).toEqual({ session: 'fallbackSession' });
+        });
+
+        it('should throw real errors from passthrough without falling back', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ error: 'Permission denied' }]);
+
+            await expect(client.triggerHostEvent(HostEvent.GetAnswerSession, {}))
+                .rejects.toThrow('Permission denied');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+        });
+
+        it('should route GetFilters through passthrough and return data', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const mockResponse = [{ value: { liveboardFilters: [{ id: 'f1' }], runtimeFilters: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.GetFilters, parameters: {} },
+                undefined,
+            );
+            expect(result).toEqual({ liveboardFilters: [{ id: 'f1' }], runtimeFilters: [] });
+        });
+
+        it('should route GetTabs through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            const mockResponse = [{ value: { orderedTabIds: ['t1', 't2'], numberOfTabs: 2, Tabs: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetTabs, {});
+
+            expect(result).toEqual({ orderedTabIds: ['t1', 't2'], numberOfTabs: 2, Tabs: [] });
+        });
+
+        it('should route GetTML through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            const tmlData = { answer: { search_query: 'revenue by region' } };
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: tmlData }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetTML, {});
+
+            expect(result).toEqual(tmlData);
+        });
+
+        it('should route GetIframeUrl through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: { iframeUrl: 'https://ts.example.com/embed' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetIframeUrl, {});
+
+            expect(result).toEqual({ iframeUrl: 'https://ts.example.com/embed' });
+        });
+
+        it('should route GetParameters through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: { parameters: [{ name: 'p1' }] } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetParameters, {});
+
+            expect(result).toEqual({ parameters: [{ name: 'p1' }] });
+        });
+
+        it('should route getExportRequestForCurrentPinboard through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: { v2Content: 'exportData' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.getExportRequestForCurrentPinboard, {});
+
+            expect(result).toEqual({ v2Content: 'exportData' });
+        });
+
+        it('should fall back to legacy for GetFilters when passthrough returns null', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce({ liveboardFilters: [], runtimeFilters: [] });
+
+            const result = await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+            expect(result).toEqual({ liveboardFilters: [], runtimeFilters: [] });
+        });
+
         it('should call fallback  for Pin event', async () => {
             const { client, mockIframe } = createHostEventClient();
             const hostEvent = HostEvent.Pin;
@@ -217,7 +526,9 @@ describe('HostEventClient', () => {
                 },
             };
 
-            mockProcessTrigger.mockResolvedValue([mockResponse]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([mockResponse]);
 
             const result = await client.triggerHostEvent(hostEvent, payload);
 
@@ -243,7 +554,9 @@ describe('HostEventClient', () => {
                 },
             };
 
-            mockProcessTrigger.mockResolvedValue([mockResponse]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([mockResponse]);
 
             const result = await client.triggerHostEvent(hostEvent, payload);
 
@@ -275,7 +588,9 @@ describe('HostEventClient', () => {
                 },
                 refId: 'testVizId',
             }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
             const result = await client.triggerHostEvent(hostEvent, payload);
             expect(result.liveboardId).toBe('testLiveboard');
         });
@@ -297,7 +612,9 @@ describe('HostEventClient', () => {
                 },
                 refId: 'testVizId',
             }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
             const result = await client.triggerHostEvent(hostEvent, payload);
             expect(result.liveboardId).toBe('testLiveboard');
             expect(mockProcessTrigger).toHaveBeenCalledWith(
@@ -318,4 +635,185 @@ describe('HostEventClient', () => {
             });
         });
     });
+
+    describe('getDataWithPassthroughFallback', () => {
+        const callMethod = (client: HostEventClient, ...args: any[]) => (client as any).getDataWithPassthroughFallback(...args);
+
+        it('should return unwrapped value when passthrough succeeds', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { session: 's1', embedAnswerData: { id: 'a1' } } }]);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetAnswerSession, HostEvent.GetAnswerSession, { vizId: '1' },
+            );
+
+            expect(result).toEqual({ session: 's1', embedAnswerData: { id: 'a1' } });
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should fall back to legacy when passthrough returns empty array', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { session: 'legacy' };
+            mockProcessTrigger
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetAnswerSession, HostEvent.GetAnswerSession, { vizId: '1' },
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should fall back to legacy when passthrough returns null', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { parameters: [] as any[] };
+            mockProcessTrigger
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetParameters, HostEvent.GetParameters, {},
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should fall back to legacy when passthrough returns undefined', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { iframeUrl: 'https://ts.example.com' };
+            mockProcessTrigger
+                .mockResolvedValueOnce(undefined)
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetIframeUrl, HostEvent.GetIframeUrl, {},
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should fall back when response array has no matching entries', async () => {
+            const { client } = createHostEventClient();
+            const legacyResponse = { v2Content: 'data' };
+            mockProcessTrigger
+                .mockResolvedValueOnce([{ refId: 'r1' }])
+                .mockResolvedValueOnce(legacyResponse);
+
+            const result = await callMethod(
+                client, UIPassthroughEvent.GetExportRequestForCurrentPinboard,
+                HostEvent.getExportRequestForCurrentPinboard, {},
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(result).toEqual(legacyResponse);
+        });
+
+        it('should throw when response has error field', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ error: 'Permission denied' }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetFilters, HostEvent.GetFilters, {},
+            )).rejects.toThrow('Permission denied');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should throw when response value contains errors field', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { errors: 'Invalid vizId' } }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetTML, HostEvent.GetTML, { vizId: 'bad' },
+            )).rejects.toThrow('Invalid vizId');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should throw when response value contains error field', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { error: 'Not found' } }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetTabs, HostEvent.GetTabs, {},
+            )).rejects.toThrow('Not found');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should stringify object errors instead of producing [object Object]', async () => {
+            const { client } = createHostEventClient();
+            const errorObj = { code: 403, reason: 'Forbidden' };
+            mockProcessTrigger.mockResolvedValue([{ error: errorObj }]);
+
+            await expect(callMethod(
+                client, UIPassthroughEvent.GetFilters, HostEvent.GetFilters, {},
+            )).rejects.toThrow(JSON.stringify(errorObj));
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should default payload to empty object when null', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { iframeUrl: 'https://ts.example.com' } }]);
+
+            await callMethod(
+                client, UIPassthroughEvent.GetIframeUrl, HostEvent.GetIframeUrl, null,
+            );
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.GetIframeUrl, parameters: {} },
+                undefined,
+            );
+        });
+    });
+
+    describe('UI passthrough available keys tests', () => {
+        const mockKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('triggerHostEvent Pin returns passthrough response', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockKeys())
+                .mockResolvedValueOnce([{ value: { pinboardId: 'lb1', tabId: 't1', vizId: 'v1' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.Pin, { newVizName: 'Viz' });
+
+            expect(result).toMatchObject({ pinboardId: 'lb1', liveboardId: 'lb1' });
+        });
+
+        it('triggerHostEvent GetAnswerSession returns session', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockKeys())
+                .mockResolvedValueOnce([{ value: { session: 's1' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+
+            expect(result).toEqual({ session: 's1' });
+        });
+
+        it('triggerHostEvent unmapped event uses fallback', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue({ data: 'legacy' });
+
+            const result = await client.triggerHostEvent('unknownEvent' as HostEvent, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.anything(), 'unknownEvent', mockThoughtSpotHost, {}, undefined);
+            expect(result).toEqual({ data: 'legacy' });
+        });
+
+        it('hostEventFallback delegates to processTrigger', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue({ ok: true });
+
+            const result = await client.hostEventFallback(HostEvent.Save, { x: 1 });
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(mockIframe, HostEvent.Save, mockThoughtSpotHost, { x: 1 }, undefined);
+            expect(result).toEqual({ ok: true });
+        });
+    });
 });