@thoughtspot/visual-embed-sdk 1.20.2 → 1.20.3

package/src/utils/answerService.spec.ts

@@ -11,11 +11,9 @@ 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,5 +1,12 @@
 import { SessionInterface, OperationType } from '../types';
 
+/**
+ *
+ * @param session
+ * @param query
+ * @param operation
+ * @param thoughtSpotHost
+ */
 export function getAnswerServiceInstance(
     session: SessionInterface,
     query: string,
@@ -10,24 +17,21 @@ 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',
-                    },
-                    body: JSON.stringify({
-                        operationName: operation,
-                        query,
-                        variables,
-                    }),
-                    credentials: 'include',
+            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',
+            });
             const result = await response.json();
             return result.data;
         } catch (error) {

package/src/utils/authService.spec.ts

@@ -19,34 +19,28 @@ 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}`,
@@ -58,42 +52,33 @@ 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,10 +1,12 @@
 // eslint-disable-next-line import/no-cycle
 import { EndPoints } from '../auth';
 
-function failureLoggedFetch(
-    url: string,
-    options: RequestInit = {},
-): Promise<Response> {
+/**
+ *
+ * @param url
+ * @param options
+ */
+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?.());
@@ -13,20 +15,30 @@ function failureLoggedFetch(
     });
 }
 
-export function fetchSessionInfoService(
-    authVerificationUrl: string,
-): Promise<any> {
+/**
+ *
+ * @param authVerificationUrl
+ */
+export function fetchSessionInfoService(authVerificationUrl: string): Promise<any> {
     return failureLoggedFetch(authVerificationUrl, {
         credentials: 'include',
     });
 }
 
-export async function fetchAuthTokenService(
-    authEndpoint: string,
-): Promise<any> {
+/**
+ *
+ * @param authEndpoint
+ */
+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,
@@ -36,12 +48,19 @@ 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,
@@ -53,15 +72,22 @@ 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,
@@ -73,16 +99,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',
     });
 }
 
-export async function fetchLogoutService(
-    thoughtSpotHost: string,
-): Promise<any> {
+/**
+ *
+ * @param thoughtSpotHost
+ */
+export async function fetchLogoutService(thoughtSpotHost: string): Promise<any> {
     return failureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
         credentials: 'include',
         method: 'POST',

package/src/utils/processData.spec.ts

@@ -26,24 +26,17 @@ 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,
@@ -56,20 +49,12 @@ 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();
     });
 
@@ -82,9 +67,7 @@ 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,
@@ -103,14 +86,10 @@ 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');
     });
@@ -125,14 +104,10 @@ 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');
     });
@@ -144,14 +119,10 @@ 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');
     });
 
@@ -163,11 +134,9 @@ 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');
     });
@@ -183,11 +152,9 @@ 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,20 +9,19 @@ 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,
@@ -31,6 +30,10 @@ 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);
@@ -45,11 +48,13 @@ 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(
@@ -62,6 +67,11 @@ 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) {
@@ -72,6 +82,11 @@ 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
@@ -81,6 +96,13 @@ 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,12 +17,7 @@ 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,6 +3,8 @@ import { HostEvent } from '../types';
 
 /**
  * Reloads the ThoughtSpot iframe.
+ *
+ * @param iFrame
  */
 function reload(iFrame: HTMLIFrameElement) {
     const oldFrame = iFrame.cloneNode();
@@ -13,6 +15,13 @@ 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,
@@ -20,13 +29,18 @@ 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,
@@ -54,11 +68,6 @@ 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,9 +77,7 @@ 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', () => {
@@ -87,9 +85,7 @@ 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', () => {
@@ -97,13 +93,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',
+            );
         });
     });