ydb-embedded-ui 6.3.0 → 6.5.0

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

@@ -16,13 +16,71 @@ 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;
-    nodes: import("../nodes/types").NodesState;
     cluster: import("../cluster/types").ClusterState;
     tenant: import("../tenant/types").TenantState;
-    storage: import("../storage/types").StorageState;
     tooltip: import("../../../types/store/tooltip").ITooltipState;
     tablets: import("../../../types/store/tablets").TabletsState;
     schema: import("../schema/types").SchemaState;
@@ -30,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;
@@ -80,13 +137,71 @@ 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;
-    nodes: import("../nodes/types").NodesState;
     cluster: import("../cluster/types").ClusterState;
     tenant: import("../tenant/types").TenantState;
-    storage: import("../storage/types").StorageState;
     tooltip: import("../../../types/store/tooltip").ITooltipState;
     tablets: import("../../../types/store/tablets").TabletsState;
     schema: import("../schema/types").SchemaState;
@@ -94,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;
@@ -144,13 +258,71 @@ 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;
-    nodes: import("../nodes/types").NodesState;
     cluster: import("../cluster/types").ClusterState;
     tenant: import("../tenant/types").TenantState;
-    storage: import("../storage/types").StorageState;
     tooltip: import("../../../types/store/tooltip").ITooltipState;
     tablets: import("../../../types/store/tablets").TabletsState;
     schema: import("../schema/types").SchemaState;
@@ -158,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;
@@ -207,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,70 +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;
-    nodes: import("./nodes/types").NodesState;
-    cluster: import("./cluster/types").ClusterState;
-    tenant: import("./tenant/types").TenantState;
-    storage: import("./storage/types").StorageState;
-    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;
+}

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

@@ -0,0 +1,6 @@
+import type { ExplainQueryResponse, ExplainScriptResponse } from '../../../types/api/query';
+import type { PreparedExplainResponse } from './types';
+export declare const explainVersions: {
+    v2: string;
+};
+export declare const prepareExplainResponse: (response: ExplainScriptResponse | ExplainQueryResponse) => PreparedExplainResponse;

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

@@ -0,0 +1,40 @@
+import { preparePlan } from '../../../utils/prepareQueryExplain';
+import { parseQueryAPIExplainResponse, parseQueryExplainPlan } from '../../../utils/query';
+export const explainVersions = {
+    v2: '0.2',
+};
+const supportedExplainQueryVersions = Object.values(explainVersions);
+export const prepareExplainResponse = (response) => {
+    const { plan: rawPlan, ast } = parseQueryAPIExplainResponse(response);
+    if (!rawPlan) {
+        return { ast };
+    }
+    const { tables, meta, Plan } = parseQueryExplainPlan(rawPlan);
+    if (supportedExplainQueryVersions.indexOf(meta.version) === -1) {
+        // Do not prepare plan for not supported versions
+        return {
+            plan: {
+                pristine: rawPlan,
+                version: meta.version,
+            },
+            ast,
+        };
+    }
+    let links = [];
+    let nodes = [];
+    if (Plan) {
+        const preparedPlan = preparePlan(Plan);
+        links = preparedPlan.links;
+        nodes = preparedPlan.nodes;
+    }
+    return {
+        plan: {
+            links,
+            nodes,
+            tables,
+            version: meta.version,
+            pristine: rawPlan,
+        },
+        ast,
+    };
+};