ydb-embedded-ui 6.4.0 → 6.6.0

package/dist/src/containers/Tenant/utils/schemaControls.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { LayoutHeaderCellsLargeFill } from '@gravity-ui/icons';
+import { Button, Icon } from '@gravity-ui/uikit';
+import { setShowPreview } from '../../../store/reducers/schema/schema';
+import { TENANT_PAGES_IDS, TENANT_QUERY_TABS_ID } from '../../../store/reducers/tenant/constants';
+import { setQueryTab, setTenantPage } from '../../../store/reducers/tenant/tenant';
+import i18n from '../i18n';
+const bindActions = (path, dispatch, additionalEffects) => {
+    const { setActivePath } = additionalEffects;
+    return {
+        openPreview: () => {
+            dispatch(setShowPreview(true));
+            dispatch(setTenantPage(TENANT_PAGES_IDS.query));
+            dispatch(setQueryTab(TENANT_QUERY_TABS_ID.newQuery));
+            setActivePath(path);
+        },
+    };
+};
+export const getControls = (dispatch, additionalEffects) => (path, type) => {
+    const options = bindActions(path, dispatch, additionalEffects);
+    const openPreview = (_jsx(Button, { view: "flat-secondary", onClick: options.openPreview, title: i18n('actions.openPreview'), size: "s", children: _jsx(Icon, { data: LayoutHeaderCellsLargeFill }) }));
+    const nodeTypeToControls = {
+        async_replication: undefined,
+        database: undefined,
+        directory: undefined,
+        table: openPreview,
+        column_table: openPreview,
+        index_table: undefined,
+        topic: undefined,
+        stream: undefined,
+        index: undefined,
+        external_table: openPreview,
+        external_data_source: undefined,
+        view: openPreview,
+    };
+    return nodeTypeToControls[type];
+};

package/dist/src/containers/UserSettings/Setting.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+export type SettingsElementType = 'switch' | 'radio';
+export interface SettingProps {
+    type?: SettingsElementType;
+    title: string;
+    description?: React.ReactNode;
+    settingKey: string;
+    helpPopoverContent?: React.ReactNode;
+    options?: {
+        value: string;
+        content: string;
+    }[];
+    defaultValue?: unknown;
+    onValueUpdate?: VoidFunction;
+}
+export declare const Setting: ({ type, settingKey, title, description, helpPopoverContent, options, defaultValue, onValueUpdate, }: SettingProps) => import("react/jsx-runtime").JSX.Element;
+export interface SettingsInfoFieldProps {
+    type: 'info';
+    title: string;
+    description?: React.ReactNode;
+    content: React.ReactNode;
+}
+export declare const SettingsInfoField: ({ title, description, content }: SettingsInfoFieldProps) => import("react/jsx-runtime").JSX.Element;

package/dist/src/containers/UserSettings/Setting.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Settings } from '@gravity-ui/navigation';
+import { RadioButton, Switch } from '@gravity-ui/uikit';
+import { LabelWithPopover } from '../../components/LabelWithPopover/LabelWithPopover';
+import { useSetting } from '../../utils/hooks';
+import { b } from './UserSettings';
+export const Setting = ({ type = 'switch', settingKey, title, description, helpPopoverContent, options, defaultValue, onValueUpdate, }) => {
+    const [settingValue, setValue] = useSetting(settingKey, defaultValue);
+    const onUpdate = (value) => {
+        setValue(value);
+        onValueUpdate === null || onValueUpdate === void 0 ? void 0 : onValueUpdate();
+    };
+    const renderTitleComponent = (value) => {
+        if (helpPopoverContent) {
+            return (_jsx(LabelWithPopover, { className: b('item-with-popup'), contentClassName: b('popup'), text: value, popoverContent: helpPopoverContent }));
+        }
+        return value;
+    };
+    const getSettingsElement = (elementType) => {
+        switch (elementType) {
+            case 'switch': {
+                return _jsx(Switch, { checked: Boolean(settingValue), onUpdate: onUpdate });
+            }
+            case 'radio': {
+                if (!options) {
+                    return null;
+                }
+                return (_jsx(RadioButton, { value: String(settingValue), onUpdate: onUpdate, children: options.map(({ value, content }) => {
+                        return (_jsx(RadioButton.Option, { value: value, children: content }, value));
+                    }) }));
+            }
+            default:
+                return null;
+        }
+    };
+    return (_jsx(Settings.Item, { title: title, highlightedTitle: title, description: description, renderTitleComponent: renderTitleComponent, children: getSettingsElement(type) }));
+};
+export const SettingsInfoField = ({ title, description, content }) => {
+    return (_jsx(Settings.Item, { title: title, highlightedTitle: title, description: description, children: content }));
+};

package/dist/src/containers/UserSettings/UserSettings.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Settings } from '@gravity-ui/navigation';
+import { cn } from '../../utils/cn';
+import { Setting, SettingsInfoField } from './Setting';
+import { settings } from './settings';
+import './UserSettings.scss';
+export const b = cn('ydb-user-settings');
+export const UserSettings = ({ settings: userSettings = settings }) => {
+    return (_jsx(Settings, { children: userSettings.map((page) => {
+            const { id, title, icon, sections = [] } = page;
+            return (_jsx(Settings.Page, { id: id, title: title, icon: icon, children: sections.map((section) => {
+                    const { title: sectionTitle, settings: sectionSettings = [] } = section;
+                    return (_jsx(Settings.Section, { title: sectionTitle, children: sectionSettings.map((setting) => {
+                            if (setting.type === 'info') {
+                                return (_jsx(SettingsInfoField, Object.assign({}, setting), setting.title));
+                            }
+                            return _jsx(Setting, Object.assign({}, setting), setting.settingKey);
+                        }) }, id));
+                }) }, id));
+        }) }));
+};

package/dist/src/containers/UserSettings/i18n/en.json

@@ -0,0 +1,31 @@
+{
+    "page.general": "General",
+    "section.appearance": "Appearance",
+    "page.experiments": "Experiments",
+    "section.experiments": "Experiments",
+    "page.editor": "Editor",
+    "section.dev-setting": "Development settings",
+    "page.about": "About",
+    "section.about": "About",
+    "settings.editor.autocomplete.title": "Enable autocomplete",
+    "settings.editor.autocomplete.description": "You’re always able to get suggestions by pressing Ctrl+Space.",
+    "settings.editor.autocomplete-on-enter.title": "Accept suggestion on Enter",
+    "settings.editor.autocomplete-on-enter.description": "Controls whether suggestions should be accepted on Enter, in addition to Tab. Helps to avoid ambiguity between inserting new lines or accepting suggestions.",
+    "settings.theme.title": "Interface theme",
+    "settings.theme.option-dark": "Dark",
+    "settings.theme.option-light": "Light",
+    "settings.theme.option-system": "System",
+    "settings.language.title": "Interface language",
+    "settings.language.option-russian": "Russian",
+    "settings.language.option-english": "English",
+    "settings.binaryDataInPlainTextDisplay.title": "Display binary data in plain text",
+    "settings.binaryDataInPlainTextDisplay.description": "Available starting from version 24.1",
+    "settings.invertedDisks.title": "Inverted disks space indicators",
+    "settings.useNodesEndpoint.title": "Break the Nodes tab in Diagnostics",
+    "settings.useNodesEndpoint.popover": "Use /viewer/json/nodes endpoint for Nodes Tab in diagnostics. It could return incorrect data on some versions",
+    "settings.useVirtualTables.title": "Use table with data load on scroll for Nodes and Storage tabs",
+    "settings.useVirtualTables.popover": "It will increase performance, but could work unstable",
+    "settings.queryUseMultiSchema.title": "Allow queries with multiple result sets",
+    "settings.queryUseMultiSchema.popover": "Use 'multi' schema for queries that enables queries with multiple result sets. Returns nothing on versions 23-3 and older",
+    "settings.about.interfaceVersionInfoField.title": "Interface version"
+}

package/dist/src/containers/UserSettings/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (key: "page.general" | "section.appearance" | "page.experiments" | "section.experiments" | "page.editor" | "section.dev-setting" | "page.about" | "section.about" | "settings.editor.autocomplete.title" | "settings.editor.autocomplete.description" | "settings.editor.autocomplete-on-enter.title" | "settings.editor.autocomplete-on-enter.description" | "settings.theme.title" | "settings.theme.option-dark" | "settings.theme.option-light" | "settings.theme.option-system" | "settings.language.title" | "settings.language.option-russian" | "settings.language.option-english" | "settings.binaryDataInPlainTextDisplay.title" | "settings.binaryDataInPlainTextDisplay.description" | "settings.invertedDisks.title" | "settings.useNodesEndpoint.title" | "settings.useNodesEndpoint.popover" | "settings.useVirtualTables.title" | "settings.useVirtualTables.popover" | "settings.queryUseMultiSchema.title" | "settings.queryUseMultiSchema.popover" | "settings.about.interfaceVersionInfoField.title", params?: import("@gravity-ui/i18n").Params | undefined) => string;
+export default _default;

package/dist/src/containers/UserSettings/settings.d.ts

@@ -0,0 +1,33 @@
+import type { IconProps } from '@gravity-ui/uikit';
+import type { SettingProps, SettingsInfoFieldProps } from './Setting';
+export interface SettingsSection {
+    id: string;
+    title: string;
+    settings: (SettingProps | SettingsInfoFieldProps)[];
+}
+export interface SettingsPage {
+    id: string;
+    title: string;
+    icon: IconProps;
+    sections: SettingsSection[];
+}
+export type YDBEmbeddedUISettings = SettingsPage[];
+export declare const themeSetting: SettingProps;
+export declare const languageSetting: SettingProps;
+export declare const binaryDataInPlainTextDisplay: SettingProps;
+export declare const invertedDisksSetting: SettingProps;
+export declare const useNodesEndpointSetting: SettingProps;
+export declare const useVirtualTables: SettingProps;
+export declare const queryUseMultiSchemaSetting: SettingProps;
+export declare const enableAutocompleteSetting: SettingProps;
+export declare const autocompleteOnEnterSetting: SettingProps;
+export declare const interfaceVersionInfoField: SettingsInfoFieldProps;
+export declare const appearanceSection: SettingsSection;
+export declare const experimentsSection: SettingsSection;
+export declare const devSettingsSection: SettingsSection;
+export declare const aboutSettingsSection: SettingsSection;
+export declare const generalPage: SettingsPage;
+export declare const experimentsPage: SettingsPage;
+export declare const editorPage: SettingsPage;
+export declare const aboutPage: SettingsPage;
+export declare const settings: YDBEmbeddedUISettings;

package/dist/src/containers/UserSettings/settings.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CircleInfo, Flask, PencilToSquare, StarFill } from '@gravity-ui/icons';
+import { AUTOCOMPLETE_ON_ENTER, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, INVERTED_DISKS_KEY, LANGUAGE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../../utils/constants';
+import { Lang, defaultLang } from '../../utils/i18n';
+import { ClusterModeGuard } from '../ClusterModeGuard';
+import i18n from './i18n';
+import packageJson from '../../../package.json';
+const themeOptions = [
+    {
+        value: 'system',
+        content: i18n('settings.theme.option-system'),
+    },
+    {
+        value: 'light',
+        content: i18n('settings.theme.option-light'),
+    },
+    {
+        value: 'dark',
+        content: i18n('settings.theme.option-dark'),
+    },
+];
+export const themeSetting = {
+    settingKey: THEME_KEY,
+    title: i18n('settings.theme.title'),
+    type: 'radio',
+    options: themeOptions,
+};
+const languageOptions = [
+    {
+        value: Lang.Ru,
+        content: i18n('settings.language.option-russian'),
+    },
+    {
+        value: Lang.En,
+        content: i18n('settings.language.option-english'),
+    },
+];
+export const languageSetting = {
+    settingKey: LANGUAGE_KEY,
+    title: i18n('settings.language.title'),
+    type: 'radio',
+    options: languageOptions,
+    defaultValue: defaultLang,
+    onValueUpdate: () => {
+        window.location.reload();
+    },
+};
+export const binaryDataInPlainTextDisplay = {
+    settingKey: BINARY_DATA_IN_PLAIN_TEXT_DISPLAY,
+    title: i18n('settings.binaryDataInPlainTextDisplay.title'),
+    description: (_jsx(ClusterModeGuard, { mode: "multi", children: i18n('settings.binaryDataInPlainTextDisplay.description') })),
+};
+export const invertedDisksSetting = {
+    settingKey: INVERTED_DISKS_KEY,
+    title: i18n('settings.invertedDisks.title'),
+};
+export const useNodesEndpointSetting = {
+    settingKey: USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY,
+    title: i18n('settings.useNodesEndpoint.title'),
+    helpPopoverContent: i18n('settings.useNodesEndpoint.popover'),
+};
+export const useVirtualTables = {
+    settingKey: USE_BACKEND_PARAMS_FOR_TABLES_KEY,
+    title: i18n('settings.useVirtualTables.title'),
+    helpPopoverContent: i18n('settings.useVirtualTables.popover'),
+};
+export const queryUseMultiSchemaSetting = {
+    settingKey: QUERY_USE_MULTI_SCHEMA_KEY,
+    title: i18n('settings.queryUseMultiSchema.title'),
+    helpPopoverContent: i18n('settings.queryUseMultiSchema.popover'),
+};
+export const enableAutocompleteSetting = {
+    settingKey: ENABLE_AUTOCOMPLETE,
+    title: i18n('settings.editor.autocomplete.title'),
+    description: i18n('settings.editor.autocomplete.description'),
+};
+export const autocompleteOnEnterSetting = {
+    settingKey: AUTOCOMPLETE_ON_ENTER,
+    title: i18n('settings.editor.autocomplete-on-enter.title'),
+    description: i18n('settings.editor.autocomplete-on-enter.description'),
+};
+export const interfaceVersionInfoField = {
+    title: i18n('settings.about.interfaceVersionInfoField.title'),
+    type: 'info',
+    content: packageJson.version,
+};
+export const appearanceSection = {
+    id: 'appearanceSection',
+    title: i18n('section.appearance'),
+    settings: [themeSetting, invertedDisksSetting, binaryDataInPlainTextDisplay],
+};
+export const experimentsSection = {
+    id: 'experimentsSection',
+    title: i18n('section.experiments'),
+    settings: [useNodesEndpointSetting, useVirtualTables, queryUseMultiSchemaSetting],
+};
+export const devSettingsSection = {
+    id: 'devSettingsSection',
+    title: i18n('section.dev-setting'),
+    settings: [enableAutocompleteSetting, autocompleteOnEnterSetting],
+};
+export const aboutSettingsSection = {
+    id: 'aboutSettingsSection',
+    title: i18n('section.about'),
+    settings: [interfaceVersionInfoField],
+};
+export const generalPage = {
+    id: 'generalPage',
+    title: i18n('page.general'),
+    icon: { data: StarFill, height: 14, width: 14 },
+    sections: [appearanceSection],
+};
+export const experimentsPage = {
+    id: 'experimentsPage',
+    title: i18n('page.experiments'),
+    icon: { data: Flask },
+    sections: [experimentsSection],
+};
+export const editorPage = {
+    id: 'editorPage',
+    title: i18n('page.editor'),
+    icon: { data: PencilToSquare },
+    sections: [devSettingsSection],
+};
+export const aboutPage = {
+    id: 'aboutPage',
+    title: i18n('page.about'),
+    icon: { data: CircleInfo },
+    sections: [aboutSettingsSection],
+};
+export const settings = [
+    generalPage,
+    editorPage,
+    experimentsPage,
+    aboutPage,
+];

package/dist/src/containers/VDiskPage/VDiskPage.js

@@ -0,0 +1,109 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from 'react';
+import { ArrowsOppositeToDots } from '@gravity-ui/icons';
+import { Icon } from '@gravity-ui/uikit';
+import { skipToken } from '@reduxjs/toolkit/query';
+import { Helmet } from 'react-helmet-async';
+import { StringParam, useQueryParams } from 'use-query-params';
+import { ButtonWithConfirmDialog } from '../../components/ButtonWithConfirmDialog/ButtonWithConfirmDialog';
+import { DiskPageTitle } from '../../components/DiskPageTitle/DiskPageTitle';
+import { GroupInfo } from '../../components/GroupInfo/GroupInfo';
+import { InfoViewerSkeleton } from '../../components/InfoViewerSkeleton/InfoViewerSkeleton';
+import { PageMeta } from '../../components/PageMeta/PageMeta';
+import { VDiskWithDonorsStack } from '../../components/VDisk/VDiskWithDonorsStack';
+import { VDiskInfo } from '../../components/VDiskInfo/VDiskInfo';
+import { setHeaderBreadcrumbs } from '../../store/reducers/header/header';
+import { selectNodesMap } from '../../store/reducers/nodesList';
+import { vDiskApi } from '../../store/reducers/vdisk/vdisk';
+import { valueIsDefined } from '../../utils';
+import { cn } from '../../utils/cn';
+import { DEFAULT_POLLING_INTERVAL } from '../../utils/constants';
+import { stringifyVdiskId } from '../../utils/dataFormatters/dataFormatters';
+import { getSeverityColor } from '../../utils/disks/helpers';
+import { useTypedDispatch, useTypedSelector } from '../../utils/hooks';
+import { vDiskPageKeyset } from './i18n';
+import './VDiskPage.scss';
+const vDiskPageCn = cn('ydb-vdisk-page');
+export function VDiskPage() {
+    const dispatch = useTypedDispatch();
+    const nodesMap = useTypedSelector(selectNodesMap);
+    const { isUserAllowedToMakeChanges } = useTypedSelector((state) => state.authentication);
+    const [{ nodeId, pDiskId, vDiskSlotId }] = useQueryParams({
+        nodeId: StringParam,
+        pDiskId: StringParam,
+        vDiskSlotId: StringParam,
+    });
+    React.useEffect(() => {
+        dispatch(setHeaderBreadcrumbs('vDisk', { nodeId, pDiskId, vDiskSlotId }));
+    }, [dispatch, nodeId, pDiskId, vDiskSlotId]);
+    const params = valueIsDefined(nodeId) && valueIsDefined(pDiskId) && valueIsDefined(vDiskSlotId)
+        ? { nodeId, pDiskId, vDiskSlotId }
+        : skipToken;
+    const { currentData, isFetching, refetch } = vDiskApi.useGetVDiskDataQuery(params, {
+        pollingInterval: DEFAULT_POLLING_INTERVAL,
+    });
+    const loading = isFetching && currentData === undefined;
+    const { vDiskData = {}, groupData } = currentData || {};
+    const { NodeHost, NodeId, NodeType, NodeDC, PDiskId, PDiskType, Severity, VDiskId } = vDiskData;
+    const handleEvictVDisk = async () => {
+        const { GroupID, GroupGeneration, Ring, Domain, VDisk } = VDiskId || {};
+        if (valueIsDefined(GroupID) &&
+            valueIsDefined(GroupGeneration) &&
+            valueIsDefined(Ring) &&
+            valueIsDefined(Domain) &&
+            valueIsDefined(VDisk)) {
+            return window.api.evictVDisk({
+                groupId: GroupID,
+                groupGeneration: GroupGeneration,
+                failRealmIdx: Ring,
+                failDomainIdx: Domain,
+                vDiskIdx: VDisk,
+            });
+        }
+        return undefined;
+    };
+    const handleAfterEvictVDisk = async () => {
+        return refetch();
+    };
+    const renderHelmet = () => {
+        const vDiskPagePart = vDiskSlotId
+            ? `${vDiskPageKeyset('vdisk')} ${vDiskSlotId}`
+            : vDiskPageKeyset('vdisk');
+        const pDiskPagePart = pDiskId
+            ? `${vDiskPageKeyset('pdisk')} ${pDiskId}`
+            : vDiskPageKeyset('pdisk');
+        const nodePagePart = NodeHost ? NodeHost : vDiskPageKeyset('node');
+        return (_jsx(Helmet, { titleTemplate: `%s - ${vDiskPagePart} - ${pDiskPagePart} — ${nodePagePart} — YDB Monitoring`, defaultTitle: `${vDiskPagePart} - ${pDiskPagePart} — ${nodePagePart} — YDB Monitoring` }));
+    };
+    const renderPageMeta = () => {
+        const hostItem = NodeHost ? `${vDiskPageKeyset('fqdn')}: ${NodeHost}` : undefined;
+        const nodeIdItem = NodeId ? `${vDiskPageKeyset('node')}: ${NodeId}` : undefined;
+        const pDiskIdItem = NodeId ? `${vDiskPageKeyset('pdisk')}: ${PDiskId}` : undefined;
+        return (_jsx(PageMeta, { loading: loading, items: [hostItem, nodeIdItem, NodeType, NodeDC, pDiskIdItem, PDiskType] }));
+    };
+    const renderPageTitle = () => {
+        return (_jsx(DiskPageTitle, { entityName: vDiskPageKeyset('vdisk'), status: getSeverityColor(Severity), id: stringifyVdiskId(vDiskData === null || vDiskData === void 0 ? void 0 : vDiskData.VDiskId) }));
+    };
+    const renderControls = () => {
+        return (_jsx("div", { children: _jsxs(ButtonWithConfirmDialog, { onConfirmAction: handleEvictVDisk, onConfirmActionSuccess: handleAfterEvictVDisk, buttonDisabled: !VDiskId || !isUserAllowedToMakeChanges, buttonView: "normal", dialogContent: vDiskPageKeyset('evict-vdisk-dialog'), withPopover: true, popoverContent: vDiskPageKeyset('evict-vdisk-not-allowed'), popoverDisabled: isUserAllowedToMakeChanges, children: [_jsx(Icon, { data: ArrowsOppositeToDots }), vDiskPageKeyset('evict-vdisk-button')] }) }));
+    };
+    const renderInfo = () => {
+        return _jsx(VDiskInfo, { data: vDiskData, isVDiskPage: true });
+    };
+    const renderGroupInfo = () => {
+        var _a;
+        if (groupData) {
+            return (_jsxs(React.Fragment, { children: [_jsx("div", { className: vDiskPageCn('group-title'), children: vDiskPageKeyset('group') }), _jsx(GroupInfo, { data: groupData }), _jsx("div", { className: vDiskPageCn('group-disks'), children: (_a = groupData.VDisks) === null || _a === void 0 ? void 0 : _a.map((vDisk) => {
+                            return (_jsx(VDiskWithDonorsStack, { data: vDisk, nodes: nodesMap, className: vDiskPageCn('group-disk') }, stringifyVdiskId(vDisk.VDiskId)));
+                        }) })] }));
+        }
+        return null;
+    };
+    const renderContent = () => {
+        if (loading) {
+            return _jsx(InfoViewerSkeleton, { rows: 20 });
+        }
+        return (_jsxs(React.Fragment, { children: [renderInfo(), renderGroupInfo()] }));
+    };
+    return (_jsxs("div", { className: vDiskPageCn(null), children: [renderHelmet(), renderPageMeta(), renderPageTitle(), renderControls(), renderContent()] }));
+}

package/dist/src/containers/VDiskPage/i18n/en.json

@@ -0,0 +1,10 @@
+{
+    "fqdn": "FQDN",
+    "node": "Node",
+    "pdisk": "PDisk",
+    "vdisk": "VDisk",
+    "group": "Group",
+    "evict-vdisk-button": "Evict VDisk",
+    "evict-vdisk-dialog": "VDisk will be evicted. Do you want to proceed?",
+    "evict-vdisk-not-allowed": "You don't have enough rights to evict VDisk"
+}

package/dist/src/containers/VDiskPage/i18n/index.d.ts

@@ -0,0 +1 @@
+export declare const vDiskPageKeyset: (key: "node" | "fqdn" | "group" | "pdisk" | "vdisk" | "evict-vdisk-button" | "evict-vdisk-dialog" | "evict-vdisk-not-allowed", params?: import("@gravity-ui/i18n").Params | undefined) => string;

package/dist/src/services/api.d.ts

@@ -0,0 +1,138 @@
+import AxiosWrapper from '@gravity-ui/axios-wrapper';
+import type { ComputeApiRequestParams, NodesApiRequestParams } from '../store/reducers/nodes/types';
+import type { StorageApiRequestParams } from '../store/reducers/storage/types';
+import type { TMetaInfo } from '../types/api/acl';
+import type { TQueryAutocomplete } from '../types/api/autocomplete';
+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 { 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 { 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';
+import type { TDomainKey, TEvTabletStateResponse, UnmergedTEvTabletStateResponse } from '../types/api/tablet';
+import type { TTenantInfo, TTenants } from '../types/api/tenant';
+import type { DescribeTopicResult } from '../types/api/topic';
+import type { TEvVDiskStateResponse } from '../types/api/vdisk';
+import type { TUserToken } from '../types/api/whoami';
+import type { QuerySyntax } from '../types/store/query';
+import type { Nullable } from '../utils/typecheckers';
+type AxiosOptions = {
+    concurrentId?: string;
+    signal?: AbortSignal;
+};
+export declare class YdbEmbeddedAPI extends AxiosWrapper {
+    getPath(path: string): string;
+    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 }: {
+        path: 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 }: {
+        nodeId: string | number;
+        pDiskId: string | number;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<TEvPDiskStateResponse>;
+    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 }: {
+        nodes?: string[];
+        path?: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<TEvTabletStateResponse>;
+    getSchema({ path }: {
+        path: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<Nullable<TEvDescribeSchemeResult>>;
+    getDescribe({ path }: {
+        path: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<Nullable<TEvDescribeSchemeResult>>;
+    getSchemaAcl({ path }: {
+        path: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<TMetaInfo>;
+    getHeatmapData({ path }: {
+        path: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<Nullable<TEvDescribeSchemeResult>>;
+    getNetwork(path: string, { concurrentId, signal }?: AxiosOptions): Promise<TNetInfo>;
+    getTopic({ path }: {
+        path?: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<DescribeTopicResult>;
+    getConsumer({ path, consumer }: {
+        path: string;
+        consumer: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<DescribeConsumerResult>;
+    getPoolInfo(poolName: string, { concurrentId, signal }?: AxiosOptions): Promise<TStorageInfo>;
+    getTablet({ id }: {
+        id?: string;
+    }, { concurrentId, signal }?: AxiosOptions): Promise<TEvTabletStateResponse>;
+    getTabletHistory({ id }: {
+        id?: string;
+    }, { 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 }: {
+        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>;
+    getHealthcheckInfo(database: string, { concurrentId, signal }?: AxiosOptions): Promise<HealthCheckAPIResponse>;
+    evictVDisk({ groupId, groupGeneration, failRealmIdx, failDomainIdx, vDiskIdx, }: {
+        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>;
+    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>;
+    logout(): Promise<any>;
+    whoami(): Promise<TUserToken>;
+    autocomplete(params: {
+        database: string;
+        prefix?: string;
+        limit?: number;
+        table?: string[];
+    }): Promise<TQueryAutocomplete>;
+    getClustersList(_?: never, { signal }?: {
+        signal?: AbortSignal;
+    }): Promise<MetaClusters>;
+}
+export declare class YdbWebVersionAPI extends YdbEmbeddedAPI {
+    getClusterInfo(clusterName: string, { signal }?: AxiosOptions): Promise<TClusterInfo>;
+    getTenants(clusterName: string, { concurrentId, signal }?: AxiosOptions): Promise<TTenantInfo>;
+}
+export declare function createApi({ webVersion, withCredentials }?: {
+    webVersion?: boolean | undefined;
+    withCredentials?: boolean | undefined;
+}): YdbEmbeddedAPI;
+export {};

package/dist/src/services/settings.d.ts

@@ -0,0 +1,41 @@
+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: false;
+    readonly queryUseMultiSchema: false;
+    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;
+};
+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 {};