@thoughtspot/visual-embed-sdk 1.45.2 → 1.45.3-mcp.2

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

@@ -473,6 +473,93 @@ describe('Answer service tests', () => {
         expect(sql).toBe('SELECT * FROM table');
     });
 
+    test('Get SQL query with all columns should update display mode', async () => {
+        fetchMock.mockResponses(
+            JSON.stringify({
+                data: {
+                    Answer__updateProperties: {
+                        id: {
+                            ...defaultSession,
+                        },
+                        answer: {
+                            id: 'answer1',
+                            displayMode: 'TABLE_MODE',
+                            suggestedDisplayMode: 'CHART_MODE',
+                        },
+                    },
+                },
+            }),
+            JSON.stringify({
+                data: {
+                    Answer__getQuery: {
+                        sql: 'SELECT * FROM table',
+                    },
+                },
+            }),
+        );
+        const answerService = createAnswerService();
+        const sql = await answerService.getSQLQuery(true);
+        expect(fetchMock).toHaveBeenCalledWith(
+            'https://tshost/prism/?op=UpdateDisplayMode',
+            expect.objectContaining({
+                body: JSON.stringify({
+                    operationName: 'UpdateDisplayMode',
+                    query: queries.updateDisplayMode,
+                    variables: {
+                        session: defaultSession,
+                        displayMode: 'TABLE_MODE',
+                    },
+                }),
+            }),
+        );
+        expect(fetchMock).toHaveBeenCalledWith(
+            'https://tshost/prism/?op=GetSQLQuery',
+            expect.objectContaining({
+                body: JSON.stringify({
+                    operationName: 'GetSQLQuery',
+                    query: getSQLQuery,
+                    variables: {
+                        session: defaultSession,
+                    },
+                }),
+            }),
+        );
+        expect(sql).toBe('SELECT * FROM table');
+    });
+
+    test('Update display mode should call the right API', async () => {
+        fetchMock.mockResponseOnce(JSON.stringify({
+            data: {
+                Answer__updateProperties: {
+                    id: {
+                        ...defaultSession,
+                    },
+                    answer: {
+                        id: 'answer1',
+                        displayMode: 'CHART_MODE',
+                        suggestedDisplayMode: 'TABLE_MODE',
+                    },
+                },
+            },
+        }));
+        const answerService = createAnswerService();
+        const response = await answerService.updateDisplayMode('CHART_MODE');
+        expect(fetchMock).toHaveBeenCalledWith(
+            'https://tshost/prism/?op=UpdateDisplayMode',
+            expect.objectContaining({
+                body: JSON.stringify({
+                    operationName: 'UpdateDisplayMode',
+                    query: queries.updateDisplayMode,
+                    variables: {
+                        session: defaultSession,
+                        displayMode: 'CHART_MODE',
+                    },
+                }),
+            }),
+        );
+        expect(response.answer.displayMode).toBe('CHART_MODE');
+    });
+
     test('Add displayed Viz should call the right API', async () => {
         fetchMock.mockResponseOnce(JSON.stringify({
             data: {

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

@@ -190,7 +190,19 @@ export class AnswerService {
         );
     }
 
-    public async getSQLQuery(): Promise<string> {
+    public async updateDisplayMode(displayMode = "TABLE_MODE") {
+        return this.executeQuery(
+            queries.updateDisplayMode,
+            {
+                displayMode,
+            },
+        );
+    }
+
+    public async getSQLQuery(fetchSQLWithAllColumns = false): Promise<string> {
+        if (fetchSQLWithAllColumns) {
+            await this.updateDisplayMode("TABLE_MODE");
+        }
         const { sql } = await this.executeQuery(
             queries.getSQLQuery,
             {},

package/src/utils.spec.ts

@@ -21,6 +21,8 @@ import {
     formatTemplate,
     isValidCssMargin,
     resetValueFromWindow,
+    validateHttpUrl,
+    setParamIfDefined,
 } from './utils';
 import { RuntimeFilterOp } from './types';
 import { logger } from './utils/logger';
@@ -824,4 +826,58 @@ describe('getValueFromWindow and storeValueInWindow', () => {
             expect(getValueFromWindow('key2')).toBe('value2');
         });
     });
+
+    describe('validateHttpUrl', () => {
+        test.each([
+            ['http URL', 'http://example.com'],
+            ['https URL', 'https://example.com'],
+            ['https URL with path', 'https://docs.example.com/spotter'],
+            ['https URL with query params', 'https://example.com/path?foo=bar'],
+        ])('should return [true, null] for valid %s', (_, url) => {
+            const [isValid, error] = validateHttpUrl(url);
+            expect(isValid).toBe(true);
+            expect(error).toBeNull();
+        });
+
+        test.each([
+            ['ftp protocol', 'ftp://example.com', 'ftp:'],
+            ['file protocol', 'file:///path/to/file', 'file:'],
+            ['javascript protocol', 'javascript:alert(1)', 'javascript:'],
+        ])('should return [false, Error] for %s', (_, url, protocol) => {
+            const [isValid, error] = validateHttpUrl(url);
+            expect(isValid).toBe(false);
+            expect(error).toBeInstanceOf(Error);
+            expect(error?.message).toContain('Invalid protocol');
+            expect(error?.message).toContain(protocol);
+        });
+
+        test.each([
+            ['invalid URL format', 'not-a-valid-url'],
+            ['empty string', ''],
+            ['URL without protocol', 'example.com'],
+        ])('should return [false, Error] for %s', (_, url) => {
+            const [isValid, error] = validateHttpUrl(url);
+            expect(isValid).toBe(false);
+            expect(error).toBeInstanceOf(Error);
+        });
+    });
+
+    describe('setParamIfDefined', () => {
+        test.each([
+            ['string value', 'testParam', 'testValue', false, 'testValue'],
+            ['number value', 'numParam', 42, false, 42],
+            ['truthy value as boolean', 'boolParam', 'truthy', true, true],
+            ['falsy value as boolean', 'boolParam', 0, true, false],
+        ])('should set %s correctly', (_, param, value, asBoolean, expected) => {
+            const queryParams: Record<string, unknown> = {};
+            setParamIfDefined(queryParams, param, value, asBoolean);
+            expect(queryParams[param]).toBe(expected);
+        });
+
+        test('should not set param when value is undefined', () => {
+            const queryParams: Record<string, unknown> = {};
+            setParamIfDefined(queryParams, 'testParam', undefined);
+            expect(queryParams.testParam).toBeUndefined();
+        });
+    });
 });

package/src/utils.ts

@@ -581,3 +581,39 @@ export const isWindowUndefined = (): boolean => {
     }
     return false;
 }
+
+/**
+ * Validates that a URL uses only http: or https: protocols.
+ * Returns a tuple of [isValid, error] so the caller can handle validation errors.
+ * @param url - The URL string to validate
+ * @returns [true, null] if valid, [false, Error] if invalid
+ */
+export const validateHttpUrl = (url: string): [boolean, Error | null] => {
+    try {
+        const parsedUrl = new URL(url);
+        if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+            return [false, new Error(`Invalid protocol: ${parsedUrl.protocol}. Only http: and https: are allowed.`)];
+        }
+        return [true, null];
+    } catch (error) {
+        return [false, error instanceof Error ? error : new Error(String(error))];
+    }
+};
+
+/**
+ * Sets a query parameter if the value is defined.
+ * @param queryParams - The query params object to modify
+ * @param param - The parameter key
+ * @param value - The value to set
+ * @param asBoolean - If true, coerces value to boolean
+ */
+export const setParamIfDefined = <T>(
+    queryParams: Record<string, unknown>,
+    param: string,
+    value: T | undefined,
+    asBoolean = false,
+): void => {
+    if (value !== undefined) {
+        queryParams[param] = asBoolean ? !!value : value;
+    }
+};