ydb-embedded-ui 3.5.0 → 4.0.0

package/dist/utils/query.test.ts

@@ -1,260 +1,182 @@
-import {parseQueryAPIExecuteResponse, parseQueryAPIExplainResponse} from './query';
+import type {PlanMeta, PlanNode, PlanTable, TKqpStatsQuery} from '../types/api/query';
+import {
+    parseQueryAPIExecuteResponse,
+    parseQueryAPIExplainResponse,
+    parseQueryExplainPlan,
+} from './query';
 
 describe('API utils', () => {
     describe('json/viewer/query', () => {
         describe('parseQueryAPIExecuteResponse', () => {
-            describe('old format', () => {
-                describe('plain response', () => {
-                    it('should handle empty response', () => {
-                        expect(parseQueryAPIExecuteResponse(null).result).toBeUndefined();
-                    });
-
-                    it('should parse json string', () => {
-                        const json = {foo: 'bar'};
-                        const response = JSON.stringify(json);
-                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(json);
-                    });
-
-                    // it should not be in the response, but is there because of a bug
-                    it('should ignore request plan as the response', () => {
-                        const response = {queries: 'some queries'};
-                        expect(parseQueryAPIExecuteResponse(response).result).toBeUndefined();
-                    });
-
-                    it('should accept key-value rows', () => {
-                        const response = [{foo: 'bar'}];
-                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(response);
-                    });
+            describe('should handle responses with incorrect format', () => {
+                it('should handle null response', () => {
+                    expect(parseQueryAPIExecuteResponse(null)).toEqual({});
                 });
-
-                describe('deep response without stats', () => {
-                    it('should parse json string in the result field', () => {
-                        const json = {foo: 'bar'};
-                        const response = {result: JSON.stringify(json)};
-                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(json);
-                    });
-
-                    // it should not be in the response, but is there because of a bug
-                    it('should ignore request plan in the result field', () => {
-                        const response = {result: {queries: 'some queries'}};
-                        expect(parseQueryAPIExecuteResponse(response).result).toBeUndefined();
-                    });
-
-                    it('should accept key-value rows in the result field', () => {
-                        const response = {result: [{foo: 'bar'}]};
-                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(
-                            response.result,
-                        );
-                    });
+                it('should handle undefined response', () => {
+                    expect(parseQueryAPIExecuteResponse(undefined)).toEqual({});
                 });
-
-                describe('deep response with stats', () => {
-                    it('should parse json string in the result field', () => {
-                        const json = {foo: 'bar'};
-                        const response = {
-                            result: JSON.stringify(json),
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toEqual(json);
-                        expect(actual.stats).toEqual(response.stats);
-                    });
-
-                    // it should not be in the response, but is there because of a bug
-                    it('should ignore request plan in the result field', () => {
-                        const response = {
-                            result: {queries: 'some queries'},
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toBeUndefined();
-                        expect(actual.stats).toEqual(response.stats);
-                    });
-
-                    it('should accept key-value rows in the result field', () => {
-                        const response = {
-                            result: [{foo: 'bar'}],
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toEqual(response.result);
-                        expect(actual.stats).toEqual(response.stats);
-                    });
-
-                    it('should accept stats without a result', () => {
-                        const response = {
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toBeUndefined();
-                        expect(actual.stats).toEqual(response.stats);
-                    });
+                it('should handle string response', () => {
+                    expect(parseQueryAPIExecuteResponse('foo')).toEqual({});
+                });
+                it('should handle array response', () => {
+                    expect(parseQueryAPIExecuteResponse([{foo: 'bar'}])).toEqual({});
+                });
+                it('should handle json string in the result field', () => {
+                    const json = {foo: 'bar'};
+                    const response = {result: JSON.stringify(json)};
+                    expect(parseQueryAPIExecuteResponse(response)).toEqual({});
+                });
+                it('should handle object with request plan in the result field', () => {
+                    const response = {result: {queries: 'some queries'}};
+                    expect(parseQueryAPIExecuteResponse(response)).toEqual({});
                 });
             });
-
-            describe('new format', () => {
-                describe('response without stats', () => {
-                    it('should parse modern schema', () => {
-                        const response = {
-                            result: [['42', 'hello world']],
-                            columns: [
-                                {
-                                    name: 'id',
-                                    type: 'Uint64?',
-                                },
-                                {
-                                    name: 'value',
-                                    type: 'Utf8?',
-                                },
-                            ],
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toEqual([
+            describe('should correctly parse data', () => {
+                it('should parse modern schema result to KeyValueRow', () => {
+                    const response = {
+                        result: [['42', 'hello world']],
+                        columns: [
                             {
-                                id: '42',
-                                value: 'hello world',
+                                name: 'id',
+                                type: 'Uint64?',
                             },
-                        ]);
-                        expect(actual.columns).toEqual(response.columns);
-                    });
-
-                    it('should handle empty response for classic schema', () => {
-                        expect(parseQueryAPIExecuteResponse(null).result).toBeUndefined();
-                    });
-
-                    it('should parse plain classic schema', () => {
-                        const response = [{foo: 'bar'}];
-                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(response);
-                    });
-
-                    it('should parse deep classic schema', () => {
-                        const response = {result: [{foo: 'bar'}]};
-                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(
-                            response.result,
-                        );
-                    });
-
-                    it('should parse ydb schema', () => {
-                        const response = {result: [{foo: 'bar'}]};
-                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(
-                            response.result,
-                        );
-                    });
-                });
-
-                describe('response with stats', () => {
-                    it('should parse modern schema', () => {
-                        const response = {
-                            result: [['42', 'hello world']],
-                            columns: [
-                                {
-                                    name: 'id',
-                                    type: 'Uint64?',
-                                },
-                                {
-                                    name: 'value',
-                                    type: 'Utf8?',
-                                },
-                            ],
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toEqual([
                             {
-                                id: '42',
-                                value: 'hello world',
+                                name: 'value',
+                                type: 'Utf8?',
                             },
-                        ]);
-                        expect(actual.columns).toEqual(response.columns);
-                        expect(actual.stats).toEqual(response.stats);
-                    });
-
-                    it('should parse classic schema', () => {
-                        const response = {
-                            result: [{foo: 'bar'}],
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toEqual(response.result);
-                        expect(actual.stats).toEqual(response.stats);
-                    });
+                        ],
+                    };
+                    const parsedResponse = parseQueryAPIExecuteResponse(response);
+
+                    expect(parsedResponse.result).toEqual([
+                        {
+                            id: '42',
+                            value: 'hello world',
+                        },
+                    ]);
+                    expect(parsedResponse.columns).toEqual(response.columns);
+                });
+                it('should return KeyValueRow result for ydb and classic schemas unchanged', () => {
+                    const response = {result: [{foo: 'bar'}]};
+                    expect(parseQueryAPIExecuteResponse(response).result).toEqual(response.result);
+                });
+                it('shoudl return stats for modern schema', () => {
+                    const result = [['42', 'hello world']];
+                    const columns = [
+                        {
+                            name: 'id',
+                            type: 'Uint64?',
+                        },
+                        {
+                            name: 'value',
+                            type: 'Utf8?',
+                        },
+                    ];
+
+                    const stats = {metric: 'good'} as TKqpStatsQuery;
+
+                    const response = {result, columns, stats};
+                    const parsedResponse = parseQueryAPIExecuteResponse(response);
+
+                    expect(parsedResponse.result).toEqual([
+                        {
+                            id: '42',
+                            value: 'hello world',
+                        },
+                    ]);
+                    expect(parsedResponse.columns).toEqual(response.columns);
+                    expect(parsedResponse.stats).toEqual(response.stats);
+                });
+                it('shoudl return stats for ydb and classic schemas', () => {
+                    const result = [{foo: 'bar'}];
+                    const stats = {metric: 'good'} as TKqpStatsQuery;
 
-                    it('should parse ydb schema', () => {
-                        const response = {
-                            result: [{foo: 'bar'}],
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toEqual(response.result);
-                        expect(actual.stats).toEqual(response.stats);
-                    });
+                    const response = {result, stats};
+                    const parsedResponse = parseQueryAPIExecuteResponse(response);
 
-                    it('should accept stats without a result', () => {
-                        const response = {
-                            stats: {metric: 'good'},
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toBeUndefined();
-                        expect(actual.columns).toBeUndefined();
-                        expect(actual.stats).toEqual(response.stats);
-                    });
+                    expect(parsedResponse.result).toEqual(response.result);
+                    expect(parsedResponse.stats).toEqual(response.stats);
+                });
+                it('should accept stats without a result', () => {
+                    const stats = {metric: 'good'} as TKqpStatsQuery;
+                    const response = {stats};
+                    const actual = parseQueryAPIExecuteResponse(response);
+                    expect(actual.result).toBeUndefined();
+                    expect(actual.columns).toBeUndefined();
+                    expect(actual.stats).toEqual(response.stats);
                 });
             });
         });
 
         describe('parseQueryAPIExplainResponse', () => {
-            it('should handle empty response', () => {
-                expect(parseQueryAPIExplainResponse(null)).toEqual({});
-            });
-
-            it('should accept stats without a plan', () => {
-                const stats = {metric: 'good'};
-                expect(parseQueryAPIExplainResponse({stats}).stats).toEqual(stats);
-            });
-
-            describe('old format', () => {
-                describe('explain', () => {
-                    it('should parse plan data in the root', () => {
-                        const plan = {foo: 'bar'};
-                        expect(parseQueryAPIExplainResponse(plan).plan).toEqual(plan);
-                    });
-
-                    it('should parse plan in the result field with stats', () => {
-                        const plan = {foo: 'bar'};
-                        const stats = {metric: 'good'};
-                        const actual = parseQueryAPIExplainResponse({result: plan, stats});
-                        expect(actual.plan).toEqual(plan);
-                        expect(actual.stats).toEqual(stats);
-                    });
+            describe('should handle responses with incorrect format', () => {
+                it('should handle null response', () => {
+                    expect(parseQueryAPIExecuteResponse(null)).toEqual({});
                 });
-
-                describe('explain-ast', () => {
-                    it('should parse ast field in the root', () => {
-                        const ast = 'ast';
-                        expect(parseQueryAPIExplainResponse({ast}).ast).toBe(ast);
-                    });
-
-                    it('should parse ast in the result field with stats', () => {
-                        const ast = 'ast';
-                        const stats = {metric: 'good'};
-                        const actual = parseQueryAPIExplainResponse({result: {ast}, stats});
-                        expect(actual.ast).toBe(ast);
-                        expect(actual.stats).toEqual(stats);
-                    });
+                it('should handle undefined response', () => {
+                    expect(parseQueryAPIExecuteResponse(undefined)).toEqual({});
+                });
+                it('should handle object with plan in the result field', () => {
+                    const response = {result: {foo: 'bar'}};
+                    expect(parseQueryAPIExecuteResponse(response)).toEqual({});
                 });
             });
 
-            describe('new format', () => {
-                it('should parse explain response with stats', () => {
-                    const plan = {foo: 'bar'};
+            describe('should correctly parse data', () => {
+                it('should parse explain-scan', () => {
+                    const plan: PlanNode = {};
+                    const tables: PlanTable[] = [];
+                    const meta: PlanMeta = {version: '0.2', type: 'script'};
                     const ast = 'ast';
-                    const stats = {metric: 'good'};
-                    const actual = parseQueryAPIExplainResponse({plan, ast, stats});
-                    expect(actual.plan).toEqual(plan);
-                    expect(actual.ast).toBe(ast);
-                    expect(actual.stats).toEqual(stats);
+                    const response = {plan: {Plan: plan, tables, meta}, ast};
+                    expect(parseQueryAPIExplainResponse(response)).toBe(response);
+                });
+                it('should parse explain-script', () => {
+                    const plan: PlanNode = {};
+                    const tables: PlanTable[] = [];
+                    const meta: PlanMeta = {version: '0.2', type: 'script'};
+
+                    const response = {
+                        plan: {queries: [{Plan: plan, tables}], meta},
+                    };
+                    expect(parseQueryAPIExplainResponse(response)).toBe(response);
                 });
             });
         });
+
+        describe('parseQueryExplainPlan', () => {
+            it('should parse explain script plan to explain scan', () => {
+                const plan: PlanNode = {};
+                const tables: PlanTable[] = [];
+                const meta: PlanMeta = {version: '0.2', type: 'script'};
+
+                const rawPlan = {
+                    queries: [
+                        {
+                            Plan: plan,
+                            tables,
+                        },
+                    ],
+                    meta,
+                };
+                const parsedPlan = parseQueryExplainPlan(rawPlan);
+                expect(parsedPlan.Plan).toEqual(plan);
+                expect(parsedPlan.tables).toBe(tables);
+                expect(parsedPlan.meta).toEqual(meta);
+            });
+            it('should left scan plan unchanged', () => {
+                const plan: PlanNode = {};
+                const tables: PlanTable[] = [];
+                const meta: PlanMeta = {version: '0.2', type: 'script'};
+
+                const rawPlan = {
+                    Plan: plan,
+                    tables: tables,
+                    meta: meta,
+                };
+                const parsedPlan = parseQueryExplainPlan(rawPlan);
+                expect(parsedPlan).toEqual(rawPlan);
+            });
+        });
     });
 });

package/dist/utils/query.ts

@@ -2,13 +2,10 @@ import {YQLType} from '../types';
 import type {
     AnyExecuteResponse,
     AnyExplainResponse,
-    AnyResponse,
-    CommonFields,
-    DeepExecuteResponse,
-    DeprecatedExecuteResponsePlain,
-    ExecuteClassicResponsePlain,
     ExecuteModernResponse,
     KeyValueRow,
+    ScanPlan,
+    ScriptPlan,
 } from '../types/api/query';
 import type {IQueryResult} from '../types/store/query';
 
@@ -49,6 +46,7 @@ export const getColumnType = (type: string) => {
     }
 };
 
+/** parse response result field from ArrayRow to KeyValueRow */
 const parseExecuteModernResponse = (data: ExecuteModernResponse): IQueryResult => {
     const {result, columns, ...restData} = data;
 
@@ -57,43 +55,17 @@ const parseExecuteModernResponse = (data: ExecuteModernResponse): IQueryResult =
             result &&
             columns &&
             result.map((row) => {
-                return row.reduce((newRow: KeyValueRow, cellData, columnIndex) => {
+                return row.reduce((newRow, cellData, columnIndex) => {
                     const {name} = columns[columnIndex];
                     newRow[name] = cellData;
                     return newRow;
-                }, {});
+                }, {} as KeyValueRow);
             }),
         columns,
         ...restData,
     };
 };
 
-const parseDeprecatedExecuteResponseValue = (
-    data?: DeprecatedExecuteResponsePlain | ExecuteClassicResponsePlain,
-): KeyValueRow[] | undefined => {
-    if (!data) {
-        return undefined;
-    }
-
-    if (typeof data === 'string') {
-        try {
-            return JSON.parse(data);
-        } catch (e) {
-            return undefined;
-        }
-    }
-
-    if (Array.isArray(data)) {
-        return data;
-    }
-
-    // Plan is not a valid response in this case
-    return undefined;
-};
-
-const hasResult = (data: AnyExecuteResponse): data is DeepExecuteResponse =>
-    Boolean(data && typeof data === 'object' && 'result' in data);
-
 const isModern = (response: AnyExecuteResponse): response is ExecuteModernResponse =>
     Boolean(
         response &&
@@ -102,70 +74,64 @@ const isModern = (response: AnyExecuteResponse): response is ExecuteModernRespon
             Array.isArray((response as ExecuteModernResponse).columns),
     );
 
-const hasCommonFields = (data: AnyResponse): data is CommonFields =>
-    Boolean(
-        data && typeof data === 'object' && ('ast' in data || 'plan' in data || 'stats' in data),
+type UnsupportedQueryResponseFormat =
+    | Array<unknown>
+    | string
+    | null
+    | undefined
+    | {result: string | Record<string, unknown>};
+
+const isUnsupportedType = (
+    data: AnyExecuteResponse | AnyExplainResponse | UnsupportedQueryResponseFormat,
+): data is UnsupportedQueryResponseFormat => {
+    return Boolean(
+        !data ||
+            typeof data !== 'object' ||
+            Array.isArray(data) ||
+            ('result' in data && !Array.isArray(data.result)),
     );
+};
 
-// complex logic because of the variety of possible responses
-// after all backends are updated to the latest version, it can be simplified
-export const parseQueryAPIExecuteResponse = (data: AnyExecuteResponse): IQueryResult => {
-    if (!data) {
+export const parseQueryAPIExecuteResponse = (
+    data: AnyExecuteResponse | UnsupportedQueryResponseFormat,
+): IQueryResult => {
+    if (isUnsupportedType(data)) {
         return {};
     }
-
-    if (hasResult(data)) {
-        if (isModern(data)) {
-            return parseExecuteModernResponse(data);
-        }
-
-        return {
-            ...data,
-            result: parseDeprecatedExecuteResponseValue(data.result),
-        };
-    }
-
-    if (hasCommonFields(data)) {
-        return data;
+    if (isModern(data)) {
+        return parseExecuteModernResponse(data);
     }
 
-    return {
-        result: parseDeprecatedExecuteResponseValue(data),
-    };
+    return data;
 };
 
-// complex logic because of the variety of possible responses
-// after all backends are updated to the latest version, it can be simplified
-export const parseQueryAPIExplainResponse = (data: AnyExplainResponse): IQueryResult => {
-    if (!data) {
+export const parseQueryAPIExplainResponse = (
+    data: AnyExplainResponse | UnsupportedQueryResponseFormat,
+): IQueryResult => {
+    if (isUnsupportedType(data)) {
         return {};
     }
 
-    if ('ast' in data) {
-        return data;
-    }
+    return data;
+};
 
-    if ('result' in data) {
-        const {result, ...restData} = data;
+const isExplainScriptPlan = (plan: ScriptPlan | ScanPlan): plan is ScriptPlan =>
+    Boolean(plan && 'queries' in plan);
 
-        if ('ast' in data.result) {
-            return {
-                ast: result.ast,
-                ...restData,
-            };
+export const parseQueryExplainPlan = (plan: ScriptPlan | ScanPlan): ScanPlan => {
+    if (isExplainScriptPlan(plan)) {
+        if (!plan.queries || !plan.queries.length) {
+            return {meta: plan.meta};
         }
 
         return {
-            plan: data.result,
-            ...restData,
+            Plan: plan.queries[0].Plan,
+            tables: plan.queries[0].tables,
+            meta: plan.meta,
         };
     }
 
-    if (hasCommonFields(data)) {
-        return data;
-    }
-
-    return {plan: data};
+    return plan;
 };
 
 export const prepareQueryResponse = (data?: KeyValueRow[]) => {

package/dist/utils/timeParsers/i18n/en.json

@@ -1,11 +1,11 @@
 {
-  "daysHours": "{{days}}d {{hours}}h",
-  "hoursMin": "{{hours}}h {{minutes}}m",
-  "minSec": "{{minutes}}m {{seconds}}s",
-  "secMs": "{{seconds}}s {{ms}}ms",
-  "days": "{{days}}d",
-  "hours": "{{hours}}h",
-  "min": "{{minutes}}m",
-  "sec": "{{seconds}}s",
-  "ms": "{{ms}}ms"
+  "daysHours": "{{days}}\u00a0d\u00a0{{hours}}\u00a0h",
+  "hoursMin": "{{hours}}\u00a0h\u00a0{{minutes}}\u00a0m",
+  "minSec": "{{minutes}}\u00a0m\u00a0{{seconds}}\u00a0s",
+  "secMs": "{{seconds}}\u00a0s\u00a0{{ms}}\u00a0ms",
+  "days": "{{days}}\u00a0d",
+  "hours": "{{hours}}\u00a0h",
+  "min": "{{minutes}}\u00a0m",
+  "sec": "{{seconds}}\u00a0s",
+  "ms": "{{ms}}\u00a0ms"
 }

package/dist/utils/timeParsers/i18n/ru.json

@@ -1,11 +1,11 @@
 {
-  "daysHours": "{{days}}д {{hours}}ч",
-  "hoursMin": "{{hours}}ч {{minutes}}м",
-  "minSec": "{{minutes}}м {{seconds}}с",
-  "secMs": "{{seconds}}с {{ms}}мс",
-  "days": "{{days}}д",
-  "hours": "{{hours}}ч",
-  "min": "{{minutes}}м",
-  "sec": "{{seconds}}с",
-  "ms": "{{ms}}мс"
+  "daysHours": "{{days}}\u00a0д\u00a0{{hours}}\u00a0ч",
+  "hoursMin": "{{hours}}\u00a0ч\u00a0{{minutes}}\u00a0м",
+  "minSec": "{{minutes}}\u00a0м\u00a0{{seconds}}\u00a0с",
+  "secMs": "{{seconds}}\u00a0с\u00a0{{ms}}\u00a0мс",
+  "days": "{{days}}\u00a0д",
+  "hours": "{{hours}}\u00a0ч",
+  "min": "{{minutes}}\u00a0м",
+  "sec": "{{seconds}}\u00a0с",
+  "ms": "{{ms}}\u00a0мс"
 }

package/dist/utils/timeParsers/parsers.ts

@@ -1,5 +1,6 @@
 import type {IProtobufTimeObject} from '../../types/api/common';
 
+import {isNumeric} from '../utils';
 import {parseProtobufDurationToMs, parseProtobufTimestampToMs} from '.';
 
 export const parseLag = (value: string | IProtobufTimeObject | undefined) =>
@@ -16,3 +17,11 @@ export const parseTimestampToIdleTime = (value: string | IProtobufTimeObject | u
     // Usually it below 100ms, so it could be omitted
     return duration < 0 ? 0 : duration;
 };
+
+export const parseUsToMs = (value: string | number | undefined) => {
+    if (!value || !isNumeric(value)) {
+        return 0;
+    }
+
+    return Math.round(Number(value) / 1000);
+};