@thoughtspot/visual-embed-sdk 1.29.1-alpha.0 → 1.29.1

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

@@ -1,11 +1,11 @@
 import {
-    fetchSessionInfoService,
-    fetchAuthTokenService,
+    EndPoints,
+    fetchAuthPostService,
     fetchAuthService,
+    fetchAuthTokenService,
     fetchBasicAuthService,
-    fetchAuthPostService,
+    fetchSessionInfoService,
     verifyTokenService,
-    EndPoints,
 } from '.';
 import { logger } from '../logger';
 
@@ -26,10 +26,9 @@ describe('Unit test for authService', () => {
             status: 200,
             ok: true,
         }));
-        const response = await fetchSessionInfoService(thoughtSpotHost);
-        expect(response.success).toBe(true);
+        const response = await fetchSessionInfoService(authVerificationUrl);
+        expect(response.status).toBe(200);
         expect(fetch).toHaveBeenCalledTimes(1);
-        expect(fetch).toBeCalledWith(`${thoughtSpotHost}${EndPoints.SESSION_INFO}`, {});
     });
 
     test('fetchAuthTokenService', async () => {
@@ -109,12 +108,8 @@ describe('Unit test for authService', () => {
             status: 500,
             ok: false,
         }));
-        try {
-            await fetchSessionInfoService(authVerificationUrl);
-        } catch (e) {
-            expect(e.message).toContain('Failed to fetch session info');
-        }
-        expect(logger.error).toHaveBeenCalledWith('Failed to fetch http://localhost:3000/callosum/v1/session/info', 'error');
+        await fetchSessionInfoService(authVerificationUrl);
+        expect(logger.error).toHaveBeenCalledWith('Failure', 'error');
     });
 
     test('verifyTokenService', async () => {

package/src/utils/authService/authService.ts

@@ -2,7 +2,6 @@ import { logger } from '../logger';
 
 export const EndPoints = {
     AUTH_VERIFICATION: '/callosum/v1/session/info',
-    SESSION_INFO: '/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',
@@ -29,7 +28,6 @@ function failureLoggedFetch(url: string, options: RequestInit = {}): Promise<Res
 
 /**
  * Service to validate a auth token against a ThoughtSpot host.
- *
  * @param thoughtSpotHost : ThoughtSpot host to verify the token against.
  * @param authToken : Auth token to verify.
  */

package/src/utils/authService/tokenizedAuthService.ts

@@ -7,33 +7,23 @@ import { EndPoints } from './authService';
  * @param url
  * @param options
  */
-function tokenizedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
+function tokenisedFailureLoggedFetch(url: string, options: RequestInit = {}): Promise<Response> {
     return tokenizedFetch(url, options).then(async (r) => {
         if (!r.ok && r.type !== 'opaqueredirect' && r.type !== 'opaque') {
-            logger.error(`Failed to fetch ${url}`, await r.text?.());
+            logger.error('Failure', await r.text?.());
         }
         return r;
     });
 }
 
 /**
- * Fetches the session info from the ThoughtSpot server.
  *
- * @param thoughtspotHost
- * @returns {Promise<any>}
- * @example
- * ```js
- *  const response = await sessionInfoService();
- * ```
+ * @param authVerificationUrl
  */
-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;
+export function fetchSessionInfoService(authVerificationUrl: string): Promise<any> {
+    return tokenisedFailureLoggedFetch(authVerificationUrl, {
+        credentials: 'include',
+    });
 }
 
 /**
@@ -41,7 +31,7 @@ export async function fetchSessionInfoService(thoughtspotHost: string): Promise<
  * @param thoughtSpotHost
  */
 export async function fetchLogoutService(thoughtSpotHost: string): Promise<any> {
-    return tokenizedFailureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
+    return tokenisedFailureLoggedFetch(`${thoughtSpotHost}${EndPoints.LOGOUT}`, {
         credentials: 'include',
         method: 'POST',
         headers: {
@@ -49,23 +39,3 @@ 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/graphql/answerService/answer-queries.ts

@@ -53,6 +53,64 @@ export const addColumns = `
     }
     `;
 
+export const addFilter = `
+    mutation AddUpdateFilter($session: BachSessionIdInput!, $params: AddUpdateFilterInput!) {
+        Answer__addUpdateFilter(session: $session, params: $params) {
+            ${bachSessionId}
+        }
+    }
+`;
+
+export const getAnswer = `
+    query GetAnswer($session: BachSessionIdInput!) {
+        getAnswer(session: $session) {
+            ${bachSessionId}
+            answer {
+                id
+                sources {
+                    header {
+                        guid
+                        displayName
+                    }
+                }
+                filterGroups {
+                    columnInfo {
+                        name
+                        referencedColumns {
+                            guid
+                            displayName
+                        }
+                    }
+                    filters {
+                        filterContent {
+                            filterType
+                            negate
+                            value {
+                                key
+                            }
+                        }
+                    }
+                }
+                visualizations {
+                    ... on TableViz {
+                        columns {
+                            column {
+                                id
+                                name
+                                referencedColumns {
+                                    guid
+                                    displayName
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+`;
+
 export const getAnswerData = `
     query GetTableWithHeadlineData($session: BachSessionIdInput!, $deadline: Int!, $dataPaginationParams: DataPaginationParamsInput!) {
         getAnswer(session: $session) {

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

@@ -1,7 +1,7 @@
 import 'jest-fetch-mock';
-import { AuthType, VizPoint } from '../../../types';
+import { AuthType, RuntimeFilterOp, VizPoint } from '../../../types';
 import { AnswerService } from './answerService';
-import { getAnswerData, removeColumns } from './answer-queries';
+import { getAnswerData, removeColumns, addFilter } from './answer-queries';
 import * as authTokenInstance from '../../../authToken';
 import * as tokenizedFetch from '../../../tokenizedFetch';
 import * as embedConfigInstance from '../../../embed/embedConfig';
@@ -266,4 +266,90 @@ describe('Answer service tests', () => {
         const answerService = createAnswerService({}, null);
         await expect(answerService.getUnderlyingDataForPoint(['col2'])).rejects.toThrow();
     });
+
+    test('addFilter should call the right API', async () => {
+        fetchMock.mockResponses(
+            JSON.stringify({
+                data: {
+                    getSourceDetailById: [{
+                        columns: [{
+                            id: 'id1',
+                            name: 'col1',
+                        }],
+                    }],
+                },
+            }),
+            JSON.stringify({
+                data: {
+                    Answer__addUpdateFilter: {
+                        id: {
+                            genNo: 2,
+                        },
+                    },
+                },
+            }),
+        );
+        const answerService = createAnswerService({
+            sources: [{
+                header: {
+                    guid: 'source1',
+                },
+            }],
+        });
+        const session = await answerService.addFilter('col1', RuntimeFilterOp.IN, [2]);
+        expect(fetchMock).toHaveBeenCalledWith(
+            'https://tshost/prism/?op=AddUpdateFilter',
+            expect.objectContaining({
+                body: JSON.stringify({
+                    operationName: 'AddUpdateFilter',
+                    query: addFilter,
+                    variables: {
+                        session: defaultSession,
+                        params: {
+                            filterContent: [{
+                                filterType: 'IN',
+                                value: [{
+                                    type: 'DOUBLE',
+                                    doubleValue: 2,
+                                }],
+                            }],
+                            filterGroupId: {
+                                logicalColumnId: 'id1',
+                            },
+                        },
+                    },
+                }),
+            }),
+        );
+    });
+
+    test('Should fetch answer if not passed', async () => {
+        fetchMock.mockResponses(JSON.stringify({
+            data: {
+                getAnswer: {
+                    id: {},
+                    answer: {
+                        visualizations: [{
+                            columns: [{
+                                column: {
+                                    id: 'id1',
+                                    name: 'col1',
+                                },
+                            }],
+                        }],
+                        sources: [{
+                            header: {
+                                guid: 'source1',
+                                displayName: 'source1',
+                            },
+                        }],
+                        filterGroups: [],
+                    },
+                },
+            },
+        }));
+        const answerService = new AnswerService(defaultSession, null, 'https://tshost');
+        const answer = await answerService.getAnswer();
+        expect(answer.sources[0].header.guid).toBe('source1');
+    });
 });

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

@@ -1,6 +1,8 @@
 import { tokenizedFetch } from '../../../tokenizedFetch';
-import type { ColumnValue, VizPoint } from '../../../types';
-import { deepMerge, removeTypename } from '../../../utils';
+import type {
+    ColumnValue, RuntimeFilter, RuntimeFilterOp, VizPoint,
+} from '../../../types';
+import { deepMerge, getTypeFromValue, removeTypename } from '../../../utils';
 import { graphqlQuery } from '../graphql-request';
 import { getSourceDetail } from '../sourceService';
 import * as queries from './answer-queries';
@@ -27,7 +29,6 @@ export interface UnderlyingDataPoint {
  * custom action payload. This service could be used to run
  * graphql queries in the context of the answer on which the
  * custom action was triggered.
- *
  * @example
  * ```js
  *  embed.on(EmbedEvent.CustomAction, e => {
@@ -37,13 +38,24 @@ export interface UnderlyingDataPoint {
  *     const data = await underlying.fetchData(0, 100);
  *  })
  * ```
+ * @example
+ * ```js
+ * embed.on(EmbedEvent.Data, async (e) => {
+ *     const service = await embed.getAnswerService();
+ *     await service.addColumns([
+ *         "<column guid>"
+ *     ]);
+ *     console.log(await service.fetchData());
+ * });
+ * ```
  * @version SDK: 1.25.0| ThoughtSpot: 9.10.0.cl
  * @group Events
  */
 export class AnswerService {
+    private answer: Promise<any>;
+
     /**
      * Should not need to be called directly.
-     *
      * @param session
      * @param answer
      * @param thoughtSpotHost
@@ -51,11 +63,19 @@ export class AnswerService {
      */
     constructor(
         private session: SessionInterface,
-        private answer: any,
+        answer: any,
         private thoughtSpotHost: string,
         private selectedPoints?: VizPoint[],
     ) {
         this.session = removeTypename(session);
+        if (!answer) {
+            this.answer = this.executeQuery(
+                queries.getAnswer,
+                {},
+            ).then((data) => data?.answer);
+        } else {
+            this.answer = answer;
+        }
     }
 
     /**
@@ -63,7 +83,7 @@ export class AnswerService {
      * This can be used to get the list of all columns in the data source for example.
      */
     public async getSourceDetail() {
-        const sourceId = this.answer.sources[0].header.guid;
+        const sourceId = (await this.answer).sources[0].header.guid;
         return getSourceDetail(
             this.thoughtSpotHost,
             sourceId,
@@ -72,7 +92,6 @@ export class AnswerService {
 
     /**
      * Remove columnIds and return updated answer session.
-     *
      * @param columnIds
      * @returns
      */
@@ -87,7 +106,6 @@ export class AnswerService {
 
     /**
      * Add columnIds and return updated answer session.
-     *
      * @param columnIds
      * @returns
      */
@@ -100,9 +118,63 @@ export class AnswerService {
         );
     }
 
+    /**
+     * Add columns by names and return updated answer session.
+     * @param columnNames
+     * @returns
+     * @example
+     * ```js
+     * embed.on(EmbedEvent.Data, async (e) => {
+     *    const service = await embed.getAnswerService();
+     *    await service.addColumnsByNames([
+     *      "col name 1",
+     *      "col name 2"
+     *    ]);
+     *    console.log(await service.fetchData());
+     * });
+     */
+    public async addColumnsByNames(columnNames: string[]) {
+        const sourceDetail = await this.getSourceDetail();
+        const columnGuids = getGuidsFromColumnNames(sourceDetail, columnNames);
+        return this.addColumns([...columnGuids]);
+    }
+
+    /**
+     * Add a filter to the answer.
+     * @param columnName
+     * @param operator
+     * @param values
+     * @returns
+     */
+    public async addFilter(columnName: string, operator: RuntimeFilterOp, values: RuntimeFilter['values']) {
+        const sourceDetail = await this.getSourceDetail();
+        const columnGuids = getGuidsFromColumnNames(sourceDetail, [columnName]);
+        return this.executeQuery(
+            queries.addFilter,
+            {
+                params: {
+                    filterContent: [{
+                        filterType: operator,
+                        value: values.map(
+                            (v) => {
+                                const [type, prefix] = getTypeFromValue(v);
+                                return {
+                                    type: type.toUpperCase(),
+                                    [`${prefix}Value`]: v,
+                                };
+                            },
+                        ),
+                    }],
+                    filterGroupId: {
+                        logicalColumnId: columnGuids.values().next().value,
+                    },
+                },
+            },
+        );
+    }
+
     /**
      * Fetch data from the answer.
-     *
      * @param offset
      * @param size
      * @returns
@@ -131,7 +203,6 @@ export class AnswerService {
     /**
      * Fetch the data for the answer as a CSV blob. This might be
      * quicker for larger data.
-     *
      * @param userLocale
      * @param includeInfo Include the CSV header in the output
      * @returns Response
@@ -146,7 +217,6 @@ export class AnswerService {
     /**
      * Just get the internal URL for this answer's data
      * as a CSV blob.
-     *
      * @param userLocale
      * @param includeInfo
      * @returns
@@ -159,7 +229,6 @@ export class AnswerService {
      * Get underlying data given a point and the output column names.
      * In case of a context menu action, the selectedPoints are
      * automatically passed.
-     *
      * @param outputColumnNames
      * @param selectedPoints
      * @example
@@ -224,7 +293,6 @@ export class AnswerService {
 
     /**
      * Execute a custom graphql query in the context of the answer.
-     *
      * @param query graphql query
      * @param variables graphql variables
      * @returns
@@ -246,12 +314,15 @@ export class AnswerService {
 
     /**
      * Get the internal session details for the answer.
-     *
      * @returns
      */
     public getSession() {
         return this.session;
     }
+
+    public getAnswer() {
+        return this.answer;
+    }
 }
 
 /**
@@ -261,12 +332,12 @@ export class AnswerService {
  */
 function getGuidsFromColumnNames(sourceDetail: any, colNames: string[]) {
     const cols = sourceDetail.columns.reduce((colSet: any, col: any) => {
-        colSet[col.name] = col;
+        colSet[col.name.toLowerCase()] = col;
         return colSet;
     }, {});
 
     return new Set(colNames.map((colName) => {
-        const col = cols[colName];
+        const col = cols[colName.toLowerCase()];
         return col.id;
     }));
 }

package/src/utils/logger.ts

@@ -1,11 +1,10 @@
-import isUndefined from 'lodash/isUndefined';
-import noop from 'lodash/noop';
+import { isUndefined } from '../utils';
 import { LogLevel } from '../types';
 
 const logFunctions: {
     [key: string]: (...args: any[]) => void;
 } = {
-    [LogLevel.SILENT]: noop,
+    [LogLevel.SILENT]: () => undefined,
     [LogLevel.ERROR]: console.error,
     [LogLevel.WARN]: console.warn,
     [LogLevel.INFO]: console.info,

package/src/utils/processData.spec.ts

@@ -4,11 +4,9 @@ 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,
@@ -37,7 +35,7 @@ describe('Unit test for process data', () => {
             expect.objectContaining({
                 ...processedData,
                 answerService: {
-                    answer: undefined,
+                    answer: {},
                     selectedPoints: undefined,
                     session: undefined,
                     thoughtSpotHost: 'http://localhost',
@@ -60,14 +58,15 @@ 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 } from '../auth';
+import { AuthFailureType, initSession } from '../auth';
 import { AuthType, CustomActionPayload, EmbedEvent } from '../types';
 import { AnswerService } from './graphql/answerService/answerService';
 import { resetCachedAuthToken } from '../authToken';
@@ -19,7 +19,7 @@ export function processCustomAction(e: any, thoughtSpotHost: string) {
     const { session, embedAnswerData, contextMenuPoints } = e.data as CustomActionPayload;
     const answerService = new AnswerService(
         session,
-        embedAnswerData,
+        embedAnswerData || {},
         thoughtSpotHost,
         contextMenuPoints?.selectedPoints,
     );
@@ -34,6 +34,8 @@ 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/processTrigger.ts

@@ -3,7 +3,6 @@ import { HostEvent } from '../types';
 
 /**
  * Reloads the ThoughtSpot iframe.
- *
  * @param iFrame
  */
 export const reload = (iFrame: HTMLIFrameElement) => {
@@ -16,7 +15,6 @@ export const reload = (iFrame: HTMLIFrameElement) => {
 
 /**
  * Post iframe message.
- *
  * @param iFrame
  * @param message
  * @param message.type