ydb-embedded-ui 6.8.0 → 6.9.0

package/dist/store/reducers/healthcheckInfo/healthcheckInfo.js

@@ -0,0 +1,76 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { api } from '../api';
+export const healthcheckApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getHealthcheckInfo: builder.query({
+            queryFn: async ({ database, maxLevel }, { signal }) => {
+                try {
+                    const data = await window.api.getHealthcheckInfo({ database, maxLevel }, { signal });
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});
+const mapStatusToPriority = {
+    RED: 0,
+    ORANGE: 1,
+    YELLOW: 2,
+    BLUE: 3,
+    GREEN: 4,
+};
+const sortIssues = (data) => {
+    return data.sort((a, b) => {
+        const aPriority = mapStatusToPriority[a.status] || 0;
+        const bPriority = mapStatusToPriority[b.status] || 0;
+        return aPriority - bPriority;
+    });
+};
+const getReasonsForIssue = ({ issue, data }) => {
+    return sortIssues(data.filter((item) => issue.reason && issue.reason.indexOf(item.id) !== -1));
+};
+const getRoots = (data) => {
+    return sortIssues(data.filter((item) => {
+        return !data.find((issue) => issue.reason && issue.reason.indexOf(item.id) !== -1);
+    }));
+};
+const getInvertedConsequencesTree = ({ data, roots, }) => {
+    return roots
+        ? roots.map((issue) => {
+            const reasonsItems = getInvertedConsequencesTree({
+                roots: getReasonsForIssue({ issue, data }),
+                data,
+            });
+            return {
+                ...issue,
+                reasonsItems,
+            };
+        })
+        : [];
+};
+const getIssuesStatistics = (data) => {
+    const issuesMap = {};
+    for (const issue of data) {
+        if (!issuesMap[issue.status]) {
+            issuesMap[issue.status] = 0;
+        }
+        issuesMap[issue.status]++;
+    }
+    return Object.entries(issuesMap).sort(([aStatus], [bStatus]) => {
+        const bPriority = mapStatusToPriority[bStatus] || 0;
+        const aPriority = mapStatusToPriority[aStatus] || 0;
+        return aPriority - bPriority;
+    });
+};
+const createGetHealthcheckInfoSelector = createSelector((database) => database, (database) => healthcheckApi.endpoints.getHealthcheckInfo.select({ database }));
+const getIssuesLog = createSelector((state) => state, (_state, database) => createGetHealthcheckInfoSelector(database), (state, selectGetPost) => { var _a; return ((_a = selectGetPost(state).data) === null || _a === void 0 ? void 0 : _a.issue_log) || []; });
+export const selectIssuesTreesRoots = createSelector(getIssuesLog, (issues = []) => getRoots(issues));
+export const selectIssuesTrees = createSelector([getIssuesLog, selectIssuesTreesRoots], (data = [], roots = []) => {
+    return getInvertedConsequencesTree({ data, roots });
+});
+export const selectIssuesStatistics = createSelector(getIssuesLog, (issues = []) => getIssuesStatistics(issues));

package/dist/store/reducers/heatmap.d.ts

@@ -0,0 +1,14 @@
+import type { IHeatmapApiRequestParams, IHeatmapMetricValue, IHeatmapState, IHeatmapTabletData } from '../../types/store/heatmap';
+export declare const initialState: IHeatmapState;
+declare const _default: import("redux").Reducer<IHeatmapState>;
+export default _default;
+export declare const setHeatmapOptions: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<IHeatmapState>, "heatmap/setHeatmapOptions">;
+export declare const heatmapApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    getHeatmapTabletsInfo: import("@reduxjs/toolkit/query").QueryDefinition<IHeatmapApiRequestParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", {
+        tablets: IHeatmapTabletData[];
+        metrics: {
+            value: IHeatmapMetricValue;
+            content: IHeatmapMetricValue;
+        }[] | undefined;
+    } | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/store/reducers/heatmap.js

@@ -0,0 +1,81 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { api } from './api';
+export const initialState = {
+    currentMetric: undefined,
+    sort: false,
+    heatmap: false,
+};
+const slice = createSlice({
+    name: 'heatmap',
+    initialState,
+    reducers: {
+        setHeatmapOptions: (state, action) => {
+            return {
+                ...state,
+                ...action.payload,
+            };
+        },
+    },
+});
+export default slice.reducer;
+export const { setHeatmapOptions } = slice.actions;
+export const heatmapApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getHeatmapTabletsInfo: builder.query({
+            queryFn: async ({ nodes, path }, { signal, getState, dispatch }) => {
+                var _a;
+                try {
+                    const response = await Promise.all([
+                        window.api.getTabletsInfo({ nodes, path }, { signal }),
+                        window.api.getHeatmapData({ path }, { signal }),
+                    ]);
+                    const data = transformResponse(response);
+                    if ((_a = data.metrics) === null || _a === void 0 ? void 0 : _a.length) {
+                        const state = getState();
+                        const currentMetric = state.heatmap.currentMetric;
+                        if (!currentMetric ||
+                            !data.metrics.find((item) => item.value === currentMetric)) {
+                            dispatch(setHeatmapOptions({ currentMetric: data.metrics[0].value }));
+                        }
+                    }
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});
+function transformResponse([tabletsData, describe]) {
+    const { TabletStateInfo: tablets = [] } = tabletsData;
+    const TabletsMap = new Map();
+    const { PathDescription = {} } = describe !== null && describe !== void 0 ? 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 { tablets: preparedTablets, metrics: selectMetrics };
+}

package/dist/store/reducers/hotKeys/hotKeys.d.ts

@@ -0,0 +1,6 @@
+import type { HotKey } from '../../../types/api/hotkeys';
+export declare const hotKeysApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getHotKeys: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", HotKey[] | null, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/store/reducers/index.d.ts

@@ -0,0 +1,92 @@
+import singleClusterMode from './singleClusterMode';
+export declare const rootReducer: {
+    api: import("redux").Reducer<import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">, import("redux").UnknownAction>;
+    singleClusterMode: typeof singleClusterMode;
+    cluster: import("redux").Reducer<import("./cluster/types").ClusterState>;
+    tenant: import("redux").Reducer<import("./tenant/types").TenantState>;
+    tooltip: import("redux").Reducer<import("../../types/store/tooltip").ITooltipState, import("../../types/store/tooltip").ITooltipAction>;
+    tablets: import("redux").Reducer<import("../../types/store/tablets").TabletsState>;
+    schema: import("redux").Reducer<import("./schema/types").SchemaState, {
+        readonly type: "schema/SET_SHOW_PREVIEW";
+        readonly data: boolean;
+    }>;
+    tenants: import("redux").Reducer<import("./tenants/types").TenantsState>;
+    partitions: import("redux").Reducer<import("./partitions/types").PartitionsState>;
+    executeQuery: import("redux").Reducer<import("../../types/store/executeQuery").ExecuteQueryState, import("../../types/store/executeQuery").ExecuteQueryAction>;
+    heatmap: import("redux").Reducer<import("../../types/store/heatmap").IHeatmapState>;
+    settings: import("redux").Reducer<import("./settings/types").SettingsState>;
+    executeTopQueries: import("redux").Reducer<import("./executeTopQueries/types").TopQueriesFilters>;
+    shardsWorkload: import("redux").Reducer<import("./shardsWorkload/types").ShardsWorkloadFilters>;
+    authentication: import("redux").Reducer<import("./authentication/types").AuthenticationState, import("./authentication/types").AuthenticationAction>;
+    header: import("redux").Reducer<import("./header/types").HeaderState, {
+        readonly type: "header/SET_HEADER_BREADCRUMBS";
+        readonly page: import("./header/types").Page;
+        readonly options: {} | import("./header/types").TabletsBreadcrumbsOptions | import("./header/types").TenantBreadcrumbsOptions | import("./header/types").ClusterBreadcrumbsOptions | import("./header/types").TabletBreadcrumbsOptions | import("./header/types").NodeBreadcrumbsOptions;
+    }>;
+    saveQuery: import("redux").Reducer<string | null, {
+        readonly type: "SET_QUERY_NAME_TO_EDIT";
+        readonly data: string;
+    } | {
+        readonly type: "CLEAR_QUERY_NAME_TO_EDIT";
+    }>;
+    fullscreen: (state: boolean | undefined, action: ReturnType<typeof import("./fullscreen").enableFullscreen> | ReturnType<typeof import("./fullscreen").disableFullscreen>) => boolean;
+    clusters: import("redux").Reducer<import("./clusters/types").ClustersFilters>;
+};
+declare const combinedReducer: import("redux").Reducer<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("./cluster/types").ClusterState;
+    tenant: import("./tenant/types").TenantState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").TabletsState;
+    schema: import("./schema/types").SchemaState;
+    tenants: import("./tenants/types").TenantsState;
+    partitions: import("./partitions/types").PartitionsState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersFilters;
+}, import("redux").UnknownAction | import("../../types/store/tooltip").ITooltipAction | {
+    readonly type: "schema/SET_SHOW_PREVIEW";
+    readonly data: boolean;
+} | import("../../types/store/executeQuery").ExecuteQueryAction | import("./authentication/types").AuthenticationAction | {
+    readonly type: "header/SET_HEADER_BREADCRUMBS";
+    readonly page: import("./header/types").Page;
+    readonly options: {} | import("./header/types").TabletsBreadcrumbsOptions | import("./header/types").TenantBreadcrumbsOptions | import("./header/types").ClusterBreadcrumbsOptions | import("./header/types").TabletBreadcrumbsOptions | import("./header/types").NodeBreadcrumbsOptions;
+} | ({
+    readonly type: "SET_QUERY_NAME_TO_EDIT";
+    readonly data: string;
+} | {
+    readonly type: "CLEAR_QUERY_NAME_TO_EDIT";
+}) | {
+    readonly type: "ENABLE_FULLSCREEN_MODE";
+} | {
+    readonly type: "DISABLE_FULLSCREEN_MODE";
+} | import("redux").Action<string>, Partial<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api"> | undefined;
+    singleClusterMode: boolean | undefined;
+    cluster: import("./cluster/types").ClusterState | undefined;
+    tenant: import("./tenant/types").TenantState | undefined;
+    tooltip: never;
+    tablets: import("../../types/store/tablets").TabletsState | undefined;
+    schema: never;
+    tenants: import("./tenants/types").TenantsState | undefined;
+    partitions: import("./partitions/types").PartitionsState | undefined;
+    executeQuery: never;
+    heatmap: import("../../types/store/heatmap").IHeatmapState | undefined;
+    settings: import("./settings/types").SettingsState | undefined;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters | undefined;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters | undefined;
+    authentication: never;
+    header: never;
+    saveQuery: never;
+    fullscreen: never;
+    clusters: import("./clusters/types").ClustersFilters | undefined;
+}>>;
+export default combinedReducer;

package/dist/store/reducers/index.js

@@ -0,0 +1,45 @@
+import { combineReducers } from '@reduxjs/toolkit';
+import { api } from './api';
+import authentication from './authentication/authentication';
+import cluster from './cluster/cluster';
+import clusters from './clusters/clusters';
+import executeQuery from './executeQuery';
+import executeTopQueries from './executeTopQueries/executeTopQueries';
+import fullscreen from './fullscreen';
+import header from './header/header';
+import heatmap from './heatmap';
+import partitions from './partitions/partitions';
+import saveQuery from './saveQuery';
+import schema from './schema/schema';
+import settings from './settings/settings';
+import shardsWorkload from './shardsWorkload/shardsWorkload';
+import singleClusterMode from './singleClusterMode';
+import tablets from './tablets';
+import tenant from './tenant/tenant';
+import tenants from './tenants/tenants';
+import tooltip from './tooltip';
+export const rootReducer = {
+    [api.reducerPath]: api.reducer,
+    singleClusterMode,
+    cluster,
+    tenant,
+    tooltip,
+    tablets,
+    schema,
+    tenants,
+    partitions,
+    executeQuery,
+    heatmap,
+    settings,
+    executeTopQueries,
+    shardsWorkload,
+    authentication,
+    header,
+    saveQuery,
+    fullscreen,
+    clusters,
+};
+const combinedReducer = combineReducers({
+    ...rootReducer,
+});
+export default combinedReducer;

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

@@ -0,0 +1,3 @@
+export declare const networkApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getNetworkInfo: import("@reduxjs/toolkit/query").QueryDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/netInfo").TNetInfo | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -0,0 +1,8 @@
+export declare const nodeApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getNodeInfo: import("@reduxjs/toolkit/query").QueryDefinition<{
+        nodeId: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PreparedNode | undefined, "api">;
+    getNodeStructure: import("@reduxjs/toolkit/query").QueryDefinition<{
+        nodeId: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/api/storage").TStorageInfo | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -0,0 +1,42 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { stringifyVdiskId } from '../../../utils/dataFormatters/dataFormatters';
+import { preparePDiskData } from '../../../utils/disks/prepareDisks';
+import { nodeApi } from './node';
+const getNodeStructureSelector = createSelector((nodeId) => nodeId, (nodeId) => nodeApi.endpoints.getNodeStructure.select({ nodeId }));
+const selectGetNodeStructureData = createSelector((state) => state, (_state, nodeId) => getNodeStructureSelector(nodeId), (state, selectGetNodeStructure) => selectGetNodeStructure(state).data);
+export const selectNodeStructure = createSelector((_state, nodeId) => Number(nodeId), (state, nodeId) => selectGetNodeStructureData(state, nodeId), (nodeId, storageInfo) => {
+    const pools = storageInfo === null || storageInfo === void 0 ? void 0 : storageInfo.StoragePools;
+    const structure = {};
+    pools === null || pools === void 0 ? void 0 : pools.forEach((pool) => {
+        const groups = pool.Groups;
+        groups === null || groups === void 0 ? void 0 : groups.forEach((group) => {
+            var _a;
+            const vDisks = (_a = group.VDisks) === null || _a === void 0 ? void 0 : _a.filter((el) => el.NodeId === nodeId);
+            vDisks === null || vDisks === void 0 ? void 0 : vDisks.forEach((vd) => {
+                const vDiskId = stringifyVdiskId(vd.VDiskId);
+                const preparedPDisk = preparePDiskData(vd.PDisk);
+                const pDiskId = preparedPDisk.PDiskId;
+                if (!structure[String(pDiskId)]) {
+                    structure[String(pDiskId)] = { vDisks: {}, ...preparedPDisk };
+                }
+                structure[String(pDiskId)].vDisks[vDiskId] = {
+                    ...vd,
+                    PDiskId: pDiskId,
+                    NodeId: nodeId,
+                    // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
+                    StoragePoolName: pool.Name,
+                };
+            });
+        });
+    });
+    const structureWithVDisksArray = Object.keys(structure).reduce((preparedStructure, el) => {
+        const vDisks = structure[el].vDisks;
+        const vDisksArray = Object.keys(vDisks).reduce((acc, key, index) => {
+            acc.push({ ...vDisks[key], id: key, order: index });
+            return acc;
+        }, []);
+        preparedStructure[el] = { ...structure[el], vDisks: vDisksArray };
+        return preparedStructure;
+    }, {});
+    return structureWithVDisksArray;
+});

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

@@ -0,0 +1,5 @@
+import type { ComputeApiRequestParams, NodesApiRequestParams } from './types';
+export declare const nodesApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getNodes: import("@reduxjs/toolkit/query").QueryDefinition<NodesApiRequestParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").NodesHandledResponse | undefined, "api">;
+    getComputeNodes: import("@reduxjs/toolkit/query").QueryDefinition<ComputeApiRequestParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").NodesHandledResponse | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/store/reducers/nodes/nodes.js

@@ -0,0 +1,39 @@
+import { EVersion } from '../../../types/api/compute';
+import { api } from '../api';
+import { prepareComputeNodesData, prepareNodesData } from './utils';
+export const nodesApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getNodes: builder.query({
+            queryFn: async (params, { signal }) => {
+                try {
+                    const data = await window.api.getNodes({
+                        type: 'any',
+                        storage: false,
+                        ...params,
+                    }, { signal });
+                    return { data: prepareNodesData(data) };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+        getComputeNodes: builder.query({
+            queryFn: async (params, { signal }) => {
+                try {
+                    const data = await window.api.getCompute({
+                        version: EVersion.v2,
+                        ...params,
+                    }, { signal });
+                    return { data: prepareComputeNodesData(data) };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -0,0 +1,11 @@
+import { NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { ProblemFilterValue } from '../settings/types';
+import type { NodesPreparedEntity } from './types';
+export declare const filterNodesByUptime: <T extends {
+    StartTime?: string;
+}>(nodesList: T[] | undefined, nodesUptimeFilter: NodesUptimeFilterValues) => T[];
+export declare function filterNodes(nodesList: NodesPreparedEntity[] | undefined, { uptimeFilter, searchValue, problemFilter, }: {
+    uptimeFilter: NodesUptimeFilterValues;
+    searchValue: string;
+    problemFilter: ProblemFilterValue;
+}): NodesPreparedEntity[];

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

@@ -0,0 +1,60 @@
+import type { OrderType } from '@gravity-ui/react-data-table';
+import type { EVersion, TTabletStateInfo as TComputeTabletStateInfo } from '../../../types/api/compute';
+import type { EFlag } from '../../../types/api/enums';
+import type { TEndpoint, TPoolStats } from '../../../types/api/nodes';
+import type { TTabletStateInfo as TFullTabletStateInfo } from '../../../types/api/tablet';
+import type { NodesSortValue } from '../../../utils/nodes';
+import type { VisibleEntities } from '../storage/types';
+export interface NodesPreparedEntity {
+    NodeId: number;
+    Host?: string;
+    SystemState?: EFlag;
+    DC?: 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[];
+    LoadAveragePercents?: number[];
+    Tablets?: TFullTabletStateInfo[] | TComputeTabletStateInfo[];
+    Endpoints?: TEndpoint[];
+    TotalSessions?: number;
+}
+export type NodeType = 'static' | 'dynamic' | 'any';
+export interface NodesSortParams {
+    sortOrder: OrderType | undefined;
+    sortValue: NodesSortValue | undefined;
+}
+export interface NodesGeneralRequestParams extends Partial<NodesSortParams> {
+    filter?: string;
+    uptime?: number;
+    problems_only?: boolean;
+    offset?: number;
+    limit?: number;
+}
+export interface NodesApiRequestParams extends NodesGeneralRequestParams {
+    node_id?: number | string;
+    path?: string;
+    tenant?: string;
+    type?: NodeType;
+    visibleEntities?: VisibleEntities;
+    storage?: boolean;
+    tablets?: boolean;
+}
+export interface ComputeApiRequestParams extends NodesGeneralRequestParams {
+    path: string;
+    version?: EVersion;
+}
+export interface NodesHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+    TotalNodes: number;
+    FoundNodes?: number;
+}

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

@@ -0,0 +1,64 @@
+import { calcUptime } from '../../../utils/dataFormatters/dataFormatters';
+import { generateEvaluator } from '../../../utils/generateEvaluator';
+import { calculateLoadAveragePercents, prepareNodeSystemState } from '../../../utils/nodes';
+const prepareComputeNode = (node, tenantName) => {
+    var _a;
+    return {
+        ...node,
+        // v2 response has tenant name, v1 - doesn't
+        TenantName: (_a = node.Tenant) !== null && _a !== void 0 ? _a : tenantName,
+        SystemState: node === null || node === void 0 ? void 0 : node.Overall,
+        Uptime: calcUptime(node === null || node === void 0 ? void 0 : node.StartTime),
+        LoadAveragePercents: calculateLoadAveragePercents(node),
+        DC: node.DataCenter,
+    };
+};
+export const prepareComputeNodes = (nodes, tenants) => {
+    var _a;
+    const preparedNodes = [];
+    // 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) {
+            (_a = tenant.Nodes) === null || _a === void 0 ? void 0 : _a.forEach((node) => {
+                preparedNodes.push(prepareComputeNode(node, tenant.Name));
+            });
+        }
+    }
+    return preparedNodes;
+};
+export const prepareComputeNodesData = (data) => {
+    const preparedNodes = prepareComputeNodes(data.Nodes, data.Tenants);
+    return {
+        Nodes: preparedNodes,
+        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
+        FoundNodes: Number(data.FoundNodes),
+    };
+};
+export const prepareNodesData = (data) => {
+    const rawNodes = data.Nodes || [];
+    const preparedNodes = rawNodes.map((node) => {
+        var _a, _b, _c, _d;
+        // 0 limit means that limit is not set, so it should be undefined
+        const sharedCacheLimit = Number((_a = node.SystemState.SharedCacheStats) === null || _a === void 0 ? void 0 : _a.LimitBytes) || undefined;
+        return {
+            ...prepareNodeSystemState(node.SystemState),
+            Tablets: node.Tablets,
+            NodeId: node.NodeId,
+            TenantName: (_c = (_b = node.SystemState) === null || _b === void 0 ? void 0 : _b.Tenants) === null || _c === void 0 ? void 0 : _c[0],
+            SharedCacheUsed: (_d = node.SystemState.SharedCacheStats) === null || _d === void 0 ? void 0 : _d.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.d.ts

@@ -0,0 +1,45 @@
+import type { RootState } from '../defaultStore';
+export declare const nodesListApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    getNodesList: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/nodesList").TEvNodesInfo | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+export declare const selectNodesMap: ((state: {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("./cluster/types").ClusterState;
+    tenant: import("./tenant/types").TenantState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: import("../../types/store/tablets").TabletsState;
+    schema: import("./schema/types").SchemaState;
+    tenants: import("./tenants/types").TenantsState;
+    partitions: import("./partitions/types").PartitionsState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersFilters;
+}) => import("../../types/store/nodesList").NodesMap | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../types/api/nodesList").TEvNodesInfo | undefined) => import("../../types/store/nodesList").NodesMap | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../types/api/nodesList").TEvNodesInfo | undefined) => import("../../types/store/nodesList").NodesMap | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../types/store/nodesList").NodesMap | undefined;
+    dependencies: [(state: RootState) => import("../../types/api/nodesList").TEvNodesInfo | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/store/reducers/olapStats.d.ts

@@ -0,0 +1,5 @@
+export declare const olapApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    getOlapStats: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path?: string;
+    } | undefined, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/store/query").IQueryResult | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/store/reducers/overview/overview.d.ts

@@ -0,0 +1,6 @@
+export declare const overviewApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getOverview: import("@reduxjs/toolkit/query").QueryDefinition<string[], import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", {
+        data: import("../../../utils/typecheckers").Nullable<import("../../../types/api/schema").TEvDescribeSchemeResult>;
+        additionalData: import("../../../utils/typecheckers").Nullable<import("../../../types/api/schema").TEvDescribeSchemeResult>[];
+    } | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

package/dist/store/reducers/partitions/partitions.d.ts

@@ -0,0 +1,10 @@
+import type { PartitionsState } from './types';
+export declare const setSelectedConsumer: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "partitions/setSelectedConsumer">;
+declare const _default: import("redux").Reducer<PartitionsState>;
+export default _default;
+export declare const partitionsApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getPartitions: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path: string;
+        consumerName?: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PreparedPartitionData[] | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;