ydb-embedded-ui 6.12.0 → 6.13.0

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

@@ -1,62 +1,82 @@
-import { createApiRequest, createRequestActionTypes } from '../../utils';
-export const SET_UNAUTHENTICATED = createRequestActionTypes('authentication', 'SET_UNAUTHENTICATED');
-export const SET_AUTHENTICATED = createRequestActionTypes('authentication', 'SET_AUTHENTICATED');
-export const FETCH_USER = createRequestActionTypes('authentication', 'FETCH_USER');
+import { createSlice } from '@reduxjs/toolkit';
+import { isAxiosResponse } from '../../../utils/response';
+import { api } from '../api';
 const initialState = {
     isAuthenticated: true,
     user: '',
-    error: undefined,
 };
-const authentication = (state = initialState, action) => {
-    switch (action.type) {
-        case SET_UNAUTHENTICATED.SUCCESS: {
-            return { ...state, isAuthenticated: false, user: '', error: undefined };
-        }
-        case SET_AUTHENTICATED.SUCCESS: {
-            return { ...state, isAuthenticated: true, error: undefined };
-        }
-        case SET_AUTHENTICATED.FAILURE: {
-            return { ...state, error: action.error };
-        }
-        case FETCH_USER.SUCCESS: {
-            const { user, isUserAllowedToMakeChanges } = action.data;
-            return {
-                ...state,
-                user,
-                isUserAllowedToMakeChanges,
-            };
-        }
-        default:
-            return { ...state };
-    }
-};
-export const authenticate = (user, password) => {
-    return createApiRequest({
-        request: window.api.authenticate(user, password),
-        actions: SET_AUTHENTICATED,
-    });
-};
-export const logout = () => {
-    return createApiRequest({
-        request: window.api.logout(),
-        actions: SET_UNAUTHENTICATED,
-    });
-};
-export const getUser = () => {
-    return createApiRequest({
-        request: window.api.whoami(),
-        actions: FETCH_USER,
-        dataHandler: (data) => {
-            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,
-            };
+export const slice = createSlice({
+    name: 'authentication',
+    initialState,
+    reducers: {
+        setIsAuthenticated: (state, action) => {
+            const isAuthenticated = action.payload;
+            state.isAuthenticated = isAuthenticated;
+            if (!isAuthenticated) {
+                state.user = '';
+            }
         },
-    });
-};
-export default authentication;
+        setUser: (state, action) => {
+            const { UserSID, AuthType, IsMonitoringAllowed } = action.payload;
+            state.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
+            state.isUserAllowedToMakeChanges = IsMonitoringAllowed !== false;
+        },
+    },
+    selectors: {
+        selectIsUserAllowedToMakeChanges: (state) => state.isUserAllowedToMakeChanges,
+        selectUser: (state) => state.user,
+    },
+});
+export default slice.reducer;
+export const { setIsAuthenticated, setUser } = slice.actions;
+export const { selectIsUserAllowedToMakeChanges, selectUser } = slice.selectors;
+export const authenticationApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        whoami: build.query({
+            queryFn: async (_, { dispatch }) => {
+                try {
+                    const data = await window.api.whoami();
+                    dispatch(setUser(data));
+                    return { data };
+                }
+                catch (error) {
+                    if (isAxiosResponse(error) && error.status === 401) {
+                        dispatch(setIsAuthenticated(false));
+                    }
+                    return { error };
+                }
+            },
+            providesTags: ['UserData'],
+        }),
+        authenticate: build.mutation({
+            queryFn: async (params, { dispatch }) => {
+                try {
+                    const data = await window.api.authenticate(params);
+                    dispatch(setIsAuthenticated(true));
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            invalidatesTags: (_, error) => (error ? [] : ['UserData']),
+        }),
+        logout: build.mutation({
+            queryFn: async (_, { dispatch }) => {
+                try {
+                    const data = await window.api.logout();
+                    dispatch(setIsAuthenticated(false));
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -1,13 +1,5 @@
-import type { AuthErrorResponse } from '../../../types/api/error';
-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, {
-    user: string | undefined;
-    isUserAllowedToMakeChanges: boolean;
-}, unknown>;

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

@@ -0,0 +1,106 @@
+import type { Capability } from '../../../types/api/capabilities';
+import type { RootState } from '../../defaultStore';
+export declare const capabilitiesApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./../api")._NEVER, unknown, {}>, {
+    getClusterCapabilities: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./../api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", import("../../../types/api/capabilities").CapabilitiesResponse | undefined, "api">;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+export declare const selectCapabilityVersion: ((state: {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All" | "PDiskData" | "UserData", "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;
+    tenants: import("../tenants/types").TenantsState;
+    partitions: import("../partitions/types").PartitionsState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    heatmap: import("../../../types/store/heatmap").IHeatmapState;
+    settings: import("../settings/types").SettingsState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+    authentication: import("../authentication/types").AuthenticationState;
+    header: import("../header/types").HeaderState;
+    queryActions: import("../queryActions/types").QueryActionsState;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersFilters;
+}, capability: Capability) => number | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: {
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, "All" | "PDiskData" | "UserData", "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;
+        tenants: import("../tenants/types").TenantsState;
+        partitions: import("../partitions/types").PartitionsState;
+        executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+        heatmap: import("../../../types/store/heatmap").IHeatmapState;
+        settings: import("../settings/types").SettingsState;
+        executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+        shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+        authentication: import("../authentication/types").AuthenticationState;
+        header: import("../header/types").HeaderState;
+        queryActions: import("../queryActions/types").QueryActionsState;
+        fullscreen: boolean;
+        clusters: import("../clusters/types").ClustersFilters;
+    }, resultFuncArgs_1: Capability) => number | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: {
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, "All" | "PDiskData" | "UserData", "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;
+        tenants: import("../tenants/types").TenantsState;
+        partitions: import("../partitions/types").PartitionsState;
+        executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+        heatmap: import("../../../types/store/heatmap").IHeatmapState;
+        settings: import("../settings/types").SettingsState;
+        executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+        shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+        authentication: import("../authentication/types").AuthenticationState;
+        header: import("../header/types").HeaderState;
+        queryActions: import("../queryActions/types").QueryActionsState;
+        fullscreen: boolean;
+        clusters: import("../clusters/types").ClustersFilters;
+    }, resultFuncArgs_1: Capability) => number | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number | undefined;
+    dependencies: [(state: RootState) => {
+        api: import("@reduxjs/toolkit/query").CombinedState<{}, "All" | "PDiskData" | "UserData", "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;
+        tenants: import("../tenants/types").TenantsState;
+        partitions: import("../partitions/types").PartitionsState;
+        executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+        heatmap: import("../../../types/store/heatmap").IHeatmapState;
+        settings: import("../settings/types").SettingsState;
+        executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+        shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+        authentication: import("../authentication/types").AuthenticationState;
+        header: import("../header/types").HeaderState;
+        queryActions: import("../queryActions/types").QueryActionsState;
+        fullscreen: boolean;
+        clusters: import("../clusters/types").ClustersFilters;
+    }, (_state: RootState, capability: Capability) => Capability];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/store/reducers/capabilities/capabilities.js

@@ -0,0 +1,22 @@
+import { createSelector } from '@reduxjs/toolkit';
+import { api } from './../api';
+export const capabilitiesApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        getClusterCapabilities: build.query({
+            queryFn: async () => {
+                try {
+                    const data = await window.api.getClusterCapabilities();
+                    return { data };
+                }
+                catch (error) {
+                    // If capabilities endpoint is not available, there will be an error
+                    // That means no new features are available
+                    return { error };
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});
+const selectCapabilities = capabilitiesApi.endpoints.getClusterCapabilities.select(undefined);
+export const selectCapabilityVersion = createSelector((state) => state, (_state, capability) => capability, (state, capability) => { var _a, _b; return (_b = (_a = selectCapabilities(state).data) === null || _a === void 0 ? void 0 : _a.Capabilities) === null || _b === void 0 ? void 0 : _b[capability]; });

package/dist/store/reducers/capabilities/hooks.d.ts

@@ -0,0 +1,2 @@
+export declare const useCreateDirectoryFeatureAvailable: () => boolean;
+export declare const useDiskPagesAvailable: () => boolean;

package/dist/store/reducers/capabilities/hooks.js

@@ -0,0 +1,13 @@
+import { useTypedSelector } from '../../../utils/hooks';
+import { selectCapabilityVersion } from './capabilities';
+const useGetFeatureVersion = (feature) => {
+    return useTypedSelector((state) => selectCapabilityVersion(state, feature) || 0);
+};
+export const useCreateDirectoryFeatureAvailable = () => {
+    return useGetFeatureVersion('/scheme/directory') > 0;
+};
+export const useDiskPagesAvailable = () => {
+    // New PDisk (info, restart) and VDisk (evict) handlers was made at the same time
+    // It's enough to check only pdisk handler
+    return useGetFeatureVersion('/pdisk/info') > 0;
+};

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

@@ -5,8 +5,8 @@ export declare function updateDefaultClusterTab(tab: string): (dispatch: Dispatc
 declare const _default: import("redux").Reducer<ClusterState>;
 export default _default;
 export declare const clusterApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
-    getClusterInfo: import("@reduxjs/toolkit/query").QueryDefinition<string | undefined, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData", {
+    getClusterInfo: import("@reduxjs/toolkit/query").QueryDefinition<string | undefined, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", {
         clusterData: TClusterInfo;
         groupsStats?: ClusterGroupsStats;
     }, "api">;
-}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -1,5 +1,5 @@
 import type { PreparedNodeSystemState } from '../../../utils/nodes';
 export type PreparedClusterNode = PreparedNodeSystemState;
 export declare const clusterNodesApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
-    getClusterNodes: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData", PreparedNodeSystemState[] | undefined, "api">;
-}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+    getClusterNodes: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", PreparedNodeSystemState[] | undefined, "api">;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -3,5 +3,5 @@ declare const _default: import("redux").Reducer<ClustersFilters>;
 export default _default;
 export declare const changeClustersFilters: import("@reduxjs/toolkit").ActionCreatorWithPayload<Partial<ClustersFilters>, "clusters/changeClustersFilters">;
 export declare const clustersApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
-    getClustersList: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData", import("./types").PreparedCluster[] | undefined, "api">;
-}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+    getClustersList: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", import("./types").PreparedCluster[] | undefined, "api">;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -3,5 +3,5 @@ export declare const describeApi: import("@reduxjs/toolkit/query").Api<import("@
     getDescribe: import("@reduxjs/toolkit/query").QueryDefinition<{
         paths: string[];
         database: string;
-    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All" | "PDiskData", IDescribeData | undefined, "api">;
-}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", IDescribeData | undefined, "api">;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -1,26 +1,19 @@
 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 { IQueryResult, QueryMode, QueryRequestParams } from '../../types/store/query';
-export declare const SEND_QUERY: {
-    readonly REQUEST: "query/SEND_QUERY_REQUEST";
-    readonly SUCCESS: "query/SEND_QUERY_SUCCESS";
-    readonly FAILURE: "query/SEND_QUERY_FAILURE";
-};
+import type { IQueryResult, QueryRequestParams, QuerySettings } from '../../types/store/query';
 declare const executeQuery: Reducer<ExecuteQueryState, ExecuteQueryAction>;
 interface SendQueryParams extends QueryRequestParams {
-    mode?: QueryMode;
+    querySettings?: Partial<QuerySettings>;
     schema?: Schemas;
+    enableTracingLevel?: boolean;
 }
 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" | "PDiskData", IQueryResult, "api">;
-}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
-export declare const saveQueryToHistory: (queryText: string, mode: QueryMode) => {
+    executeQuery: import("@reduxjs/toolkit/query").MutationDefinition<SendQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", IQueryResult, "api">;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+export declare const saveQueryToHistory: (queryText: string) => {
     readonly type: "query/SAVE_QUERY_TO_HISTORY";
-    readonly data: {
-        readonly queryText: string;
-        readonly mode: QueryMode;
-    };
+    readonly data: string;
 };
 export declare const goToPreviousQuery: () => {
     readonly type: "query/GO_TO_PREVIOUS_QUERY";

package/dist/store/reducers/executeQuery.js

@@ -1,10 +1,10 @@
 import { settingsManager } from '../../services/settings';
+import { TracingLevelNumber } from '../../types/api/query';
 import { QUERIES_HISTORY_KEY } from '../../utils/constants';
-import { QUERY_MODES, QUERY_SYNTAX, isQueryErrorResponse, parseQueryAPIExecuteResponse, } from '../../utils/query';
-import { createRequestActionTypes } from '../utils';
+import { QUERY_SYNTAX, isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../utils/query';
+import { isNumeric } from '../../utils/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';
 const SAVE_QUERY_TO_HISTORY = 'query/SAVE_QUERY_TO_HISTORY';
 const GO_TO_PREVIOUS_QUERY = 'query/GO_TO_PREVIOUS_QUERY';
@@ -33,10 +33,8 @@ const executeQuery = (state = initialState, action) => {
             };
         }
         case SAVE_QUERY_TO_HISTORY: {
-            const queryText = action.data.queryText;
-            // Do not save explicit yql syntax value for easier further support (use yql by default)
-            const syntax = action.data.mode === QUERY_MODES.pg ? QUERY_SYNTAX.pg : undefined;
-            const newQueries = [...state.history.queries, { queryText, syntax }].slice(state.history.queries.length >= MAXIMUM_QUERIES_IN_HISTORY ? 1 : 0);
+            const queryText = action.data;
+            const newQueries = [...state.history.queries, { queryText }].slice(state.history.queries.length >= MAXIMUM_QUERIES_IN_HISTORY ? 1 : 0);
             settingsManager.setUserSettingsValue(QUERIES_HISTORY_KEY, newQueries);
             const currentIndex = newQueries.length - 1;
             return {
@@ -93,15 +91,15 @@ const executeQuery = (state = initialState, action) => {
 export const executeQueryApi = api.injectEndpoints({
     endpoints: (build) => ({
         executeQuery: build.mutation({
-            queryFn: async ({ query, database, mode, schema = 'modern' }) => {
+            queryFn: async ({ query, database, querySettings = {}, schema = 'modern', enableTracingLevel, }) => {
                 let action = 'execute';
                 let syntax = QUERY_SYNTAX.yql;
-                if (mode === 'pg') {
+                if (querySettings.queryMode === 'pg') {
                     action = 'execute-query';
                     syntax = QUERY_SYNTAX.pg;
                 }
-                else if (mode) {
-                    action = `execute-${mode}`;
+                else if (querySettings.queryMode) {
+                    action = `execute-${querySettings.queryMode}`;
                 }
                 try {
                     const response = await window.api.sendQuery({
@@ -110,7 +108,14 @@ export const executeQueryApi = api.injectEndpoints({
                         database,
                         action,
                         syntax,
-                        stats: 'full',
+                        stats: querySettings.statisticsMode,
+                        tracingLevel: querySettings.tracingLevel && enableTracingLevel
+                            ? TracingLevelNumber[querySettings.tracingLevel]
+                            : undefined,
+                        transaction_mode: querySettings.isolationLevel,
+                        timeout: isNumeric(querySettings.timeout)
+                            ? Number(querySettings.timeout) * 1000
+                            : undefined,
                     });
                     if (isQueryErrorResponse(response)) {
                         return { error: response };
@@ -126,10 +131,10 @@ export const executeQueryApi = api.injectEndpoints({
     }),
     overrideExisting: 'throw',
 });
-export const saveQueryToHistory = (queryText, mode) => {
+export const saveQueryToHistory = (queryText) => {
     return {
         type: SAVE_QUERY_TO_HISTORY,
-        data: { queryText, mode },
+        data: queryText,
     };
 };
 export const goToPreviousQuery = () => {

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

@@ -6,5 +6,5 @@ export declare const topQueriesApi: import("@reduxjs/toolkit/query").Api<import(
     getTopQueries: import("@reduxjs/toolkit/query").QueryDefinition<{
         database: string;
         filters?: TopQueriesFilters;
-    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData", import("../../../types/store/query").IQueryResult | undefined, "api">;
-}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", import("../../../types/store/query").IQueryResult | undefined, "api">;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;

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

@@ -1,9 +1,10 @@
-import type { QueryMode, QueryRequestParams } from '../../../types/store/query';
+import type { QueryRequestParams, QuerySettings } from '../../../types/store/query';
 import type { PreparedExplainResponse } from './types';
 interface ExplainQueryParams extends QueryRequestParams {
-    mode?: QueryMode;
+    querySettings?: Partial<QuerySettings>;
+    enableTracingLevel?: boolean;
 }
 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" | "PDiskData", PreparedExplainResponse, "api">;
-}, "api", "All" | "PDiskData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
+    explainQuery: import("@reduxjs/toolkit/query").MutationDefinition<ExplainQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All" | "PDiskData" | "UserData", PreparedExplainResponse, "api">;
+}, "api", "All" | "PDiskData" | "UserData", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;
 export {};

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

@@ -1,18 +1,20 @@
+import { TracingLevelNumber } from '../../../types/api/query';
 import { QUERY_SYNTAX, isQueryErrorResponse } from '../../../utils/query';
+import { isNumeric } from '../../../utils/utils';
 import { api } from '../api';
 import { prepareExplainResponse } from './utils';
 export const explainQueryApi = api.injectEndpoints({
     endpoints: (build) => ({
         explainQuery: build.mutation({
-            queryFn: async ({ query, database, mode }) => {
+            queryFn: async ({ query, database, querySettings, enableTracingLevel }) => {
                 let action = 'explain';
                 let syntax = QUERY_SYNTAX.yql;
-                if (mode === 'pg') {
+                if ((querySettings === null || querySettings === void 0 ? void 0 : querySettings.queryMode) === 'pg') {
                     action = 'explain-query';
                     syntax = QUERY_SYNTAX.pg;
                 }
-                else if (mode) {
-                    action = `explain-${mode}`;
+                else if (querySettings === null || querySettings === void 0 ? void 0 : querySettings.queryMode) {
+                    action = `explain-${querySettings === null || querySettings === void 0 ? void 0 : querySettings.queryMode}`;
                 }
                 try {
                     const response = await window.api.sendQuery({
@@ -20,6 +22,14 @@ export const explainQueryApi = api.injectEndpoints({
                         database,
                         action,
                         syntax,
+                        stats: querySettings === null || querySettings === void 0 ? void 0 : querySettings.statisticsMode,
+                        tracingLevel: (querySettings === null || querySettings === void 0 ? void 0 : querySettings.tracingLevel) && enableTracingLevel
+                            ? TracingLevelNumber[querySettings === null || querySettings === void 0 ? void 0 : querySettings.tracingLevel]
+                            : undefined,
+                        transaction_mode: querySettings === null || querySettings === void 0 ? void 0 : querySettings.isolationLevel,
+                        timeout: isNumeric(querySettings === null || querySettings === void 0 ? void 0 : querySettings.timeout)
+                            ? Number(querySettings === null || querySettings === void 0 ? void 0 : querySettings.timeout) * 1000
+                            : undefined,
                     });
                     if (isQueryErrorResponse(response)) {
                         return { error: response };

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

@@ -1,5 +1,5 @@
 import type { ExplainPlanNodeData, GraphNode, Link } from '@gravity-ui/paranoid';
-import type { PlanTable, QueryPlan, ScriptPlan } from '../../../types/api/query';
+import type { PlanTable, QueryPlan, ScriptPlan, SimlifiedPlanOperatorOtherParams } from '../../../types/api/query';
 export interface PreparedExplainResponse {
     plan?: {
         links?: Link[];
@@ -8,5 +8,17 @@ export interface PreparedExplainResponse {
         version?: string;
         pristine?: QueryPlan | ScriptPlan;
     };
+    simplifiedPlan?: SimplifiedPlanItem[];
     ast?: string;
 }
+export interface SimplifiedPlanItem {
+    parentId?: string;
+    name: string;
+    operationParams: SimlifiedPlanOperatorOtherParams;
+    aCpu?: number;
+    aRows?: number;
+    eCost?: string;
+    eRows?: string;
+    eSize?: string;
+    children?: SimplifiedPlanItem[];
+}

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

@@ -1,4 +1,4 @@
-import { preparePlan } from '../../../utils/prepareQueryExplain';
+import { preparePlan, prepareSimplifiedPlan } from '../../../utils/prepareQueryExplain';
 import { parseQueryAPIExplainResponse, parseQueryExplainPlan } from '../../../utils/query';
 export const explainVersions = {
     v2: '0.2',
@@ -9,7 +9,7 @@ export const prepareExplainResponse = (response) => {
     if (!rawPlan) {
         return { ast };
     }
-    const { tables, meta, Plan } = parseQueryExplainPlan(rawPlan);
+    const { tables, meta, Plan, SimplifiedPlan } = parseQueryExplainPlan(rawPlan);
     if (supportedExplainQueryVersions.indexOf(meta.version) === -1) {
         // Do not prepare plan for not supported versions
         return {
@@ -27,6 +27,10 @@ export const prepareExplainResponse = (response) => {
         links = preparedPlan.links;
         nodes = preparedPlan.nodes;
     }
+    let preparedSimplifiedPlan;
+    if (SimplifiedPlan) {
+        preparedSimplifiedPlan = prepareSimplifiedPlan([SimplifiedPlan]);
+    }
     return {
         plan: {
             links,
@@ -35,6 +39,7 @@ export const prepareExplainResponse = (response) => {
             version: meta.version,
             pristine: rawPlan,
         },
+        simplifiedPlan: preparedSimplifiedPlan,
         ast,
     };
 };