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

package/src/auth.spec.ts

@@ -1,9 +1,8 @@
-import 'jest-fetch-mock';
 import * as authInstance from './auth';
 import * as authTokenService from './authToken';
 import * as EmbedConfig from './embed/embedConfig';
 import * as mixPanelService from './mixpanel-service';
-import { executeAfterWait, mockSessionInfo } from './test/test-utils';
+import { executeAfterWait } from './test/test-utils';
 import { AuthType, EmbedEvent } from './types';
 import * as checkReleaseVersionInBetaInstance from './utils';
 import * as authService from './utils/authService/authService';
@@ -103,6 +102,17 @@ export const embedConfig: any = {
 };
 
 const originalWindow = window;
+export const mockSessionInfo = {
+    userGUID: '1234',
+    mixpanelToken: 'abc123',
+    isPublicUser: false,
+    sessionId: '6588e7d9-710c-453e-a7b4-535fb3a8cbb2',
+    genNo: 3,
+    acSession: {
+        sessionId: 'cb202c48-b14b-4466-8a70-899ea666d46q',
+        genNo: 5,
+    },
+};
 
 export const mockSessionInfoApiResponse = {
     userGUID: '1234',
@@ -195,7 +205,6 @@ describe('Unit test for auth', () => {
     });
 
     test('doTokenAuth: when user is not loggedIn & getAuthToken not present, isLoggedIn should called', async () => {
-        fetchMock.mockResponse(JSON.stringify({ mixpanelAccessToken: '' }));
         jest.spyOn(tokenAuthService, 'isActiveService').mockImplementation(async () => false);
         jest.spyOn(authService, 'fetchAuthTokenService').mockImplementation(() => ({
             text: () => Promise.resolve('abc'),

package/src/auth.ts

@@ -214,6 +214,7 @@ async function isLoggedIn(thoughtSpotHost: string): Promise<boolean> {
  * Services to be called after the login is successful,
  * This should be called after the cookie is set for cookie auth or
  * after the token is set for cookieless.
+ *
  * @return {Promise<void>}
  * @example
  * ```js
@@ -230,7 +231,7 @@ export async function postLoginService(): Promise<void> {
             initMixpanel(sessionInfo);
         }
     } catch (e) {
-        logger.error('Post login services failed.', e.message, e);
+        logger.error('Post login services failed.', e.message);
     }
 }
 

package/src/authToken.ts

@@ -6,10 +6,6 @@ import { logger } from './utils/logger';
 let cachedAuthToken: string | null = null;
 
 // This method can be used to get the authToken using the embedConfig
-/**
- *
- * @param embedConfig
- */
 export async function getAuthenticationToken(embedConfig: EmbedConfig): Promise<string> {
     // Since we don't have token validation enabled , we cannot tell if the
     // cached token is valid or not. So we will always fetch a new token.

package/src/embed/app.ts

@@ -346,19 +346,6 @@ export interface AppViewConfig extends Omit<ViewConfig, 'visibleTabs'> {
      * @deprecated Use {@link collapseSearchBar} instead
      */
     collapseSearchBarInitially?: boolean;
-    /**
-     * To enable custom column groups in data panel v2.
-     * @version SDK: 1.32.0 | Thoughtspot: 10.0.0.cl
-     * @default false
-     * @example
-     * ```js
-     * const embed = new AppEmbed('#embed', {
-     *   ... // other app view config
-     *   enableCustomColumnGroups: true,
-     * });
-     * ```
-     */
-    enableCustomColumnGroups?: boolean;
     /**
      * This controls the initial behaviour of custom column groups accordion.
      * It takes DataPanelCustomColumnGroupsAccordionState enum values as input.

package/src/embed/liveboard.ts

@@ -386,6 +386,7 @@ export class LiveboardEmbed extends V1Embed {
             enableAskSage,
             enable2ColumnLayout,
             dataPanelV2 = true,
+            enableCustomColumnGroups = false,
         } = this.viewConfig;
 
         const preventLiveboardFilterRemoval = this.viewConfig.preventLiveboardFilterRemoval
@@ -438,6 +439,7 @@ export class LiveboardEmbed extends V1Embed {
         params[Param.ShowLiveboardReverifyBanner] = showLiveboardReverifyBanner;
 
         params[Param.DataPanelV2Enabled] = dataPanelV2;
+        params[Param.EnableCustomColumnGroups] = enableCustomColumnGroups;
         const queryParams = getQueryParamString(params, true);
 
         return queryParams;
@@ -607,25 +609,6 @@ export class LiveboardEmbed extends V1Embed {
             this.render();
         }
     }
-
-    /**
-     * Returns the full url of the liveboard/viz which can be used to open
-     * this liveboard inside the full Thoughtspot application in a new tab.
-     *
-     * @returns url string
-     */
-    public getLiveboardUrl(): string {
-        let url = `${this.thoughtSpotHost}/#/pinboard/${this.viewConfig.liveboardId}`;
-        if (this.viewConfig.activeTabId) {
-            url = `${url}/tab/${this.viewConfig.activeTabId}`;
-        }
-
-        if (this.viewConfig.vizId) {
-            url = `${url}/${this.viewConfig.vizId}`;
-        }
-
-        return url;
-    }
 }
 
 /**

package/src/embed/search.ts

@@ -239,19 +239,6 @@ export interface SearchViewConfig
      * @deprecated Use {@link collapseSearchBar} instead
      */
     collapseSearchBarInitially?: boolean;
-    /**
-     * To enable custom column groups in data panel v2
-     * @version SDK: 1.32.0 | Thoughtspot: 10.0.0.cl
-     * @default false
-     * @example
-     * ```js
-     * const embed = new SearchEmbed('#tsEmbed', {
-     *   ... // other options
-     *   enableCustomColumnGroups: true,
-     * });
-     * ```
-     */
-    enableCustomColumnGroups?: boolean;
     /**
      * Flag to enable onBeforeSearchExecute Embed Event
      * @version: SDK: 1.29.0 | Thoughtspot: 10.1.0.cl

package/src/embed/searchEmbed-basic-auth.spec.ts

@@ -0,0 +1,110 @@
+import { SearchEmbed } from './search';
+import * as baseInstance from './base';
+import * as authService from '../utils/authService';
+import * as authInstance from '../auth';
+import * as config from '../config';
+import * as embedConfigInstance from './embedConfig';
+
+import { init } from '../index';
+import { AuthType } from '../types';
+import { getDocumentBody, getRootEl } from '../test/test-utils';
+import { mockSessionInfo } from '../auth.spec';
+import { ERROR_MESSAGE } from '../errors';
+
+const thoughtSpotHost = 'tshost';
+init({
+    thoughtSpotHost,
+    authType: AuthType.Basic,
+    username: 'tsadmin',
+    password: 'admin',
+});
+
+describe('Search embed tests when authType is Basic', () => {
+    /**
+     *
+     * @param version
+     */
+    function setupVersion(version: string) {
+        jest.spyOn(window, 'addEventListener').mockImplementation((event, handler, options) => {
+            handler({
+                data: {
+                    type: 'xyz',
+                },
+                ports: [3000],
+                source: null,
+            });
+        });
+        jest.spyOn(authService, 'fetchSessionInfoService').mockImplementation(async () => ({
+            json: () => ({
+                ...mockSessionInfo,
+                releaseVersion: version,
+            }),
+            status: 200,
+        }));
+        jest.spyOn(authInstance, 'getReleaseVersion').mockReturnValue(version);
+    }
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+        jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValue(true);
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+
+    test('when releaseVersion is empty', async () => {
+        setupVersion('');
+        const mockAlert = spyOn(window, 'alert');
+        const searchEmbed = new SearchEmbed(getRootEl(), {});
+        await searchEmbed.render();
+        expect(mockAlert).not.toBeCalled();
+    });
+
+    test("when releaseVersion is '7.0.1.cl' ", async () => {
+        setupVersion('7.0.1.cl');
+        const mockAlert = jest.spyOn(window, 'alert');
+        const searchEmbed = new SearchEmbed(getRootEl(), {});
+        await searchEmbed.render();
+        expect(mockAlert).not.toBeCalled();
+    });
+    test('when releaseVersion is above 8.4.0.sw', async () => {
+        setupVersion('8.4.0.sw');
+        const mockAlert = jest.spyOn(window, 'alert');
+        const searchEmbed = new SearchEmbed(getRootEl(), {});
+        await searchEmbed.render();
+        expect(mockAlert).not.toBeCalled();
+    });
+
+    test('releaseVersion is above 8.4.0.sw', async () => {
+        setupVersion('8.8.0.sw');
+        jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
+        const mockAlert = jest.spyOn(window, 'alert');
+        const searchEmbed = new SearchEmbed(getRootEl(), {});
+        await searchEmbed.render();
+        expect(mockAlert).not.toBeCalled();
+    });
+
+    test('Alert should not appear when suppressSearchEmbedBetaWarning is true and releaseVersion is ts7.dec.cl', async () => {
+        setupVersion('ts7.dec.cl');
+        jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
+            suppressSearchEmbedBetaWarning: true,
+        });
+        const mockAlert = jest.spyOn(window, 'alert');
+        const searchEmbed = new SearchEmbed(getRootEl(), {});
+        await searchEmbed.render();
+        expect(mockAlert).not.toBeCalled();
+    });
+
+    test('Alert should not appear when suppressSearchEmbedBetaWarning is true and releaseVersion is 8.4.0.sw', async () => {
+        setupVersion('8.4.0.sw');
+        jest.spyOn(config, 'getThoughtSpotHost').mockImplementation(() => 'http://tshost');
+        jest.spyOn(embedConfigInstance, 'getEmbedConfig').mockReturnValue({
+            suppressSearchEmbedBetaWarning: true,
+        });
+        const mockAlert = jest.spyOn(window, 'alert');
+        const searchEmbed = new SearchEmbed(getRootEl(), {});
+        await searchEmbed.render();
+        expect(mockAlert).not.toBeCalled();
+    });
+});

package/src/embed/ts-embed.ts

@@ -1020,9 +1020,7 @@ export class TsEmbed {
      * THOUGHTSPOT URL params starts with a prefix "ts-"
      * @version SDK: 1.14.0 | ThoughtSpot: 8.4.0.cl, 8.4.1-sw
      */
-    public getThoughtSpotPostUrlParams(
-        additionalParams: { [key: string]: string | number } = {},
-    ): string {
+    public getThoughtSpotPostUrlParams(): string {
         const urlHash = window.location.hash;
         const queryParams = window.location.search;
         const postHashParams = urlHash.split('?');
@@ -1038,7 +1036,6 @@ export class TsEmbed {
         };
         queryParamsObj.forEach(addKeyValuePairCb);
         postURLParamsObj.forEach(addKeyValuePairCb);
-        Object.entries(additionalParams).forEach(([k, v]) => params.append(k, v as string));
 
         let tsParams = params.toString();
         tsParams = tsParams ? `?${tsParams}` : '';

package/src/index.ts

@@ -19,7 +19,6 @@ import {
 import { PinboardEmbed, LiveboardViewConfig, LiveboardEmbed } from './embed/liveboard';
 import { SearchEmbed, SearchViewConfig } from './embed/search';
 import { SearchBarEmbed, SearchBarViewConfig } from './embed/search-bar';
-import { BodylessConversation, BodylessConversationViewConfig } from './embed/bodyless-conversation';
 import {
     AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter,
 } from './auth';
@@ -56,8 +55,6 @@ import { AnswerService, SessionInterface, UnderlyingDataPoint } from './utils/gr
 import { getEmbedConfig } from './embed/embedConfig';
 import { uploadMixpanelEvent, MIXPANEL_EVENT } from './mixpanel-service';
 import { tokenizedFetch } from './tokenizedFetch';
-import { getAnswerFromQuery } from './utils/graphql/nlsService/nls-answer-service';
-import { createLiveboardWithAnswers } from './utils/liveboardService/liveboardService';
 
 export {
     init,
@@ -70,16 +67,12 @@ export {
     getEmbedConfig as getInitConfig,
     getSessionInfo,
     tokenizedFetch,
-    getAnswerFromQuery,
-    createLiveboardWithAnswers,
     SearchEmbed,
     SearchBarEmbed,
     PinboardEmbed,
     LiveboardEmbed,
     SageEmbed,
     AppEmbed,
-    BodylessConversation,
-    BodylessConversationViewConfig,
     AuthFailureType,
     AuthStatus,
     AuthEvent,

package/src/react/index.tsx

@@ -10,7 +10,6 @@ import { TsEmbed } from '../embed/ts-embed';
 
 import { EmbedEvent, ViewConfig } from '../types';
 import { EmbedProps, getViewPropsAndListeners } from './util';
-import { ConversationEmbed as _ConversationEmbed, ConversationViewConfig } from '../embed/conversation';
 
 const componentFactory = <T extends typeof TsEmbed, U extends EmbedProps, V extends ViewConfig>(
     EmbedConstructor: T,
@@ -40,11 +39,11 @@ const componentFactory = <T extends typeof TsEmbed, U extends EmbedProps, V exte
             tsEmbed.destroy();
         };
 
-        const handlePreRenderRendering = (tsEmbed: InstanceType<T>) => {
+        const handlePreRenderRendering = (tsEmbed : InstanceType<T>) => {
             tsEmbed.preRender();
         };
 
-        const handleDefaultRendering = (tsEmbed: InstanceType<T>) => {
+        const handleDefaultRendering = (tsEmbed : InstanceType<T>) => {
             // if component is connected to a preRendered component
             if (props.preRenderId) {
                 tsEmbed.showPreRender();
@@ -54,7 +53,7 @@ const componentFactory = <T extends typeof TsEmbed, U extends EmbedProps, V exte
             tsEmbed.render();
         };
 
-        const handleRendering = (tsEmbed: InstanceType<T>) => {
+        const handleRendering = (tsEmbed : InstanceType<T>) => {
             if (isPreRenderedComponent) {
                 handlePreRenderRendering(tsEmbed);
                 return;
@@ -64,16 +63,16 @@ const componentFactory = <T extends typeof TsEmbed, U extends EmbedProps, V exte
 
         useDeepCompareEffect(() => {
             const tsEmbed = new EmbedConstructor(
-                ref!.current,
-                deepMerge(
-                    {
-                        insertAsSibling: viewConfig.insertAsSibling,
-                        frameParams: {
-                            class: viewConfig.insertAsSibling ? className || '' : '',
+                    ref!.current,
+                    deepMerge(
+                        {
+                            insertAsSibling: viewConfig.insertAsSibling,
+                            frameParams: {
+                                class: viewConfig.insertAsSibling ? className || '' : '',
+                            },
                         },
-                    },
-                    viewConfig,
-                ),
+                        viewConfig,
+                    ),
             ) as InstanceType<T>;
             Object.keys(listeners).forEach((eventName) => {
                 tsEmbed.on(eventName as EmbedEvent, listeners[eventName as EmbedEvent]);
@@ -99,33 +98,33 @@ const componentFactory = <T extends typeof TsEmbed, U extends EmbedProps, V exte
 interface SearchProps extends EmbedProps, SearchViewConfig { }
 
 interface PreRenderProps {
-    /**
-     * PreRender id to be used for PreRendering the embed.
-     * Use PreRender to render the embed in the background and then
-     * show or hide the rendered embed using showPreRender or hidePreRender respectively.
-     * @example
-     * ```js
-     * const embed = new LiveboardEmbed('#embed', {
-     *   ... // other liveboard view config
-     *   preRenderId: "preRenderId-123"
-     * });
-     * embed.showPreRender();
-     * ```
-     *
-     * Use PreRendered react component for pre rendering embed components.
-     * @example
-     * ```tsx
-     * function LandingPageComponent() {
-     *  return <PreRenderedLiveboardEmbed preRenderId="someId" liveboardId="libId" />
-     * }
-     * ```
-     * function MyComponent() {
-     *  return <LiveboardEmbed preRenderId="someId" liveboardId="libId" />
-     * }
-     * ```
-     * @version SDK: 1.25.0 | Thoughtspot: 9.6.0.cl
-     */
-    preRenderId: string;
+   /**
+    * PreRender id to be used for PreRendering the embed.
+    * Use PreRender to render the embed in the background and then
+    * show or hide the rendered embed using showPreRender or hidePreRender respectively.
+    * @example
+    * ```js
+    * const embed = new LiveboardEmbed('#embed', {
+    *   ... // other liveboard view config
+    *   preRenderId: "preRenderId-123"
+    * });
+    * embed.showPreRender();
+    * ```
+    *
+    * Use PreRendered react component for pre rendering embed components.
+    * @example
+    * ```tsx
+    * function LandingPageComponent() {
+    *  return <PreRenderedLiveboardEmbed preRenderId="someId" liveboardId="libId" />
+    * }
+    * ```
+    * function MyComponent() {
+    *  return <LiveboardEmbed preRenderId="someId" liveboardId="libId" />
+    * }
+    * ```
+    * @version SDK: 1.25.0 | Thoughtspot: 9.6.0.cl
+    */
+  preRenderId: string;
 }
 
 /**
@@ -330,58 +329,11 @@ export const PreRenderedSageEmbed = componentFactory<
     SageViewConfig
 >(_SageEmbed, true);
 
-interface ConversationEmbedProps extends EmbedProps, ConversationViewConfig { }
-
-/**
- * React component for LLM based conversation BI.
- * @example
- * ```tsx
- * function Sage() {
- *  return <ConversationEmbed
- *      worksheetId="<worksheet-id-here>"
- *      searchOptions={{
- *          searchQuery: "<search query to start with>"
- *      }}
- *      ... other view config props or event listeners.
- *  />
- * }
- * ```
- */
-export const ConversationEmbed = componentFactory<
-    typeof _ConversationEmbed, ConversationEmbedProps, ConversationViewConfig>(
-        _ConversationEmbed,
-    );
-
-/**
- * React component for PreRendered Conversation embed.
- *
- * PreRenderedConversationEmbed will preRender the ConversationEmbed and will be hidden by
- * default.
- *
- * SageEmbed with preRenderId passed will call showPreRender on the embed.
- * @example
- * ```tsx
- * function LandingPageComponent() {
- *  return <PreRenderedConversationEmbed preRenderId="someId" worksheetId={"id-"} />
- * }
- * ```
- * function MyComponent() {
- *  return <ConversationEmbed preRenderId="someId" worksheetId="id" />
- * }
- * ```
- */
-export const PreRenderedConversationEmbed = componentFactory<
-    typeof _ConversationEmbed,
-    SageEmbedProps & PreRenderProps,
-    ConversationViewConfig
->(_ConversationEmbed, true);
-
 type EmbedComponent = typeof SearchEmbed
     | typeof AppEmbed
     | typeof LiveboardEmbed
     | typeof SearchBarEmbed
-    | typeof SageEmbed
-    | typeof ConversationEmbed;
+    | typeof SageEmbed;
 
 /**
  * Get a reference to the embed component to trigger events on the component.
@@ -400,7 +352,7 @@ type EmbedComponent = typeof SearchEmbed
  * @returns {React.MutableRefObject<T extends TsEmbed>} ref
  */
 export function useEmbedRef<T extends EmbedComponent>():
-    React.MutableRefObject<React.ComponentRef<T>> {
+  React.MutableRefObject<React.ComponentRef<T>> {
     return React.useRef<React.ComponentRef<T>>(null);
 }
 

package/src/test/test-utils.ts

@@ -1,16 +1,12 @@
-import { has } from 'lodash';
 import { version } from '../../package.json';
 import { Action, AuthType } from '../types';
 
 /**
  Initialises fetch to the global object
  */
-if (!(global.fetch as any).mockResponse) {
-    console.log('mocking fetch');
-    global.fetch = jest.fn(() => Promise.resolve({
-        json: () => ({ mixpanelAccessToken: '' }),
-    }));
-}
+global.fetch = jest.fn(() => Promise.resolve({
+    json: () => ({ mixpanelAccessToken: '' }),
+}));
 
 export const defaultParamsWithoutHiddenActions = `hostAppUrl=local-host&viewPortHeight=768&viewPortWidth=1024&sdkVersion=${version}&authType=${AuthType.None}&blockNonEmbedFullAppAccess=true`;
 export const defaultParams = `&${defaultParamsWithoutHiddenActions}&hideAction=[%22${Action.ReportError}%22]`;
@@ -110,27 +106,6 @@ export const expectUrlMatchesWithParams = (source: string, target: string) => {
     const sourceParamsObj = Object.fromEntries(sourceUrl.searchParams);
     const targetParamsObj = Object.fromEntries(targetUrl.searchParams);
     expect(sourceParamsObj).toMatchObject(targetParamsObj);
-
-    const sourceHashParams = getHashQueryParams(sourceUrl.hash);
-    const targetHashParams = getHashQueryParams(targetUrl.hash);
-    expect(sourceHashParams).toMatchObject(targetHashParams);
-};
-
-export const expectUrlToHaveParamsWithValues = (
-    url: string, paramsWithValues: Record<string, any>,
-) => {
-    const urlObj = new URL(url);
-    const urlParams = Object.fromEntries(urlObj.searchParams);
-
-    const sourceHashParams = getHashQueryParams(urlObj.hash);
-    const sourceParams = {
-        ...urlParams, ...sourceHashParams,
-    };
-
-    Object.entries(paramsWithValues).forEach(([key, value]) => {
-        expect(has(sourceParams, key)).toBeTruthy();
-        expect(`${sourceParams[key]}`).toBe(`${value}`);
-    });
 };
 
 export const expectUrlMatch = (source: string, target: string) => {
@@ -148,21 +123,3 @@ export const createRootEleForEmbed = () => {
     rootEle.appendChild(tsEmbedDiv);
     document.body.appendChild(rootEle);
 };
-
-export const getHashQueryParams = (hash: string): any => {
-    const params = hash.split('?')[1];
-    const hashParams = new URLSearchParams(params);
-    return Object.fromEntries(hashParams);
-};
-
-export const mockSessionInfo = {
-    userGUID: '1234',
-    mixpanelToken: 'abc123',
-    isPublicUser: false,
-    sessionId: '6588e7d9-710c-453e-a7b4-535fb3a8cbb2',
-    genNo: 3,
-    acSession: {
-        sessionId: 'cb202c48-b14b-4466-8a70-899ea666d46q',
-        genNo: 5,
-    },
-};

package/src/types.ts

@@ -1054,6 +1054,19 @@ export interface ViewConfig {
      * ```
      */
     dataPanelV2?: boolean;
+    /**
+     * To enable custom column groups in data panel v2
+     * @version SDK: 1.32.0 | Thoughtspot: 10.0.0.cl
+     * @default false
+     * @example
+     * ```js
+     * const embed = new SearchEmbed('#tsEmbed', {
+     *   ... // other options
+     *   enableCustomColumnGroups: true,
+     * });
+     * ```
+     */
+    enableCustomColumnGroups?: boolean;
 }
 
 /**

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

@@ -113,17 +113,10 @@ describe('Unit test for authService', () => {
         }));
         try {
             await fetchSessionInfoService(authVerificationUrl);
-        } catch (e) {
-            //
-        }
-        expect(logger.error).toHaveBeenCalledWith('Failed to fetch http://localhost:3000/callosum/v1/session/info', 'error');
-
-        try {
-            await fetchBasicAuthService(thoughtSpotHost, username, password);
         } catch (e) {
             expect(e.message).toContain('Failed to fetch session info');
         }
-        expect(logger.error).toHaveBeenCalledWith('Failure', 'error');
+        expect(logger.error).toHaveBeenCalledWith('Failed to fetch http://localhost:3000/callosum/v1/session/info', 'error');
     });
 
     test('verifyTokenService if token api works', async () => {

package/src/utils/authService/tokenizedAuthService.ts

@@ -18,6 +18,7 @@ function tokenizedFailureLoggedFetch(url: string, options: RequestInit = {}): Pr
 
 /**
  * Fetches the session info from the ThoughtSpot server.
+ *
  * @param thoughtspotHost
  * @returns {Promise<any>}
  * @example
@@ -51,6 +52,7 @@ 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: *
  */

package/src/utils/graphql/answerService/answer-queries.ts

@@ -104,7 +104,6 @@ export const getAnswer = `
                 }
                 visualizations {
                     ... on TableViz {
-                        id
                         columns {
                             column {
                                 id
@@ -116,9 +115,6 @@ export const getAnswer = `
                             }
                         }
                     }
-                    ... on ChartViz {
-                        id
-                    }
                 }
             }
         }
@@ -176,23 +172,3 @@ export const getSQLQuery = `
         }
     }
 `;
-
-export const getAnswerTML = `
-mutation GetUnsavedAnswerTML($session: BachSessionIdInput!, $exportDependencies: Boolean, $formatType:  EDocFormatType, $exportPermissions: Boolean, $exportFqn: Boolean) {
-  UnsavedAnswer_getTML(
-    session: $session
-    exportDependencies: $exportDependencies
-    formatType: $formatType
-    exportPermissions: $exportPermissions
-    exportFqn: $exportFqn
-  ) {
-    zipFile
-    object {
-      edoc
-      name
-      type
-      __typename
-    }
-    __typename
-  }
-}`;