ydb-embedded-ui 4.33.0 → 5.0.0

package/dist/store/reducers/healthcheckInfo.ts

@@ -1,169 +0,0 @@
-import _flow from 'lodash/fp/flow';
-import _sortBy from 'lodash/fp/sortBy';
-import _uniqBy from 'lodash/fp/uniqBy';
-import {createSelector, Selector} from 'reselect';
-import {Reducer} from 'redux';
-
-import type {
-    IHealthCheckInfoAction,
-    IHealthcheckInfoRootStateSlice,
-    IHealthcheckInfoState,
-    IIssuesTree,
-} from '../../types/store/healthcheck';
-import type {IssueLog, StatusFlag} from '../../types/api/healthcheck';
-
-import '../../services/api';
-import {createRequestActionTypes, createApiRequest} from '../utils';
-
-export const FETCH_HEALTHCHECK = createRequestActionTypes('cluster', 'FETCH_HEALTHCHECK');
-
-const SET_DATA_WAS_NOT_LOADED = 'healthcheckInfo/SET_DATA_WAS_NOT_LOADED';
-
-const initialState = {loading: false, wasLoaded: false};
-
-const healthcheckInfo: Reducer<IHealthcheckInfoState, IHealthCheckInfoAction> = function (
-    state = initialState,
-    action,
-) {
-    switch (action.type) {
-        case FETCH_HEALTHCHECK.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_HEALTHCHECK.SUCCESS: {
-            const {data} = action;
-
-            return {
-                ...state,
-                data,
-                wasLoaded: true,
-                loading: false,
-                error: undefined,
-            };
-        }
-        case FETCH_HEALTHCHECK.FAILURE: {
-            if (action.error?.isCancelled) {
-                return state;
-            }
-
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-                wasLoaded: true,
-                data: undefined,
-            };
-        }
-
-        case SET_DATA_WAS_NOT_LOADED: {
-            return {
-                ...state,
-                wasLoaded: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-const mapStatusToPriority: Partial<Record<StatusFlag, number>> = {
-    RED: 0,
-    ORANGE: 1,
-    YELLOW: 2,
-    BLUE: 3,
-    GREEN: 4,
-};
-
-const sortIssues = (data: IssueLog[]): IssueLog[] => {
-    return data.sort((a, b) => {
-        const aPriority = mapStatusToPriority[a.status] || 0;
-        const bPriority = mapStatusToPriority[b.status] || 0;
-
-        return aPriority - bPriority;
-    });
-};
-
-const getReasonsForIssue = ({issue, data}: {issue: IssueLog; data: IssueLog[]}) => {
-    return sortIssues(data.filter((item) => issue.reason && issue.reason.indexOf(item.id) !== -1));
-};
-
-const getRoots = (data: IssueLog[]): IssueLog[] => {
-    return sortIssues(
-        data.filter((item) => {
-            return !data.find((issue) => issue.reason && issue.reason.indexOf(item.id) !== -1);
-        }),
-    );
-};
-
-const getInvertedConsequencesTree = ({
-    data,
-    roots,
-}: {
-    data: IssueLog[];
-    roots?: IssueLog[];
-}): IIssuesTree[] => {
-    return roots
-        ? roots.map((issue) => {
-              const reasonsItems = getInvertedConsequencesTree({
-                  roots: getReasonsForIssue({issue, data}),
-                  data,
-              });
-
-              return {
-                  ...issue,
-                  reasonsItems,
-              };
-          })
-        : [];
-};
-
-const getIssuesStatistics = (data: IssueLog[]): [StatusFlag, number][] => {
-    const issuesMap = {} as Record<StatusFlag, number>;
-
-    for (const issue of data) {
-        if (!issuesMap[issue.status]) {
-            issuesMap[issue.status] = 0;
-        }
-        issuesMap[issue.status]++;
-    }
-
-    return (Object.entries(issuesMap) as [StatusFlag, number][]).sort(([aStatus], [bStatus]) => {
-        const bPriority = mapStatusToPriority[bStatus] || 0;
-        const aPriority = mapStatusToPriority[aStatus] || 0;
-
-        return aPriority - bPriority;
-    });
-};
-
-const getIssuesLog = (state: IHealthcheckInfoRootStateSlice) =>
-    state.healthcheckInfo.data?.issue_log;
-
-export const selectIssuesTreesRoots: Selector<IHealthcheckInfoRootStateSlice, IssueLog[]> =
-    createSelector(getIssuesLog, (issues = []) => getRoots(issues));
-
-export const selectIssuesTrees: Selector<IHealthcheckInfoRootStateSlice, IIssuesTree[]> =
-    createSelector([getIssuesLog, selectIssuesTreesRoots], (data = [], roots = []) => {
-        return getInvertedConsequencesTree({data, roots});
-    });
-
-export const selectIssuesStatistics: Selector<
-    IHealthcheckInfoRootStateSlice,
-    [StatusFlag, number][]
-> = createSelector(getIssuesLog, (issues = []) => getIssuesStatistics(issues));
-
-export function getHealthcheckInfo(database: string) {
-    return createApiRequest({
-        request: window.api.getHealthcheckInfo(database, {concurrentId: 'getHealthcheckInfo'}),
-        actions: FETCH_HEALTHCHECK,
-    });
-}
-
-export const setDataWasNotLoaded = () => {
-    return {
-        type: SET_DATA_WAS_NOT_LOADED,
-    } as const;
-};
-
-export default healthcheckInfo;

package/dist/store/reducers/heatmap.ts

@@ -1,120 +0,0 @@
-import type {Reducer} from 'redux';
-
-import '../../services/api';
-import type {
-    IHeatmapAction,
-    IHeatmapApiRequestParams,
-    IHeatmapState,
-    IHeatmapTabletData,
-} from '../../types/store/heatmap';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
-
-export const FETCH_HEATMAP = createRequestActionTypes('heatmap', 'FETCH_HEATMAP');
-
-const SET_HEATMAP_OPTIONS = 'heatmap/SET_HEATMAP_OPTIONS';
-
-export const initialState = {
-    loading: false,
-    wasLoaded: false,
-    currentMetric: undefined,
-    sort: false,
-    heatmap: false,
-};
-
-const heatmap: Reducer<IHeatmapState, IHeatmapAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_HEATMAP.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_HEATMAP.SUCCESS: {
-            return {
-                ...state,
-                ...action.data,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_HEATMAP.FAILURE: {
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-                wasLoaded: false,
-            };
-        }
-        case SET_HEATMAP_OPTIONS:
-            return {
-                ...state,
-                ...action.data,
-            };
-        default:
-            return state;
-    }
-};
-
-export function getTabletsInfo({nodes, path}: IHeatmapApiRequestParams) {
-    return createApiRequest({
-        request: Promise.all([
-            window.api.getTabletsInfo({nodes, path}),
-            window.api.getHeatmapData({path}),
-        ]),
-        actions: FETCH_HEATMAP,
-        dataHandler: ([tabletsData = {}, describe = {}]) => {
-            const {TabletStateInfo: tablets = []} = tabletsData;
-            const TabletsMap: Map<string, IHeatmapTabletData> = new Map();
-            const {PathDescription = {}} = describe;
-            const {
-                TablePartitions = [],
-                TablePartitionStats = [],
-                TablePartitionMetrics = [],
-            } = PathDescription;
-
-            tablets.forEach((item) => {
-                if (item.TabletId) {
-                    TabletsMap.set(item.TabletId, item);
-                }
-            });
-
-            TablePartitions.forEach((item, index) => {
-                const metrics = Object.assign(
-                    {},
-                    TablePartitionStats[index],
-                    TablePartitionMetrics[index],
-                );
-                if (item.DatashardId) {
-                    TabletsMap.set(item.DatashardId, {
-                        ...TabletsMap.get(item.DatashardId),
-                        metrics,
-                    });
-                }
-            });
-
-            const preparedTablets = Array.from(TabletsMap.values());
-            const selectMetrics =
-                preparedTablets[0] &&
-                preparedTablets[0].metrics &&
-                Object.keys(preparedTablets[0].metrics).map((item) => {
-                    return {
-                        value: item,
-                        content: item,
-                    };
-                });
-
-            return {data: preparedTablets, metrics: selectMetrics};
-        },
-    });
-}
-
-export function setHeatmapOptions(options: Partial<IHeatmapState>) {
-    return {
-        type: SET_HEATMAP_OPTIONS,
-        data: options,
-    } as const;
-}
-
-export default heatmap;

package/dist/store/reducers/host.ts

@@ -1,48 +0,0 @@
-import type {Reducer} from 'redux';
-
-import type {IHostAction, IHostState} from '../../types/store/host';
-import '../../services/api';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
-
-export const FETCH_HOST = createRequestActionTypes('host', 'FETCH_HOST');
-
-const initialState = {loading: true, wasLoaded: false, data: {}};
-
-const host: Reducer<IHostState, IHostAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_HOST.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_HOST.SUCCESS: {
-            return {
-                ...state,
-                data: action.data.SystemStateInfo?.[0],
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_HOST.FAILURE: {
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export function getHostInfo() {
-    return createApiRequest({
-        request: window.api.getHostInfo(),
-        actions: FETCH_HOST,
-    });
-}
-
-export default host;

package/dist/store/reducers/index.ts

@@ -1,99 +0,0 @@
-import {combineReducers} from 'redux';
-
-import nodes from './nodes/nodes';
-import {topNodesByLoad} from './tenantOverview/topNodesByLoad/topNodesByLoad';
-import {topNodesByCpu} from './tenantOverview/topNodesByCpu/topNodesByCpu';
-import {topNodesByMemory} from './tenantOverview/topNodesByMemory/topNodesByMemory';
-import cluster from './cluster/cluster';
-import clusterNodes from './clusterNodes/clusterNodes';
-import tenant from './tenant/tenant';
-import storage from './storage/storage';
-import topStorageGroups from './tenantOverview/topStorageGroups/topStorageGroups';
-import node from './node/node';
-import tooltip from './tooltip';
-import tablets from './tablets';
-import heatmap from './heatmap';
-import schema from './schema/schema';
-import overview from './overview/overview';
-import host from './host';
-import network from './network/network';
-import tenants from './tenants/tenants';
-import tablet from './tablet';
-import topic from './topic';
-import partitions from './partitions/partitions';
-import executeQuery from './executeQuery';
-import explainQuery from './explainQuery';
-import tabletsFilters from './tabletsFilters';
-import settings from './settings/settings';
-import preview from './preview';
-import nodesList from './nodesList';
-import describe from './describe';
-import schemaAcl from './schemaAcl/schemaAcl';
-import executeTopQueries from './executeTopQueries/executeTopQueries';
-import {tenantOverviewTopQueries} from './tenantOverview/topQueries/tenantOverviewTopQueries';
-import executeTopTables from './tenantOverview/executeTopTables/executeTopTables';
-import healthcheckInfo from './healthcheckInfo';
-import shardsWorkload from './shardsWorkload/shardsWorkload';
-import {tenantOverviewTopShards} from './tenantOverview/topShards/tenantOverviewTopShards';
-import hotKeys from './hotKeys';
-import olapStats from './olapStats';
-import authentication from './authentication/authentication';
-import header from './header/header';
-import saveQuery from './saveQuery';
-import fullscreen from './fullscreen';
-import singleClusterMode from './singleClusterMode';
-
-export const rootReducer = {
-    singleClusterMode,
-    nodes,
-    topNodesByLoad,
-    topNodesByCpu,
-    topNodesByMemory,
-    cluster,
-    clusterNodes,
-    tenant,
-    storage,
-    topStorageGroups,
-    node,
-    tooltip,
-    tablets,
-    schema,
-    overview,
-    olapStats,
-    host,
-    network,
-    tenants,
-    tablet,
-    topic,
-    partitions,
-    executeQuery,
-    explainQuery,
-    tabletsFilters,
-    heatmap,
-    settings,
-    preview,
-    nodesList,
-    describe,
-    schemaAcl,
-    executeTopQueries,
-    executeTopTables,
-    tenantOverviewTopQueries,
-    healthcheckInfo,
-    shardsWorkload,
-    tenantOverviewTopShards,
-    hotKeys,
-    authentication,
-    header,
-    saveQuery,
-    fullscreen,
-};
-
-const combinedReducer = combineReducers({
-    ...rootReducer,
-});
-
-export type RootReducer = typeof combinedReducer;
-export type RootState = ReturnType<RootReducer>;
-export type GetState = () => RootState;
-
-export default combinedReducer;

package/dist/store/reducers/network/network.ts

@@ -1,69 +0,0 @@
-import {Reducer} from 'redux';
-
-import '../../../services/api';
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-
-import type {NetworkAction, NetworkState} from './types';
-
-export const FETCH_ALL_NODES_NETWORK = createRequestActionTypes(
-    'network',
-    'FETCH_ALL_NODES_NETWORK',
-);
-
-const SET_DATA_WAS_NOT_LOADED = 'network/SET_DATA_WAS_NOT_LOADED';
-
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-};
-
-const network: Reducer<NetworkState, NetworkAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_ALL_NODES_NETWORK.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_ALL_NODES_NETWORK.SUCCESS: {
-            return {
-                ...state,
-                data: action.data,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_ALL_NODES_NETWORK.FAILURE: {
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-
-        case SET_DATA_WAS_NOT_LOADED: {
-            return {
-                ...state,
-                wasLoaded: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export const setDataWasNotLoaded = () => {
-    return {
-        type: SET_DATA_WAS_NOT_LOADED,
-    } as const;
-};
-
-export const getNetworkInfo = (tenant: string) => {
-    return createApiRequest({
-        request: window.api.getNetwork(tenant),
-        actions: FETCH_ALL_NODES_NETWORK,
-    });
-};
-
-export default network;

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

@@ -1,16 +0,0 @@
-import type {IResponseError} from '../../../types/api/error';
-import type {TNetInfo} from '../../../types/api/netInfo';
-import type {ApiRequestAction} from '../../utils';
-
-import {FETCH_ALL_NODES_NETWORK, setDataWasNotLoaded} from './network';
-
-export interface NetworkState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data?: TNetInfo;
-    error?: IResponseError;
-}
-
-export type NetworkAction =
-    | ApiRequestAction<typeof FETCH_ALL_NODES_NETWORK, TNetInfo, IResponseError>
-    | ReturnType<typeof setDataWasNotLoaded>;

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

@@ -1,102 +0,0 @@
-import {Reducer} from 'redux';
-
-import '../../../services/api';
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-
-import type {NodeAction, NodeState} from './types';
-
-export const FETCH_NODE = createRequestActionTypes('node', 'FETCH_NODE');
-export const FETCH_NODE_STRUCTURE = createRequestActionTypes('node', 'FETCH_NODE_STRUCTURE');
-
-const RESET_NODE = 'node/RESET_NODE';
-
-const initialState = {
-    data: {},
-    loading: true,
-    wasLoaded: false,
-    nodeStructure: {},
-    loadingStructure: true,
-    wasLoadedStructure: false,
-};
-
-const node: Reducer<NodeState, NodeAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_NODE.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_NODE.SUCCESS: {
-            return {
-                ...state,
-                data: action.data,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        case FETCH_NODE.FAILURE: {
-            return {
-                ...state,
-                error: action.error,
-                loading: false,
-            };
-        }
-        case FETCH_NODE_STRUCTURE.REQUEST: {
-            return {
-                ...state,
-                loadingStructure: true,
-            };
-        }
-        case FETCH_NODE_STRUCTURE.SUCCESS: {
-            return {
-                ...state,
-                nodeStructure: action.data,
-                loadingStructure: false,
-                wasLoadedStructure: true,
-                errorStructure: undefined,
-            };
-        }
-        case FETCH_NODE_STRUCTURE.FAILURE: {
-            return {
-                ...state,
-                errorStructure: action.error,
-                loadingStructure: false,
-            };
-        }
-        case RESET_NODE: {
-            return {
-                ...state,
-                data: {},
-                wasLoaded: false,
-                nodeStructure: {},
-                wasLoadedStructure: false,
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export const getNodeInfo = (id: string) => {
-    return createApiRequest({
-        request: window.api.getNodeInfo(id),
-        actions: FETCH_NODE,
-    });
-};
-
-export const getNodeStructure = (nodeId: string) => {
-    return createApiRequest({
-        request: window.api.getStorageInfo({nodeId}, {concurrentId: 'getNodeStructure'}),
-        actions: FETCH_NODE_STRUCTURE,
-    });
-};
-
-export function resetNode() {
-    return {
-        type: RESET_NODE,
-    } as const;
-}
-
-export default node;

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

@@ -1,59 +0,0 @@
-import type {Selector} from 'reselect';
-import {createSelector} from 'reselect';
-
-import {stringifyVdiskId} from '../../../utils/dataFormatters/dataFormatters';
-
-import type {
-    NodeStateSlice,
-    PreparedNodeStructure,
-    PreparedStructureVDisk,
-    RawNodeStructure,
-} from './types';
-
-const selectNodeId = (state: NodeStateSlice) => state.node?.data?.SystemStateInfo?.[0].NodeId;
-
-const selectRawNodeStructure = (state: NodeStateSlice) => state.node?.nodeStructure;
-
-export const selectNodeStructure: Selector<NodeStateSlice, PreparedNodeStructure> = createSelector(
-    [selectNodeId, selectRawNodeStructure],
-    (nodeId, storageInfo) => {
-        const pools = storageInfo?.StoragePools;
-        const structure: RawNodeStructure = {};
-
-        pools?.forEach((pool) => {
-            const groups = pool.Groups;
-            groups?.forEach((group) => {
-                const vDisks = group.VDisks?.filter((el) => el.NodeId === nodeId);
-                vDisks?.forEach((vd) => {
-                    const vDiskId = stringifyVdiskId(vd.VDiskId);
-                    const pDiskId = vd.PDisk?.PDiskId;
-                    if (!structure[String(pDiskId)]) {
-                        structure[String(pDiskId)] = {vDisks: {}, ...vd.PDisk};
-                    }
-                    structure[String(pDiskId)].vDisks[vDiskId] = {
-                        ...vd,
-                        // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
-                        StoragePoolName: pool.Name,
-                    };
-                });
-            });
-        });
-
-        const structureWithVdisksArray = Object.keys(structure).reduce<PreparedNodeStructure>(
-            (preparedStructure, el) => {
-                const vDisks = structure[el].vDisks;
-                const vDisksArray = Object.keys(vDisks).reduce<PreparedStructureVDisk[]>(
-                    (acc, key, index) => {
-                        acc.push({...vDisks[key], id: key, order: index});
-                        return acc;
-                    },
-                    [],
-                );
-                preparedStructure[el] = {...structure[el], vDisks: vDisksArray};
-                return preparedStructure;
-            },
-            {},
-        );
-        return structureWithVdisksArray;
-    },
-);