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

package/src/utils/graphql/nlsService/nls-answer-queries.ts

@@ -0,0 +1,399 @@
+export const getAnswerSessionFromQuery = `
+query GetEurekaResults($params: Input_eureka_SearchRequest) {
+        queryRequest(request: $params) {
+            ...eurekaResults
+            __typename
+        }
+    }
+
+        fragment eurekaResults on eureka_SearchResponse {
+        facets {
+            facetType
+            facetValue
+            facetValues {
+            id
+            resultCount
+            name
+            __typename
+            }
+            __typename
+        }
+        requestIdentifiers {
+            apiRequestId
+            appActivityId
+            __typename
+        }
+        sageQuerySuggestions {
+            llmReasoning {
+                assumptions
+                clarifications
+                interpretation
+                __typename
+            }
+            tokens
+            tmlTokens
+            worksheetId
+            description
+            title
+            tmlTokens
+            formulaInfo {
+            name
+            expression
+            __typename
+            }
+            tmlPhrases
+            ambiguousPhrases {
+            alternativePhrases {
+                phraseType
+                token {
+                token
+                dataType
+                typeEnum
+                guid
+                tokenMetadata {
+                    name
+                    __typename
+                }
+                __typename
+                }
+                __typename
+            }
+            ambiguityType
+            token {
+                token
+                dataType
+                typeEnum
+                guid
+                tokenMetadata {
+                name
+                __typename
+                }
+                __typename
+            }
+            __typename
+            }
+            ambiguousTokens {
+            alternativeTokens {
+                token
+                dataType
+                typeEnum
+                guid
+                tokenMetadata {
+                name
+                deprecatedTableGuid
+                deprecatedTableName
+                isFormula
+                rootTables {
+                    created
+                    description
+                    guid
+                    indexVersion
+                    modified
+                    name
+                    __typename
+                }
+                schemaTableUserDefinedName
+                table {
+                    created
+                    description
+                    guid
+                    indexVersion
+                    modified
+                    name
+                    __typename
+                }
+                __typename
+                }
+                __typename
+            }
+            ambiguityType
+            token {
+                token
+                dataType
+                typeEnum
+                guid
+                tokenMetadata {
+                name
+                __typename
+                }
+                __typename
+            }
+            __typename
+            }
+            sessionId
+            genNo
+            stateKey {
+                generationNumber
+                transactionId
+            __typename
+            }
+            subQueries {
+            tokens
+            cohortConfig {
+                anchorColumnId
+                cohortAnswerGuid
+                cohortGroupingType
+                cohortGuid
+                cohortType
+                combineNonGroupValues
+                description
+                groupExcludedQueryValues
+                hideExcludedQueryValues
+                isEditable
+                name
+                nullOutputValue
+                returnColumnId
+                __typename
+            }
+            formulas {
+                name
+                expression
+                __typename
+            }
+            __typename
+            }
+            visualizationSuggestion {
+            chartType
+            displayMode
+            axisConfigs {
+                category
+                color
+                hidden
+                size
+                sort
+                x
+                y
+                __typename
+            }
+            usersVizIntentApplied
+            customChartConfigs {
+                dimensions {
+                columns
+                key
+                __typename
+                }
+                key
+                __typename
+            }
+            customChartGuid
+            __typename
+            }
+            tableData {
+            columnDataLite {
+                columnId
+                columnDataType
+                dataValue
+                columnName
+                __typename
+            }
+            __typename
+            }
+            warningType
+            cached
+            warningDetails {
+            warningType
+            __typename
+            }
+            __typename
+        }
+        results {
+            objectSecurityInfo {
+            objectType
+            objectId
+            objectIdForDeletionCheck
+            objectTypeForDeletionCheck
+            isD13ySourced
+            offset
+            __typename
+            }
+            searchAnswer {
+            ...eurekaAnswer
+            __typename
+            }
+            searchPinboardViz {
+            answer {
+                ...eurekaAnswer
+                __typename
+            }
+            pinboardHeader {
+                id
+                title
+                __typename
+            }
+            __typename
+            }
+            searchPinboard {
+            header {
+                ...header
+                __typename
+            }
+            usageInfo {
+                ...usageInfo
+                __typename
+            }
+            answers {
+                ...eurekaAnswer
+                __typename
+            }
+            vizCount {
+                charts
+                metrics
+                tables
+                __typename
+            }
+            __typename
+            }
+            snippetInfo {
+            titleSnippet {
+                snippetString
+                highlights {
+                start
+                end
+                __typename
+                }
+                __typename
+            }
+            descriptionSnippet {
+                snippetString
+                highlights {
+                start
+                end
+                __typename
+                }
+                __typename
+            }
+            sageQuerySnippet {
+                phrase {
+                isCompletePhrase
+                numTokens
+                phraseType
+                startIndex
+                __typename
+                }
+                token {
+                token
+                dataType
+                typeEnum
+                __typename
+                }
+                __typename
+            }
+            sageQuerySnippetWithHighlights {
+                highlights {
+                start
+                end
+                __typename
+                }
+                phraseType
+                phraseValue
+                __typename
+            }
+            __typename
+            }
+            score
+            debugInfo
+            resultType
+            sageQuery
+            __typename
+        }
+        version
+        nextPageOffset
+        batchSizeRequired
+        isFinalPage
+        totalResults
+        totalFacetResultCount
+        errorCode
+        debugInfo {
+            fewShotExamples {
+            chartType
+            formulas {
+                name
+                expression
+                __typename
+            }
+            id
+            mappingId
+            nlQuery
+            nlQueryConcepts
+            sageQuery
+            scope
+            sql
+            tml
+            feedbackType
+            __typename
+            }
+            __typename
+        }
+        __typename
+        }
+
+        fragment eurekaAnswer on eureka_AnswerResult {
+        header {
+            ...header
+            __typename
+        }
+        usageInfo {
+            ...usageInfo
+            __typename
+        }
+        preferredViz {
+            ...visualizationMetadata
+            __typename
+        }
+        worksheetInfo {
+            ...worksheetInfo
+            __typename
+        }
+        formatted {
+            phrase {
+            isCompletePhrase
+            numTokens
+            phraseType
+            startIndex
+            __typename
+            }
+            token {
+            token
+            typeEnum
+            __typename
+            }
+            __typename
+        }
+        __typename
+        }
+
+        fragment header on eureka_Header {
+        id
+        title
+        description
+        authorGuid
+        authorName
+        createdOn
+        tagIds
+        __typename
+        }
+
+        fragment usageInfo on eureka_UsageInfo {
+        favouriteCount
+        viewCount
+        __typename
+        }
+
+        fragment visualizationMetadata on eureka_VisualizationMetadata {
+        vizType
+        chartType
+        vizSnapshotRequestData {
+            parentReportbookGuid
+            parentType
+            version
+            vizGuid
+            __typename
+        }
+        __typename
+        }
+
+        fragment worksheetInfo on eureka_WorksheetInfo {
+        id
+        name
+        __typename
+        }`;

package/src/utils/graphql/nlsService/nls-answer-service.spec.ts

@@ -0,0 +1,35 @@
+import 'jest-fetch-mock';
+import { getAnswerFromQuery } from './nls-answer-service';
+
+describe('getAnswerFromQuery', () => {
+    test('should return answer and suggestion', async () => {
+        fetchMock.mockResponses(
+            JSON.stringify({
+                data: {
+                    queryRequest: {
+                        sageQuerySuggestions: [
+                            {
+                                sessionId: 'sessionId',
+                                genNo: 2,
+                                stateKey: {
+                                    transactionId: 'transactionId',
+                                    generationNumber: 1,
+                                },
+                            },
+                        ],
+                    },
+                },
+            }),
+        );
+        const query = 'query';
+        const worksheetId = 'worksheetId';
+
+        const res = await getAnswerFromQuery(query, worksheetId);
+
+        const session = res.answer.getSession();
+        expect(session.sessionId).toEqual('sessionId');
+        expect(session.genNo).toEqual(2);
+        expect(session.acSession.sessionId).toEqual('transactionId');
+        expect(session.acSession.genNo).toEqual(1);
+    });
+});

package/src/utils/graphql/nlsService/nls-answer-service.ts

@@ -0,0 +1,58 @@
+import { getEmbedConfig } from '../../../embed/embedConfig';
+import { SessionInterface, AnswerService } from '../answerService/answerService';
+import { graphqlQuery } from '../graphql-request';
+import * as queries from './nls-answer-queries';
+
+/**
+ *
+ * @param query string
+ * @param worksheetId string
+ * @returns answerService AnswerService
+ */
+export const getAnswerFromQuery = async (
+    query: string,
+    worksheetId: string,
+): Promise<{ answer: AnswerService, suggestion: any }> => {
+    const embedConfig = getEmbedConfig();
+    const resp = await graphqlQuery({
+        query: queries.getAnswerSessionFromQuery,
+        variables: {
+            params: {
+                facetSelections: [],
+                filterSelections: [
+                    {
+                        facetType: 'WORKSHEETS',
+                        facetValue: [
+                            worksheetId,
+                        ],
+                    },
+                ],
+                query,
+                worksheetFacetPayload: {
+                    worksheetId,
+                },
+                searchOption: 'AI_ANSWER',
+            },
+        },
+        thoughtSpotHost: embedConfig.thoughtSpotHost,
+        isCompositeQuery: false,
+    });
+
+    const suggestion = resp.sageQuerySuggestions[0];
+    const answerSession: SessionInterface = {
+        sessionId: suggestion.sessionId,
+        genNo: suggestion.genNo,
+        acSession: {
+            sessionId: suggestion.stateKey.transactionId,
+            genNo: suggestion.stateKey.generationNumber,
+        },
+    };
+    return {
+        answer: new AnswerService(
+            answerSession,
+            null,
+            embedConfig.thoughtSpotHost,
+        ),
+        suggestion,
+    };
+};

package/src/utils/graphql/preview-service.spec.ts

@@ -0,0 +1,20 @@
+import 'jest-fetch-mock';
+import { getPreview } from './preview-service';
+
+describe('getPreview', () => {
+    test('should return preview', async () => {
+        fetchMock.mockResponses(
+            JSON.stringify({
+                data: {
+                    getEurekaVizSnapshot: {
+                        id: 'previewId',
+                        vizcontent: '<vizcontent>',
+                    },
+                },
+            }),
+        );
+        const res = await getPreview('tshost', 'vizId', 'liveboardId');
+        expect(res.id).toEqual('previewId');
+        expect(res.vizcontent).toEqual('<vizcontent>');
+    });
+});

package/src/utils/graphql/preview-service.ts

@@ -18,6 +18,12 @@ query GetEurekaVizSnapshots(
   } 
 `;
 
+/**
+ *
+ * @param thoughtSpotHost
+ * @param vizId
+ * @param liveboardId
+ */
 export async function getPreview(
     thoughtSpotHost: string,
     vizId: string,

package/src/utils/liveboardService/liveboardService.spec.ts

@@ -0,0 +1,63 @@
+import 'jest-fetch-mock';
+import * as base from '../../embed/base';
+import { createLiveboardWithAnswers } from './liveboardService';
+
+describe('createLiveboardWithAnswers', () => {
+    test('should create liveboard with answers', async () => {
+        const answers: any = [
+            {
+                getTML: jest.fn().mockResolvedValue({
+                    answer: {
+                        search_query: '[revenue]',
+                    },
+                }),
+            },
+        ];
+        const name = 'liveboard';
+        const thoughtSpotHost = 'https://thoughtspot.example.com';
+        const liveboardId = 'liveboardId';
+        const lbTml = {
+            guid: liveboardId,
+            liveboard: {
+                name,
+                visualizations: [
+                    {
+                        id: 'Viz_0',
+                        answer: {
+                            search_query: '[revenue]',
+                        },
+                    },
+                ],
+                layout: {
+                    tiles: [
+                        {
+                            visualization_id: 'Viz_0',
+                            size: 'MEDIUM_SMALL',
+                        },
+                    ],
+                },
+            },
+        };
+        const result = {
+            success: true,
+        };
+
+        fetchMock.mockResponseOnce(JSON.stringify([{ metadata_id: liveboardId }]));
+        jest.spyOn(base, 'executeTML').mockResolvedValue(result);
+        const res = await createLiveboardWithAnswers(answers, name);
+        expect(res).toEqual(result);
+        expect(base.executeTML).toHaveBeenCalledWith({
+            metadata_tmls: [JSON.stringify(lbTml)],
+            import_policy: 'ALL_OR_NONE',
+        });
+
+        fetchMock.mockResponseOnce(JSON.stringify([]));
+        jest.spyOn(base, 'executeTML').mockResolvedValue(result);
+        await createLiveboardWithAnswers(answers, name);
+        delete lbTml.guid;
+        expect(base.executeTML).toHaveBeenCalledWith({
+            metadata_tmls: [JSON.stringify(lbTml)],
+            import_policy: 'ALL_OR_NONE',
+        });
+    });
+});

package/src/utils/liveboardService/liveboardService.ts

@@ -0,0 +1,55 @@
+import { tokenizedFetch } from '../../tokenizedFetch';
+import { AnswerService } from '../graphql/answerService/answerService';
+import { getEmbedConfig } from '../../embed/embedConfig';
+import { executeTML } from '../../embed/base';
+
+export const createLiveboardWithAnswers = async (
+    answers: AnswerService[],
+    name: string,
+): Promise<any> => {
+    const { thoughtSpotHost, authType } = getEmbedConfig();
+    const resp = await tokenizedFetch(
+        `${thoughtSpotHost}/api/rest/2.0/metadata/search`, {
+            method: 'POST',
+            credentials: 'include',
+            headers: {
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({
+                metadata: [{
+                    type: 'LIVEBOARD',
+                    identifier: name,
+                }],
+            }),
+        },
+    );
+    const lbList = await resp.json();
+    const liveboardId = lbList[0]?.metadata_id;
+
+    const answerTMLs = (await Promise.all(answers.map((a) => a.getTML())))
+        .filter((tml: any) => tml.answer.search_query);
+
+    const lbTml: any = {
+        guid: liveboardId,
+        liveboard: {
+            name,
+            visualizations: answerTMLs.map((tml: any, idx) => ({
+                id: `Viz_${idx}`,
+                answer: tml.answer,
+            })),
+            layout: {
+                tiles: answerTMLs.map((tml: any, idx) => ({
+                    visualization_id: `Viz_${idx}`,
+                    size: 'MEDIUM_SMALL',
+                })),
+            },
+        },
+    };
+
+    const result = await executeTML({
+        metadata_tmls: [JSON.stringify(lbTml)],
+        import_policy: 'ALL_OR_NONE',
+    });
+
+    return result;
+};

package/src/utils/processData.spec.ts

@@ -1,3 +1,4 @@
+import { disable } from 'mixpanel-browser';
 import * as processDataInstance from './processData';
 import * as answerServiceInstance from './graphql/answerService/answerService';
 import * as auth from '../auth';
@@ -41,6 +42,7 @@ describe('Unit test for process data', () => {
                     selectedPoints: undefined,
                     session: undefined,
                     thoughtSpotHost: 'http://localhost',
+                    tmlOverride: {},
                 },
             }),
         );
@@ -171,4 +173,19 @@ describe('Unit test for process data', () => {
         expect(el.innerHTML).toBe('Hello');
         expect(embedConfigInstance.getEmbedConfig().autoLogin).toBe(false);
     });
+
+    test('process authFailure AuthType=None', () => {
+        const e = { type: EmbedEvent.AuthFailure };
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
+            loginFailedMessage: 'Hello',
+            authType: AuthType.EmbeddedSSO,
+            disableLoginFailurePage: true,
+        });
+        const el: any = {};
+        expect(processDataInstance.processEventData(e.type, e, '', el)).toEqual({
+            type: e.type,
+        });
+        expect(base.notifyAuthFailure).not.toBeCalled();
+        expect(el.innerHTML).not.toBe('Hello');
+    });
 });

package/src/utils/processData.ts

@@ -9,6 +9,7 @@ import { AuthFailureType } from '../auth';
 import { AuthType, CustomActionPayload, EmbedEvent } from '../types';
 import { AnswerService } from './graphql/answerService/answerService';
 import { resetCachedAuthToken } from '../authToken';
+import { ERROR_MESSAGE } from '../errors';
 
 /**
  *
@@ -62,9 +63,7 @@ function processNoCookieAccess(e: any, containerEl: Element) {
     if (!ignoreNoCookieAccess) {
         if (!suppressNoCookieAccessAlert && !suppressErrorAlerts) {
             // eslint-disable-next-line no-alert
-            alert(
-                'Third party cookie access is blocked on this browser, please allow third party cookies for this to work properly. \nYou can use `suppressNoCookieAccessAlert` to suppress this message.',
-            );
+            alert(ERROR_MESSAGE.THIRD_PARTY_COOKIE_BLOCKED_ALERT);
         }
         // eslint-disable-next-line no-param-reassign
         containerEl.innerHTML = loginFailedMessage;
@@ -79,8 +78,8 @@ function processNoCookieAccess(e: any, containerEl: Element) {
  * @param containerEl
  */
 export function processAuthFailure(e: any, containerEl: Element) {
-    const { loginFailedMessage, authType } = getEmbedConfig();
-    if (authType !== AuthType.None) {
+    const { loginFailedMessage, authType, disableLoginFailurePage } = getEmbedConfig();
+    if (authType !== AuthType.None && !disableLoginFailurePage) {
         // eslint-disable-next-line no-param-reassign
         containerEl.innerHTML = loginFailedMessage;
         notifyAuthFailure(AuthFailureType.OTHER);