ydb-embedded-ui 4.32.0 → 5.0.0

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;
+    DataCenter?: 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) });
+};
+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;
+        // 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], SharedCacheUsed: (_e = node.SystemState.SharedCacheStats) === null || _e === void 0 ? void 0 : _e.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;

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

@@ -0,0 +1,41 @@
+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 Object.assign({ 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 Object.assign(Object.assign({}, 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/preview.d.ts

@@ -0,0 +1,23 @@
+import type { ExecuteActions } from '../../types/api/query';
+import type { IQueryResult, QueryErrorResponse } from '../../types/store/query';
+import { ApiRequestAction } from '../utils';
+declare const SEND_QUERY: {
+    readonly REQUEST: "preview/SEND_QUERY_REQUEST";
+    readonly SUCCESS: "preview/SEND_QUERY_SUCCESS";
+    readonly FAILURE: "preview/SEND_QUERY_FAILURE";
+};
+declare const preview: (state: {
+    loading: boolean;
+    wasLoaded: boolean;
+} | undefined, action: ApiRequestAction<typeof SEND_QUERY, IQueryResult, QueryErrorResponse> | ReturnType<typeof setQueryOptions>) => any;
+interface SendQueryParams {
+    query?: string;
+    database?: string;
+    action?: ExecuteActions;
+}
+export declare const sendQuery: ({ query, database, action }: SendQueryParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<IQueryResult | undefined>;
+export declare function setQueryOptions(options: any): {
+    readonly type: "preview/SET_QUERY_OPTIONS";
+    readonly data: any;
+};
+export default preview;