ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/store/reducers/tenantOverview/executeTopTables/executeTopTables.js

@@ -0,0 +1,61 @@
+import { TENANT_OVERVIEW_TABLES_LIMIT } from '../../../../utils/constants';
+import { parseQueryAPIExecuteResponse } from '../../../../utils/query';
+import { createApiRequest, createRequestActionTypes } from '../../../utils';
+export const FETCH_TOP_TABLES = createRequestActionTypes('top-tables', 'FETCH_TOP_TABLES');
+const SET_DATA_WAS_NOT_LOADED = 'top-tables/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+const getQueryText = (path) => {
+    return `
+SELECT
+    Path, SUM(DataSize) as Size
+FROM \`${path}/.sys/partition_stats\`
+GROUP BY Path
+    ORDER BY Size DESC
+    LIMIT ${TENANT_OVERVIEW_TABLES_LIMIT}
+`;
+};
+const executeTopTables = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_TOP_TABLES.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, error: undefined });
+        }
+        case FETCH_TOP_TABLES.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, error: undefined, wasLoaded: true });
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TOP_TABLES.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error || 'Unauthorized', loading: false });
+        }
+        case SET_DATA_WAS_NOT_LOADED:
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        default:
+            return state;
+    }
+};
+export const fetchTopTables = (database) => {
+    return createApiRequest({
+        request: window.api.sendQuery({
+            schema: 'modern',
+            query: getQueryText(database),
+            database,
+            action: 'execute-scan',
+        }, {
+            concurrentId: 'executeTopTables',
+        }),
+        actions: FETCH_TOP_TABLES,
+        dataHandler: parseQueryAPIExecuteResponse,
+    });
+};
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+}
+export default executeTopTables;

package/dist/store/reducers/tenantOverview/executeTopTables/types.d.ts

@@ -0,0 +1,10 @@
+import type { IQueryResult, QueryErrorResponse } from '../../../../types/store/query';
+import type { ApiRequestAction } from '../../../utils';
+import { FETCH_TOP_TABLES, setDataWasNotLoaded } from './executeTopTables';
+export interface TopTablesState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: IQueryResult;
+    error?: QueryErrorResponse;
+}
+export declare type TopTablesAction = ApiRequestAction<typeof FETCH_TOP_TABLES, IQueryResult, QueryErrorResponse> | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/tenantOverview/executeTopTables/types.js

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

package/dist/store/reducers/tenantOverview/topNodesByCpu/topNodesByCpu.d.ts

@@ -0,0 +1,14 @@
+import type { Reducer } from 'redux';
+import type { NodesApiRequestParams } from '../../nodes/types';
+import type { TopNodesByCpuAction, TopNodesByCpuState, TopPoolsStateSlice } from './types';
+export declare const FETCH_TOP_NODES_BY_CPU: {
+    readonly REQUEST: "topNodesByCpu/FETCH_TOP_NODES_BY_CPU_REQUEST";
+    readonly SUCCESS: "topNodesByCpu/FETCH_TOP_NODES_BY_CPU_SUCCESS";
+    readonly FAILURE: "topNodesByCpu/FETCH_TOP_NODES_BY_CPU_FAILURE";
+};
+export declare const topNodesByCpu: Reducer<TopNodesByCpuState, TopNodesByCpuAction>;
+export declare function getTopNodesByCpu({ type, sortOrder, sortValue, limit, ...params }: NodesApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("../..").GetState) => Promise<import("../../nodes/types").NodesHandledResponse | undefined>;
+export declare const selectTopNodesByCpu: (state: TopPoolsStateSlice) => import("../../nodes/types").NodesPreparedEntity[] | undefined;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "topNodesByCpu/SET_DATA_WAS_NOT_LOADED";
+};

package/dist/store/reducers/tenantOverview/topNodesByCpu/topNodesByCpu.js

@@ -0,0 +1,57 @@
+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 { TENANT_OVERVIEW_TABLES_LIMIT } from '../../../../utils/constants';
+import { createApiRequest, createRequestActionTypes } from '../../../utils';
+import { prepareNodesData } from '../../nodes/utils';
+export const FETCH_TOP_NODES_BY_CPU = createRequestActionTypes('topNodesByCpu', 'FETCH_TOP_NODES_BY_CPU');
+const SET_DATA_WAS_NOT_LOADED = 'topNodesByCpu/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+export const topNodesByCpu = (state = initialState, action) => {
+    var _a, _b;
+    switch (action.type) {
+        case FETCH_TOP_NODES_BY_CPU.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TOP_NODES_BY_CPU.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: (_a = action.data) === null || _a === void 0 ? void 0 : _a.Nodes, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_TOP_NODES_BY_CPU.FAILURE: {
+            if ((_b = action.error) === null || _b === void 0 ? void 0 : _b.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;
+    }
+};
+const concurrentId = 'getTopNodeByCpu';
+export function getTopNodesByCpu(_a) {
+    var { type = 'any', sortOrder = -1, sortValue = 'CPU', limit = TENANT_OVERVIEW_TABLES_LIMIT } = _a, params = __rest(_a, ["type", "sortOrder", "sortValue", "limit"]);
+    return createApiRequest({
+        request: window.api.getNodes(Object.assign({ type, sortOrder, sortValue, limit }, params), { concurrentId }),
+        actions: FETCH_TOP_NODES_BY_CPU,
+        dataHandler: prepareNodesData,
+    });
+}
+export const selectTopNodesByCpu = (state) => state.topNodesByCpu.data;
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};

package/dist/store/reducers/tenantOverview/topNodesByCpu/types.d.ts

@@ -0,0 +1,19 @@
+import type { IResponseError } from '../../../../types/api/error';
+import type { ApiRequestAction } from '../../../utils';
+import type { NodesPreparedEntity } from '../../nodes/types';
+import { FETCH_TOP_NODES_BY_CPU, setDataWasNotLoaded } from './topNodesByCpu';
+export interface TopNodesByCpuState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: NodesPreparedEntity[];
+    error?: IResponseError;
+}
+export interface TopNodesByCpuHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+}
+declare type TopNodesByCpuApiRequestAction = ApiRequestAction<typeof FETCH_TOP_NODES_BY_CPU, TopNodesByCpuHandledResponse, IResponseError>;
+export declare type TopNodesByCpuAction = TopNodesByCpuApiRequestAction | ReturnType<typeof setDataWasNotLoaded>;
+export interface TopPoolsStateSlice {
+    topNodesByCpu: TopNodesByCpuState;
+}
+export {};

package/dist/store/reducers/tenantOverview/topNodesByCpu/types.js

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

package/dist/store/reducers/tenantOverview/topNodesByLoad/topNodesByLoad.d.ts

@@ -0,0 +1,14 @@
+import type { Reducer } from 'redux';
+import type { NodesApiRequestParams } from '../../nodes/types';
+import type { TopNodesByLoadAction, TopNodesByLoadState, TopNodesByLoadStateSlice } from './types';
+export declare const FETCH_TOP_NODES_BY_LOAD: {
+    readonly REQUEST: "topNodesByLoad/FETCH_TOP_NODES_BY_LOAD_REQUEST";
+    readonly SUCCESS: "topNodesByLoad/FETCH_TOP_NODES_BY_LOAD_SUCCESS";
+    readonly FAILURE: "topNodesByLoad/FETCH_TOP_NODES_BY_LOAD_FAILURE";
+};
+export declare const topNodesByLoad: Reducer<TopNodesByLoadState, TopNodesByLoadAction>;
+export declare function getTopNodesByLoad({ type, sortOrder, sortValue, limit, ...params }: NodesApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("../..").GetState) => Promise<import("../../nodes/types").NodesHandledResponse | undefined>;
+export declare const selectTopNodesByLoad: (state: TopNodesByLoadStateSlice) => import("../../nodes/types").NodesPreparedEntity[] | undefined;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "topNodesByLoad/SET_DATA_WAS_NOT_LOADED";
+};

package/dist/store/reducers/tenantOverview/topNodesByLoad/topNodesByLoad.js

@@ -0,0 +1,57 @@
+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 { TENANT_OVERVIEW_TABLES_LIMIT } from '../../../../utils/constants';
+import { createApiRequest, createRequestActionTypes } from '../../../utils';
+import { prepareNodesData } from '../../nodes/utils';
+export const FETCH_TOP_NODES_BY_LOAD = createRequestActionTypes('topNodesByLoad', 'FETCH_TOP_NODES_BY_LOAD');
+const SET_DATA_WAS_NOT_LOADED = 'topNodesByLoad/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+export const topNodesByLoad = (state = initialState, action) => {
+    var _a, _b;
+    switch (action.type) {
+        case FETCH_TOP_NODES_BY_LOAD.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TOP_NODES_BY_LOAD.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: (_a = action.data) === null || _a === void 0 ? void 0 : _a.Nodes, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_TOP_NODES_BY_LOAD.FAILURE: {
+            if ((_b = action.error) === null || _b === void 0 ? void 0 : _b.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;
+    }
+};
+const concurrentId = 'getTopNodesByLoad';
+export function getTopNodesByLoad(_a) {
+    var { type = 'any', sortOrder = -1, sortValue = 'LoadAverage', limit = TENANT_OVERVIEW_TABLES_LIMIT } = _a, params = __rest(_a, ["type", "sortOrder", "sortValue", "limit"]);
+    return createApiRequest({
+        request: window.api.getNodes(Object.assign({ type, sortOrder, sortValue, limit }, params), { concurrentId }),
+        actions: FETCH_TOP_NODES_BY_LOAD,
+        dataHandler: prepareNodesData,
+    });
+}
+export const selectTopNodesByLoad = (state) => state.topNodesByLoad.data;
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};

package/dist/store/reducers/tenantOverview/topNodesByLoad/types.d.ts

@@ -0,0 +1,19 @@
+import type { IResponseError } from '../../../../types/api/error';
+import type { ApiRequestAction } from '../../../utils';
+import type { NodesPreparedEntity } from '../../nodes/types';
+import { FETCH_TOP_NODES_BY_LOAD, setDataWasNotLoaded } from './topNodesByLoad';
+export interface TopNodesByLoadState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: NodesPreparedEntity[];
+    error?: IResponseError;
+}
+export interface TopNodesByLoadHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+}
+declare type TopNodesByLoadApiRequestAction = ApiRequestAction<typeof FETCH_TOP_NODES_BY_LOAD, TopNodesByLoadHandledResponse, IResponseError>;
+export declare type TopNodesByLoadAction = TopNodesByLoadApiRequestAction | ReturnType<typeof setDataWasNotLoaded>;
+export interface TopNodesByLoadStateSlice {
+    topNodesByLoad: TopNodesByLoadState;
+}
+export {};

package/dist/store/reducers/tenantOverview/topNodesByLoad/types.js

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

package/dist/store/reducers/tenantOverview/topNodesByMemory/topNodesByMemory.d.ts

@@ -0,0 +1,14 @@
+import type { Reducer } from 'redux';
+import type { NodesApiRequestParams } from '../../nodes/types';
+import type { TopNodesByMemoryAction, TopNodesByMemoryState, TopNodesByMemorySlice } from './types';
+export declare const FETCH_TOP_NODES_BY_MEMORY: {
+    readonly REQUEST: "topNodesByMemory/FETCH_TOP_NODES_BY_MEMORY_REQUEST";
+    readonly SUCCESS: "topNodesByMemory/FETCH_TOP_NODES_BY_MEMORY_SUCCESS";
+    readonly FAILURE: "topNodesByMemory/FETCH_TOP_NODES_BY_MEMORY_FAILURE";
+};
+export declare const topNodesByMemory: Reducer<TopNodesByMemoryState, TopNodesByMemoryAction>;
+export declare function getTopNodesByMemory({ type, sortOrder, sortValue, limit, ...params }: NodesApiRequestParams): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("../..").GetState) => Promise<import("../../nodes/types").NodesHandledResponse | undefined>;
+export declare const selectTopNodesByMemory: (state: TopNodesByMemorySlice) => import("../../nodes/types").NodesPreparedEntity[] | undefined;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "topNodesByMemory/SET_DATA_WAS_NOT_LOADED";
+};

package/dist/store/reducers/tenantOverview/topNodesByMemory/topNodesByMemory.js

@@ -0,0 +1,57 @@
+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 { TENANT_OVERVIEW_TABLES_LIMIT } from '../../../../utils/constants';
+import { createApiRequest, createRequestActionTypes } from '../../../utils';
+import { prepareNodesData } from '../../nodes/utils';
+export const FETCH_TOP_NODES_BY_MEMORY = createRequestActionTypes('topNodesByMemory', 'FETCH_TOP_NODES_BY_MEMORY');
+const SET_DATA_WAS_NOT_LOADED = 'topNodesByMemory/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+export const topNodesByMemory = (state = initialState, action) => {
+    var _a, _b;
+    switch (action.type) {
+        case FETCH_TOP_NODES_BY_MEMORY.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TOP_NODES_BY_MEMORY.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: (_a = action.data) === null || _a === void 0 ? void 0 : _a.Nodes, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_TOP_NODES_BY_MEMORY.FAILURE: {
+            if ((_b = action.error) === null || _b === void 0 ? void 0 : _b.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;
+    }
+};
+const concurrentId = 'getTopNodeByMemory';
+export function getTopNodesByMemory(_a) {
+    var { type = 'any', sortOrder = -1, sortValue = 'Memory', limit = TENANT_OVERVIEW_TABLES_LIMIT } = _a, params = __rest(_a, ["type", "sortOrder", "sortValue", "limit"]);
+    return createApiRequest({
+        request: window.api.getNodes(Object.assign({ type, sortOrder, sortValue, limit }, params), { concurrentId }),
+        actions: FETCH_TOP_NODES_BY_MEMORY,
+        dataHandler: prepareNodesData,
+    });
+}
+export const selectTopNodesByMemory = (state) => state.topNodesByMemory.data;
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};

package/dist/store/reducers/tenantOverview/topNodesByMemory/types.d.ts

@@ -0,0 +1,19 @@
+import type { IResponseError } from '../../../../types/api/error';
+import type { ApiRequestAction } from '../../../utils';
+import type { NodesPreparedEntity } from '../../nodes/types';
+import { FETCH_TOP_NODES_BY_MEMORY, setDataWasNotLoaded } from './topNodesByMemory';
+export interface TopNodesByMemoryState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: NodesPreparedEntity[];
+    error?: IResponseError;
+}
+export interface TopNodesByMemoryHandledResponse {
+    Nodes?: NodesPreparedEntity[];
+}
+declare type TopNodesByMemoryApiRequestAction = ApiRequestAction<typeof FETCH_TOP_NODES_BY_MEMORY, TopNodesByMemoryHandledResponse, IResponseError>;
+export declare type TopNodesByMemoryAction = TopNodesByMemoryApiRequestAction | ReturnType<typeof setDataWasNotLoaded>;
+export interface TopNodesByMemorySlice {
+    topNodesByMemory: TopNodesByMemoryState;
+}
+export {};

package/dist/store/reducers/tenantOverview/topNodesByMemory/types.js

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

package/dist/store/reducers/tenantOverview/topQueries/tenantOverviewTopQueries.d.ts

@@ -0,0 +1,12 @@
+import type { Reducer } from 'redux';
+import type { TenantOverviewTopQueriesAction, TenantOverviewTopQueriesState } from './types';
+export declare const FETCH_TENANT_OVERVIEW_TOP_QUERIES: {
+    readonly REQUEST: "tenantOverviewTopQueries/FETCH_TOP_QUERIES_REQUEST";
+    readonly SUCCESS: "tenantOverviewTopQueries/FETCH_TOP_QUERIES_SUCCESS";
+    readonly FAILURE: "tenantOverviewTopQueries/FETCH_TOP_QUERIES_FAILURE";
+};
+export declare const tenantOverviewTopQueries: Reducer<TenantOverviewTopQueriesState, TenantOverviewTopQueriesAction>;
+export declare const fetchTenantOverviewTopQueries: (database: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("../..").GetState) => Promise<import("../../../../types/store/query").IQueryResult | undefined>;
+export declare function setDataWasNotLoaded(): {
+    readonly type: "tenantOverviewTopQueries/SET_DATA_WAS_NOT_LOADED";
+};

package/dist/store/reducers/tenantOverview/topQueries/tenantOverviewTopQueries.js

@@ -0,0 +1,55 @@
+import { TENANT_OVERVIEW_TABLES_LIMIT } from '../../../../utils/constants';
+import { parseQueryAPIExecuteResponse } from '../../../../utils/query';
+import { createRequestActionTypes, createApiRequest } from '../../../utils';
+export const FETCH_TENANT_OVERVIEW_TOP_QUERIES = createRequestActionTypes('tenantOverviewTopQueries', 'FETCH_TOP_QUERIES');
+const SET_DATA_WAS_NOT_LOADED = 'tenantOverviewTopQueries/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    filters: {},
+};
+const getQueryText = (path) => {
+    return `
+SELECT
+    CPUTime as CPUTimeUs,
+    QueryText,
+FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
+ORDER BY CPUTimeUs DESC
+LIMIT ${TENANT_OVERVIEW_TABLES_LIMIT}
+`;
+};
+export const tenantOverviewTopQueries = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_TENANT_OVERVIEW_TOP_QUERIES.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, error: undefined });
+        }
+        case FETCH_TENANT_OVERVIEW_TOP_QUERIES.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, error: undefined, wasLoaded: true });
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TENANT_OVERVIEW_TOP_QUERIES.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error || 'Unauthorized', loading: false });
+        }
+        case SET_DATA_WAS_NOT_LOADED:
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        default:
+            return state;
+    }
+};
+export const fetchTenantOverviewTopQueries = (database) => createApiRequest({
+    request: window.api.sendQuery({
+        schema: 'modern',
+        query: getQueryText(database),
+        database,
+        action: 'execute-scan',
+    }, {
+        concurrentId: 'executeTopQueries',
+    }),
+    actions: FETCH_TENANT_OVERVIEW_TOP_QUERIES,
+    dataHandler: parseQueryAPIExecuteResponse,
+});
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+}

package/dist/store/reducers/tenantOverview/topQueries/types.d.ts

@@ -0,0 +1,10 @@
+import type { IQueryResult, QueryErrorResponse } from '../../../../types/store/query';
+import type { ApiRequestAction } from '../../../utils';
+import { FETCH_TENANT_OVERVIEW_TOP_QUERIES, setDataWasNotLoaded } from './tenantOverviewTopQueries';
+export interface TenantOverviewTopQueriesState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: IQueryResult;
+    error?: QueryErrorResponse;
+}
+export declare type TenantOverviewTopQueriesAction = ApiRequestAction<typeof FETCH_TENANT_OVERVIEW_TOP_QUERIES, IQueryResult, QueryErrorResponse> | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/tenantOverview/topQueries/types.js

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

package/dist/store/reducers/tenantOverview/topShards/tenantOverviewTopShards.d.ts

@@ -0,0 +1,12 @@
+import type { Reducer } from 'redux';
+import { TenantOverviewTopShardsAction, TenantOverviewTopShardsState } from './types';
+export declare const FETCH_TENANT_OVERVIEW_TOP_SHARDS: {
+    readonly REQUEST: "tenantOverviewTopShards/FETCH_TENANT_OVERVIEW_TOP_SHARDS_REQUEST";
+    readonly SUCCESS: "tenantOverviewTopShards/FETCH_TENANT_OVERVIEW_TOP_SHARDS_SUCCESS";
+    readonly FAILURE: "tenantOverviewTopShards/FETCH_TENANT_OVERVIEW_TOP_SHARDS_FAILURE";
+};
+export declare const tenantOverviewTopShards: Reducer<TenantOverviewTopShardsState, TenantOverviewTopShardsAction>;
+export declare const sendTenantOverviewTopShardsQuery: (database: string, path?: string) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("../..").GetState) => Promise<import("../../../../types/store/query").IQueryResult | undefined>;
+export declare function setDataWasNotLoaded(): {
+    readonly type: "tenantOverviewTopShards/SET_DATA_WAS_NOT_LOADED";
+};

package/dist/store/reducers/tenantOverview/topShards/tenantOverviewTopShards.js

@@ -0,0 +1,64 @@
+import { TENANT_OVERVIEW_TABLES_LIMIT } from '../../../../utils/constants';
+import { parseQueryAPIExecuteResponse } from '../../../../utils/query';
+import { createRequestActionTypes, createApiRequest } from '../../../utils';
+export const FETCH_TENANT_OVERVIEW_TOP_SHARDS = createRequestActionTypes('tenantOverviewTopShards', 'FETCH_TENANT_OVERVIEW_TOP_SHARDS');
+const SET_DATA_WAS_NOT_LOADED = 'tenantOverviewTopShards/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+function createShardQuery(path, tenantName) {
+    const pathSelect = tenantName
+        ? `CAST(SUBSTRING(CAST(Path AS String), ${tenantName.length}) AS Utf8) AS Path`
+        : 'Path';
+    return `SELECT
+    ${pathSelect},
+    TabletId,
+    CPUCores,
+FROM \`.sys/partition_stats\`
+WHERE
+    Path='${path}'
+    OR Path LIKE '${path}/%'
+ORDER BY CPUCores DESC
+LIMIT ${TENANT_OVERVIEW_TABLES_LIMIT}`;
+}
+const queryAction = 'execute-scan';
+export const tenantOverviewTopShards = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_TENANT_OVERVIEW_TOP_SHARDS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, error: undefined });
+        }
+        case FETCH_TENANT_OVERVIEW_TOP_SHARDS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, error: undefined, wasLoaded: true });
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TENANT_OVERVIEW_TOP_SHARDS.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error || 'Unauthorized', loading: false });
+        }
+        case SET_DATA_WAS_NOT_LOADED:
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        default:
+            return state;
+    }
+};
+export const sendTenantOverviewTopShardsQuery = (database, path = '') => createApiRequest({
+    request: window.api.sendQuery({
+        schema: 'modern',
+        query: createShardQuery(path, database),
+        database,
+        action: queryAction,
+    }, {
+        concurrentId: 'executeTopShards',
+    }),
+    actions: FETCH_TENANT_OVERVIEW_TOP_SHARDS,
+    dataHandler: parseQueryAPIExecuteResponse,
+});
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+}

package/dist/store/reducers/tenantOverview/topShards/types.d.ts

@@ -0,0 +1,10 @@
+import type { IQueryResult, QueryErrorResponse } from '../../../../types/store/query';
+import type { ApiRequestAction } from '../../../utils';
+import { FETCH_TENANT_OVERVIEW_TOP_SHARDS, setDataWasNotLoaded } from './tenantOverviewTopShards';
+export interface TenantOverviewTopShardsState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: IQueryResult;
+    error?: QueryErrorResponse;
+}
+export declare type TenantOverviewTopShardsAction = ApiRequestAction<typeof FETCH_TENANT_OVERVIEW_TOP_SHARDS, IQueryResult, QueryErrorResponse> | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/tenantOverview/topShards/types.js

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

package/dist/store/reducers/tenantOverview/topShards/utils.d.ts

@@ -0,0 +1 @@
+export declare const getLoadSeverityForShard: (value: number) => "success" | "warning" | "danger" | undefined;

package/dist/store/reducers/tenantOverview/topShards/utils.js

@@ -0,0 +1,2 @@
+import { generateEvaluator } from '../../../../utils/generateEvaluator';
+export const getLoadSeverityForShard = generateEvaluator(60, 80, ['success', 'warning', 'danger']);

package/dist/store/reducers/tenantOverview/topStorageGroups/topStorageGroups.d.ts

@@ -0,0 +1,15 @@
+import type { Reducer } from 'redux';
+import type { StorageApiRequestParams } from '../../storage/types';
+import type { TopStorageGroupsAction, TopStorageGroupsState, TopStorageGroupsStateSlice } from './types';
+export declare const FETCH_TOP_STORAGE_GROUPS: {
+    readonly REQUEST: "topStorageGroups/FETCH_TOP_STORAGE_GROUPS_REQUEST";
+    readonly SUCCESS: "topStorageGroups/FETCH_TOP_STORAGE_GROUPS_SUCCESS";
+    readonly FAILURE: "topStorageGroups/FETCH_TOP_STORAGE_GROUPS_FAILURE";
+};
+declare const topStorageGroups: Reducer<TopStorageGroupsState, TopStorageGroupsAction>;
+export declare const getTopStorageGroups: ({ tenant, visibleEntities, nodeId, sortOrder, sortValue, limit, version, ...params }: StorageApiRequestParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("../..").GetState) => Promise<import("./types").PreparedTopStorageGroupsResponse | undefined>;
+export declare const selectTopStorageGroups: (state: TopStorageGroupsStateSlice) => import("../../storage/types").PreparedStorageGroup[] | undefined;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "topStorageGroups/SET_DATA_WAS_NOT_LOADED";
+};
+export default topStorageGroups;

package/dist/store/reducers/tenantOverview/topStorageGroups/topStorageGroups.js

@@ -0,0 +1,58 @@
+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 { TENANT_OVERVIEW_TABLES_LIMIT } from '../../../../utils/constants';
+import { EVersion } from '../../../../types/api/storage';
+import { createApiRequest, createRequestActionTypes } from '../../../utils';
+import { prepareTopStorageGroupsResponse } from './utils';
+export const FETCH_TOP_STORAGE_GROUPS = createRequestActionTypes('topStorageGroups', 'FETCH_TOP_STORAGE_GROUPS');
+const SET_DATA_WAS_NOT_LOADED = 'topStorageGroups/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+};
+const topStorageGroups = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_TOP_STORAGE_GROUPS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TOP_STORAGE_GROUPS.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data.groups, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_TOP_STORAGE_GROUPS.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, wasLoaded: true });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export const getTopStorageGroups = (_a) => {
+    var { tenant, visibleEntities = 'all', nodeId, sortOrder = -1, sortValue = 'Usage', limit = TENANT_OVERVIEW_TABLES_LIMIT, version = EVersion.v2 } = _a, params = __rest(_a, ["tenant", "visibleEntities", "nodeId", "sortOrder", "sortValue", "limit", "version"]);
+    return createApiRequest({
+        request: window.api.getStorageInfo(Object.assign({ tenant, visibleEntities, nodeId, version, sortOrder, sortValue, limit }, params), { concurrentId: 'getTopStorageGroups' }),
+        actions: FETCH_TOP_STORAGE_GROUPS,
+        dataHandler: prepareTopStorageGroupsResponse,
+    });
+};
+export const selectTopStorageGroups = (state) => state.topStorageGroups.data;
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export default topStorageGroups;