ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/services/api.d.ts

@@ -0,0 +1,114 @@
+import AxiosWrapper from '@gravity-ui/axios-wrapper';
+import type { Actions, ExplainActions, ExplainResponse, QueryAPIResponse, Schemas } from '../types/api/query';
+import type { TDomainKey, TEvTabletStateResponse, UnmergedTEvTabletStateResponse } from '../types/api/tablet';
+import type { TMetaInfo } from '../types/api/acl';
+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 { TNetInfo } from '../types/api/netInfo';
+import type { TNodesInfo } from '../types/api/nodes';
+import type { TEvNodesInfo } from '../types/api/nodesList';
+import type { TEvDescribeSchemeResult } from '../types/api/schema';
+import type { TStorageInfo } from '../types/api/storage';
+import type { TEvSystemStateResponse } from '../types/api/systemState';
+import type { TTenantInfo, TTenants } from '../types/api/tenant';
+import type { DescribeTopicResult } from '../types/api/topic';
+import type { TEvPDiskStateResponse } from '../types/api/pdisk';
+import type { TEvVDiskStateResponse } from '../types/api/vdisk';
+import type { TUserToken } from '../types/api/whoami';
+import type { JsonRenderRequestParams, JsonRenderResponse } from '../types/api/render';
+import type { QuerySyntax } from '../types/store/query';
+import type { ComputeApiRequestParams, NodesApiRequestParams } from '../store/reducers/nodes/types';
+import type { StorageApiRequestParams } from '../store/reducers/storage/types';
+import type { MetaClusters } from '../types/api/meta';
+declare type AxiosOptions = {
+    concurrentId?: string;
+};
+export declare class YdbEmbeddedAPI extends AxiosWrapper {
+    getPath(path: string): string;
+    getClusterInfo(clusterName?: string, { concurrentId }?: AxiosOptions): Promise<TClusterInfo>;
+    getClusterNodes({ concurrentId }?: AxiosOptions): Promise<TEvSystemStateResponse>;
+    getNodeInfo(id?: string): Promise<TEvSystemStateResponse>;
+    getTenants(clusterName?: string): Promise<TTenantInfo>;
+    getTenantInfo({ path }: {
+        path: string;
+    }, { concurrentId }?: AxiosOptions): Promise<TTenantInfo>;
+    getNodes({ visibleEntities, type, tablets, sortOrder, sortValue, ...params }: NodesApiRequestParams, { concurrentId }?: AxiosOptions): Promise<TNodesInfo>;
+    /** @deprecated use getNodes instead */
+    getCompute({ sortOrder, sortValue, ...params }: ComputeApiRequestParams, { concurrentId }?: AxiosOptions): Promise<TComputeInfo>;
+    getStorageInfo({ tenant, visibleEntities, nodeId, sortOrder, sortValue, ...params }: StorageApiRequestParams, { concurrentId }?: AxiosOptions): Promise<TStorageInfo>;
+    getPdiskInfo(nodeId: string | number, pdiskId: string | number): Promise<TEvPDiskStateResponse>;
+    getVdiskInfo({ vdiskId, pdiskId, nodeId, }: {
+        vdiskId: string | number;
+        pdiskId: string | number;
+        nodeId: string | number;
+    }): Promise<TEvVDiskStateResponse>;
+    getGroupInfo(groupId: string | number): Promise<TStorageInfo>;
+    getHostInfo(): Promise<TEvSystemStateResponse>;
+    getTabletsInfo({ nodes, path }: {
+        nodes?: string[];
+        path?: string;
+    }): Promise<TEvTabletStateResponse>;
+    getSchema({ path }: {
+        path: string;
+    }, { concurrentId }?: AxiosOptions): Promise<TEvDescribeSchemeResult>;
+    getDescribe({ path }: {
+        path: string;
+    }, { concurrentId }?: AxiosOptions): Promise<TEvDescribeSchemeResult>;
+    getSchemaAcl({ path }: {
+        path: string;
+    }): Promise<TMetaInfo>;
+    getHeatmapData({ path }: {
+        path: string;
+    }): Promise<TEvDescribeSchemeResult>;
+    getNetwork(path: string): Promise<TNetInfo>;
+    getTopic({ path }: {
+        path?: string;
+    }, { concurrentId }?: AxiosOptions): Promise<DescribeTopicResult>;
+    getConsumer({ path, consumer }: {
+        path: string;
+        consumer: string;
+    }, { concurrentId }?: AxiosOptions): Promise<DescribeConsumerResult>;
+    getPoolInfo(poolName: string): Promise<TStorageInfo>;
+    getTablet({ id }: {
+        id?: string;
+    }): Promise<TEvTabletStateResponse>;
+    getTabletHistory({ id }: {
+        id?: string;
+    }): Promise<UnmergedTEvTabletStateResponse>;
+    getNodesList(): Promise<TEvNodesInfo>;
+    getTenantsList(): Promise<TTenants>;
+    sendQuery<Action extends Actions, Schema extends Schemas = undefined>({ schema, ...params }: {
+        query?: string;
+        database?: string;
+        action?: Action;
+        stats?: string;
+        schema?: Schema;
+        syntax?: QuerySyntax;
+    }, { concurrentId }?: AxiosOptions): Promise<QueryAPIResponse<Action, Schema>>;
+    getExplainQuery<Action extends ExplainActions>(query: string, database: string, action: Action, syntax?: QuerySyntax): Promise<ExplainResponse<Action>>;
+    getExplainQueryAst(query: string, database: string): Promise<import("../types/api/query").ExplainQueryResponse>;
+    getHotKeys(path: string, enableSampling: boolean): Promise<any>;
+    getHealthcheckInfo(database: string, { concurrentId }?: AxiosOptions): Promise<HealthCheckAPIResponse>;
+    killTablet(id?: string): Promise<string>;
+    stopTablet(id?: string, hiveId?: string): Promise<string>;
+    resumeTablet(id?: string, hiveId?: string): Promise<string>;
+    getTabletDescribe(tenantId: TDomainKey): Promise<TEvDescribeSchemeResult>;
+    getChartData({ target, from, until, maxDataPoints }: JsonRenderRequestParams, { concurrentId }?: AxiosOptions): Promise<JsonRenderResponse>;
+    /** @deprecated use localStorage instead */
+    postSetting(settingsApi: string, name: string, value: string): Promise<any>;
+    authenticate(user: string, password: string): Promise<any>;
+    logout(): Promise<any>;
+    whoami(): Promise<TUserToken>;
+    getClustersList(): Promise<MetaClusters>;
+}
+export declare class YdbWebVersionAPI extends YdbEmbeddedAPI {
+    getClusterInfo(clusterName: string): Promise<TClusterInfo>;
+    getTenants(clusterName: string): Promise<TTenantInfo>;
+}
+export declare function createApi({ webVersion, withCredentials }?: {
+    webVersion?: boolean | undefined;
+    withCredentials?: boolean | undefined;
+}): YdbEmbeddedAPI;
+export {};

package/dist/services/api.js

@@ -0,0 +1,278 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import AxiosWrapper from '@gravity-ui/axios-wrapper';
+import { backend as BACKEND, metaBackend as META_BACKEND } from '../store';
+import { prepareSortValue } from '../utils/filters';
+import { parseMetaCluster } from './parsers/parseMetaCluster';
+import { parseMetaTenants } from './parsers/parseMetaTenants';
+export class YdbEmbeddedAPI extends AxiosWrapper {
+    getPath(path) {
+        return `${BACKEND !== null && BACKEND !== void 0 ? BACKEND : ''}${path}`;
+    }
+    getClusterInfo(clusterName, { concurrentId } = {}) {
+        return this.get(this.getPath('/viewer/json/cluster'), {
+            name: clusterName,
+            tablets: true,
+        }, { concurrentId: concurrentId || `getClusterInfo` });
+    }
+    getClusterNodes({ concurrentId } = {}) {
+        return this.get(this.getPath('/viewer/json/sysinfo'), {}, { concurrentId: concurrentId || `getClusterNodes` });
+    }
+    getNodeInfo(id) {
+        return this.get(this.getPath('/viewer/json/sysinfo?enums=true'), {
+            node_id: id,
+        });
+    }
+    getTenants(clusterName) {
+        return this.get(this.getPath('/viewer/json/tenantinfo'), {
+            tablets: 1,
+            storage: 1,
+            cluster_name: clusterName,
+        });
+    }
+    getTenantInfo({ path }, { concurrentId } = {}) {
+        return this.get(this.getPath('/viewer/json/tenantinfo'), {
+            path,
+            tablets: true,
+            storage: true,
+        }, { concurrentId: concurrentId || `getTenantInfo|${path}` });
+    }
+    getNodes(_a, _b) {
+        var { visibleEntities, type = 'any', tablets = true, sortOrder, sortValue } = _a, params = __rest(_a, ["visibleEntities", "type", "tablets", "sortOrder", "sortValue"]);
+        var _c = _b === void 0 ? {} : _b, concurrentId = _c.concurrentId;
+        const sort = prepareSortValue(sortValue, sortOrder);
+        return this.get(this.getPath('/viewer/json/nodes?enums=true'), Object.assign({ with: visibleEntities, type, tablets, sort }, params), { concurrentId });
+    }
+    /** @deprecated use getNodes instead */
+    getCompute(_a, _b) {
+        var { sortOrder, sortValue } = _a, params = __rest(_a, ["sortOrder", "sortValue"]);
+        var _c = _b === void 0 ? {} : _b, concurrentId = _c.concurrentId;
+        const sort = prepareSortValue(sortValue, sortOrder);
+        return this.get(this.getPath('/viewer/json/compute?enums=true'), Object.assign({ sort }, params), { concurrentId });
+    }
+    getStorageInfo(_a, _b) {
+        var { tenant, visibleEntities, nodeId, sortOrder, sortValue } = _a, params = __rest(_a, ["tenant", "visibleEntities", "nodeId", "sortOrder", "sortValue"]);
+        var _c = _b === void 0 ? {} : _b, concurrentId = _c.concurrentId;
+        const sort = prepareSortValue(sortValue, sortOrder);
+        return this.get(this.getPath(`/viewer/json/storage?enums=true`), Object.assign({ tenant, node_id: nodeId, with: visibleEntities, sort }, params), { concurrentId });
+    }
+    getPdiskInfo(nodeId, pdiskId) {
+        return this.get(this.getPath('/viewer/json/pdiskinfo?enums=true'), {
+            filter: `(NodeId=${nodeId}${pdiskId ? `;PDiskId=${pdiskId}` : ''})`,
+        });
+    }
+    getVdiskInfo({ vdiskId, pdiskId, nodeId, }) {
+        return this.get(this.getPath('/viewer/json/vdiskinfo?enums=true'), {
+            filter: `(VDiskId=${vdiskId !== null && vdiskId !== void 0 ? vdiskId : ''};PDiskId=${pdiskId !== null && pdiskId !== void 0 ? pdiskId : ''};NodeId=${nodeId !== null && nodeId !== void 0 ? nodeId : ''})`,
+        });
+    }
+    getGroupInfo(groupId) {
+        return this.get(this.getPath('/viewer/json/storage?enums=true'), {
+            group_id: groupId,
+        });
+    }
+    getHostInfo() {
+        return this.get(this.getPath('/viewer/json/sysinfo?node_id=.&enums=true'), {});
+    }
+    getTabletsInfo({ nodes = [], path }) {
+        const filter = nodes.length > 0 && `(NodeId=[${nodes.join(',')}])`;
+        return this.get(this.getPath('/viewer/json/tabletinfo'), {
+            filter,
+            path,
+            enums: true,
+        });
+    }
+    getSchema({ path }, { concurrentId } = {}) {
+        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: concurrentId || `getSchema|${path}` });
+    }
+    getDescribe({ path }, { concurrentId } = {}) {
+        return this.get(this.getPath('/viewer/json/describe'), {
+            path,
+            enums: true,
+            partition_stats: true,
+            subs: 0,
+        }, { concurrentId: concurrentId || `getDescribe|${path}` });
+    }
+    getSchemaAcl({ path }) {
+        return this.get(this.getPath('/viewer/json/acl'), {
+            path,
+        }, { concurrentId: `getSchemaAcl` });
+    }
+    getHeatmapData({ path }) {
+        return this.get(this.getPath('/viewer/json/describe'), {
+            path,
+            enums: true,
+            backup: false,
+            children: false,
+            partition_config: false,
+            partition_stats: true,
+        });
+    }
+    getNetwork(path) {
+        return this.get(this.getPath('/viewer/json/netinfo'), {
+            enums: true,
+            path,
+        });
+    }
+    getTopic({ path }, { concurrentId } = {}) {
+        return this.get(this.getPath('/viewer/json/describe_topic'), {
+            enums: true,
+            include_stats: true,
+            path,
+        }, { concurrentId: concurrentId || 'getTopic' });
+    }
+    getConsumer({ path, consumer }, { concurrentId } = {}) {
+        return this.get(this.getPath('/viewer/json/describe_consumer'), {
+            enums: true,
+            include_stats: true,
+            path,
+            consumer,
+        }, { concurrentId: concurrentId || 'getConsumer' });
+    }
+    getPoolInfo(poolName) {
+        return this.get(this.getPath('/viewer/json/storage'), {
+            pool: poolName,
+            enums: true,
+        });
+    }
+    getTablet({ id }) {
+        return this.get(this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`), {
+            enums: true,
+        });
+    }
+    getTabletHistory({ id }) {
+        return this.get(this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`), {
+            enums: true,
+            merge: false,
+        });
+    }
+    getNodesList() {
+        return this.get(this.getPath('/viewer/json/nodelist'), { enums: true });
+    }
+    getTenantsList() {
+        return this.get(this.getPath('/viewer/json/tenants'), {
+            enums: true,
+            state: 0,
+        });
+    }
+    sendQuery(_a, _b) {
+        var { schema } = _a, params = __rest(_a, ["schema"]);
+        var _c = _b === void 0 ? {} : _b, concurrentId = _c.concurrentId;
+        // 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 this.post(this.getPath(`/viewer/json/query?timeout=${backendTimeout}${schema ? `&schema=${schema}` : ''}`), params, {}, {
+            concurrentId,
+            timeout: uiTimeout,
+        });
+    }
+    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) {
+        return this.get(this.getPath('/viewer/json/hotkeys'), {
+            path,
+            enable_sampling: enableSampling,
+        });
+    }
+    getHealthcheckInfo(database, { concurrentId } = {}) {
+        return this.get(this.getPath('/viewer/json/healthcheck?merge_records=true'), { tenant: database }, { concurrentId });
+    }
+    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) {
+        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,
+        });
+    }
+    getChartData({ target, from, until, maxDataPoints }, { concurrentId } = {}) {
+        const requestString = `${target}&from=${from}&until=${until}&maxDataPoints=${maxDataPoints}&format=json`;
+        return this.post(this.getPath('/viewer/json/render'), requestString, {}, {
+            concurrentId,
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+            },
+        });
+    }
+    /** @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'), {});
+    }
+    // used if not single cluster mode
+    getClustersList() {
+        return this.get(`${META_BACKEND || ''}/meta/clusters`, null);
+    }
+}
+export class YdbWebVersionAPI extends YdbEmbeddedAPI {
+    getClusterInfo(clusterName) {
+        return this.get(`${META_BACKEND || ''}/meta/cluster`, {
+            name: clusterName,
+        }, { concurrentId: `getCluster${clusterName}` }).then(parseMetaCluster);
+    }
+    getTenants(clusterName) {
+        return this.get(`${META_BACKEND || ''}/meta/cp_databases`, {
+            cluster_name: clusterName,
+        }).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.d.ts

@@ -0,0 +1,3 @@
+import type { TClusterInfo } from '../../types/api/cluster';
+import type { MetaCluster } from '../../types/api/meta';
+export declare const parseMetaCluster: (data: MetaCluster) => TClusterInfo;

package/dist/services/parsers/parseMetaCluster.js

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

package/dist/services/parsers/parseMetaTenants.d.ts

@@ -0,0 +1,3 @@
+import type { TTenantInfo } from '../../types/api/tenant';
+import type { MetaTenants } from '../../types/api/meta';
+export declare const parseMetaTenants: (data: MetaTenants) => TTenantInfo;

package/dist/services/parsers/parseMetaTenants.js

@@ -0,0 +1,5 @@
+export const parseMetaTenants = (data) => {
+    return {
+        TenantInfo: data === null || data === void 0 ? void 0 : data.databases,
+    };
+};

package/dist/services/settings.d.ts

@@ -0,0 +1,24 @@
+export declare type SettingsObject = Record<string, unknown>;
+/** User settings keys and their default values */
+export declare const DEFAULT_USER_SETTINGS: SettingsObject;
+declare class SettingsManager {
+    constructor();
+    /**
+     * 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,82 @@
+import { TENANT_PAGES_IDS } from '../store/reducers/tenant/constants';
+import { ASIDE_HEADER_COMPACT_KEY, CLUSTER_INFO_HIDDEN_KEY, INVERTED_DISKS_KEY, LANGUAGE_KEY, LAST_USED_QUERY_ACTION_KEY, PARTITIONS_HIDDEN_COLUMNS_KEY, QUERY_INITIAL_MODE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, SAVED_QUERIES_KEY, TENANT_INITIAL_PAGE_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, USE_CLUSTER_BALANCER_AS_BACKEND_KEY, } from '../utils/constants';
+import { QUERY_ACTIONS, QUERY_MODES } from '../utils/query';
+import { parseJson } from '../utils/utils';
+const USE_LOCAL_STORAGE_FOR_SETTINGS_KEY = 'useLocalStorageForSettings';
+/** 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]: false,
+    [QUERY_USE_MULTI_SCHEMA_KEY]: false,
+    [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]: [],
+    [CLUSTER_INFO_HIDDEN_KEY]: true,
+    [USE_BACKEND_PARAMS_FOR_TABLES_KEY]: false,
+    [USE_CLUSTER_BALANCER_AS_BACKEND_KEY]: true,
+};
+class SettingsManager {
+    constructor() {
+        var _a;
+        /**
+         * 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) { }
+        };
+        // Migrate settings to LS if external API was used before
+        const settingsApi = window.web_version ? (_a = window.systemSettings) === null || _a === void 0 ? void 0 : _a.settingsApi : undefined;
+        const useLocalStorage = this.readUserSettingsValue(USE_LOCAL_STORAGE_FOR_SETTINGS_KEY);
+        if (settingsApi && !useLocalStorage) {
+            const externalUserSettings = window.userSettings;
+            if (externalUserSettings) {
+                Object.entries(externalUserSettings).forEach(([key, value]) => this.setUserSettingsValue(key, value));
+            }
+            this.setUserSettingsValue(USE_LOCAL_STORAGE_FOR_SETTINGS_KEY, true);
+        }
+    }
+    /**
+     * 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 | undefined;
+}) => {
+    basename: string;
+    backend: string | string[] | undefined;
+    clusterName: string | string[] | undefined;
+} | {
+    basename: string;
+    backend: string | string[];
+    clusterName?: undefined;
+};

package/dist/store/getUrlData.js

@@ -0,0 +1,27 @@
+import url from 'url';
+export const getUrlData = ({ href, singleClusterMode, customBackend, }) => {
+    if (!singleClusterMode) {
+        const { backend, clusterName } = url.parse(href, true).query;
+        return {
+            basename: '/',
+            backend,
+            clusterName,
+        };
+    }
+    else if (customBackend) {
+        const { backend } = url.parse(href, true).query;
+        return {
+            basename: '/',
+            backend: backend || customBackend,
+        };
+    }
+    else {
+        const parsedPrefix = window.location.pathname.match(/.*(?=\/monitoring)/) || [];
+        const basenamePrefix = Boolean(parsedPrefix.length) && parsedPrefix[0];
+        const basename = [basenamePrefix, 'monitoring'].filter(Boolean).join('/');
+        return {
+            basename,
+            backend: basenamePrefix || '',
+        };
+    }
+};

package/dist/store/index.d.ts

@@ -0,0 +1,97 @@
+export function configureStore({ aRootReducer, singleClusterMode, api, }?: {
+    aRootReducer?: import("redux").Reducer<import("redux").CombinedState<{
+        singleClusterMode: boolean;
+        nodes: import("./reducers/nodes/types").NodesState;
+        topNodesByLoad: import("./reducers/tenantOverview/topNodesByLoad/types").TopNodesByLoadState;
+        topNodesByCpu: import("./reducers/tenantOverview/topNodesByCpu/types").TopNodesByCpuState;
+        topNodesByMemory: import("./reducers/tenantOverview/topNodesByMemory/types").TopNodesByMemoryState;
+        cluster: import("./reducers/cluster/types").ClusterState;
+        clusterNodes: import("./reducers/clusterNodes/types").ClusterNodesState;
+        tenant: import("./reducers/tenant/types").TenantState;
+        storage: import("./reducers/storage/types").StorageState;
+        topStorageGroups: import("./reducers/tenantOverview/topStorageGroups/types").TopStorageGroupsState;
+        node: import("./reducers/node/types").NodeState;
+        tooltip: import("../types/store/tooltip").ITooltipState;
+        tablets: import("../types/store/tablets").ITabletsState;
+        schema: import("./reducers/schema/types").SchemaState;
+        overview: import("./reducers/overview/types").OverviewState;
+        olapStats: import("../types/store/olapStats").OlapStatsState;
+        host: import("../types/store/host").IHostState;
+        network: import("./reducers/network/types").NetworkState;
+        tenants: import("./reducers/tenants/types").TenantsState;
+        tablet: import("../types/store/tablet").ITabletState;
+        topic: import("../types/store/topic").ITopicState;
+        partitions: import("./reducers/partitions/types").PartitionsState;
+        executeQuery: import("../types/store/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("./reducers/settings/types").SettingsState;
+        preview: any;
+        nodesList: import("../types/store/nodesList").NodesListState;
+        describe: import("../types/store/describe").IDescribeState;
+        schemaAcl: import("./reducers/schemaAcl/types").SchemaAclState;
+        executeTopQueries: import("./reducers/executeTopQueries/types").ITopQueriesState;
+        executeTopTables: import("./reducers/tenantOverview/executeTopTables/types").TopTablesState;
+        tenantOverviewTopQueries: import("./reducers/tenantOverview/topQueries/types").TenantOverviewTopQueriesState;
+        healthcheckInfo: import("../types/store/healthcheck").IHealthcheckInfoState;
+        shardsWorkload: import("./reducers/shardsWorkload/types").IShardsWorkloadState;
+        tenantOverviewTopShards: import("./reducers/tenantOverview/topShards/types").TenantOverviewTopShardsState;
+        hotKeys: any;
+        authentication: import("./reducers/authentication/types").AuthenticationState;
+        header: import("./reducers/header/types").HeaderState;
+        saveQuery: string | null;
+        fullscreen: boolean;
+        clusters: import("./reducers/clusters/types").ClustersState;
+    }>, any> | undefined;
+    singleClusterMode?: boolean | undefined;
+    api?: import("../services/api").YdbEmbeddedAPI | undefined;
+}): {
+    history: import("history").History<unknown>;
+    store: import("redux").Store<any, any> & {
+        dispatch: any;
+    };
+};
+export let backend: any;
+export let basename: any;
+export let clusterName: any;
+export const webVersion: boolean | undefined;
+export const customBackend: string | undefined;
+export const metaBackend: any;
+export * from "./reducers";