ydb-embedded-ui 3.4.5 → 4.0.0

package/dist/utils/error.ts

@@ -0,0 +1,25 @@
+import type {AxiosError} from 'axios';
+
+import type {IResponseError, NetworkError} from '../types/api/error';
+import type {ErrorResponse as QueryErrorResponse} from '../types/api/query';
+import type {QueryError} from '../types/store/query';
+
+type RequestError = NetworkError | IResponseError | AxiosError | QueryErrorResponse | unknown;
+
+const isNetworkError = (error: RequestError): error is NetworkError => {
+    return Boolean(
+        error &&
+            typeof error === 'object' &&
+            'message' in error &&
+            (error as {message: unknown}).message === 'Network Error',
+    );
+};
+
+export const parseQueryError = (error: QueryError): QueryErrorResponse | string | undefined => {
+    if (isNetworkError(error)) {
+        return error.message;
+    }
+
+    // 401 Unauthorized error is handled by GenericAPI
+    return error ?? 'Unauthorized';
+};

package/dist/utils/index.js

@@ -113,52 +113,3 @@ export const renderExplainNode = (node) => {
     const parts = node.name.split('|');
     return parts.length > 1 ? parts[1] : node.name;
 };
-
-export const getExplainNodeId = (...values) => {
-    return values.join('|');
-};
-
-const getStringFromProps = (props) => {
-    return props
-        .map(([name, value]) => {
-            return value && `${name}: ${Array.isArray(value) ? value.join(', ') : value}`;
-        })
-        .filter(Boolean)
-        .join('\n');
-};
-
-export const getMetaForExplainNode = (node) => {
-    switch (node.type) {
-        case 'MultiLookup':
-        case 'Lookup': {
-            return getStringFromProps([
-                ['lookup by', node.lookup_by],
-                ['columns', node.columns],
-            ]);
-        }
-        case 'FullScan':
-        case 'Scan': {
-            return getStringFromProps([
-                ['scan by', node.scan_by],
-                ['limit', node.limit],
-                ['columns', node.columns],
-            ]);
-        }
-        case 'Upsert':
-        case 'MultiUpsert': {
-            return getStringFromProps([
-                ['key', node.key],
-                ['columns', node.columns],
-            ]);
-        }
-        case 'Erase':
-        case 'MultiErase': {
-            return getStringFromProps([
-                ['key', node.key],
-                ['columns', node.columns],
-            ]);
-        }
-        default:
-            return '';
-    }
-};

package/dist/utils/prepareQueryExplain.ts

@@ -1,4 +1,4 @@
-import {
+import type {
     Link,
     GraphNode,
     TopologyNodeDataStats,
@@ -7,28 +7,11 @@ import {
     TopologyNodeDataStatsItem,
 } from '@gravity-ui/paranoid';
 
-interface PlanOperator {
-    Name: string;
-    [key: string]: any;
-}
-
-export interface Plan {
-    PlanNodeId: number;
-    'Node Type': string;
-    Plans?: Plan[];
-    Operators?: PlanOperator[];
-    Tables?: string[];
-    PlanNodeType?: string;
-    [key: string]: any;
-}
-
-export interface RootPlan {
-    Plan: Plan;
-}
+import type {PlanNode} from '../types/api/query';
 
 const CONNECTION_NODE_META_FIELDS = new Set(['PlanNodeId', 'PlanNodeType', 'Node Type', 'Plans']);
 
-function prepareStats(plan: Plan) {
+function prepareStats(plan: PlanNode) {
     const stats: TopologyNodeDataStats[] = [];
 
     if (plan.Operators) {
@@ -77,7 +60,7 @@ function prepareStats(plan: Plan) {
     return stats;
 }
 
-function getNodeType(plan: Plan) {
+function getNodeType(plan: PlanNode) {
     switch (plan.PlanNodeType) {
         case 'Connection':
             return 'connection';
@@ -90,11 +73,11 @@ function getNodeType(plan: Plan) {
     }
 }
 
-export function preparePlan(plan: Plan) {
-    const nodes: GraphNode[] = [];
+export function preparePlan(plan: PlanNode) {
+    const nodes: GraphNode<ExplainPlanNodeData>[] = [];
     const links: Link[] = [];
 
-    function parsePlans(plans: Plan[] = [], from: string) {
+    function parsePlans(plans: PlanNode[] = [], from: string) {
         plans.forEach((p) => {
             const node: GraphNode<ExplainPlanNodeData> = {
                 name: String(p.PlanNodeId),

package/dist/utils/query.test.ts

@@ -1,247 +1,182 @@
+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: [{
+            describe('should correctly parse data', () => {
+                it('should parse modern schema result to KeyValueRow', () => {
+                    const response = {
+                        result: [['42', 'hello world']],
+                        columns: [
+                            {
                                 name: 'id',
-                                type: 'Uint64?'
-                            }, {
+                                type: 'Uint64?',
+                            },
+                            {
                                 name: 'value',
-                                type: 'Utf8?'
-                            }],
-                        };
-                        const actual = parseQueryAPIExecuteResponse(response);
-                        expect(actual.result).toEqual([{
+                                type: 'Utf8?',
+                            },
+                        ],
+                    };
+                    const parsedResponse = parseQueryAPIExecuteResponse(response);
+
+                    expect(parsedResponse.result).toEqual([
+                        {
                             id: '42',
-                            value: 'hello world'
-                        }]);
-                        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);
-                    });
+                            value: 'hello world',
+                        },
+                    ]);
+                    expect(parsedResponse.columns).toEqual(response.columns);
                 });
-
-                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([{
+                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(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);
-                    });
+                            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);
+            });
+        });
     });
 });