ydb-embedded-ui 4.33.0 → 5.0.0

package/dist/utils/prepareQueryExplain.ts

@@ -1,115 +0,0 @@
-import type {
-    Link,
-    GraphNode,
-    TopologyNodeDataStats,
-    TopologyNodeDataStatsSection,
-    ExplainPlanNodeData,
-    TopologyNodeDataStatsItem,
-} from '@gravity-ui/paranoid';
-
-import type {PlanNode} from '../types/api/query';
-
-const CONNECTION_NODE_META_FIELDS = new Set(['PlanNodeId', 'PlanNodeType', 'Node Type', 'Plans']);
-
-function prepareStats(plan: PlanNode) {
-    const stats: TopologyNodeDataStats[] = [];
-
-    if (plan.Operators) {
-        const operatorsSections: TopologyNodeDataStatsSection[] = [];
-
-        for (const operator of plan.Operators) {
-            const section: TopologyNodeDataStatsSection = {name: operator.Name, items: []};
-
-            for (const [name, data] of Object.entries(operator)) {
-                if (name === 'Name') {
-                    continue;
-                }
-
-                const value = Array.isArray(data) ? data.join(', ') : data;
-                section.items.push({name, value});
-            }
-
-            operatorsSections.push(section);
-        }
-
-        stats.push({
-            group: 'Operators',
-            stats: operatorsSections,
-        });
-    }
-
-    if (plan.PlanNodeType === 'Connection') {
-        const attrStats: TopologyNodeDataStatsItem[] = [];
-
-        for (const [key, value] of Object.entries(plan)) {
-            if (CONNECTION_NODE_META_FIELDS.has(key)) {
-                continue;
-            }
-
-            attrStats.push({name: key, value: String(value)});
-        }
-
-        if (attrStats.length > 0) {
-            stats.push({
-                group: 'Attributes',
-                stats: attrStats,
-            });
-        }
-    }
-
-    return stats;
-}
-
-function getNodeType(plan: PlanNode) {
-    switch (plan.PlanNodeType) {
-        case 'Connection':
-            return 'connection';
-        case 'ResultSet':
-            return 'result';
-        case 'Query':
-            return 'query';
-        default:
-            return 'stage';
-    }
-}
-
-export function preparePlan(plan: PlanNode) {
-    const nodes: GraphNode<ExplainPlanNodeData>[] = [];
-    const links: Link[] = [];
-
-    function parsePlans(plans: PlanNode[] = [], from: string) {
-        plans.forEach((p) => {
-            const node: GraphNode<ExplainPlanNodeData> = {
-                name: String(p.PlanNodeId),
-                data: {
-                    id: p.PlanNodeId,
-                    type: getNodeType(p),
-                    name: p['Node Type'],
-                    operators: p.Operators?.map((o) => o.Name),
-                    stats: prepareStats(p),
-                    tables: p.Tables,
-                },
-            };
-            nodes.push(node);
-            links.push({from, to: node.name});
-            parsePlans(p.Plans, node.name);
-        });
-    }
-
-    const rootPlan = plan;
-    const rootNode: GraphNode<ExplainPlanNodeData> = {
-        name: String(rootPlan.PlanNodeId),
-        data: {
-            id: rootPlan.PlanNodeId,
-            type: getNodeType(rootPlan),
-            name: rootPlan['Node Type'],
-        },
-    };
-    nodes.push(rootNode);
-    parsePlans(rootPlan.Plans, rootNode.name);
-
-    return {
-        nodes,
-        links,
-    };
-}

package/dist/utils/query.test.ts

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

@@ -1,243 +0,0 @@
-import {YQLType} from '../types';
-import type {
-    AnyExecuteResponse,
-    AnyExplainResponse,
-    ArrayRow,
-    ColumnType,
-    ExecuteModernResponse,
-    ExecuteMultiResponse,
-    KeyValueRow,
-    QueryPlan,
-    ScriptPlan,
-} from '../types/api/query';
-import type {IQueryResult, QueryErrorResponse, QueryMode} from '../types/store/query';
-
-export const QUERY_ACTIONS = {
-    execute: 'execute',
-    explain: 'explain',
-} as const;
-
-export const QUERY_MODES = {
-    scan: 'scan',
-    script: 'script',
-    data: 'data',
-    query: 'query',
-    pg: 'pg',
-} as const;
-
-export const QUERY_MODES_TITLES: Record<QueryMode, string> = {
-    scan: 'Scan',
-    script: 'YQL Script',
-    data: 'Data',
-    query: 'YQL - QueryService',
-    pg: 'PostgreSQL',
-} as const;
-
-export const QUERY_SYNTAX = {
-    yql: 'yql_v1',
-    pg: 'pg',
-} as const;
-
-// eslint-disable-next-line complexity
-export const getColumnType = (type: string) => {
-    switch (type.replace(/\?$/, '')) {
-        case YQLType.Bool:
-            return 'boolean';
-        case YQLType.Int8:
-        case YQLType.Int16:
-        case YQLType.Int32:
-        case YQLType.Int64:
-        case YQLType.Uint8:
-        case YQLType.Uint16:
-        case YQLType.Uint32:
-        case YQLType.Uint64:
-        case YQLType.Float:
-        case YQLType.Double:
-        case YQLType.Decimal:
-            return 'number';
-        case YQLType.String:
-        case YQLType.Utf8:
-        case YQLType.Json:
-        case YQLType.JsonDocument:
-        case YQLType.Yson:
-        case YQLType.Uuid:
-            return 'string';
-        case YQLType.Date:
-        case YQLType.Datetime:
-        case YQLType.Timestamp:
-        case YQLType.Interval:
-        case YQLType.TzDate:
-        case YQLType.TzDateTime:
-        case YQLType.TzTimestamp:
-            return 'date';
-        default:
-            return undefined;
-    }
-};
-
-/** parse response result from ArrayRow to KeyValueRow */
-const parseModernResult = (rows: ArrayRow[], columns: ColumnType[]) => {
-    return rows.map((row) => {
-        return row.reduce<KeyValueRow>((newRow, cellData, columnIndex) => {
-            const {name} = columns[columnIndex];
-            newRow[name] = cellData;
-            return newRow;
-        }, {});
-    });
-};
-
-const parseExecuteModernResponse = (data: ExecuteModernResponse): IQueryResult => {
-    const {result, columns, ...restData} = data;
-
-    return {
-        result: result && columns && parseModernResult(result, columns),
-        columns,
-        ...restData,
-    };
-};
-
-const parseExecuteMultiResponse = (data: ExecuteMultiResponse): IQueryResult => {
-    const {result, ...restData} = data;
-
-    const parsedResult = result?.map((resultSet) => {
-        const {rows, columns} = resultSet;
-
-        let parsedRows: KeyValueRow[] | undefined;
-
-        if (columns) {
-            // Result shouldn't be null if there are columns
-            parsedRows = [];
-        }
-
-        if (rows && columns) {
-            parsedRows = parseModernResult(rows, columns);
-        }
-
-        return {
-            columns: columns,
-            result: parsedRows,
-        };
-    });
-
-    return {
-        resultSets: parsedResult, // use a separate field to make result compatible
-        ...restData,
-    };
-};
-
-const isModern = (response: AnyExecuteResponse): response is ExecuteModernResponse =>
-    Boolean(
-        response &&
-            !Array.isArray(response) &&
-            Array.isArray(response.result) &&
-            Array.isArray((response as ExecuteModernResponse).columns),
-    );
-
-const isMulti = (response: AnyExecuteResponse): response is ExecuteMultiResponse =>
-    Boolean(
-        response &&
-            !Array.isArray(response) &&
-            Array.isArray(response.result) &&
-            typeof response.result[0] === 'object' &&
-            'rows' in response.result[0] &&
-            'columns' in response.result[0],
-    );
-
-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)),
-    );
-};
-
-// Although schema is set in request, if schema is not supported default schema for the version will be used
-// So we should additionally parse response
-export const parseQueryAPIExecuteResponse = (
-    data: AnyExecuteResponse | UnsupportedQueryResponseFormat,
-): IQueryResult => {
-    if (isUnsupportedType(data)) {
-        return {};
-    }
-    if (isMulti(data)) {
-        return parseExecuteMultiResponse(data);
-    }
-    if (isModern(data)) {
-        return parseExecuteModernResponse(data);
-    }
-
-    return data;
-};
-
-export const parseQueryAPIExplainResponse = (
-    data: AnyExplainResponse | UnsupportedQueryResponseFormat,
-): IQueryResult => {
-    if (isUnsupportedType(data)) {
-        return {};
-    }
-
-    return data;
-};
-
-const isExplainScriptPlan = (plan: ScriptPlan | QueryPlan): plan is ScriptPlan =>
-    Boolean(plan && 'queries' in plan);
-
-export const parseQueryExplainPlan = (plan: ScriptPlan | QueryPlan): QueryPlan => {
-    if (isExplainScriptPlan(plan)) {
-        if (!plan.queries || !plan.queries.length) {
-            return {meta: plan.meta};
-        }
-
-        return {
-            Plan: plan.queries[0].Plan,
-            tables: plan.queries[0].tables,
-            meta: plan.meta,
-        };
-    }
-
-    return plan;
-};
-
-export const prepareQueryResponse = (data?: KeyValueRow[]) => {
-    if (!Array.isArray(data)) {
-        return [];
-    }
-
-    return data.map((row) => {
-        const formattedData: KeyValueRow = {};
-
-        for (const field in row) {
-            if (Object.prototype.hasOwnProperty.call(row, field)) {
-                const type = typeof row[field];
-
-                // Although typeof null == 'object'
-                // null result should be preserved
-                if (
-                    (row[field] !== null && type === 'object') ||
-                    type === 'boolean' ||
-                    Array.isArray(row[field])
-                ) {
-                    formattedData[field] = JSON.stringify(row[field]);
-                } else {
-                    formattedData[field] = row[field];
-                }
-            }
-        }
-
-        return formattedData;
-    });
-};
-
-export function prepareQueryError(error: QueryErrorResponse) {
-    return error.data?.error?.message || error.statusText;
-}

package/dist/utils/registerError.ts

@@ -1,18 +0,0 @@
-export function registerError(error: Error, message?: string, type = 'error') {
-    if (typeof window !== 'undefined' && window.Ya?.Rum) {
-        window.Ya.Rum.logError(
-            {
-                additional: {
-                    url: window.location.href,
-                },
-                type,
-                message,
-                level: window.Ya.Rum.ERROR_LEVEL.ERROR,
-            },
-            error,
-        );
-    } else {
-        // eslint-disable-next-line no-console
-        console.error(error);
-    }
-}

package/dist/utils/storage.ts

@@ -1,40 +0,0 @@
-import type {TVSlotId, TVDiskStateInfo} from '../types/api/vdisk';
-import type {ValueOf} from '../types/common';
-
-export const isFullVDiskData = (disk: TVDiskStateInfo | TVSlotId): disk is TVDiskStateInfo =>
-    'VDiskId' in disk;
-
-interface EntityWithUsage {
-    Used: number;
-    Limit: number;
-}
-
-export const getUsage = <T extends EntityWithUsage>(data: T, step = 1) => {
-    // if limit is 0, display 0
-    const usage = data.Limit ? (data.Used * 100) / data.Limit : 0;
-
-    return Math.floor(usage / step) * step;
-};
-
-/**
- * Values to sort /storage v2 response
- *
- * Source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/json_storage.h
- */
-export const STORAGE_SORT_VALUES = {
-    PoolName: 'PoolName',
-    Kind: 'Kind',
-    Erasure: 'Erasure',
-    Degraded: 'Degraded',
-    Usage: 'Usage',
-    GroupId: 'GroupId',
-    Used: 'Used',
-    Limit: 'Limit',
-    Read: 'Read',
-    Write: 'Write',
-} as const;
-
-export type StorageSortValue = ValueOf<typeof STORAGE_SORT_VALUES>;
-
-export const isSortableStorageProperty = (value: string): value is StorageSortValue =>
-    Object.values(STORAGE_SORT_VALUES).includes(value as StorageSortValue);

package/dist/utils/tablet.ts

@@ -1,54 +0,0 @@
-import {EFlag} from '../types/api/enums';
-import {ETabletState} from '../types/api/tablet';
-
-// Similar to mapping in https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/viewer.cpp
-const tabletStateToColorState: Record<ETabletState, EFlag> = {
-    [ETabletState.Dead]: EFlag.Red,
-
-    [ETabletState.Created]: EFlag.Yellow,
-    [ETabletState.ResolveStateStorage]: EFlag.Yellow,
-    [ETabletState.Candidate]: EFlag.Yellow,
-    [ETabletState.BlockBlobStorage]: EFlag.Yellow,
-    [ETabletState.WriteZeroEntry]: EFlag.Yellow,
-    [ETabletState.Restored]: EFlag.Yellow,
-    [ETabletState.Discover]: EFlag.Yellow,
-    [ETabletState.Lock]: EFlag.Yellow,
-    [ETabletState.Stopped]: EFlag.Yellow,
-    [ETabletState.ResolveLeader]: EFlag.Yellow,
-    [ETabletState.RebuildGraph]: EFlag.Yellow,
-
-    [ETabletState.Deleted]: EFlag.Green,
-    [ETabletState.Active]: EFlag.Green,
-};
-
-export const tabletStates = Object.keys(ETabletState);
-
-export const tabletColorToTabletState = Object.entries(tabletStateToColorState).reduce(
-    (acc, [state, color]) => {
-        if (acc[color]) {
-            acc[color].push(state as ETabletState);
-        } else {
-            acc[color] = [state as ETabletState];
-        }
-
-        return acc;
-    },
-    {} as Record<EFlag, ETabletState[]>,
-);
-
-// Tablet State in different versions or in different endpoint
-// could be represented as ETabletState of EFlag
-export const mapTabletStateToColorState = (state?: ETabletState | EFlag): EFlag => {
-    if (!state) {
-        return EFlag.Grey;
-    }
-
-    const isEFlag = (value: ETabletState | EFlag): value is EFlag =>
-        Object.values(EFlag).includes(value as EFlag);
-
-    if (isEFlag(state)) {
-        return state;
-    }
-
-    return tabletStateToColorState[state];
-};

package/dist/utils/tests/providers.tsx

@@ -1,26 +0,0 @@
-import React, {PropsWithChildren} from 'react';
-import {Provider} from 'react-redux';
-import {render} from '@testing-library/react';
-import type {RenderOptions} from '@testing-library/react';
-
-import configureStore from '../../store';
-
-interface ExtendedRenderOptions extends Omit<RenderOptions, 'queries'> {
-    storeConfiguration?: {
-        store?: any;
-        history?: any;
-    };
-}
-
-export const renderWithStore = (
-    ui: React.ReactElement,
-    {storeConfiguration = configureStore(), ...renderOptions}: ExtendedRenderOptions = {},
-) => {
-    const {store} = storeConfiguration;
-
-    function Wrapper({children}: PropsWithChildren<{}>) {
-        return <Provider store={store}>{children}</Provider>;
-    }
-
-    return {store, ...render(ui, {wrapper: Wrapper, ...renderOptions})};
-};