@thoughtspot/visual-embed-sdk 1.26.1 → 1.26.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@thoughtspot/visual-embed-sdk",
-    "version": "1.26.1",
+    "version": "1.26.3",
     "description": "ThoughtSpot Embed SDK",
     "module": "lib/src/index.js",
     "main": "dist/tsembed.js",
@@ -38,7 +38,7 @@
     "size-limit": [
         {
             "path": "dist/tsembed.js",
-            "limit": "43 kB"
+            "limit": "44 kB"
         }
     ],
     "scripts": {

package/src/auth.spec.ts

@@ -1,9 +1,11 @@
 import * as authInstance from './auth';
-import * as authService from './utils/authService';
+import * as authService from './utils/authService/authService';
+import * as tokenAuthService from './utils/authService/tokenizedAuthService';
 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';
@@ -94,7 +96,6 @@ export const embedConfig: any = {
         authType: AuthType.TrustedAuthTokenCookieless,
         getAuthToken: jest.fn(() => Promise.resolve(token)),
     }),
-
 };
 
 const originalWindow = window;
@@ -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}`);
     });
 
@@ -150,31 +153,28 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is loggedIn', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(
-            async () => ({
-                json: () => mockSessionInfo,
-                status: 200,
-            }),
-        );
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(async () => ({
+            json: () => mockSessionInfo,
+            status: 200,
+        }));
         jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
         jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
-        await authInstance.doTokenAuth(
-            embedConfig.doTokenAuthSuccess('authToken'),
-        );
-        expect(authService.fetchSessionInfoService).toBeCalled();
+        await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken'));
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authInstance.loggedInStatus).toBe(true);
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken have response', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),
         }));
         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(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -183,22 +183,27 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken not present, isLoggedIn should called', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => Promise.resolve({ text: () => Promise.resolve('abc') }));
         jest.spyOn(authService, 'fetchAuthService').mockImplementation(() => Promise.resolve({
             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(tokenAuthService.fetchSessionInfoService).toBeCalled();
+            expect(authService.fetchAuthService).toBeCalledWith(
+                thoughtSpotHost,
+                username,
+                'authToken2',
+            );
         });
     });
 
     test('doTokenAuth: Should raise error when duplicate token is used', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService').mockResolvedValue({
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockResolvedValue({
             status: 401,
         });
         jest.spyOn(window, 'alert').mockClear();
@@ -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) {
@@ -224,7 +231,7 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: Should set loggedInStatus if detectThirdPartyCookieAccess is true and the second info call fails', async () => {
-        jest.spyOn(authService, 'fetchSessionInfoService')
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService')
             .mockResolvedValue({
                 status: 401,
             })
@@ -236,14 +243,15 @@ 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(tokenAuthService.fetchSessionInfoService).toHaveBeenCalledTimes(2);
         expect(isLoggedIn).toBe(false);
     });
 
     test('doTokenAuth: when user is not loggedIn & fetchAuthPostService failed than fetchAuthService should call', async () => {
         jest.spyOn(window, 'alert').mockImplementation(() => undefined);
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => false);
+        jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => false);
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),
         }));
@@ -256,10 +264,11 @@ describe('Unit test for auth', () => {
             status: 200,
             type: 'opaqueredirect',
         }));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
         expect(await authInstance.doTokenAuth(embedConfig.doTokenAuthSuccess('authToken2'))).toBe(
             true,
         );
-        expect(authService.fetchSessionInfoService).toBeCalled();
+        expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
         expect(authService.fetchAuthPostService).toBeCalledWith(
             thoughtSpotHost,
             username,
@@ -278,35 +287,31 @@ describe('Unit test for auth', () => {
         });
 
         it('when user is loggedIn', async () => {
-            spyOn(
-                checkReleaseVersionInBetaInstance,
-                'checkReleaseVersionInBeta',
-            );
+            spyOn(checkReleaseVersionInBetaInstance, 'checkReleaseVersionInBeta');
             jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
             jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
-            jest.spyOn(
-                authService,
-                'fetchSessionInfoService',
-            ).mockImplementation(async () => ({
-                json: () => mockSessionInfo,
-                status: 200,
-            }));
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(
+                async () => ({
+                    json: () => mockSessionInfo,
+                    status: 200,
+                }),
+            );
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
             expect(authInstance.getSessionDetails).toBeCalled();
             expect(authInstance.initSession).toBeCalled();
         });
 
         it('when user is not loggedIn', async () => {
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             jest.spyOn(authService, 'fetchBasicAuthService').mockImplementation(() => ({
                 status: 200,
                 ok: true,
             }));
 
             await authInstance.doBasicAuth(embedConfig.doBasicAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authService.fetchBasicAuthService).toBeCalled();
             expect(authInstance.loggedInStatus).toBe(true);
         });
@@ -328,22 +333,24 @@ describe('Unit test for auth', () => {
                     hash: '',
                 },
             });
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(async () => ({
-                json: () => mockSessionInfo,
-                status: 200,
-            }));
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(
+                async () => ({
+                    json: () => mockSessionInfo,
+                    status: 200,
+                }),
+            );
             jest.spyOn(authInstance, 'getSessionDetails').mockReturnValue(mockSessionInfo);
             jest.spyOn(authInstance, 'initSession').mockReturnValue(null);
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(true);
         });
 
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });
@@ -355,9 +362,9 @@ describe('Unit test for auth', () => {
                     hash: '',
                 },
             });
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doSamlAuth(embedConfig.doSamlAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(global.window.location.href).toBe(samalLoginUrl);
         });
 
@@ -370,7 +377,7 @@ describe('Unit test for auth', () => {
             });
             spyOn(authInstance, 'samlCompletionPromise');
             global.window.open = jest.fn();
-            jest.spyOn(authService, 'fetchSessionInfoService')
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService')
                 .mockImplementationOnce(() => Promise.reject())
                 .mockImplementationOnce(async () => ({
                     json: () => mockSessionInfo,
@@ -387,7 +394,7 @@ describe('Unit test for auth', () => {
             document.getElementById('ts-auth-btn').click();
             window.postMessage({ type: EmbedEvent.SAMLComplete }, '*');
             await authInstance.samlCompletionPromise;
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(authInstance.getSessionDetails).toBeCalled();
             expect(authInstance.initSession).toBeCalled();
         });
@@ -395,6 +402,7 @@ describe('Unit test for auth', () => {
 
     describe('doOIDCAuth', () => {
         afterEach(() => {
+            resetCachedAuthToken();
             delete global.window;
             global.window = Object.create(originalWindow);
             global.window.open = jest.fn();
@@ -402,9 +410,9 @@ describe('Unit test for auth', () => {
         });
 
         it('when user is not loggedIn & isAtSSORedirectUrl is true', async () => {
-            jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
+            jest.spyOn(tokenAuthService, 'fetchSessionInfoService').mockImplementation(() => Promise.reject());
             await authInstance.doOIDCAuth(embedConfig.doOidcAuth);
-            expect(authService.fetchSessionInfoService).toBeCalled();
+            expect(tokenAuthService.fetchSessionInfoService).toBeCalled();
             expect(window.location.hash).toBe('');
             expect(authInstance.loggedInStatus).toBe(false);
         });
@@ -463,16 +471,18 @@ 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'));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(true);
+        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 }));
-        const isLoggedIn = await authInstance.doCookielessTokenAuth(embedConfig.doCookielessAuth('testToken'));
+        jest.spyOn(authService, 'verifyTokenService').mockResolvedValueOnce(false);
+        const isLoggedIn = await authInstance.doCookielessTokenAuth(
+            embedConfig.doCookielessAuth('testToken'),
+        );
         expect(isLoggedIn).toBe(false);
     });
     it('get AuthEE should return proper value', () => {
@@ -495,9 +505,11 @@ describe('Unit test for auth', () => {
                 },
             },
         });
-        expect(details).toEqual(expect.objectContaining({
-            mixpanelToken: 'devKey',
-        }));
+        expect(details).toEqual(
+            expect.objectContaining({
+                mixpanelToken: 'devKey',
+            }),
+        );
 
         const details2 = authInstance.getSessionDetails({
             configInfo: {
@@ -508,8 +520,10 @@ describe('Unit test for auth', () => {
                 },
             },
         });
-        expect(details2).toEqual(expect.objectContaining({
-            mixpanelToken: 'prodKey',
-        }));
+        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;
@@ -270,22 +257,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 +276,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
  *
@@ -360,15 +318,17 @@ export const doCookielessTokenAuth = async (embedConfig: EmbedConfig): Promise<b
     if (!authEndpoint && !getAuthToken) {
         throw new Error('Either auth endpoint or getAuthToken function must be provided');
     }
+    let authSuccess = false;
     try {
         const authToken = await getAuthenticationToken(embedConfig);
-        const response = await verifyTokenService(embedConfig.thoughtSpotHost, authToken);
-        if (!response.ok) return false;
-    } catch (e) {
-        return false;
+        if (authToken) {
+            authSuccess = true;
+        }
+    } catch {
+        authSuccess = false;
     }
 
-    return true;
+    return authSuccess;
 };
 
 /**
@@ -462,11 +422,7 @@ const doSSOAuth = async (embedConfig: EmbedConfig, ssoEndPoint: string): Promise
 
     const ssoURL = `${thoughtSpotHost}${ssoEndPoint}`;
     if (embedConfig.inPopup) {
-        await samlPopupFlow(
-            ssoURL,
-            embedConfig.authTriggerContainer,
-            embedConfig.authTriggerText,
-        );
+        await samlPopupFlow(ssoURL, embedConfig.authTriggerContainer, embedConfig.authTriggerText);
         loggedInStatus = await isLoggedIn(thoughtSpotHost);
         return;
     }
@@ -514,7 +470,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,66 @@
+import { EmbedConfig } from './types';
+import { fetchAuthTokenService, verifyTokenService } from './utils/authService/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) {
+        let isCachedTokenStillValid;
+        try {
+            isCachedTokenStillValid = await validateAuthToken(embedConfig, cachedAuthToken, true);
+        } catch {
+            isCachedTokenStillValid = false;
+        }
+
+        if (isCachedTokenStillValid) return cachedAuthToken;
+    }
+
+    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,
+    suppressAlert?: boolean,
+): Promise<boolean> => {
+    try {
+        const isTokenValid = await verifyTokenService(embedConfig.thoughtSpotHost, authToken);
+        if (isTokenValid) return true;
+    } catch {
+        return false;
+    }
+
+    if (cachedAuthToken && cachedAuthToken === authToken) {
+        if (!embedConfig.suppressErrorAlerts && !suppressAlert) {
+            // 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/embed/app.ts

@@ -202,10 +202,9 @@ export class AppEmbed extends V1Embed {
 
     private defaultHeight = '100%';
 
-    protected embedComponentType = 'AppEmbed';
-
     // eslint-disable-next-line no-useless-constructor
     constructor(domSelector: DOMSelector, viewConfig: AppViewConfig) {
+        viewConfig.embedComponentType = 'AppEmbed';
         super(domSelector, viewConfig);
         if (this.viewConfig.fullHeight === true) {
             this.on(EmbedEvent.RouteChange, this.setIframeHeightForNonEmbedLiveboard);