ydb-embedded-ui 6.8.0 → 6.9.0

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

@@ -0,0 +1,56 @@
+import { convertBytesObjectToSpeed } from '../../../utils/bytesParsers';
+import { parseLag, parseTimestampToIdleTime } from '../../../utils/timeParsers';
+import { isNumeric } from '../../../utils/utils';
+const prepareGeneralPartitionStats = (partitionStats) => {
+    const { partition_offsets, store_size_bytes = '0', last_write_time: partition_last_write_time, max_write_time_lag: partition_write_lag, bytes_written, partition_node_id = 0, } = partitionStats || {};
+    const { start: start_offset = '0', end: end_offset = '0' } = partition_offsets || {};
+    return {
+        storeSize: store_size_bytes,
+        writeSpeed: convertBytesObjectToSpeed(bytes_written),
+        partitionWriteLag: parseLag(partition_write_lag),
+        partitionWriteIdleTime: parseTimestampToIdleTime(partition_last_write_time),
+        startOffset: start_offset,
+        endOffset: end_offset,
+        partitionNodeId: partition_node_id,
+    };
+};
+export const prepareTopicPartitions = (partitions) => {
+    return partitions === null || partitions === void 0 ? void 0 : partitions.map((partition) => {
+        // describe_topic endpoint doesn't return zero values, so some values will be initialized with 0
+        const { partition_id = '0', partition_stats } = partition;
+        const preparedPartitionStats = prepareGeneralPartitionStats(partition_stats);
+        return {
+            partitionId: partition_id,
+            ...preparedPartitionStats,
+        };
+    });
+};
+export const prepareConsumerPartitions = (partitions) => {
+    return partitions === null || partitions === void 0 ? void 0 : partitions.map((partition) => {
+        // describe_consumer endpoint doesn't return zero values, so some values will be initialized with 0
+        const { partition_id = '0', partition_stats, partition_consumer_stats } = partition;
+        const preparedPartitionStats = prepareGeneralPartitionStats(partition_stats);
+        const { endOffset } = preparedPartitionStats;
+        const { last_read_offset = '0', committed_offset = '0', read_session_id, last_read_time: consumer_last_read_time, max_read_time_lag: consumer_read_lag, max_write_time_lag: consumer_write_lag, bytes_read, reader_name, connection_node_id = 0, } = partition_consumer_stats || {};
+        const uncommitedMessages = isNumeric(endOffset) && isNumeric(committed_offset)
+            ? Number(endOffset) - Number(committed_offset)
+            : 0;
+        const unreadMessages = isNumeric(endOffset) && isNumeric(last_read_offset)
+            ? Number(endOffset) - Number(last_read_offset)
+            : 0;
+        return {
+            ...preparedPartitionStats,
+            partitionId: partition_id,
+            readSpeed: convertBytesObjectToSpeed(bytes_read),
+            consumerWriteLag: parseLag(consumer_write_lag),
+            consumerReadLag: parseLag(consumer_read_lag),
+            consumerReadIdleTime: parseTimestampToIdleTime(consumer_last_read_time),
+            uncommitedMessages,
+            unreadMessages,
+            commitedOffset: committed_offset,
+            readSessionId: read_session_id,
+            readerName: reader_name,
+            connectionNodeId: connection_node_id,
+        };
+    });
+};

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

@@ -0,0 +1,9 @@
+interface PDiskParams {
+    nodeId: number | string;
+    pDiskId: number | string;
+}
+export declare const pDiskApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getPdiskInfo: import("@reduxjs/toolkit/query").QueryDefinition<PDiskParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PDiskData | undefined, "api">;
+    getStorageInfo: import("@reduxjs/toolkit/query").QueryDefinition<PDiskParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../storage/types").PreparedStorageGroup[] | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+export {};

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

@@ -0,0 +1,38 @@
+import { preparePDiskData } from '../../../utils/disks/prepareDisks';
+import { prepareNodeSystemState } from '../../../utils/nodes';
+import { prepareStorageGroupData } from '../storage/utils';
+export function preparePDiskDataResponse([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 {
+        ...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));
+            }
+        });
+    });
+    return preparedGroups;
+}

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

@@ -0,0 +1,10 @@
+import type { ExecuteActions } from '../../types/api/query';
+interface SendQueryParams {
+    query?: string;
+    database?: string;
+    action?: ExecuteActions;
+}
+export declare const previewApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    sendQuery: import("@reduxjs/toolkit/query").QueryDefinition<SendQueryParams, 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>;
+export {};

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

@@ -0,0 +1,31 @@
+import type { Reducer, Selector } from '@reduxjs/toolkit';
+import type { EPathType, TEvDescribeSchemeResult } from '../../../types/api/schema';
+import type { RootState } from '../../defaultStore';
+import type { SchemaAction, SchemaState } from './types';
+export declare const initialState: {
+    loading: boolean;
+    data: {};
+    currentSchemaPath: undefined;
+    showPreview: boolean;
+};
+declare const schema: Reducer<SchemaState, SchemaAction>;
+export declare function setShowPreview(value: boolean): {
+    readonly type: "schema/SET_SHOW_PREVIEW";
+    readonly data: boolean;
+};
+export default schema;
+export declare const schemaApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    createDirectory: import("@reduxjs/toolkit/query").MutationDefinition<{
+        database: string;
+        path: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", unknown, "api">;
+    getSchema: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", TEvDescribeSchemeResult & {
+        partial?: boolean;
+    }, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+export declare const selectSchemaMergedChildrenPaths: Selector<RootState, string[] | undefined, [
+    string | undefined,
+    EPathType | undefined
+]>;

package/dist/store/reducers/schema/schema.js

@@ -0,0 +1,92 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { isEntityWithMergedImplementation } from '../../../containers/Tenant/utils/schema';
+import { api } from '../api';
+const SET_SHOW_PREVIEW = 'schema/SET_SHOW_PREVIEW';
+export const initialState = {
+    loading: true,
+    data: {},
+    currentSchemaPath: undefined,
+    showPreview: false,
+};
+const schema = (state = initialState, action) => {
+    switch (action.type) {
+        case SET_SHOW_PREVIEW: {
+            return {
+                ...state,
+                showPreview: action.data,
+            };
+        }
+        default:
+            return state;
+    }
+};
+export function setShowPreview(value) {
+    return {
+        type: SET_SHOW_PREVIEW,
+        data: value,
+    };
+}
+export default schema;
+export const schemaApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        createDirectory: builder.mutation({
+            queryFn: async ({ database, path }, { signal }) => {
+                try {
+                    const data = await window.api.createSchemaDirectory(database, path, { signal });
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+        }),
+        getSchema: builder.query({
+            queryFn: async ({ path }, { signal }) => {
+                try {
+                    const data = await window.api.getSchema({ path }, { signal });
+                    return { data: data !== null && data !== void 0 ? data : {} };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            keepUnusedDataFor: Infinity,
+            forceRefetch: ({ endpointState }) => {
+                const data = endpointState === null || endpointState === void 0 ? void 0 : endpointState.data;
+                if (data && typeof data === 'object' && 'partial' in data && data.partial) {
+                    return true;
+                }
+                return false;
+            },
+            onQueryStarted: async ({ path }, { dispatch, getState, queryFulfilled }) => {
+                const { data } = await queryFulfilled;
+                if (data) {
+                    const state = getState();
+                    const { PathDescription: { Children = [] } = {} } = data;
+                    for (const child of Children) {
+                        const { Name = '' } = child;
+                        const childPath = `${path}/${Name}`;
+                        const cachedData = schemaApi.endpoints.getSchema.select({ path: childPath })(state).data;
+                        if (!cachedData) {
+                            // not full data, but it contains PathType, which ensures seamless switch between nodes
+                            dispatch(schemaApi.util.upsertQueryData('getSchema', { path: childPath }, { PathDescription: { Self: child }, partial: true }));
+                        }
+                    }
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});
+const getSchemaSelector = createSelector((path) => path, (path) => schemaApi.endpoints.getSchema.select({ path }));
+const selectGetSchema = createSelector((state) => state, (_state, path) => getSchemaSelector(path), (state, selectTabletsInfo) => selectTabletsInfo(state).data);
+const selectSchemaChildren = (state, path) => { var _a, _b; return (_b = (_a = selectGetSchema(state, path)) === null || _a === void 0 ? void 0 : _a.PathDescription) === null || _b === void 0 ? void 0 : _b.Children; };
+export const selectSchemaMergedChildrenPaths = createSelector([
+    (_, path) => path,
+    (_, _path, type) => type,
+    selectSchemaChildren,
+], (path, type, children) => {
+    return isEntityWithMergedImplementation(type)
+        ? children === null || children === void 0 ? void 0 : children.map(({ Name }) => path + '/' + Name)
+        : undefined;
+});

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

@@ -0,0 +1,8 @@
+export declare const schemaAclApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getSchemaAcl: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", {
+        acl: import("../../../types/api/acl").TACE[] | undefined;
+        owner: string | undefined;
+    } | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -0,0 +1,17 @@
+import type { ShardsWorkloadFilters } from './types';
+export interface SortOrder {
+    columnId: string;
+    order: string;
+}
+export declare const setShardsQueryFilters: import("@reduxjs/toolkit").ActionCreatorWithPayload<ShardsWorkloadFilters, "shardsWorkload/setShardsQueryFilters">;
+declare const _default: import("redux").Reducer<ShardsWorkloadFilters>;
+export default _default;
+interface SendShardQueryParams {
+    database?: string;
+    path?: string;
+    sortOrder?: SortOrder[];
+    filters?: ShardsWorkloadFilters;
+}
+export declare const shardApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    sendShardQuery: import("@reduxjs/toolkit/query").QueryDefinition<SendShardQueryParams, 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/shardsWorkload/shardsWorkload.js

@@ -0,0 +1,112 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../../utils/query';
+import { api } from '../api';
+import { EShardsWorkloadMode } from './types';
+const initialState = {};
+function formatSortOrder({ columnId, order }) {
+    return `${columnId} ${order}`;
+}
+function getFiltersConditions(filters) {
+    const conditions = [];
+    if ((filters === null || filters === void 0 ? void 0 : filters.from) && (filters === null || filters === void 0 ? void 0 : filters.to) && filters.from > filters.to) {
+        throw new Error('Invalid date range');
+    }
+    if (filters === null || filters === void 0 ? void 0 : filters.from) {
+        // matching `from` & `to` is an edge case
+        // other cases should not include the starting point, since intervals are stored using the ending time
+        const gt = filters.to === filters.from ? '>=' : '>';
+        conditions.push(`IntervalEnd ${gt} Timestamp('${new Date(filters.from).toISOString()}')`);
+    }
+    if (filters === null || filters === void 0 ? void 0 : filters.to) {
+        conditions.push(`IntervalEnd <= Timestamp('${new Date(filters.to).toISOString()}')`);
+    }
+    return conditions.join(' AND ');
+}
+function createShardQueryHistorical(path, filters, sortOrder, tenantName) {
+    const pathSelect = tenantName
+        ? `CAST(SUBSTRING(CAST(Path AS String), ${tenantName.length}) AS Utf8) AS Path`
+        : 'Path';
+    let where = `Path='${path}' OR Path LIKE '${path}/%'`;
+    const filterConditions = getFiltersConditions(filters);
+    if (filterConditions.length) {
+        where = `(${where}) AND ${filterConditions}`;
+    }
+    const orderBy = sortOrder ? `ORDER BY ${sortOrder.map(formatSortOrder).join(', ')}` : '';
+    return `SELECT
+    ${pathSelect},
+    TabletId,
+    CPUCores,
+    DataSize,
+    NodeId,
+    PeakTime,
+    InFlightTxCount,
+    IntervalEnd
+FROM \`.sys/top_partitions_one_hour\`
+WHERE ${where}
+${orderBy}
+LIMIT 20`;
+}
+function createShardQueryImmediate(path, sortOrder, tenantName) {
+    const pathSelect = tenantName
+        ? `CAST(SUBSTRING(CAST(Path AS String), ${tenantName.length}) AS Utf8) AS Path`
+        : 'Path';
+    const orderBy = sortOrder ? `ORDER BY ${sortOrder.map(formatSortOrder).join(', ')}` : '';
+    return `SELECT
+    ${pathSelect},
+    TabletId,
+    CPUCores,
+    DataSize,
+    NodeId,
+    InFlightTxCount
+FROM \`.sys/partition_stats\`
+WHERE
+    Path='${path}'
+    OR Path LIKE '${path}/%'
+${orderBy}
+LIMIT 20`;
+}
+const queryAction = 'execute-scan';
+const slice = createSlice({
+    name: 'shardsWorkload',
+    initialState,
+    reducers: {
+        setShardsQueryFilters: (state, action) => {
+            return {
+                ...state,
+                ...action.payload,
+            };
+        },
+    },
+});
+export const { setShardsQueryFilters } = slice.actions;
+export default slice.reducer;
+export const shardApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        sendShardQuery: build.query({
+            queryFn: async ({ database, path = '', sortOrder, filters }, { signal }) => {
+                try {
+                    const response = await window.api.sendQuery({
+                        schema: 'modern',
+                        query: (filters === null || filters === void 0 ? void 0 : filters.mode) === EShardsWorkloadMode.Immediate
+                            ? createShardQueryImmediate(path, sortOrder, database)
+                            : createShardQueryHistorical(path, filters, sortOrder, database),
+                        database,
+                        action: queryAction,
+                    }, {
+                        signal,
+                    });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    const data = parseQueryAPIExecuteResponse(response);
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -0,0 +1,6 @@
+import type { NodesApiRequestParams } from '../nodes/types';
+import type { StorageApiRequestParams } from './types';
+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/query/react").reactHooksModuleName>;

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

@@ -0,0 +1,32 @@
+import { EVersion } from '../../../types/api/storage';
+import { api } from '../api';
+import { prepareStorageGroupsResponse, prepareStorageNodesResponse } from './utils';
+export const storageApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getStorageNodesInfo: builder.query({
+            queryFn: async (params, { signal }) => {
+                try {
+                    const result = await window.api.getNodes({ 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({ version: EVersion.v1, ...params }, { signal });
+                    return { data: prepareStorageGroupsResponse(result) };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -0,0 +1,159 @@
+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 { 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 = {
+    [EFlag.Grey]: 0,
+    [EFlag.Blue]: 0,
+    [EFlag.Green]: 1,
+    [EFlag.Yellow]: 100,
+    [EFlag.Orange]: 10000,
+    [EFlag.Red]: 1000000,
+};
+// ==== Prepare groups ====
+const prepareVDisk = (vDisk, poolName) => {
+    var _a;
+    const preparedVDisk = prepareVDiskData(vDisk);
+    // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
+    return {
+        ...preparedVDisk,
+        StoragePoolName: poolName,
+        Donors: (_a = preparedVDisk === null || preparedVDisk === void 0 ? void 0 : preparedVDisk.Donors) === null || _a === void 0 ? void 0 : _a.map((donor) => ({
+            ...donor,
+            StoragePoolName: poolName,
+        })),
+    };
+};
+export const prepareStorageGroupData = (group, pool) => {
+    var _a;
+    let missing = 0;
+    let usedSpaceFlag = 0;
+    let usedSpaceBytes = 0;
+    let limitSizeBytes = 0;
+    let readSpeedBytesPerSec = 0;
+    let writeSpeedBytesPerSec = 0;
+    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;
+            const { Type: PDiskType, State: PDiskState, AvailableSize: PDiskAvailableSize, } = preparePDiskData(PDisk);
+            if (!Replicated || PDiskState !== TPDiskState.Normal || VDiskState !== EVDiskState.OK) {
+                missing += 1;
+            }
+            if (DiskSpace) {
+                usedSpaceFlag += FLAGS_POINTS[DiskSpace];
+            }
+            const available = Number(AvailableSize !== null && AvailableSize !== void 0 ? AvailableSize : PDiskAvailableSize) || 0;
+            const allocated = Number(AllocatedSize) || 0;
+            usedSpaceBytes += allocated;
+            limitSizeBytes += available + allocated;
+            readSpeedBytesPerSec += Number(ReadThroughput) || 0;
+            writeSpeedBytesPerSec += Number(WriteThroughput) || 0;
+            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 {
+        ...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, MediaType, } = group;
+    const UsedSpaceFlag = VDisks.reduce((acc, { DiskSpace }) => {
+        if (DiskSpace && DiskSpace !== EFlag.Grey) {
+            return acc + FLAGS_POINTS[DiskSpace];
+        }
+        return acc;
+    }, 0);
+    const vDisks = VDisks.map((vdisk) => prepareVDisk(vdisk, PoolName));
+    const usage = Math.floor(Number(Usage) * 100);
+    return {
+        ...group,
+        UsedSpaceFlag,
+        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 = [];
+    if (StorageGroups) {
+        preparedGroups = StorageGroups.map(prepareStorageGroupDataV2);
+    }
+    else {
+        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));
+            });
+        });
+    }
+    return preparedGroups;
+};
+// ==== Prepare nodes ====
+const prepareStorageNodeData = (node) => {
+    var _a, _b, _c;
+    const missing = ((_a = node.PDisks) === null || _a === void 0 ? void 0 : _a.filter((pDisk) => {
+        return pDisk.State !== TPDiskState.Normal;
+    }).length) || 0;
+    const pDisks = (_b = node.PDisks) === null || _b === void 0 ? void 0 : _b.map((pDisk) => {
+        return {
+            ...preparePDiskData(pDisk),
+            NodeId: node.NodeId,
+        };
+    });
+    const vDisks = (_c = node.VDisks) === null || _c === void 0 ? void 0 : _c.map((vDisk) => {
+        return {
+            ...prepareVDiskData(vDisk),
+            NodeId: node.NodeId,
+        };
+    });
+    return {
+        ...prepareNodeSystemState(node.SystemState),
+        NodeId: node.NodeId,
+        PDisks: pDisks,
+        VDisks: vDisks,
+        Missing: missing,
+    };
+};
+// ==== Prepare responses ====
+export const prepareStorageNodesResponse = (data) => {
+    const { Nodes, TotalNodes, FoundNodes } = data;
+    const preparedNodes = Nodes === null || Nodes === void 0 ? void 0 : Nodes.map(prepareStorageNodeData);
+    return {
+        nodes: preparedNodes,
+        total: Number(TotalNodes) || (preparedNodes === null || preparedNodes === void 0 ? void 0 : preparedNodes.length),
+        found: Number(FoundNodes),
+    };
+};
+export const prepareStorageGroupsResponse = (data) => {
+    const { StoragePools, StorageGroups, TotalGroups, FoundGroups } = data;
+    const preparedGroups = prepareStorageGroups(StorageGroups, StoragePools);
+    return {
+        groups: preparedGroups,
+        total: Number(TotalGroups) || preparedGroups.length,
+        found: Number(FoundGroups),
+    };
+};

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

@@ -0,0 +1,14 @@
+import type { TDomainKey } from '../../types/api/tablet';
+import type { ITabletPreparedHistoryItem } from '../../types/store/tablet';
+export declare const tabletApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    getTablet: import("@reduxjs/toolkit/query").QueryDefinition<{
+        id: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", {
+        id: string | undefined;
+        data: import("../../types/api/tablet").TTabletStateInfo;
+        history: ITabletPreparedHistoryItem[];
+    } | undefined, "api">;
+    getTabletDescribe: import("@reduxjs/toolkit/query").QueryDefinition<{
+        tenantId: TDomainKey;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", string | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;