ydb-embedded-ui 6.4.0 → 6.5.0

package/dist/services/api.d.ts

@@ -13,7 +13,7 @@ import type { TNetInfo } from '../types/api/netInfo';
 import type { TNodesInfo } from '../types/api/nodes';
 import type { TEvNodesInfo } from '../types/api/nodesList';
 import type { TEvPDiskStateResponse } from '../types/api/pdisk';
-import type { Actions, ExplainActions, ExplainResponse, QueryAPIResponse, Schemas } from '../types/api/query';
+import type { Actions, ErrorResponse, ExplainActions, ExplainResponse, QueryAPIResponse, Schemas } from '../types/api/query';
 import type { JsonRenderRequestParams, JsonRenderResponse } from '../types/api/render';
 import type { RestartPDiskResponse } from '../types/api/restartPDisk';
 import type { TEvDescribeSchemeResult } from '../types/api/schema';
@@ -94,8 +94,8 @@ export declare class YdbEmbeddedAPI extends AxiosWrapper {
         stats?: string;
         schema?: Schema;
         syntax?: QuerySyntax;
-    }, { concurrentId, signal }?: AxiosOptions): Promise<QueryAPIResponse<Action, Schema>>;
-    getExplainQuery<Action extends ExplainActions>(query: string, database: string, action: Action, syntax?: QuerySyntax): Promise<ExplainResponse<Action>>;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<ErrorResponse | QueryAPIResponse<Action, Schema>>;
+    getExplainQuery<Action extends ExplainActions>(query: string, database: string, action: Action, syntax?: QuerySyntax): Promise<ErrorResponse | ExplainResponse<Action>>;
     getExplainQueryAst(query: string, database: string): Promise<import("../types/api/query").ExplainQueryResponse>;
     getHotKeys(path: string, enableSampling: boolean, { concurrentId, signal }?: AxiosOptions): Promise<JsonHotKeysResponse>;
     getHealthcheckInfo(database: string, { concurrentId, signal }?: AxiosOptions): Promise<HealthCheckAPIResponse>;

package/dist/services/settings.d.ts

@@ -17,6 +17,7 @@ export declare const DEFAULT_USER_SETTINGS: {
     readonly useClusterBalancerAsBacked: true;
     readonly enableAutocomplete: false;
     readonly autocompleteOnEnter: true;
+    readonly isHotKeysHelpHidden: false;
 };
 declare class SettingsManager {
     /**

package/dist/services/settings.js

@@ -1,5 +1,5 @@
 import { TENANT_PAGES_IDS } from '../store/reducers/tenant/constants';
-import { ASIDE_HEADER_COMPACT_KEY, AUTOCOMPLETE_ON_ENTER, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, 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_CLUSTER_BALANCER_AS_BACKEND_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../utils/constants';
+import { ASIDE_HEADER_COMPACT_KEY, AUTOCOMPLETE_ON_ENTER, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, INVERTED_DISKS_KEY, IS_HOTKEYS_HELP_HIDDDEN_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_CLUSTER_BALANCER_AS_BACKEND_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../utils/constants';
 import { QUERY_ACTIONS, QUERY_MODES } from '../utils/query';
 import { parseJson } from '../utils/utils';
 /** User settings keys and their default values */
@@ -20,6 +20,7 @@ export const DEFAULT_USER_SETTINGS = {
     [USE_CLUSTER_BALANCER_AS_BACKEND_KEY]: true,
     [ENABLE_AUTOCOMPLETE]: false,
     [AUTOCOMPLETE_ON_ENTER]: true,
+    [IS_HOTKEYS_HELP_HIDDDEN_KEY]: false,
 };
 class SettingsManager {
     constructor() {

package/dist/store/configureStore.d.ts

@@ -17,7 +17,6 @@ export declare function configureStore({ aRootReducer, singleClusterMode, api, }
         tenants: import("./reducers/tenants/types").TenantsState;
         partitions: import("./reducers/partitions/types").PartitionsState;
         executeQuery: import("../types/store/executeQuery").ExecuteQueryState;
-        explainQuery: import("../types/store/explainQuery").ExplainQueryState;
         tabletsFilters: {
             loading: boolean;
             requestTime: number;
@@ -78,7 +77,6 @@ export declare function configureStore({ aRootReducer, singleClusterMode, api, }
         tenants: import("./reducers/tenants/types").TenantsState | undefined;
         partitions: import("./reducers/partitions/types").PartitionsState | undefined;
         executeQuery: never;
-        explainQuery: never;
         tabletsFilters: {
             data: undefined;
             loading: boolean;
@@ -114,7 +112,6 @@ export declare function configureStore({ aRootReducer, singleClusterMode, api, }
         tenants: import("./reducers/tenants/types").TenantsState;
         partitions: import("./reducers/partitions/types").PartitionsState;
         executeQuery: import("../types/store/executeQuery").ExecuteQueryState;
-        explainQuery: import("../types/store/explainQuery").ExplainQueryState;
         tabletsFilters: {
             loading: boolean;
             requestTime: number;
@@ -176,7 +173,6 @@ export declare function configureStore({ aRootReducer, singleClusterMode, api, }
             tenants: import("./reducers/tenants/types").TenantsState;
             partitions: import("./reducers/partitions/types").PartitionsState;
             executeQuery: import("../types/store/executeQuery").ExecuteQueryState;
-            explainQuery: import("../types/store/explainQuery").ExplainQueryState;
             tabletsFilters: {
                 loading: boolean;
                 requestTime: number;

package/dist/store/defaultStore.d.ts

@@ -10,7 +10,6 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
     tenants: import("./reducers/tenants/types").TenantsState;
     partitions: import("./reducers/partitions/types").PartitionsState;
     executeQuery: import("../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
         loading: boolean;
         requestTime: number;
@@ -72,7 +71,6 @@ export declare const store: import("@reduxjs/toolkit").EnhancedStore<{
         tenants: import("./reducers/tenants/types").TenantsState;
         partitions: import("./reducers/partitions/types").PartitionsState;
         executeQuery: import("../types/store/executeQuery").ExecuteQueryState;
-        explainQuery: import("../types/store/explainQuery").ExplainQueryState;
         tabletsFilters: {
             loading: boolean;
             requestTime: number;

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

@@ -16,7 +16,67 @@ export declare const FETCH_USER: {
     readonly FAILURE: "authentication/FETCH_USER_FAILURE";
 };
 declare const authentication: Reducer<AuthenticationState, AuthenticationAction>;
-export declare const authenticate: (user: string, password: string) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+export declare const authenticate: (user: string, password: string) => (dispatch: import("redux-thunk").ThunkDispatch<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("../cluster/types").ClusterState;
+    tenant: import("../tenant/types").TenantState;
+    tooltip: import("../../../types/store/tooltip").ITooltipState;
+    tablets: import("../../../types/store/tablets").TabletsState;
+    schema: import("../schema/types").SchemaState;
+    host: import("../../../types/store/host").IHostState;
+    tenants: import("../tenants/types").TenantsState;
+    partitions: import("../partitions/types").PartitionsState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    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;
+    schemaAcl: import("../schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("../hotKeys/types").HotKeysState;
+    authentication: AuthenticationState;
+    header: import("../header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersFilters;
+}, undefined, import("redux").UnknownAction> & import("redux").Dispatch<any>, getState: () => {
     api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
     cluster: import("../cluster/types").ClusterState;
@@ -28,7 +88,6 @@ export declare const authenticate: (user: string, password: string) => (dispatch
     tenants: import("../tenants/types").TenantsState;
     partitions: import("../partitions/types").PartitionsState;
     executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
         loading: boolean;
         requestTime: number;
@@ -78,7 +137,67 @@ export declare const authenticate: (user: string, password: string) => (dispatch
     fullscreen: boolean;
     clusters: import("../clusters/types").ClustersFilters;
 }) => Promise<unknown>;
-export declare const logout: () => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+export declare const logout: () => (dispatch: import("redux-thunk").ThunkDispatch<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("../cluster/types").ClusterState;
+    tenant: import("../tenant/types").TenantState;
+    tooltip: import("../../../types/store/tooltip").ITooltipState;
+    tablets: import("../../../types/store/tablets").TabletsState;
+    schema: import("../schema/types").SchemaState;
+    host: import("../../../types/store/host").IHostState;
+    tenants: import("../tenants/types").TenantsState;
+    partitions: import("../partitions/types").PartitionsState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    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;
+    schemaAcl: import("../schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("../hotKeys/types").HotKeysState;
+    authentication: AuthenticationState;
+    header: import("../header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersFilters;
+}, undefined, import("redux").UnknownAction> & import("redux").Dispatch<any>, getState: () => {
     api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
     cluster: import("../cluster/types").ClusterState;
@@ -90,7 +209,6 @@ export declare const logout: () => (dispatch: import("redux").Dispatch<import("r
     tenants: import("../tenants/types").TenantsState;
     partitions: import("../partitions/types").PartitionsState;
     executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
         loading: boolean;
         requestTime: number;
@@ -140,7 +258,67 @@ export declare const logout: () => (dispatch: import("redux").Dispatch<import("r
     fullscreen: boolean;
     clusters: import("../clusters/types").ClustersFilters;
 }) => Promise<unknown>;
-export declare const getUser: () => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+export declare const getUser: () => (dispatch: import("redux-thunk").ThunkDispatch<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("../cluster/types").ClusterState;
+    tenant: import("../tenant/types").TenantState;
+    tooltip: import("../../../types/store/tooltip").ITooltipState;
+    tablets: import("../../../types/store/tablets").TabletsState;
+    schema: import("../schema/types").SchemaState;
+    host: import("../../../types/store/host").IHostState;
+    tenants: import("../tenants/types").TenantsState;
+    partitions: import("../partitions/types").PartitionsState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    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;
+    schemaAcl: import("../schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("../hotKeys/types").HotKeysState;
+    authentication: AuthenticationState;
+    header: import("../header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersFilters;
+}, undefined, import("redux").UnknownAction> & import("redux").Dispatch<any>, getState: () => {
     api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
     cluster: import("../cluster/types").ClusterState;
@@ -152,7 +330,6 @@ export declare const getUser: () => (dispatch: import("redux").Dispatch<import("
     tenants: import("../tenants/types").TenantsState;
     partitions: import("../partitions/types").PartitionsState;
     executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
         loading: boolean;
         requestTime: number;
@@ -201,5 +378,8 @@ export declare const getUser: () => (dispatch: import("redux").Dispatch<import("
     saveQuery: string | null;
     fullscreen: boolean;
     clusters: import("../clusters/types").ClustersFilters;
-}) => Promise<string | undefined>;
+}) => Promise<{
+    user: string | undefined;
+    isUserAllowedToMakeChanges: boolean;
+} | undefined>;
 export default authentication;

package/dist/store/reducers/authentication/authentication.js

@@ -19,7 +19,9 @@ const authentication = (state = initialState, action) => {
             return Object.assign(Object.assign({}, state), { error: action.error });
         }
         case FETCH_USER.SUCCESS: {
-            return Object.assign(Object.assign({}, state), { user: action.data });
+            const { user, isUserAllowedToMakeChanges } = action.data;
+            return Object.assign(Object.assign({}, state), { user,
+                isUserAllowedToMakeChanges });
         }
         default:
             return Object.assign({}, state);
@@ -42,8 +44,15 @@ export const getUser = () => {
         request: window.api.whoami(),
         actions: FETCH_USER,
         dataHandler: (data) => {
-            const { UserSID, AuthType } = data;
-            return AuthType === 'Login' ? UserSID : undefined;
+            const { UserSID, AuthType, IsMonitoringAllowed } = data;
+            return {
+                user: AuthType === 'Login' ? UserSID : undefined,
+                // If ydb version supports this feature,
+                // There should be explicit flag in whoami response
+                // Otherwise every user is allowed to make changes
+                // Anyway there will be guards on backend
+                isUserAllowedToMakeChanges: IsMonitoringAllowed !== false,
+            };
         },
     });
 };

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

@@ -3,7 +3,11 @@ import type { ApiRequestAction } from '../../utils';
 import type { FETCH_USER, SET_AUTHENTICATED, SET_UNAUTHENTICATED } from './authentication';
 export interface AuthenticationState {
     isAuthenticated: boolean;
+    isUserAllowedToMakeChanges?: boolean;
     user: string | undefined;
     error: AuthErrorResponse | undefined;
 }
-export type AuthenticationAction = ApiRequestAction<typeof SET_UNAUTHENTICATED, unknown, unknown> | ApiRequestAction<typeof SET_AUTHENTICATED, unknown, AuthErrorResponse> | ApiRequestAction<typeof FETCH_USER, string | undefined, unknown>;
+export type AuthenticationAction = ApiRequestAction<typeof SET_UNAUTHENTICATED, unknown, unknown> | ApiRequestAction<typeof SET_AUTHENTICATED, unknown, AuthErrorResponse> | ApiRequestAction<typeof FETCH_USER, {
+    user: string | undefined;
+    isUserAllowedToMakeChanges: boolean;
+}, unknown>;

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

@@ -1,6 +1,7 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { clusterTabsIds, isClusterTab } from '../../../containers/Cluster/utils';
 import { DEFAULT_CLUSTER_TAB_KEY } from '../../../utils/constants';
+import { isQueryErrorResponse } from '../../../utils/query';
 import { api } from '../api';
 import { createSelectClusterGroupsQuery, parseGroupsStatsQueryResponse } from './utils';
 const defaultClusterTabLS = localStorage.getItem(DEFAULT_CLUSTER_TAB_KEY);
@@ -54,6 +55,9 @@ export const clusterApi = api.injectEndpoints({
                             database: clusterRoot,
                             action: 'execute-scan',
                         });
+                        if (isQueryErrorResponse(groupsStatsResponse)) {
+                            return { data: { clusterData } };
+                        }
                         return {
                             data: {
                                 clusterData,

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

@@ -1,7 +1,7 @@
 import type { Reducer } from '@reduxjs/toolkit';
 import type { Schemas } from '../../types/api/query';
 import type { ExecuteQueryAction, ExecuteQueryState, ExecuteQueryStateSlice, QueryInHistory } from '../../types/store/executeQuery';
-import type { QueryMode, QueryRequestParams } from '../../types/store/query';
+import type { IQueryResult, QueryMode, QueryRequestParams } from '../../types/store/query';
 export declare const SEND_QUERY: {
     readonly REQUEST: "query/SEND_QUERY_REQUEST";
     readonly SUCCESS: "query/SEND_QUERY_SUCCESS";
@@ -12,68 +12,9 @@ interface SendQueryParams extends QueryRequestParams {
     mode?: QueryMode;
     schema?: Schemas;
 }
-export declare const sendExecuteQuery: ({ query, database, mode, schema }: SendQueryParams) => (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
-    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
-    singleClusterMode: boolean;
-    cluster: import("./cluster/types").ClusterState;
-    tenant: import("./tenant/types").TenantState;
-    tooltip: import("../../types/store/tooltip").ITooltipState;
-    tablets: import("../../types/store/tablets").TabletsState;
-    schema: import("./schema/types").SchemaState;
-    host: import("../../types/store/host").IHostState;
-    tenants: import("./tenants/types").TenantsState;
-    partitions: import("./partitions/types").PartitionsState;
-    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;
-    schemaAcl: import("./schemaAcl/types").SchemaAclState;
-    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").ClustersFilters;
-}) => Promise<import("../../types/store/query").IQueryResult | undefined>;
+export declare const executeQueryApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    executeQuery: import("@reduxjs/toolkit/query").MutationDefinition<SendQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", IQueryResult, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
 export declare const saveQueryToHistory: (queryText: string, mode: QueryMode) => {
     readonly type: "query/SAVE_QUERY_TO_HISTORY";
     readonly data: {

package/dist/store/reducers/executeQuery.js

@@ -1,8 +1,8 @@
 import { settingsManager } from '../../services/settings';
 import { QUERIES_HISTORY_KEY } from '../../utils/constants';
-import { parseQueryError } from '../../utils/error';
-import { QUERY_MODES, QUERY_SYNTAX, parseQueryAPIExecuteResponse } from '../../utils/query';
-import { createApiRequest, createRequestActionTypes } from '../utils';
+import { QUERY_MODES, QUERY_SYNTAX, isQueryErrorResponse, parseQueryAPIExecuteResponse, } from '../../utils/query';
+import { createRequestActionTypes } from '../utils';
+import { api } from './api';
 const MAXIMUM_QUERIES_IN_HISTORY = 20;
 export const SEND_QUERY = createRequestActionTypes('query', 'SEND_QUERY');
 const CHANGE_USER_INPUT = 'query/CHANGE_USER_INPUT';
@@ -26,15 +26,6 @@ const initialState = {
 };
 const executeQuery = (state = initialState, action) => {
     switch (action.type) {
-        case SEND_QUERY.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true, data: undefined, error: undefined });
-        }
-        case SEND_QUERY.SUCCESS: {
-            return Object.assign(Object.assign({}, state), { data: action.data, stats: action.data.stats, loading: false, error: undefined });
-        }
-        case SEND_QUERY.FAILURE: {
-            return Object.assign(Object.assign({}, state), { error: parseQueryError(action.error), loading: false });
-        }
         case CHANGE_USER_INPUT: {
             return Object.assign(Object.assign({}, state), { input: action.data.input });
         }
@@ -76,29 +67,42 @@ const executeQuery = (state = initialState, action) => {
             return state;
     }
 };
-export const sendExecuteQuery = ({ query, database, mode, schema = 'modern' }) => {
-    let action = 'execute';
-    let syntax = QUERY_SYNTAX.yql;
-    if (mode === 'pg') {
-        action = 'execute-query';
-        syntax = QUERY_SYNTAX.pg;
-    }
-    else if (mode) {
-        action = `execute-${mode}`;
-    }
-    return createApiRequest({
-        request: window.api.sendQuery({
-            schema,
-            query,
-            database,
-            action,
-            syntax,
-            stats: 'full',
+export const executeQueryApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        executeQuery: build.mutation({
+            queryFn: async ({ query, database, mode, schema = 'modern' }) => {
+                let action = 'execute';
+                let syntax = QUERY_SYNTAX.yql;
+                if (mode === 'pg') {
+                    action = 'execute-query';
+                    syntax = QUERY_SYNTAX.pg;
+                }
+                else if (mode) {
+                    action = `execute-${mode}`;
+                }
+                try {
+                    const response = await window.api.sendQuery({
+                        schema,
+                        query,
+                        database,
+                        action,
+                        syntax,
+                        stats: 'full',
+                    });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    const data = parseQueryAPIExecuteResponse(response);
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
         }),
-        actions: SEND_QUERY,
-        dataHandler: parseQueryAPIExecuteResponse,
-    });
-};
+    }),
+    overrideExisting: 'throw',
+});
 export const saveQueryToHistory = (queryText, mode) => {
     return {
         type: SAVE_QUERY_TO_HISTORY,

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

@@ -1,6 +1,6 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { HOUR_IN_SECONDS } from '../../../utils/constants';
-import { parseQueryAPIExecuteResponse } from '../../../utils/query';
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../../utils/query';
 import { api } from '../api';
 import { getFiltersConditions } from './utils';
 const initialState = {};
@@ -43,6 +43,9 @@ export const topQueriesApi = api.injectEndpoints({
                         database,
                         action: 'execute-scan',
                     }, { signal });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
                     const data = parseQueryAPIExecuteResponse(response);
                     // FIXME: do we really need this?
                     if (!(filters === null || filters === void 0 ? void 0 : filters.from) && !(filters === null || filters === void 0 ? void 0 : filters.to)) {

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

@@ -0,0 +1,9 @@
+import type { QueryMode, QueryRequestParams } from '../../../types/store/query';
+import type { PreparedExplainResponse } from './types';
+interface ExplainQueryParams extends QueryRequestParams {
+    mode?: QueryMode;
+}
+export declare const explainQueryApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    explainQuery: import("@reduxjs/toolkit/query").MutationDefinition<ExplainQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", PreparedExplainResponse, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export {};

package/dist/store/reducers/explainQuery/explainQuery.js

@@ -0,0 +1,32 @@
+import { QUERY_SYNTAX, isQueryErrorResponse } from '../../../utils/query';
+import { api } from '../api';
+import { prepareExplainResponse } from './utils';
+export const explainQueryApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        explainQuery: build.mutation({
+            queryFn: async ({ query, database, mode }) => {
+                let action = 'explain';
+                let syntax = QUERY_SYNTAX.yql;
+                if (mode === 'pg') {
+                    action = 'explain-query';
+                    syntax = QUERY_SYNTAX.pg;
+                }
+                else if (mode) {
+                    action = `explain-${mode}`;
+                }
+                try {
+                    const response = await window.api.getExplainQuery(query, database, action, syntax);
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    const data = prepareExplainResponse(response);
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -0,0 +1,12 @@
+import type { ExplainPlanNodeData, GraphNode, Link } from '@gravity-ui/paranoid';
+import type { PlanTable, QueryPlan, ScriptPlan } from '../../../types/api/query';
+export interface PreparedExplainResponse {
+    plan?: {
+        links?: Link[];
+        nodes?: GraphNode<ExplainPlanNodeData>[];
+        tables?: PlanTable[];
+        version?: string;
+        pristine?: QueryPlan | ScriptPlan;
+    };
+    ast?: string;
+}