ydb-embedded-ui 5.4.0 → 6.0.0

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

@@ -1,4 +1,3 @@
-import { createSelector } from '@reduxjs/toolkit';
 import { ASCENDING, DESCENDING } from '@gravity-ui/react-data-table/build/esm/lib/constants';
 import { NODES_SORT_VALUES } from '../../../utils/nodes';
 import { STORAGE_SORT_VALUES, getUsage } from '../../../utils/storage';
@@ -37,17 +36,23 @@ const filterGroupsByUsage = (entities, usage) => {
         return usage.some((val) => Number(val) <= entityUsage && entityUsage < Number(val) + 5);
     });
 };
+export function filterNodes(storageNodes, textFilter, uptimeFilter) {
+    let result = storageNodes || [];
+    result = filterNodesByText(result, textFilter);
+    result = filterNodesByUptime(result, uptimeFilter);
+    return result;
+}
+export function filterGroups(storageGroups, textFilter, usageFilter) {
+    let result = storageGroups || [];
+    result = filterGroupsByText(result, textFilter);
+    result = filterGroupsByUsage(result, usageFilter);
+    return result;
+}
 // ==== Simple selectors ====
-export const selectEntitiesCount = (state) => ({
-    total: state.storage.total,
-    found: state.storage.found,
-});
-export const selectStorageGroups = (state) => state.storage.groups;
-export const selectStorageNodes = (state) => state.storage.nodes;
 export const selectStorageFilter = (state) => state.storage.filter;
 export const selectUsageFilter = (state) => state.storage.usageFilter;
 export const selectVisibleEntities = (state) => state.storage.visible;
-export const selectNodesUptimeFilter = (state) => state.storage.nodesUptimeFilter;
+export const selectNodesUptimeFilter = (state) => state.storage.uptimeFilter;
 export const selectStorageType = (state) => state.storage.type;
 // ==== Sort params selectors ====
 export const selectNodesSortParams = (state) => {
@@ -76,7 +81,7 @@ export const selectGroupsSortParams = (state) => {
     };
 };
 // ==== Complex selectors ====
-export const selectUsageFilterOptions = createSelector(selectStorageGroups, (groups) => {
+export function getUsageFilterOptions(groups) {
     const items = {};
     groups === null || groups === void 0 ? void 0 : groups.forEach((group) => {
         // Get groups usage with step 5
@@ -89,17 +94,4 @@ export const selectUsageFilterOptions = createSelector(selectStorageGroups, (gro
     return Object.entries(items)
         .map(([threshold, count]) => ({ threshold: Number(threshold), count }))
         .sort((a, b) => b.threshold - a.threshold);
-});
-// ==== Complex selectors with filters ====
-export const selectFilteredNodes = createSelector([selectStorageNodes, selectStorageFilter, selectNodesUptimeFilter], (storageNodes, textFilter, uptimeFilter) => {
-    let result = storageNodes || [];
-    result = filterNodesByText(result, textFilter);
-    result = filterNodesByUptime(result, uptimeFilter);
-    return result;
-});
-export const selectFilteredGroups = createSelector([selectStorageGroups, selectStorageFilter, selectUsageFilter], (storageGroups, textFilter, usageFilter) => {
-    let result = storageGroups || [];
-    result = filterGroupsByText(result, textFilter);
-    result = filterGroupsByUsage(result, usageFilter);
-    return result;
-});
+}

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

@@ -1,209 +1,10 @@
-import type { Reducer } from '@reduxjs/toolkit';
 import { NodesUptimeFilterValues } from '../../../utils/nodes';
 import type { NodesApiRequestParams, NodesSortParams } from '../nodes/types';
-import type { StorageAction, StorageApiRequestParams, StorageSortParams, StorageState, StorageType, VisibleEntities } from './types';
-export declare const FETCH_STORAGE: {
-    readonly REQUEST: "storage/FETCH_STORAGE_REQUEST";
-    readonly SUCCESS: "storage/FETCH_STORAGE_SUCCESS";
-    readonly FAILURE: "storage/FETCH_STORAGE_FAILURE";
-};
-declare const storage: Reducer<StorageState, StorageAction>;
-export declare const getStorageNodesInfo: ({ tenant, visibleEntities, ...params }: Omit<NodesApiRequestParams, 'type'>) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
-    singleClusterMode: boolean;
-    nodes: import("../nodes/types").NodesState;
-    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
-    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
-    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
-    cluster: import("../cluster/types").ClusterState;
-    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
-    tenant: import("../tenant/types").TenantState;
-    storage: StorageState;
-    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
-    node: import("../node/types").NodeState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").ITabletsState;
-    schema: import("../schema/types").SchemaState;
-    overview: import("../overview/types").OverviewState;
-    olapStats: import("../../../types/store/olapStats").OlapStatsState;
-    host: import("../../../types/store/host").IHostState;
-    network: import("../network/types").NetworkState;
-    tenants: import("../tenants/types").TenantsState;
-    tablet: import("../../../types/store/tablet").ITabletState;
-    topic: import("../../../types/store/topic").ITopicState;
-    partitions: import("../partitions/types").PartitionsState;
-    pDisk: import("../pdisk/types").PDiskState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
-    tabletsFilters: {
-        loading: boolean;
-        requestTime: number;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        tabletsData: any;
-        nodes: any;
-        loading: boolean;
-        wasLoaded: boolean;
-        timeoutForRequest: number;
-        error: undefined;
-        data: undefined;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        error: any;
-        loading: boolean;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        stateFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        typeFilter: never[];
-    } | {
-        typeFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        stateFilter: never[];
-    };
-    heatmap: import("../../../types/store/heatmap").IHeatmapState;
-    settings: import("../settings/types").SettingsState;
-    preview: any;
-    nodesList: import("../../../types/store/nodesList").NodesListState;
-    describe: import("../../../types/store/describe").IDescribeState;
-    schemaAcl: import("../schemaAcl/types").SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
-    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
-    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
-    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
-    shardsWorkload: import("../shardsWorkload/types").IShardsWorkloadState;
-    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
-    hotKeys: import("../hotKeys/types").HotKeysState;
-    authentication: import("../authentication/types").AuthenticationState;
-    header: import("../header/types").HeaderState;
-    saveQuery: string | null;
-    fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersState;
-}) => Promise<import("./types").PreparedStorageResponse | undefined>;
-export declare const getStorageGroupsInfo: ({ tenant, visibleEntities, nodeId, version, ...params }: StorageApiRequestParams) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
-    singleClusterMode: boolean;
-    nodes: import("../nodes/types").NodesState;
-    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
-    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
-    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
-    cluster: import("../cluster/types").ClusterState;
-    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
-    tenant: import("../tenant/types").TenantState;
-    storage: StorageState;
-    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
-    node: import("../node/types").NodeState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").ITabletsState;
-    schema: import("../schema/types").SchemaState;
-    overview: import("../overview/types").OverviewState;
-    olapStats: import("../../../types/store/olapStats").OlapStatsState;
-    host: import("../../../types/store/host").IHostState;
-    network: import("../network/types").NetworkState;
-    tenants: import("../tenants/types").TenantsState;
-    tablet: import("../../../types/store/tablet").ITabletState;
-    topic: import("../../../types/store/topic").ITopicState;
-    partitions: import("../partitions/types").PartitionsState;
-    pDisk: import("../pdisk/types").PDiskState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
-    tabletsFilters: {
-        loading: boolean;
-        requestTime: number;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        tabletsData: any;
-        nodes: any;
-        loading: boolean;
-        wasLoaded: boolean;
-        timeoutForRequest: number;
-        error: undefined;
-        data: undefined;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        error: any;
-        loading: boolean;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        stateFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        typeFilter: never[];
-    } | {
-        typeFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        stateFilter: never[];
-    };
-    heatmap: import("../../../types/store/heatmap").IHeatmapState;
-    settings: import("../settings/types").SettingsState;
-    preview: any;
-    nodesList: import("../../../types/store/nodesList").NodesListState;
-    describe: import("../../../types/store/describe").IDescribeState;
-    schemaAcl: import("../schemaAcl/types").SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
-    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
-    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
-    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
-    shardsWorkload: import("../shardsWorkload/types").IShardsWorkloadState;
-    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
-    hotKeys: import("../hotKeys/types").HotKeysState;
-    authentication: import("../authentication/types").AuthenticationState;
-    header: import("../header/types").HeaderState;
-    saveQuery: string | null;
-    fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersState;
-}) => Promise<import("./types").PreparedStorageResponse | undefined>;
-export declare function setInitialState(): {
-    readonly type: "storage/SET_INITIAL";
-};
-export declare function setStorageType(value: StorageType): {
-    readonly type: "storage/SET_STORAGE_TYPE";
-    readonly data: StorageType;
-};
-export declare function setStorageTextFilter(value: string): {
-    readonly type: "storage/SET_FILTER";
-    readonly data: string;
-};
-export declare function setUsageFilter(value: string[]): {
-    readonly type: "storage/SET_USAGE_FILTER";
-    readonly data: string[];
-};
-export declare function setVisibleEntities(value: VisibleEntities): {
-    readonly type: "storage/SET_VISIBLE_GROUPS";
-    readonly data: VisibleEntities;
-};
-export declare function setNodesUptimeFilter(value: NodesUptimeFilterValues): {
-    readonly type: "storage/SET_NODES_UPTIME_FILTER";
-    readonly data: NodesUptimeFilterValues;
-};
-export declare const setDataWasNotLoaded: () => {
-    readonly type: "storage/SET_DATA_WAS_NOT_LOADED";
-};
-export declare const setNodesSortParams: (sortParams: NodesSortParams) => {
-    readonly type: "storage/SET_NODES_SORT_PARAMS";
-    readonly data: NodesSortParams;
-};
-export declare const setGroupsSortParams: (sortParams: StorageSortParams) => {
-    readonly type: "storage/SET_GROUPS_SORT_PARAMS";
-    readonly data: StorageSortParams;
-};
-export default storage;
+import type { StorageApiRequestParams, StorageSortParams, StorageState, StorageType, VisibleEntities } from './types';
+declare const _default: import("redux").Reducer<StorageState>;
+export default _default;
+export declare const setInitialState: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"storage/setInitialState">, setStorageTextFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "storage/setStorageTextFilter">, setUsageFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "storage/setUsageFilter">, setVisibleEntities: import("@reduxjs/toolkit").ActionCreatorWithPayload<VisibleEntities, "storage/setVisibleEntities">, setStorageType: import("@reduxjs/toolkit").ActionCreatorWithPayload<StorageType, "storage/setStorageType">, setUptimeFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<NodesUptimeFilterValues, "storage/setUptimeFilter">, setNodesSortParams: import("@reduxjs/toolkit").ActionCreatorWithPayload<NodesSortParams, "storage/setNodesSortParams">, setGroupsSortParams: import("@reduxjs/toolkit").ActionCreatorWithPayload<StorageSortParams, "storage/setGroupsSortParams">;
+export declare const storageApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getStorageNodesInfo: import("@reduxjs/toolkit/query").QueryDefinition<Omit<NodesApiRequestParams, "type">, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PreparedStorageResponse | undefined, "api">;
+    getStorageGroupsInfo: import("@reduxjs/toolkit/query").QueryDefinition<StorageApiRequestParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PreparedStorageResponse | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/store/reducers/storage/storage.js

@@ -1,141 +1,76 @@
-import { __rest } from "tslib";
+import { createSlice } from '@reduxjs/toolkit';
 import { EVersion } from '../../../types/api/storage';
 import { NodesUptimeFilterValues } from '../../../utils/nodes';
-import { createRequestActionTypes, createApiRequest } from '../../utils';
-import { VISIBLE_ENTITIES, STORAGE_TYPES } from './constants';
+import { api } from '../api';
+import { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
 import { prepareStorageGroupsResponse, prepareStorageNodesResponse } from './utils';
-export const FETCH_STORAGE = createRequestActionTypes('storage', 'FETCH_STORAGE');
-const SET_INITIAL = 'storage/SET_INITIAL';
-const SET_FILTER = 'storage/SET_FILTER';
-const SET_USAGE_FILTER = 'storage/SET_USAGE_FILTER';
-const SET_VISIBLE_GROUPS = 'storage/SET_VISIBLE_GROUPS';
-const SET_STORAGE_TYPE = 'storage/SET_STORAGE_TYPE';
-const SET_NODES_UPTIME_FILTER = 'storage/SET_NODES_UPTIME_FILTER';
-const SET_DATA_WAS_NOT_LOADED = 'storage/SET_DATA_WAS_NOT_LOADED';
-const SET_NODES_SORT_PARAMS = 'storage/SET_NODES_SORT_PARAMS';
-const SET_GROUPS_SORT_PARAMS = 'storage/SET_GROUPS_SORT_PARAMS';
 const initialState = {
-    loading: true,
-    wasLoaded: false,
     filter: '',
     usageFilter: [],
     visible: VISIBLE_ENTITIES.all,
-    nodesUptimeFilter: NodesUptimeFilterValues.All,
+    uptimeFilter: NodesUptimeFilterValues.All,
     type: STORAGE_TYPES.groups,
 };
-const storage = (state = initialState, action) => {
-    var _a;
-    switch (action.type) {
-        case FETCH_STORAGE.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_STORAGE.SUCCESS: {
-            return Object.assign(Object.assign({}, state), { nodes: action.data.nodes, groups: action.data.groups, total: action.data.total, found: action.data.found, loading: false, wasLoaded: true, error: undefined });
-        }
-        case FETCH_STORAGE.FAILURE: {
-            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
-                return state;
-            }
-            return Object.assign(Object.assign({}, state), { error: action.error, loading: false, wasLoaded: true });
-        }
-        case SET_INITIAL: {
-            return Object.assign({}, initialState);
-        }
-        case SET_FILTER: {
-            return Object.assign(Object.assign({}, state), { filter: action.data });
-        }
-        case SET_USAGE_FILTER: {
-            return Object.assign(Object.assign({}, state), { usageFilter: action.data });
-        }
-        case SET_VISIBLE_GROUPS: {
-            return Object.assign(Object.assign({}, state), { visible: action.data, usageFilter: [], wasLoaded: false, error: undefined });
-        }
-        case SET_NODES_UPTIME_FILTER: {
-            return Object.assign(Object.assign({}, state), { nodesUptimeFilter: action.data });
-        }
-        case SET_STORAGE_TYPE: {
-            return Object.assign(Object.assign({}, state), { type: action.data, filter: '', usageFilter: [], wasLoaded: false, error: undefined });
-        }
-        case SET_DATA_WAS_NOT_LOADED: {
-            return Object.assign(Object.assign({}, state), { wasLoaded: false });
-        }
-        case SET_NODES_SORT_PARAMS: {
-            return Object.assign(Object.assign({}, state), { nodesSortValue: action.data.sortValue, nodesSortOrder: action.data.sortOrder });
-        }
-        case SET_GROUPS_SORT_PARAMS: {
-            return Object.assign(Object.assign({}, state), { groupsSortValue: action.data.sortValue, groupsSortOrder: action.data.sortOrder });
-        }
-        default:
-            return state;
-    }
-};
-const concurrentId = 'getStorageInfo';
-export const getStorageNodesInfo = (_a) => {
-    var { tenant, visibleEntities } = _a, params = __rest(_a, ["tenant", "visibleEntities"]);
-    return createApiRequest({
-        request: window.api.getNodes(Object.assign({ tenant, visibleEntities, storage: true, type: 'static' }, params), { concurrentId }),
-        actions: FETCH_STORAGE,
-        dataHandler: prepareStorageNodesResponse,
-    });
-};
-export const getStorageGroupsInfo = (_a) => {
-    var { tenant, visibleEntities, nodeId, version = EVersion.v1 } = _a, params = __rest(_a, ["tenant", "visibleEntities", "nodeId", "version"]);
-    return createApiRequest({
-        request: window.api.getStorageInfo(Object.assign({ tenant, visibleEntities, nodeId, version }, params), { concurrentId }),
-        actions: FETCH_STORAGE,
-        dataHandler: prepareStorageGroupsResponse,
-    });
-};
-export function setInitialState() {
-    return {
-        type: SET_INITIAL,
-    };
-}
-export function setStorageType(value) {
-    return {
-        type: SET_STORAGE_TYPE,
-        data: value,
-    };
-}
-export function setStorageTextFilter(value) {
-    return {
-        type: SET_FILTER,
-        data: value,
-    };
-}
-export function setUsageFilter(value) {
-    return {
-        type: SET_USAGE_FILTER,
-        data: value,
-    };
-}
-export function setVisibleEntities(value) {
-    return {
-        type: SET_VISIBLE_GROUPS,
-        data: value,
-    };
-}
-export function setNodesUptimeFilter(value) {
-    return {
-        type: SET_NODES_UPTIME_FILTER,
-        data: value,
-    };
-}
-export const setDataWasNotLoaded = () => {
-    return {
-        type: SET_DATA_WAS_NOT_LOADED,
-    };
-};
-export const setNodesSortParams = (sortParams) => {
-    return {
-        type: SET_NODES_SORT_PARAMS,
-        data: sortParams,
-    };
-};
-export const setGroupsSortParams = (sortParams) => {
-    return {
-        type: SET_GROUPS_SORT_PARAMS,
-        data: sortParams,
-    };
-};
-export default storage;
+const slice = createSlice({
+    name: 'storage',
+    initialState,
+    reducers: {
+        setUptimeFilter: (state, action) => {
+            state.uptimeFilter = action.payload;
+        },
+        setStorageType: (state, action) => {
+            state.type = action.payload;
+        },
+        setStorageTextFilter: (state, action) => {
+            state.filter = action.payload;
+        },
+        setUsageFilter: (state, action) => {
+            state.usageFilter = action.payload;
+        },
+        setVisibleEntities: (state, action) => {
+            state.visible = action.payload;
+        },
+        setNodesSortParams: (state, action) => {
+            state.nodesSortValue = action.payload.sortValue;
+            state.nodesSortOrder = action.payload.sortOrder;
+        },
+        setGroupsSortParams: (state, action) => {
+            state.groupsSortValue = action.payload.sortValue;
+            state.groupsSortOrder = action.payload.sortOrder;
+        },
+        setInitialState: () => {
+            return initialState;
+        },
+    },
+});
+export default slice.reducer;
+export const { setInitialState, setStorageTextFilter, setUsageFilter, setVisibleEntities, setStorageType, setUptimeFilter, setNodesSortParams, setGroupsSortParams, } = slice.actions;
+export const storageApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getStorageNodesInfo: builder.query({
+            queryFn: async (params, { signal }) => {
+                try {
+                    const result = await window.api.getNodes(Object.assign({ storage: true, type: 'static' }, params), { signal });
+                    return { data: prepareStorageNodesResponse(result) };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+        getStorageGroupsInfo: builder.query({
+            queryFn: async (params, { signal }) => {
+                try {
+                    const result = await window.api.getStorageInfo(Object.assign({ version: EVersion.v1 }, params), { signal });
+                    return { data: prepareStorageGroupsResponse(result) };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -1,14 +1,11 @@
 import type { OrderType } from '@gravity-ui/react-data-table';
-import type { IResponseError } from '../../../types/api/error';
 import type { TSystemStateInfo } from '../../../types/api/nodes';
 import type { EVersion, TStorageGroupInfo } from '../../../types/api/storage';
-import type { PreparedPDisk, PreparedVDisk } from '../../../utils/disks/types';
 import type { ValueOf } from '../../../types/common';
+import type { PreparedPDisk, PreparedVDisk } from '../../../utils/disks/types';
 import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
 import type { StorageSortValue } from '../../../utils/storage';
-import type { ApiRequestAction } from '../../utils';
-import { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
-import { FETCH_STORAGE, setDataWasNotLoaded, setGroupsSortParams, setInitialState, setNodesSortParams, setNodesUptimeFilter, setStorageTextFilter, setStorageType, setUsageFilter, setVisibleEntities } from './storage';
+import type { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
 export type VisibleEntities = ValueOf<typeof VISIBLE_ENTITIES>;
 export type StorageType = ValueOf<typeof STORAGE_TYPES>;
 export interface PreparedStorageNode extends TSystemStateInfo {
@@ -28,7 +25,7 @@ export interface PreparedStorageGroup extends TStorageGroupInfo {
     Used: number;
     Limit: number;
     Degraded: number;
-    Kind?: string;
+    MediaType?: string;
     UsedSpaceFlag: number;
     VDisks?: PreparedVDisk[];
 }
@@ -48,26 +45,21 @@ export interface StorageSortAndFilterParams extends StorageSortParams {
 export interface StorageApiRequestParams extends StorageSortAndFilterParams {
     tenant?: string;
     nodeId?: string | number;
+    poolName?: string;
+    groupId?: string | number;
     visibleEntities?: VisibleEntities;
     version?: EVersion;
 }
 export interface StorageState {
-    loading: boolean;
-    wasLoaded: boolean;
     filter: string;
     usageFilter: string[];
     visible: VisibleEntities;
-    nodesUptimeFilter: NodesUptimeFilterValues;
+    uptimeFilter: NodesUptimeFilterValues;
     groupsSortValue?: StorageSortValue;
     groupsSortOrder?: OrderType;
     nodesSortValue?: NodesSortValue;
     nodesSortOrder?: OrderType;
     type: StorageType;
-    nodes?: PreparedStorageNode[];
-    groups?: PreparedStorageGroup[];
-    found?: number;
-    total?: number;
-    error?: IResponseError;
 }
 export interface PreparedStorageResponse {
     nodes?: PreparedStorageNode[];
@@ -75,9 +67,6 @@ export interface PreparedStorageResponse {
     found: number | undefined;
     total: number | undefined;
 }
-type GetStorageInfoApiRequestAction = ApiRequestAction<typeof FETCH_STORAGE, PreparedStorageResponse, IResponseError>;
-export type StorageAction = GetStorageInfoApiRequestAction | ReturnType<typeof setInitialState> | ReturnType<typeof setStorageType> | ReturnType<typeof setStorageTextFilter> | ReturnType<typeof setUsageFilter> | ReturnType<typeof setVisibleEntities> | ReturnType<typeof setNodesUptimeFilter> | ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setNodesSortParams> | ReturnType<typeof setGroupsSortParams>;
 export interface StorageStateSlice {
     storage: StorageState;
 }
-export {};

package/dist/store/reducers/storage/utils.d.ts

@@ -1,7 +1,7 @@
 import type { TNodesInfo } from '../../../types/api/nodes';
 import type { TStorageGroupInfo, TStorageGroupInfoV2, TStorageInfo, TStoragePoolInfo } from '../../../types/api/storage';
 import type { PreparedStorageGroup, PreparedStorageResponse } from './types';
-export declare const prepareStorageGroupData: (group: TStorageGroupInfo, poolName?: string) => PreparedStorageGroup;
+export declare const prepareStorageGroupData: (group: TStorageGroupInfo, pool: TStoragePoolInfo) => PreparedStorageGroup;
 export declare const prepareStorageGroupDataV2: (group: TStorageGroupInfoV2) => PreparedStorageGroup;
 export declare const prepareStorageGroups: (StorageGroups?: TStorageGroupInfoV2[], StoragePools?: TStoragePoolInfo[]) => PreparedStorageGroup[];
 export declare const prepareStorageNodesResponse: (data: TNodesInfo) => PreparedStorageResponse;

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

@@ -1,9 +1,9 @@
-import { EVDiskState } from '../../../types/api/vdisk';
-import { TPDiskState } from '../../../types/api/pdisk';
 import { EFlag } from '../../../types/api/enums';
+import { TPDiskState } from '../../../types/api/pdisk';
+import { EVDiskState } from '../../../types/api/vdisk';
 import { preparePDiskData, prepareVDiskData } from '../../../utils/disks/prepareDisks';
-import { getUsage } from '../../../utils/storage';
 import { prepareNodeSystemState } from '../../../utils/nodes';
+import { getUsage } from '../../../utils/storage';
 // ==== Constants  ====
 // Do not count Grey and Blue statuses in used space severity calculations
 const FLAGS_POINTS = {
@@ -21,7 +21,7 @@ const prepareVDisk = (vDisk, poolName) => {
     // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
     return Object.assign(Object.assign({}, preparedVDisk), { StoragePoolName: poolName, Donors: (_a = preparedVDisk === null || preparedVDisk === void 0 ? void 0 : preparedVDisk.Donors) === null || _a === void 0 ? void 0 : _a.map((donor) => (Object.assign(Object.assign({}, donor), { StoragePoolName: poolName }))) });
 };
-export const prepareStorageGroupData = (group, poolName) => {
+export const prepareStorageGroupData = (group, pool) => {
     var _a;
     let missing = 0;
     let usedSpaceFlag = 0;
@@ -29,7 +29,8 @@ export const prepareStorageGroupData = (group, poolName) => {
     let limitSizeBytes = 0;
     let readSpeedBytesPerSec = 0;
     let writeSpeedBytesPerSec = 0;
-    let mediaType = '';
+    let mediaType;
+    const { Name: poolName, MediaType: poolMediaType } = pool;
     if (group.VDisks) {
         for (const vDisk of group.VDisks) {
             const { Replicated, VDiskState, AvailableSize, AllocatedSize, PDisk, DiskSpace, ReadThroughput, WriteThroughput, } = vDisk;
@@ -46,16 +47,15 @@ export const prepareStorageGroupData = (group, poolName) => {
             limitSizeBytes += available + allocated;
             readSpeedBytesPerSec += Number(ReadThroughput) || 0;
             writeSpeedBytesPerSec += Number(WriteThroughput) || 0;
-            mediaType =
-                PDiskType && (PDiskType === mediaType || mediaType === '') ? PDiskType : 'Mixed';
+            mediaType = PDiskType && (PDiskType === mediaType || !mediaType) ? PDiskType : 'Mixed';
         }
     }
     const vDisks = (_a = group.VDisks) === null || _a === void 0 ? void 0 : _a.map((vdisk) => prepareVDisk(vdisk, poolName));
     const usage = getUsage({ Used: usedSpaceBytes, Limit: limitSizeBytes }, 5);
-    return Object.assign(Object.assign({}, group), { VDisks: vDisks, Usage: usage, Read: readSpeedBytesPerSec, Write: writeSpeedBytesPerSec, PoolName: poolName, Used: usedSpaceBytes, Limit: limitSizeBytes, Degraded: missing, UsedSpaceFlag: usedSpaceFlag, Kind: mediaType || undefined });
+    return Object.assign(Object.assign({}, group), { VDisks: vDisks, Usage: usage, Read: readSpeedBytesPerSec, Write: writeSpeedBytesPerSec, PoolName: poolName, Used: usedSpaceBytes, Limit: limitSizeBytes, Degraded: missing, UsedSpaceFlag: usedSpaceFlag, MediaType: poolMediaType || mediaType || undefined });
 };
 export const prepareStorageGroupDataV2 = (group) => {
-    const { VDisks = [], PoolName, Usage = 0, Read = 0, Write = 0, Used = 0, Limit = 0, Degraded = 0, Kind, } = group;
+    const { VDisks = [], PoolName, Usage = 0, Read = 0, Write = 0, Used = 0, Limit = 0, Degraded = 0, Kind, MediaType, } = group;
     const UsedSpaceFlag = VDisks.reduce((acc, { DiskSpace }) => {
         if (DiskSpace && DiskSpace !== EFlag.Grey) {
             return acc + FLAGS_POINTS[DiskSpace];
@@ -65,8 +65,7 @@ export const prepareStorageGroupDataV2 = (group) => {
     const vDisks = VDisks.map((vdisk) => prepareVDisk(vdisk, PoolName));
     const usage = Math.floor(Number(Usage) * 100);
     return Object.assign(Object.assign({}, group), { UsedSpaceFlag,
-        PoolName,
-        Kind, VDisks: vDisks, Usage: usage, Read: Number(Read), Write: Number(Write), Used: Number(Used), Limit: Number(Limit), Degraded: Number(Degraded) });
+        PoolName, MediaType: MediaType || Kind, VDisks: vDisks, Usage: usage, Read: Number(Read), Write: Number(Write), Used: Number(Used), Limit: Number(Limit), Degraded: Number(Degraded) });
 };
 export const prepareStorageGroups = (StorageGroups, StoragePools) => {
     let preparedGroups = [];
@@ -77,7 +76,7 @@ export const prepareStorageGroups = (StorageGroups, StoragePools) => {
         StoragePools === null || StoragePools === void 0 ? void 0 : StoragePools.forEach((pool) => {
             var _a;
             (_a = pool.Groups) === null || _a === void 0 ? void 0 : _a.forEach((group) => {
-                preparedGroups.push(prepareStorageGroupData(group, pool.Name));
+                preparedGroups.push(prepareStorageGroupData(group, pool));
             });
         });
     }