ydb-embedded-ui 6.8.0 → 6.9.0

package/dist/services/api.js

@@ -0,0 +1,361 @@
+import AxiosWrapper from '@gravity-ui/axios-wrapper';
+import axiosRetry from 'axios-retry';
+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';
+import { settingsManager } from './settings';
+export class YdbEmbeddedAPI extends AxiosWrapper {
+    constructor(options) {
+        super(options);
+        axiosRetry(this._axios, {
+            retries: 3,
+            retryDelay: axiosRetry.exponentialDelay,
+        });
+        // Interceptor to process OIDC auth
+        this._axios.interceptors.response.use(null, function (error) {
+            var _a;
+            const response = error.response;
+            // OIDC proxy returns 401 response with authUrl in it
+            // 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);
+            }
+            return Promise.reject(error);
+        });
+    }
+    getPath(path) {
+        return `${BACKEND !== null && BACKEND !== void 0 ? BACKEND : ''}${path}`;
+    }
+    getClusterInfo(clusterName, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/cluster'), {
+            name: clusterName,
+            tablets: true,
+        }, { concurrentId: concurrentId || `getClusterInfo`, requestConfig: { signal } });
+    }
+    getClusterNodes({ concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/sysinfo'), {}, { concurrentId: concurrentId || `getClusterNodes`, requestConfig: { signal } });
+    }
+    getNodeInfo(id, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/sysinfo?enums=true'), {
+            node_id: id,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getTenants(clusterName, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/tenantinfo'), {
+            tablets: 1,
+            storage: 1,
+            cluster_name: clusterName,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getTenantInfo({ path }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/tenantinfo'), {
+            path,
+            tablets: true,
+            storage: true,
+        }, { concurrentId: concurrentId || `getTenantInfo|${path}`, 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 } });
+    }
+    /** @deprecated use getNodes instead */
+    getCompute({ sortOrder, sortValue, ...params }, { concurrentId, signal } = {}) {
+        const sort = prepareSortValue(sortValue, sortOrder);
+        return this.get(this.getPath('/viewer/json/compute?enums=true'), { sort, ...params }, { concurrentId, requestConfig: { signal } });
+    }
+    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`), {
+            tenant,
+            node_id: nodeId,
+            pool: poolName,
+            group_id: groupId,
+            with: visibleEntities,
+            sort,
+            ...params,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getPDiskInfo({ nodeId, pDiskId }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/pdiskinfo?enums=true'), {
+            filter: `(NodeId=${nodeId}${pDiskId ? `;PDiskId=${pDiskId}` : ''})`,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getVDiskInfo({ vDiskSlotId, pDiskId, nodeId, }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/vdiskinfo?enums=true'), {
+            node_id: nodeId,
+            filter: `(PDiskId=${pDiskId};VDiskSlotId=${vDiskSlotId})`,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getGroupInfo(groupId, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/storage?enums=true'), {
+            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 } = {}) {
+        const filter = nodes.length > 0 && `(NodeId=[${nodes.join(',')}])`;
+        return this.get(this.getPath('/viewer/json/tabletinfo'), {
+            filter,
+            path,
+            enums: true,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getSchema({ path }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/describe'), {
+            path,
+            enums: true,
+            backup: false,
+            private: true,
+            partition_config: true,
+            partition_stats: true,
+            partitioning_info: true,
+            subs: 1,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getDescribe({ path }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/describe'), {
+            path,
+            enums: true,
+            partition_stats: true,
+            subs: 0,
+        }, { concurrentId: concurrentId || `getDescribe|${path}`, requestConfig: { signal } });
+    }
+    getSchemaAcl({ path }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/acl'), {
+            path,
+            merge_rules: true,
+        }, { concurrentId: concurrentId || `getSchemaAcl`, requestConfig: { signal } });
+    }
+    getHeatmapData({ path }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/describe'), {
+            path,
+            enums: true,
+            backup: false,
+            children: false,
+            partition_config: false,
+            partition_stats: true,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getNetwork(path, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/netinfo'), {
+            enums: true,
+            path,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getTopic({ path }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/describe_topic'), {
+            enums: true,
+            include_stats: true,
+            path,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getConsumer({ path, consumer }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/describe_consumer'), {
+            enums: true,
+            include_stats: true,
+            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,
+        }, {
+            concurrentId,
+            requestConfig: { signal },
+        });
+    }
+    getTabletHistory({ id }, { concurrentId, signal } = {}) {
+        return this.get(this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`), {
+            enums: true,
+            merge: false,
+        }, {
+            concurrentId,
+            requestConfig: { signal },
+        });
+    }
+    getNodesList({ concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/nodelist'), {
+            enums: true,
+        }, {
+            concurrentId,
+            requestConfig: { signal },
+        });
+    }
+    getTenantsList({ concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/tenants'), {
+            enums: true,
+            state: 0,
+        }, {
+            concurrentId,
+            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;
+        /**
+         * 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, {}, {
+            concurrentId,
+            timeout: uiTimeout,
+            requestConfig: { signal },
+        });
+    }
+    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 } = {}) {
+        return this.get(this.getPath('/viewer/json/hotkeys'), {
+            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',
+            },
+        });
+    }
+    restartPDisk(nodeId, pDiskId) {
+        const pDiskPath = createPDiskDeveloperUILink({
+            nodeId,
+            pDiskId,
+            host: this.getPath(''),
+        });
+        return this.post(pDiskPath, 'restartPDisk=', {}, {
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            },
+        });
+    }
+    killTablet(id) {
+        return this.get(this.getPath(`/tablets?KillTabletID=${id}`), {});
+    }
+    stopTablet(id, hiveId) {
+        return this.get(this.getPath(`/tablets/app?TabletID=${hiveId}&page=StopTablet&tablet=${id}`), {});
+    }
+    resumeTablet(id, hiveId) {
+        return this.get(this.getPath(`/tablets/app?TabletID=${hiveId}&page=ResumeTablet&tablet=${id}`), {});
+    }
+    getTabletDescribe(tenantId, { concurrentId, signal } = {}) {
+        return this.get(this.getPath('/viewer/json/describe'), {
+            schemeshard_id: tenantId === null || tenantId === void 0 ? void 0 : tenantId.SchemeShard,
+            path_id: tenantId === null || tenantId === void 0 ? void 0 : tenantId.PathId,
+        }, { concurrentId, requestConfig: { signal } });
+    }
+    getChartData({ target, from, until, maxDataPoints, database }, { concurrentId, signal } = {}) {
+        const requestString = `${target}&from=${from}&until=${until}&maxDataPoints=${maxDataPoints}&format=json`;
+        return this.post(this.getPath(`/viewer/json/render?database=${database}`), requestString, {}, {
+            concurrentId,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+            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,
+        }, {});
+    }
+    logout() {
+        return this.post(this.getPath('/logout'), {}, {});
+    }
+    whoami() {
+        return this.get(this.getPath('/viewer/json/whoami'), {});
+    }
+    autocomplete(params) {
+        const { table, ...rest } = params;
+        const tablesParam = table === null || table === void 0 ? void 0 : table.join(',');
+        return this.get(this.getPath('/viewer/json/autocomplete'), { ...rest, table: tablesParam }, { concurrentId: 'sql-autocomplete' });
+    }
+    // used if not single cluster mode
+    getClustersList(_, { signal } = {}) {
+        return this.get(`${META_BACKEND || ''}/meta/clusters`, null, {
+            requestConfig: { signal },
+        });
+    }
+    createSchemaDirectory(database, path, { signal } = {}) {
+        return this.post(this.getPath('/scheme/directory'), {}, {
+            database,
+            path,
+        }, {
+            requestConfig: { signal },
+        });
+    }
+}
+export class YdbWebVersionAPI extends YdbEmbeddedAPI {
+    getClusterInfo(clusterName, { signal } = {}) {
+        return this.get(`${META_BACKEND || ''}/meta/cluster`, {
+            name: clusterName,
+        }, { concurrentId: `getCluster${clusterName}`, requestConfig: { signal } }).then(parseMetaCluster);
+    }
+    getTenants(clusterName, { concurrentId, signal } = {}) {
+        return this.get(`${META_BACKEND || ''}/meta/cp_databases`, {
+            cluster_name: clusterName,
+        }, { concurrentId, requestConfig: { signal } }).then(parseMetaTenants);
+    }
+}
+export function createApi({ webVersion = false, withCredentials = false } = {}) {
+    const config = { withCredentials };
+    const api = webVersion ? new YdbWebVersionAPI({ config }) : new YdbEmbeddedAPI({ config });
+    return api;
+}

package/dist/services/parsers/parseMetaCluster.js

@@ -0,0 +1,10 @@
+export const parseMetaCluster = (data) => {
+    const { cluster = {} } = data;
+    const { cluster: generalClusterInfo, balancer, solomon } = cluster;
+    return {
+        ...generalClusterInfo,
+        Name: cluster.title || (generalClusterInfo === null || generalClusterInfo === void 0 ? void 0 : generalClusterInfo.Name),
+        Balancer: balancer,
+        Solomon: solomon,
+    };
+};

package/dist/services/settings.d.ts

@@ -0,0 +1,42 @@
+export type SettingsObject = Record<string, unknown>;
+/** User settings keys and their default values */
+export declare const DEFAULT_USER_SETTINGS: {
+    readonly theme: "system";
+    readonly language: undefined;
+    readonly invertedDisks: false;
+    readonly useNodesEndpointInDiagnostics: true;
+    readonly queryUseMultiSchema: true;
+    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 enableAutocomplete: true;
+    readonly autocompleteOnEnter: true;
+    readonly isHotKeysHelpHidden: false;
+    readonly "auto-refresh-interval": 0;
+};
+declare class SettingsManager {
+    /**
+     * Returns parsed settings value.
+     * If value cannot be parsed, returns initially stored string.
+     * If there is no value, return default value
+     */
+    readUserSettingsValue(key: string, defaultValue?: unknown): unknown;
+    /**
+     * Stringify value and set it to LS
+     */
+    setUserSettingsValue(key: string, value: unknown): void;
+    /**
+     * Extract values by provided settings object
+     */
+    extractSettingsFromLS: (settings: SettingsObject) => SettingsObject;
+    private readValueFromLS;
+    private setValueToLS;
+}
+export declare const settingsManager: SettingsManager;
+export {};

package/dist/services/settings.js

@@ -0,0 +1,74 @@
+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_BACKEND_PARAMS_FOR_TABLES_KEY, USE_CLUSTER_BALANCER_AS_BACKEND_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../utils/constants';
+import { QUERY_ACTIONS, QUERY_MODES } from '../utils/query';
+import { parseJson } from '../utils/utils';
+/** User settings keys and their default values */
+export const DEFAULT_USER_SETTINGS = {
+    [THEME_KEY]: 'system',
+    [LANGUAGE_KEY]: undefined,
+    [INVERTED_DISKS_KEY]: false,
+    [USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY]: true,
+    [QUERY_USE_MULTI_SCHEMA_KEY]: true,
+    [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_BACKEND_PARAMS_FOR_TABLES_KEY]: false,
+    [USE_CLUSTER_BALANCER_AS_BACKEND_KEY]: true,
+    [ENABLE_AUTOCOMPLETE]: true,
+    [AUTOCOMPLETE_ON_ENTER]: true,
+    [IS_HOTKEYS_HELP_HIDDEN_KEY]: false,
+    [AUTO_REFRESH_INTERVAL]: 0,
+};
+class SettingsManager {
+    constructor() {
+        /**
+         * Extract values by provided settings object
+         */
+        this.extractSettingsFromLS = (settings) => {
+            return Object.entries(settings).reduce((acc, [key, value]) => {
+                acc[key] = this.readUserSettingsValue(key, value);
+                return acc;
+            }, {});
+        };
+        this.readValueFromLS = (key) => {
+            try {
+                const value = localStorage.getItem(key);
+                return parseJson(value);
+            }
+            catch (_a) {
+                return undefined;
+            }
+        };
+        this.setValueToLS = (key, value) => {
+            try {
+                if (typeof value === 'string') {
+                    localStorage.setItem(key, value);
+                }
+                else {
+                    localStorage.setItem(key, JSON.stringify(value));
+                }
+            }
+            catch (_a) { }
+        };
+    }
+    /**
+     * Returns parsed settings value.
+     * If value cannot be parsed, returns initially stored string.
+     * If there is no value, return default value
+     */
+    readUserSettingsValue(key, defaultValue) {
+        var _a;
+        return (_a = this.readValueFromLS(key)) !== null && _a !== void 0 ? _a : defaultValue;
+    }
+    /**
+     * Stringify value and set it to LS
+     */
+    setUserSettingsValue(key, value) {
+        return this.setValueToLS(key, value);
+    }
+}
+export const settingsManager = new SettingsManager();

package/dist/store/getUrlData.d.ts

@@ -0,0 +1,13 @@
+export declare const getUrlData: ({ href, singleClusterMode, customBackend, }: {
+    href: string;
+    singleClusterMode: boolean;
+    customBackend?: string;
+}) => {
+    basename: string;
+    backend: string | undefined;
+    clusterName: string | undefined;
+} | {
+    basename: string;
+    backend: string;
+    clusterName?: undefined;
+};

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

@@ -0,0 +1,25 @@
+import type { Reducer } from '@reduxjs/toolkit';
+import type { AuthenticationAction, AuthenticationState } from './types';
+export declare const SET_UNAUTHENTICATED: {
+    readonly REQUEST: "authentication/SET_UNAUTHENTICATED_REQUEST";
+    readonly SUCCESS: "authentication/SET_UNAUTHENTICATED_SUCCESS";
+    readonly FAILURE: "authentication/SET_UNAUTHENTICATED_FAILURE";
+};
+export declare const SET_AUTHENTICATED: {
+    readonly REQUEST: "authentication/SET_AUTHENTICATED_REQUEST";
+    readonly SUCCESS: "authentication/SET_AUTHENTICATED_SUCCESS";
+    readonly FAILURE: "authentication/SET_AUTHENTICATED_FAILURE";
+};
+export declare const FETCH_USER: {
+    readonly REQUEST: "authentication/FETCH_USER_REQUEST";
+    readonly SUCCESS: "authentication/FETCH_USER_SUCCESS";
+    readonly FAILURE: "authentication/FETCH_USER_FAILURE";
+};
+declare const authentication: Reducer<AuthenticationState, AuthenticationAction>;
+export declare const authenticate: (user: string, password: string) => (dispatch: import("../..").AppDispatch, getState: import("../..").GetState) => Promise<unknown>;
+export declare const logout: () => (dispatch: import("../..").AppDispatch, getState: import("../..").GetState) => Promise<unknown>;
+export declare const getUser: () => (dispatch: import("../..").AppDispatch, getState: import("../..").GetState) => Promise<{
+    user: string | undefined;
+    isUserAllowedToMakeChanges: boolean;
+} | undefined>;
+export default authentication;

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

@@ -0,0 +1,62 @@
+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');
+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 default authentication;

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

@@ -0,0 +1,12 @@
+import type { Dispatch } from '@reduxjs/toolkit';
+import type { TClusterInfo } from '../../../types/api/cluster';
+import type { ClusterGroupsStats, ClusterState } from './types';
+export declare function updateDefaultClusterTab(tab: string): (dispatch: Dispatch) => void;
+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", {
+        clusterData: TClusterInfo;
+        groupsStats?: ClusterGroupsStats;
+    }, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/query/react").reactHooksModuleName>;