ydb-embedded-ui 6.11.0 → 6.13.0

package/dist/routes.js

@@ -42,11 +42,11 @@ const prepareRoute = (route) => {
 };
 export function createHref(route, params, query = {}) {
     let extendedQuery = query;
-    const isBackendInQuery = Boolean(query.backend);
+    const isBackendInQuery = 'backend' in query && Boolean(query.backend);
     if (backend && !isBackendInQuery && webVersion) {
         extendedQuery = { ...query, backend };
     }
-    const isClusterNameInQuery = Boolean(query.clusterName);
+    const isClusterNameInQuery = 'clusterName' in query && Boolean(query.clusterName);
     if (clusterName && !isClusterNameInQuery && webVersion) {
         extendedQuery = { ...extendedQuery, clusterName };
     }

package/dist/services/api.d.ts

@@ -4,19 +4,20 @@ import type { ComputeApiRequestParams, NodesApiRequestParams } from '../store/re
 import type { StorageApiRequestParams } from '../store/reducers/storage/types';
 import type { TMetaInfo } from '../types/api/acl';
 import type { TQueryAutocomplete } from '../types/api/autocomplete';
+import type { CapabilitiesResponse } from '../types/api/capabilities';
 import type { TClusterInfo } from '../types/api/cluster';
 import type { TComputeInfo } from '../types/api/compute';
 import type { DescribeConsumerResult } from '../types/api/consumer';
 import type { HealthCheckAPIResponse } from '../types/api/healthcheck';
 import type { JsonHotKeysResponse } from '../types/api/hotkeys';
 import type { MetaClusters } from '../types/api/meta';
+import type { ModifyDiskResponse } from '../types/api/modifyDisk';
 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, ErrorResponse, ExplainActions, ExplainResponse, QueryAPIResponse, Schemas } from '../types/api/query';
+import type { TEvPDiskStateResponse, TPDiskInfoResponse } from '../types/api/pdisk';
+import type { Actions, ErrorResponse, QueryAPIResponse, Schemas, Stats, Timeout, TracingLevel, TransactionMode } 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';
 import type { TStorageInfo } from '../types/api/storage';
 import type { TEvSystemStateResponse } from '../types/api/systemState';
@@ -30,57 +31,73 @@ import type { Nullable } from '../utils/typecheckers';
 type AxiosOptions = {
     concurrentId?: string;
     signal?: AbortSignal;
+    withRetries?: boolean;
 };
 export declare class YdbEmbeddedAPI extends AxiosWrapper {
+    DEFAULT_RETRIES_COUNT: number;
     constructor(options?: AxiosWrapperOptions);
     getPath(path: string): string;
+    getClusterCapabilities(): Promise<CapabilitiesResponse>;
     getClusterInfo(clusterName?: string, { concurrentId, signal }?: AxiosOptions): Promise<TClusterInfo>;
     getClusterNodes({ concurrentId, signal }?: AxiosOptions): Promise<TEvSystemStateResponse>;
     getNodeInfo(id?: string | number, { concurrentId, signal }?: AxiosOptions): Promise<TEvSystemStateResponse>;
     getTenants(clusterName?: string, { concurrentId, signal }?: AxiosOptions): Promise<TTenantInfo>;
-    getTenantInfo({ path }: {
+    getTenantInfo({ path, database }: {
         path: string;
+        database?: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<TTenantInfo>;
     getNodes({ visibleEntities, type, tablets, sortOrder, sortValue, ...params }: NodesApiRequestParams, { concurrentId, signal }?: AxiosOptions): Promise<TNodesInfo>;
     /** @deprecated use getNodes instead */
     getCompute({ sortOrder, sortValue, ...params }: ComputeApiRequestParams, { concurrentId, signal }?: AxiosOptions): Promise<TComputeInfo>;
     getStorageInfo({ tenant, visibleEntities, nodeId, poolName, groupId, sortOrder, sortValue, ...params }: StorageApiRequestParams, { concurrentId, signal }?: AxiosOptions): Promise<TStorageInfo>;
-    getPDiskInfo({ nodeId, pDiskId }: {
+    getNodeWhiteboardPDiskInfo({ nodeId, pDiskId }: {
         nodeId: string | number;
         pDiskId: string | number;
     }, { concurrentId, signal }?: AxiosOptions): Promise<TEvPDiskStateResponse>;
+    getPDiskInfo({ nodeId, pDiskId }: {
+        nodeId: string | number;
+        pDiskId: string | number;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<TPDiskInfoResponse>;
     getVDiskInfo({ vDiskSlotId, pDiskId, nodeId, }: {
         vDiskSlotId: string | number;
         pDiskId: string | number;
         nodeId: string | number;
     }, { concurrentId, signal }?: AxiosOptions): Promise<TEvVDiskStateResponse>;
     getGroupInfo(groupId: string | number, { concurrentId, signal }?: AxiosOptions): Promise<TStorageInfo>;
-    getHostInfo({ concurrentId, signal }?: AxiosOptions): Promise<TEvSystemStateResponse>;
-    getTabletsInfo({ nodes, path }: {
+    getTabletsInfo({ nodes, path, database }: {
         nodes?: string[];
         path?: string;
+        database?: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<TEvTabletStateResponse>;
-    getSchema({ path }: {
+    getSchema({ path, database }: {
         path: string;
+        database: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<Nullable<TEvDescribeSchemeResult>>;
-    getDescribe({ path }: {
+    getDescribe({ path, database }: {
         path: string;
+        database: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<Nullable<TEvDescribeSchemeResult>>;
-    getSchemaAcl({ path }: {
+    getSchemaAcl({ path, database }: {
         path: string;
+        database: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<TMetaInfo>;
-    getHeatmapData({ path }: {
+    getHeatmapData({ path, database }: {
         path: string;
+        database: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<Nullable<TEvDescribeSchemeResult>>;
-    getNetwork(path: string, { concurrentId, signal }?: AxiosOptions): Promise<TNetInfo>;
-    getTopic({ path }: {
+    getNetwork({ path, database }: {
+        path: string;
+        database: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<TNetInfo>;
+    getTopic({ path, database }: {
         path?: string;
+        database?: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<DescribeTopicResult>;
-    getConsumer({ path, consumer }: {
+    getConsumer({ path, consumer, database }: {
         path: string;
         consumer: string;
+        database?: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<DescribeConsumerResult>;
-    getPoolInfo(poolName: string, { concurrentId, signal }?: AxiosOptions): Promise<TStorageInfo>;
     getTablet({ id }: {
         id?: string;
     }, { concurrentId, signal }?: AxiosOptions): Promise<TEvTabletStateResponse>;
@@ -89,37 +106,48 @@ export declare class YdbEmbeddedAPI extends AxiosWrapper {
     }, { concurrentId, signal }?: AxiosOptions): Promise<UnmergedTEvTabletStateResponse>;
     getNodesList({ concurrentId, signal }?: AxiosOptions): Promise<TEvNodesInfo>;
     getTenantsList({ concurrentId, signal }?: AxiosOptions): Promise<TTenants>;
-    sendQuery<Action extends Actions, Schema extends Schemas = undefined>({ schema, ...params }: {
+    sendQuery<Action extends Actions, Schema extends Schemas = undefined>(params: {
         query?: string;
         database?: string;
         action?: Action;
-        stats?: string;
         schema?: Schema;
         syntax?: QuerySyntax;
-    }, { 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>;
+        stats?: Stats;
+        tracingLevel?: TracingLevel;
+        transaction_mode?: TransactionMode;
+        timeout?: Timeout;
+    }, { concurrentId, signal, withRetries }?: AxiosOptions): Promise<ErrorResponse | QueryAPIResponse<Action, Schema>>;
+    getHotKeys({ path, database, enableSampling }: {
+        path: string;
+        database: string;
+        enableSampling: boolean;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<JsonHotKeysResponse>;
     getHealthcheckInfo({ database, maxLevel }: {
         database: string;
         maxLevel?: number;
     }, { concurrentId, signal }?: AxiosOptions): Promise<HealthCheckAPIResponse>;
-    evictVDisk({ groupId, groupGeneration, failRealmIdx, failDomainIdx, vDiskIdx, }: {
+    evictVDisk({ groupId, groupGeneration, failRealmIdx, failDomainIdx, vDiskIdx, force, }: {
         groupId: string | number;
         groupGeneration: string | number;
         failRealmIdx: string | number;
         failDomainIdx: string | number;
         vDiskIdx: string | number;
-    }): Promise<any>;
-    restartPDisk(nodeId: number | string, pDiskId: number | string): Promise<RestartPDiskResponse>;
+        force?: boolean;
+    }): Promise<ModifyDiskResponse>;
+    restartPDisk({ nodeId, pDiskId, force, }: {
+        nodeId: number | string;
+        pDiskId: number | string;
+        force?: boolean;
+    }): Promise<ModifyDiskResponse>;
     killTablet(id?: string): Promise<string>;
     stopTablet(id?: string, hiveId?: string): Promise<string>;
     resumeTablet(id?: string, hiveId?: string): Promise<string>;
     getTabletDescribe(tenantId: TDomainKey, { concurrentId, signal }?: AxiosOptions): Promise<Nullable<TEvDescribeSchemeResult>>;
     getChartData({ target, from, until, maxDataPoints, database }: JsonRenderRequestParams, { concurrentId, signal }?: AxiosOptions): Promise<JsonRenderResponse>;
-    /** @deprecated use localStorage instead */
-    postSetting(settingsApi: string, name: string, value: string): Promise<any>;
-    authenticate(user: string, password: string): Promise<any>;
+    authenticate(params: {
+        user: string;
+        password: string;
+    }): Promise<any>;
     logout(): Promise<any>;
     whoami(): Promise<TUserToken>;
     autocomplete(params: {
@@ -131,7 +159,10 @@ export declare class YdbEmbeddedAPI extends AxiosWrapper {
     getClustersList(_?: never, { signal }?: {
         signal?: AbortSignal;
     }): Promise<MetaClusters>;
-    createSchemaDirectory(database: string, path: string, { signal }?: {
+    createSchemaDirectory({ database, path }: {
+        database: string;
+        path: string;
+    }, { signal }?: {
         signal?: AbortSignal;
     }): Promise<{
         test: string;

package/dist/services/api.js

@@ -1,8 +1,8 @@
 import AxiosWrapper from '@gravity-ui/axios-wrapper';
 import axiosRetry from 'axios-retry';
+import qs from 'qs';
 import { backend as BACKEND, metaBackend as META_BACKEND } from '../store';
 import { BINARY_DATA_IN_PLAIN_TEXT_DISPLAY } from '../utils/constants';
-import { createPDiskDeveloperUILink } from '../utils/developerUI/developerUI';
 import { prepareSortValue } from '../utils/filters';
 import { parseMetaCluster } from './parsers/parseMetaCluster';
 import { parseMetaTenants } from './parsers/parseMetaTenants';
@@ -10,8 +10,9 @@ import { settingsManager } from './settings';
 export class YdbEmbeddedAPI extends AxiosWrapper {
     constructor(options) {
         super(options);
+        this.DEFAULT_RETRIES_COUNT = 3;
         axiosRetry(this._axios, {
-            retries: 3,
+            retries: this.DEFAULT_RETRIES_COUNT,
             retryDelay: axiosRetry.exponentialDelay,
         });
         // Interceptor to process OIDC auth
@@ -22,7 +23,7 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             // authUrl - external auth service link, after successful auth additional cookies will be appended
             // that will allow access to clusters where OIDC proxy is a balancer
             if (response && response.status === 401 && ((_a = response.data) === null || _a === void 0 ? void 0 : _a.authUrl)) {
-                return window.location.assign(response.data.authUrl);
+                window.location.assign(response.data.authUrl);
             }
             return Promise.reject(error);
         });
@@ -30,6 +31,9 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
     getPath(path) {
         return `${BACKEND !== null && BACKEND !== void 0 ? BACKEND : ''}${path}`;
     }
+    getClusterCapabilities() {
+        return this.get(this.getPath('/viewer/capabilities'), {}, {});
+    }
     getClusterInfo(clusterName, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/cluster'), {
             name: clusterName,
@@ -51,16 +55,17 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             cluster_name: clusterName,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getTenantInfo({ path }, { concurrentId, signal } = {}) {
+    getTenantInfo({ path, database = path }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/tenantinfo'), {
+            database,
             path,
             tablets: true,
             storage: true,
-        }, { concurrentId: concurrentId || `getTenantInfo|${path}`, requestConfig: { signal } });
+        }, { concurrentId, requestConfig: { signal } });
     }
     getNodes({ visibleEntities, type = 'any', tablets = true, sortOrder, sortValue, ...params }, { concurrentId, signal } = {}) {
         const sort = prepareSortValue(sortValue, sortOrder);
-        return this.get(this.getPath('/viewer/json/nodes?enums=true'), { with: visibleEntities, type, tablets, sort, ...params }, { concurrentId, requestConfig: { signal } });
+        return this.get(this.getPath('/viewer/json/nodes?enums=true'), { with: visibleEntities, type, tablets, sort, database: params.tenant, ...params }, { concurrentId, requestConfig: { signal } });
     }
     /** @deprecated use getNodes instead */
     getCompute({ sortOrder, sortValue, ...params }, { concurrentId, signal } = {}) {
@@ -70,6 +75,7 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
     getStorageInfo({ tenant, visibleEntities, nodeId, poolName, groupId, sortOrder, sortValue, ...params }, { concurrentId, signal } = {}) {
         const sort = prepareSortValue(sortValue, sortOrder);
         return this.get(this.getPath(`/viewer/json/storage?enums=true`), {
+            database: tenant,
             tenant,
             node_id: nodeId,
             pool: poolName,
@@ -79,11 +85,17 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             ...params,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getPDiskInfo({ nodeId, pDiskId }, { concurrentId, signal } = {}) {
+    getNodeWhiteboardPDiskInfo({ nodeId, pDiskId }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/pdiskinfo?enums=true'), {
             filter: `(NodeId=${nodeId}${pDiskId ? `;PDiskId=${pDiskId}` : ''})`,
         }, { concurrentId, requestConfig: { signal } });
     }
+    getPDiskInfo({ nodeId, pDiskId }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/pdisk/info'), {
+            node_id: nodeId,
+            pdisk_id: pDiskId,
+        }, { concurrentId, requestConfig: { signal } });
+    }
     getVDiskInfo({ vDiskSlotId, pDiskId, nodeId, }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/vdiskinfo?enums=true'), {
             node_id: nodeId,
@@ -95,19 +107,18 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             group_id: groupId,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getHostInfo({ concurrentId, signal } = {}) {
-        return this.get(this.getPath('/viewer/json/sysinfo?node_id=.&enums=true'), { concurrentId, requestConfig: { signal } });
-    }
-    getTabletsInfo({ nodes = [], path }, { concurrentId, signal } = {}) {
+    getTabletsInfo({ nodes = [], path, database }, { concurrentId, signal } = {}) {
         const filter = nodes.length > 0 && `(NodeId=[${nodes.join(',')}])`;
         return this.get(this.getPath('/viewer/json/tabletinfo'), {
+            database,
             filter,
             path,
             enums: true,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getSchema({ path }, { concurrentId, signal } = {}) {
+    getSchema({ path, database }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/describe'), {
+            database,
             path,
             enums: true,
             backup: false,
@@ -118,22 +129,25 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             subs: 1,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getDescribe({ path }, { concurrentId, signal } = {}) {
+    getDescribe({ path, database }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/describe'), {
+            database,
             path,
             enums: true,
             partition_stats: true,
             subs: 0,
         }, { concurrentId: concurrentId || `getDescribe|${path}`, requestConfig: { signal } });
     }
-    getSchemaAcl({ path }, { concurrentId, signal } = {}) {
+    getSchemaAcl({ path, database }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/acl'), {
+            database,
             path,
             merge_rules: true,
-        }, { concurrentId: concurrentId || `getSchemaAcl`, requestConfig: { signal } });
+        }, { concurrentId, requestConfig: { signal } });
     }
-    getHeatmapData({ path }, { concurrentId, signal } = {}) {
+    getHeatmapData({ path, database }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/describe'), {
+            database,
             path,
             enums: true,
             backup: false,
@@ -142,33 +156,30 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             partition_stats: true,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getNetwork(path, { concurrentId, signal } = {}) {
+    getNetwork({ path, database }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/netinfo'), {
             enums: true,
+            database,
             path,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getTopic({ path }, { concurrentId, signal } = {}) {
+    getTopic({ path, database }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/describe_topic'), {
             enums: true,
             include_stats: true,
+            database,
             path,
         }, { concurrentId, requestConfig: { signal } });
     }
-    getConsumer({ path, consumer }, { concurrentId, signal } = {}) {
+    getConsumer({ path, consumer, database }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/describe_consumer'), {
             enums: true,
             include_stats: true,
+            database,
             path,
             consumer,
         }, { concurrentId: concurrentId || 'getConsumer', requestConfig: { signal } });
     }
-    getPoolInfo(poolName, { concurrentId, signal } = {}) {
-        return this.get(this.getPath('/viewer/json/storage'), {
-            pool: poolName,
-            enums: true,
-        }, { concurrentId, requestConfig: { signal } });
-    }
     getTablet({ id }, { concurrentId, signal } = {}) {
         return this.get(this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`), {
             enums: true,
@@ -203,88 +214,64 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             requestConfig: { signal },
         });
     }
-    sendQuery({ schema, ...params }, { concurrentId, signal } = {}) {
-        // Time difference to ensure that timeout from ui will be shown rather than backend error
-        const uiTimeout = 9 * 60 * 1000;
-        const backendTimeout = 10 * 60 * 1000;
+    sendQuery(params, { concurrentId, signal, withRetries } = {}) {
         /**
          * Return strings using base64 encoding.
          * @link https://github.com/ydb-platform/ydb/pull/647
          */
         const base64 = !settingsManager.readUserSettingsValue(BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, true);
-        return this.post(this.getPath(`/viewer/json/query?timeout=${backendTimeout}&base64=${base64}${schema ? `&schema=${schema}` : ''}`), params, {}, {
+        return this.post(this.getPath('/viewer/json/query'), { ...params, base64 }, {}, {
             concurrentId,
-            timeout: uiTimeout,
-            requestConfig: { signal },
+            timeout: params.timeout,
+            requestConfig: {
+                signal,
+                'axios-retry': { retries: withRetries ? this.DEFAULT_RETRIES_COUNT : 0 },
+            },
+            headers: params.tracingLevel
+                ? {
+                    'X-Trace-Verbosity': params.tracingLevel,
+                }
+                : undefined,
         });
     }
-    getExplainQuery(query, database, action, syntax) {
-        return this.post(this.getPath('/viewer/json/query'), {
-            query,
-            database,
-            action: action || 'explain',
-            syntax,
-            timeout: 600000,
-        }, {});
-    }
-    getExplainQueryAst(query, database) {
-        return this.post(this.getPath('/viewer/json/query'), {
-            query,
-            database,
-            action: 'explain-ast',
-            timeout: 600000,
-        }, {});
-    }
-    getHotKeys(path, enableSampling, { concurrentId, signal } = {}) {
+    getHotKeys({ path, database, enableSampling }, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/hotkeys'), {
+            database,
             path,
             enable_sampling: enableSampling,
         }, { concurrentId: concurrentId || 'getHotKeys', requestConfig: { signal } });
     }
     getHealthcheckInfo({ database, maxLevel }, { concurrentId, signal } = {}) {
-        return this.get(this.getPath('/viewer/json/healthcheck?merge_records=true'), { tenant: database, max_level: maxLevel }, { concurrentId, requestConfig: { signal } });
-    }
-    evictVDisk({ groupId, groupGeneration, failRealmIdx, failDomainIdx, vDiskIdx, }) {
-        // BSC Id is constant for all ydb clusters
-        const BSC_TABLET_ID = '72057594037932033';
-        return this.post(this.getPath(`/tablets/app?TabletID=${BSC_TABLET_ID}&exec=1`), {
-            Command: {
-                ReassignGroupDisk: {
-                    GroupId: groupId,
-                    GroupGeneration: groupGeneration,
-                    FailRealmIdx: failRealmIdx,
-                    FailDomainIdx: failDomainIdx,
-                    VDiskIdx: vDiskIdx,
-                },
-            },
-        }, {}, {
-            headers: {
-                // This handler requires exactly this string
-                // Automatic headers may not suit
-                Accept: 'application/json',
-            },
-        });
+        return this.get(this.getPath('/viewer/json/healthcheck?merge_records=true'), { database, tenant: database, max_level: maxLevel }, { concurrentId, requestConfig: { signal } });
     }
-    restartPDisk(nodeId, pDiskId) {
-        const pDiskPath = createPDiskDeveloperUILink({
-            nodeId,
-            pDiskId,
-            host: this.getPath(''),
+    evictVDisk({ groupId, groupGeneration, failRealmIdx, failDomainIdx, vDiskIdx, force, }) {
+        const params = {
+            group_id: groupId,
+            group_generation_id: groupGeneration,
+            fail_realm_idx: failRealmIdx,
+            fail_domain_idx: failDomainIdx,
+            vdisk_idx: vDiskIdx,
+            force,
+        };
+        const paramsString = qs.stringify(params);
+        const path = this.getPath(`/vdisk/evict?${paramsString}`);
+        return this.post(path, {}, {}, {
+            requestConfig: { 'axios-retry': { retries: 0 } },
         });
-        return this.post(pDiskPath, 'restartPDisk=', {}, {
-            headers: {
-                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
-            },
+    }
+    restartPDisk({ nodeId, pDiskId, force, }) {
+        return this.post(this.getPath(`/pdisk/restart?node_id=${nodeId}&pdisk_id=${pDiskId}&force=${force}`), {}, {}, {
+            requestConfig: { 'axios-retry': { retries: 0 } },
         });
     }
     killTablet(id) {
-        return this.get(this.getPath(`/tablets?KillTabletID=${id}`), {});
+        return this.get(this.getPath(`/tablets?KillTabletID=${id}`), {}, { requestConfig: { 'axios-retry': { retries: 0 } } });
     }
     stopTablet(id, hiveId) {
-        return this.get(this.getPath(`/tablets/app?TabletID=${hiveId}&page=StopTablet&tablet=${id}`), {});
+        return this.get(this.getPath(`/tablets/app?TabletID=${hiveId}&page=StopTablet&tablet=${id}`), {}, { requestConfig: { 'axios-retry': { retries: 0 } } });
     }
     resumeTablet(id, hiveId) {
-        return this.get(this.getPath(`/tablets/app?TabletID=${hiveId}&page=ResumeTablet&tablet=${id}`), {});
+        return this.get(this.getPath(`/tablets/app?TabletID=${hiveId}&page=ResumeTablet&tablet=${id}`), {}, { requestConfig: { 'axios-retry': { retries: 0 } } });
     }
     getTabletDescribe(tenantId, { concurrentId, signal } = {}) {
         return this.get(this.getPath('/viewer/json/describe'), {
@@ -302,19 +289,8 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             requestConfig: { signal },
         });
     }
-    /** @deprecated use localStorage instead */
-    postSetting(settingsApi, name, value) {
-        return this.request({
-            method: 'PATCH',
-            url: settingsApi,
-            data: { [name]: value },
-        });
-    }
-    authenticate(user, password) {
-        return this.post(this.getPath('/login'), {
-            user,
-            password,
-        }, {});
+    authenticate(params) {
+        return this.post(this.getPath('/login'), params, {});
     }
     logout() {
         return this.post(this.getPath('/logout'), {}, {});
@@ -333,7 +309,7 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
             requestConfig: { signal },
         });
     }
-    createSchemaDirectory(database, path, { signal } = {}) {
+    createSchemaDirectory({ database, path }, { signal } = {}) {
         return this.post(this.getPath('/scheme/directory'), {}, {
             database,
             path,

package/dist/services/settings.d.ts

@@ -9,18 +9,26 @@ export declare const DEFAULT_USER_SETTINGS: {
     readonly binaryDataInPlainTextDisplay: true;
     readonly saved_queries: readonly [];
     readonly saved_tenant_initial_tab: "query";
-    readonly query_initial_mode: "script";
     readonly last_used_query_action: "execute";
     readonly asideHeaderCompact: true;
     readonly partitionsHiddenColumns: readonly [];
     readonly useBackendParamsForTables: false;
     readonly useClusterBalancerAsBacked: true;
-    readonly useSeparateDisksPages: false;
     readonly enableAutocomplete: true;
     readonly autocompleteOnEnter: true;
     readonly isHotKeysHelpHidden: false;
     readonly "auto-refresh-interval": 0;
-    readonly useDirectoryOperations: false;
+    readonly enableTracingLevel: false;
+    readonly showDomainDatabase: false;
+    readonly last_query_execution_settings: undefined;
+    readonly querySettingsBannerLastClosed: undefined;
+    readonly queryExecutionSettings: {
+        queryMode: "script";
+        isolationLevel: "serializable-read-write";
+        timeout: string;
+        statisticsMode: "none";
+        tracingLevel: "detailed";
+    };
 };
 declare class SettingsManager {
     /**

package/dist/services/settings.js

@@ -1,6 +1,6 @@
 import { TENANT_PAGES_IDS } from '../store/reducers/tenant/constants';
-import { ASIDE_HEADER_COMPACT_KEY, AUTOCOMPLETE_ON_ENTER, AUTO_REFRESH_INTERVAL, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, INVERTED_DISKS_KEY, IS_HOTKEYS_HELP_HIDDEN_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_CLUSTER_BALANCER_AS_BACKEND_KEY, USE_DIRECTORY_OPERATIONS, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, USE_PAGINATED_TABLES_KEY, USE_SEPARATE_DISKS_PAGES_KEY, } from '../utils/constants';
-import { QUERY_ACTIONS, QUERY_MODES } from '../utils/query';
+import { ASIDE_HEADER_COMPACT_KEY, AUTOCOMPLETE_ON_ENTER, AUTO_REFRESH_INTERVAL, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, DEFAULT_QUERY_SETTINGS, ENABLE_AUTOCOMPLETE, ENABLE_TRACING_LEVEL_KEY, INVERTED_DISKS_KEY, IS_HOTKEYS_HELP_HIDDEN_KEY, LANGUAGE_KEY, LAST_QUERY_EXECUTION_SETTINGS_KEY, LAST_USED_QUERY_ACTION_KEY, PARTITIONS_HIDDEN_COLUMNS_KEY, QUERY_EXECUTION_SETTINGS_KEY, QUERY_SETTINGS_BANNER_LAST_CLOSED_KEY, QUERY_USE_MULTI_SCHEMA_KEY, SAVED_QUERIES_KEY, SHOW_DOMAIN_DATABASE_KEY, TENANT_INITIAL_PAGE_KEY, THEME_KEY, USE_CLUSTER_BALANCER_AS_BACKEND_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, USE_PAGINATED_TABLES_KEY, } from '../utils/constants';
+import { QUERY_ACTIONS } from '../utils/query';
 import { parseJson } from '../utils/utils';
 /** User settings keys and their default values */
 export const DEFAULT_USER_SETTINGS = {
@@ -12,18 +12,20 @@ export const DEFAULT_USER_SETTINGS = {
     [BINARY_DATA_IN_PLAIN_TEXT_DISPLAY]: true,
     [SAVED_QUERIES_KEY]: [],
     [TENANT_INITIAL_PAGE_KEY]: TENANT_PAGES_IDS.query,
-    [QUERY_INITIAL_MODE_KEY]: QUERY_MODES.script,
     [LAST_USED_QUERY_ACTION_KEY]: QUERY_ACTIONS.execute,
     [ASIDE_HEADER_COMPACT_KEY]: true,
     [PARTITIONS_HIDDEN_COLUMNS_KEY]: [],
     [USE_PAGINATED_TABLES_KEY]: false,
     [USE_CLUSTER_BALANCER_AS_BACKEND_KEY]: true,
-    [USE_SEPARATE_DISKS_PAGES_KEY]: false,
     [ENABLE_AUTOCOMPLETE]: true,
     [AUTOCOMPLETE_ON_ENTER]: true,
     [IS_HOTKEYS_HELP_HIDDEN_KEY]: false,
     [AUTO_REFRESH_INTERVAL]: 0,
-    [USE_DIRECTORY_OPERATIONS]: false,
+    [ENABLE_TRACING_LEVEL_KEY]: false,
+    [SHOW_DOMAIN_DATABASE_KEY]: false,
+    [LAST_QUERY_EXECUTION_SETTINGS_KEY]: undefined,
+    [QUERY_SETTINGS_BANNER_LAST_CLOSED_KEY]: undefined,
+    [QUERY_EXECUTION_SETTINGS_KEY]: DEFAULT_QUERY_SETTINGS,
 };
 class SettingsManager {
     constructor() {