@thoughtspot/visual-embed-sdk 1.33.0-alpha.1 → 1.33.0-dc.1

package/src/utils/processTrigger.spec.ts

@@ -67,4 +67,23 @@ describe('Unit test for processTrigger', () => {
         expect(messageChannelMock.port1.close).toBeCalled();
         expect(triggerPromise).rejects.toEqual(res.data.error);
     });
+
+    test('should close channel.port1 when timeout exceeds TRIGGER_TIMEOUT', async () => {
+        const messageType = HostEvent.Search;
+        const thoughtSpotHost = 'http://localhost:3000';
+        const data = {};
+        mockMessageChannel();
+
+        const triggerPromise = _processTriggerInstance.processTrigger(
+            iFrame,
+            messageType,
+            thoughtSpotHost,
+            data,
+        );
+
+        jest.advanceTimersByTime(_processTriggerInstance.TRIGGER_TIMEOUT);
+
+        expect(messageChannelMock.port1.close).toBeCalled();
+        await expect(triggerPromise).resolves.toBeInstanceOf(Error);
+    });
 });

package/src/utils/processTrigger.ts

@@ -31,7 +31,7 @@ function postIframeMessage(
     return iFrame.contentWindow.postMessage(message, thoughtSpotHost, [channel?.port2]);
 }
 
-const TRIGGER_TIMEOUT = 30000;
+export const TRIGGER_TIMEOUT = 30000;
 
 /**
  *

package/src/utils/reporting.spec.ts

@@ -0,0 +1,91 @@
+import { setEmbedConfig } from '../embed/embedConfig';
+import { registerReportingObserver, getGlobalReportingObserver, resetGlobalReportingObserver } from './reporting';
+import { logger } from './logger';
+import { AuthType } from '../types';
+import { ERROR_MESSAGE } from '../errors';
+
+jest.mock('./logger');
+
+describe('ReportingObserver', () => {
+    let mockReportingObserver: jest.Mock;
+
+    beforeAll(() => {
+        // Mock the ReportingObserver
+        mockReportingObserver = jest.fn().mockImplementation((callback: any, options: any) => ({
+            observe: jest.fn(),
+            disconnect: jest.fn(),
+            takeRecords: jest.fn(),
+        }));
+        (window as any).ReportingObserver = mockReportingObserver;
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+        resetGlobalReportingObserver();
+    });
+
+    test('should warn if ReportingObserver is not supported', () => {
+        (window as any).ReportingObserver = undefined;
+        const observer = registerReportingObserver();
+        expect(observer).toBeNull();
+        expect(logger.warn).toHaveBeenCalledWith('ReportingObserver not supported');
+        (window as any).ReportingObserver = mockReportingObserver;
+    });
+
+    test('should return existing globalObserver if override is false', () => {
+        const firstObserver = registerReportingObserver();
+        const secondObserver = registerReportingObserver();
+        expect(firstObserver === secondObserver).toBe(true);
+    });
+
+    test('should override existing globalObserver if override is true', () => {
+        const firstObserver = registerReportingObserver();
+        const secondObserver = registerReportingObserver(true);
+        expect(firstObserver).not.toBe(secondObserver);
+    });
+
+    test('should return globalObserver', () => {
+        const observer = registerReportingObserver();
+        const globalObserver = getGlobalReportingObserver();
+        expect(globalObserver).toBe(observer);
+    });
+
+    test('Should register a global observer with callback', () => {
+        let callBackPassed: any;
+
+        // Mock the ReportingObserver
+        const NewMockRO = jest.fn().mockImplementation((callback: any, options: any) => {
+            callBackPassed = callback;
+            return ({
+                observe: jest.fn(),
+                disconnect: jest.fn(),
+                takeRecords: jest.fn(),
+            });
+        });
+        const currentObserver = (window as any).ReportingObserver;
+        (window as any).ReportingObserver = NewMockRO;
+
+        setEmbedConfig({
+            thoughtSpotHost: 'testHost',
+            authType: AuthType.None,
+        });
+
+        const mockAlert = jest.fn();
+        window.alert = mockAlert;
+
+        const observer = registerReportingObserver();
+        expect(observer).toBeDefined();
+        expect(NewMockRO).toHaveBeenCalled();
+        expect(callBackPassed).toBeDefined();
+
+        // call the callback
+        callBackPassed([{ type: 'csp-violation', url: 'testHost', body: { effectiveDirective: 'frame-ancestors' } }]);
+
+        expect(mockAlert).toHaveBeenCalledWith(ERROR_MESSAGE.CSP_VIOLATION_ALERT);
+        expect(logger.error).toHaveBeenCalledWith(
+            ERROR_MESSAGE.CSP_FRAME_HOST_VIOLATION_LOG_MESSAGE,
+        );
+
+        (window as any).ReportingObserver = currentObserver;
+    });
+});

package/src/utils/reporting.ts

@@ -0,0 +1,71 @@
+import { getEmbedConfig } from '../embed/embedConfig';
+import { logger } from './logger';
+import { ERROR_MESSAGE } from '../errors';
+
+enum ReportType {
+  CSP_VIOLATION = 'csp-violation',
+  DEPRECATION = 'deprecation',
+  INTERVENTION = 'intervention',
+}
+
+let globalObserver: ReportingObserver | null = null;
+
+/**
+ * Register a global ReportingObserver to capture all unhandled errors
+ * @param overrideExisting boolean to override existing observer
+ * @returns ReportingObserver | null
+ */
+export function registerReportingObserver(overrideExisting = false): ReportingObserver | null {
+    if (!((window as any).ReportingObserver)) {
+        logger.warn(ERROR_MESSAGE.MISSING_REPORTING_OBSERVER);
+        return null;
+    }
+
+    if (overrideExisting) {
+        resetGlobalReportingObserver();
+    }
+
+    if (globalObserver) {
+        return globalObserver;
+    }
+
+    const embedConfig = getEmbedConfig();
+
+    globalObserver = new ReportingObserver((reports) => {
+        reports.forEach((report) => {
+            const { type, url, body } = report;
+            const reportBody = body as any;
+
+            const isThoughtSpotHost = url
+                && url.startsWith(embedConfig.thoughtSpotHost);
+
+            const isFrameHostError = type === ReportType.CSP_VIOLATION
+                && reportBody.effectiveDirective === 'frame-ancestors';
+
+            if (isThoughtSpotHost && isFrameHostError) {
+                if (!embedConfig.suppressErrorAlerts) {
+                    alert(ERROR_MESSAGE.CSP_VIOLATION_ALERT);
+                }
+                logger.error(ERROR_MESSAGE.CSP_FRAME_HOST_VIOLATION_LOG_MESSAGE);
+            }
+        });
+    }, { buffered: true });
+    globalObserver.observe();
+    return globalObserver;
+}
+
+/**
+ * Get the global ReportingObserver
+ * @returns - ReportingObserver | null
+ */
+export function getGlobalReportingObserver(): ReportingObserver | null {
+    return globalObserver;
+}
+
+/**
+ * Resets the global ReportingObserver
+ */
+export function resetGlobalReportingObserver(): void {
+    if (globalObserver) globalObserver.disconnect();
+    globalObserver = null;
+}

package/src/utils.ts

@@ -206,7 +206,6 @@ export const getCustomisations = (
     embedConfig: EmbedConfig,
     viewConfig: ViewConfig,
 ): CustomisationsInterface => {
-    const customCssUrlFromEmbedConfig = embedConfig.customCssUrl;
     const customizationsFromViewConfig = viewConfig.customizations;
     const customizationsFromEmbedConfig = embedConfig.customizations
         || ((embedConfig as any).customisations as CustomisationsInterface);
@@ -221,8 +220,7 @@ export const getCustomisations = (
             },
             customCSSUrl:
                 customizationsFromViewConfig?.style?.customCSSUrl
-                || customizationsFromEmbedConfig?.style?.customCSSUrl
-                || customCssUrlFromEmbedConfig,
+                || customizationsFromEmbedConfig?.style?.customCSSUrl,
         },
         content: {
             ...customizationsFromEmbedConfig?.content,

package/dist/src/embed/searchEmbed-basic-auth.spec.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=searchEmbed-basic-auth.spec.d.ts.map

package/dist/src/embed/searchEmbed-basic-auth.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"searchEmbed-basic-auth.spec.d.ts","sourceRoot":"","sources":["searchEmbed-basic-auth.spec.ts"],"names":[],"mappings":""}

package/src/embed/searchEmbed-basic-auth.spec.ts

@@ -1,110 +0,0 @@
-import { SearchEmbed } from './search';
-import * as baseInstance from './base';
-import * as authService from '../utils/authService';
-import * as authInstance from '../auth';
-import * as config from '../config';
-import * as embedConfigInstance from './embedConfig';
-
-import { init } from '../index';
-import { AuthType } from '../types';
-import { getDocumentBody, getRootEl } from '../test/test-utils';
-import { mockSessionInfo } from '../auth.spec';
-import { ERROR_MESSAGE } from '../errors';
-
-const thoughtSpotHost = 'tshost';
-init({
-    thoughtSpotHost,
-    authType: AuthType.Basic,
-    username: 'tsadmin',
-    password: 'admin',
-});
-
-describe('Search embed tests when authType is Basic', () => {
-    /**
-     *
-     * @param version
-     */
-    function setupVersion(version: string) {
-        jest.spyOn(window, 'addEventListener').mockImplementation((event, handler, options) => {
-            handler({
-                data: {
-                    type: 'xyz',
-                },
-                ports: [3000],
-                source: null,
-            });
-        });
-        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(async () => ({
-            json: () => ({
-                ...mockSessionInfo,
-                releaseVersion: version,
-            }),
-            status: 200,
-        }));
-        jest.spyOn(authInstance, 'getReleaseVersion').mockReturnValue(version);
-    }
-    beforeEach(() => {
-        document.body.innerHTML = getDocumentBody();
-        jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValue(true);
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    test('when releaseVersion is empty', async () => {
-        setupVersion('');
-        const mockAlert = spyOn(window, 'alert');
-        const searchEmbed = new SearchEmbed(getRootEl(), {});
-        await searchEmbed.render();
-        expect(mockAlert).not.toBeCalled();
-    });
-
-    test("when releaseVersion is '7.0.1.cl' ", async () => {
-        setupVersion('7.0.1.cl');
-        const mockAlert = jest.spyOn(window, 'alert');
-        const searchEmbed = new SearchEmbed(getRootEl(), {});
-        await searchEmbed.render();
-        expect(mockAlert).not.toBeCalled();
-    });
-    test('when releaseVersion is above 8.4.0.sw', async () => {
-        setupVersion('8.4.0.sw');
-        const mockAlert = jest.spyOn(window, 'alert');
-        const searchEmbed = new SearchEmbed(getRootEl(), {});
-        await searchEmbed.render();
-        expect(mockAlert).not.toBeCalled();
-    });
-
-    test('releaseVersion is above 8.4.0.sw', async () => {
-        setupVersion('8.8.0.sw');
-        jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
-        const mockAlert = jest.spyOn(window, 'alert');
-        const searchEmbed = new SearchEmbed(getRootEl(), {});
-        await searchEmbed.render();
-        expect(mockAlert).not.toBeCalled();
-    });
-
-    test('Alert should not appear when suppressSearchEmbedBetaWarning is true and releaseVersion is ts7.dec.cl', async () => {
-        setupVersion('ts7.dec.cl');
-        jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
-        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
-            suppressSearchEmbedBetaWarning: true,
-        });
-        const mockAlert = jest.spyOn(window, 'alert');
-        const searchEmbed = new SearchEmbed(getRootEl(), {});
-        await searchEmbed.render();
-        expect(mockAlert).not.toBeCalled();
-    });
-
-    test('Alert should not appear when suppressSearchEmbedBetaWarning is true and releaseVersion is 8.4.0.sw', async () => {
-        setupVersion('8.4.0.sw');
-        jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
-        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
-            suppressSearchEmbedBetaWarning: true,
-        });
-        const mockAlert = jest.spyOn(window, 'alert');
-        const searchEmbed = new SearchEmbed(getRootEl(), {});
-        await searchEmbed.render();
-        expect(mockAlert).not.toBeCalled();
-    });
-});