@thoughtspot/visual-embed-sdk 1.24.0-dev → 1.24.0-preRender.1

package/src/utils/graphql/graphql-request.ts

@@ -0,0 +1,45 @@
+import { getOperationNameFromQuery } from '../../utils';
+
+/**
+ *
+ * @param root0
+ * @param root0.query
+ * @param root0.variables
+ * @param root0.thoughtSpotHost
+ * @param root0.isCompositeQuery
+ */
+export async function graphqlQuery({
+    query,
+    variables,
+    thoughtSpotHost,
+    isCompositeQuery = false,
+}: {
+    query: string,
+    variables: any,
+    thoughtSpotHost: string,
+    isCompositeQuery?: boolean
+}) {
+    const operationName = getOperationNameFromQuery(query);
+    try {
+        const response = await fetch(`${thoughtSpotHost}/prism/?op=${operationName}`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json;charset=UTF-8',
+                'x-requested-by': 'ThoughtSpot',
+                accept: '*/*',
+                'accept-language': 'en-us',
+            },
+            body: JSON.stringify({
+                operationName,
+                query,
+                variables,
+            }),
+            credentials: 'include',
+        });
+        const result = await response.json();
+        const dataValues = Object.values(result.data);
+        return (isCompositeQuery) ? result.data : dataValues[0];
+    } catch (error) {
+        return error;
+    }
+}

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

@@ -0,0 +1,10 @@
+import 'jest-fetch-mock';
+import { getSourceDetail } from './sourceService';
+
+describe('Source service tests', () => {
+    test('Should return source detail and cache it', async () => {
+        await getSourceDetail('https://tshost', 'id');
+        await getSourceDetail('https://tshost', 'id');
+        expect(fetchMock).toBeCalledTimes(1);
+    });
+});

package/src/utils/graphql/sourceService.ts

@@ -0,0 +1,71 @@
+import { graphqlQuery } from './graphql-request';
+
+export const getSourceDetailQuery = `
+    query GetSourceDetail($ids: [GUID!]!) {
+        getSourceDetailById(ids: $ids, type: LOGICAL_TABLE) {
+        id
+        name
+        description
+        authorName
+        authorDisplayName
+        isExternal
+        type
+        created
+        modified
+        columns {
+            id
+            name
+            author
+            authorDisplayName
+            description
+            dataType
+            type
+            modified
+            ownerName
+            owner
+            dataRecency
+            sources {
+            tableId
+            tableName
+            columnId
+            columnName
+            __typename
+            }
+            synonyms
+            cohortAnswerId
+            __typename
+        }
+        relationships
+        destinationRelationships
+        dataSourceId
+        __typename
+        }
+    }  
+`;
+
+const sourceDetailCache = new Map<string, any>();
+
+/**
+ *
+ * @param thoughtSpotHost
+ * @param sourceId
+ */
+export async function getSourceDetail(
+    thoughtSpotHost: string,
+    sourceId: string,
+): Promise<any> {
+    if (sourceDetailCache.has(sourceId)) {
+        return sourceDetailCache.get(sourceId);
+    }
+    const details = await graphqlQuery({
+        query: getSourceDetailQuery,
+        variables: {
+            ids: [sourceId],
+        },
+        thoughtSpotHost,
+    });
+
+    const souceDetails = details[0];
+    sourceDetailCache.set(sourceId, souceDetails);
+    return souceDetails;
+}

package/src/utils/processData.spec.ts

@@ -1,8 +1,8 @@
 import * as processDataInstance from './processData';
-import * as answerServiceInstance from './answerService';
+import * as answerServiceInstance from './graphql/answerService/answerService';
 import * as auth from '../auth';
 import * as base from '../embed/base';
-import { EmbedEvent, OperationType, AuthType } from '../types';
+import { EmbedEvent, AuthType } from '../types';
 
 describe('Unit test for process data', () => {
     beforeAll(() => {
@@ -16,26 +16,12 @@ describe('Unit test for process data', () => {
     });
 
     const thoughtSpotHost = 'http://localhost';
-    test('processDataInstance, when operation is GetChartWithData', () => {
-        const answerService = {};
-        const processChartData = {
-            answerService,
-            data: {
-                session: 'session',
-                query: 'query',
-                operation: OperationType.GetChartWithData,
-            },
-        };
-        jest.spyOn(answerServiceInstance, 'getAnswerServiceInstance').mockReturnValue(
-            answerService,
-        );
-        expect(
-            processDataInstance.processCustomAction(processChartData, thoughtSpotHost),
-        ).toStrictEqual(processChartData);
-    });
 
     test('ProcessData, when Action is CustomAction', async () => {
-        const processedData = { type: EmbedEvent.CustomAction };
+        const processedData = {
+            type: EmbedEvent.CustomAction,
+            data: {},
+        };
         jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
         expect(
             processDataInstance.processEventData(
@@ -44,16 +30,20 @@ describe('Unit test for process data', () => {
                 thoughtSpotHost,
                 null,
             ),
-        ).toStrictEqual(processedData);
+        ).toEqual(expect.objectContaining({
+            ...processedData,
+            answerService: {
+                answer: undefined,
+                selectedPoints: undefined,
+                session: undefined,
+                thoughtSpotHost: 'http://localhost',
+            },
+        }));
     });
 
     test('ProcessData, when Action is non CustomAction', () => {
         const processedData = { type: EmbedEvent.Data };
         jest.spyOn(processDataInstance, 'processCustomAction').mockImplementation(async () => ({}));
-        jest.spyOn(
-            answerServiceInstance,
-            'getAnswerServiceInstance',
-        ).mockImplementation(async () => ({}));
         processDataInstance.processEventData(EmbedEvent.Data, processedData, thoughtSpotHost, null);
         expect(processDataInstance.processCustomAction).not.toBeCalled();
     });

package/src/utils/processData.ts

@@ -6,8 +6,8 @@ import {
     notifyLogout,
 } from '../embed/base';
 import { AuthFailureType, initSession } from '../auth';
-import { AuthType, EmbedEvent, OperationType } from '../types';
-import { getAnswerServiceInstance } from './answerService';
+import { AuthType, CustomActionPayload, EmbedEvent } from '../types';
+import { AnswerService } from './graphql/answerService/answerService';
 
 /**
  *
@@ -15,19 +15,17 @@ import { getAnswerServiceInstance } from './answerService';
  * @param thoughtSpotHost
  */
 export function processCustomAction(e: any, thoughtSpotHost: string) {
-    if (
-        [OperationType.GetChartWithData, OperationType.GetTableWithHeadlineData].includes(
-            e.data?.operation,
-        )
-    ) {
-        const { session, query, operation } = e.data;
-        const answerService = getAnswerServiceInstance(session, query, operation, thoughtSpotHost);
-        return {
-            ...e,
-            answerService,
-        };
-    }
-    return e;
+    const { session, embedAnswerData, contextMenuPoints } = e.data as CustomActionPayload;
+    const answerService = new AnswerService(
+        session,
+        embedAnswerData,
+        thoughtSpotHost,
+        contextMenuPoints?.selectedPoints,
+    );
+    return {
+        ...e,
+        answerService,
+    };
 }
 
 /**

package/src/utils.ts

@@ -249,6 +249,30 @@ export function getDOMNode(domSelector: DOMSelector): HTMLElement {
 
 export const deepMerge = (target: any, source: any) => merge(target, source);
 
+export const getOperationNameFromQuery = (query: string) => {
+    const regex = /(?:query|mutation)\s+(\w+)/;
+    const matches = query.match(regex);
+    return matches?.[1];
+};
+
+/**
+ *
+ * @param obj
+ */
+export function removeTypename(obj: any) {
+    if (!obj || typeof obj !== 'object') return obj;
+
+    // eslint-disable-next-line no-restricted-syntax
+    for (const key in obj) {
+        if (key === '__typename') {
+            delete obj[key];
+        } else if (typeof obj[key] === 'object') {
+            removeTypename(obj[key]);
+        }
+    }
+    return obj;
+}
+
 export const setStyleProperties = (
     element: HTMLElement,
     styleProperties: Partial<CSSStyleDeclaration>,

package/src/utils/answerService.spec.ts

@@ -1,41 +0,0 @@
-import { getAnswerServiceInstance } from './answerService';
-
-describe('Unit test for getAnswerServiceInstance', () => {
-    const session = {
-        sessionId: '',
-        genNo: 2,
-        acSession: { sessionId: '', genNo: 1 },
-    };
-    const query = '';
-    const thoughtSpotHost = 'http://10.79.135.124:3000';
-
-    test('fetchData, when api giving answer data', async () => {
-        const mockAnswerResponse = { data: {} };
-        global.fetch = jest.fn(() => Promise.resolve({
-            json: () => mockAnswerResponse,
-        }));
-        const answerService = getAnswerServiceInstance(
-            session,
-            query,
-            'GetTableWithHeadlineData',
-            thoughtSpotHost,
-        );
-        const answerData = await answerService.fetchData(1, 500);
-        expect(answerData).toStrictEqual(mockAnswerResponse.data);
-        expect(answerData).not.toBeInstanceOf(Error);
-        expect(fetch).toHaveBeenCalledTimes(1);
-    });
-
-    test('fetchData, when api giving error', async () => {
-        global.fetch = jest.fn(() => Promise.reject(new Error('failure')));
-        const answerService = getAnswerServiceInstance(
-            session,
-            query,
-            'GetChartWithData',
-            thoughtSpotHost,
-        );
-        const answerData = await answerService.fetchData(1, 500);
-        expect(answerData).toBeInstanceOf(Error);
-        expect(fetch).toHaveBeenCalledTimes(1);
-    });
-});

package/src/utils/answerService.ts

@@ -1,63 +0,0 @@
-import { SessionInterface, OperationType } from '../types';
-
-/**
- *
- * @param session
- * @param query
- * @param operation
- * @param thoughtSpotHost
- */
-export function getAnswerServiceInstance(
-    session: SessionInterface,
-    query: string,
-    operation: string,
-    thoughtSpotHost: string,
-): any {
-    let variable: any;
-
-    const fetchQuery = async (variables: any) => {
-        try {
-            const response = await fetch(`${thoughtSpotHost}/prism/?op=${operation}`, {
-                method: 'POST',
-                headers: {
-                    'content-type': 'application/json;charset=UTF-8',
-                    'x-requested-by': 'ThoughtSpot',
-                    accept: '*/*',
-                    'accept-language': 'en-us',
-                },
-                body: JSON.stringify({
-                    operationName: operation,
-                    query,
-                    variables,
-                }),
-                credentials: 'include',
-            });
-            const result = await response.json();
-            return result.data;
-        } catch (error) {
-            return error;
-        }
-    };
-
-    const fetchData = (offset: number, batchSize: number) => {
-        if (operation === OperationType.GetChartWithData) {
-            variable = { batchSize, offset: offset * batchSize };
-        } else {
-            variable = {
-                dataPaginationParams: {
-                    isClientPaginated: true,
-                    offset: offset * batchSize,
-                    size: batchSize,
-                },
-            };
-        }
-        return fetchQuery({
-            session,
-            ...variable,
-        });
-    };
-
-    return {
-        fetchData,
-    };
-}