ydb-embedded-ui 4.33.0 → 5.1.0

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

@@ -0,0 +1,105 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { NodesUptimeFilterValues } from '../../../utils/nodes';
+import { EVersion } from '../../../types/api/compute';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareComputeNodesData, prepareNodesData } from './utils';
+export const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
+const RESET_NODES_STATE = 'nodes/RESET_NODES_STATE';
+const SET_NODES_UPTIME_FILTER = 'nodes/SET_NODES_UPTIME_FILTER';
+const SET_DATA_WAS_NOT_LOADED = 'nodes/SET_DATA_WAS_NOT_LOADED';
+const SET_SEARCH_VALUE = 'nodes/SET_SEARCH_VALUE';
+const SET_SORT = 'nodes/SET_SORT';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    nodesUptimeFilter: NodesUptimeFilterValues.All,
+    searchValue: '',
+};
+const nodes = (state = initialState, action) => {
+    var _a, _b, _c;
+    switch (action.type) {
+        case FETCH_NODES.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_NODES.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: (_a = action.data) === null || _a === void 0 ? void 0 : _a.Nodes, totalNodes: (_b = action.data) === null || _b === void 0 ? void 0 : _b.TotalNodes, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_NODES.FAILURE: {
+            if ((_c = action.error) === null || _c === void 0 ? void 0 : _c.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case RESET_NODES_STATE: {
+            return Object.assign(Object.assign({}, state), { loading: initialState.loading, wasLoaded: initialState.wasLoaded, nodesUptimeFilter: initialState.nodesUptimeFilter, searchValue: initialState.searchValue });
+        }
+        case SET_NODES_UPTIME_FILTER: {
+            return Object.assign(Object.assign({}, state), { nodesUptimeFilter: action.data });
+        }
+        case SET_SEARCH_VALUE: {
+            return Object.assign(Object.assign({}, state), { searchValue: action.data });
+        }
+        case SET_SORT: {
+            return Object.assign(Object.assign({}, state), { sortValue: action.data.sortValue, sortOrder: action.data.sortOrder });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+const concurrentId = 'getNodes';
+export function getNodes(_a) {
+    var { type = 'any', storage = false } = _a, params = __rest(_a, ["type", "storage"]);
+    return createApiRequest({
+        request: window.api.getNodes(Object.assign({ type, storage }, params), { concurrentId }),
+        actions: FETCH_NODES,
+        dataHandler: prepareNodesData,
+    });
+}
+export function getComputeNodes(_a) {
+    var { version = EVersion.v2 } = _a, params = __rest(_a, ["version"]);
+    return createApiRequest({
+        request: window.api.getCompute(Object.assign({ version }, params), { concurrentId }),
+        actions: FETCH_NODES,
+        dataHandler: prepareComputeNodesData,
+    });
+}
+export const resetNodesState = () => {
+    return {
+        type: RESET_NODES_STATE,
+    };
+};
+export const setNodesUptimeFilter = (value) => ({
+    type: SET_NODES_UPTIME_FILTER,
+    data: value,
+});
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export const setSearchValue = (value) => {
+    return {
+        type: SET_SEARCH_VALUE,
+        data: value,
+    };
+};
+export const setSort = (sortParams) => {
+    return {
+        type: SET_SORT,
+        data: sortParams,
+    };
+};
+export default nodes;

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

@@ -0,0 +1,7 @@
+import { Selector } from 'reselect';
+import { NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { NodesPreparedEntity, NodesStateSlice } from './types';
+export declare const filterNodesByUptime: <T extends {
+    StartTime?: string | undefined;
+}>(nodesList: T[] | undefined, nodesUptimeFilter: NodesUptimeFilterValues) => T[];
+export declare const selectFilteredNodes: Selector<NodesStateSlice, NodesPreparedEntity[] | undefined>;

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

@@ -0,0 +1,49 @@
+import { createSelector } from 'reselect';
+import { EFlag } from '../../../types/api/enums';
+import { calcUptimeInSeconds } from '../../../utils/dataFormatters/dataFormatters';
+import { HOUR_IN_SECONDS } from '../../../utils/constants';
+import { NodesUptimeFilterValues } from '../../../utils/nodes';
+import { prepareSearchValue } from '../../../utils/filters';
+import { ProblemFilterValues } from '../settings/settings';
+// ==== Filters ====
+const filterNodesByProblemsStatus = (nodesList = [], problemFilter) => {
+    if (problemFilter === ProblemFilterValues.ALL) {
+        return nodesList;
+    }
+    return nodesList.filter(({ SystemState }) => {
+        return SystemState && SystemState !== EFlag.Green;
+    });
+};
+export const filterNodesByUptime = (nodesList = [], nodesUptimeFilter) => {
+    if (nodesUptimeFilter === NodesUptimeFilterValues.All) {
+        return nodesList;
+    }
+    return nodesList.filter(({ StartTime }) => {
+        return !StartTime || calcUptimeInSeconds(StartTime) < HOUR_IN_SECONDS;
+    });
+};
+const filterNodesBySearchValue = (nodesList = [], searchValue) => {
+    if (!searchValue) {
+        return nodesList;
+    }
+    const re = prepareSearchValue(searchValue);
+    return nodesList.filter((node) => {
+        return node.Host ? re.test(node.Host) || re.test(String(node.NodeId)) : true;
+    });
+};
+// ==== Simple selectors ====
+const selectNodesUptimeFilter = (state) => state.nodes.nodesUptimeFilter;
+const selectSearchValue = (state) => state.nodes.searchValue;
+const selectNodesList = (state) => state.nodes.data;
+// ==== Complex selectors ====
+export const selectFilteredNodes = createSelector([
+    selectNodesList,
+    selectNodesUptimeFilter,
+    selectSearchValue,
+    (state) => state.settings.problemFilter,
+], (nodesList, uptimeFilter, searchValue, problemFilter) => {
+    let result = filterNodesByUptime(nodesList, uptimeFilter);
+    result = filterNodesByProblemsStatus(result, problemFilter);
+    result = filterNodesBySearchValue(result, searchValue);
+    return result;
+});

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

@@ -0,0 +1,78 @@
+import type { OrderType } from '@gravity-ui/react-data-table';
+import type { IResponseError } from '../../../types/api/error';
+import type { TEndpoint, TPoolStats } from '../../../types/api/nodes';
+import type { EVersion, TTabletStateInfo as TComputeTabletStateInfo } from '../../../types/api/compute';
+import type { TTabletStateInfo as TFullTabletStateInfo } from '../../../types/api/tablet';
+import type { EFlag } from '../../../types/api/enums';
+import type { ApiRequestAction } from '../../utils';
+import type { VisibleEntities } from '../storage/types';
+import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
+import { FETCH_NODES, resetNodesState, setDataWasNotLoaded, setNodesUptimeFilter, setSearchValue, setSort } from './nodes';
+export interface NodesPreparedEntity {
+    NodeId: number;
+    Host?: string;
+    SystemState?: EFlag;
+    DC?: string;
+    Rack?: string;
+    Version?: string;
+    TenantName?: string;
+    StartTime?: string;
+    Uptime: string;
+    DisconnectTime?: string;
+    MemoryUsed?: string;
+    MemoryUsedInAlloc?: string;
+    MemoryLimit?: string;
+    SharedCacheUsed?: string;
+    SharedCacheLimit?: string | number;
+    PoolStats?: TPoolStats[];
+    LoadAverage?: number[];
+    Tablets?: TFullTabletStateInfo[] | TComputeTabletStateInfo[];
+    Endpoints?: TEndpoint[];
+    TotalSessions?: number;
+}
+export interface NodesState {
+    loading: boolean;
+    wasLoaded: boolean;
+    nodesUptimeFilter: NodesUptimeFilterValues;
+    searchValue: string;
+    sortValue?: NodesSortValue;
+    sortOrder?: OrderType;
+    data?: NodesPreparedEntity[];
+    totalNodes?: number;
+    error?: IResponseError;
+}
+export declare type NodeType = 'static' | 'dynamic' | 'any';
+export interface NodesSortParams {
+    sortOrder?: OrderType;
+    sortValue?: NodesSortValue;
+}
+export interface NodesGeneralRequestParams extends NodesSortParams {
+    filter?: string;
+    uptime?: number;
+    problems_only?: boolean;
+    offset?: number;
+    limit?: number;
+}
+export interface NodesApiRequestParams extends NodesGeneralRequestParams {
+    path?: string;
+    tenant?: string;
+    type?: NodeType;
+    visibleEntities?: VisibleEntities;
+    storage?: boolean;
+    tablets?: boolean;
+}
+export interface ComputeApiRequestParams extends NodesGeneralRequestParams {
+    path: string;
+    version?: EVersion;
+}
+export interface NodesHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+    TotalNodes: number;
+    FoundNodes?: number;
+}
+declare type NodesApiRequestAction = ApiRequestAction<typeof FETCH_NODES, NodesHandledResponse, IResponseError>;
+export declare type NodesAction = NodesApiRequestAction | (ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setNodesUptimeFilter> | ReturnType<typeof setSearchValue> | ReturnType<typeof setSort> | ReturnType<typeof resetNodesState>);
+export interface NodesStateSlice {
+    nodes: NodesState;
+}
+export {};

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

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

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

@@ -0,0 +1,7 @@
+import type { TComputeInfo, TComputeNodeInfo, TComputeTenantInfo } from '../../../types/api/compute';
+import type { TNodesInfo } from '../../../types/api/nodes';
+import type { NodesHandledResponse, NodesPreparedEntity } from './types';
+export declare const prepareComputeNodes: (nodes?: TComputeNodeInfo[] | undefined, tenants?: TComputeTenantInfo[] | undefined) => NodesPreparedEntity[];
+export declare const prepareComputeNodesData: (data: TComputeInfo) => NodesHandledResponse;
+export declare const prepareNodesData: (data: TNodesInfo) => NodesHandledResponse;
+export declare const getLoadSeverityForNode: (value: number) => "success" | "warning" | "danger" | undefined;

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

@@ -0,0 +1,50 @@
+import { calcUptime } from '../../../utils/dataFormatters/dataFormatters';
+import { generateEvaluator } from '../../../utils/generateEvaluator';
+const prepareComputeNode = (node, tenantName) => {
+    var _a;
+    return Object.assign(Object.assign({}, node), { 
+        // v2 response has tenant name, v1 - doesn't
+        TenantName: (_a = node.Tenant) !== null && _a !== void 0 ? _a : tenantName, SystemState: node === null || node === void 0 ? void 0 : node.Overall, Uptime: calcUptime(node === null || node === void 0 ? void 0 : node.StartTime), DC: node.DataCenter });
+};
+export const prepareComputeNodes = (nodes, tenants) => {
+    var _a;
+    const preparedNodes = [];
+    // First try to parse v2 response in case backend supports it
+    // Else parse v1 response
+    if (nodes) {
+        nodes.forEach((node) => {
+            preparedNodes.push(prepareComputeNode(node));
+        });
+    }
+    else if (tenants) {
+        for (const tenant of tenants) {
+            (_a = tenant.Nodes) === null || _a === void 0 ? void 0 : _a.forEach((node) => {
+                preparedNodes.push(prepareComputeNode(node, tenant.Name));
+            });
+        }
+    }
+    return preparedNodes;
+};
+export const prepareComputeNodesData = (data) => {
+    const preparedNodes = prepareComputeNodes(data.Nodes, data.Tenants);
+    return {
+        Nodes: preparedNodes,
+        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
+        FoundNodes: Number(data.FoundNodes),
+    };
+};
+export const prepareNodesData = (data) => {
+    const rawNodes = data.Nodes || [];
+    const preparedNodes = rawNodes.map((node) => {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // 0 limit means that limit is not set, so it should be undefined
+        const sharedCacheLimit = Number((_a = node.SystemState.SharedCacheStats) === null || _a === void 0 ? void 0 : _a.LimitBytes) || undefined;
+        return Object.assign(Object.assign({}, node.SystemState), { Tablets: node.Tablets, NodeId: node.NodeId, Uptime: calcUptime((_b = node.SystemState) === null || _b === void 0 ? void 0 : _b.StartTime), TenantName: (_d = (_c = node.SystemState) === null || _c === void 0 ? void 0 : _c.Tenants) === null || _d === void 0 ? void 0 : _d[0], DC: (_e = node.SystemState.Location) === null || _e === void 0 ? void 0 : _e.DataCenter, Rack: (_f = node.SystemState.Location) === null || _f === void 0 ? void 0 : _f.Rack, SharedCacheUsed: (_g = node.SystemState.SharedCacheStats) === null || _g === void 0 ? void 0 : _g.UsedBytes, SharedCacheLimit: sharedCacheLimit });
+    });
+    return {
+        Nodes: preparedNodes,
+        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
+        FoundNodes: Number(data.FoundNodes),
+    };
+};
+export const getLoadSeverityForNode = generateEvaluator(60, 80, ['success', 'warning', 'danger']);

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

@@ -0,0 +1,11 @@
+import type { Reducer } from 'redux';
+import type { NodesListState, NodesListAction, NodesListRootStateSlice } from '../../types/store/nodesList';
+export declare const FETCH_NODES_LIST: {
+    readonly REQUEST: "nodesList/FETCH_NODES_LIST_REQUEST";
+    readonly SUCCESS: "nodesList/FETCH_NODES_LIST_SUCCESS";
+    readonly FAILURE: "nodesList/FETCH_NODES_LIST_FAILURE";
+};
+declare const nodesList: Reducer<NodesListState, NodesListAction>;
+export declare function getNodesList(): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export declare const selectNodesMap: (state: NodesListRootStateSlice) => import("../../types/store/nodesList").NodesMap | undefined;
+export default nodesList;

package/dist/store/reducers/nodesList.js

@@ -0,0 +1,27 @@
+import { createRequestActionTypes, createApiRequest } from '../utils';
+import { prepareNodesMap } from '../../utils/nodes';
+export const FETCH_NODES_LIST = createRequestActionTypes('nodesList', 'FETCH_NODES_LIST');
+const initialState = { loading: true, wasLoaded: false, data: [] };
+const nodesList = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_NODES_LIST.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_NODES_LIST.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_NODES_LIST.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        default:
+            return state;
+    }
+};
+export function getNodesList() {
+    return createApiRequest({
+        request: window.api.getNodesList(),
+        actions: FETCH_NODES_LIST,
+    });
+}
+export const selectNodesMap = (state) => prepareNodesMap(state.nodesList.data);
+export default nodesList;

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

@@ -0,0 +1,15 @@
+import type { Reducer } from 'redux';
+import type { OlapStatsAction, OlapStatsState } from '../../types/store/olapStats';
+export declare const FETCH_OLAP_STATS: {
+    readonly REQUEST: "query/SEND_OLAP_STATS_QUERY_REQUEST";
+    readonly SUCCESS: "query/SEND_OLAP_STATS_QUERY_SUCCESS";
+    readonly FAILURE: "query/SEND_OLAP_STATS_QUERY_FAILURE";
+};
+declare const olapStats: Reducer<OlapStatsState, OlapStatsAction>;
+export declare const getOlapStats: ({ path }: {
+    path?: string | undefined;
+}) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<import("../../types/store/query").IQueryResult | undefined>;
+export declare function resetLoadingState(): {
+    readonly type: "olapStats/RESET_LOADING_STATE";
+};
+export default olapStats;

package/dist/store/reducers/olapStats.js

@@ -0,0 +1,48 @@
+import { parseQueryAPIExecuteResponse } from '../../utils/query';
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_OLAP_STATS = createRequestActionTypes('query', 'SEND_OLAP_STATS_QUERY');
+const RESET_LOADING_STATE = 'olapStats/RESET_LOADING_STATE';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+function createOlatStatsQuery(path) {
+    return `SELECT * FROM \`${path}/.sys/primary_index_stats\``;
+}
+const queryAction = 'execute-scan';
+const olapStats = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_OLAP_STATS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, error: undefined });
+        }
+        case FETCH_OLAP_STATS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, error: undefined, wasLoaded: true });
+        }
+        case FETCH_OLAP_STATS.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error || 'Unauthorized', loading: false });
+        }
+        case RESET_LOADING_STATE: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: initialState.wasLoaded });
+        }
+        default:
+            return state;
+    }
+};
+export const getOlapStats = ({ path = '' }) => {
+    return createApiRequest({
+        request: window.api.sendQuery({
+            schema: 'modern',
+            query: createOlatStatsQuery(path),
+            database: path,
+            action: queryAction,
+        }),
+        actions: FETCH_OLAP_STATS,
+        dataHandler: parseQueryAPIExecuteResponse,
+    });
+};
+export function resetLoadingState() {
+    return {
+        type: RESET_LOADING_STATE,
+    };
+}
+export default olapStats;

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

@@ -0,0 +1,24 @@
+import type { Reducer } from 'redux';
+import type { OverviewState, OverviewAction, OverviewHandledResponse } from './types';
+export declare const FETCH_OVERVIEW: {
+    readonly REQUEST: "overview/FETCH_OVERVIEW_REQUEST";
+    readonly SUCCESS: "overview/FETCH_OVERVIEW_SUCCESS";
+    readonly FAILURE: "overview/FETCH_OVERVIEW_FAILURE";
+};
+export declare const initialState: {
+    loading: boolean;
+    wasLoaded: boolean;
+};
+declare const schema: Reducer<OverviewState, OverviewAction>;
+export declare function getOverview({ path }: {
+    path: string;
+}): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<OverviewHandledResponse | undefined>;
+export declare function getOverviewBatched(paths: string[]): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<OverviewHandledResponse | undefined>;
+export declare function setDataWasNotLoaded(): {
+    readonly type: "overview/SET_DATA_WAS_NOT_LOADED";
+};
+export declare const setCurrentOverviewPath: (path?: string | undefined) => {
+    readonly type: "overview/SET_CURRENT_OVERVIEW_PATH";
+    readonly data: string | undefined;
+};
+export default schema;

package/dist/store/reducers/overview/overview.js

@@ -0,0 +1,72 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+export const FETCH_OVERVIEW = createRequestActionTypes('overview', 'FETCH_OVERVIEW');
+const SET_CURRENT_OVERVIEW_PATH = 'overview/SET_CURRENT_OVERVIEW_PATH';
+const SET_DATA_WAS_NOT_LOADED = 'overview/SET_DATA_WAS_NOT_LOADED';
+export const initialState = {
+    loading: true,
+    wasLoaded: false,
+};
+const schema = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_OVERVIEW.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_OVERVIEW.SUCCESS: {
+            if (action.data.data.Path !== state.currentOverviewPath) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: undefined, data: action.data.data, additionalData: action.data.additionalData, loading: false, wasLoaded: true });
+        }
+        case FETCH_OVERVIEW.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_CURRENT_OVERVIEW_PATH: {
+            return Object.assign(Object.assign({}, state), { currentOverviewPath: action.data });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export function getOverview({ path }) {
+    const request = window.api.getDescribe({ path }, { concurrentId: 'getOverview' });
+    return createApiRequest({
+        request,
+        actions: FETCH_OVERVIEW,
+        dataHandler: (data) => {
+            return { data };
+        },
+    });
+}
+export function getOverviewBatched(paths) {
+    const requestArray = paths.map((p) => window.api.getDescribe({ path: p }, { concurrentId: `getOverviewBatched|${p}` }));
+    const request = Promise.all(requestArray);
+    return createApiRequest({
+        request,
+        actions: FETCH_OVERVIEW,
+        dataHandler: ([item, ...rest]) => {
+            return {
+                data: item,
+                additionalData: rest,
+            };
+        },
+    });
+}
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+}
+export const setCurrentOverviewPath = (path) => {
+    return {
+        type: SET_CURRENT_OVERVIEW_PATH,
+        data: path,
+    };
+};
+export default schema;

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

@@ -0,0 +1,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';
+export interface OverviewState {
+    loading: boolean;
+    wasLoaded: boolean;
+    currentOverviewPath?: string;
+    data?: TEvDescribeSchemeResult;
+    additionalData?: TEvDescribeSchemeResult[];
+    error?: IResponseError;
+}
+export interface OverviewHandledResponse {
+    data: TEvDescribeSchemeResult;
+    additionalData?: TEvDescribeSchemeResult[];
+}
+export declare type OverviewAction = ApiRequestAction<typeof FETCH_OVERVIEW, OverviewHandledResponse, IResponseError> | ReturnType<typeof setCurrentOverviewPath> | ReturnType<typeof setDataWasNotLoaded>;

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

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

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

@@ -0,0 +1,17 @@
+import type { Reducer } from 'redux';
+import type { PartitionsAction, PartitionsState } from './types';
+export declare const FETCH_PARTITIONS: {
+    readonly REQUEST: "partitions/FETCH_PARTITIONS_REQUEST";
+    readonly SUCCESS: "partitions/FETCH_PARTITIONS_SUCCESS";
+    readonly FAILURE: "partitions/FETCH_PARTITIONS_FAILURE";
+};
+declare const partitions: Reducer<PartitionsState, PartitionsAction>;
+export declare const setSelectedConsumer: (value: string) => {
+    readonly type: "partitions/SET_SELECTED_CONSUMER";
+    readonly data: 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 default partitions;

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

@@ -0,0 +1,67 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareConsumerPartitions, prepareTopicPartitions } from './utils';
+export const FETCH_PARTITIONS = createRequestActionTypes('partitions', 'FETCH_PARTITIONS');
+const SET_SELECTED_CONSUMER = 'partitions/SET_SELECTED_CONSUMER';
+const SET_DATA_WAS_NOT_LOADED = 'partitions/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    selectedConsumer: '',
+};
+const partitions = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_PARTITIONS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_PARTITIONS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { partitions: action.data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_PARTITIONS.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_SELECTED_CONSUMER: {
+            return Object.assign(Object.assign({}, state), { selectedConsumer: action.data });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export const setSelectedConsumer = (value) => {
+    return {
+        type: SET_SELECTED_CONSUMER,
+        data: value,
+    };
+};
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export function getPartitions(path, consumerName) {
+    if (consumerName) {
+        return createApiRequest({
+            request: window.api.getConsumer({ path, consumer: consumerName }, { concurrentId: 'getPartitions' }),
+            actions: FETCH_PARTITIONS,
+            dataHandler: (data) => {
+                const rawPartitions = data.partitions;
+                return prepareConsumerPartitions(rawPartitions);
+            },
+        });
+    }
+    return createApiRequest({
+        request: window.api.getTopic({ path }, { concurrentId: 'getPartitions' }),
+        actions: FETCH_PARTITIONS,
+        dataHandler: (data) => {
+            const rawPartitions = data.partitions;
+            return prepareTopicPartitions(rawPartitions);
+        },
+    });
+}
+export default partitions;

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

@@ -0,0 +1,32 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { ProcessSpeedStats } from '../../../utils/bytesParsers';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_PARTITIONS, setDataWasNotLoaded, setSelectedConsumer } from './partitions';
+export interface PreparedPartitionData {
+    partitionId: string;
+    storeSize: string;
+    writeSpeed: ProcessSpeedStats;
+    readSpeed?: ProcessSpeedStats;
+    partitionWriteLag: number;
+    partitionWriteIdleTime: number;
+    consumerWriteLag?: number;
+    consumerReadLag?: number;
+    consumerReadIdleTime?: number;
+    uncommitedMessages?: number;
+    unreadMessages?: number;
+    startOffset: string;
+    endOffset: string;
+    commitedOffset?: string;
+    readSessionId?: string;
+    readerName?: string;
+    partitionNodeId: number;
+    connectionNodeId?: number;
+}
+export interface PartitionsState {
+    loading: boolean;
+    wasLoaded: boolean;
+    selectedConsumer: string;
+    partitions?: PreparedPartitionData[];
+    error?: IResponseError;
+}
+export declare type PartitionsAction = ApiRequestAction<typeof FETCH_PARTITIONS, PreparedPartitionData[], IResponseError> | ReturnType<typeof setDataWasNotLoaded> | ReturnType<typeof setSelectedConsumer>;

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

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

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

@@ -0,0 +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;