@thoughtspot/visual-embed-sdk 1.42.0 → 1.42.1-alpha.2

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

@@ -0,0 +1,134 @@
+import { getThoughtSpotHost } from "./config";
+import { getEmbedConfig } from "./embed/embedConfig";
+import { InterceptedApiType, BaseViewConfig, EmbedConfig, InterceptV2Flags, EmbedEvent } from "./types";
+import { logger } from "./utils/logger";
+
+
+const defaultUrls: Record<Exclude<InterceptedApiType, InterceptedApiType.ALL>, string[]> = {
+    [InterceptedApiType.METADATA]: [
+        '/prism/?op=CreateAnswerSession',
+        '/prism/?op=GetV2SourceDetail',
+    ] as string[],
+    [InterceptedApiType.ANSWER_DATA]: [
+        '/prism/?op=GetChartWithData',
+        '/prism/?op=GetTableWithHeadlineData',
+    ] as string[],
+    [InterceptedApiType.LIVEBOARD_DATA]: [
+        '/prism/?op=LoadContextBook'
+    ] as string[],
+};
+
+const formatInterceptUrl = (url: string) => {
+    const host = getThoughtSpotHost(getEmbedConfig());
+    if (url.startsWith('/')) return `${host}${url}`;
+    return url;
+}
+
+export const processApiIntercept = async (eventData: any) => {
+
+    return JSON.parse(eventData.data);
+}
+
+interface LegacyInterceptFlags {
+    isOnBeforeGetVizDataInterceptEnabled: boolean;
+}
+
+const processInterceptUrls = (interceptUrls: (string | InterceptedApiType)[]) => {
+    let processedUrls = [...interceptUrls];
+    Object.entries(defaultUrls).forEach(([apiType, apiTypeUrls]) => {
+        if (!processedUrls.includes(apiType)) return;
+        processedUrls = processedUrls.filter(url => url !== apiType);
+        processedUrls = [...processedUrls, ...apiTypeUrls];
+    })
+    return processedUrls.map(url => formatInterceptUrl(url));
+}
+export const getInterceptInitData = (embedConfig: EmbedConfig, viewConfig: BaseViewConfig): InterceptV2Flags => {
+
+    const enableApiIntercept = (embedConfig.enableApiIntercept || viewConfig.enableApiIntercept) && (viewConfig.enableApiIntercept !== false);
+
+    if (!enableApiIntercept) return {
+        enableApiIntercept: false,
+    };
+
+    const combinedUrls = [...(embedConfig.interceptUrls || []), ...(viewConfig.interceptUrls || [])];
+
+    if ((viewConfig as LegacyInterceptFlags).isOnBeforeGetVizDataInterceptEnabled) {
+        combinedUrls.push(InterceptedApiType.ANSWER_DATA);
+    }
+
+    const shouldInterceptAll = combinedUrls.includes(InterceptedApiType.ALL);
+    const interceptUrls = shouldInterceptAll ? [InterceptedApiType.ALL] : processInterceptUrls(combinedUrls);
+
+    const interceptTimeout = embedConfig.interceptTimeout || viewConfig.interceptTimeout;
+
+    return {
+        interceptUrls,
+        interceptTimeout,
+        enableApiIntercept,
+    };
+}
+
+/**
+ * 
+ * @param fetchInit 
+ */
+const parseInterceptData = (eventDataString: any) => {
+
+    try {
+        const { input, init } = JSON.parse(eventDataString);
+
+        init.body = JSON.parse(init.body);
+
+        const parsedInit = { input, init };
+        return [parsedInit, null];
+    } catch (error) {
+        return [null, error];
+    }
+}
+
+export const handleInterceptEvent = async (params: { eventData: any, executeEvent: (eventType: EmbedEvent, data: any) => void, embedConfig: EmbedConfig, viewConfig: BaseViewConfig, getUnsavedAnswerTml: (props: { sessionId?: string, vizId?: string }) => Promise<{ tml: string }> }) => {
+
+    const { eventData, executeEvent, viewConfig, getUnsavedAnswerTml } = params;
+
+    const [interceptData, bodyParseError] = parseInterceptData(eventData.data);
+
+    if (bodyParseError) {
+        executeEvent(EmbedEvent.Error, {
+            error: 'Error parsing api intercept body',
+        });
+        logger.error('Error parsing request body', bodyParseError);
+        return;
+    }
+
+    const { input: requestUrl, init } = interceptData;
+
+    const sessionId = init?.body?.variables?.session?.sessionId;
+    const vizId = init?.body?.variables?.contextBookId;
+
+    if (defaultUrls.ANSWER_DATA.includes(requestUrl) && (viewConfig as LegacyInterceptFlags).isOnBeforeGetVizDataInterceptEnabled) {
+        const answerTml = await getUnsavedAnswerTml({ sessionId, vizId });
+        executeEvent(EmbedEvent.OnBeforeGetVizDataIntercept, { data: { data: answerTml } });
+    }
+
+    executeEvent(EmbedEvent.ApiIntercept, interceptData);
+}
+
+export const processLegacyInterceptResponse = (payload: any) => {
+
+    const title = payload?.data?.errorText;
+    const desc = payload?.data?.errorDescription;
+
+    const payloadToSend = {
+        execute: payload?.data?.execute,
+        errors: [
+            {
+                errorObj: {
+                    title,
+                    desc
+                }
+            }
+        ],
+    };
+
+    return { data : payloadToSend };
+}

package/src/embed/app.spec.ts

@@ -358,6 +358,34 @@ describe('App embed tests', () => {
         });
     });
 
+    test('should set isLinkParametersEnabled to true in url', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            isLinkParametersEnabled: true,
+        } as AppViewConfig);
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&isLinkParametersEnabled=true${defaultParamsPost}#/home`,
+            );
+        });
+    });
+    
+    test('should set isLinkParametersEnabled to false in url', async () => {
+        const appEmbed = new AppEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            isLinkParametersEnabled: false,
+        } as AppViewConfig);
+        appEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true&profileAndHelpInNavBarHidden=false&isLinkParametersEnabled=false${defaultParamsPost}#/home`,
+            );
+        });
+    });
+
     test('should set liveboardXLSXCSVDownload to true in url', async () => {
         const appEmbed = new AppEmbed(getRootEl(), {
             ...defaultViewConfig,

package/src/embed/app.ts

@@ -19,6 +19,7 @@ import {
     AllEmbedViewConfig,
 } from '../types';
 import { V1Embed } from './ts-embed';
+import { getInterceptInitData } from '../api-intercept';
 
 /**
  * Pages within the ThoughtSpot app that can be embedded.
@@ -663,6 +664,7 @@ export class AppEmbed extends V1Embed {
             liveboardXLSXCSVDownload = false,
             isLiveboardStylingAndGroupingEnabled,
             isPNGInScheduledEmailsEnabled = false,
+            isLinkParametersEnabled,
         } = this.viewConfig;
 
         let params: any = {};
@@ -727,7 +729,9 @@ export class AppEmbed extends V1Embed {
             params[Param.enableAskSage] = enableAskSage;
         }
 
-        if (isOnBeforeGetVizDataInterceptEnabled) {
+        const { enableApiIntercept } = getInterceptInitData(this.embedConfig, this.viewConfig);
+
+        if (isOnBeforeGetVizDataInterceptEnabled && !enableApiIntercept) {
 
             params[
                 Param.IsOnBeforeGetVizDataInterceptEnabled
@@ -750,6 +754,10 @@ export class AppEmbed extends V1Embed {
             params[Param.isPNGInScheduledEmailsEnabled] = isPNGInScheduledEmailsEnabled;
         }
 
+        if (isLinkParametersEnabled !== undefined) {
+            params[Param.isLinkParametersEnabled] = isLinkParametersEnabled;
+        }
+
         params[Param.DataPanelV2Enabled] = dataPanelV2;
         params[Param.HideHomepageLeftNav] = hideHomepageLeftNav;
         params[Param.ModularHomeExperienceEnabled] = modularHomeExperience;

package/src/embed/hostEventClient/contracts.ts

@@ -7,6 +7,7 @@ export enum UIPassthroughEvent {
   GetAvailableUIPassthroughs = 'getAvailableUiPassthroughs',
   GetAnswerConfig = 'getAnswerPageConfig',
   GetLiveboardConfig = 'getPinboardPageConfig',
+  GetUnsavedAnswerTML = 'getUnsavedAnswerTML',
 }
 
 // UI Passthrough Contract
@@ -63,6 +64,15 @@ export type UIPassthroughContractBase = {
     request: any;
     response: any;
   };
+  [UIPassthroughEvent.GetUnsavedAnswerTML]: {
+    request: {
+      sessionId?: string;
+      vizId?: string;
+    };
+    response: {
+      tml: string;
+    };
+  };
 };
 
 // UI Passthrough Request and Response

package/src/embed/liveboard.spec.ts

@@ -183,6 +183,36 @@ describe('Liveboard/viz embed tests', () => {
         });
     });
 
+    test('should set isLinkParametersEnabled to true in url', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            isLinkParametersEnabled: true,
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isLinkParametersEnabled=true${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
+    test('should set isLinkParametersEnabled to false in url', async () => {
+        const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
+            isLinkParametersEnabled: false,
+            ...defaultViewConfig,
+            liveboardId,
+        } as LiveboardViewConfig);
+        liveboardEmbed.render();
+        await executeAfterWait(() => {
+            expectUrlMatchesWithParams(
+                getIFrameSrc(),
+                `http://${thoughtSpotHost}/?embedApp=true${defaultParams}&isLinkParametersEnabled=false${prefixParams}#/embed/viz/${liveboardId}`,
+            );
+        });
+    });
+
     test('should set visible actions as empty array', async () => {
         const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
             visibleActions: [],

package/src/embed/liveboard.ts

@@ -477,6 +477,7 @@ export class LiveboardEmbed extends V1Embed {
             isLiveboardStylingAndGroupingEnabled,
             isPNGInScheduledEmailsEnabled = false,
             showSpotterLimitations,
+            isLinkParametersEnabled,
         } = this.viewConfig;
 
         const preventLiveboardFilterRemoval = this.viewConfig.preventLiveboardFilterRemoval
@@ -552,6 +553,10 @@ export class LiveboardEmbed extends V1Embed {
             params[Param.ShowSpotterLimitations] = showSpotterLimitations;
         }
 
+        if (isLinkParametersEnabled !== undefined) {
+            params[Param.isLinkParametersEnabled] = isLinkParametersEnabled;
+        }
+
         params[Param.LiveboardHeaderSticky] = isLiveboardHeaderSticky;
         params[Param.LiveboardHeaderV2] = isLiveboardCompactHeaderEnabled;
         params[Param.ShowLiveboardVerifiedBadge] = showLiveboardVerifiedBadge;

package/src/embed/search.ts

@@ -26,6 +26,7 @@ import { ERROR_MESSAGE } from '../errors';
 import { getAuthPromise } from './base';
 import { getReleaseVersion } from '../auth';
 import { getEmbedConfig } from './embedConfig';
+import { getInterceptInitData } from '../api-intercept';
 
 /**
  * Configuration for search options.
@@ -442,7 +443,8 @@ export class SearchEmbed extends TsEmbed {
             queryParams[Param.HideSearchBar] = true;
         }
 
-        if (isOnBeforeGetVizDataInterceptEnabled) {
+        const { enableApiIntercept } = getInterceptInitData(this.embedConfig, this.viewConfig);
+        if (isOnBeforeGetVizDataInterceptEnabled && !enableApiIntercept) {
 
             queryParams[Param.IsOnBeforeGetVizDataInterceptEnabled] = isOnBeforeGetVizDataInterceptEnabled;
         }