@thoughtspot/visual-embed-sdk 1.42.1-alpha.1 → 1.42.1-alpha.3

package/src/api-intercept.spec.ts

@@ -0,0 +1,147 @@
+import { getInterceptInitData, processApiIntercept, handleInterceptEvent, processLegacyInterceptResponse } from './api-intercept';
+import { EmbedEvent, InterceptedApiType } from './types';
+import * as embedCfg from './embed/embedConfig';
+import * as cfg from './config';
+import { logger } from './utils/logger';
+
+describe('api-intercept', () => {
+  beforeEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+  });
+
+  describe('getInterceptInitData', () => {
+    test('returns disabled when not enabled in either config', () => {
+      const init = getInterceptInitData({} as any, {} as any);
+      expect(init).toEqual({ enableApiIntercept: false });
+    });
+
+    test('merges urls and expands api types, formats with host', () => {
+      jest.spyOn(embedCfg, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'http://tshost' } as any);
+      jest.spyOn(cfg, 'getThoughtSpotHost').mockReturnValue('http://tshost');
+
+      const embedConfig: any = { enableApiIntercept: true };
+      const viewConfig: any = { interceptUrls: [InterceptedApiType.METADATA, '/custom/path'] };
+
+      const init = getInterceptInitData(embedConfig, viewConfig);
+
+      expect(init.enableApiIntercept).toBe(true);
+      expect(init.interceptUrls).toEqual(expect.arrayContaining([
+        'http://tshost/prism/?op=CreateAnswerSession',
+        'http://tshost/prism/?op=GetV2SourceDetail',
+        'http://tshost/custom/path',
+      ]));
+    });
+
+    test('honors InterceptedApiType.ALL and interceptTimeout', () => {
+      const embedConfig: any = { enableApiIntercept: true, interceptTimeout: 2500 };
+      const viewConfig: any = { interceptUrls: [InterceptedApiType.ALL] };
+
+      const init = getInterceptInitData(embedConfig, viewConfig);
+
+      expect(init).toEqual({
+        enableApiIntercept: true,
+        interceptUrls: [InterceptedApiType.ALL],
+        interceptTimeout: 2500,
+      });
+    });
+
+    test('legacy flag isOnBeforeGetVizDataInterceptEnabled adds ANSWER_DATA', () => {
+      jest.spyOn(embedCfg, 'getEmbedConfig').mockReturnValue({ thoughtSpotHost: 'http://tshost' } as any);
+      jest.spyOn(cfg, 'getThoughtSpotHost').mockReturnValue('http://tshost');
+
+      const embedConfig: any = { enableApiIntercept: true };
+      const viewConfig: any = { isOnBeforeGetVizDataInterceptEnabled: true, interceptUrls: [] };
+
+      const init = getInterceptInitData(embedConfig, viewConfig);
+
+      // Should expand to concrete ANSWER_DATA URLs
+      expect(init.interceptUrls).toEqual(expect.arrayContaining([
+        'http://tshost/prism/?op=GetChartWithData',
+        'http://tshost/prism/?op=GetTableWithHeadlineData',
+      ]));
+    });
+
+    test('viewConfig enableApiIntercept=false overrides embed config', () => {
+      const embedConfig: any = { enableApiIntercept: true };
+      const viewConfig: any = { enableApiIntercept: false };
+      const init = getInterceptInitData(embedConfig, viewConfig);
+      expect(init).toEqual({ enableApiIntercept: false });
+    });
+  });
+
+  describe('processApiIntercept', () => {
+    test('parses data JSON string', async () => {
+      const result = await processApiIntercept({ data: JSON.stringify({ foo: 'bar' }) });
+      expect(result).toEqual({ foo: 'bar' });
+    });
+  });
+
+  describe('handleInterceptEvent', () => {
+    test('emits error on body parse failure', async () => {
+      const executeEvent = jest.fn();
+      const loggerErrSpy = jest.spyOn(logger, 'error').mockImplementation(() => undefined as any);
+      await handleInterceptEvent({
+        eventData: { data: 'not-a-json' },
+        executeEvent,
+        embedConfig: {} as any,
+        viewConfig: {} as any,
+        getUnsavedAnswerTml: jest.fn(),
+      });
+      expect(executeEvent).toHaveBeenCalledWith(EmbedEvent.Error, { error: 'Error parsing api intercept body' });
+      loggerErrSpy.mockReset();
+    });
+
+    test('calls getUnsavedAnswerTml and emits legacy + ApiIntercept events when applicable', async () => {
+      const executeEvent = jest.fn();
+      const getUnsavedAnswerTml = jest.fn().mockResolvedValue({ tml: 'TML_STRING' });
+
+      const eventPayload = {
+        input: '/prism/?op=GetChartWithData',
+        init: {
+          body: JSON.stringify({
+            variables: {
+              session: { sessionId: 'S1' },
+              contextBookId: 'V1',
+            },
+          }),
+        },
+      };
+
+      await handleInterceptEvent({
+        eventData: { data: JSON.stringify(eventPayload) },
+        executeEvent,
+        embedConfig: {} as any,
+        viewConfig: { isOnBeforeGetVizDataInterceptEnabled: true } as any,
+        getUnsavedAnswerTml,
+      });
+
+      expect(getUnsavedAnswerTml).toHaveBeenCalledWith({ sessionId: 'S1', vizId: 'V1' });
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.OnBeforeGetVizDataIntercept,
+        { data: { data: { tml: 'TML_STRING' } } },
+      );
+      expect(executeEvent).toHaveBeenCalledWith(
+        EmbedEvent.ApiIntercept,
+        expect.objectContaining({ input: '/prism/?op=GetChartWithData' }),
+      );
+    });
+  });
+
+  describe('processLegacyInterceptResponse', () => {
+    test('wraps legacy error payload as expected', () => {
+      const payload = { data: { errorText: 'Title', errorDescription: 'Desc' } } as any;
+      const res = processLegacyInterceptResponse(payload);
+      expect(Array.isArray(res)).toBe(true);
+      expect(res[0]).toEqual(expect.objectContaining({
+        errors: [
+          expect.objectContaining({
+            errorObj: expect.objectContaining({ title: 'Title', desc: 'Desc' }),
+          }),
+        ],
+      }));
+    });
+  });
+});
+
+

package/src/api-intercept.ts

@@ -118,17 +118,20 @@ export const processLegacyInterceptResponse = (payload: any) => {
     const title = payload?.data?.errorText;
     const desc = payload?.data?.errorDescription;
 
-    const payloadToSend = [{
-        data: {},
-        errors: [
-            {
-                errorObj: {
-                    title,
-                    desc
+    const payloadToSend = {
+        execute: payload?.data?.execute,
+        body: {
+            errors: [
+                {
+                    errorObj: {
+                        title,
+                        desc
+                    }
                 }
-            }
-        ],
-    }];
+            ],
+        },
+        status: 200,
+    };
 
-    return payloadToSend;
+    return { data: payloadToSend };
 }

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

@@ -61,6 +61,14 @@ import { UIPassthroughEvent } from './hostEventClient/contracts';
 import * as sessionInfoService from '../utils/sessionInfoService';
 import * as authToken from '../authToken';
 
+// Mock api-intercept by default to avoid altering existing APP_INIT payload
+// expectations
+jest.mock('../api-intercept', () => ({
+    getInterceptInitData: jest.fn(() => ({})),
+    handleInterceptEvent: jest.fn(),
+    processLegacyInterceptResponse: jest.fn((x: any) => x),
+}));
+
 jest.mock('../utils/processTrigger');
 
 const mockProcessTrigger = processTrigger as jest.Mock;
@@ -3457,3 +3465,100 @@ describe('Unit test case for ts embed', () => {
         });
     });
 });
+
+describe('API Intercept integration in TsEmbed', () => {
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+        jest.clearAllMocks();
+    });
+
+    test('APP_INIT includes API intercept init data when enabled', async () => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+            enableApiIntercept: true,
+            interceptTimeout: 1234,
+        } as any);
+
+        // Include intercept setup via viewConfig too
+        const { InterceptedApiType } = require('../types');
+
+        // Override mocked getInterceptInitData for this test only
+        const apiInterceptModule = require('../api-intercept');
+        apiInterceptModule.getInterceptInitData.mockReturnValue({
+            enableApiIntercept: true,
+            interceptTimeout: 1234,
+            interceptUrls: [
+                'http://tshost/prism/?op=CreateAnswerSession',
+                'http://tshost/prism/?op=GetV2SourceDetail',
+                'http://tshost/custom/path',
+            ],
+        });
+        const searchEmbed = new SearchEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            enableApiIntercept: true,
+            interceptUrls: [InterceptedApiType.METADATA, '/custom/path'],
+        } as any);
+
+        searchEmbed.render();
+
+        const mockPort: any = { postMessage: jest.fn() };
+        const mockEmbedEventPayload = { type: EmbedEvent.APP_INIT, data: {} };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+        });
+
+        await executeAfterWait(() => {
+            expect(mockPort.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    type: EmbedEvent.APP_INIT,
+                    data: expect.objectContaining({
+                        enableApiIntercept: true,
+                        interceptTimeout: 1234,
+                        interceptUrls: expect.arrayContaining([
+                            expect.stringContaining('CreateAnswerSession'),
+                            expect.stringContaining('GetV2SourceDetail'),
+                            expect.stringContaining('custom/path'),
+                        ]),
+                    }),
+                }),
+            );
+        });
+    });
+
+    test('ApiIntercept event delegates to handleInterceptEvent and bypasses default callbacks', async () => {
+        init({ thoughtSpotHost: 'tshost', authType: AuthType.None } as any);
+
+        const apiInterceptModule = require('../api-intercept');
+        const handleInterceptSpy = jest.spyOn(apiInterceptModule, 'handleInterceptEvent').mockResolvedValue(undefined);
+
+        const searchEmbed = new SearchEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            enableApiIntercept: true,
+        } as any);
+
+        const apiCb = jest.fn();
+        searchEmbed.on(EmbedEvent.ApiIntercept as any, apiCb as any);
+
+        searchEmbed.render();
+
+        const mockPort: any = { postMessage: jest.fn() };
+        const eventPayload = {
+            type: EmbedEvent.ApiIntercept,
+            data: JSON.stringify({ input: '/prism/?op=GetChartWithData', init: { body: '{}' } }),
+        };
+
+        await executeAfterWait(() => {
+            const iframe = getIFrameEl();
+            postMessageToParent(iframe.contentWindow, eventPayload, mockPort);
+        });
+
+        await executeAfterWait(() => {
+            expect(handleInterceptSpy).toHaveBeenCalled();
+            expect(apiCb).not.toHaveBeenCalled();
+        });
+    });
+});
+