ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/containers/Tenant/Diagnostics/Partitions/Partitions.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import block from 'bem-cn-lite';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useDispatch } from 'react-redux';
+import DataTable from '@gravity-ui/react-data-table';
+import { useAutofetcher, useTypedSelector, useSetting } from '../../../../utils/hooks';
+import { DEFAULT_TABLE_SETTINGS, PARTITIONS_HIDDEN_COLUMNS_KEY } from '../../../../utils/constants';
+import { getNodesList, selectNodesMap } from '../../../../store/reducers/nodesList';
+import { cleanTopicData, getTopic, selectConsumersNames, setDataWasNotLoaded as setTopicDataWasNotLoaded, } from '../../../../store/reducers/topic';
+import { getPartitions, setDataWasNotLoaded as setPartitionsDataWasNotLoaded, setSelectedConsumer, } from '../../../../store/reducers/partitions/partitions';
+import { TableSkeleton } from '../../../../components/TableSkeleton/TableSkeleton';
+import { ResponseError } from '../../../../components/Errors/ResponseError';
+import { addHostToPartitions } from './utils';
+import { PartitionsControls } from './PartitionsControls/PartitionsControls';
+import { useGetPartitionsColumns } from './utils/useGetPartitionsColumns';
+import i18n from './i18n';
+import './Partitions.scss';
+export const b = block('ydb-diagnostics-partitions');
+export const Partitions = ({ path }) => {
+    const dispatch = useDispatch();
+    // Manual path control to ensure that topic state will be reset before data fetch
+    // so no request with wrong params will be sent
+    const [componentCurrentPath, setComponentCurrentPath] = useState(path);
+    const [partitionsToRender, setPartitionsToRender] = useState([]);
+    const consumers = useTypedSelector(selectConsumersNames);
+    const nodesMap = useTypedSelector(selectNodesMap);
+    const { autorefresh } = useTypedSelector((state) => state.schema);
+    const { loading: partitionsLoading, wasLoaded: partitionsWasLoaded, error: partitionsError, partitions: rawPartitions, selectedConsumer, } = useTypedSelector((state) => state.partitions);
+    const { loading: topicLoading, wasLoaded: topicWasLoaded, error: topicError, } = useTypedSelector((state) => state.topic);
+    const { loading: nodesLoading, wasLoaded: nodesWasLoaded, error: nodesError, } = useTypedSelector((state) => state.nodesList);
+    const [hiddenColumns, setHiddenColumns] = useSetting(PARTITIONS_HIDDEN_COLUMNS_KEY);
+    const [columns, columnsIdsForSelector] = useGetPartitionsColumns(selectedConsumer);
+    useEffect(() => {
+        dispatch(cleanTopicData());
+        dispatch(setTopicDataWasNotLoaded());
+        dispatch(getNodesList());
+        dispatch(getTopic(path));
+        setComponentCurrentPath(path);
+    }, [dispatch, path]);
+    const partitionsWithHosts = useMemo(() => {
+        return addHostToPartitions(rawPartitions, nodesMap);
+    }, [rawPartitions, nodesMap]);
+    const fetchData = useCallback((isBackground) => {
+        if (!isBackground) {
+            dispatch(setPartitionsDataWasNotLoaded());
+        }
+        if (topicWasLoaded && componentCurrentPath) {
+            dispatch(getPartitions(componentCurrentPath, selectedConsumer));
+        }
+    }, [dispatch, selectedConsumer, componentCurrentPath, topicWasLoaded]);
+    useAutofetcher(fetchData, [fetchData], autorefresh);
+    // Wrong consumer could be passed in search query
+    // Reset consumer if it doesn't exist for current topic
+    useEffect(() => {
+        const isTopicWithoutConsumers = topicWasLoaded && !consumers;
+        const wrongSelectedConsumer = selectedConsumer && consumers && !consumers.includes(selectedConsumer);
+        if (isTopicWithoutConsumers || wrongSelectedConsumer) {
+            dispatch(setSelectedConsumer(''));
+        }
+    }, [dispatch, topicWasLoaded, selectedConsumer, consumers]);
+    const columnsToShow = useMemo(() => {
+        return columns.filter((column) => !hiddenColumns.includes(column.name));
+    }, [columns, hiddenColumns]);
+    const hadleTableColumnsSetupChange = (newHiddenColumns) => {
+        setHiddenColumns(newHiddenColumns);
+    };
+    const handleSelectedConsumerChange = (value) => {
+        dispatch(setSelectedConsumer(value));
+    };
+    const loading = (topicLoading && !topicWasLoaded) ||
+        (nodesLoading && !nodesWasLoaded) ||
+        (partitionsLoading && !partitionsWasLoaded);
+    const error = nodesError || topicError || partitionsError;
+    const getContent = () => {
+        if (loading) {
+            return _jsx(TableSkeleton, { className: b('loader') });
+        }
+        if (error) {
+            return _jsx(ResponseError, { error: error });
+        }
+        return (_jsx(DataTable, { theme: "yandex-cloud", data: partitionsToRender, columns: columnsToShow, settings: DEFAULT_TABLE_SETTINGS, emptyDataMessage: i18n('table.emptyDataMessage') }));
+    };
+    return (_jsxs("div", Object.assign({ className: b() }, { children: [_jsx(PartitionsControls, { consumers: consumers, selectedConsumer: selectedConsumer, onSelectedConsumerChange: handleSelectedConsumerChange, selectDisabled: Boolean(error) || loading, partitions: partitionsWithHosts, onSearchChange: setPartitionsToRender, hiddenColumns: hiddenColumns, onHiddenColumnsChange: hadleTableColumnsSetupChange, initialColumnsIds: columnsIdsForSelector }), _jsx("div", Object.assign({ className: b('table-wrapper') }, { children: _jsx("div", Object.assign({ className: b('table-content') }, { children: getContent() })) }))] })));
+};

package/dist/containers/Tenant/Diagnostics/Partitions/PartitionsControls/PartitionsControls.d.ts

@@ -0,0 +1,14 @@
+import type { PreparedPartitionDataWithHosts } from '../utils/types';
+interface PartitionsControlsProps {
+    consumers: string[] | undefined;
+    selectedConsumer: string;
+    onSelectedConsumerChange: (consumer: string) => void;
+    selectDisabled: boolean;
+    partitions: PreparedPartitionDataWithHosts[] | undefined;
+    onSearchChange: (filteredPartitions: PreparedPartitionDataWithHosts[]) => void;
+    hiddenColumns: string[];
+    onHiddenColumnsChange: (newHiddenColumns: string[]) => void;
+    initialColumnsIds: string[];
+}
+export declare const PartitionsControls: ({ consumers, selectedConsumer, onSelectedConsumerChange, selectDisabled, partitions, onSearchChange, hiddenColumns, onHiddenColumnsChange, initialColumnsIds, }: PartitionsControlsProps) => JSX.Element;
+export {};

package/dist/containers/Tenant/Diagnostics/Partitions/PartitionsControls/PartitionsControls.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from 'react';
+import { escapeRegExp } from 'lodash/fp';
+import { Select, TableColumnSetup } from '@gravity-ui/uikit';
+import { Search } from '../../../../../components/Search/Search';
+import { PARTITIONS_COLUMNS_IDS, PARTITIONS_COLUMNS_TITILES } from '../utils/constants';
+import i18n from '../i18n';
+import { b } from '../Partitions';
+export const PartitionsControls = ({ consumers, selectedConsumer, onSelectedConsumerChange, selectDisabled, partitions, onSearchChange, hiddenColumns, onHiddenColumnsChange, initialColumnsIds, }) => {
+    const [generalSearchValue, setGeneralSearchValue] = useState('');
+    const [partitionIdSearchValue, setPartitionIdSearchValue] = useState('');
+    useEffect(() => {
+        if (!partitions) {
+            return;
+        }
+        const partitionIdRe = new RegExp(escapeRegExp(partitionIdSearchValue), 'i');
+        const generalRe = new RegExp(escapeRegExp(generalSearchValue), 'i');
+        const filteredPartitions = partitions.filter((partition) => {
+            const { partitionId, readerName, readSessionId, partitionNodeId, connectionNodeId, partitionHost, connectionHost, } = partition;
+            const isPartitionIdMatch = partitionIdRe.test(partitionId);
+            const otherValues = [
+                readerName,
+                readSessionId,
+                partitionNodeId,
+                connectionNodeId,
+                partitionHost,
+                connectionHost,
+            ]
+                .filter(Boolean)
+                .map(String);
+            const isOtherValuesMatch = otherValues.length === 0 || otherValues.some((value) => generalRe.test(value));
+            return isPartitionIdMatch && isOtherValuesMatch;
+        });
+        onSearchChange(filteredPartitions);
+    }, [partitionIdSearchValue, generalSearchValue, partitions, onSearchChange]);
+    const consumersToSelect = useMemo(() => {
+        const options = consumers && consumers.length
+            ? consumers.map((consumer) => ({
+                value: consumer,
+                content: consumer,
+            }))
+            : [];
+        return [{ value: '', content: i18n('controls.consumerSelector.emptyOption') }, ...options];
+    }, [consumers]);
+    const columnsToSelect = useMemo(() => {
+        return initialColumnsIds.map((id) => {
+            return {
+                title: PARTITIONS_COLUMNS_TITILES[id],
+                selected: Boolean(!hiddenColumns.includes(id)),
+                id: id,
+                required: id === PARTITIONS_COLUMNS_IDS.PARTITION_ID,
+            };
+        });
+    }, [initialColumnsIds, hiddenColumns]);
+    const handleConsumerSelectChange = (value) => {
+        onSelectedConsumerChange(value[0]);
+    };
+    const handlePartitionIdSearchChange = (value) => {
+        setPartitionIdSearchValue(value);
+    };
+    const handleGeneralSearchChange = (value) => {
+        setGeneralSearchValue(value);
+    };
+    const hadleTableColumnsSetupChange = (value) => {
+        const result = [...hiddenColumns];
+        // Process current set of columns
+        // This way we do not remove from hidden these columns, that are not displayed currently
+        // The reasons: set of columns differs for partitions with and without consumers
+        value.forEach((el) => {
+            if (!el.selected && !hiddenColumns.includes(el.id)) {
+                result.push(el.id);
+            }
+            else if (el.selected && hiddenColumns.includes(el.id)) {
+                result.splice(hiddenColumns.indexOf(el.id));
+            }
+        });
+        onHiddenColumnsChange(result);
+    };
+    const renderOption = (option) => {
+        return (_jsx("div", Object.assign({ className: b('select-option', { empty: option.value === '' }) }, { children: option.content })));
+    };
+    return (_jsxs("div", Object.assign({ className: b('controls') }, { children: [_jsx(Select, { className: b('consumer-select'), label: i18n('controls.consumerSelector'), options: consumersToSelect, value: [selectedConsumer], onUpdate: handleConsumerSelectChange, filterable: consumers && consumers.length > 5, disabled: selectDisabled || !consumers || !consumers.length, renderOption: renderOption, renderSelectedOption: renderOption }), _jsx(Search, { onChange: handlePartitionIdSearchChange, placeholder: i18n('controls.partitionSearch'), className: b('search', { partition: true }), value: partitionIdSearchValue }), _jsx(Search, { onChange: handleGeneralSearchChange, placeholder: i18n('controls.generalSearch'), className: b('search', { general: true }), value: generalSearchValue }), _jsx(TableColumnSetup, { popupWidth: "242px", items: columnsToSelect, showStatus: true, onUpdate: hadleTableColumnsSetupChange }, "TableColumnSetup")] })));
+};

package/dist/containers/Tenant/Diagnostics/Partitions/columns/columns.d.ts

@@ -0,0 +1,5 @@
+import { Column } from '@gravity-ui/react-data-table';
+import type { PreparedPartitionDataWithHosts } from '../utils/types';
+import './Columns.scss';
+export declare const allColumns: Column<PreparedPartitionDataWithHosts>[];
+export declare const generalColumns: Column<PreparedPartitionDataWithHosts>[];

package/dist/containers/Tenant/Diagnostics/Partitions/columns/columns.js

@@ -0,0 +1,147 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DataTable from '@gravity-ui/react-data-table';
+import block from 'bem-cn-lite';
+import { SpeedMultiMeter } from '../../../../../components/SpeedMultiMeter';
+import EntityStatus from '../../../../../components/EntityStatus/EntityStatus';
+import { getDefaultNodePath } from '../../../../Node/NodePages';
+import { formatBytes, formatMsToUptime } from '../../../../../utils/dataFormatters/dataFormatters';
+import { isNumeric } from '../../../../../utils/utils';
+import { PARTITIONS_COLUMNS_IDS, PARTITIONS_COLUMNS_TITILES, PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS, PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES, PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS, PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES, generalPartitionColumnsIds, } from '../utils/constants';
+import { MultilineHeader, ReadLagsHeader, ReadSessionHeader, UncommitedMessagesHeader, UnreadMessagesHeader, WriteLagsHeader, } from '../Headers';
+import './Columns.scss';
+const b = block('ydb-diagnostics-partitions-columns');
+export const allColumns = [
+    {
+        name: PARTITIONS_COLUMNS_IDS.PARTITION_ID,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.PARTITION_ID] })),
+        sortAccessor: (row) => isNumeric(row.partitionId) && Number(row.partitionId),
+        align: DataTable.LEFT,
+        render: ({ row }) => row.partitionId,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.STORE_SIZE,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.STORE_SIZE] })),
+        align: DataTable.RIGHT,
+        render: ({ row }) => formatBytes(row.storeSize),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.WRITE_SPEED,
+        header: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.WRITE_SPEED],
+        align: DataTable.LEFT,
+        sortAccessor: (row) => row.writeSpeed.perMinute,
+        render: ({ row }) => _jsx(SpeedMultiMeter, { data: row.writeSpeed }),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READ_SPEED,
+        header: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.READ_SPEED],
+        align: DataTable.LEFT,
+        sortAccessor: (row) => { var _a; return (_a = row.readSpeed) === null || _a === void 0 ? void 0 : _a.perMinute; },
+        render: ({ row }) => _jsx(SpeedMultiMeter, { data: row.readSpeed }),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.WRITE_LAGS,
+        header: _jsx(WriteLagsHeader, {}),
+        className: b('lags-header'),
+        sub: [
+            {
+                name: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_LAG,
+                header: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES[PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_LAG],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.partitionWriteLag),
+            },
+            {
+                name: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_IDLE_TIME,
+                header: PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES[PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_IDLE_TIME],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.partitionWriteIdleTime),
+            },
+        ],
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READ_LAGS,
+        header: _jsx(ReadLagsHeader, {}),
+        className: b('lags-header'),
+        sub: [
+            {
+                name: PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_WRITE_LAG,
+                header: PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES[PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_WRITE_LAG],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.consumerWriteLag),
+            },
+            {
+                name: PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_LAG,
+                header: PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES[PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_LAG],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.consumerReadLag),
+            },
+            {
+                name: PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_IDLE_TIME,
+                header: PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES[PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_IDLE_TIME],
+                align: DataTable.RIGHT,
+                render: ({ row }) => formatMsToUptime(row.consumerReadIdleTime),
+            },
+        ],
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.UNCOMMITED_MESSAGES,
+        header: _jsx(UncommitedMessagesHeader, {}),
+        align: DataTable.RIGHT,
+        render: ({ row }) => row.uncommitedMessages,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.UNREAD_MESSAGES,
+        header: _jsx(UnreadMessagesHeader, {}),
+        align: DataTable.RIGHT,
+        render: ({ row }) => row.unreadMessages,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.START_OFFSET,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.START_OFFSET] })),
+        sortAccessor: (row) => isNumeric(row.startOffset) && Number(row.startOffset),
+        align: DataTable.RIGHT,
+        render: ({ row }) => row.startOffset,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.END_OFFSET,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.END_OFFSET] })),
+        sortAccessor: (row) => isNumeric(row.endOffset) && Number(row.endOffset),
+        align: DataTable.RIGHT,
+        render: ({ row }) => row.endOffset,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.COMMITED_OFFSET,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.COMMITED_OFFSET] })),
+        sortAccessor: (row) => isNumeric(row.commitedOffset) && Number(row.commitedOffset),
+        align: DataTable.RIGHT,
+        render: ({ row }) => row.commitedOffset,
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READ_SESSION_ID,
+        header: _jsx(ReadSessionHeader, {}),
+        align: DataTable.LEFT,
+        render: ({ row }) => row.readSessionId ? (_jsx(EntityStatus, { name: row.readSessionId, showStatus: false, hasClipboardButton: true, className: b('string-with-copy') })) : ('–'),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.READER_NAME,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.READER_NAME] })),
+        align: DataTable.LEFT,
+        render: ({ row }) => row.readerName ? (_jsx(EntityStatus, { name: row.readerName, showStatus: false, hasClipboardButton: true, className: b('string-with-copy') })) : ('–'),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.PARTITION_HOST,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.PARTITION_HOST] })),
+        align: DataTable.LEFT,
+        render: ({ row }) => row.partitionNodeId && row.partitionHost ? (_jsx(EntityStatus, { name: row.partitionHost, path: getDefaultNodePath(row.partitionNodeId), showStatus: false, hasClipboardButton: true, className: b('string-with-copy') })) : ('–'),
+    },
+    {
+        name: PARTITIONS_COLUMNS_IDS.CONNECTION_HOST,
+        header: (_jsx(MultilineHeader, { title: PARTITIONS_COLUMNS_TITILES[PARTITIONS_COLUMNS_IDS.CONNECTION_HOST] })),
+        align: DataTable.LEFT,
+        render: ({ row }) => row.connectionNodeId && row.connectionHost ? (_jsx(EntityStatus, { name: row.connectionHost, path: getDefaultNodePath(row.connectionNodeId), showStatus: false, hasClipboardButton: true, className: b('string-with-copy') })) : ('–'),
+    },
+];
+// Topics without consumers have partitions data with no data corresponding to consumers
+// These columns will be empty and should not be displayed
+export const generalColumns = allColumns.filter((column) => {
+    return generalPartitionColumnsIds.includes(column.name);
+});

package/dist/containers/Tenant/Diagnostics/Partitions/columns/index.d.ts

@@ -0,0 +1 @@
+export * from './columns';

package/dist/containers/Tenant/Diagnostics/Partitions/columns/index.js

@@ -0,0 +1 @@
+export * from './columns';

package/dist/containers/Tenant/Diagnostics/Partitions/i18n/en.json

@@ -1,13 +1,13 @@
 {
-  "lagsPopover.writeLags": "Write lags statistics (time format dd hh:mm:ss)",
-  "lagsPopover.readLags": "Read lags statistics (time format dd hh:mm:ss)",
-  "headers.unread": "End offset - Last read offset",
-  "headers.uncommited": "End offset - Committed offset",
-  "controls.consumerSelector": "Consumer:",
-  "controls.consumerSelector.emptyOption": "No consumer",
-  "controls.partitionSearch": "Partition ID",
-  "controls.generalSearch": "Host, Host ID, Reader, Read Session ID",
-  "table.emptyDataMessage": "No partitions match the current search",
-  "noConsumersMessage.topic": "This topic has no consumers",
-  "noConsumersMessage.stream": "This changefeed has no consumers"
+    "lagsPopover.writeLags": "Write lags statistics (time format dd hh:mm:ss)",
+    "lagsPopover.readLags": "Read lags statistics (time format dd hh:mm:ss)",
+    "headers.unread": "End offset - Last read offset",
+    "headers.uncommited": "End offset - Committed offset",
+    "controls.consumerSelector": "Consumer:",
+    "controls.consumerSelector.emptyOption": "No consumer",
+    "controls.partitionSearch": "Partition ID",
+    "controls.generalSearch": "Host, Host ID, Reader, Read Session ID",
+    "table.emptyDataMessage": "No partitions match the current search",
+    "noConsumersMessage.topic": "This topic has no consumers",
+    "noConsumersMessage.stream": "This changefeed has no consumers"
 }

package/dist/containers/Tenant/Diagnostics/Partitions/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: string, params?: import("@gravity-ui/i18n").Params | undefined) => string;
+export default _default;

package/dist/containers/Tenant/Diagnostics/Partitions/i18n/index.js

@@ -0,0 +1,7 @@
+import { i18n, Lang } from '../../../../../utils/i18n';
+import en from './en.json';
+import ru from './ru.json';
+const COMPONENT = 'ydb-diagnostics-partitions';
+i18n.registerKeyset(Lang.En, COMPONENT, en);
+i18n.registerKeyset(Lang.Ru, COMPONENT, ru);
+export default i18n.keyset(COMPONENT);

package/dist/containers/Tenant/Diagnostics/Partitions/i18n/ru.json

@@ -1,13 +1,13 @@
 {
-  "lagsPopover.writeLags": "Статистика лагов записи (формат времени дд чч:мм:сс)",
-  "lagsPopover.readLags": "Статистика лагов чтения (формат времени дд чч:мм:сс)",
-  "headers.unread": "End offset - Last read offset",
-  "headers.uncommited": "End offset - Committed offset",
-  "controls.consumerSelector": "Читатель:",
-  "controls.consumerSelector.emptyOption": "Нет читателя",
-  "controls.partitionSearch": "Partition ID",
-  "controls.generalSearch": "Host, Host ID, Reader, Read Session ID",
-  "table.emptyDataMessage": "По заданному поиску нет партиций",
-  "noConsumersMessage.topic": "У этого топика нет читателей",
-  "noConsumersMessage.stream": "У этого стрима нет читателей"
+    "lagsPopover.writeLags": "Статистика лагов записи (формат времени дд чч:мм:сс)",
+    "lagsPopover.readLags": "Статистика лагов чтения (формат времени дд чч:мм:сс)",
+    "headers.unread": "End offset - Last read offset",
+    "headers.uncommited": "End offset - Committed offset",
+    "controls.consumerSelector": "Читатель:",
+    "controls.consumerSelector.emptyOption": "Нет читателя",
+    "controls.partitionSearch": "Partition ID",
+    "controls.generalSearch": "Host, Host ID, Reader, Read Session ID",
+    "table.emptyDataMessage": "По заданному поиску нет партиций",
+    "noConsumersMessage.topic": "У этого топика нет читателей",
+    "noConsumersMessage.stream": "У этого стрима нет читателей"
 }

package/dist/containers/Tenant/Diagnostics/Partitions/utils/constants.d.ts

@@ -0,0 +1,54 @@
+export declare const PARTITIONS_COLUMNS_IDS: {
+    readonly PARTITION_ID: "partitionId";
+    readonly STORE_SIZE: "storeSize";
+    readonly WRITE_SPEED: "writeSpeed";
+    readonly READ_SPEED: "readSpeed";
+    readonly WRITE_LAGS: "writeLags";
+    readonly READ_LAGS: "readLags";
+    readonly UNCOMMITED_MESSAGES: "uncommitedMessages";
+    readonly UNREAD_MESSAGES: "unreadMessages";
+    readonly START_OFFSET: "startOffset";
+    readonly END_OFFSET: "endOffset";
+    readonly COMMITED_OFFSET: "commitedOffset";
+    readonly READ_SESSION_ID: "readSessionId";
+    readonly READER_NAME: "readerName";
+    readonly PARTITION_HOST: "partitionHost";
+    readonly CONNECTION_HOST: "connectionHost";
+};
+export declare const PARTITIONS_COLUMNS_TITILES: {
+    readonly partitionId: "Partition ID";
+    readonly storeSize: "Store size";
+    readonly writeSpeed: "Write speed";
+    readonly readSpeed: "Read speed";
+    readonly writeLags: "Write lags, duration";
+    readonly readLags: "Read lags, duration";
+    readonly uncommitedMessages: "Uncommited messages";
+    readonly unreadMessages: "Unread messages";
+    readonly startOffset: "Start offset";
+    readonly endOffset: "End offset";
+    readonly commitedOffset: "Commited offset";
+    readonly readSessionId: "Read session ID";
+    readonly readerName: "Reader name";
+    readonly partitionHost: "Partition host";
+    readonly connectionHost: "Connection host";
+};
+export declare const PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS: {
+    readonly PARTITION_WRITE_LAG: "partitionWriteLag";
+    readonly PARTITION_WRITE_IDLE_TIME: "partitionWriteIdleTime";
+};
+export declare const PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES: {
+    readonly partitionWriteLag: "write lag";
+    readonly partitionWriteIdleTime: "write idle time";
+};
+export declare const PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS: {
+    readonly CONSUMER_WRITE_LAG: "consumerWriteLag";
+    readonly CONSUMER_READ_LAG: "consumerReadLag";
+    readonly CONSUMER_READ_IDLE_TIME: "consumerReadIdleTime";
+};
+export declare const PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES: {
+    readonly consumerWriteLag: "write lag";
+    readonly consumerReadLag: "read lag";
+    readonly consumerReadIdleTime: "read idle time";
+};
+export declare const generalPartitionColumnsIds: ("storeSize" | "endOffset" | "partitionId" | "writeSpeed" | "writeLags" | "startOffset" | "partitionHost")[];
+export declare const allPartitionsColumnsIds: ("storeSize" | "endOffset" | "partitionId" | "writeSpeed" | "readSpeed" | "writeLags" | "readLags" | "uncommitedMessages" | "unreadMessages" | "startOffset" | "commitedOffset" | "readSessionId" | "readerName" | "partitionHost" | "connectionHost")[];

package/dist/containers/Tenant/Diagnostics/Partitions/utils/constants.js

@@ -0,0 +1,64 @@
+export const PARTITIONS_COLUMNS_IDS = {
+    PARTITION_ID: 'partitionId',
+    STORE_SIZE: 'storeSize',
+    WRITE_SPEED: 'writeSpeed',
+    READ_SPEED: 'readSpeed',
+    WRITE_LAGS: 'writeLags',
+    READ_LAGS: 'readLags',
+    UNCOMMITED_MESSAGES: 'uncommitedMessages',
+    UNREAD_MESSAGES: 'unreadMessages',
+    START_OFFSET: 'startOffset',
+    END_OFFSET: 'endOffset',
+    COMMITED_OFFSET: 'commitedOffset',
+    READ_SESSION_ID: 'readSessionId',
+    READER_NAME: 'readerName',
+    PARTITION_HOST: 'partitionHost',
+    CONNECTION_HOST: 'connectionHost',
+};
+export const PARTITIONS_COLUMNS_TITILES = {
+    [PARTITIONS_COLUMNS_IDS.PARTITION_ID]: 'Partition ID',
+    [PARTITIONS_COLUMNS_IDS.STORE_SIZE]: 'Store size',
+    [PARTITIONS_COLUMNS_IDS.WRITE_SPEED]: 'Write speed',
+    [PARTITIONS_COLUMNS_IDS.READ_SPEED]: 'Read speed',
+    [PARTITIONS_COLUMNS_IDS.WRITE_LAGS]: 'Write lags, duration',
+    [PARTITIONS_COLUMNS_IDS.READ_LAGS]: 'Read lags, duration',
+    [PARTITIONS_COLUMNS_IDS.UNCOMMITED_MESSAGES]: 'Uncommited messages',
+    [PARTITIONS_COLUMNS_IDS.UNREAD_MESSAGES]: 'Unread messages',
+    [PARTITIONS_COLUMNS_IDS.START_OFFSET]: 'Start offset',
+    [PARTITIONS_COLUMNS_IDS.END_OFFSET]: 'End offset',
+    [PARTITIONS_COLUMNS_IDS.COMMITED_OFFSET]: 'Commited offset',
+    [PARTITIONS_COLUMNS_IDS.READ_SESSION_ID]: 'Read session ID',
+    [PARTITIONS_COLUMNS_IDS.READER_NAME]: 'Reader name',
+    [PARTITIONS_COLUMNS_IDS.PARTITION_HOST]: 'Partition host',
+    [PARTITIONS_COLUMNS_IDS.CONNECTION_HOST]: 'Connection host',
+};
+export const PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS = {
+    PARTITION_WRITE_LAG: 'partitionWriteLag',
+    PARTITION_WRITE_IDLE_TIME: 'partitionWriteIdleTime',
+};
+export const PARTITIONS_WRITE_LAGS_SUB_COLUMNS_TITLES = {
+    [PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_LAG]: 'write lag',
+    [PARTITIONS_WRITE_LAGS_SUB_COLUMNS_IDS.PARTITION_WRITE_IDLE_TIME]: 'write idle time',
+};
+export const PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS = {
+    CONSUMER_WRITE_LAG: 'consumerWriteLag',
+    CONSUMER_READ_LAG: 'consumerReadLag',
+    CONSUMER_READ_IDLE_TIME: 'consumerReadIdleTime',
+};
+export const PARTITIONS_READ_LAGS_SUB_COLUMNS_TITLES = {
+    [PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_WRITE_LAG]: 'write lag',
+    [PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_LAG]: 'read lag',
+    [PARTITIONS_READ_LAGS_SUB_COLUMNS_IDS.CONSUMER_READ_IDLE_TIME]: 'read idle time',
+};
+// Topics without consumers have partitions data with no data corresponding to consumers
+// These columns will be empty and should not be displayed
+export const generalPartitionColumnsIds = [
+    PARTITIONS_COLUMNS_IDS.PARTITION_ID,
+    PARTITIONS_COLUMNS_IDS.STORE_SIZE,
+    PARTITIONS_COLUMNS_IDS.WRITE_SPEED,
+    PARTITIONS_COLUMNS_IDS.WRITE_LAGS,
+    PARTITIONS_COLUMNS_IDS.START_OFFSET,
+    PARTITIONS_COLUMNS_IDS.END_OFFSET,
+    PARTITIONS_COLUMNS_IDS.PARTITION_HOST,
+];
+export const allPartitionsColumnsIds = Object.values(PARTITIONS_COLUMNS_IDS);

package/dist/containers/Tenant/Diagnostics/Partitions/utils/index.d.ts

@@ -0,0 +1,4 @@
+import type { PreparedPartitionData } from '../../../../../store/reducers/partitions/types';
+import type { NodesMap } from '../../../../../types/store/nodesList';
+import type { PreparedPartitionDataWithHosts } from './types';
+export declare const addHostToPartitions: (partitions?: PreparedPartitionData[], nodesMap?: NodesMap | undefined) => PreparedPartitionDataWithHosts[];

package/dist/containers/Tenant/Diagnostics/Partitions/utils/index.js

@@ -0,0 +1,12 @@
+export const addHostToPartitions = (partitions = [], nodesMap) => {
+    return partitions === null || partitions === void 0 ? void 0 : partitions.map((partition) => {
+        const partitionHost = partition.partitionNodeId && nodesMap
+            ? nodesMap.get(partition.partitionNodeId)
+            : undefined;
+        const connectionHost = partition.connectionNodeId && nodesMap
+            ? nodesMap.get(partition.connectionNodeId)
+            : undefined;
+        return Object.assign(Object.assign({}, partition), { partitionHost,
+            connectionHost });
+    });
+};

package/dist/containers/Tenant/Diagnostics/Partitions/utils/types.d.ts

@@ -0,0 +1,5 @@
+import type { PreparedPartitionData } from '../../../../../store/reducers/partitions/types';
+export interface PreparedPartitionDataWithHosts extends PreparedPartitionData {
+    partitionHost: string | undefined;
+    connectionHost: string | undefined;
+}

package/dist/containers/Tenant/Diagnostics/Partitions/utils/types.js

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

package/dist/containers/Tenant/Diagnostics/Partitions/utils/useGetPartitionsColumns.d.ts

@@ -0,0 +1,3 @@
+import type { Column } from '@gravity-ui/react-data-table';
+import type { PreparedPartitionDataWithHosts } from './types';
+export declare const useGetPartitionsColumns: (selectedConsumer: string | undefined) => [Column<PreparedPartitionDataWithHosts>[], string[]];

package/dist/containers/Tenant/Diagnostics/Partitions/utils/useGetPartitionsColumns.js

@@ -0,0 +1,19 @@
+import { useEffect, useState } from 'react';
+import { allColumns, generalColumns } from '../columns';
+import { allPartitionsColumnsIds, generalPartitionColumnsIds } from './constants';
+// Columns are different for partitions with consumers and without
+export const useGetPartitionsColumns = (selectedConsumer) => {
+    const [columns, setColumns] = useState([]);
+    const [columnsIdsForSelector, setColumnsIdsForSelector] = useState([]);
+    useEffect(() => {
+        if (selectedConsumer) {
+            setColumns(allColumns);
+            setColumnsIdsForSelector(allPartitionsColumnsIds);
+        }
+        else {
+            setColumns(generalColumns);
+            setColumnsIdsForSelector(generalPartitionColumnsIds);
+        }
+    }, [selectedConsumer]);
+    return [columns, columnsIdsForSelector];
+};

package/dist/containers/Tenant/Diagnostics/TenantOverview/DefaultOverviewContent/DefaultOverviewContent.d.ts

@@ -0,0 +1 @@
+export declare const DefaultOverviewContent: () => JSX.Element;

package/dist/containers/Tenant/Diagnostics/TenantOverview/DefaultOverviewContent/DefaultOverviewContent.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { TenantDashboard } from '../TenantDashboard/TenantDashboard';
+import { defaultDashboardConfig } from './defaultDashboardConfig';
+export const DefaultOverviewContent = () => {
+    return _jsx(TenantDashboard, { charts: defaultDashboardConfig });
+};

package/dist/containers/Tenant/Diagnostics/TenantOverview/DefaultOverviewContent/defaultDashboardConfig.d.ts

@@ -0,0 +1,2 @@
+import type { ChartConfig } from '../TenantDashboard/TenantDashboard';
+export declare const defaultDashboardConfig: ChartConfig[];