@thoughtspot/visual-embed-sdk 1.26.6 → 1.26.7

package/src/utils/authService/authService.spec.ts

@@ -1,12 +1,13 @@
 import {
-    fetchSessionInfoService,
-    fetchAuthTokenService,
+    EndPoints,
+    fetchAuthPostService,
     fetchAuthService,
+    fetchAuthTokenService,
     fetchBasicAuthService,
-    fetchAuthPostService,
+    fetchSessionInfoService,
     verifyTokenService,
-    EndPoints,
 } from '.';
+import { logger } from '../logger';
 
 const thoughtSpotHost = 'http://10.79.135.124:3000';
 
@@ -74,14 +75,14 @@ describe('Unit test for authService', () => {
     });
 
     test('log error on API failures', async () => {
-        jest.spyOn(global.console, 'error').mockImplementation(() => undefined);
+        jest.spyOn(logger, 'error').mockImplementation(() => undefined);
         global.fetch = jest.fn(() => Promise.resolve({
             text: () => Promise.resolve('error'),
             status: 500,
             ok: false,
         }));
         await fetchSessionInfoService(authVerificationUrl);
-        expect(global.console.error).toHaveBeenCalledWith('Failure', 'error');
+        expect(logger.error).toHaveBeenCalledWith('Failure', 'error');
     });
 
     test('verifyTokenService', async () => {

package/src/utils/authService/authService.ts

@@ -1,3 +1,5 @@
+import { logger } from '../logger';
+
 export const EndPoints = {
     AUTH_VERIFICATION: '/callosum/v1/session/info',
     SAML_LOGIN_TEMPLATE: (targetUrl: string) => `/callosum/v1/saml/login?targetURLPath=${targetUrl}`,
@@ -18,7 +20,7 @@ export const EndPoints = {
 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?.());
+            logger.error('Failure', await r.text?.());
         }
         return r;
     });
@@ -45,7 +47,7 @@ export async function verifyTokenService(
         });
         return res.ok;
     } catch (e) {
-        console.error(`Token Verification Service failed : ${e.message}`);
+        logger.error(`Token Verification Service failed : ${e.message}`);
     }
 
     return false;

package/src/utils/authService/tokenizedAuthService.ts

@@ -1,4 +1,5 @@
 import { tokenizedFetch } from '../../tokenizedFetch';
+import { logger } from '../logger';
 import { EndPoints } from './authService';
 
 /**
@@ -9,7 +10,7 @@ import { EndPoints } from './authService';
 function tokenisedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
     return tokenizedFetch(url, options).then(async (r) => {
         if (!r.ok && r.type !== 'opaqueredirect' && r.type !== 'opaque') {
-            console.error('Failure', await r.text?.());
+            logger.error('Failure', await r.text?.());
         }
         return r;
     });

package/src/utils/graphql/answerService/answerService.ts

@@ -37,8 +37,7 @@ interface UnderlyingDataPoint {
  *     const data = await underlying.fetchData(0, 100);
  *  })
  * ```
- * @version
- * ThoughtSpot: 9.9.0.cl / SDK: 1.25.0
+ * @version SDK: 1.25.0| ThoughtSpot: 9.10.0.cl
  * @group Events
  */
 export class AnswerService {
@@ -129,8 +128,7 @@ export class AnswerService {
      *     const data = await underlying.fetchData(0, 100);
      *  })
      * ```
-     * @version
-     * ThoughtSpot: 9.9.0.cl / SDK: 1.25.0
+     * @version SDK: 1.25.0| ThoughtSpot: 9.10.0.cl
      */
     public async getUnderlyingDataForPoint(
         outputColumnNames: string[],

package/src/utils/logger.spec.ts

@@ -0,0 +1,108 @@
+let logger: any;
+let LogLevel: any;
+let setGlobalLogLevelOverride: any;
+
+const consoleErrorSpy = jest.spyOn(console, 'error');
+const consoleWarnSpy = jest.spyOn(console, 'warn');
+const consoleInfoSpy = jest.spyOn(console, 'info');
+const consoleDebugSpy = jest.spyOn(console, 'debug');
+const consoleTraceSpy = jest.spyOn(console, 'trace');
+
+describe('Logger', () => {
+    beforeAll(async () => {
+        const a = await import('./logger');
+        logger = a.logger;
+        LogLevel = a.LogLevel;
+        setGlobalLogLevelOverride = a.setGlobalLogLevelOverride;
+    });
+
+    beforeEach(() => {
+        // Reset the logger's log level before each test
+        setGlobalLogLevelOverride(LogLevel.TRACE);
+        logger.setLogLevel(LogLevel.ERROR);
+
+        consoleErrorSpy.mockRestore();
+        consoleWarnSpy.mockRestore();
+        consoleInfoSpy.mockRestore();
+        consoleDebugSpy.mockRestore();
+        consoleTraceSpy.mockRestore();
+    });
+
+    it('should set the log level correctly', () => {
+        logger.setLogLevel(LogLevel.INFO);
+        expect(logger.getLogLevel()).toBe(LogLevel.INFO);
+
+        logger.setLogLevel(LogLevel.DEBUG);
+        expect(logger.getLogLevel()).toBe(LogLevel.DEBUG);
+    });
+
+    it('should log messages based on the log level', () => {
+        setGlobalLogLevelOverride(undefined);
+
+        logger.setLogLevel(LogLevel.SILENT);
+        logger.logMessages(['log me'], LogLevel.SILENT);
+        logger.error('Error message');
+        logger.warn('Warning message');
+        logger.debug('Debug message');
+        expect(consoleErrorSpy).not.toHaveBeenCalled();
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(consoleDebugSpy).not.toHaveBeenCalled();
+
+        logger.setLogLevel(LogLevel.ERROR);
+        logger.error('Error message');
+        logger.warn('Warning message');
+        logger.debug('Debug message');
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error message');
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(consoleDebugSpy).not.toHaveBeenCalled();
+
+        logger.error('Warning message');
+        logger.warn('Warning message');
+        logger.debug('Debug message');
+        expect(consoleTraceSpy).not.toHaveBeenCalled();
+
+        logger.setLogLevel(LogLevel.WARN);
+        logger.error('Warning message');
+        logger.warn('Warning message');
+        logger.debug('Debug message');
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Warning message');
+        expect(consoleWarnSpy).toHaveBeenCalledWith('Warning message');
+        expect(consoleDebugSpy).not.toHaveBeenCalled();
+
+        logger.setLogLevel(LogLevel.DEBUG);
+        logger.error('Warning message');
+        logger.warn('Warning message');
+        logger.debug('Debug message');
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Warning message');
+        expect(consoleWarnSpy).toHaveBeenCalledWith('Warning message');
+        expect(consoleDebugSpy).toHaveBeenCalledWith('Debug message');
+    });
+
+    it('should log messages with the global log level override', () => {
+        setGlobalLogLevelOverride(LogLevel.WARN);
+
+        logger.error('Error message');
+        logger.warn('Warn message');
+        logger.info('Info message');
+        logger.trace('Trace message');
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error message');
+        expect(consoleWarnSpy).toHaveBeenCalledWith('Warn message');
+        expect(consoleInfoSpy).not.toHaveBeenCalled();
+        expect(consoleDebugSpy).not.toHaveBeenCalled();
+        expect(consoleTraceSpy).not.toHaveBeenCalled();
+    });
+
+    it('If global level is not set , default local level (error) should be used', () => {
+        setGlobalLogLevelOverride(undefined);
+
+        logger.error('Error message');
+        logger.warn('Warn message');
+        logger.info('Info message');
+        logger.trace('Trace message');
+        expect(consoleErrorSpy).toHaveBeenCalledWith('Error message');
+        expect(consoleWarnSpy).not.toHaveBeenCalled();
+        expect(consoleInfoSpy).not.toHaveBeenCalled();
+        expect(consoleDebugSpy).not.toHaveBeenCalled();
+        expect(consoleTraceSpy).not.toHaveBeenCalled();
+    });
+});

package/src/utils/logger.ts

@@ -0,0 +1,88 @@
+import isUndefined from 'lodash/isUndefined';
+import noop from 'lodash/noop';
+import { LogLevel } from '../types';
+
+const logFunctions: {
+    [key: string]: (...args: any[]) => void;
+} = {
+    [LogLevel.SILENT]: noop,
+    [LogLevel.ERROR]: console.error,
+    [LogLevel.WARN]: console.warn,
+    [LogLevel.INFO]: console.info,
+    [LogLevel.DEBUG]: console.debug,
+    [LogLevel.TRACE]: console.trace,
+};
+
+let globalLogLevelOverride: LogLevel = LogLevel.TRACE;
+const setGlobalLogLevelOverride = (logLevel: LogLevel): void => {
+    globalLogLevelOverride = logLevel;
+};
+
+const logLevelToNumber: { [key: string]: number } = {
+    [LogLevel.SILENT]: 0,
+    [LogLevel.ERROR]: 1,
+    [LogLevel.WARN]: 2,
+    [LogLevel.INFO]: 3,
+    [LogLevel.DEBUG]: 4,
+    [LogLevel.TRACE]: 5,
+};
+const compareLogLevels = (logLevel1: LogLevel, logLevel2: LogLevel): number => {
+    const logLevel1Index = logLevelToNumber[logLevel1];
+    const logLevel2Index = logLevelToNumber[logLevel2];
+    return logLevel1Index - logLevel2Index;
+};
+
+class Logger {
+    private logLevel: LogLevel = LogLevel.ERROR;
+
+    public setLogLevel = (newLogLevel: LogLevel): void => {
+        this.logLevel = newLogLevel;
+    };
+
+    public getLogLevel = (): LogLevel => this.logLevel;
+
+    public canLog(logLevel: LogLevel): boolean {
+        if (logLevel === LogLevel.SILENT) return false;
+        if (!isUndefined(globalLogLevelOverride)) {
+            return compareLogLevels(globalLogLevelOverride, logLevel) >= 0;
+        }
+        return compareLogLevels(this.logLevel, logLevel) >= 0;
+    }
+
+    public logMessages(args: any[], logLevel: LogLevel): void {
+        if (this.canLog(logLevel)) {
+            const logFn = logFunctions[logLevel];
+            if (logFn) {
+                logFn(...args);
+            }
+        }
+    }
+
+    public log(...args: any[]): void {
+        this.info(args);
+    }
+
+    public info(...args: any[]): void {
+        this.logMessages(args, LogLevel.INFO);
+    }
+
+    public debug(...args: any[]): void {
+        this.logMessages(args, LogLevel.DEBUG);
+    }
+
+    public trace(...args: any[]): void {
+        this.logMessages(args, LogLevel.TRACE);
+    }
+
+    public error(...args: any[]): void {
+        this.logMessages(args, LogLevel.ERROR);
+    }
+
+    public warn(...args: any[]): void {
+        this.logMessages(args, LogLevel.WARN);
+    }
+}
+
+const logger = new Logger();
+
+export { LogLevel, logger, setGlobalLogLevelOverride };

package/src/utils/processData.ts

@@ -8,6 +8,7 @@ import {
 import { AuthFailureType, initSession } from '../auth';
 import { AuthType, CustomActionPayload, EmbedEvent } from '../types';
 import { AnswerService } from './graphql/answerService/answerService';
+import { resetCachedAuthToken } from '../authToken';
 
 /**
  *
@@ -77,13 +78,14 @@ function processNoCookieAccess(e: any, containerEl: Element) {
  * @param e
  * @param containerEl
  */
-function processAuthFailure(e: any, containerEl: Element) {
+export function processAuthFailure(e: any, containerEl: Element) {
     const { loginFailedMessage, authType } = getEmbedConfig();
     if (authType !== AuthType.None) {
         // eslint-disable-next-line no-param-reassign
         containerEl.innerHTML = loginFailedMessage;
         notifyAuthFailure(AuthFailureType.OTHER);
     }
+    resetCachedAuthToken();
     return e;
 }
 
@@ -96,6 +98,7 @@ function processAuthLogout(e: any, containerEl: Element) {
     const { loginFailedMessage } = getEmbedConfig();
     // eslint-disable-next-line no-param-reassign
     containerEl.innerHTML = loginFailedMessage;
+    resetCachedAuthToken();
     disableAutoLogin();
     notifyLogout();
     return e;

package/src/utils/processTrigger.ts

@@ -15,7 +15,7 @@ export const reload = (iFrame: HTMLIFrameElement) => {
 };
 
 /**
- * Post Iframe message.
+ * Post iframe message.
  *
  * @param iFrame
  * @param message