@thoughtspot/visual-embed-sdk 1.20.0-prerender.2 → 1.20.1

package/src/utils/answerService.spec.ts

@@ -11,9 +11,11 @@ describe('Unit test for getAnswerServiceInstance', () => {
 
     test('fetchData, when api giving answer data', async () => {
         const mockAnswerResponse = { data: {} };
-        global.fetch = jest.fn(() => Promise.resolve({
-            json: () => mockAnswerResponse,
-        }));
+        global.fetch = jest.fn(() =>
+            Promise.resolve({
+                json: () => mockAnswerResponse,
+            }),
+        );
         const answerService = getAnswerServiceInstance(
             session,
             query,

package/src/utils/answerService.ts

@@ -1,12 +1,5 @@
 import { SessionInterface, OperationType } from '../types';
 
-/**
- *
- * @param session
- * @param query
- * @param operation
- * @param thoughtSpotHost
- */
 export function getAnswerServiceInstance(
     session: SessionInterface,
     query: string,
@@ -17,21 +10,24 @@ export function getAnswerServiceInstance(
 
     const fetchQuery = async (variables: any) => {
         try {
-            const response = await fetch(`${thoughtSpotHost}/prism/?op=${operation}`, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json;charset=UTF-8',
-                    'x-requested-by': 'ThoughtSpot',
-                    accept: '*/*',
-                    'accept-language': 'en-us',
+            const response = await fetch(
+                `${thoughtSpotHost}/prism/?op=${operation}`,
+                {
+                    method: 'POST',
+                    headers: {
+                        'content-type': 'application/json;charset=UTF-8',
+                        'x-requested-by': 'ThoughtSpot',
+                        accept: '*/*',
+                        'accept-language': 'en-us',
+                    },
+                    body: JSON.stringify({
+                        operationName: operation,
+                        query,
+                        variables,
+                    }),
+                    credentials: 'include',
                 },
-                body: JSON.stringify({
-                    operationName: operation,
-                    query,
-                    variables,
-                }),
-                credentials: 'include',
-            });
+            );
             const result = await response.json();
             return result.data;
         } catch (error) {

package/src/utils/authService.spec.ts

@@ -19,28 +19,34 @@ describe('Unit test for authService', () => {
         global.fetch = window.fetch;
     });
     test('fetchSessionInfoService', async () => {
-        global.fetch = jest.fn(() => Promise.resolve({
-            json: () => ({ success: true }),
-            status: 200,
-            ok: true,
-        }));
+        global.fetch = jest.fn(() =>
+            Promise.resolve({
+                json: () => ({ success: true }),
+                status: 200,
+                ok: true,
+            }),
+        );
         const response = await fetchSessionInfoService(authVerificationUrl);
         expect(response.status).toBe(200);
         expect(fetch).toHaveBeenCalledTimes(1);
     });
 
     test('fetchAuthTokenService', async () => {
-        global.fetch = jest.fn(() => Promise.resolve({
-            text: () => ({ success: true }),
-            ok: true,
-        }));
+        global.fetch = jest.fn(() =>
+            Promise.resolve({
+                text: () => ({ success: true }),
+                ok: true,
+            }),
+        );
         const response = await fetchAuthTokenService(authEndpoint);
         expect(response.text()).toStrictEqual({ success: true });
         expect(fetch).toBeCalled();
     });
 
     test('fetchAuthService', async () => {
-        global.fetch = jest.fn(() => Promise.resolve({ success: true, ok: true }));
+        global.fetch = jest.fn(() =>
+            Promise.resolve({ success: true, ok: true }),
+        );
         await fetchAuthService(thoughtSpotHost, username, authToken);
         expect(fetch).toBeCalledWith(
             `${thoughtSpotHost}${EndPoints.TOKEN_LOGIN}?username=${username}&auth_token=${authToken}`,
@@ -52,33 +58,42 @@ describe('Unit test for authService', () => {
     });
 
     test('fetchAuthPostService', async () => {
-        global.fetch = jest.fn(() => Promise.resolve({ success: true, ok: true }));
+        global.fetch = jest.fn(() =>
+            Promise.resolve({ success: true, ok: true }),
+        );
         await fetchAuthPostService(thoughtSpotHost, username, authToken);
-        expect(fetch).toBeCalledWith(`${thoughtSpotHost}${EndPoints.TOKEN_LOGIN}`, {
-            method: 'POST',
-            credentials: 'include',
-            redirect: 'manual',
-            body: 'username=tsuser&auth_token=token',
-            headers: {
-                'content-type': 'application/x-www-form-urlencoded',
-                'x-requested-by': 'ThoughtSpot',
+        expect(fetch).toBeCalledWith(
+            `${thoughtSpotHost}${EndPoints.TOKEN_LOGIN}`,
+            {
+                method: 'POST',
+                credentials: 'include',
+                redirect: 'manual',
+                body: 'username=tsuser&auth_token=token',
+                headers: {
+                    'content-type': 'application/x-www-form-urlencoded',
+                    'x-requested-by': 'ThoughtSpot',
+                },
             },
-        });
+        );
     });
 
     test('fetchBasicAuthService called with manual redirect', async () => {
-        global.fetch = jest.fn(() => Promise.resolve({ success: true, ok: true }));
+        global.fetch = jest.fn(() =>
+            Promise.resolve({ success: true, ok: true }),
+        );
         await fetchBasicAuthService(thoughtSpotHost, username, password);
         expect(fetch).toBeCalled();
     });
 
     test('log error on API failures', async () => {
         jest.spyOn(global.console, 'error').mockImplementation(() => undefined);
-        global.fetch = jest.fn(() => Promise.resolve({
-            text: () => Promise.resolve('error'),
-            status: 500,
-            ok: false,
-        }));
+        global.fetch = jest.fn(() =>
+            Promise.resolve({
+                text: () => Promise.resolve('error'),
+                status: 500,
+                ok: false,
+            }),
+        );
         await fetchSessionInfoService(authVerificationUrl);
         expect(global.console.error).toHaveBeenCalledWith('Failure', 'error');
     });

package/src/utils/authService.ts

@@ -1,12 +1,10 @@
 // eslint-disable-next-line import/no-cycle
 import { EndPoints } from '../auth';
 
-/**
- *
- * @param url
- * @param options
- */
-function failureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
+function failureLoggedFetch(
+    url: string,
+    options: RequestInit = {},
+): Promise<Response> {
     return fetch(url, options).then(async (r) => {
         if (!r.ok && r.type !== 'opaqueredirect' && r.type !== 'opaque') {
             console.error('Failure', await r.text?.());
@@ -15,30 +13,20 @@ function failureLoggedFetch(url: string, options: RequestInit = {}): Promise<Res
     });
 }
 
-/**
- *
- * @param authVerificationUrl
- */
-export function fetchSessionInfoService(authVerificationUrl: string): Promise<any> {
+export function fetchSessionInfoService(
+    authVerificationUrl: string,
+): Promise<any> {
     return failureLoggedFetch(authVerificationUrl, {
         credentials: 'include',
     });
 }
 
-/**
- *
- * @param authEndpoint
- */
-export async function fetchAuthTokenService(authEndpoint: string): Promise<any> {
+export async function fetchAuthTokenService(
+    authEndpoint: string,
+): Promise<any> {
     return fetch(authEndpoint);
 }
 
-/**
- *
- * @param thoughtSpotHost
- * @param username
- * @param authToken
- */
 export async function fetchAuthService(
     thoughtSpotHost: string,
     username: string,
@@ -48,19 +36,12 @@ export async function fetchAuthService(
         `${thoughtSpotHost}${EndPoints.TOKEN_LOGIN}?username=${username}&auth_token=${authToken}`,
         {
             credentials: 'include',
-            // We do not want to follow the redirect, as it starts giving a CORS
-            // error
+            // We do not want to follow the redirect, as it starts giving a CORS error
             redirect: 'manual',
         },
     );
 }
 
-/**
- *
- * @param thoughtSpotHost
- * @param username
- * @param authToken
- */
 export async function fetchAuthPostService(
     thoughtSpotHost: string,
     username: string,
@@ -72,22 +53,15 @@ export async function fetchAuthPostService(
             'content-type': 'application/x-www-form-urlencoded',
             'x-requested-by': 'ThoughtSpot',
         },
-        body: `username=${encodeURIComponent(username)}&auth_token=${encodeURIComponent(
-            authToken,
-        )}`,
+        body: `username=${encodeURIComponent(
+            username,
+        )}&auth_token=${encodeURIComponent(authToken)}`,
         credentials: 'include',
-        // We do not want to follow the redirect, as it starts giving a CORS
-        // error
+        // We do not want to follow the redirect, as it starts giving a CORS error
         redirect: 'manual',
     });
 }
 
-/**
- *
- * @param thoughtSpotHost
- * @param username
- * @param password
- */
 export async function fetchBasicAuthService(
     thoughtSpotHost: string,
     username: string,
@@ -99,16 +73,16 @@ export async function fetchBasicAuthService(
             'content-type': 'application/x-www-form-urlencoded',
             'x-requested-by': 'ThoughtSpot',
         },
-        body: `username=${encodeURIComponent(username)}&password=${encodeURIComponent(password)}`,
+        body: `username=${encodeURIComponent(
+            username,
+        )}&password=${encodeURIComponent(password)}`,
         credentials: 'include',
     });
 }
 
-/**
- *
- * @param thoughtSpotHost
- */
-export async function fetchLogoutService(thoughtSpotHost: string): Promise<any> {
+export async function fetchLogoutService(
+    thoughtSpotHost: string,
+): Promise<any> {
     return failureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
         credentials: 'include',
         method: 'POST',

package/src/utils/processData.spec.ts

@@ -26,17 +26,24 @@ describe('Unit test for process data', () => {
                 operation: OperationType.GetChartWithData,
             },
         };
-        jest.spyOn(answerServiceInstance, 'getAnswerServiceInstance').mockReturnValue(
-            answerService,
-        );
+        jest.spyOn(
+            answerServiceInstance,
+            'getAnswerServiceInstance',
+        ).mockReturnValue(answerService);
         expect(
-            processDataInstance.processCustomAction(processChartData, thoughtSpotHost),
+            processDataInstance.processCustomAction(
+                processChartData,
+                thoughtSpotHost,
+            ),
         ).toStrictEqual(processChartData);
     });
 
     test('ProcessData, when Action is CustomAction', async () => {
         const processedData = { type: EmbedEvent.CustomAction };
-        jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
+        jest.spyOn(
+            processDataInstance,
+            'processCustomAction',
+        ).mockImplementation(async () => ({}));
         expect(
             processDataInstance.processEventData(
                 EmbedEvent.CustomAction,
@@ -49,12 +56,20 @@ describe('Unit test for process data', () => {
 
     test('ProcessData, when Action is non CustomAction', () => {
         const processedData = { type: EmbedEvent.Data };
-        jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
+        jest.spyOn(
+            processDataInstance,
+            'processCustomAction',
+        ).mockImplementation(async () => ({}));
         jest.spyOn(
             answerServiceInstance,
             'getAnswerServiceInstance',
         ).mockImplementation(async () => ({}));
-        processDataInstance.processEventData(EmbedEvent.Data, processedData, thoughtSpotHost, null);
+        processDataInstance.processEventData(
+            EmbedEvent.Data,
+            processedData,
+            thoughtSpotHost,
+            null,
+        );
         expect(processDataInstance.processCustomAction).not.toBeCalled();
     });
 
@@ -67,7 +82,9 @@ describe('Unit test for process data', () => {
         const e = { type: EmbedEvent.AuthInit, data: sessionInfo };
         jest.spyOn(auth, 'initSession').mockReturnValue(null);
         jest.spyOn(base, 'notifyAuthSuccess');
-        expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
+        expect(
+            processDataInstance.processEventData(e.type, e, '', null),
+        ).toEqual({
             type: e.type,
             data: {
                 userGUID: sessionInfo.userGUID,
@@ -86,10 +103,14 @@ describe('Unit test for process data', () => {
         });
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
-        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
-            type: e.type,
-        });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual(
+            {
+                type: e.type,
+            },
+        );
+        expect(base.notifyAuthFailure).toBeCalledWith(
+            auth.AuthFailureType.NO_COOKIE_ACCESS,
+        );
         expect(window.alert).toBeCalled();
         expect(el.innerHTML).toBe('Hello');
     });
@@ -104,10 +125,14 @@ describe('Unit test for process data', () => {
         jest.spyOn(window, 'alert').mockReset();
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
         const el: any = {};
-        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
-            type: e.type,
-        });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.NO_COOKIE_ACCESS);
+        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual(
+            {
+                type: e.type,
+            },
+        );
+        expect(base.notifyAuthFailure).toBeCalledWith(
+            auth.AuthFailureType.NO_COOKIE_ACCESS,
+        );
         expect(window.alert).not.toBeCalled();
         expect(el.innerHTML).toBe('Hello');
     });
@@ -119,10 +144,14 @@ describe('Unit test for process data', () => {
             loginFailedMessage: 'Hello',
         });
         const el: any = {};
-        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
-            type: e.type,
-        });
-        expect(base.notifyAuthFailure).toBeCalledWith(auth.AuthFailureType.OTHER);
+        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual(
+            {
+                type: e.type,
+            },
+        );
+        expect(base.notifyAuthFailure).toBeCalledWith(
+            auth.AuthFailureType.OTHER,
+        );
         expect(el.innerHTML).toBe('Hello');
     });
 
@@ -134,9 +163,11 @@ describe('Unit test for process data', () => {
             authType: AuthType.None,
         });
         const el: any = {};
-        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
-            type: e.type,
-        });
+        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual(
+            {
+                type: e.type,
+            },
+        );
         expect(base.notifyAuthFailure).not.toBeCalled();
         expect(el.innerHTML).not.toBe('Hello');
     });
@@ -152,9 +183,11 @@ describe('Unit test for process data', () => {
         const e = { type: EmbedEvent.AuthLogout };
         jest.spyOn(base, 'notifyLogout');
         const el: any = {};
-        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
-            type: e.type,
-        });
+        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual(
+            {
+                type: e.type,
+            },
+        );
         expect(base.notifyLogout).toBeCalled();
         expect(el.innerHTML).toBe('Hello');
         expect(base.getEmbedConfig().autoLogin).toBe(false);

package/src/utils/processData.ts

@@ -9,19 +9,20 @@ import { AuthFailureType, initSession } from '../auth';
 import { AuthType, EmbedEvent, OperationType } from '../types';
 import { getAnswerServiceInstance } from './answerService';
 
-/**
- *
- * @param e
- * @param thoughtSpotHost
- */
 export function processCustomAction(e: any, thoughtSpotHost: string) {
     if (
-        [OperationType.GetChartWithData, OperationType.GetTableWithHeadlineData].includes(
-            e.data?.operation,
-        )
+        [
+            OperationType.GetChartWithData,
+            OperationType.GetTableWithHeadlineData,
+        ].includes(e.data?.operation)
     ) {
         const { session, query, operation } = e.data;
-        const answerService = getAnswerServiceInstance(session, query, operation, thoughtSpotHost);
+        const answerService = getAnswerServiceInstance(
+            session,
+            query,
+            operation,
+            thoughtSpotHost,
+        );
         return {
             ...e,
             answerService,
@@ -30,10 +31,6 @@ export function processCustomAction(e: any, thoughtSpotHost: string) {
     return e;
 }
 
-/**
- *
- * @param e
- */
 function processAuthInit(e: any) {
     // Store user session details sent by app.
     initSession(e.data);
@@ -48,13 +45,11 @@ function processAuthInit(e: any) {
     };
 }
 
-/**
- *
- * @param e
- * @param containerEl
- */
 function processNoCookieAccess(e: any, containerEl: Element) {
-    const { loginFailedMessage, suppressNoCookieAccessAlert } = getEmbedConfig();
+    const {
+        loginFailedMessage,
+        suppressNoCookieAccessAlert,
+    } = getEmbedConfig();
     if (!suppressNoCookieAccessAlert) {
         // eslint-disable-next-line no-alert
         alert(
@@ -67,11 +62,6 @@ function processNoCookieAccess(e: any, containerEl: Element) {
     return e;
 }
 
-/**
- *
- * @param e
- * @param containerEl
- */
 function processAuthFailure(e: any, containerEl: Element) {
     const { loginFailedMessage, authType } = getEmbedConfig();
     if (authType !== AuthType.None) {
@@ -82,11 +72,6 @@ function processAuthFailure(e: any, containerEl: Element) {
     return e;
 }
 
-/**
- *
- * @param e
- * @param containerEl
- */
 function processAuthLogout(e: any, containerEl: Element) {
     const { loginFailedMessage } = getEmbedConfig();
     // eslint-disable-next-line no-param-reassign
@@ -96,13 +81,6 @@ function processAuthLogout(e: any, containerEl: Element) {
     return e;
 }
 
-/**
- *
- * @param type
- * @param e
- * @param thoughtSpotHost
- * @param containerEl
- */
 export function processEventData(
     type: EmbedEvent,
     e: any,

package/src/utils/processTrigger.spec.ts

@@ -17,7 +17,12 @@ describe('Unit test for processTrigger', () => {
         const messageType = HostEvent.Reload;
         const thoughtSpotHost = 'http://localhost:3000';
         const data = {};
-        _processTriggerInstance.processTrigger(iFrameElement, messageType, thoughtSpotHost, data);
+        _processTriggerInstance.processTrigger(
+            iFrameElement,
+            messageType,
+            thoughtSpotHost,
+            data,
+        );
         expect(divFrame.childNodes[0]).not.toBe(iFrameElement);
     });
 

package/src/utils/processTrigger.ts

@@ -3,8 +3,6 @@ import { HostEvent } from '../types';
 
 /**
  * Reloads the ThoughtSpot iframe.
- *
- * @param iFrame
  */
 function reload(iFrame: HTMLIFrameElement) {
     const oldFrame = iFrame.cloneNode();
@@ -15,13 +13,6 @@ function reload(iFrame: HTMLIFrameElement) {
 
 /**
  * Post Iframe message.
- *
- * @param iFrame
- * @param message
- * @param message.type
- * @param message.data
- * @param thoughtSpotHost
- * @param channel
  */
 function postIframeMessage(
     iFrame: HTMLIFrameElement,
@@ -29,18 +20,13 @@ function postIframeMessage(
     thoughtSpotHost: string,
     channel?: MessageChannel,
 ) {
-    return iFrame.contentWindow.postMessage(message, thoughtSpotHost, [channel?.port2]);
+    return iFrame.contentWindow.postMessage(message, thoughtSpotHost, [
+        channel?.port2,
+    ]);
 }
 
 const TRIGGER_TIMEOUT = 30000;
 
-/**
- *
- * @param iFrame
- * @param messageType
- * @param thoughtSpotHost
- * @param data
- */
 export function processTrigger(
     iFrame: HTMLIFrameElement,
     messageType: HostEvent,
@@ -68,6 +54,11 @@ export function processTrigger(
             res(new Error(ERROR_MESSAGE.TRIGGER_TIMED_OUT));
         }, TRIGGER_TIMEOUT);
 
-        return postIframeMessage(iFrame, { type: messageType, data }, thoughtSpotHost, channel);
+        return postIframeMessage(
+            iFrame,
+            { type: messageType, data },
+            thoughtSpotHost,
+            channel,
+        );
     });
 }

package/src/utils.spec.ts

@@ -77,7 +77,9 @@ describe('unit test for utils', () => {
         expect(appendToUrlHash('http://myhost:3000', 'hashFrag')).toBe(
             'http://myhost:3000#hashFrag',
         );
-        expect(appendToUrlHash('http://xyz.com/#foo', 'bar')).toBe('http://xyz.com/#foobar');
+        expect(appendToUrlHash('http://xyz.com/#foo', 'bar')).toBe(
+            'http://xyz.com/#foobar',
+        );
     });
 
     describe('getRedirectURL', () => {
@@ -85,7 +87,9 @@ describe('unit test for utils', () => {
             expect(getRedirectUrl('http://myhost:3000', 'hashFrag')).toBe(
                 'http://myhost:3000#hashFrag',
             );
-            expect(getRedirectUrl('http://xyz.com/#foo', 'bar')).toBe('http://xyz.com/#foobar');
+            expect(getRedirectUrl('http://xyz.com/#foo', 'bar')).toBe(
+                'http://xyz.com/#foobar',
+            );
         });
 
         test('Should return correct value when path is set', () => {
@@ -93,13 +97,13 @@ describe('unit test for utils', () => {
                 get: () => 'http://myhost:3000',
             });
 
-            expect(getRedirectUrl('http://myhost:3000/', 'hashFrag', '/bar')).toBe(
-                'http://myhost:3000/bar#hashFrag',
-            );
+            expect(
+                getRedirectUrl('http://myhost:3000/', 'hashFrag', '/bar'),
+            ).toBe('http://myhost:3000/bar#hashFrag');
 
-            expect(getRedirectUrl('http://myhost:3000/#/foo', 'hashFrag', '#/bar')).toBe(
-                'http://myhost:3000/#/barhashFrag',
-            );
+            expect(
+                getRedirectUrl('http://myhost:3000/#/foo', 'hashFrag', '#/bar'),
+            ).toBe('http://myhost:3000/#/barhashFrag');
         });
     });