ydb-embedded-ui 4.5.1 → 4.6.0

package/dist/store/reducers/node/node.ts

@@ -0,0 +1,102 @@
+import {Reducer} from 'redux';
+
+import '../../../services/api';
+import {createRequestActionTypes, createApiRequest} from '../../utils';
+
+import type {NodeAction, NodeState} from './types';
+
+export const FETCH_NODE = createRequestActionTypes('node', 'FETCH_NODE');
+export const FETCH_NODE_STRUCTURE = createRequestActionTypes('node', 'FETCH_NODE_STRUCTURE');
+
+const RESET_NODE = 'node/RESET_NODE';
+
+const initialState = {
+    data: {},
+    loading: true,
+    wasLoaded: false,
+    nodeStructure: {},
+    loadingStructure: true,
+    wasLoadedStructure: false,
+};
+
+const node: Reducer<NodeState, NodeAction> = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_NODE.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_NODE.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_NODE.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case FETCH_NODE_STRUCTURE.REQUEST: {
+            return {
+                ...state,
+                loadingStructure: true,
+            };
+        }
+        case FETCH_NODE_STRUCTURE.SUCCESS: {
+            return {
+                ...state,
+                nodeStructure: action.data,
+                loadingStructure: false,
+                wasLoadedStructure: true,
+                errorStructure: undefined,
+            };
+        }
+        case FETCH_NODE_STRUCTURE.FAILURE: {
+            return {
+                ...state,
+                errorStructure: action.error,
+                loadingStructure: false,
+            };
+        }
+        case RESET_NODE: {
+            return {
+                ...state,
+                data: {},
+                wasLoaded: false,
+                nodeStructure: {},
+                wasLoadedStructure: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const getNodeInfo = (id: string) => {
+    return createApiRequest({
+        request: window.api.getNodeInfo(id),
+        actions: FETCH_NODE,
+    });
+};
+
+export const getNodeStructure = (nodeId: string) => {
+    return createApiRequest({
+        request: window.api.getStorageInfo({nodeId}, {concurrentId: 'getNodeStructure'}),
+        actions: FETCH_NODE_STRUCTURE,
+    });
+};
+
+export function resetNode() {
+    return {
+        type: RESET_NODE,
+    } as const;
+}
+
+export default node;

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

@@ -0,0 +1,59 @@
+import type {Selector} from 'reselect';
+import {createSelector} from 'reselect';
+
+import {stringifyVdiskId} from '../../../utils';
+
+import type {
+    NodeStateSlice,
+    PreparedNodeStructure,
+    PreparedStructureVDisk,
+    RawNodeStructure,
+} from './types';
+
+const selectNodeId = (state: NodeStateSlice) => state.node?.data?.SystemStateInfo?.[0].NodeId;
+
+const selectRawNodeStructure = (state: NodeStateSlice) => state.node?.nodeStructure;
+
+export const selectNodeStructure: Selector<NodeStateSlice, PreparedNodeStructure> = createSelector(
+    [selectNodeId, selectRawNodeStructure],
+    (nodeId, storageInfo) => {
+        const pools = storageInfo?.StoragePools;
+        const structure: RawNodeStructure = {};
+
+        pools?.forEach((pool) => {
+            const groups = pool.Groups;
+            groups?.forEach((group) => {
+                const vDisks = group.VDisks?.filter((el) => el.NodeId === nodeId);
+                vDisks?.forEach((vd) => {
+                    const vDiskId = stringifyVdiskId(vd.VDiskId);
+                    const pDiskId = vd.PDisk?.PDiskId;
+                    if (!structure[String(pDiskId)]) {
+                        structure[String(pDiskId)] = {vDisks: {}, ...vd.PDisk};
+                    }
+                    structure[String(pDiskId)].vDisks[vDiskId] = {
+                        ...vd,
+                        // VDisk doesn't have its own StoragePoolName when located inside StoragePool data
+                        StoragePoolName: pool.Name,
+                    };
+                });
+            });
+        });
+
+        const structureWithVdisksArray = Object.keys(structure).reduce<PreparedNodeStructure>(
+            (preparedStructure, el) => {
+                const vDisks = structure[el].vDisks;
+                const vDisksArray = Object.keys(vDisks).reduce<PreparedStructureVDisk[]>(
+                    (acc, key, index) => {
+                        acc.push({...vDisks[key], id: key, order: index});
+                        return acc;
+                    },
+                    [],
+                );
+                preparedStructure[el] = {...structure[el], vDisks: vDisksArray};
+                return preparedStructure;
+            },
+            {},
+        );
+        return structureWithVdisksArray;
+    },
+);

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

@@ -0,0 +1,44 @@
+import type {IResponseError} from '../../../types/api/error';
+import type {TPDiskStateInfo} from '../../../types/api/pdisk';
+import type {TStorageInfo} from '../../../types/api/storage';
+import type {TEvSystemStateResponse} from '../../../types/api/systemState';
+import type {TVDiskStateInfo} from '../../../types/api/vdisk';
+import type {ApiRequestAction} from '../../utils';
+
+import {FETCH_NODE, FETCH_NODE_STRUCTURE, resetNode} from './node';
+
+interface RawStructurePDisk extends TPDiskStateInfo {
+    vDisks: Record<string, TVDiskStateInfo>;
+}
+
+export type RawNodeStructure = Record<string, RawStructurePDisk>;
+
+export interface PreparedStructureVDisk extends TVDiskStateInfo {
+    id: string;
+    order: number;
+}
+
+export interface PreparedStructurePDisk extends TPDiskStateInfo {
+    vDisks: PreparedStructureVDisk[];
+}
+
+export type PreparedNodeStructure = Record<string, PreparedStructurePDisk>;
+
+export interface NodeState {
+    data: TEvSystemStateResponse;
+    loading: boolean;
+    wasLoaded: boolean;
+
+    nodeStructure: TStorageInfo;
+    loadingStructure: boolean;
+    wasLoadedStructure: boolean;
+}
+
+export type NodeAction =
+    | ApiRequestAction<typeof FETCH_NODE, TEvSystemStateResponse, IResponseError>
+    | ApiRequestAction<typeof FETCH_NODE_STRUCTURE, TStorageInfo, IResponseError>
+    | ReturnType<typeof resetNode>;
+
+export interface NodeStateSlice {
+    node: NodeState;
+}

package/dist/store/reducers/overview/overview.ts

@@ -0,0 +1,109 @@
+import type {Reducer} from 'redux';
+
+import type {OverviewState, OverviewAction, OverviewHandledResponse} from './types';
+
+import '../../../services/api';
+import {createRequestActionTypes, createApiRequest} from '../../utils';
+
+export const FETCH_OVERVIEW = createRequestActionTypes('overview', 'FETCH_OVERVIEW');
+const SET_CURRENT_OVERVIEW_PATH = 'overview/SET_CURRENT_OVERVIEW_PATH';
+const SET_DATA_WAS_NOT_LOADED = 'overview/SET_DATA_WAS_NOT_LOADED';
+
+export const initialState = {
+    loading: true,
+    wasLoaded: false,
+};
+
+const schema: Reducer<OverviewState, OverviewAction> = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_OVERVIEW.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_OVERVIEW.SUCCESS: {
+            if (action.data.data.Path !== state.currentOverviewPath) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: undefined,
+                data: action.data.data,
+                additionalData: action.data.additionalData,
+                loading: false,
+                wasLoaded: true,
+            };
+        }
+        case FETCH_OVERVIEW.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_CURRENT_OVERVIEW_PATH: {
+            return {
+                ...state,
+                currentOverviewPath: action.data,
+            };
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return {
+                ...state,
+                wasLoaded: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getOverview({path}: {path: string}) {
+    const request = window.api.getDescribe({path}, {concurrentId: 'getOverview'});
+    return createApiRequest({
+        request,
+        actions: FETCH_OVERVIEW,
+        dataHandler: (data): OverviewHandledResponse => {
+            return {data};
+        },
+    });
+}
+
+export function getOverviewBatched(paths: string[]) {
+    const requestArray = paths.map((p) =>
+        window.api.getDescribe({path: p}, {concurrentId: `getOverviewBatched|${p}`}),
+    );
+    const request = Promise.all(requestArray);
+
+    return createApiRequest({
+        request,
+        actions: FETCH_OVERVIEW,
+        dataHandler: ([item, ...rest]): OverviewHandledResponse => {
+            return {
+                data: item,
+                additionalData: rest,
+            };
+        },
+    });
+}
+
+export function setDataWasNotLoaded() {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    } as const;
+}
+
+export const setCurrentOverviewPath = (path?: string) => {
+    return {
+        type: SET_CURRENT_OVERVIEW_PATH,
+        data: path,
+    } as const;
+};
+
+export default schema;

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

@@ -0,0 +1,24 @@
+import type {ApiRequestAction} from '../../utils';
+import type {IResponseError} from '../../../types/api/error';
+import type {TEvDescribeSchemeResult} from '../../../types/api/schema';
+
+import {FETCH_OVERVIEW, setDataWasNotLoaded, setCurrentOverviewPath} from './overview';
+
+export interface OverviewState {
+    loading: boolean;
+    wasLoaded: boolean;
+    currentOverviewPath?: string;
+    data?: TEvDescribeSchemeResult;
+    additionalData?: TEvDescribeSchemeResult[];
+    error?: IResponseError;
+}
+
+export interface OverviewHandledResponse {
+    data: TEvDescribeSchemeResult;
+    additionalData?: TEvDescribeSchemeResult[];
+}
+
+export type OverviewAction =
+    | ApiRequestAction<typeof FETCH_OVERVIEW, OverviewHandledResponse, IResponseError>
+    | ReturnType<typeof setCurrentOverviewPath>
+    | ReturnType<typeof setDataWasNotLoaded>;

package/dist/store/reducers/{schema.ts → schema/schema.ts}

@@ -1,18 +1,20 @@
-import {Reducer} from 'redux';
-import {createSelector, Selector} from 'reselect';
-
-import {
-    ISchemaAction,
-    ISchemaData,
-    ISchemaHandledResponse,
-    ISchemaRootStateSlice,
-    ISchemaState,
-} from '../../types/store/schema';
-import {EPathType} from '../../types/api/schema';
-import '../../services/api';
-import {isEntityWithMergedImplementation} from '../../containers/Tenant/utils/schema';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
+import type {Reducer} from 'redux';
+import type {Selector} from 'reselect';
+
+import {createSelector} from 'reselect';
+
+import type {EPathType} from '../../../types/api/schema';
+import type {
+    SchemaAction,
+    SchemaData,
+    SchemaHandledResponse,
+    SchemaStateSlice,
+    SchemaState,
+} from './types';
+
+import '../../../services/api';
+import {isEntityWithMergedImplementation} from '../../../containers/Tenant/utils/schema';
+import {createRequestActionTypes, createApiRequest} from '../../utils';
 
 export const FETCH_SCHEMA = createRequestActionTypes('schema', 'FETCH_SCHEMA');
 const PRELOAD_SCHEMAS = 'schema/PRELOAD_SCHEMAS';
@@ -31,7 +33,7 @@ export const initialState = {
     showPreview: false,
 };
 
-const schema: Reducer<ISchemaState, ISchemaAction> = (state = initialState, action) => {
+const schema: Reducer<SchemaState, SchemaAction> = (state = initialState, action) => {
     switch (action.type) {
         case FETCH_SCHEMA.REQUEST: {
             return {
@@ -87,7 +89,6 @@ const schema: Reducer<ISchemaState, ISchemaAction> = (state = initialState, acti
             return {
                 ...state,
                 currentSchemaPath: action.data,
-                wasLoaded: false,
             };
         }
         case ENABLE_AUTOREFRESH: {
@@ -124,8 +125,8 @@ export function getSchema({path}: {path: string}) {
     return createApiRequest({
         request,
         actions: FETCH_SCHEMA,
-        dataHandler: (data): ISchemaHandledResponse => {
-            const newData: ISchemaData = {};
+        dataHandler: (data): SchemaHandledResponse => {
+            const newData: SchemaData = {};
             if (data.Path) {
                 newData[data.Path] = data;
             }
@@ -138,33 +139,6 @@ export function getSchema({path}: {path: string}) {
     });
 }
 
-export function getSchemaBatched(paths: string[]) {
-    const requestArray = paths.map((p) =>
-        window.api.getSchema({path: p}, {concurrentId: `getSchemaBatched|${p}`}),
-    );
-    const request = Promise.all(requestArray);
-
-    return createApiRequest({
-        request,
-        actions: FETCH_SCHEMA,
-        dataHandler: (data): ISchemaHandledResponse => {
-            const newData: ISchemaData = {};
-
-            data.forEach((dataItem) => {
-                if (dataItem.Path) {
-                    newData[dataItem.Path] = dataItem;
-                }
-            });
-
-            return {
-                path: data[0].Path,
-                currentSchema: data[0],
-                data: newData,
-            };
-        },
-    });
-}
-
 export function setCurrentSchemaPath(currentSchemaPath: string) {
     return {
         type: SET_SCHEMA,
@@ -190,7 +164,7 @@ export function setShowPreview(value: boolean) {
 
 // only stores data for paths that are not in the store yet
 // existing paths are ignored
-export function preloadSchemas(data: ISchemaData) {
+export function preloadSchemas(data: SchemaData) {
     return {
         type: PRELOAD_SCHEMAS,
         data,
@@ -203,14 +177,14 @@ export function resetLoadingState() {
     } as const;
 }
 
-export const selectSchemaChildren = (state: ISchemaRootStateSlice, path?: string) =>
+const selectSchemaChildren = (state: SchemaStateSlice, path?: string) =>
     path ? state.schema.data[path]?.PathDescription?.Children : undefined;
 
-export const selectSchemaData = (state: ISchemaRootStateSlice, path?: string) =>
+export const selectSchemaData = (state: SchemaStateSlice, path?: string) =>
     path ? state.schema.data[path] : undefined;
 
 export const selectSchemaMergedChildrenPaths: Selector<
-    ISchemaRootStateSlice,
+    SchemaStateSlice,
     string[] | undefined,
     [string | undefined, EPathType | undefined]
 > = createSelector(

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

@@ -1,3 +1,7 @@
+import type {ApiRequestAction} from '../../utils';
+import type {IResponseError} from '../../../types/api/error';
+import type {TEvDescribeSchemeResult} from '../../../types/api/schema';
+
 import {
     disableAutorefresh,
     enableAutorefresh,
@@ -6,17 +10,14 @@ import {
     resetLoadingState,
     setCurrentSchemaPath,
     setShowPreview,
-} from '../../store/reducers/schema';
-import {ApiRequestAction} from '../../store/utils';
-import {IResponseError} from '../api/error';
-import {TEvDescribeSchemeResult} from '../api/schema';
+} from './schema';
 
-export type ISchemaData = Record<string, TEvDescribeSchemeResult>;
+export type SchemaData = Record<string, TEvDescribeSchemeResult>;
 
-export interface ISchemaState {
+export interface SchemaState {
     loading: boolean;
     wasLoaded: boolean;
-    data: ISchemaData;
+    data: SchemaData;
     currentSchema?: TEvDescribeSchemeResult;
     currentSchemaPath?: string;
     autorefresh: boolean;
@@ -24,20 +25,20 @@ export interface ISchemaState {
     error?: IResponseError;
 }
 
-export interface ISchemaHandledResponse {
+export interface SchemaHandledResponse {
     path?: string;
     currentSchema?: TEvDescribeSchemeResult;
-    data?: ISchemaData;
+    data?: SchemaData;
 }
 
-type ISchemaApiRequestAction = ApiRequestAction<
+type SchemaApiRequestAction = ApiRequestAction<
     typeof FETCH_SCHEMA,
-    ISchemaHandledResponse,
+    SchemaHandledResponse,
     IResponseError
 >;
 
-export type ISchemaAction =
-    | ISchemaApiRequestAction
+export type SchemaAction =
+    | SchemaApiRequestAction
     | (
           | ReturnType<typeof setCurrentSchemaPath>
           | ReturnType<typeof enableAutorefresh>
@@ -47,6 +48,6 @@ export type ISchemaAction =
           | ReturnType<typeof resetLoadingState>
       );
 
-export interface ISchemaRootStateSlice {
-    schema: ISchemaState;
+export interface SchemaStateSlice {
+    schema: SchemaState;
 }

package/dist/store/reducers/{schemaAcl.js → schemaAcl/schemaAcl.ts}

@@ -1,10 +1,18 @@
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import '../../services/api';
-import _ from 'lodash';
+import type {Reducer} from 'redux';
 
-const FETCH_SCHEMA_ACL = createRequestActionTypes('schemaAcl', 'FETCH_SCHEMA_ACL');
+import '../../../services/api';
+import {createRequestActionTypes, createApiRequest} from '../../utils';
 
-const schemaAcl = function z(state = {loading: false, wasLoaded: false, acl: undefined}, action) {
+import type {SchemaAclAction, SchemaAclState} from './types';
+
+export const FETCH_SCHEMA_ACL = createRequestActionTypes('schemaAcl', 'FETCH_SCHEMA_ACL');
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+const schemaAcl: Reducer<SchemaAclState, SchemaAclAction> = (state = initialState, action) => {
     switch (action.type) {
         case FETCH_SCHEMA_ACL.REQUEST: {
             return {
@@ -13,13 +21,16 @@ const schemaAcl = function z(state = {loading: false, wasLoaded: false, acl: und
             };
         }
         case FETCH_SCHEMA_ACL.SUCCESS: {
+            const acl = action.data.Common?.ACL;
+            const owner = action.data.Common?.Owner;
+
             return {
                 ...state,
-                error: undefined,
-                acl: _.get(action.data, 'Common.ACL'),
-                owner: _.get(action.data, 'Common.Owner'),
+                acl,
+                owner,
                 loading: false,
                 wasLoaded: true,
+                error: undefined,
             };
         }
         case FETCH_SCHEMA_ACL.FAILURE: {
@@ -34,7 +45,7 @@ const schemaAcl = function z(state = {loading: false, wasLoaded: false, acl: und
     }
 };
 
-export function getSchemaAcl({path}) {
+export function getSchemaAcl({path}: {path: string}) {
     return createApiRequest({
         request: window.api.getSchemaAcl({path}),
         actions: FETCH_SCHEMA_ACL,

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

@@ -0,0 +1,15 @@
+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';
+
+export interface SchemaAclState {
+    loading: boolean
+    wasLoaded: boolean
+    acl?: TACE[]
+    owner?: string
+    error?: IResponseError
+}
+
+export type SchemaAclAction = ApiRequestAction<typeof FETCH_SCHEMA_ACL, TMetaInfo, IResponseError>;

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

@@ -11,7 +11,8 @@ import {
     USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY,
     PARTITIONS_HIDDEN_COLUMNS_KEY,
     QUERY_INITIAL_MODE_KEY,
-    ENABLE_QUERY_MODES_FOR_EXPLAIN,
+    ENABLE_ADDITIONAL_QUERY_MODES,
+    CLUSTER_INFO_HIDDEN_KEY,
 } from '../../../utils/constants';
 import '../../../services/api';
 import {getValueFromLS, parseJson} from '../../../utils/utils';
@@ -52,8 +53,8 @@ export const initialState = {
             USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY,
             'false',
         ),
-        [ENABLE_QUERY_MODES_FOR_EXPLAIN]: readSavedSettingsValue(
-            ENABLE_QUERY_MODES_FOR_EXPLAIN,
+        [ENABLE_ADDITIONAL_QUERY_MODES]: readSavedSettingsValue(
+            ENABLE_ADDITIONAL_QUERY_MODES,
             'false',
         ),
         [SAVED_QUERIES_KEY]: readSavedSettingsValue(SAVED_QUERIES_KEY, '[]'),
@@ -61,6 +62,7 @@ export const initialState = {
         [QUERY_INITIAL_MODE_KEY]: readSavedSettingsValue(QUERY_INITIAL_MODE_KEY, QueryModes.script),
         [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, 'false'),
     },
     systemSettings,
 };

package/dist/types/api/acl.ts

@@ -16,7 +16,7 @@ export interface TMetaCommonInfo {
     ACL?: TACE[];
 }
 
-interface TACE {
+export interface TACE {
     AccessType: string;
     AccessRights?: string[];
     Subject: string;