@thoughtspot/visual-embed-sdk 1.35.14 → 1.36.1

package/src/utils/authService/authService.ts

@@ -3,6 +3,7 @@ import { logger } from '../logger';
 export const EndPoints = {
     AUTH_VERIFICATION: '/callosum/v1/session/info',
     SESSION_INFO: '/callosum/v1/session/info',
+    PREAUTH_INFO: '/prism/preauth/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',

package/src/utils/authService/index.ts

@@ -6,4 +6,8 @@ export {
     fetchBasicAuthService,
     verifyTokenService,
 } from './authService';
-export { fetchLogoutService, fetchSessionInfoService } from './tokenizedAuthService';
+export {
+    fetchLogoutService,
+    fetchSessionInfoService,
+    fetchPreauthInfoService,
+} from './tokenizedAuthService';

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

@@ -1,9 +1,16 @@
 import * as tokenizedFetchModule from '../../tokenizedFetch';
-import { isActiveService } from './tokenizedAuthService';
+import { isActiveService, fetchSessionInfoService, fetchPreauthInfoService } from './tokenizedAuthService';
 import { logger } from '../logger';
+import { EndPoints } from './authService';
+
+const thoughtspotHost = 'http://thoughtspotHost';
 
 describe('tokenizedAuthService', () => {
-    test('isActiveService is fetch returns ok', async () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+    test('isActiveService if fetch returns ok', async () => {
         jest.spyOn(tokenizedFetchModule, 'tokenizedFetch').mockResolvedValueOnce({
             ok: true,
         });
@@ -34,3 +41,60 @@ describe('tokenizedAuthService', () => {
         expect(logger.warn).toHaveBeenCalled();
     });
 });
+
+describe('fetchPreauthInfoService', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+        jest.restoreAllMocks();
+    });
+
+    test('fetchPreauthInfoService if fetch returns ok', async () => {
+        const mockFetch = jest.spyOn(tokenizedFetchModule, 'tokenizedFetch');
+
+        // Mock for fetchPreauthInfoService
+        mockFetch
+            .mockResolvedValueOnce({
+                ok: true,
+                headers: new Headers({ 'content-type': 'application/json' }), // Mock headers correctly
+                status: 200,
+                statusText: 'Ok',
+                json: jest.fn().mockResolvedValue({
+                    info: {
+                        configInfo: {
+                            mixpanelConfig: {
+                                devSdkKey: 'devSdkKey',
+                            },
+                        },
+                        userGUID: 'userGUID',
+                    },
+                }),
+            });
+
+        const result = await fetchPreauthInfoService(thoughtspotHost);
+        const response = await result.json();
+
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        expect(mockFetch).toHaveBeenNthCalledWith(1, `${thoughtspotHost}${EndPoints.PREAUTH_INFO}`, {});
+        expect(response).toHaveProperty('info');
+    });
+    it('fetchPreauthInfoService if fetch fails', async () => {
+        const mockFetch = jest.spyOn(tokenizedFetchModule, 'tokenizedFetch');
+
+        // Mock for fetchPreauthInfoService
+        mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 500,
+            statusText: 'Internal Server Error',
+            json: jest.fn().mockResolvedValue({}),
+            text: jest.fn().mockResolvedValue('Internal Server Error'),
+        });
+
+        try {
+            await fetchPreauthInfoService(thoughtspotHost);
+        } catch (e) {
+            expect(e.message).toContain(`Failed to fetch ${thoughtspotHost}${EndPoints.PREAUTH_INFO}`);
+        }
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        expect(mockFetch).toHaveBeenCalledWith(`${thoughtspotHost}${EndPoints.PREAUTH_INFO}`, {});
+    });
+});

package/src/utils/authService/tokenizedAuthService.ts

@@ -16,6 +16,32 @@ function tokenizedFailureLoggedFetch(url: string, options: RequestInit = {}): Pr
     });
 }
 
+/**
+ * Fetches the session info from the ThoughtSpot server.
+ * @param thoughtspotHost
+ * @returns {Promise<any>}
+ * @example
+ * ```js
+ *  const response = await sessionInfoService();
+ * ```
+ */
+export async function fetchPreauthInfoService(thoughtspotHost: string): Promise<any> {
+    const sessionInfoPath = `${thoughtspotHost}${EndPoints.PREAUTH_INFO}`;
+    const handleError = (e: any) => {
+        const error: any = new Error(`Failed to fetch auth info: ${e.message || e.statusText}`);
+        error.status = e.status; // Attach the status code to the error object
+        throw error;
+    };
+
+    try {
+        const response = await tokenizedFailureLoggedFetch(sessionInfoPath);
+        return response;
+    } catch (e) {
+        handleError(e);
+        return null;
+    }
+}
+
 /**
  * Fetches the session info from the ThoughtSpot server.
  * @param thoughtspotHost

package/src/utils/sessionInfoService.ts

@@ -1,5 +1,5 @@
 import { getEmbedConfig } from '../embed/embedConfig';
-import { fetchSessionInfoService } from './authService';
+import { fetchSessionInfoService, fetchPreauthInfoService } from './authService';
 
 export type SessionInfo = {
     releaseVersion: string;
@@ -13,7 +13,70 @@ export type SessionInfo = {
     [key: string]: any;
 };
 
+export type PreauthInfo = {
+    info?: SessionInfo;
+    headers: Record<string, string>;
+    status: number;
+    [key: string]: any;
+};
+
 let sessionInfo: null | SessionInfo = null;
+let preauthInfo: null | PreauthInfo = null;
+
+/**
+ * Processes the session info response and returns the session info object.
+ *  @param preauthInfoResp {any} Response from the session info API.
+ *  @returns {PreauthInfo} The session info object.
+ *  @example ```js
+ *  const preauthInfoResp = await fetch(sessionInfoPath);
+ *  const sessionInfo = await formatPreauthInfo(preauthInfoResp);
+ *  console.log(sessionInfo);
+ *  ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ */
+export const formatPreauthInfo = async (preauthInfoResp: any): Promise<PreauthInfo> => {
+    try {
+        // Convert Headers to a plain object
+        const headers: Record<string, string> = {};
+        preauthInfoResp?.headers?.forEach((value: string, key: string) => {
+            headers[key] = value;
+        });
+        const data = await preauthInfoResp.json();
+        return {
+            ...data,
+            status: 200,
+            headers,
+        };
+    } catch (error) {
+        return 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 preauthInfo = await getPreauthInfo();
+ * console.log(preauthInfo);
+ * ```
+ * @version SDK: 1.28.3 | ThoughtSpot: *
+ * @returns {Promise<SessionInfo>} The session info object.
+ */
+export async function getPreauthInfo(allowCache = true): Promise<PreauthInfo> {
+    if (!allowCache || !preauthInfo) {
+        try {
+            const host = getEmbedConfig().thoughtSpotHost;
+            const sessionResponse = await fetchPreauthInfoService(host);
+            const processedPreauthInfo = await formatPreauthInfo(sessionResponse);
+            preauthInfo = processedPreauthInfo;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    return preauthInfo;
+}
 
 /**
  * Returns the session info object and caches it for future use.