ydb-embedded-ui 4.10.0 → 4.11.0

package/dist/store/reducers/nodes/nodes.ts

@@ -1,25 +1,18 @@
 import type {Reducer} from 'redux';
-import {createSelector, Selector} from 'reselect';
-import {escapeRegExp} from 'lodash/fp';
 
 import '../../../services/api';
-import {HOUR_IN_SECONDS} from '../../../utils/constants';
-import {calcUptime, calcUptimeInSeconds} from '../../../utils';
 import {NodesUptimeFilterValues} from '../../../utils/nodes';
-import {EFlag} from '../../../types/api/enums';
+import {EVersion} from '../../../types/api/compute';
 
-import type {ProblemFilterValue} from '../settings/types';
 import {createRequestActionTypes, createApiRequest} from '../../utils';
-import {ProblemFilterValues} from '../settings/settings';
 
 import type {
+    ComputeApiRequestParams,
     NodesAction,
     NodesApiRequestParams,
-    NodesHandledResponse,
-    NodesPreparedEntity,
-    NodesStateSlice,
     NodesState,
 } from './types';
+import {prepareComputeNodesData, prepareNodesData} from './utils';
 
 export const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
 
@@ -93,60 +86,22 @@ const nodes: Reducer<NodesState, NodesAction> = (state = initialState, action) =
     }
 };
 
-export function getNodes({tenant, visibleEntities, type = 'any'}: NodesApiRequestParams) {
+export function getNodes({type = 'any', ...params}: NodesApiRequestParams) {
     return createApiRequest({
-        request: window.api.getNodes({tenant, visibleEntities, type}),
+        request: window.api.getNodes({
+            type,
+            ...params,
+        }),
         actions: FETCH_NODES,
-        dataHandler: (data): NodesHandledResponse => {
-            const rawNodes = data.Nodes || [];
-
-            const preparedNodes = rawNodes.map((node) => {
-                return {
-                    ...node?.SystemState,
-                    Tablets: node?.Tablets,
-                    NodeId: node?.NodeId,
-                    Uptime: calcUptime(node?.SystemState?.StartTime),
-                    TenantName: node?.SystemState?.Tenants?.[0],
-                };
-            });
-
-            return {
-                Nodes: preparedNodes,
-                TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
-            };
-        },
+        dataHandler: prepareNodesData,
     });
 }
 
-export function getComputeNodes(path: string) {
+export function getComputeNodes({version = EVersion.v2, ...params}: ComputeApiRequestParams) {
     return createApiRequest({
-        request: window.api.getCompute(path),
+        request: window.api.getCompute({version, ...params}),
         actions: FETCH_NODES,
-        dataHandler: (data): NodesHandledResponse => {
-            const preparedNodes: NodesPreparedEntity[] = [];
-
-            if (data.Tenants) {
-                for (const tenant of data.Tenants) {
-                    if (tenant && tenant.Nodes) {
-                        const tenantNodes = tenant.Nodes.map((node) => {
-                            return {
-                                ...node,
-                                TenantName: tenant.Name,
-                                SystemState: node?.Overall,
-                                Uptime: calcUptime(node?.StartTime),
-                            };
-                        });
-
-                        preparedNodes.push(...tenantNodes);
-                    }
-                }
-            }
-
-            return {
-                Nodes: preparedNodes,
-                TotalNodes: preparedNodes.length,
-            };
-        },
+        dataHandler: prepareComputeNodesData,
     });
 }
 
@@ -175,58 +130,4 @@ export const setSearchValue = (value: string) => {
     } as const;
 };
 
-const getNodesUptimeFilter = (state: NodesStateSlice) => state.nodes.nodesUptimeFilter;
-const getSearchValue = (state: NodesStateSlice) => state.nodes.searchValue;
-const getNodesList = (state: NodesStateSlice) => state.nodes.data;
-
-const filterNodesByProblemsStatus = (
-    nodesList: NodesPreparedEntity[] = [],
-    problemFilter: ProblemFilterValue,
-) => {
-    if (problemFilter === ProblemFilterValues.ALL) {
-        return nodesList;
-    }
-
-    return nodesList.filter(({SystemState}) => {
-        return SystemState && SystemState !== EFlag.Green;
-    });
-};
-
-export const filterNodesByUptime = <T extends {StartTime?: string}>(
-    nodesList: T[] = [],
-    nodesUptimeFilter: NodesUptimeFilterValues,
-) => {
-    if (nodesUptimeFilter === NodesUptimeFilterValues.All) {
-        return nodesList;
-    }
-    return nodesList.filter(({StartTime}) => {
-        return !StartTime || calcUptimeInSeconds(StartTime) < HOUR_IN_SECONDS;
-    });
-};
-
-const filterNodesBySearchValue = (nodesList: NodesPreparedEntity[] = [], searchValue: string) => {
-    if (!searchValue) {
-        return nodesList;
-    }
-    const re = new RegExp(escapeRegExp(searchValue), 'i');
-
-    return nodesList.filter((node) => {
-        return node.Host ? re.test(node.Host) || re.test(String(node.NodeId)) : true;
-    });
-};
-
-export const getFilteredPreparedNodesList: Selector<
-    NodesStateSlice,
-    NodesPreparedEntity[] | undefined
-> = createSelector(
-    [getNodesList, getNodesUptimeFilter, getSearchValue, (state) => state.settings.problemFilter],
-    (nodesList, uptimeFilter, searchValue, problemFilter) => {
-        let result = filterNodesByUptime(nodesList, uptimeFilter);
-        result = filterNodesByProblemsStatus(result, problemFilter);
-        result = filterNodesBySearchValue(result, searchValue);
-
-        return result;
-    },
-);
-
 export default nodes;

package/dist/store/reducers/nodes/selectors.ts

@@ -0,0 +1,74 @@
+import {Selector, createSelector} from 'reselect';
+import {escapeRegExp} from 'lodash';
+
+import {EFlag} from '../../../types/api/enums';
+import {calcUptimeInSeconds} from '../../../utils';
+import {HOUR_IN_SECONDS} from '../../../utils/constants';
+import {NodesUptimeFilterValues} from '../../../utils/nodes';
+
+import type {ProblemFilterValue} from '../settings/types';
+import type {NodesPreparedEntity, NodesStateSlice} from './types';
+import {ProblemFilterValues} from '../settings/settings';
+
+// ==== Filters ====
+
+const filterNodesByProblemsStatus = (
+    nodesList: NodesPreparedEntity[] = [],
+    problemFilter: ProblemFilterValue,
+) => {
+    if (problemFilter === ProblemFilterValues.ALL) {
+        return nodesList;
+    }
+
+    return nodesList.filter(({SystemState}) => {
+        return SystemState && SystemState !== EFlag.Green;
+    });
+};
+
+export const filterNodesByUptime = <T extends {StartTime?: string}>(
+    nodesList: T[] = [],
+    nodesUptimeFilter: NodesUptimeFilterValues,
+) => {
+    if (nodesUptimeFilter === NodesUptimeFilterValues.All) {
+        return nodesList;
+    }
+    return nodesList.filter(({StartTime}) => {
+        return !StartTime || calcUptimeInSeconds(StartTime) < HOUR_IN_SECONDS;
+    });
+};
+
+const filterNodesBySearchValue = (nodesList: NodesPreparedEntity[] = [], searchValue: string) => {
+    if (!searchValue) {
+        return nodesList;
+    }
+    const re = new RegExp(escapeRegExp(searchValue), 'i');
+
+    return nodesList.filter((node) => {
+        return node.Host ? re.test(node.Host) || re.test(String(node.NodeId)) : true;
+    });
+};
+
+// ==== Simple selectors ====
+
+const selectNodesUptimeFilter = (state: NodesStateSlice) => state.nodes.nodesUptimeFilter;
+const selectSearchValue = (state: NodesStateSlice) => state.nodes.searchValue;
+const selectNodesList = (state: NodesStateSlice) => state.nodes.data;
+
+// ==== Complex selectors ====
+
+export const selectFilteredNodes: Selector<NodesStateSlice, NodesPreparedEntity[] | undefined> =
+    createSelector(
+        [
+            selectNodesList,
+            selectNodesUptimeFilter,
+            selectSearchValue,
+            (state) => state.settings.problemFilter,
+        ],
+        (nodesList, uptimeFilter, searchValue, problemFilter) => {
+            let result = filterNodesByUptime(nodesList, uptimeFilter);
+            result = filterNodesByProblemsStatus(result, problemFilter);
+            result = filterNodesBySearchValue(result, searchValue);
+
+            return result;
+        },
+    );

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

@@ -1,6 +1,9 @@
 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 {
+    EVersion,
+    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';
@@ -46,17 +49,33 @@ export interface NodesState {
 
 export type NodeType = 'static' | 'dynamic' | 'any';
 
-export interface NodesApiRequestParams {
+interface RequestParams {
+    filter?: string; // NodeId or Host
+    uptime?: number; // return nodes with less uptime in seconds
+    problems_only?: boolean; // return nodes with SystemState !== EFlag.Green
+    sort?: string; // Sort by one of ESort params (may differ for /nodes and /compute)
+
+    offser?: number;
+    limit?: number;
+}
+
+export interface NodesApiRequestParams extends RequestParams {
     tenant?: string;
     type?: NodeType;
-    visibleEntities?: VisibleEntities;
+    visibleEntities?: VisibleEntities; // "with" param
     storage?: boolean;
     tablets?: boolean;
 }
 
+export interface ComputeApiRequestParams extends RequestParams {
+    path: string;
+    version?: EVersion; // only v2 works with filters
+}
+
 export interface NodesHandledResponse {
     Nodes?: NodesPreparedEntity[];
     TotalNodes: number;
+    FoundNodes?: number;
 }
 
 type NodesApiRequestAction = ApiRequestAction<

package/dist/store/reducers/nodes/utils.ts

@@ -0,0 +1,59 @@
+import type {TComputeInfo, TComputeNodeInfo} from '../../../types/api/compute';
+import type {TNodesInfo} from '../../../types/api/nodes';
+import {calcUptime} from '../../../utils';
+
+import type {NodesHandledResponse, NodesPreparedEntity} from './types';
+
+const prepareComputeNode = (node: TComputeNodeInfo, tenantName?: string) => {
+    return {
+        ...node,
+        // v2 response has tenant name, v1 - doesn't
+        TenantName: node.Tenant ?? tenantName,
+        SystemState: node?.Overall,
+        Uptime: calcUptime(node?.StartTime),
+    };
+};
+
+export const prepareComputeNodesData = (data: TComputeInfo): NodesHandledResponse => {
+    const preparedNodes: NodesPreparedEntity[] = [];
+
+    // First try to parse v2 response in case backend supports it
+    // Else parse v1 response
+    if (data.Nodes) {
+        data.Nodes.forEach((node) => {
+            preparedNodes.push(prepareComputeNode(node));
+        });
+    } else if (data.Tenants) {
+        for (const tenant of data.Tenants) {
+            tenant.Nodes?.forEach((node) => {
+                preparedNodes.push(prepareComputeNode(node, tenant.Name));
+            });
+        }
+    }
+
+    return {
+        Nodes: preparedNodes,
+        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
+        FoundNodes: Number(data.FoundNodes),
+    };
+};
+
+export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
+    const rawNodes = data.Nodes || [];
+
+    const preparedNodes = rawNodes.map((node) => {
+        return {
+            ...node.SystemState,
+            Tablets: node.Tablets,
+            NodeId: node.NodeId,
+            Uptime: calcUptime(node.SystemState?.StartTime),
+            TenantName: node.SystemState?.Tenants?.[0],
+        };
+    });
+
+    return {
+        Nodes: preparedNodes,
+        TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
+        FoundNodes: Number(data.FoundNodes),
+    };
+};

package/dist/store/reducers/preview.ts

@@ -1,7 +1,7 @@
 import '../../services/api';
 
-import type {ErrorResponse, ExecuteActions} from '../../types/api/query';
-import type {IQueryResult} from '../../types/store/query';
+import type {ExecuteActions} from '../../types/api/query';
+import type {IQueryResult, QueryErrorResponse} from '../../types/store/query';
 import {parseQueryAPIExecuteResponse} from '../../utils/query';
 
 import {createRequestActionTypes, createApiRequest, ApiRequestAction} from '../utils';
@@ -16,7 +16,9 @@ const initialState = {
 
 const preview = (
     state = initialState,
-    action: ApiRequestAction<typeof SEND_QUERY, IQueryResult, ErrorResponse> | ReturnType<typeof setQueryOptions>,
+    action:
+        | ApiRequestAction<typeof SEND_QUERY, IQueryResult, QueryErrorResponse>
+        | ReturnType<typeof setQueryOptions>,
 ) => {
     switch (action.type) {
         case SEND_QUERY.REQUEST: {
@@ -57,7 +59,7 @@ interface SendQueryParams {
     query?: string;
     database?: string;
     action?: ExecuteActions;
-};
+}
 
 export const sendQuery = ({query, database, action}: SendQueryParams) => {
     return createApiRequest({

package/dist/store/reducers/schemaAcl/schemaAcl.ts

@@ -6,6 +6,7 @@ import {createRequestActionTypes, createApiRequest} from '../../utils';
 import type {SchemaAclAction, SchemaAclState} from './types';
 
 export const FETCH_SCHEMA_ACL = createRequestActionTypes('schemaAcl', 'FETCH_SCHEMA_ACL');
+const SET_ACL_WAS_NOT_LOADED = 'schemaAcl/SET_DATA_WAS_NOT_LOADED';
 
 const initialState = {
     loading: false,
@@ -34,12 +35,22 @@ const schemaAcl: Reducer<SchemaAclState, SchemaAclAction> = (state = initialStat
             };
         }
         case FETCH_SCHEMA_ACL.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
             return {
                 ...state,
                 error: action.error,
                 loading: false,
             };
         }
+        case SET_ACL_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
         default:
             return state;
     }
@@ -52,4 +63,10 @@ export function getSchemaAcl({path}: {path: string}) {
     });
 }
 
+export const setAclWasNotLoaded = () => {
+    return {
+        type: SET_ACL_WAS_NOT_LOADED,
+    } as const;
+};
+
 export default schemaAcl;

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

@@ -2,14 +2,16 @@ import type {TACE, TMetaInfo} from '../../../types/api/acl';
 import type {IResponseError} from '../../../types/api/error';
 import type {ApiRequestAction} from '../../utils';
 
-import {FETCH_SCHEMA_ACL} from './schemaAcl';
+import {FETCH_SCHEMA_ACL, setAclWasNotLoaded} from './schemaAcl';
 
 export interface SchemaAclState {
-    loading: boolean
-    wasLoaded: boolean
-    acl?: TACE[]
-    owner?: string
-    error?: IResponseError
+    loading: boolean;
+    wasLoaded: boolean;
+    acl?: TACE[];
+    owner?: string;
+    error?: IResponseError;
 }
 
-export type SchemaAclAction = ApiRequestAction<typeof FETCH_SCHEMA_ACL, TMetaInfo, IResponseError>;
+export type SchemaAclAction =
+    | ApiRequestAction<typeof FETCH_SCHEMA_ACL, TMetaInfo, IResponseError>
+    | ReturnType<typeof setAclWasNotLoaded>;

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

@@ -15,7 +15,7 @@ import type {
     StorageStateSlice,
     UsageFilter,
 } from './types';
-import {filterNodesByUptime} from '../nodes/nodes';
+import {filterNodesByUptime} from '../nodes/selectors';
 
 // ==== Prepare data ====
 const FLAGS_POINTS = {

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

@@ -25,3 +25,9 @@ export const TENANT_DIAGNOSTICS_TABS_IDS = {
     consumers: 'consumers',
     partitions: 'partitions',
 } as const;
+
+export const TENANT_SUMMARY_TABS_IDS = {
+    overview: 'overview',
+    acl: 'acl',
+    schema: 'schema',
+} as const;

package/dist/store/reducers/tenant/tenant.ts

@@ -7,6 +7,7 @@ import type {
     TenantPage,
     TenantQueryTab,
     TenantState,
+    TenantSummaryTab,
 } from './types';
 
 import '../../../services/api';
@@ -17,6 +18,7 @@ export const FETCH_TENANT = createRequestActionTypes('tenant', 'FETCH_TENANT');
 const SET_TOP_LEVEL_TAB = 'tenant/SET_TOP_LEVEL_TAB';
 const SET_QUERY_TAB = 'tenant/SET_QUERY_TAB';
 const SET_DIAGNOSTICS_TAB = 'tenant/SET_DIAGNOSTICS_TAB';
+const SET_SUMMARY_TAB = 'tenant/SET_SUMMARY_TAB';
 const CLEAR_TENANT = 'tenant/CLEAR_TENANT';
 
 const initialState = {loading: false, wasLoaded: false};
@@ -75,6 +77,12 @@ const tenantReducer: Reducer<TenantState, TenantAction> = (state = initialState,
                 diagnosticsTab: action.data,
             };
         }
+        case SET_SUMMARY_TAB: {
+            return {
+                ...state,
+                summaryTab: action.data,
+            };
+        }
 
         default:
             return state;
@@ -116,4 +124,11 @@ export function setDiagnosticsTab(tab: TenantDiagnosticsTab) {
     } as const;
 }
 
+export function setSummaryTab(tab: TenantSummaryTab) {
+    return {
+        type: SET_SUMMARY_TAB,
+        data: tab,
+    } as const;
+}
+
 export default tenantReducer;

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

@@ -3,13 +3,26 @@ import type {TTenant} from '../../../types/api/tenant';
 import type {ValueOf} from '../../../types/common';
 import type {ApiRequestAction} from '../../utils';
 
-import {TENANT_QUERY_TABS_ID, TENANT_DIAGNOSTICS_TABS_IDS, TENANT_PAGES_IDS} from './constants';
-import {FETCH_TENANT, clearTenant, setDiagnosticsTab, setQueryTab, setTenantPage} from './tenant';
+import {
+    TENANT_QUERY_TABS_ID,
+    TENANT_DIAGNOSTICS_TABS_IDS,
+    TENANT_PAGES_IDS,
+    TENANT_SUMMARY_TABS_IDS,
+} from './constants';
+import {
+    FETCH_TENANT,
+    clearTenant,
+    setDiagnosticsTab,
+    setQueryTab,
+    setSummaryTab,
+    setTenantPage,
+} from './tenant';
 
 export type TenantPage = ValueOf<typeof TENANT_PAGES_IDS>;
 
 export type TenantQueryTab = ValueOf<typeof TENANT_QUERY_TABS_ID>;
 export type TenantDiagnosticsTab = ValueOf<typeof TENANT_DIAGNOSTICS_TABS_IDS>;
+export type TenantSummaryTab = ValueOf<typeof TENANT_SUMMARY_TABS_IDS>;
 
 export interface TenantState {
     loading: boolean;
@@ -17,6 +30,7 @@ export interface TenantState {
     tenantPage?: TenantPage;
     queryTab?: TenantQueryTab;
     diagnosticsTab?: TenantDiagnosticsTab;
+    summaryTab?: TenantSummaryTab;
     tenant?: TTenant;
     error?: IResponseError;
 }
@@ -26,4 +40,5 @@ export type TenantAction =
     | ReturnType<typeof clearTenant>
     | ReturnType<typeof setTenantPage>
     | ReturnType<typeof setQueryTab>
-    | ReturnType<typeof setDiagnosticsTab>;
+    | ReturnType<typeof setDiagnosticsTab>
+    | ReturnType<typeof setSummaryTab>;

package/dist/store/state-url-mapping.js

@@ -51,6 +51,9 @@ const paramSetup = {
         diagnosticsTab: {
             stateKey: 'tenant.diagnosticsTab',
         },
+        summaryTab: {
+            stateKey: 'tenant.summaryTab',
+        },
         shardsMode: {
             stateKey: 'shardsWorkload.filters.mode',
         },

package/dist/types/api/cluster.ts

@@ -31,7 +31,7 @@ export interface TClusterInfo {
     Tenants?: string;
     /** uint64 */
     Tablets?: string;
-    
+
     Balancer?: string; // additional
     Solomon?: string; // additional
 }

package/dist/types/api/compute.ts

@@ -4,13 +4,20 @@ import {TMetrics} from './tenant';
 
 /**
  * endpoint: viewer/json/compute
- * 
+ *
  * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ *
+ * response has 2 versions, depending on version param in request
  */
 export interface TComputeInfo {
     Overall: EFlag;
-    Tenants?: TComputeTenantInfo[];
+    Tenants?: TComputeTenantInfo[]; // v1
     Errors?: string[];
+    /** uint64 */
+    TotalNodes: string;
+    /** uint64 */
+    FoundNodes: string;
+    Nodes?: TComputeNodeInfo[]; // v2
 }
 
 interface TComputeTenantInfo {
@@ -43,6 +50,7 @@ export interface TComputeNodeInfo {
     MemoryLimit?: string;
     Metrics: TMetrics;
     Tablets?: TTabletStateInfo[];
+    Tenant?: string; // For v2 response without grouping by tenants
 }
 
 // Tablets in compute nodes
@@ -52,3 +60,20 @@ export interface TTabletStateInfo {
     State: EFlag;
     Count: number;
 }
+
+export enum EVersion {
+    v1 = 'v1',
+    v2 = 'v2', // only this versions works with sorting
+}
+
+export enum ESort {
+    NodeId = 'NodeId',
+    Host = 'Host',
+    DC = 'DC',
+    Rack = 'Rack',
+    Version = 'Version',
+    Uptime = 'Uptime',
+    Memory = 'Memory',
+    CPU = 'CPU',
+    LoadAverage = 'LoadAverage',
+}

package/dist/types/api/error.ts

@@ -1,5 +1,5 @@
-export interface IResponseError {
-    data?: unknown;
+export interface IResponseError<T = unknown> {
+    data?: T;
     status?: number;
     statusText?: string;
     isCancelled?: boolean;

package/dist/types/api/netInfo.ts

@@ -42,7 +42,7 @@ interface TNetNodePeerInfo {
 }
 
 enum ENodeType {
-    UnknownNodeType,
-    Static,
-    Dynamic,
+    UnknownNodeType = 'UnknownNodeType',
+    Static = 'Static',
+    Dynamic = 'Dynamic',
 }

package/dist/types/api/nodes.ts

@@ -5,7 +5,7 @@ import {TVDiskStateInfo} from './vdisk';
 
 /**
  * endpoint: /viewer/json/nodes
- * 
+ *
  * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
  */
 export interface TNodesInfo {
@@ -101,3 +101,15 @@ enum EConfigState {
     'Consistent' = 'Consistent',
     'Outdated' = 'Outdated',
 }
+
+export enum ESort {
+    NodeId = 'NodeId',
+    Host = 'Host',
+    DC = 'DC',
+    Rack = 'Rack',
+    Version = 'Version',
+    Uptime = 'Uptime',
+    Memory = 'Memory',
+    CPU = 'CPU',
+    LoadAverage = 'LoadAverage',
+}

package/dist/types/api/query.ts

@@ -205,7 +205,7 @@ export type Actions = ExecuteActions | ExplainActions;
 
 export interface ErrorResponse {
     error?: IssueMessage;
-    issues?: IssueMessage[];
+    issues?: IssueMessage[] | null;
 }
 
 // ==== Explain Responses ====