ydb-embedded-ui 4.8.1 → 4.9.0

package/dist/{types/store/nodes.ts → store/reducers/nodes/types.ts}

@@ -1,22 +1,23 @@
-import type {IResponseError} from '../api/error';
-import type {TEndpoint, TPoolStats} from '../api/nodes';
-import type {TTabletStateInfo as TComputeTabletStateInfo} from '../api/compute';
-import type {TTabletStateInfo as TFullTabletStateInfo} from '../api/tablet';
-import type {EFlag} from '../api/enums';
+import type {IResponseError} from '../../../types/api/error';
+import type {TEndpoint, TPoolStats} from '../../../types/api/nodes';
+import type {TTabletStateInfo as TComputeTabletStateInfo} from '../../../types/api/compute';
+import type {TTabletStateInfo as TFullTabletStateInfo} from '../../../types/api/tablet';
+import type {EFlag} from '../../../types/api/enums';
+import type {ApiRequestAction} from '../../utils';
+import type {VisibleEntities} from '../storage/types';
 
-import {NodesUptimeFilterValues} from '../../utils/nodes';
+import {NodesUptimeFilterValues} from '../../../utils/nodes';
 import {
     FETCH_NODES,
     resetNodesState,
     setDataWasNotLoaded,
     setNodesUptimeFilter,
     setSearchValue,
-} from '../../store/reducers/nodes';
-import {ApiRequestAction} from '../../store/utils';
+} from './nodes';
 
 // Since nodes from different endpoints can have different types,
 // This type describes fields, that are expected by tables with nodes
-export interface INodesPreparedEntity {
+export interface NodesPreparedEntity {
     NodeId: number;
     Host?: string;
     SystemState?: EFlag;
@@ -33,43 +34,39 @@ export interface INodesPreparedEntity {
     Endpoints?: TEndpoint[];
 }
 
-export interface INodesState {
+export interface NodesState {
     loading: boolean;
     wasLoaded: boolean;
     nodesUptimeFilter: NodesUptimeFilterValues;
     searchValue: string;
-    data?: INodesPreparedEntity[];
+    data?: NodesPreparedEntity[];
     totalNodes?: number;
     error?: IResponseError;
 }
 
-type INodesApiRequestNodeType = 'static' | 'dynamic' | 'any';
+export type NodeType = 'static' | 'dynamic' | 'any';
 
-// Space - out of space nodes
-// Missing - nodes with missing disks
-type INodesApiRequestProblemType = 'missing' | 'space';
-
-export interface INodesApiRequestParams {
+export interface NodesApiRequestParams {
     tenant?: string;
-    type?: INodesApiRequestNodeType;
-    filter?: INodesApiRequestProblemType;
+    type?: NodeType;
+    visibleEntities?: VisibleEntities;
     storage?: boolean;
     tablets?: boolean;
 }
 
-export interface INodesHandledResponse {
-    Nodes?: INodesPreparedEntity[];
+export interface NodesHandledResponse {
+    Nodes?: NodesPreparedEntity[];
     TotalNodes: number;
 }
 
-type INodesApiRequestAction = ApiRequestAction<
+type NodesApiRequestAction = ApiRequestAction<
     typeof FETCH_NODES,
-    INodesHandledResponse,
+    NodesHandledResponse,
     IResponseError
 >;
 
-export type INodesAction =
-    | INodesApiRequestAction
+export type NodesAction =
+    | NodesApiRequestAction
     | (
           | ReturnType<typeof setDataWasNotLoaded>
           | ReturnType<typeof setNodesUptimeFilter>
@@ -77,6 +74,6 @@ export type INodesAction =
           | ReturnType<typeof resetNodesState>
       );
 
-export interface INodesRootStateSlice {
-    nodes: INodesState;
+export interface NodesStateSlice {
+    nodes: NodesState;
 }

package/dist/store/reducers/settings/settings.ts

@@ -13,10 +13,11 @@ import {
     QUERY_INITIAL_MODE_KEY,
     ENABLE_ADDITIONAL_QUERY_MODES,
     CLUSTER_INFO_HIDDEN_KEY,
+    LAST_USED_QUERY_ACTION_KEY,
 } from '../../../utils/constants';
 import '../../../services/api';
 import {getValueFromLS, parseJson} from '../../../utils/utils';
-import {QueryModes} from '../../../types/store/query';
+import {QUERY_ACTIONS, QUERY_MODES} from '../../../utils/query';
 
 import {TENANT_PAGES_IDS} from '../tenant/constants';
 
@@ -64,7 +65,14 @@ export const initialState = {
             TENANT_INITIAL_PAGE_KEY,
             TENANT_PAGES_IDS.query,
         ),
-        [QUERY_INITIAL_MODE_KEY]: readSavedSettingsValue(QUERY_INITIAL_MODE_KEY, QueryModes.script),
+        [QUERY_INITIAL_MODE_KEY]: readSavedSettingsValue(
+            QUERY_INITIAL_MODE_KEY,
+            QUERY_MODES.script,
+        ),
+        [LAST_USED_QUERY_ACTION_KEY]: readSavedSettingsValue(
+            LAST_USED_QUERY_ACTION_KEY,
+            QUERY_ACTIONS.execute,
+        ),
         [ASIDE_HEADER_COMPACT_KEY]: readSavedSettingsValue(ASIDE_HEADER_COMPACT_KEY, 'true'),
         [PARTITIONS_HIDDEN_COLUMNS_KEY]: readSavedSettingsValue(PARTITIONS_HIDDEN_COLUMNS_KEY),
         [CLUSTER_INFO_HIDDEN_KEY]: readSavedSettingsValue(CLUSTER_INFO_HIDDEN_KEY, 'true'),

package/dist/store/reducers/storage/constants.ts

@@ -0,0 +1,10 @@
+export const VISIBLE_ENTITIES = {
+    all: 'all',
+    missing: 'missing',
+    space: 'space',
+} as const;
+
+export const STORAGE_TYPES = {
+    groups: 'groups',
+    nodes: 'nodes',
+} as const;

package/dist/store/reducers/{storage.js → storage/storage.js}

@@ -1,31 +1,16 @@
 import _ from 'lodash';
 import {createSelector} from 'reselect';
 
-import {calcUptime} from '../../utils';
-import {getUsage} from '../../utils/storage';
-import {NodesUptimeFilterValues} from '../../utils/nodes';
-import {getPDiskType} from '../../utils/pdisk';
-import '../../services/api';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import {filterNodesByUptime} from './nodes';
-
-export const VisibleEntities = {
-    All: 'All',
-    Missing: 'Missing',
-    Space: 'Space',
-};
+import {calcUptime} from '../../../utils';
+import {getUsage} from '../../../utils/storage';
+import {NodesUptimeFilterValues} from '../../../utils/nodes';
+import {getPDiskType} from '../../../utils/pdisk';
+import '../../../services/api';
 
-export const VisibleEntitiesTitles = {
-    [VisibleEntities.All]: 'All',
-    [VisibleEntities.Missing]: 'Degraded',
-    [VisibleEntities.Space]: 'Out of Space',
-};
+import {createRequestActionTypes, createApiRequest} from '../../utils';
+import {filterNodesByUptime} from '../nodes/nodes';
 
-export const StorageTypes = {
-    groups: 'Groups',
-    nodes: 'Nodes',
-};
+import {VISIBLE_ENTITIES, STORAGE_TYPES} from './constants';
 
 const FETCH_STORAGE = createRequestActionTypes('storage', 'FETCH_STORAGE');
 const SET_INITIAL = 'storage/SET_INITIAL';
@@ -41,9 +26,9 @@ const initialState = {
     wasLoaded: false,
     filter: '',
     usageFilter: [],
-    visible: VisibleEntities.Missing,
+    visible: VISIBLE_ENTITIES.missing,
     nodesUptimeFilter: NodesUptimeFilterValues.All,
-    type: StorageTypes.groups,
+    type: STORAGE_TYPES.groups,
 };
 
 const storage = (state = initialState, action) => {
@@ -134,16 +119,16 @@ export function setInitialState() {
     };
 }
 
-export function getStorageInfo({tenant, filter, nodeId, type}, {concurrentId}) {
-    if (type === StorageTypes.nodes) {
+export function getStorageInfo({tenant, visibleEntities, nodeId, type}, {concurrentId}) {
+    if (type === STORAGE_TYPES.nodes) {
         return createApiRequest({
-            request: window.api.getNodes({tenant, filter, type: 'static'}, {concurrentId}),
+            request: window.api.getNodes({tenant, visibleEntities, type: 'static'}, {concurrentId}),
             actions: FETCH_STORAGE,
         });
     }
 
     return createApiRequest({
-        request: window.api.getStorageInfo({tenant, filter, nodeId}, {concurrentId}),
+        request: window.api.getStorageInfo({tenant, visibleEntities, nodeId}, {concurrentId}),
         actions: FETCH_STORAGE,
     });
 }
@@ -343,26 +328,13 @@ export const getVDisksForPDisk = createSelector(
 export const getFlatListStorage = createSelector(
     [getStorageType, getFlatListStorageGroups, getFlatListStorageNodes],
     (storageType, groupsList, nodesList) => {
-        if (storageType === StorageTypes.groups) {
+        if (storageType === STORAGE_TYPES.groups) {
             return groupsList;
         }
         return nodesList;
     },
 );
 
-export const getVisibleEntitiesList = createSelector(
-    [getVisibleEntities, getFlatListStorage],
-    (visibleGroups, storageList) => {
-        if (visibleGroups === VisibleEntities.All) {
-            return storageList;
-        } else if (visibleGroups === VisibleEntities.Missing) {
-            return _.filter(storageList, (g) => g.Missing > 0);
-        } else {
-            return _.filter(storageList, (g) => g.UsedSpaceFlag > 100);
-        }
-    },
-);
-
 const filterByText = (entities, type, text) => {
     const cleanedFilter = text.trim().toLowerCase();
 
@@ -371,7 +343,7 @@ const filterByText = (entities, type, text) => {
     }
 
     return entities.filter((entity) => {
-        if (type === StorageTypes.groups) {
+        if (type === STORAGE_TYPES.groups) {
             return (
                 entity.PoolName.toLowerCase().includes(cleanedFilter) ||
                 entity.GroupID?.toString().includes(cleanedFilter)
@@ -397,19 +369,13 @@ const filterByUsage = (entities, usage) => {
 };
 
 export const getFilteredEntities = createSelector(
-    [
-        getStorageFilter,
-        getUsageFilter,
-        getStorageType,
-        getNodesUptimeFilter,
-        getVisibleEntitiesList,
-    ],
+    [getStorageFilter, getUsageFilter, getStorageType, getNodesUptimeFilter, getFlatListStorage],
     (textFilter, usageFilter, type, nodesUptimeFilter, entities) => {
         let result = entities;
         result = filterByText(result, type, textFilter);
         result = filterByUsage(result, usageFilter);
 
-        if (type === StorageTypes.nodes) {
+        if (type === STORAGE_TYPES.nodes) {
             result = filterNodesByUptime(result, nodesUptimeFilter);
         }
 
@@ -417,7 +383,7 @@ export const getFilteredEntities = createSelector(
     },
 );
 
-export const getUsageFilterOptions = createSelector(getVisibleEntitiesList, (entities) => {
+export const getUsageFilterOptions = createSelector(getFlatListStorage, (entities) => {
     const items = {};
 
     entities.forEach((entity) => {

package/dist/store/reducers/storage/types.ts

@@ -0,0 +1,12 @@
+import type {ValueOf} from '../../../types/common';
+
+import {STORAGE_TYPES, VISIBLE_ENTITIES} from './constants';
+
+export type VisibleEntities = ValueOf<typeof VISIBLE_ENTITIES>;
+export type StorageType = ValueOf<typeof STORAGE_TYPES>;
+
+export interface StorageApiRequestParams {
+    tenant?: string;
+    nodeId?: string;
+    visibleEntities?: VisibleEntities;
+}

package/dist/types/store/query.ts

@@ -1,3 +1,5 @@
+import {QUERY_ACTIONS, QUERY_MODES} from '../../utils/query';
+
 import type {NetworkError} from '../api/error';
 import type {
     KeyValueRow,
@@ -7,6 +9,7 @@ import type {
     QueryPlan,
     TKqpStatsQuery,
 } from '../api/query';
+import type {ValueOf} from '../common';
 
 export interface IQueryResult {
     result?: KeyValueRow[];
@@ -23,12 +26,8 @@ export interface QueryRequestParams {
 
 export type QueryError = NetworkError | ErrorResponse;
 
-export enum QueryModes {
-    scan = 'scan',
-    script = 'script',
-    data = 'data',
-    query = 'query',
-}
+export type QueryAction = ValueOf<typeof QUERY_ACTIONS>;
+export type QueryMode = ValueOf<typeof QUERY_MODES>;
 
 export interface SavedQuery {
     name: string;

package/dist/utils/constants.ts

@@ -105,6 +105,7 @@ export const DEFAULT_TABLE_SETTINGS = {
 } as const;
 
 export const QUERY_INITIAL_MODE_KEY = 'query_initial_mode';
+export const LAST_USED_QUERY_ACTION_KEY = 'last_used_query_action';
 
 export const PARTITIONS_HIDDEN_COLUMNS_KEY = 'partitionsHiddenColumns';
 

package/dist/utils/nodes.ts

@@ -1,6 +1,6 @@
 import type {TSystemStateInfo} from '../types/api/nodes';
 import type {TNodeInfo} from '../types/api/nodesList';
-import type {INodesPreparedEntity} from '../types/store/nodes';
+import type {NodesPreparedEntity} from '../store/reducers/nodes/types';
 import type {NodesMap} from '../types/store/nodesList';
 import {EFlag} from '../types/api/enums';
 
@@ -14,7 +14,7 @@ export const NodesUptimeFilterTitles = {
     [NodesUptimeFilterValues.SmallUptime]: 'Uptime < 1h',
 };
 
-export const isUnavailableNode = (node: INodesPreparedEntity | TSystemStateInfo) =>
+export const isUnavailableNode = (node: NodesPreparedEntity | TSystemStateInfo) =>
     !node.SystemState || node.SystemState === EFlag.Grey;
 
 export type NodeAddress = Pick<TSystemStateInfo, 'Host' | 'Endpoints'>;

package/dist/utils/query.ts

@@ -9,6 +9,18 @@ import type {
 } from '../types/api/query';
 import type {IQueryResult} from '../types/store/query';
 
+export const QUERY_ACTIONS = {
+    execute: 'execute',
+    explain: 'explain',
+} as const;
+
+export const QUERY_MODES = {
+    scan: 'scan',
+    script: 'script',
+    data: 'data',
+    query: 'query',
+} as const;
+
 // eslint-disable-next-line complexity
 export const getColumnType = (type: string) => {
     switch (type.replace(/\?$/, '')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-embedded-ui",
-  "version": "4.8.1",
+  "version": "4.9.0",
   "files": [
     "dist"
   ],

package/dist/containers/Tenant/Query/QueryEditorControls/OldQueryEditorControls.tsx

@@ -1,90 +0,0 @@
-import {Button, DropdownMenu} from '@gravity-ui/uikit';
-import {useMemo} from 'react';
-
-import {QueryModes} from '../../../../types/store/query';
-import {Icon} from '../../../../components/Icon';
-
-import SaveQuery from '../SaveQuery/SaveQuery';
-
-import {QueryEditorControlsProps, b} from './shared';
-
-import './QueryEditorControls.scss';
-
-type OldQueryModes = QueryModes.script | QueryModes.scan;
-
-export const QueryModeSelectorTitles = {
-    [QueryModes.script]: 'Script',
-    [QueryModes.scan]: 'Scan',
-} as const;
-
-export const OldQueryEditorControls = ({
-    onRunButtonClick,
-    runIsLoading,
-    onExplainButtonClick,
-    explainIsLoading,
-    onSaveQueryClick,
-    savedQueries,
-    disabled,
-    onUpdateQueryMode,
-    queryMode,
-}: QueryEditorControlsProps) => {
-    const runModeSelectorMenuItems = useMemo(() => {
-        return Object.entries(QueryModeSelectorTitles).map(([mode, title]) => {
-            return {
-                text: `Run ${title}`,
-                action: () => {
-                    onUpdateQueryMode(mode as OldQueryModes);
-                },
-            };
-        });
-    }, [onUpdateQueryMode]);
-
-    return (
-        <div className={b()}>
-            <div className={b('left')}>
-                <div className={b('run')}>
-                    <Button
-                        onClick={() => onRunButtonClick(queryMode)}
-                        view="action"
-                        pin="round-brick"
-                        disabled={disabled}
-                        loading={runIsLoading}
-                    >
-                        <Icon name="startPlay" viewBox="0 0 16 16" width={16} height={16} />
-                        {`Run ${QueryModeSelectorTitles[queryMode as OldQueryModes]}`}
-                    </Button>
-                    <DropdownMenu
-                        items={runModeSelectorMenuItems}
-                        popupProps={{className: b('select-query-action-popup')}}
-                        switcher={
-                            <Button
-                                view="action"
-                                pin="brick-round"
-                                disabled={disabled}
-                                loading={runIsLoading}
-                                className={b('select-query-action')}
-                            >
-                                <Icon name="chevron-down" width={16} height={16} />
-                            </Button>
-                        }
-                    />
-                </div>
-                <Button
-                    onClick={() => {
-                        // Without defined query mode it sends 'explain' action
-                        onExplainButtonClick();
-                    }}
-                    disabled={disabled}
-                    loading={explainIsLoading}
-                >
-                    Explain
-                </Button>
-            </div>
-            <SaveQuery
-                savedQueries={savedQueries}
-                onSaveQuery={onSaveQueryClick}
-                saveButtonDisabled={disabled}
-            />
-        </div>
-    );
-};

package/dist/containers/Tenant/Query/QueryEditorControls/shared.ts

@@ -1,18 +0,0 @@
-import block from 'bem-cn-lite';
-
-import type {QueryModes} from '../../../../types/store/query';
-
-export const b = block('ydb-query-editor-controls');
-
-export interface QueryEditorControlsProps {
-    onRunButtonClick: (mode?: QueryModes) => void;
-    runIsLoading: boolean;
-    onExplainButtonClick: (mode?: QueryModes) => void;
-    explainIsLoading: boolean;
-    onSaveQueryClick: (queryName: string) => void;
-    savedQueries: unknown;
-    disabled: boolean;
-    onUpdateQueryMode: (mode: QueryModes) => void;
-    queryMode: QueryModes;
-    enableQueryModesForExplain: boolean;
-}