ydb-embedded-ui 5.5.0 → 6.0.0

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

@@ -1,46 +1,36 @@
-import type { Selector, Reducer } from '@reduxjs/toolkit';
+import type { Dispatch, Reducer, Selector } from '@reduxjs/toolkit';
 import type { EPathType } from '../../../types/api/schema';
-import type { SchemaAction, SchemaData, SchemaHandledResponse, SchemaStateSlice, SchemaState } from './types';
+import type { SchemaAction, SchemaData, SchemaHandledResponse, SchemaState, SchemaStateSlice } from './types';
 export declare const FETCH_SCHEMA: {
     readonly REQUEST: "schema/FETCH_SCHEMA_REQUEST";
     readonly SUCCESS: "schema/FETCH_SCHEMA_SUCCESS";
     readonly FAILURE: "schema/FETCH_SCHEMA_FAILURE";
 };
+export declare const SET_AUTOREFRESH_INTERVAL = "schema/SET_AUTOREFRESH_INTERVAL";
 export declare const initialState: {
     loading: boolean;
     wasLoaded: boolean;
     data: {};
     currentSchemaPath: undefined;
-    autorefresh: boolean;
+    autorefresh: number;
     showPreview: boolean;
 };
 declare const schema: Reducer<SchemaState, SchemaAction>;
 export declare function getSchema({ path }: {
     path: string;
-}): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+}): (dispatch: Dispatch<import("redux").UnknownAction>, getState: () => {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
     nodes: import("../nodes/types").NodesState;
-    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
-    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
-    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
     cluster: import("../cluster/types").ClusterState;
-    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
     tenant: import("../tenant/types").TenantState;
     storage: import("../storage/types").StorageState;
-    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
-    node: import("../node/types").NodeState;
     tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").ITabletsState;
+    tablets: import("../../../types/store/tablets").TabletsState;
     schema: SchemaState;
-    overview: import("../overview/types").OverviewState;
-    olapStats: import("../../../types/store/olapStats").OlapStatsState;
     host: import("../../../types/store/host").IHostState;
-    network: import("../network/types").NetworkState;
     tenants: import("../tenants/types").TenantsState;
-    tablet: import("../../../types/store/tablet").ITabletState;
-    topic: import("../../../types/store/topic").ITopicState;
     partitions: import("../partitions/types").PartitionsState;
-    pDisk: import("../pdisk/types").PDiskState;
     executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
     explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
@@ -82,34 +72,21 @@ export declare function getSchema({ path }: {
     };
     heatmap: import("../../../types/store/heatmap").IHeatmapState;
     settings: import("../settings/types").SettingsState;
-    preview: any;
-    nodesList: import("../../../types/store/nodesList").NodesListState;
-    describe: import("../../../types/store/describe").IDescribeState;
     schemaAcl: import("../schemaAcl/types").SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
-    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
-    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
-    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
-    shardsWorkload: import("../shardsWorkload/types").IShardsWorkloadState;
-    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
     hotKeys: import("../hotKeys/types").HotKeysState;
     authentication: import("../authentication/types").AuthenticationState;
     header: import("../header/types").HeaderState;
     saveQuery: string | null;
     fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersState;
-    vDisk: import("../vdisk/types").VDiskState;
+    clusters: import("../clusters/types").ClustersFilters;
 }) => Promise<SchemaHandledResponse | undefined>;
 export declare function setCurrentSchemaPath(currentSchemaPath: string): {
     readonly type: "schema/SET_SCHEMA";
     readonly data: string;
 };
-export declare function enableAutorefresh(): {
-    readonly type: "schema/ENABLE_AUTOREFRESH";
-};
-export declare function disableAutorefresh(): {
-    readonly type: "schema/DISABLE_AUTOREFRESH";
-};
+export declare function setAutorefreshInterval(interval: number): (dispatch: Dispatch) => void;
 export declare function setShowPreview(value: boolean): {
     readonly type: "schema/SET_SHOW_PREVIEW";
     readonly data: boolean;

package/dist/store/reducers/schema/schema.js

@@ -1,19 +1,21 @@
 import { createSelector } from '@reduxjs/toolkit';
 import { isEntityWithMergedImplementation } from '../../../containers/Tenant/utils/schema';
-import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { settingsManager } from '../../../services/settings';
+import { AUTO_REFRESH_INTERVAL } from '../../../utils/constants';
+import { createApiRequest, createRequestActionTypes } from '../../utils';
 export const FETCH_SCHEMA = createRequestActionTypes('schema', 'FETCH_SCHEMA');
 const PRELOAD_SCHEMAS = 'schema/PRELOAD_SCHEMAS';
 const SET_SCHEMA = 'schema/SET_SCHEMA';
 const SET_SHOW_PREVIEW = 'schema/SET_SHOW_PREVIEW';
-const ENABLE_AUTOREFRESH = 'schema/ENABLE_AUTOREFRESH';
-const DISABLE_AUTOREFRESH = 'schema/DISABLE_AUTOREFRESH';
+export const SET_AUTOREFRESH_INTERVAL = 'schema/SET_AUTOREFRESH_INTERVAL';
 const RESET_LOADING_STATE = 'schema/RESET_LOADING_STATE';
+const autoRefreshLS = Number(settingsManager.readUserSettingsValue(AUTO_REFRESH_INTERVAL, 0));
 export const initialState = {
     loading: true,
     wasLoaded: false,
     data: {},
     currentSchemaPath: undefined,
-    autorefresh: false,
+    autorefresh: isNaN(autoRefreshLS) ? 0 : autoRefreshLS,
     showPreview: false,
 };
 const schema = (state = initialState, action) => {
@@ -42,11 +44,8 @@ const schema = (state = initialState, action) => {
         case SET_SCHEMA: {
             return Object.assign(Object.assign({}, state), { currentSchemaPath: action.data });
         }
-        case ENABLE_AUTOREFRESH: {
-            return Object.assign(Object.assign({}, state), { autorefresh: true });
-        }
-        case DISABLE_AUTOREFRESH: {
-            return Object.assign(Object.assign({}, state), { autorefresh: false });
+        case SET_AUTOREFRESH_INTERVAL: {
+            return Object.assign(Object.assign({}, state), { autorefresh: action.data });
         }
         case SET_SHOW_PREVIEW: {
             return Object.assign(Object.assign({}, state), { showPreview: action.data });
@@ -82,14 +81,13 @@ export function setCurrentSchemaPath(currentSchemaPath) {
         data: currentSchemaPath,
     };
 }
-export function enableAutorefresh() {
-    return {
-        type: ENABLE_AUTOREFRESH,
-    };
-}
-export function disableAutorefresh() {
-    return {
-        type: DISABLE_AUTOREFRESH,
+export function setAutorefreshInterval(interval) {
+    return (dispatch) => {
+        settingsManager.setUserSettingsValue(AUTO_REFRESH_INTERVAL, interval);
+        dispatch({
+            type: SET_AUTOREFRESH_INTERVAL,
+            data: interval,
+        });
     };
 }
 export function setShowPreview(value) {

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

@@ -1,7 +1,7 @@
-import type { ApiRequestAction } from '../../utils';
 import type { IResponseError } from '../../../types/api/error';
 import type { TEvDescribeSchemeResult } from '../../../types/api/schema';
-import { disableAutorefresh, enableAutorefresh, FETCH_SCHEMA, preloadSchemas, resetLoadingState, setCurrentSchemaPath, setShowPreview } from './schema';
+import type { ApiRequestAction } from '../../utils';
+import type { FETCH_SCHEMA, SET_AUTOREFRESH_INTERVAL, preloadSchemas, resetLoadingState, setCurrentSchemaPath, setShowPreview } from './schema';
 export type SchemaData = Record<string, TEvDescribeSchemeResult>;
 export interface SchemaState {
     loading: boolean;
@@ -9,7 +9,7 @@ export interface SchemaState {
     data: SchemaData;
     currentSchema?: TEvDescribeSchemeResult;
     currentSchemaPath?: string;
-    autorefresh: boolean;
+    autorefresh: number;
     showPreview: boolean;
     error?: IResponseError;
 }
@@ -19,7 +19,10 @@ export interface SchemaHandledResponse {
     data?: SchemaData;
 }
 type SchemaApiRequestAction = ApiRequestAction<typeof FETCH_SCHEMA, SchemaHandledResponse, IResponseError>;
-export type SchemaAction = SchemaApiRequestAction | (ReturnType<typeof setCurrentSchemaPath> | ReturnType<typeof enableAutorefresh> | ReturnType<typeof disableAutorefresh> | ReturnType<typeof setShowPreview> | ReturnType<typeof preloadSchemas> | ReturnType<typeof resetLoadingState>);
+export type SchemaAction = SchemaApiRequestAction | (ReturnType<typeof setCurrentSchemaPath> | {
+    type: typeof SET_AUTOREFRESH_INTERVAL;
+    data: number;
+} | ReturnType<typeof setShowPreview> | ReturnType<typeof preloadSchemas> | ReturnType<typeof resetLoadingState>);
 export interface SchemaStateSlice {
     schema: SchemaState;
 }

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

@@ -9,29 +9,18 @@ declare const schemaAcl: Reducer<SchemaAclState, SchemaAclAction>;
 export declare function getSchemaAcl({ path }: {
     path: string;
 }): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
     nodes: import("../nodes/types").NodesState;
-    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
-    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
-    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
     cluster: import("../cluster/types").ClusterState;
-    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
     tenant: import("../tenant/types").TenantState;
     storage: import("../storage/types").StorageState;
-    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
-    node: import("../node/types").NodeState;
     tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").ITabletsState;
+    tablets: import("../../../types/store/tablets").TabletsState;
     schema: import("../schema/types").SchemaState;
-    overview: import("../overview/types").OverviewState;
-    olapStats: import("../../../types/store/olapStats").OlapStatsState;
     host: import("../../../types/store/host").IHostState;
-    network: import("../network/types").NetworkState;
     tenants: import("../tenants/types").TenantsState;
-    tablet: import("../../../types/store/tablet").ITabletState;
-    topic: import("../../../types/store/topic").ITopicState;
     partitions: import("../partitions/types").PartitionsState;
-    pDisk: import("../pdisk/types").PDiskState;
     executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
     explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
@@ -73,23 +62,15 @@ export declare function getSchemaAcl({ path }: {
     };
     heatmap: import("../../../types/store/heatmap").IHeatmapState;
     settings: import("../settings/types").SettingsState;
-    preview: any;
-    nodesList: import("../../../types/store/nodesList").NodesListState;
-    describe: import("../../../types/store/describe").IDescribeState;
     schemaAcl: SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
-    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
-    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
-    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
-    shardsWorkload: import("../shardsWorkload/types").IShardsWorkloadState;
-    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
     hotKeys: import("../hotKeys/types").HotKeysState;
     authentication: import("../authentication/types").AuthenticationState;
     header: import("../header/types").HeaderState;
     saveQuery: string | null;
     fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersState;
-    vDisk: import("../vdisk/types").VDiskState;
+    clusters: import("../clusters/types").ClustersFilters;
 }) => Promise<unknown>;
 export declare const setAclWasNotLoaded: () => {
     readonly type: "schemaAcl/SET_DATA_WAS_NOT_LOADED";

package/dist/store/reducers/schemaAcl/schemaAcl.js

@@ -1,4 +1,4 @@
-import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { createApiRequest, createRequestActionTypes } from '../../utils';
 export const FETCH_SCHEMA_ACL = createRequestActionTypes('schemaAcl', 'FETCH_SCHEMA_ACL');
 const SET_ACL_WAS_NOT_LOADED = 'schemaAcl/SET_DATA_WAS_NOT_LOADED';
 const initialState = {

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

@@ -1,7 +1,7 @@
 import type { TACE, TMetaInfo } from '../../../types/api/acl';
 import type { IResponseError } from '../../../types/api/error';
 import type { ApiRequestAction } from '../../utils';
-import { FETCH_SCHEMA_ACL, setAclWasNotLoaded } from './schemaAcl';
+import type { FETCH_SCHEMA_ACL, setAclWasNotLoaded } from './schemaAcl';
 export interface SchemaAclState {
     loading: boolean;
     wasLoaded: boolean;

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

@@ -1,7 +1,6 @@
-import type { Reducer } from '@reduxjs/toolkit';
-import type { ThunkAction } from 'redux-thunk';
-import { SettingsObject } from '../../../services/settings';
+import type { Reducer, ThunkAction } from '@reduxjs/toolkit';
 import type { RootState } from '../..';
+import type { SettingsObject } from '../../../services/settings';
 import type { ProblemFilterValue, SetSettingValueAction, SettingsAction, SettingsRootStateSlice, SettingsState } from './types';
 export declare const SET_SETTING_VALUE = "settings/SET_VALUE";
 export declare const SET_USER_SETTINGS = "settings/SET_USER_SETTINGS";

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

@@ -1,6 +1,6 @@
-import type { ValueOf } from '../../../types/common';
 import type { SettingsObject } from '../../../services/settings';
-import { changeFilter, setUserSettings, ProblemFilterValues, SET_SETTING_VALUE } from './settings';
+import type { ValueOf } from '../../../types/common';
+import type { ProblemFilterValues, SET_SETTING_VALUE, changeFilter, setUserSettings } from './settings';
 export type ProblemFilterValue = ValueOf<typeof ProblemFilterValues>;
 export interface SettingsState {
     problemFilter: ProblemFilterValue;

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

@@ -1,113 +1,17 @@
-import type { Reducer } from '@reduxjs/toolkit';
-import type { IShardsWorkloadAction, IShardsWorkloadFilters, IShardsWorkloadState } from './types';
-export declare const SEND_SHARD_QUERY: {
-    readonly REQUEST: "query/SEND_SHARD_QUERY_REQUEST";
-    readonly SUCCESS: "query/SEND_SHARD_QUERY_SUCCESS";
-    readonly FAILURE: "query/SEND_SHARD_QUERY_FAILURE";
-};
+import type { ShardsWorkloadFilters } from './types';
 export interface SortOrder {
     columnId: string;
     order: string;
 }
-declare const shardsWorkload: Reducer<IShardsWorkloadState, IShardsWorkloadAction>;
+export declare const setShardsQueryFilters: import("@reduxjs/toolkit").ActionCreatorWithPayload<ShardsWorkloadFilters, "shardsWorkload/setShardsQueryFilters">;
+declare const _default: import("redux").Reducer<ShardsWorkloadFilters>;
+export default _default;
 interface SendShardQueryParams {
     database?: string;
     path?: string;
     sortOrder?: SortOrder[];
-    filters?: IShardsWorkloadFilters;
+    filters?: ShardsWorkloadFilters;
 }
-export declare const sendShardQuery: ({ database, path, sortOrder, filters }: SendShardQueryParams) => ((dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
-    singleClusterMode: boolean;
-    nodes: import("../nodes/types").NodesState;
-    topNodesByLoad: import("../tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
-    topNodesByCpu: import("../tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
-    topNodesByMemory: import("../tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
-    cluster: import("../cluster/types").ClusterState;
-    clusterNodes: import("../clusterNodes/types").ClusterNodesState;
-    tenant: import("../tenant/types").TenantState;
-    storage: import("../storage/types").StorageState;
-    topStorageGroups: import("../tenantOverview/topStorageGroups/types").TopStorageGroupsState;
-    node: import("../node/types").NodeState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").ITabletsState;
-    schema: import("../schema/types").SchemaState;
-    overview: import("../overview/types").OverviewState;
-    olapStats: import("../../../types/store/olapStats").OlapStatsState;
-    host: import("../../../types/store/host").IHostState;
-    network: import("../network/types").NetworkState;
-    tenants: import("../tenants/types").TenantsState;
-    tablet: import("../../../types/store/tablet").ITabletState;
-    topic: import("../../../types/store/topic").ITopicState;
-    partitions: import("../partitions/types").PartitionsState;
-    pDisk: import("../pdisk/types").PDiskState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
-    tabletsFilters: {
-        loading: boolean;
-        requestTime: number;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        tabletsData: any;
-        nodes: any;
-        loading: boolean;
-        wasLoaded: boolean;
-        timeoutForRequest: number;
-        error: undefined;
-        data: undefined;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        error: any;
-        loading: boolean;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        stateFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        typeFilter: never[];
-    } | {
-        typeFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        stateFilter: never[];
-    };
-    heatmap: import("../../../types/store/heatmap").IHeatmapState;
-    settings: import("../settings/types").SettingsState;
-    preview: any;
-    nodesList: import("../../../types/store/nodesList").NodesListState;
-    describe: import("../../../types/store/describe").IDescribeState;
-    schemaAcl: import("../schemaAcl/types").SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").ITopQueriesState;
-    executeTopTables: import("../tenantOverview/executeTopTables/types").TopTablesState;
-    tenantOverviewTopQueries: import("../tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
-    healthcheckInfo: import("../healthcheckInfo/types").HealthcheckInfoState;
-    shardsWorkload: IShardsWorkloadState;
-    tenantOverviewTopShards: import("../tenantOverview/topShards/types").TenantOverviewTopShardsState;
-    hotKeys: import("../hotKeys/types").HotKeysState;
-    authentication: import("../authentication/types").AuthenticationState;
-    header: import("../header/types").HeaderState;
-    saveQuery: string | null;
-    fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersState;
-    vDisk: import("../vdisk/types").VDiskState;
-}) => Promise<import("../../../types/store/query").IQueryResult | undefined>) | {
-    type: "query/SEND_SHARD_QUERY_FAILURE";
-    error: unknown;
-};
-export declare function setShardsState(options: Partial<IShardsWorkloadState>): {
-    readonly type: "query/SET_SHARD_STATE";
-    readonly data: Partial<IShardsWorkloadState>;
-};
-export declare function setShardsQueryFilters(filters: Partial<IShardsWorkloadFilters>): {
-    readonly type: "shardsWorkload/SET_SHARD_QUERY_FILTERS";
-    readonly filters: Partial<IShardsWorkloadFilters>;
-};
-export default shardsWorkload;
+export declare const shardApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    sendShardQuery: import("@reduxjs/toolkit/query").QueryDefinition<SendShardQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("../../../types/store/query").IQueryResult | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/store/reducers/shardsWorkload/shardsWorkload.js

@@ -1,14 +1,8 @@
+import { createSlice } from '@reduxjs/toolkit';
 import { parseQueryAPIExecuteResponse } from '../../../utils/query';
-import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { api } from '../api';
 import { EShardsWorkloadMode } from './types';
-export const SEND_SHARD_QUERY = createRequestActionTypes('query', 'SEND_SHARD_QUERY');
-const SET_SHARD_STATE = 'query/SET_SHARD_STATE';
-const SET_SHARD_QUERY_FILTERS = 'shardsWorkload/SET_SHARD_QUERY_FILTERS';
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-    filters: {},
-};
+const initialState = {};
 function formatSortOrder({ columnId, order }) {
     return `${columnId} ${order}`;
 }
@@ -72,64 +66,41 @@ ${orderBy}
 LIMIT 20`;
 }
 const queryAction = 'execute-scan';
-const shardsWorkload = (state = initialState, action) => {
-    var _a;
-    switch (action.type) {
-        case SEND_SHARD_QUERY.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true, error: undefined });
-        }
-        case SEND_SHARD_QUERY.SUCCESS: {
-            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, error: undefined, wasLoaded: true });
-        }
-        // 401 Unauthorized error is handled by GenericAPI
-        case SEND_SHARD_QUERY.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_SHARD_STATE:
-            return Object.assign(Object.assign({}, state), action.data);
-        case SET_SHARD_QUERY_FILTERS:
-            return Object.assign(Object.assign({}, state), { filters: Object.assign(Object.assign({}, state.filters), action.filters) });
-        default:
-            return state;
-    }
-};
-export const sendShardQuery = ({ database, path = '', sortOrder, filters }) => {
-    try {
-        return createApiRequest({
-            request: window.api.sendQuery({
-                schema: 'modern',
-                query: (filters === null || filters === void 0 ? void 0 : filters.mode) === EShardsWorkloadMode.Immediate
-                    ? createShardQueryImmediate(path, sortOrder, database)
-                    : createShardQueryHistorical(path, filters, sortOrder, database),
-                database,
-                action: queryAction,
-            }, {
-                concurrentId: 'shardsWorkload',
-            }),
-            actions: SEND_SHARD_QUERY,
-            dataHandler: parseQueryAPIExecuteResponse,
-        });
-    }
-    catch (error) {
-        return {
-            type: SEND_SHARD_QUERY.FAILURE,
-            error,
-        };
-    }
-};
-export function setShardsState(options) {
-    return {
-        type: SET_SHARD_STATE,
-        data: options,
-    };
-}
-export function setShardsQueryFilters(filters) {
-    return {
-        type: SET_SHARD_QUERY_FILTERS,
-        filters,
-    };
-}
-export default shardsWorkload;
+const slice = createSlice({
+    name: 'shardsWorkload',
+    initialState,
+    reducers: {
+        setShardsQueryFilters: (state, action) => {
+            return Object.assign(Object.assign({}, state), action.payload);
+        },
+    },
+});
+export const { setShardsQueryFilters } = slice.actions;
+export default slice.reducer;
+export const shardApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        sendShardQuery: build.query({
+            queryFn: async ({ database, path = '', sortOrder, filters }, { signal }) => {
+                try {
+                    const response = await window.api.sendQuery({
+                        schema: 'modern',
+                        query: (filters === null || filters === void 0 ? void 0 : filters.mode) === EShardsWorkloadMode.Immediate
+                            ? createShardQueryImmediate(path, sortOrder, database)
+                            : createShardQueryHistorical(path, filters, sortOrder, database),
+                        database,
+                        action: queryAction,
+                    }, {
+                        signal,
+                    });
+                    const data = parseQueryAPIExecuteResponse(response);
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -1,25 +1,14 @@
-import { SEND_SHARD_QUERY, setShardsState, setShardsQueryFilters } from './shardsWorkload';
-import type { ApiRequestAction } from '../../utils';
-import type { IQueryResult, QueryErrorResponse } from '../../../types/store/query';
 export declare enum EShardsWorkloadMode {
     Immediate = "immediate",
     History = "history"
 }
-export interface IShardsWorkloadFilters {
+export interface ShardsWorkloadFilters {
     /** ms from epoch */
     from?: number;
     /** ms from epoch */
     to?: number;
     mode?: EShardsWorkloadMode;
 }
-export interface IShardsWorkloadState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data?: IQueryResult;
-    error?: QueryErrorResponse;
-    filters: IShardsWorkloadFilters;
-}
-export type IShardsWorkloadAction = ApiRequestAction<typeof SEND_SHARD_QUERY, IQueryResult, QueryErrorResponse> | ReturnType<typeof setShardsState> | ReturnType<typeof setShardsQueryFilters>;
-export interface IShardsWorkloadRootStateSlice {
-    shardsWorkload: IShardsWorkloadState;
+export interface ShardsWorkloadRootStateSlice {
+    shardsWorkload: ShardsWorkloadFilters;
 }

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

@@ -1,18 +1,13 @@
-import { Selector } from '@reduxjs/toolkit';
 import type { OrderType } from '@gravity-ui/react-data-table';
-import { type NodesSortValue } from '../../../utils/nodes';
-import { type StorageSortValue } from '../../../utils/storage';
+import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { StorageSortValue } from '../../../utils/storage';
 import type { PreparedStorageGroup, PreparedStorageNode, StorageStateSlice, UsageFilter } from './types';
-export declare const selectEntitiesCount: (state: StorageStateSlice) => {
-    total: number | undefined;
-    found: number | undefined;
-};
-export declare const selectStorageGroups: (state: StorageStateSlice) => PreparedStorageGroup[] | undefined;
-export declare const selectStorageNodes: (state: StorageStateSlice) => PreparedStorageNode[] | undefined;
+export declare function filterNodes(storageNodes: PreparedStorageNode[], textFilter: string, uptimeFilter: NodesUptimeFilterValues): PreparedStorageNode[];
+export declare function filterGroups(storageGroups: PreparedStorageGroup[], textFilter: string, usageFilter: string[]): PreparedStorageGroup[];
 export declare const selectStorageFilter: (state: StorageStateSlice) => string;
 export declare const selectUsageFilter: (state: StorageStateSlice) => string[];
 export declare const selectVisibleEntities: (state: StorageStateSlice) => import("./types").VisibleEntities;
-export declare const selectNodesUptimeFilter: (state: StorageStateSlice) => import("../../../utils/nodes").NodesUptimeFilterValues;
+export declare const selectNodesUptimeFilter: (state: StorageStateSlice) => NodesUptimeFilterValues;
 export declare const selectStorageType: (state: StorageStateSlice) => import("./types").StorageType;
 export declare const selectNodesSortParams: (state: StorageStateSlice) => {
     sortValue: NodesSortValue;
@@ -22,6 +17,4 @@ export declare const selectGroupsSortParams: (state: StorageStateSlice) => {
     sortValue: StorageSortValue;
     sortOrder: OrderType;
 };
-export declare const selectUsageFilterOptions: Selector<StorageStateSlice, UsageFilter[]>;
-export declare const selectFilteredNodes: Selector<StorageStateSlice, PreparedStorageNode[]>;
-export declare const selectFilteredGroups: Selector<StorageStateSlice, PreparedStorageGroup[]>;
+export declare function getUsageFilterOptions(groups: PreparedStorageGroup[]): UsageFilter[];