@thoughtspot/visual-embed-sdk 1.29.0-alpha.3 → 1.29.0-alpha.authRefactor

package/src/utils/authService/tokenizedAuthService.ts

@@ -7,23 +7,33 @@ import { EndPoints } from './authService';
  * @param url
  * @param options
  */
-function tokenisedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
+function tokenizedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
     return tokenizedFetch(url, options).then(async (r) => {
         if (!r.ok && r.type !== 'opaqueredirect' && r.type !== 'opaque') {
-            logger.error('Failure', await r.text?.());
+            logger.error(`Failed to fetch ${url}`, await r.text?.());
         }
         return r;
     });
 }
 
 /**
+ * Fetches the session info from the ThoughtSpot server.
  *
- * @param authVerificationUrl
+ * @param thoughtspotHost
+ * @returns {Promise<any>}
+ * @example
+ * ```js
+ *  const response = await sessionInfoService();
+ * ```
  */
-export function fetchSessionInfoService(authVerificationUrl: string): Promise<any> {
-    return tokenisedFailureLoggedFetch(authVerificationUrl, {
-        credentials: 'include',
-    });
+export async function fetchSessionInfoService(thoughtspotHost: string): Promise<any> {
+    const sessionInfoPath = `${thoughtspotHost}${EndPoints.SESSION_INFO}`;
+    const response = await tokenizedFailureLoggedFetch(sessionInfoPath);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch session info: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
 }
 
 /**
@@ -31,7 +41,7 @@ export function fetchSessionInfoService(authVerificationUrl: string): Promise<an
  * @param thoughtSpotHost
  */
 export async function fetchLogoutService(thoughtSpotHost: string): Promise<any> {
-    return tokenisedFailureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
+    return tokenizedFailureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
         credentials: 'include',
         method: 'POST',
         headers: {
@@ -39,3 +49,23 @@ export async function fetchLogoutService(thoughtSpotHost: string): Promise<any>
         },
     });
 }
+
+/**
+ * Is active service to check if the user is logged in.
+ *
+ * @param thoughtSpotHost
+ * @version SDK: 1.28.4 | ThoughtSpot: *
+ */
+export async function isActiveService(thoughtSpotHost: string): Promise<boolean> {
+    const isActiveUrl = `${thoughtSpotHost}${EndPoints.IS_ACTIVE}`;
+    try {
+        const res = await tokenizedFetch(isActiveUrl, {
+            credentials: 'include',
+        });
+        return res.ok;
+    } catch (e) {
+        logger.warn(`Is Logged In Service failed : ${e.message}`);
+    }
+
+    return false;
+}

package/src/utils/processData.spec.ts

@@ -4,9 +4,11 @@ import * as auth from '../auth';
 import * as base from '../embed/base';
 import * as embedConfigInstance from '../embed/embedConfig';
 import { EmbedEvent, AuthType } from '../types';
+import * as sessionInfoService from './sessionInfoService';
 
 describe('Unit test for process data', () => {
     beforeAll(() => {
+        jest.spyOn(auth, 'postLoginService').mockImplementation(() => Promise.resolve({}));
         base.init({
             thoughtSpotHost: 'https://tshost',
             authType: AuthType.None,
@@ -58,15 +60,14 @@ describe('Unit test for process data', () => {
             isPublicUser: false,
         };
         const e = { type: EmbedEvent.AuthInit, data: sessionInfo };
-        jest.spyOn(auth, 'initSession').mockReturnValue(null);
         jest.spyOn(base, 'notifyAuthSuccess');
+        jest.spyOn(sessionInfoService, 'getSessionInfoSync').mockReturnValue(sessionInfo);
         expect(processDataInstance.processEventData(e.type, e, '', null)).toEqual({
             type: e.type,
             data: {
                 userGUID: sessionInfo.userGUID,
             },
         });
-        expect(auth.initSession).toBeCalledWith(sessionInfo);
         expect(base.notifyAuthSuccess).toBeCalled();
     });
 

package/src/utils/processData.ts

@@ -5,7 +5,7 @@ import {
     notifyAuthSuccess,
     notifyLogout,
 } from '../embed/base';
-import { AuthFailureType, initSession } from '../auth';
+import { AuthFailureType } from '../auth';
 import { AuthType, CustomActionPayload, EmbedEvent } from '../types';
 import { AnswerService } from './graphql/answerService/answerService';
 import { resetCachedAuthToken } from '../authToken';
@@ -34,8 +34,6 @@ export function processCustomAction(e: any, thoughtSpotHost: string) {
  * @param e
  */
 function processAuthInit(e: any) {
-    // Store user session details sent by app.
-    initSession(e.data);
     notifyAuthSuccess();
 
     // Expose only allowed details (eg: userGUID) back to SDK users.

package/src/utils/sessionInfoService.ts

@@ -0,0 +1,101 @@
+import { getEmbedConfig } from '../embed/embedConfig';
+import { fetchSessionInfoService } from './authService';
+
+export type SessionInfo = {
+    releaseVersion: string;
+    userGUID: string;
+    currentOrgId: number;
+    privileges: string[];
+    mixpanelToken: string;
+    isPublicUser: boolean;
+    clusterId: string;
+    clusterName: string;
+    [key: string]: any;
+};
+
+let sessionInfo: null | SessionInfo = null;
+
+/**
+ * Returns the session info object and caches it for future use.
+ * Once fetched the session info object is cached and returned from the cache on
+ * subsequent calls.
+ *
+ * @example ```js
+ * const sessionInfo = await getSessionInfo();
+ * console.log(sessionInfo);
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ * @returns {Promise<SessionInfo>} The session info object.
+ */
+export async function getSessionInfo(): Promise<SessionInfo> {
+    if (!sessionInfo) {
+        const host = getEmbedConfig().thoughtSpotHost;
+        const sessionResponse = await fetchSessionInfoService(host);
+        const processedSessionInfo = getSessionDetails(sessionResponse);
+        sessionInfo = processedSessionInfo;
+    }
+    return sessionInfo;
+}
+
+/**
+ * Returns the cached session info object. If the client is not authenticated the
+ * function will return null.
+ *
+ * @example ```js
+ * const sessionInfo = getSessionInfoSync();
+ * if (sessionInfo) {
+ *   console.log(sessionInfo);
+ * } else {
+ *   console.log('Not authenticated');
+ * }
+ * ```
+ * @returns {SessionInfo | null} The session info object.
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ */
+export function getSessionInfoSync(): SessionInfo | null {
+    return sessionInfo;
+}
+
+/**
+ * Processes the session info response and returns the session info object.
+ *
+ *  @param sessionInfoResp {any} Response from the session info API.
+ *  @returns {SessionInfo} The session info object.
+ *  @example ```js
+ *  const sessionInfoResp = await fetch(sessionInfoPath);
+ *  const sessionInfo = getSessionDetails(sessionInfoResp);
+ *  console.log(sessionInfo);
+ *  ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ */
+export const getSessionDetails = (sessionInfoResp: any): SessionInfo => {
+    const devMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.devSdkKey;
+    const prodMixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.prodSdkKey;
+    const mixpanelToken = sessionInfoResp.configInfo.mixpanelConfig.production
+        ? prodMixpanelToken
+        : devMixpanelToken;
+    return {
+        userGUID: sessionInfoResp.userGUID,
+        mixpanelToken,
+        isPublicUser: sessionInfoResp.configInfo.isPublicUser,
+        releaseVersion: sessionInfoResp.releaseVersion,
+        clusterId: sessionInfoResp.configInfo.selfClusterId,
+        clusterName: sessionInfoResp.configInfo.selfClusterName,
+        ...sessionInfoResp,
+    };
+};
+
+/**
+ * Resets the cached session info object and forces a new fetch on the next call.
+ *
+ * @example ```js
+ * resetCachedSessionInfo();
+ * const sessionInfo = await getSessionInfo();
+ * console.log(sessionInfo);
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot ts7.april.cl, 7.2.1
+ * @returns {void}
+ */
+export function resetCachedSessionInfo(): void {
+    sessionInfo = null;
+}