@thoughtspot/visual-embed-sdk 1.25.0 → 1.26.0-token-cache.0

package/src/auth.spec.ts

@@ -4,6 +4,7 @@ import * as checkReleaseVersionInBetaInstance from './utils';
 import * as mixPanelService from './mixpanel-service';
 import { AuthType, EmbedEvent } from './types';
 import { executeAfterWait } from './test/test-utils';
+import { resetCachedAuthToken } from './authToken';
 
 const thoughtSpotHost = 'http://localhost:3000';
 const username = 'tsuser';
@@ -88,7 +89,7 @@ export const embedConfig: any = {
         password,
         authType: AuthType.None,
     },
-    doCookielessAuth: (token :string) => ({
+    doCookielessAuth: (token: string) => ({
         thoughtSpotHost,
         username,
         authType: AuthType.TrustedAuthTokenCookieless,
@@ -114,9 +115,11 @@ describe('Unit test for auth', () => {
     beforeEach(() => {
         global.fetch = window.fetch;
     });
-
+    afterEach(() => {
+        resetCachedAuthToken();
+    });
     test('endpoints, SAML_LOGIN_TEMPLATE', () => {
-        const ssoTemplateUrl = authInstance.EndPoints.SAML_LOGIN_TEMPLATE(thoughtSpotHost);
+        const ssoTemplateUrl = authService.EndPoints.SAML_LOGIN_TEMPLATE(thoughtSpotHost);
         expect(ssoTemplateUrl).toBe(`/callosum/v1/saml/login?targetURLPath=${thoughtSpotHost}`);
     });
 
@@ -173,6 +176,7 @@ describe('Unit test for auth', () => {
         jest.spyOn(authService, 'fetchAuthService').mockImplementation(() => Promise.resolve({
             status: 200,
         }));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'));
         expect(authService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthService).toBeCalledWith(
@@ -189,11 +193,12 @@ describe('Unit test for auth', () => {
             status: 200,
             ok: true,
         }));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthFailureWithoutGetAuthToken);
         await executeAfterWait(() => {
             expect(authInstance.loggedInStatus).toBe(true);
             expect(authService.fetchSessionInfoService).toBeCalled();
-            expect(authService.fetchAuthService).toBeCalledWith(thoughtSpotHost, username, 'abc');
+            expect(authService.fetchAuthService).toBeCalledWith(thoughtSpotHost, username, 'authToken2');
         });
     });
 
@@ -208,9 +213,11 @@ describe('Unit test for auth', () => {
             status: 200,
             ok: true,
         }));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken3'));
 
         try {
+            jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(false);
             await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken3'));
             expect(false).toBe(true);
         } catch (e) {
@@ -236,6 +243,7 @@ describe('Unit test for auth', () => {
             status: 200,
             ok: true,
         }));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         const isLoggedIn = await authInstance.doTokenAuth(embedConfig.doTokenAuthWithCookieDetect);
         expect(authService.fetchSessionInfoService).toHaveBeenCalledTimes(2);
         expect(isLoggedIn).toBe(false);
@@ -256,6 +264,7 @@ describe('Unit test for auth', () => {
             status: 200,
             type: 'opaqueredirect',
         }));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         expect(await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'))).toBe(
             true,
         );
@@ -395,6 +404,7 @@ describe('Unit test for auth', () => {
 
     describe('doOIDCAuth', () => {
         afterEach(() => {
+            resetCachedAuthToken();
             delete global.window;
             global.window = Object.create(originalWindow);
             global.window.open = jest.fn();
@@ -463,15 +473,13 @@ describe('Unit test for auth', () => {
     });
 
     it('doCookielessTokenAuth should resolve to true if valid token is passed', async () => {
-        jest.spyOn(authService, 'fetchAuthTokenService').mockResolvedValueOnce(new Response(JSON.stringify({ token: 'testToken' }), { status: 200 }));
         jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(new Response('', { status: 200 }));
         const isLoggedIn = await authInstance.doCookielessTokenAuth(embedConfig.doCookielessAuth('testToken'));
         expect(isLoggedIn).toBe(true);
     });
 
     it('doCookielessTokenAuth should resolve to false if valid token is not passed', async () => {
-        jest.spyOn(authService, 'fetchAuthTokenService').mockResolvedValueOnce(new Response(JSON.stringify({ token: 'testToken' }), { status: 200 }));
-        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(new Response('', { status: 400 }));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(false);
         const isLoggedIn = await authInstance.doCookielessTokenAuth(embedConfig.doCookielessAuth('testToken'));
         expect(isLoggedIn).toBe(false);
     });
@@ -480,4 +488,36 @@ describe('Unit test for auth', () => {
         authInstance.setAuthEE(testObject as any);
         expect(authInstance.getAuthEE()).toBe(testObject);
     });
+    it('getSessionDetails returns the correct details given sessionInfo', () => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+
+        const details = authInstance.getSessionDetails({
+            userGUID: '1234',
+            releaseVersion: '1',
+            configInfo: {
+                mixpanelConfig: {
+                    devSdkKey: 'devKey',
+                    prodSdkKey: 'prodKey',
+                    production: false,
+                },
+            },
+        });
+        expect(details).toEqual(expect.objectContaining({
+            mixpanelToken: 'devKey',
+        }));
+
+        const details2 = authInstance.getSessionDetails({
+            configInfo: {
+                mixpanelConfig: {
+                    devSdkKey: 'devKey',
+                    prodSdkKey: 'prodKey',
+                    production: true,
+                },
+            },
+        });
+        expect(details2).toEqual(expect.objectContaining({
+            mixpanelToken: 'prodKey',
+        }));
+    });
 });

package/src/auth.ts

@@ -4,16 +4,15 @@ import {
     AuthType, DOMSelector, EmbedConfig, EmbedEvent, Param,
 } from './types';
 import { getDOMNode, getRedirectUrl } from './utils';
-// eslint-disable-next-line import/no-cycle
 import {
     fetchSessionInfoService,
-    fetchAuthTokenService,
     fetchAuthService,
     fetchBasicAuthService,
     fetchLogoutService,
     fetchAuthPostService,
-    verifyTokenService,
+    EndPoints,
 } from './utils/authService';
+import { getAuthenticationToken, resetCachedAuthToken } from './authToken';
 
 // eslint-disable-next-line import/no-mutable-exports
 export let loggedInStatus = false;
@@ -30,18 +29,6 @@ let releaseVersion = '';
 
 export const SSO_REDIRECTION_MARKER_GUID = '5e16222e-ef02-43e9-9fbd-24226bf3ce5b';
 
-export const EndPoints = {
-    AUTH_VERIFICATION: '/callosum/v1/session/info',
-    SAML_LOGIN_TEMPLATE: (targetUrl: string) => `/callosum/v1/saml/login?targetURLPath=${targetUrl}`,
-    OIDC_LOGIN_TEMPLATE: (targetUrl: string) => `/callosum/v1/oidc/login?targetURLPath=${targetUrl}`,
-    TOKEN_LOGIN: '/callosum/v1/session/login/token',
-    BASIC_LOGIN: '/callosum/v1/session/login',
-    LOGOUT: '/callosum/v1/session/logout',
-    EXECUTE_TML: '/api/rest/2.0/metadata/tml/import',
-    EXPORT_TML: '/api/rest/2.0/metadata/tml/export',
-    IS_ACTIVE: '/callosum/v1/session/isactive',
-};
-
 interface sessionInfoInterface {
     userGUID: any;
     isPublicUser: any;
@@ -216,6 +203,7 @@ export const initSession = (sessionDetails: sessionInfoInterface) => {
 };
 
 export const getSessionDetails = (sessionInfoResp: any): sessionInfoInterface => {
+    console.log('helloooo');
     const devMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.devSdkKey;
     const prodMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.prodSdkKey;
     const mixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.production
@@ -270,22 +258,6 @@ export function getSessionInfo(): Promise<sessionInfoInterface> {
     return sessionInfoPromise;
 }
 
-const DUPLICATE_TOKEN_ERR = 'Duplicate token, please issue a new token every time getAuthToken callback is called.'
-    + 'See https://developers.thoughtspot.com/docs/?pageid=embed-auth#trusted-auth-embed for more details.';
-let prevAuthToken: string = null;
-/**
- *
- * @param authtoken
- */
-function alertForDuplicateToken(authtoken: string) {
-    if (prevAuthToken === authtoken) {
-        // eslint-disable-next-line no-alert
-        alert(DUPLICATE_TOKEN_ERR);
-        throw new Error(DUPLICATE_TOKEN_ERR);
-    }
-    prevAuthToken = authtoken;
-}
-
 /**
  * Check if we are stuck at the SSO redirect URL
  */
@@ -305,19 +277,6 @@ function removeSSORedirectUrlMarker(): void {
     window.location.hash = window.location.hash.replace(SSO_REDIRECTION_MARKER_GUID, '');
 }
 
-export const getAuthenticationToken = async (embedConfig: EmbedConfig): Promise<any> => {
-    const { authEndpoint, getAuthToken } = embedConfig;
-    let authToken = null;
-    if (getAuthToken) {
-        authToken = await getAuthToken();
-        alertForDuplicateToken(authToken);
-    } else {
-        const response = await fetchAuthTokenService(authEndpoint);
-        authToken = await response.text();
-    }
-    return authToken;
-};
-
 /**
  * Perform token based authentication
  *
@@ -362,13 +321,12 @@ export const doCookielessTokenAuth = async (embedConfig: EmbedConfig): Promise<b
     }
     try {
         const authToken = await getAuthenticationToken(embedConfig);
-        const response = await verifyTokenService(embedConfig.thoughtSpotHost, authToken);
-        if (!response.ok) return false;
-    } catch (e) {
-        return false;
+        if (authToken) return true;
+    } catch {
+        // return false if getAuthenticationToken fails
     }
 
-    return true;
+    return false;
 };
 
 /**
@@ -514,7 +472,8 @@ export const doOIDCAuth = async (embedConfig: EmbedConfig) => {
 
 export const logout = async (embedConfig: EmbedConfig): Promise<boolean> => {
     const { thoughtSpotHost } = embedConfig;
-    const response = await fetchLogoutService(thoughtSpotHost);
+    await fetchLogoutService(thoughtSpotHost);
+    resetCachedAuthToken();
     loggedInStatus = false;
     return loggedInStatus;
 };

package/src/authToken.ts

@@ -0,0 +1,60 @@
+import { EmbedConfig } from './types';
+import { fetchAuthTokenService, verifyTokenService } from './utils/authService';
+
+const DUPLICATE_TOKEN_ERR = 'Duplicate token, please issue a new token every time getAuthToken callback is called.'
+    + 'See https://developers.thoughtspot.com/docs/?pageid=embed-auth#trusted-auth-embed for more details.';
+
+const INVALID_TOKEN_ERR = 'Invalid token received form token callback or authToken endpoint.';
+
+let cachedAuthToken: string | null = null;
+
+// This method can be used to get the authToken using the embedConfig
+export const getAuthenticationToken = async (embedConfig: EmbedConfig): Promise<string> => {
+    if (cachedAuthToken) {
+        try {
+            const isCachedTokenStillValid = await validateAuthToken(embedConfig, cachedAuthToken);
+            if (isCachedTokenStillValid) return cachedAuthToken;
+        } catch {
+            // Continue to get a new token if validation fails
+        }
+    }
+
+    const { authEndpoint, getAuthToken } = embedConfig;
+
+    let authToken = null;
+    if (getAuthToken) {
+        authToken = await getAuthToken();
+    } else {
+        const response = await fetchAuthTokenService(authEndpoint);
+        authToken = await response.text();
+    }
+
+    // this will throw error if the token is not valid
+    await validateAuthToken(embedConfig, authToken);
+
+    cachedAuthToken = authToken;
+    return authToken;
+};
+
+const validateAuthToken = async (embedConfig: EmbedConfig, authToken: string): Promise<boolean> => {
+    try {
+        const isTokenValid = await verifyTokenService(embedConfig.thoughtSpotHost, authToken);
+        if (isTokenValid) return true;
+    } catch {
+        return false;
+    }
+
+    if (cachedAuthToken && cachedAuthToken === authToken) {
+        if (!embedConfig.suppressErrorAlerts) {
+            // eslint-disable-next-line no-alert
+            alert(DUPLICATE_TOKEN_ERR);
+        }
+        throw new Error(DUPLICATE_TOKEN_ERR);
+    } else {
+        throw new Error(INVALID_TOKEN_ERR);
+    }
+};
+
+export const resetCachedAuthToken = (): void => {
+    cachedAuthToken = null;
+};

package/src/config.spec.ts

@@ -18,7 +18,7 @@ describe('getThoughtSpotHost', () => {
             });
         };
 
-        expect(testFn).toThrow(TypeError);
+        expect(testFn).toThrow(Error);
     });
 
     test('IP address/hostname only', () => {

package/src/config.ts

@@ -27,6 +27,9 @@ const urlRegex = new RegExp(
  * @param config
  */
 export const getThoughtSpotHost = (config: EmbedConfig): string => {
+    if (!config.thoughtSpotHost) {
+        throw new Error(ERROR_MESSAGE.INVALID_THOUGHTSPOT_HOST);
+    }
     const urlParts = config.thoughtSpotHost.match(urlRegex);
     if (!urlParts) {
         throw new Error(ERROR_MESSAGE.INVALID_THOUGHTSPOT_HOST);

package/src/embed/base.spec.ts

@@ -3,6 +3,8 @@
 import EventEmitter from 'eventemitter3';
 import { EmbedConfig } from '../index';
 import * as auth from '../auth';
+import * as authService from '../utils/authService';
+import * as authTokenService from '../authToken';
 import * as index from '../index';
 import * as base from './base';
 import {
@@ -10,7 +12,6 @@ import {
     getAllIframeEl,
     getDocumentBody,
     getRootEl,
-    getRootEl2,
     getIFrameSrc,
 } from '../test/test-utils';
 
@@ -107,7 +108,7 @@ describe('Base TS Embed', () => {
         };
         await index.executeTML(data);
         expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.EXECUTE_TML}`,
+            `http://${thoughtSpotHost}${authService.EndPoints.EXECUTE_TML}`,
             {
                 credentials: 'include',
                 headers: {
@@ -132,7 +133,7 @@ describe('Base TS Embed', () => {
             autoLogin: true,
         });
         const embedConfig = base.getEmbedConfig();
-        const authToken = await auth.getAuthenticationToken(embedConfig);
+        const authToken = await authTokenService.getAuthenticationToken(embedConfig);
         const data: base.executeTMLInput = {
             metadata_tmls: ['{"liveboard":{"name":"Parameters Liveboard"}}'],
             import_policy: 'PARTIAL',
@@ -140,7 +141,7 @@ describe('Base TS Embed', () => {
         };
         await index.executeTML(data);
         expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.EXECUTE_TML}`,
+            `http://${thoughtSpotHost}${authService.EndPoints.EXECUTE_TML}`,
             {
                 credentials: 'include',
                 headers: expect.objectContaining({
@@ -210,7 +211,7 @@ describe('Base TS Embed', () => {
         };
         await index.exportTML(data);
         expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.EXPORT_TML}`,
+            `http://${thoughtSpotHost}${authService.EndPoints.EXPORT_TML}`,
             {
                 credentials: 'include',
                 headers: {
@@ -351,7 +352,7 @@ describe('Base TS Embed', () => {
         });
         index.logout();
         expect(window.fetch).toHaveBeenCalledWith(
-            `http://${thoughtSpotHost}${auth.EndPoints.LOGOUT}`,
+            `http://${thoughtSpotHost}${authService.EndPoints.LOGOUT}`,
             {
                 credentials: 'include',
                 headers: {

package/src/embed/base.ts

@@ -10,6 +10,8 @@
  */
 import EventEmitter from 'eventemitter3';
 import uniq from 'lodash/uniq';
+import { getAuthenticationToken } from '../authToken';
+import { EndPoints } from '../utils/authService';
 import { getThoughtSpotHost } from '../config';
 import { AuthType, EmbedConfig, PrefetchFeatures } from '../types';
 import {
@@ -24,8 +26,6 @@ import {
     notifyLogout,
     setAuthEE,
     AuthEventEmitter,
-    EndPoints,
-    getAuthenticationToken,
 } from '../auth';
 import { uploadMixpanelEvent, MIXPANEL_EVENT } from '../mixpanel-service';
 
@@ -351,7 +351,6 @@ export const executeTML = async (data: executeTMLInput): Promise<any> => {
     console.error(error);
   });
  * ```
- *
  * @version SDK: 1.23.0 | ThoughtSpot: 9.4.0.cl
  * @group Global methods
  */

package/src/embed/search.ts

@@ -69,10 +69,6 @@ export interface SearchViewConfig
      * using raw answer data.
      */
     hideResults?: boolean;
-    /**
-     * If set to true, expands all the data sources panel.
-     */
-    expandAllDataSource?: boolean;
     /**
      * If set to true, the Search Assist feature is enabled.
      *
@@ -178,7 +174,6 @@ export class SearchEmbed extends TsEmbed {
     protected getEmbedParams(): string {
         const {
             hideResults,
-            expandAllDataSource,
             enableSearchAssist,
             forceTable,
             searchOptions,
@@ -274,7 +269,8 @@ export class SearchEmbed extends TsEmbed {
             if (
                 checkReleaseVersionInBeta(
                     getReleaseVersion(),
-                    getEmbedConfig().suppressSearchEmbedBetaWarning,
+                    getEmbedConfig().suppressSearchEmbedBetaWarning
+                     || getEmbedConfig().suppressErrorAlerts,
                 )
             ) {
                 alert(ERROR_MESSAGE.SEARCHEMBED_BETA_WRANING_MESSAGE);

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

@@ -1,4 +1,5 @@
 /* eslint-disable dot-notation */
+import { resetCachedAuthToken } from '../authToken';
 import {
     AuthType,
     init,
@@ -34,6 +35,7 @@ import * as mixpanelInstance from '../mixpanel-service';
 import * as authInstance from '../auth';
 import * as baseInstance from './base';
 import { MIXPANEL_EVENT } from '../mixpanel-service';
+import * as authService from '../utils/authService';
 
 const defaultViewConfig = {
     frameParams: {
@@ -89,8 +91,51 @@ describe('Unit test case for ts embed', () => {
 
     afterEach(() => {
         jest.clearAllMocks();
+        resetCachedAuthToken();
     });
 
+    describe('AuthExpire embedEvent in cookieless authentication authType', () => {
+        beforeAll(() => {
+            jest.spyOn(authInstance, 'doCookielessTokenAuth').mockResolvedValueOnce(true);
+            jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
+            init({
+                thoughtSpotHost: 'tshost',
+                customizations: customisations,
+                customCssUrl: 'http://localhost:5000',
+                authType: AuthType.TrustedAuthTokenCookieless,
+                getAuthToken: () => Promise.resolve('test_auth_token2'),
+            });
+        });
+
+        test('check for new authToken based on getAuthToken function', async () => {
+            const mockEmbedEventPayload = {
+                type: EmbedEvent.AuthExpire,
+                data: {},
+            };
+            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+            jest.spyOn(baseInstance, 'notifyAuthFailure');
+            jest.spyOn(baseInstance, 'handleAuth');
+
+            searchEmbed.render();
+            const mockPort: any = {
+                postMessage: jest.fn(),
+            };
+            await executeAfterWait(() => {
+                const iframe = getIFrameEl();
+                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
+            });
+            await executeAfterWait(() => {
+                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
+                    authInstance.AuthFailureType.EXPIRY,
+                );
+                expect(baseInstance.handleAuth).not.toHaveBeenCalled();
+                expect(mockPort.postMessage).toHaveBeenCalledWith({
+                    type: EmbedEvent.AuthExpire,
+                    data: { authToken: 'test_auth_token2' },
+                });
+            });
+        });
+    });
     describe('Called Embed event status for start and end', () => {
         beforeAll(() => {
             init({
@@ -483,7 +528,15 @@ describe('Unit test case for ts embed', () => {
             });
         });
 
+        afterEach(() => {
+            baseInstance.reset();
+        });
+
         test('check for authToken based on getAuthToken function', async () => {
+            const a = jest.spyOn(authService, 'verifyTokenService');
+            a.mockResolvedValue(true);
+
+            // authVerifyMock.mockResolvedValue(true);
             const mockEmbedEventPayload = {
                 type: EmbedEvent.APP_INIT,
                 data: {},
@@ -511,47 +564,8 @@ describe('Unit test case for ts embed', () => {
                     },
                 });
             });
-        });
-    });
 
-    describe('AuthExpire embedEvent in cookieless authentication authType', () => {
-        beforeAll(() => {
-            jest.spyOn(authInstance, 'doCookielessTokenAuth').mockResolvedValueOnce(true);
-            init({
-                thoughtSpotHost: 'tshost',
-                customizations: customisations,
-                customCssUrl: 'http://localhost:5000',
-                authType: AuthType.TrustedAuthTokenCookieless,
-                getAuthToken: () => Promise.resolve('test_auth_token2'),
-            });
-        });
-
-        test('check for new authToken based on getAuthToken function', async () => {
-            const mockEmbedEventPayload = {
-                type: EmbedEvent.AuthExpire,
-                data: {},
-            };
-            const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
-            jest.spyOn(baseInstance, 'notifyAuthFailure');
-            jest.spyOn(baseInstance, 'handleAuth');
-            searchEmbed.render();
-            const mockPort: any = {
-                postMessage: jest.fn(),
-            };
-            await executeAfterWait(() => {
-                const iframe = getIFrameEl();
-                postMessageToParent(iframe.contentWindow, mockEmbedEventPayload, mockPort);
-            });
-            await executeAfterWait(() => {
-                expect(baseInstance.notifyAuthFailure).toBeCalledWith(
-                    authInstance.AuthFailureType.EXPIRY,
-                );
-                expect(baseInstance.handleAuth).not.toHaveBeenCalled();
-                expect(mockPort.postMessage).toHaveBeenCalledWith({
-                    type: EmbedEvent.AuthExpire,
-                    data: { authToken: 'test_auth_token2' },
-                });
-            });
+            jest.spyOn(authService, 'verifyTokenService').mockClear();
         });
     });
 

package/src/embed/ts-embed.ts

@@ -9,6 +9,7 @@
 
 import isEqual from 'lodash/isEqual';
 
+import { getAuthenticationToken } from '../authToken';
 import { AnswerService } from '../utils/graphql/answerService/answerService';
 import {
     getEncodedQueryParamsString,
@@ -61,7 +62,7 @@ import {
     handleAuth,
     notifyAuthFailure,
 } from './base';
-import { AuthFailureType, getAuthenticationToken } from '../auth';
+import { AuthFailureType } from '../auth';
 
 const { version } = pkgInfo;
 

package/src/react/index.spec.tsx

@@ -199,35 +199,6 @@ describe('React Components', () => {
             ).toBe(true);
             expect(containerSibling.querySelector('div')).toBe(null);
         });
-
-        it('Should have the correct container element', async () => {
-            const { container } = render(
-                <LiveboardEmbed liveboardId="abcd" className="def" />,
-            );
-
-            await waitFor(() => getIFrameEl(container));
-            expect(container.querySelector('div')).not.toBe(null);
-            expect(
-                container.querySelector('div').classList.contains('def'),
-            ).toBe(true);
-
-            const { container: containerSibling } = render(
-                <LiveboardEmbed
-                    liveboardId="abcd"
-                    className="def"
-                    insertAsSibling={true}
-                />,
-            );
-            await waitFor(() => getIFrameEl(containerSibling));
-            expect(containerSibling.querySelector('span')).not.toBe(null);
-            expect(containerSibling.querySelector('span').style.position).toBe(
-                'absolute',
-            );
-            expect(
-                getIFrameEl(containerSibling).classList.contains('def'),
-            ).toBe(true);
-            expect(containerSibling.querySelector('div')).toBe(null);
-        });
     });
 
     describe('SearchBarEmbed', () => {

package/src/tokenizedFetch.ts

@@ -0,0 +1,16 @@
+import { getAuthenticationToken } from './authToken';
+import { getEmbedConfig } from './embed/base';
+import { AuthType } from './types';
+
+export const tokenizedFetch: typeof fetch = async (input, init) : Promise<Response> => {
+    const req = new Request(input, init);
+    const embedConfig = getEmbedConfig();
+    if (embedConfig.authType !== AuthType.TrustedAuthTokenCookieless) {
+        return fetch(req);
+    }
+    const authToken = await getAuthenticationToken(embedConfig);
+    if (authToken) {
+        req.headers.append('Authorization', `Bearer ${authToken}`);
+    }
+    return fetch(req);
+};