ydb-embedded-ui 5.0.0 → 5.1.0

package/dist/services/api.d.ts

@@ -22,6 +22,7 @@ import type { QuerySyntax } from '../types/store/query';
 import type { ComputeApiRequestParams, NodesApiRequestParams } from '../store/reducers/nodes/types';
 import type { StorageApiRequestParams } from '../store/reducers/storage/types';
 import type { MetaClusters } from '../types/api/meta';
+import type { JsonHotKeysResponse } from '../types/api/hotkeys';
 declare type AxiosOptions = {
     concurrentId?: string;
 };
@@ -89,7 +90,7 @@ export declare class YdbEmbeddedAPI extends AxiosWrapper {
     }, { concurrentId }?: AxiosOptions): Promise<QueryAPIResponse<Action, Schema>>;
     getExplainQuery<Action extends ExplainActions>(query: string, database: string, action: Action, syntax?: QuerySyntax): Promise<ExplainResponse<Action>>;
     getExplainQueryAst(query: string, database: string): Promise<import("../types/api/query").ExplainQueryResponse>;
-    getHotKeys(path: string, enableSampling: boolean): Promise<any>;
+    getHotKeys(path: string, enableSampling: boolean, { concurrentId }?: AxiosOptions): Promise<JsonHotKeysResponse>;
     getHealthcheckInfo(database: string, { concurrentId }?: AxiosOptions): Promise<HealthCheckAPIResponse>;
     killTablet(id?: string): Promise<string>;
     stopTablet(id?: string, hiveId?: string): Promise<string>;

package/dist/services/api.js

@@ -201,11 +201,11 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             timeout: 600000,
         }, {});
     }
-    getHotKeys(path, enableSampling) {
+    getHotKeys(path, enableSampling, { concurrentId } = {}) {
         return this.get(this.getPath('/viewer/json/hotkeys'), {
             path,
             enable_sampling: enableSampling,
-        });
+        }, { concurrentId: concurrentId || 'getHotKeys' });
     }
     getHealthcheckInfo(database, { concurrentId } = {}) {
         return this.get(this.getPath('/viewer/json/healthcheck?merge_records=true'), { tenant: database }, { concurrentId });

package/dist/services/settings.d.ts

@@ -2,7 +2,6 @@ export declare type SettingsObject = Record<string, unknown>;
 /** User settings keys and their default values */
 export declare const DEFAULT_USER_SETTINGS: SettingsObject;
 declare class SettingsManager {
-    constructor();
     /**
      * Returns parsed settings value.
      * If value cannot be parsed, returns initially stored string.

package/dist/services/settings.js

@@ -1,8 +1,7 @@
 import { TENANT_PAGES_IDS } from '../store/reducers/tenant/constants';
-import { ASIDE_HEADER_COMPACT_KEY, CLUSTER_INFO_HIDDEN_KEY, INVERTED_DISKS_KEY, LANGUAGE_KEY, LAST_USED_QUERY_ACTION_KEY, PARTITIONS_HIDDEN_COLUMNS_KEY, QUERY_INITIAL_MODE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, SAVED_QUERIES_KEY, TENANT_INITIAL_PAGE_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, USE_CLUSTER_BALANCER_AS_BACKEND_KEY, } from '../utils/constants';
+import { ASIDE_HEADER_COMPACT_KEY, INVERTED_DISKS_KEY, LANGUAGE_KEY, LAST_USED_QUERY_ACTION_KEY, PARTITIONS_HIDDEN_COLUMNS_KEY, QUERY_INITIAL_MODE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, SAVED_QUERIES_KEY, TENANT_INITIAL_PAGE_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, USE_CLUSTER_BALANCER_AS_BACKEND_KEY, } from '../utils/constants';
 import { QUERY_ACTIONS, QUERY_MODES } from '../utils/query';
 import { parseJson } from '../utils/utils';
-const USE_LOCAL_STORAGE_FOR_SETTINGS_KEY = 'useLocalStorageForSettings';
 /** User settings keys and their default values */
 export const DEFAULT_USER_SETTINGS = {
     [THEME_KEY]: 'system',
@@ -16,13 +15,11 @@ export const DEFAULT_USER_SETTINGS = {
     [LAST_USED_QUERY_ACTION_KEY]: QUERY_ACTIONS.execute,
     [ASIDE_HEADER_COMPACT_KEY]: true,
     [PARTITIONS_HIDDEN_COLUMNS_KEY]: [],
-    [CLUSTER_INFO_HIDDEN_KEY]: true,
     [USE_BACKEND_PARAMS_FOR_TABLES_KEY]: false,
     [USE_CLUSTER_BALANCER_AS_BACKEND_KEY]: true,
 };
 class SettingsManager {
     constructor() {
-        var _a;
         /**
          * Extract values by provided settings object
          */
@@ -52,16 +49,6 @@ class SettingsManager {
             }
             catch (_a) { }
         };
-        // Migrate settings to LS if external API was used before
-        const settingsApi = window.web_version ? (_a = window.systemSettings) === null || _a === void 0 ? void 0 : _a.settingsApi : undefined;
-        const useLocalStorage = this.readUserSettingsValue(USE_LOCAL_STORAGE_FOR_SETTINGS_KEY);
-        if (settingsApi && !useLocalStorage) {
-            const externalUserSettings = window.userSettings;
-            if (externalUserSettings) {
-                Object.entries(externalUserSettings).forEach(([key, value]) => this.setUserSettingsValue(key, value));
-            }
-            this.setUserSettingsValue(USE_LOCAL_STORAGE_FOR_SETTINGS_KEY, true);
-        }
     }
     /**
      * Returns parsed settings value.

package/dist/store/index.d.ts

@@ -73,7 +73,7 @@ export function configureStore({ aRootReducer, singleClusterMode, api, }?: {
         healthcheckInfo: import("../types/store/healthcheck").IHealthcheckInfoState;
         shardsWorkload: import("./reducers/shardsWorkload/types").IShardsWorkloadState;
         tenantOverviewTopShards: import("./reducers/tenantOverview/topShards/types").TenantOverviewTopShardsState;
-        hotKeys: any;
+        hotKeys: import("./reducers/hotKeys/types").HotKeysState;
         authentication: import("./reducers/authentication/types").AuthenticationState;
         header: import("./reducers/header/types").HeaderState;
         saveQuery: string | null;

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

@@ -1,4 +1,5 @@
-import type { Reducer } from 'redux';
+import type { Dispatch, Reducer } from 'redux';
+import { ClusterTab } from '../../../containers/Cluster/utils';
 import type { ClusterAction, ClusterState } from './types';
 export declare const FETCH_CLUSTER: {
     readonly REQUEST: "cluster/FETCH_CLUSTER_REQUEST";
@@ -6,5 +7,10 @@ export declare const FETCH_CLUSTER: {
     readonly FAILURE: "cluster/FETCH_CLUSTER_FAILURE";
 };
 declare const cluster: Reducer<ClusterState, ClusterAction>;
-export declare function getClusterInfo(clusterName?: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export declare function setDefaultClusterTab(tab: ClusterTab): {
+    readonly type: "cluster/SET_DEFAULT_CLUSTER_TAB";
+    readonly data: ClusterTab;
+};
+export declare function updateDefaultClusterTab(tab: string): (dispatch: Dispatch) => void;
+export declare function getClusterInfo(clusterName?: string): (dispatch: Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
 export default cluster;

package/dist/store/reducers/cluster/cluster.js

@@ -1,7 +1,18 @@
+import { DEFAULT_CLUSTER_TAB_KEY } from '../../../utils/constants';
+import { clusterTabsIds, isClusterTab } from '../../../containers/Cluster/utils';
 import { createRequestActionTypes, createApiRequest } from '../../utils';
 import { createSelectClusterGroupsQuery, parseGroupsStatsQueryResponse } from './utils';
+const SET_DEFAULT_CLUSTER_TAB = 'cluster/SET_DEFAULT_CLUSTER_TAB';
 export const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
-const initialState = { loading: true, wasLoaded: false };
+const defaultClusterTabLS = localStorage.getItem(DEFAULT_CLUSTER_TAB_KEY);
+let defaultClusterTab;
+if (isClusterTab(defaultClusterTabLS)) {
+    defaultClusterTab = defaultClusterTabLS;
+}
+else {
+    defaultClusterTab = clusterTabsIds.overview;
+}
+const initialState = { loading: true, wasLoaded: false, defaultClusterTab };
 const cluster = (state = initialState, action) => {
     var _a;
     switch (action.type) {
@@ -18,10 +29,27 @@ const cluster = (state = initialState, action) => {
             }
             return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
         }
+        case SET_DEFAULT_CLUSTER_TAB: {
+            return Object.assign(Object.assign({}, state), { defaultClusterTab: action.data });
+        }
         default:
             return state;
     }
 };
+export function setDefaultClusterTab(tab) {
+    return {
+        type: SET_DEFAULT_CLUSTER_TAB,
+        data: tab,
+    };
+}
+export function updateDefaultClusterTab(tab) {
+    return (dispatch) => {
+        if (isClusterTab(tab)) {
+            localStorage.setItem(DEFAULT_CLUSTER_TAB_KEY, tab);
+            dispatch(setDefaultClusterTab(tab));
+        }
+    };
+}
 export function getClusterInfo(clusterName) {
     async function requestClusterData() {
         // Error here is handled by createApiRequest

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

@@ -1,7 +1,8 @@
+import type { ClusterTab } from '../../../containers/Cluster/utils';
 import type { TClusterInfo } from '../../../types/api/cluster';
 import type { IResponseError } from '../../../types/api/error';
 import type { ApiRequestAction } from '../../utils';
-import { FETCH_CLUSTER } from './cluster';
+import type { FETCH_CLUSTER, setDefaultClusterTab } from './cluster';
 export interface DiskErasureGroupsStats {
     diskType: string;
     erasure: string;
@@ -20,9 +21,10 @@ export interface ClusterState {
     data?: TClusterInfo;
     error?: IResponseError;
     groupsStats?: ClusterGroupsStats;
+    defaultClusterTab: ClusterTab;
 }
 export interface HandledClusterResponse {
     clusterData: TClusterInfo;
     groupsStats: ClusterGroupsStats;
 }
-export declare type ClusterAction = ApiRequestAction<typeof FETCH_CLUSTER, HandledClusterResponse, IResponseError>;
+export declare type ClusterAction = ApiRequestAction<typeof FETCH_CLUSTER, HandledClusterResponse, IResponseError> | ReturnType<typeof setDefaultClusterTab>;

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

@@ -1,17 +1,12 @@
 import type { Reducer } from 'redux';
 import type { Schemas } from '../../types/api/query';
-import type { ExecuteQueryAction, ExecuteQueryState, ExecuteQueryStateSlice, MonacoHotKeyAction, QueryInHistory } from '../../types/store/executeQuery';
+import type { ExecuteQueryAction, ExecuteQueryState, ExecuteQueryStateSlice, QueryInHistory } from '../../types/store/executeQuery';
 import type { QueryRequestParams, QueryMode } from '../../types/store/query';
 export declare const SEND_QUERY: {
     readonly REQUEST: "query/SEND_QUERY_REQUEST";
     readonly SUCCESS: "query/SEND_QUERY_SUCCESS";
     readonly FAILURE: "query/SEND_QUERY_FAILURE";
 };
-export declare const MONACO_HOT_KEY_ACTIONS: {
-    readonly sendQuery: "sendQuery";
-    readonly goPrev: "goPrev";
-    readonly goNext: "goNext";
-};
 declare const executeQuery: Reducer<ExecuteQueryState, ExecuteQueryAction>;
 interface SendQueryParams extends QueryRequestParams {
     mode?: QueryMode;
@@ -39,10 +34,6 @@ export declare const changeUserInput: ({ input }: {
         readonly input: string;
     };
 };
-export declare const setMonacoHotKey: (value: MonacoHotKeyAction | null) => {
-    readonly type: "query/SET_MONACO_HOT_KEY";
-    readonly data: MonacoHotKeyAction | null;
-};
 export declare const setTenantPath: (value: string) => {
     readonly type: "query/SET_TENANT_PATH";
     readonly data: string;

package/dist/store/reducers/executeQuery.js

@@ -9,25 +9,20 @@ const CHANGE_USER_INPUT = 'query/CHANGE_USER_INPUT';
 const SAVE_QUERY_TO_HISTORY = 'query/SAVE_QUERY_TO_HISTORY';
 const GO_TO_PREVIOUS_QUERY = 'query/GO_TO_PREVIOUS_QUERY';
 const GO_TO_NEXT_QUERY = 'query/GO_TO_NEXT_QUERY';
-const SET_MONACO_HOT_KEY = 'query/SET_MONACO_HOT_KEY';
 const SET_TENANT_PATH = 'query/SET_TENANT_PATH';
 const queriesHistoryInitial = settingsManager.readUserSettingsValue(QUERIES_HISTORY_KEY, []);
 const sliceLimit = queriesHistoryInitial.length - MAXIMUM_QUERIES_IN_HISTORY;
-export const MONACO_HOT_KEY_ACTIONS = {
-    sendQuery: 'sendQuery',
-    goPrev: 'goPrev',
-    goNext: 'goNext',
-};
 const initialState = {
     loading: false,
     input: '',
     history: {
-        queries: queriesHistoryInitial.slice(sliceLimit < 0 ? 0 : sliceLimit),
+        queries: queriesHistoryInitial
+            .slice(sliceLimit < 0 ? 0 : sliceLimit)
+            .map(getQueryInHistory),
         currentIndex: queriesHistoryInitial.length > MAXIMUM_QUERIES_IN_HISTORY
             ? MAXIMUM_QUERIES_IN_HISTORY - 1
             : queriesHistoryInitial.length - 1,
     },
-    monacoHotKey: null,
 };
 const executeQuery = (state = initialState, action) => {
     switch (action.type) {
@@ -56,16 +51,23 @@ const executeQuery = (state = initialState, action) => {
                 } });
         }
         case GO_TO_PREVIOUS_QUERY: {
-            const newCurrentIndex = Math.max(0, state.history.currentIndex - 1);
-            return Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, state.history), { currentIndex: newCurrentIndex }) });
+            const currentIndex = state.history.currentIndex;
+            if (currentIndex <= 0) {
+                return state;
+            }
+            const newCurrentIndex = currentIndex - 1;
+            const query = state.history.queries[newCurrentIndex];
+            return Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, state.history), { currentIndex: newCurrentIndex }), input: query.queryText });
         }
         case GO_TO_NEXT_QUERY: {
             const lastIndexInHistory = state.history.queries.length - 1;
-            const newCurrentIndex = Math.min(lastIndexInHistory, state.history.currentIndex + 1);
-            return Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, state.history), { currentIndex: newCurrentIndex }) });
-        }
-        case SET_MONACO_HOT_KEY: {
-            return Object.assign(Object.assign({}, state), { monacoHotKey: action.data });
+            const currentIndex = state.history.currentIndex;
+            if (currentIndex >= lastIndexInHistory) {
+                return state;
+            }
+            const newCurrentIndex = currentIndex + 1;
+            const query = state.history.queries[newCurrentIndex];
+            return Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, state.history), { currentIndex: newCurrentIndex }), input: query.queryText });
         }
         case SET_TENANT_PATH: {
             return Object.assign(Object.assign({}, state), { tenantPath: action.data });
@@ -119,12 +121,6 @@ export const changeUserInput = ({ input }) => {
         data: { input },
     };
 };
-export const setMonacoHotKey = (value) => {
-    return {
-        type: SET_MONACO_HOT_KEY,
-        data: value,
-    };
-};
 export const setTenantPath = (value) => {
     return {
         type: SET_TENANT_PATH,
@@ -132,13 +128,14 @@ export const setTenantPath = (value) => {
     };
 };
 export const selectQueriesHistory = (state) => {
-    return state.executeQuery.history.queries.map((rawQuery) => {
-        if (typeof rawQuery === 'string') {
-            return {
-                queryText: rawQuery,
-            };
-        }
-        return rawQuery;
-    });
+    return state.executeQuery.history.queries;
 };
+function getQueryInHistory(rawQuery) {
+    if (typeof rawQuery === 'string') {
+        return {
+            queryText: rawQuery,
+        };
+    }
+    return rawQuery;
+}
 export default executeQuery;

package/dist/store/reducers/executeTopQueries/executeTopQueries.js

@@ -19,7 +19,8 @@ SELECT
     EndTime,
     ReadRows,
     ReadBytes,
-    UserSID
+    UserSID,
+    Duration
 FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
 WHERE ${filterConditions || 'true'}
 `;

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

@@ -1,6 +1,8 @@
+const endTimeColumn = 'EndTime';
+const intervalEndColumn = 'IntervalEnd';
 const getMaxIntervalSubquery = (path) => `(
     SELECT
-        MAX(IntervalEnd)
+        MAX(${intervalEndColumn})
     FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
 )`;
 export function getFiltersConditions(path, filters) {
@@ -12,13 +14,14 @@ export function getFiltersConditions(path, filters) {
         // 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()}')`);
+        conditions.push(`${endTimeColumn} ${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()}')`);
+        conditions.push(`${endTimeColumn} <= Timestamp('${new Date(filters.to).toISOString()}')`);
     }
+    // If there is no filters, return queries, that were executed in the last hour
     if (!(filters === null || filters === void 0 ? void 0 : filters.from) && !(filters === null || filters === void 0 ? void 0 : filters.to)) {
-        conditions.push(`IntervalEnd IN ${getMaxIntervalSubquery(path)}`);
+        conditions.push(`${intervalEndColumn} IN ${getMaxIntervalSubquery(path)}`);
     }
     if (filters === null || filters === void 0 ? void 0 : filters.text) {
         conditions.push(`QueryText ILIKE '%${filters.text}%'`);

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

@@ -0,0 +1,25 @@
+import type { Reducer } from 'redux';
+import type { JsonHotKeysResponse } from '../../../types/api/hotkeys';
+import type { IResponseError } from '../../../types/api/error';
+import type { HotKeysAction, HotKeysState } from './types';
+export declare const FETCH_HOT_KEYS: {
+    readonly REQUEST: "hot_keys/FETCH_HOT_KEYS_REQUEST";
+    readonly SUCCESS: "hot_keys/FETCH_HOT_KEYS_SUCCESS";
+    readonly FAILURE: "hot_keys/FETCH_HOT_KEYS_FAILURE";
+};
+declare const hotKeys: Reducer<HotKeysState, HotKeysAction>;
+export declare function setHotKeysDataWasNotLoaded(): {
+    readonly type: "hot_keys/SET_DATA_WAS_NOT_LOADED";
+};
+export declare function setHotKeysLoading(): {
+    readonly type: "hot_keys/FETCH_HOT_KEYS_REQUEST";
+};
+export declare function setHotKeysData(data: JsonHotKeysResponse): {
+    readonly type: "hot_keys/FETCH_HOT_KEYS_SUCCESS";
+    readonly data: JsonHotKeysResponse;
+};
+export declare function setHotKeysError(error: IResponseError): {
+    readonly type: "hot_keys/FETCH_HOT_KEYS_FAILURE";
+    readonly error: IResponseError<unknown>;
+};
+export default hotKeys;

package/dist/store/reducers/hotKeys/hotKeys.js

@@ -0,0 +1,49 @@
+import { createRequestActionTypes } from '../../utils';
+export const FETCH_HOT_KEYS = createRequestActionTypes('hot_keys', 'FETCH_HOT_KEYS');
+const SET_DATA_WAS_NOT_LOADED = 'hot_keys/SET_DATA_WAS_NOT_LOADED';
+const initialState = { loading: true, wasLoaded: false, data: null };
+const hotKeys = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_HOT_KEYS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_HOT_KEYS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data.hotkeys, loading: false, error: undefined, wasLoaded: true });
+        }
+        case FETCH_HOT_KEYS.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_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export function setHotKeysDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+}
+export function setHotKeysLoading() {
+    return {
+        type: FETCH_HOT_KEYS.REQUEST,
+    };
+}
+export function setHotKeysData(data) {
+    return {
+        type: FETCH_HOT_KEYS.SUCCESS,
+        data: data,
+    };
+}
+export function setHotKeysError(error) {
+    return {
+        type: FETCH_HOT_KEYS.FAILURE,
+        error: error,
+    };
+}
+export default hotKeys;

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

@@ -0,0 +1,10 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { HotKey } from '../../../types/api/hotkeys';
+import type { setHotKeysData, setHotKeysDataWasNotLoaded, setHotKeysError, setHotKeysLoading } from './hotKeys';
+export interface HotKeysState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data: null | HotKey[];
+    error?: IResponseError;
+}
+export declare type HotKeysAction = ReturnType<typeof setHotKeysDataWasNotLoaded> | ReturnType<typeof setHotKeysLoading> | ReturnType<typeof setHotKeysData> | ReturnType<typeof setHotKeysError>;

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

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

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

@@ -89,11 +89,7 @@ export declare const rootReducer: {
     healthcheckInfo: import("redux").Reducer<import("../../types/store/healthcheck").IHealthcheckInfoState, import("../../types/store/healthcheck").IHealthCheckInfoAction>;
     shardsWorkload: import("redux").Reducer<import("./shardsWorkload/types").IShardsWorkloadState, import("./shardsWorkload/types").IShardsWorkloadAction>;
     tenantOverviewTopShards: import("redux").Reducer<import("./tenantOverview/topShards/types").TenantOverviewTopShardsState, import("./tenantOverview/topShards/types").TenantOverviewTopShardsAction>;
-    hotKeys: (state: {
-        loading: boolean;
-        data: {};
-        wasLoaded: boolean;
-    } | undefined, action: any) => any;
+    hotKeys: import("redux").Reducer<import("./hotKeys/types").HotKeysState, import("./hotKeys/types").HotKeysAction>;
     authentication: import("redux").Reducer<import("./authentication/types").AuthenticationState, import("./authentication/types").AuthenticationAction>;
     header: import("redux").Reducer<import("./header/types").HeaderState, {
         readonly type: "header/SET_HEADER_BREADCRUMBS";
@@ -187,7 +183,7 @@ declare const combinedReducer: import("redux").Reducer<import("redux").CombinedS
     healthcheckInfo: import("../../types/store/healthcheck").IHealthcheckInfoState;
     shardsWorkload: import("./shardsWorkload/types").IShardsWorkloadState;
     tenantOverviewTopShards: import("./tenantOverview/topShards/types").TenantOverviewTopShardsState;
-    hotKeys: any;
+    hotKeys: import("./hotKeys/types").HotKeysState;
     authentication: import("./authentication/types").AuthenticationState;
     header: import("./header/types").HeaderState;
     saveQuery: string | null;

package/dist/store/reducers/index.js

@@ -34,7 +34,7 @@ import executeTopTables from './tenantOverview/executeTopTables/executeTopTables
 import healthcheckInfo from './healthcheckInfo';
 import shardsWorkload from './shardsWorkload/shardsWorkload';
 import { tenantOverviewTopShards } from './tenantOverview/topShards/tenantOverviewTopShards';
-import hotKeys from './hotKeys';
+import hotKeys from './hotKeys/hotKeys';
 import olapStats from './olapStats';
 import authentication from './authentication/authentication';
 import header from './header/header';

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

@@ -11,7 +11,7 @@ export declare const FETCH_NODE_STRUCTURE: {
     readonly FAILURE: "node/FETCH_NODE_STRUCTURE_FAILURE";
 };
 declare const node: Reducer<NodeState, NodeAction>;
-export declare const getNodeInfo: (id: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export declare const getNodeInfo: (id: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("./types").PreparedNode | undefined>;
 export declare const getNodeStructure: (nodeId: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
 export declare function resetNode(): {
     readonly type: "node/RESET_NODE";

package/dist/store/reducers/node/node.js

@@ -1,4 +1,5 @@
 import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareNodeData } from './utils';
 export const FETCH_NODE = createRequestActionTypes('node', 'FETCH_NODE');
 export const FETCH_NODE_STRUCTURE = createRequestActionTypes('node', 'FETCH_NODE_STRUCTURE');
 const RESET_NODE = 'node/RESET_NODE';
@@ -41,6 +42,7 @@ export const getNodeInfo = (id) => {
     return createApiRequest({
         request: window.api.getNodeInfo(id),
         actions: FETCH_NODE,
+        dataHandler: prepareNodeData,
     });
 };
 export const getNodeStructure = (nodeId) => {

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

@@ -1,6 +1,6 @@
 import { createSelector } from 'reselect';
 import { stringifyVdiskId } from '../../../utils/dataFormatters/dataFormatters';
-const selectNodeId = (state) => { var _a, _b, _c; return (_c = (_b = (_a = state.node) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.SystemStateInfo) === null || _c === void 0 ? void 0 : _c[0].NodeId; };
+const selectNodeId = (state) => { var _a, _b; return (_b = (_a = state.node) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.NodeId; };
 const selectRawNodeStructure = (state) => { var _a; return (_a = state.node) === null || _a === void 0 ? void 0 : _a.nodeStructure; };
 export const selectNodeStructure = createSelector([selectNodeId, selectRawNodeStructure], (nodeId, storageInfo) => {
     const pools = storageInfo === null || storageInfo === void 0 ? void 0 : storageInfo.StoragePools;

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

@@ -1,7 +1,7 @@
 import type { IResponseError } from '../../../types/api/error';
+import type { TSystemStateInfo } from '../../../types/api/nodes';
 import type { TPDiskStateInfo } from '../../../types/api/pdisk';
 import type { TStorageInfo } from '../../../types/api/storage';
-import type { TEvSystemStateResponse } from '../../../types/api/systemState';
 import type { TVDiskStateInfo } from '../../../types/api/vdisk';
 import type { ApiRequestAction } from '../../utils';
 import { FETCH_NODE, FETCH_NODE_STRUCTURE, resetNode } from './node';
@@ -17,8 +17,12 @@ export interface PreparedStructurePDisk extends TPDiskStateInfo {
     vDisks: PreparedStructureVDisk[];
 }
 export declare type PreparedNodeStructure = Record<string, PreparedStructurePDisk>;
+export interface PreparedNode extends TSystemStateInfo {
+    DC?: string;
+    Rack?: string;
+}
 export interface NodeState {
-    data: TEvSystemStateResponse;
+    data: PreparedNode;
     loading: boolean;
     wasLoaded: boolean;
     error?: IResponseError;
@@ -27,7 +31,7 @@ export interface NodeState {
     wasLoadedStructure: boolean;
     errorStructure?: IResponseError;
 }
-export declare type NodeAction = ApiRequestAction<typeof FETCH_NODE, TEvSystemStateResponse, IResponseError> | ApiRequestAction<typeof FETCH_NODE_STRUCTURE, TStorageInfo, IResponseError> | ReturnType<typeof resetNode>;
+export declare type NodeAction = ApiRequestAction<typeof FETCH_NODE, PreparedNode, IResponseError> | ApiRequestAction<typeof FETCH_NODE_STRUCTURE, TStorageInfo, IResponseError> | ReturnType<typeof resetNode>;
 export interface NodeStateSlice {
     node: NodeState;
 }

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

@@ -0,0 +1,3 @@
+import type { TEvSystemStateResponse } from '../../../types/api/systemState';
+import type { PreparedNode } from './types';
+export declare const prepareNodeData: (data: TEvSystemStateResponse) => PreparedNode;

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

@@ -0,0 +1,8 @@
+export const prepareNodeData = (data) => {
+    var _a, _b, _c;
+    if (!((_a = data.SystemStateInfo) === null || _a === void 0 ? void 0 : _a.length)) {
+        return {};
+    }
+    const nodeData = data.SystemStateInfo[0];
+    return Object.assign(Object.assign({}, nodeData), { DC: (_b = nodeData.Location) === null || _b === void 0 ? void 0 : _b.DataCenter, Rack: (_c = nodeData.Location) === null || _c === void 0 ? void 0 : _c.Rack });
+};

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

@@ -12,7 +12,7 @@ export interface NodesPreparedEntity {
     NodeId: number;
     Host?: string;
     SystemState?: EFlag;
-    DataCenter?: string;
+    DC?: string;
     Rack?: string;
     Version?: string;
     TenantName?: string;

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

@@ -4,7 +4,7 @@ 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) });
+        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;
@@ -36,10 +36,10 @@ export const prepareComputeNodesData = (data) => {
 export const prepareNodesData = (data) => {
     const rawNodes = data.Nodes || [];
     const preparedNodes = rawNodes.map((node) => {
-        var _a, _b, _c, _d, _e;
+        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], SharedCacheUsed: (_e = node.SystemState.SharedCacheStats) === null || _e === void 0 ? void 0 : _e.UsedBytes, SharedCacheLimit: sharedCacheLimit });
+        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,

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

@@ -16,6 +16,8 @@ export interface PreparedStorageNode extends TSystemStateInfo {
     NodeId: number;
     PDisks: TPDiskStateInfo[] | undefined;
     VDisks: TVDiskStateInfo[] | undefined;
+    DC?: string;
+    Rack?: string;
     Missing: number;
     Uptime: string;
 }

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

@@ -85,7 +85,7 @@ export const prepareStorageGroups = (StorageGroups, StoragePools) => {
 };
 // ==== Prepare nodes ====
 const prepareStorageNodeData = (node) => {
-    var _a, _b;
+    var _a, _b, _c, _d;
     const systemState = (_a = node.SystemState) !== null && _a !== void 0 ? _a : {};
     const missing = ((_b = node.PDisks) === null || _b === void 0 ? void 0 : _b.filter((pDisk) => {
         return pDisk.State !== TPDiskState.Normal;
@@ -93,8 +93,8 @@ const prepareStorageNodeData = (node) => {
     return {
         NodeId: node.NodeId,
         SystemState: systemState.SystemState,
-        DataCenter: systemState.DataCenter,
-        Rack: systemState.Rack,
+        DC: (_c = systemState.Location) === null || _c === void 0 ? void 0 : _c.DataCenter,
+        Rack: (_d = systemState.Location) === null || _d === void 0 ? void 0 : _d.Rack,
         Host: systemState.Host,
         Endpoints: systemState.Endpoints,
         Uptime: calcUptime(systemState.StartTime),