ydb-embedded-ui 4.33.0 → 5.0.0

package/dist/store/reducers/node/types.ts

@@ -1,46 +0,0 @@
-import type {IResponseError} from '../../../types/api/error';
-import type {TPDiskStateInfo} from '../../../types/api/pdisk';
-import type {TStorageInfo} from '../../../types/api/storage';
-import type {TEvSystemStateResponse} from '../../../types/api/systemState';
-import type {TVDiskStateInfo} from '../../../types/api/vdisk';
-import type {ApiRequestAction} from '../../utils';
-
-import {FETCH_NODE, FETCH_NODE_STRUCTURE, resetNode} from './node';
-
-interface RawStructurePDisk extends TPDiskStateInfo {
-    vDisks: Record<string, TVDiskStateInfo>;
-}
-
-export type RawNodeStructure = Record<string, RawStructurePDisk>;
-
-export interface PreparedStructureVDisk extends TVDiskStateInfo {
-    id: string;
-    order: number;
-}
-
-export interface PreparedStructurePDisk extends TPDiskStateInfo {
-    vDisks: PreparedStructureVDisk[];
-}
-
-export type PreparedNodeStructure = Record<string, PreparedStructurePDisk>;
-
-export interface NodeState {
-    data: TEvSystemStateResponse;
-    loading: boolean;
-    wasLoaded: boolean;
-    error?: IResponseError;
-
-    nodeStructure: TStorageInfo;
-    loadingStructure: boolean;
-    wasLoadedStructure: boolean;
-    errorStructure?: IResponseError;
-}
-
-export type NodeAction =
-    | ApiRequestAction<typeof FETCH_NODE, TEvSystemStateResponse, IResponseError>
-    | ApiRequestAction<typeof FETCH_NODE_STRUCTURE, TStorageInfo, IResponseError>
-    | ReturnType<typeof resetNode>;
-
-export interface NodeStateSlice {
-    node: NodeState;
-}

package/dist/store/reducers/nodes/nodes.ts

@@ -1,150 +0,0 @@
-import type {Reducer} from 'redux';
-
-import '../../../services/api';
-import {NodesUptimeFilterValues} from '../../../utils/nodes';
-import {EVersion} from '../../../types/api/compute';
-
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-
-import type {
-    ComputeApiRequestParams,
-    NodesAction,
-    NodesApiRequestParams,
-    NodesSortParams,
-    NodesState,
-} from './types';
-import {prepareComputeNodesData, prepareNodesData} from './utils';
-
-export const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
-
-const RESET_NODES_STATE = 'nodes/RESET_NODES_STATE';
-const SET_NODES_UPTIME_FILTER = 'nodes/SET_NODES_UPTIME_FILTER';
-const SET_DATA_WAS_NOT_LOADED = 'nodes/SET_DATA_WAS_NOT_LOADED';
-const SET_SEARCH_VALUE = 'nodes/SET_SEARCH_VALUE';
-const SET_SORT = 'nodes/SET_SORT';
-
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-    nodesUptimeFilter: NodesUptimeFilterValues.All,
-    searchValue: '',
-};
-
-const nodes: Reducer<NodesState, NodesAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_NODES.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_NODES.SUCCESS: {
-            return {
-                ...state,
-                data: action.data?.Nodes,
-                totalNodes: action.data?.TotalNodes,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_NODES.FAILURE: {
-            if (action.error?.isCancelled) {
-                return state;
-            }
-
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-        case RESET_NODES_STATE: {
-            return {
-                ...state,
-                loading: initialState.loading,
-                wasLoaded: initialState.wasLoaded,
-                nodesUptimeFilter: initialState.nodesUptimeFilter,
-                searchValue: initialState.searchValue,
-            };
-        }
-        case SET_NODES_UPTIME_FILTER: {
-            return {
-                ...state,
-                nodesUptimeFilter: action.data,
-            };
-        }
-        case SET_SEARCH_VALUE: {
-            return {
-                ...state,
-                searchValue: action.data,
-            };
-        }
-        case SET_SORT: {
-            return {
-                ...state,
-                sortValue: action.data.sortValue,
-                sortOrder: action.data.sortOrder,
-            };
-        }
-        case SET_DATA_WAS_NOT_LOADED: {
-            return {
-                ...state,
-                wasLoaded: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-const concurrentId = 'getNodes';
-
-export function getNodes({type = 'any', storage = false, ...params}: NodesApiRequestParams) {
-    return createApiRequest({
-        request: window.api.getNodes({type, storage, ...params}, {concurrentId}),
-        actions: FETCH_NODES,
-        dataHandler: prepareNodesData,
-    });
-}
-
-export function getComputeNodes({version = EVersion.v2, ...params}: ComputeApiRequestParams) {
-    return createApiRequest({
-        request: window.api.getCompute({version, ...params}, {concurrentId}),
-        actions: FETCH_NODES,
-        dataHandler: prepareComputeNodesData,
-    });
-}
-
-export const resetNodesState = () => {
-    return {
-        type: RESET_NODES_STATE,
-    } as const;
-};
-
-export const setNodesUptimeFilter = (value: NodesUptimeFilterValues) =>
-    ({
-        type: SET_NODES_UPTIME_FILTER,
-        data: value,
-    } as const);
-
-export const setDataWasNotLoaded = () => {
-    return {
-        type: SET_DATA_WAS_NOT_LOADED,
-    } as const;
-};
-
-export const setSearchValue = (value: string) => {
-    return {
-        type: SET_SEARCH_VALUE,
-        data: value,
-    } as const;
-};
-
-export const setSort = (sortParams: NodesSortParams) => {
-    return {
-        type: SET_SORT,
-        data: sortParams,
-    } as const;
-};
-
-export default nodes;

package/dist/store/reducers/nodes/selectors.ts

@@ -1,74 +0,0 @@
-import {Selector, createSelector} from 'reselect';
-
-import {EFlag} from '../../../types/api/enums';
-import {calcUptimeInSeconds} from '../../../utils/dataFormatters/dataFormatters';
-import {HOUR_IN_SECONDS} from '../../../utils/constants';
-import {NodesUptimeFilterValues} from '../../../utils/nodes';
-import {prepareSearchValue} from '../../../utils/filters';
-
-import type {ProblemFilterValue} from '../settings/types';
-import type {NodesPreparedEntity, NodesStateSlice} from './types';
-import {ProblemFilterValues} from '../settings/settings';
-
-// ==== Filters ====
-
-const filterNodesByProblemsStatus = (
-    nodesList: NodesPreparedEntity[] = [],
-    problemFilter: ProblemFilterValue,
-) => {
-    if (problemFilter === ProblemFilterValues.ALL) {
-        return nodesList;
-    }
-
-    return nodesList.filter(({SystemState}) => {
-        return SystemState && SystemState !== EFlag.Green;
-    });
-};
-
-export const filterNodesByUptime = <T extends {StartTime?: string}>(
-    nodesList: T[] = [],
-    nodesUptimeFilter: NodesUptimeFilterValues,
-) => {
-    if (nodesUptimeFilter === NodesUptimeFilterValues.All) {
-        return nodesList;
-    }
-    return nodesList.filter(({StartTime}) => {
-        return !StartTime || calcUptimeInSeconds(StartTime) < HOUR_IN_SECONDS;
-    });
-};
-
-const filterNodesBySearchValue = (nodesList: NodesPreparedEntity[] = [], searchValue: string) => {
-    if (!searchValue) {
-        return nodesList;
-    }
-    const re = prepareSearchValue(searchValue);
-
-    return nodesList.filter((node) => {
-        return node.Host ? re.test(node.Host) || re.test(String(node.NodeId)) : true;
-    });
-};
-
-// ==== Simple selectors ====
-
-const selectNodesUptimeFilter = (state: NodesStateSlice) => state.nodes.nodesUptimeFilter;
-const selectSearchValue = (state: NodesStateSlice) => state.nodes.searchValue;
-const selectNodesList = (state: NodesStateSlice) => state.nodes.data;
-
-// ==== Complex selectors ====
-
-export const selectFilteredNodes: Selector<NodesStateSlice, NodesPreparedEntity[] | undefined> =
-    createSelector(
-        [
-            selectNodesList,
-            selectNodesUptimeFilter,
-            selectSearchValue,
-            (state) => state.settings.problemFilter,
-        ],
-        (nodesList, uptimeFilter, searchValue, problemFilter) => {
-            let result = filterNodesByUptime(nodesList, uptimeFilter);
-            result = filterNodesByProblemsStatus(result, problemFilter);
-            result = filterNodesBySearchValue(result, searchValue);
-
-            return result;
-        },
-    );

package/dist/store/reducers/nodes/types.ts

@@ -1,120 +0,0 @@
-import type {OrderType} from '@gravity-ui/react-data-table';
-
-import type {IResponseError} from '../../../types/api/error';
-import type {TEndpoint, TPoolStats} from '../../../types/api/nodes';
-import type {
-    EVersion,
-    TTabletStateInfo as TComputeTabletStateInfo,
-} from '../../../types/api/compute';
-import type {TTabletStateInfo as TFullTabletStateInfo} from '../../../types/api/tablet';
-import type {EFlag} from '../../../types/api/enums';
-import type {ApiRequestAction} from '../../utils';
-import type {VisibleEntities} from '../storage/types';
-
-import type {NodesSortValue, NodesUptimeFilterValues} from '../../../utils/nodes';
-import {
-    FETCH_NODES,
-    resetNodesState,
-    setDataWasNotLoaded,
-    setNodesUptimeFilter,
-    setSearchValue,
-    setSort,
-} from './nodes';
-
-// Since nodes from different endpoints can have different types,
-// This type describes fields, that are expected by tables with nodes
-export interface NodesPreparedEntity {
-    NodeId: number;
-    Host?: string;
-    SystemState?: EFlag;
-    DataCenter?: string;
-    Rack?: string;
-    Version?: string;
-    TenantName?: string;
-
-    StartTime?: string;
-    Uptime: string;
-    DisconnectTime?: string;
-
-    MemoryUsed?: string;
-    MemoryUsedInAlloc?: string;
-    MemoryLimit?: string;
-
-    SharedCacheUsed?: string;
-    SharedCacheLimit?: string | number;
-
-    PoolStats?: TPoolStats[];
-    LoadAverage?: number[];
-    Tablets?: TFullTabletStateInfo[] | TComputeTabletStateInfo[];
-    Endpoints?: TEndpoint[];
-
-    TotalSessions?: number;
-}
-
-export interface NodesState {
-    loading: boolean;
-    wasLoaded: boolean;
-    nodesUptimeFilter: NodesUptimeFilterValues;
-    searchValue: string;
-    sortValue?: NodesSortValue;
-    sortOrder?: OrderType;
-    data?: NodesPreparedEntity[];
-    totalNodes?: number;
-    error?: IResponseError;
-}
-
-export type NodeType = 'static' | 'dynamic' | 'any';
-
-export interface NodesSortParams {
-    sortOrder?: OrderType;
-    sortValue?: NodesSortValue;
-}
-
-export interface NodesGeneralRequestParams extends NodesSortParams {
-    filter?: string; // NodeId or Host
-    uptime?: number; // return nodes with less uptime in seconds
-    problems_only?: boolean; // return nodes with SystemState !== EFlag.Green
-
-    offset?: number;
-    limit?: number;
-}
-
-export interface NodesApiRequestParams extends NodesGeneralRequestParams {
-    path?: string;
-    tenant?: string;
-    type?: NodeType;
-    visibleEntities?: VisibleEntities; // "with" param
-    storage?: boolean;
-    tablets?: boolean;
-}
-
-export interface ComputeApiRequestParams extends NodesGeneralRequestParams {
-    path: string;
-    version?: EVersion; // only v2 works with filters
-}
-
-export interface NodesHandledResponse {
-    Nodes?: NodesPreparedEntity[];
-    TotalNodes: number;
-    FoundNodes?: number;
-}
-
-type NodesApiRequestAction = ApiRequestAction<
-    typeof FETCH_NODES,
-    NodesHandledResponse,
-    IResponseError
->;
-
-export type NodesAction =
-    | NodesApiRequestAction
-    | (
-          | ReturnType<typeof setDataWasNotLoaded>
-          | ReturnType<typeof setNodesUptimeFilter>
-          | ReturnType<typeof setSearchValue>
-          | ReturnType<typeof setSort>
-          | ReturnType<typeof resetNodesState>
-      );
-
-export interface NodesStateSlice {
-    nodes: NodesState;
-}

package/dist/store/reducers/nodes/utils.ts

@@ -1,75 +0,0 @@
-import type {TComputeInfo, TComputeNodeInfo, TComputeTenantInfo} from '../../../types/api/compute';
-import type {TNodesInfo} from '../../../types/api/nodes';
-import {calcUptime} from '../../../utils/dataFormatters/dataFormatters';
-import {generateEvaluator} from '../../../utils/generateEvaluator';
-
-import type {NodesHandledResponse, NodesPreparedEntity} from './types';
-
-const prepareComputeNode = (node: TComputeNodeInfo, tenantName?: string) => {
-    return {
-        ...node,
-        // v2 response has tenant name, v1 - doesn't
-        TenantName: node.Tenant ?? tenantName,
-        SystemState: node?.Overall,
-        Uptime: calcUptime(node?.StartTime),
-    };
-};
-
-export const prepareComputeNodes = (nodes?: TComputeNodeInfo[], tenants?: TComputeTenantInfo[]) => {
-    const preparedNodes: NodesPreparedEntity[] = [];
-
-    // First try to parse v2 response in case backend supports it
-    // Else parse v1 response
-
-    if (nodes) {
-        nodes.forEach((node) => {
-            preparedNodes.push(prepareComputeNode(node));
-        });
-    } else if (tenants) {
-        for (const tenant of tenants) {
-            tenant.Nodes?.forEach((node) => {
-                preparedNodes.push(prepareComputeNode(node, tenant.Name));
-            });
-        }
-    }
-
-    return preparedNodes;
-};
-
-export const prepareComputeNodesData = (data: TComputeInfo): NodesHandledResponse => {
-    const preparedNodes = prepareComputeNodes(data.Nodes, data.Tenants);
-
-    return {
-        Nodes: preparedNodes,
-        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
-        FoundNodes: Number(data.FoundNodes),
-    };
-};
-
-export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
-    const rawNodes = data.Nodes || [];
-
-    const preparedNodes = rawNodes.map((node) => {
-        // 0 limit means that limit is not set, so it should be undefined
-        const sharedCacheLimit = Number(node.SystemState.SharedCacheStats?.LimitBytes) || undefined;
-
-        return {
-            ...node.SystemState,
-            Tablets: node.Tablets,
-            NodeId: node.NodeId,
-            Uptime: calcUptime(node.SystemState?.StartTime),
-            TenantName: node.SystemState?.Tenants?.[0],
-
-            SharedCacheUsed: node.SystemState.SharedCacheStats?.UsedBytes,
-            SharedCacheLimit: sharedCacheLimit,
-        };
-    });
-
-    return {
-        Nodes: preparedNodes,
-        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
-        FoundNodes: Number(data.FoundNodes),
-    };
-};
-
-export const getLoadSeverityForNode = generateEvaluator(60, 80, ['success', 'warning', 'danger']);

package/dist/store/reducers/nodesList.ts

@@ -1,55 +0,0 @@
-import type {Reducer} from 'redux';
-
-import type {
-    NodesListState,
-    NodesListAction,
-    NodesListRootStateSlice,
-} from '../../types/store/nodesList';
-import '../../services/api';
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import {prepareNodesMap} from '../../utils/nodes';
-
-export const FETCH_NODES_LIST = createRequestActionTypes('nodesList', 'FETCH_NODES_LIST');
-
-const initialState = {loading: true, wasLoaded: false, data: []};
-
-const nodesList: Reducer<NodesListState, NodesListAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_NODES_LIST.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_NODES_LIST.SUCCESS: {
-            return {
-                ...state,
-                data: action.data,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_NODES_LIST.FAILURE: {
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export function getNodesList() {
-    return createApiRequest({
-        request: window.api.getNodesList(),
-        actions: FETCH_NODES_LIST,
-    });
-}
-
-export const selectNodesMap = (state: NodesListRootStateSlice) =>
-    prepareNodesMap(state.nodesList.data);
-
-export default nodesList;

package/dist/store/reducers/olapStats.ts

@@ -1,79 +0,0 @@
-import type {Reducer} from 'redux';
-
-import type {OlapStatsAction, OlapStatsState} from '../../types/store/olapStats';
-
-import '../../services/api';
-import {parseQueryAPIExecuteResponse} from '../../utils/query';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
-
-export const FETCH_OLAP_STATS = createRequestActionTypes('query', 'SEND_OLAP_STATS_QUERY');
-const RESET_LOADING_STATE = 'olapStats/RESET_LOADING_STATE';
-
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-};
-
-function createOlatStatsQuery(path: string) {
-    return `SELECT * FROM \`${path}/.sys/primary_index_stats\``;
-}
-
-const queryAction = 'execute-scan';
-
-const olapStats: Reducer<OlapStatsState, OlapStatsAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_OLAP_STATS.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-                error: undefined,
-            };
-        }
-        case FETCH_OLAP_STATS.SUCCESS: {
-            return {
-                ...state,
-                data: action.data,
-                loading: false,
-                error: undefined,
-                wasLoaded: true,
-            };
-        }
-        case FETCH_OLAP_STATS.FAILURE: {
-            return {
-                ...state,
-                error: action.error || 'Unauthorized',
-                loading: false,
-            };
-        }
-        case RESET_LOADING_STATE: {
-            return {
-                ...state,
-                wasLoaded: initialState.wasLoaded,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export const getOlapStats = ({path = ''}) => {
-    return createApiRequest({
-        request: window.api.sendQuery({
-            schema: 'modern',
-            query: createOlatStatsQuery(path),
-            database: path,
-            action: queryAction,
-        }),
-        actions: FETCH_OLAP_STATS,
-        dataHandler: parseQueryAPIExecuteResponse,
-    });
-};
-
-export function resetLoadingState() {
-    return {
-        type: RESET_LOADING_STATE,
-    } as const;
-}
-
-export default olapStats;