ydb-embedded-ui 4.5.2 → 4.7.0

package/dist/services/api.ts

@@ -44,14 +44,22 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
     getPath(path: string) {
         return `${BACKEND}${path}`;
     }
-    getClusterInfo(clusterName?: string) {
-        return this.get<TClusterInfo>(this.getPath('/viewer/json/cluster'), {
-            name: clusterName,
-            tablets: true,
-        });
+    getClusterInfo(clusterName?: string, {concurrentId}: AxiosOptions = {}) {
+        return this.get<TClusterInfo>(
+            this.getPath('/viewer/json/cluster'),
+            {
+                name: clusterName,
+                tablets: true,
+            },
+            {concurrentId: concurrentId || `getClusterInfo`},
+        );
     }
-    getClusterNodes() {
-        return this.get<TEvSystemStateResponse>(this.getPath('/viewer/json/sysinfo'), {});
+    getClusterNodes({concurrentId}: AxiosOptions = {}) {
+        return this.get<TEvSystemStateResponse>(
+            this.getPath('/viewer/json/sysinfo'),
+            {},
+            {concurrentId: concurrentId || `getClusterNodes`},
+        );
     }
     getNodeInfo(id?: string) {
         return this.get<TEvSystemStateResponse>(this.getPath('/viewer/json/sysinfo?enums=true'), {

package/dist/store/reducers/clusterNodes/clusterNodes.tsx

@@ -34,6 +34,10 @@ const clusterNodes: Reducer<ClusterNodesState, ClusterNodesAction> = (
             };
         }
         case FETCH_CLUSTER_NODES.FAILURE: {
+            if (action.error?.isCancelled) {
+                return state;
+            }
+
             return {
                 ...state,
                 error: action.error,

package/dist/store/reducers/executeQuery.ts

@@ -186,7 +186,7 @@ export const changeUserInput = ({input}: {input: string}) => {
     } as const;
 };
 
-export const setMonacoHotKey = (value: MonacoHotKeyAction) => {
+export const setMonacoHotKey = (value: MonacoHotKeyAction | null) => {
     return {
         type: MONACO_HOT_KEY,
         data: value,

package/dist/store/reducers/header/header.ts

@@ -0,0 +1,31 @@
+import type {Reducer} from 'redux';
+
+import type {HeaderAction, HeaderState, Page, PageBreadcrumbsOptions} from './types';
+
+const SET_HEADER_BREADCRUMBS = 'header/SET_HEADER_BREADCRUMBS';
+
+const initialState = {
+    pageBreadcrumbsOptions: {},
+};
+
+const header: Reducer<HeaderState, HeaderAction> = (state = initialState, action) => {
+    switch (action.type) {
+        case SET_HEADER_BREADCRUMBS:
+            return {
+                page: action.page,
+                pageBreadcrumbsOptions: action.options,
+            };
+        default:
+            return state;
+    }
+};
+
+export function setHeaderBreadcrumbs<T extends Page>(page: T, options: PageBreadcrumbsOptions<T>) {
+    return {
+        type: SET_HEADER_BREADCRUMBS,
+        page,
+        options,
+    } as const;
+}
+
+export default header;

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

@@ -0,0 +1,54 @@
+import type {ClusterTab} from '../../../containers/Cluster/utils';
+
+import {setHeaderBreadcrumbs} from './header';
+
+export type Page = 'cluster' | 'tenant' | 'node' | 'tablets' | 'tablet' | undefined;
+
+export interface ClusterBreadcrumbsOptions {
+    clusterName?: string;
+    clusterTab?: ClusterTab;
+}
+
+export interface TenantBreadcrumbsOptions extends ClusterBreadcrumbsOptions {
+    tenantName?: string;
+}
+
+export interface NodeBreadcrumbsOptions extends TenantBreadcrumbsOptions {
+    nodeId?: string | number;
+}
+
+export interface TabletsBreadcrumbsOptions extends TenantBreadcrumbsOptions {
+    nodeIds?: string[] | number[];
+    state?: string;
+    type?: string;
+}
+
+export interface TabletBreadcrumbsOptions extends TabletsBreadcrumbsOptions {
+    tabletId?: string;
+}
+
+export type BreadcrumbsOptions =
+    | ClusterBreadcrumbsOptions
+    | TenantBreadcrumbsOptions
+    | NodeBreadcrumbsOptions
+    | TabletsBreadcrumbsOptions
+    | TabletBreadcrumbsOptions;
+
+export type PageBreadcrumbsOptions<T extends Page = undefined> = T extends 'cluster'
+    ? ClusterBreadcrumbsOptions
+    : T extends 'tenant'
+    ? TenantBreadcrumbsOptions
+    : T extends 'node'
+    ? NodeBreadcrumbsOptions
+    : T extends 'tablets'
+    ? TabletsBreadcrumbsOptions
+    : T extends 'tablet'
+    ? TabletBreadcrumbsOptions
+    : {};
+
+export interface HeaderState {
+    page?: Page;
+    pageBreadcrumbsOptions: BreadcrumbsOptions;
+}
+
+export type HeaderAction = ReturnType<typeof setHeaderBreadcrumbs>;

package/dist/store/reducers/index.ts

@@ -9,7 +9,8 @@ import node from './node/node';
 import tooltip from './tooltip';
 import tablets from './tablets';
 import heatmap from './heatmap';
-import schema from './schema';
+import schema from './schema/schema';
+import overview from './overview/overview';
 import host from './host';
 import network from './network/network';
 import tenants from './tenants/tenants';
@@ -30,7 +31,7 @@ import shardsWorkload from './shardsWorkload';
 import hotKeys from './hotKeys';
 import olapStats from './olapStats';
 import authentication from './authentication';
-import header from './header';
+import header from './header/header';
 import saveQuery from './saveQuery';
 import fullscreen from './fullscreen';
 import singleClusterMode from './singleClusterMode';
@@ -46,6 +47,7 @@ export const rootReducer = {
     tooltip,
     tablets,
     schema,
+    overview,
     olapStats,
     host,
     network,

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

@@ -28,10 +28,12 @@ export interface NodeState {
     data: TEvSystemStateResponse;
     loading: boolean;
     wasLoaded: boolean;
+    error?: IResponseError;
 
     nodeStructure: TStorageInfo;
     loadingStructure: boolean;
     wasLoadedStructure: boolean;
+    errorStructure?: IResponseError;
 }
 
 export type NodeAction =

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/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, 'true'),
     },
     systemSettings,
 };

package/dist/store/reducers/tablet.ts

@@ -16,9 +16,11 @@ import {prepareNodesMap} from '../../utils/nodes';
 export const FETCH_TABLET = createRequestActionTypes('TABLET', 'FETCH_TABLET');
 export const FETCH_TABLET_DESCRIBE = createRequestActionTypes('TABLET', 'FETCH_TABLET_DESCRIBE');
 
+const CLEAR_TABLET_DATA = 'tablet/CLEAR_TABLET_DATA';
+
 const initialState = {
     loading: false,
-    tenantPath: '-',
+    tenantPath: undefined,
 };
 
 const tablet: Reducer<ITabletState, ITabletAction> = (state = initialState, action) => {
@@ -57,6 +59,15 @@ const tablet: Reducer<ITabletState, ITabletAction> = (state = initialState, acti
                 error: undefined,
             };
         }
+        case CLEAR_TABLET_DATA: {
+            return {
+                ...state,
+                id: undefined,
+                tenantPath: undefined,
+                data: undefined,
+                history: undefined,
+            };
+        }
         default:
             return state;
     }
@@ -122,4 +133,10 @@ export const getTabletDescribe = (tenantId: TDomainKey = {}) => {
     });
 };
 
+export const clearTabletData = () => {
+    return {
+        type: CLEAR_TABLET_DATA,
+    } as const;
+};
+
 export default tablet;

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

@@ -3,6 +3,12 @@ export const TENANT_GENERAL_TABS_IDS = {
     diagnostics: 'diagnostics',
 } as const;
 
+export const TENANT_QUERY_TABS_ID = {
+    newQuery: 'newQuery',
+    history: 'history',
+    saved: 'saved',
+} as const;
+
 export const TENANT_DIAGNOSTICS_TABS_IDS = {
     overview: 'overview',
     topQueries: 'topQueries',

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

@@ -1,7 +1,13 @@
 import type {Reducer} from 'redux';
 
 import type {TTenant} from '../../../types/api/tenant';
-import type {TenantAction, TenantDiagnosticsTab, TenantGeneralTab, TenantState} from './types';
+import type {
+    TenantAction,
+    TenantDiagnosticsTab,
+    TenantGeneralTab,
+    TenantQueryTab,
+    TenantState,
+} from './types';
 
 import '../../../services/api';
 import {createRequestActionTypes, createApiRequest} from '../../utils';
@@ -9,6 +15,7 @@ import {createRequestActionTypes, createApiRequest} from '../../utils';
 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 CLEAR_TENANT = 'tenant/CLEAR_TENANT';
 
@@ -56,7 +63,12 @@ const tenantReducer: Reducer<TenantState, TenantAction> = (state = initialState,
                 topLevelTab: action.data,
             };
         }
-
+        case SET_QUERY_TAB: {
+            return {
+                ...state,
+                queryTab: action.data,
+            };
+        }
         case SET_DIAGNOSTICS_TAB: {
             return {
                 ...state,
@@ -90,6 +102,13 @@ export function setTopLevelTab(tab: TenantGeneralTab) {
     } as const;
 }
 
+export function setQueryTab(tab: TenantQueryTab) {
+    return {
+        type: SET_QUERY_TAB,
+        data: tab,
+    } as const;
+}
+
 export function setDiagnosticsTab(tab: TenantDiagnosticsTab) {
     return {
         type: SET_DIAGNOSTICS_TAB,

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

@@ -3,16 +3,22 @@ import type {TTenant} from '../../../types/api/tenant';
 import type {ValueOf} from '../../../types/common';
 import type {ApiRequestAction} from '../../utils';
 
-import {TENANT_DIAGNOSTICS_TABS_IDS, TENANT_GENERAL_TABS_IDS} from './constants';
-import {FETCH_TENANT, clearTenant, setDiagnosticsTab, setTopLevelTab} from './tenant';
+import {
+    TENANT_QUERY_TABS_ID,
+    TENANT_DIAGNOSTICS_TABS_IDS,
+    TENANT_GENERAL_TABS_IDS,
+} from './constants';
+import {FETCH_TENANT, clearTenant, setDiagnosticsTab, setQueryTab, setTopLevelTab} from './tenant';
 
 export type TenantGeneralTab = ValueOf<typeof TENANT_GENERAL_TABS_IDS>;
+export type TenantQueryTab = ValueOf<typeof TENANT_QUERY_TABS_ID>;
 export type TenantDiagnosticsTab = ValueOf<typeof TENANT_DIAGNOSTICS_TABS_IDS>;
 
 export interface TenantState {
     loading: boolean;
     wasLoaded: boolean;
     topLevelTab?: TenantGeneralTab;
+    queryTab?: TenantQueryTab;
     diagnosticsTab?: TenantDiagnosticsTab;
     tenant?: TTenant;
     error?: IResponseError;
@@ -22,4 +28,5 @@ export type TenantAction =
     | ApiRequestAction<typeof FETCH_TENANT, TTenant | undefined, IResponseError>
     | ReturnType<typeof clearTenant>
     | ReturnType<typeof setTopLevelTab>
+    | ReturnType<typeof setQueryTab>
     | ReturnType<typeof setDiagnosticsTab>;

package/dist/store/reducers/topic.ts

@@ -35,7 +35,7 @@ const topic: Reducer<ITopicState, ITopicAction> = (state = initialState, action)
             };
         }
         case FETCH_TOPIC.SUCCESS: {
-            // On older version it can return HTML page of Internal Viewer with an error
+            // On older version it can return HTML page of Developer UI with an error
             if (typeof action.data !== 'object') {
                 return {...state, loading: false, error: {}};
             }