ydb-embedded-ui 5.2.1 → 5.4.0

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

@@ -2,16 +2,17 @@ import type { ApiRequestAction } from '../../utils';
 import type { IResponseError } from '../../../types/api/error';
 import type { TEvDescribeSchemeResult } from '../../../types/api/schema';
 import { FETCH_OVERVIEW, setDataWasNotLoaded, setCurrentOverviewPath } from './overview';
+import { Nullable } from '../../../utils/typecheckers';
 export interface OverviewState {
     loading: boolean;
     wasLoaded: boolean;
     currentOverviewPath?: string;
-    data?: TEvDescribeSchemeResult;
-    additionalData?: TEvDescribeSchemeResult[];
+    data?: Nullable<TEvDescribeSchemeResult>;
+    additionalData?: Nullable<TEvDescribeSchemeResult>[];
     error?: IResponseError;
 }
 export interface OverviewHandledResponse {
-    data: TEvDescribeSchemeResult;
-    additionalData?: TEvDescribeSchemeResult[];
+    data: Nullable<TEvDescribeSchemeResult>;
+    additionalData?: Nullable<TEvDescribeSchemeResult>[];
 }
-export declare type OverviewAction = ApiRequestAction<typeof FETCH_OVERVIEW, OverviewHandledResponse, IResponseError> | ReturnType<typeof setCurrentOverviewPath> | ReturnType<typeof setDataWasNotLoaded>;
+export type OverviewAction = ApiRequestAction<typeof FETCH_OVERVIEW, OverviewHandledResponse, IResponseError> | ReturnType<typeof setCurrentOverviewPath> | ReturnType<typeof setDataWasNotLoaded>;

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

@@ -1,4 +1,4 @@
-import type { Reducer } from 'redux';
+import type { Reducer } from '@reduxjs/toolkit';
 import type { PartitionsAction, PartitionsState } from './types';
 export declare const FETCH_PARTITIONS: {
     readonly REQUEST: "partitions/FETCH_PARTITIONS_REQUEST";
@@ -13,5 +13,86 @@ export declare const setSelectedConsumer: (value: string) => {
 export declare const setDataWasNotLoaded: () => {
     readonly type: "partitions/SET_DATA_WAS_NOT_LOADED";
 };
-export declare function getPartitions(path: string, consumerName?: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("./types").PreparedPartitionData[] | undefined>;
+export declare function getPartitions(path: string, consumerName?: string): (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: import("../storage/types").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: 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").PreparedPartitionData[] | undefined>;
 export default partitions;

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

@@ -29,4 +29,4 @@ export interface PartitionsState {
     partitions?: PreparedPartitionData[];
     error?: IResponseError;
 }
-export declare type PartitionsAction = ApiRequestAction<typeof FETCH_PARTITIONS, PreparedPartitionData[], IResponseError> | ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setSelectedConsumer>;
+export type PartitionsAction = ApiRequestAction<typeof FETCH_PARTITIONS, PreparedPartitionData[], IResponseError> | ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setSelectedConsumer>;

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

@@ -1,5 +1,5 @@
 import type { PartitionInfo as ConsumerPartitionInfo } from '../../../types/api/consumer';
 import type { PartitionInfo as TopicPartitionInfo } from '../../../types/api/topic';
 import { PreparedPartitionData } from './types';
-export declare const prepareTopicPartitions: (partitions?: TopicPartitionInfo[] | undefined) => PreparedPartitionData[] | undefined;
-export declare const prepareConsumerPartitions: (partitions?: ConsumerPartitionInfo[] | undefined) => PreparedPartitionData[] | undefined;
+export declare const prepareTopicPartitions: (partitions?: TopicPartitionInfo[]) => PreparedPartitionData[] | undefined;
+export declare const prepareConsumerPartitions: (partitions?: ConsumerPartitionInfo[]) => PreparedPartitionData[] | undefined;

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

@@ -0,0 +1,210 @@
+import type { Reducer } from '@reduxjs/toolkit';
+import type { PDiskAction, PDiskState } from './types';
+export declare const FETCH_PDISK: {
+    readonly REQUEST: "pdisk/FETCH_PDISK_REQUEST";
+    readonly SUCCESS: "pdisk/FETCH_PDISK_SUCCESS";
+    readonly FAILURE: "pdisk/FETCH_PDISK_FAILURE";
+};
+export declare const FETCH_PDISK_GROUPS: {
+    readonly REQUEST: "pdisk/FETCH_PDISK_GROUPS_REQUEST";
+    readonly SUCCESS: "pdisk/FETCH_PDISK_GROUPS_SUCCESS";
+    readonly FAILURE: "pdisk/FETCH_PDISK_GROUPS_FAILURE";
+};
+declare const pdisk: Reducer<PDiskState, PDiskAction>;
+export declare const setPDiskDataWasNotLoaded: () => {
+    readonly type: "pdisk/SET_PDISK_DATA_WAS_NOT_LOADED";
+};
+export declare const getPDiskData: ({ nodeId, pDiskId, }: {
+    nodeId: number | string;
+    pDiskId: number | string;
+}) => (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: import("../storage/types").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: 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<{
+    NodeId: number | undefined;
+    NodeHost: string | undefined;
+    NodeType: string | undefined;
+    NodeDC: string | undefined;
+    Type?: string | undefined;
+    AllocatedPercent?: number | undefined;
+    Severity?: number | undefined;
+    PDiskId?: number | undefined;
+    CreateTime?: string | undefined;
+    ChangeTime?: string | undefined;
+    Path?: string | undefined;
+    Guid?: string | undefined;
+    Category?: string | undefined;
+    AvailableSize?: string | undefined;
+    TotalSize?: string | undefined;
+    State?: import("../../../types/api/pdisk").TPDiskState | undefined;
+    Count?: number | undefined;
+    Device?: import("../../../types/api/enums").EFlag | undefined;
+    Realtime?: import("../../../types/api/enums").EFlag | undefined;
+    StateFlag?: import("../../../types/api/enums").EFlag | undefined;
+    Overall?: import("../../../types/api/enums").EFlag | undefined;
+    SerialNumber?: string | undefined;
+} | undefined>;
+export declare const getPDiskStorage: ({ nodeId, pDiskId, }: {
+    nodeId: number | string;
+    pDiskId: number | string;
+}) => (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: import("../storage/types").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: 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("../storage/types").PreparedStorageGroup[] | undefined>;
+export default pdisk;

package/dist/store/reducers/pdisk/pdisk.js

@@ -0,0 +1,64 @@
+import { EVersion } from '../../../types/api/storage';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { preparePDiksDataResponse, preparePDiskStorageResponse } from './utils';
+export const FETCH_PDISK = createRequestActionTypes('pdisk', 'FETCH_PDISK');
+export const FETCH_PDISK_GROUPS = createRequestActionTypes('pdisk', 'FETCH_PDISK_GROUPS');
+const SET_PDISK_DATA_WAS_NOT_LOADED = 'pdisk/SET_PDISK_DATA_WAS_NOT_LOADED';
+const initialState = {
+    pDiskLoading: false,
+    pDiskWasLoaded: false,
+    pDiskData: {},
+    groupsLoading: false,
+    groupsWasLoaded: false,
+    groupsData: [],
+};
+const pdisk = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_PDISK.REQUEST: {
+            return Object.assign(Object.assign({}, state), { pDiskLoading: true });
+        }
+        case FETCH_PDISK.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { pDiskData: action.data, pDiskLoading: false, pDiskWasLoaded: true, pDiskError: undefined });
+        }
+        case FETCH_PDISK.FAILURE: {
+            return Object.assign(Object.assign({}, state), { pDiskError: action.error, pDiskLoading: false });
+        }
+        case FETCH_PDISK_GROUPS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { groupsLoading: true });
+        }
+        case FETCH_PDISK_GROUPS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { groupsData: action.data, groupsLoading: false, groupsWasLoaded: true, groupsError: undefined });
+        }
+        case FETCH_PDISK_GROUPS.FAILURE: {
+            return Object.assign(Object.assign({}, state), { groupsError: action.error, groupsLoading: false });
+        }
+        case SET_PDISK_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { pDiskWasLoaded: false, groupsWasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export const setPDiskDataWasNotLoaded = () => {
+    return {
+        type: SET_PDISK_DATA_WAS_NOT_LOADED,
+    };
+};
+export const getPDiskData = ({ nodeId, pDiskId, }) => {
+    return createApiRequest({
+        request: Promise.all([
+            window.api.getPdiskInfo(nodeId, pDiskId),
+            window.api.getNodeInfo(nodeId),
+        ]),
+        actions: FETCH_PDISK,
+        dataHandler: preparePDiksDataResponse,
+    });
+};
+export const getPDiskStorage = ({ nodeId, pDiskId, }) => {
+    return createApiRequest({
+        request: window.api.getStorageInfo({ nodeId, version: EVersion.v1 }),
+        actions: FETCH_PDISK_GROUPS,
+        dataHandler: (data) => preparePDiskStorageResponse(data, pDiskId, nodeId),
+    });
+};
+export default pdisk;

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

@@ -0,0 +1,23 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { PreparedPDisk } from '../../../utils/disks/types';
+import type { ApiRequestAction } from '../../utils';
+import type { PreparedStorageGroup } from '../storage/types';
+import type { FETCH_PDISK, FETCH_PDISK_GROUPS, setPDiskDataWasNotLoaded } from './pdisk';
+interface PDiskData extends PreparedPDisk {
+    NodeId?: number;
+    NodeHost?: string;
+    NodeType?: string;
+    NodeDC?: string;
+}
+export interface PDiskState {
+    pDiskLoading: boolean;
+    pDiskWasLoaded: boolean;
+    pDiskData: PDiskData;
+    pDiskError?: IResponseError;
+    groupsLoading: boolean;
+    groupsWasLoaded: boolean;
+    groupsData: PreparedStorageGroup[];
+    groupsError?: IResponseError;
+}
+export type PDiskAction = ApiRequestAction<typeof FETCH_PDISK, PDiskData, IResponseError> | ApiRequestAction<typeof FETCH_PDISK_GROUPS, PreparedStorageGroup[], IResponseError> | ReturnType<typeof setPDiskDataWasNotLoaded>;
+export {};

package/dist/store/reducers/pdisk/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,32 @@
+import type { TEvPDiskStateResponse } from '../../../types/api/pdisk';
+import type { TStorageInfo } from '../../../types/api/storage';
+import type { TEvSystemStateResponse } from '../../../types/api/systemState';
+import type { PreparedStorageGroup } from '../storage/types';
+export declare function preparePDiksDataResponse([pdiskResponse, nodeResponse]: [
+    TEvPDiskStateResponse,
+    TEvSystemStateResponse
+]): {
+    NodeId: number | undefined;
+    NodeHost: string | undefined;
+    NodeType: string | undefined;
+    NodeDC: string | undefined;
+    Type?: string | undefined;
+    AllocatedPercent?: number | undefined;
+    Severity?: number | undefined;
+    PDiskId?: number | undefined;
+    CreateTime?: string | undefined;
+    ChangeTime?: string | undefined;
+    Path?: string | undefined;
+    Guid?: string | undefined;
+    Category?: string | undefined;
+    AvailableSize?: string | undefined;
+    TotalSize?: string | undefined;
+    State?: import("../../../types/api/pdisk").TPDiskState | undefined;
+    Count?: number | undefined;
+    Device?: import("../../../types/api/enums").EFlag | undefined;
+    Realtime?: import("../../../types/api/enums").EFlag | undefined;
+    StateFlag?: import("../../../types/api/enums").EFlag | undefined;
+    Overall?: import("../../../types/api/enums").EFlag | undefined;
+    SerialNumber?: string | undefined;
+};
+export declare function preparePDiskStorageResponse(data: TStorageInfo, pDiskId: number | string, nodeId: number | string): PreparedStorageGroup[];

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

@@ -0,0 +1,32 @@
+import { preparePDiskData } from '../../../utils/disks/prepareDisks';
+import { prepareNodeSystemState } from '../../../utils/nodes';
+import { prepareStorageGroupData } from '../storage/utils';
+export function preparePDiksDataResponse([pdiskResponse, nodeResponse]) {
+    var _a, _b, _c, _d;
+    const rawPDisk = (_a = pdiskResponse.PDiskStateInfo) === null || _a === void 0 ? void 0 : _a[0];
+    const preparedPDisk = preparePDiskData(rawPDisk);
+    const rawNode = (_b = nodeResponse.SystemStateInfo) === null || _b === void 0 ? void 0 : _b[0];
+    const preparedNode = prepareNodeSystemState(rawNode);
+    return Object.assign(Object.assign({}, preparedPDisk), { NodeId: (_c = preparedPDisk.NodeId) !== null && _c !== void 0 ? _c : preparedNode.NodeId, NodeHost: preparedNode.Host, NodeType: (_d = preparedNode.Roles) === null || _d === void 0 ? void 0 : _d[0], NodeDC: preparedNode.DC });
+}
+export function preparePDiskStorageResponse(data, pDiskId, nodeId) {
+    var _a;
+    const preparedGroups = [];
+    (_a = data.StoragePools) === null || _a === void 0 ? void 0 : _a.forEach((pool) => {
+        var _a;
+        return (_a = pool.Groups) === null || _a === void 0 ? void 0 : _a.forEach((group) => {
+            var _a;
+            const groupHasPDiskVDisks = (_a = group.VDisks) === null || _a === void 0 ? void 0 : _a.some((vdisk) => {
+                var _a, _b, _c, _d;
+                // If VDisk has PDisk inside, PDiskId and NodeId fields could be only inside PDisk and vice versa
+                const groupPDiskId = (_a = vdisk.PDiskId) !== null && _a !== void 0 ? _a : (_b = vdisk.PDisk) === null || _b === void 0 ? void 0 : _b.PDiskId;
+                const groupNodeId = (_c = vdisk.NodeId) !== null && _c !== void 0 ? _c : (_d = vdisk.PDisk) === null || _d === void 0 ? void 0 : _d.NodeId;
+                return groupPDiskId === Number(pDiskId) && groupNodeId === Number(nodeId);
+            });
+            if (groupHasPDiskVDisks) {
+                preparedGroups.push(prepareStorageGroupData(group, pool.Name));
+            }
+        });
+    });
+    return preparedGroups;
+}

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

@@ -15,7 +15,88 @@ interface SendQueryParams {
     database?: string;
     action?: ExecuteActions;
 }
-export declare const sendQuery: ({ query, database, action }: SendQueryParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<IQueryResult | undefined>;
+export declare const sendQuery: ({ query, database, action }: SendQueryParams) => (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: import("./storage/types").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<IQueryResult | undefined>;
 export declare function setQueryOptions(options: any): {
     readonly type: "preview/SET_QUERY_OPTIONS";
     readonly data: any;

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

@@ -1,6 +1,6 @@
-import { Reducer } from 'redux';
-declare type IAction = ReturnType<typeof setQueryNameToEdit> | ReturnType<typeof clearQueryNameToEdit>;
-declare type ISaveQueryState = string | null;
+import type { Reducer } from '@reduxjs/toolkit';
+type IAction = ReturnType<typeof setQueryNameToEdit> | ReturnType<typeof clearQueryNameToEdit>;
+type ISaveQueryState = string | null;
 declare const saveQuery: Reducer<ISaveQueryState, IAction>;
 export declare function setQueryNameToEdit(name: string): {
     readonly type: "SET_QUERY_NAME_TO_EDIT";