ydb-embedded-ui 4.33.0 → 5.1.0

package/dist/store/reducers/topic.d.ts

@@ -0,0 +1,20 @@
+import type { Reducer } from 'redux';
+import { Selector } from 'reselect';
+import type { IPreparedConsumerData, IPreparedTopicStats, ITopicAction, ITopicRootStateSlice, ITopicState } from '../../types/store/topic';
+export declare const FETCH_TOPIC: {
+    readonly REQUEST: "topic/FETCH_TOPIC_REQUEST";
+    readonly SUCCESS: "topic/FETCH_TOPIC_SUCCESS";
+    readonly FAILURE: "topic/FETCH_TOPIC_FAILURE";
+};
+declare const topic: Reducer<ITopicState, ITopicAction>;
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "topic/SET_DATA_WAS_NOT_LOADED";
+};
+export declare const cleanTopicData: () => {
+    readonly type: "topic/CLEAN_TOPIC_DATA";
+};
+export declare function getTopic(path?: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<unknown>;
+export declare const selectConsumersNames: Selector<ITopicRootStateSlice, string[] | undefined>;
+export declare const selectPreparedTopicStats: Selector<ITopicRootStateSlice, IPreparedTopicStats | undefined>;
+export declare const selectPreparedConsumersData: Selector<ITopicRootStateSlice, IPreparedConsumerData[] | undefined>;
+export default topic;

package/dist/store/reducers/topic.js

@@ -0,0 +1,88 @@
+import { createSelector } from 'reselect';
+import { createRequestActionTypes, createApiRequest } from '../utils';
+import { parseLag, parseTimestampToIdleTime } from '../../utils/timeParsers';
+import { convertBytesObjectToSpeed } from '../../utils/bytesParsers';
+export const FETCH_TOPIC = createRequestActionTypes('topic', 'FETCH_TOPIC');
+const SET_DATA_WAS_NOT_LOADED = 'topic/SET_DATA_WAS_NOT_LOADED';
+const CLEAN_TOPIC_DATA = 'topic/CLEAN_TOPIC_DATA';
+const initialState = {
+    loading: true,
+    wasLoaded: false,
+    data: undefined,
+};
+const topic = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_TOPIC.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_TOPIC.SUCCESS: {
+            // On older version it can return HTML page of Developer UI with an error
+            if (typeof action.data !== 'object') {
+                return Object.assign(Object.assign({}, state), { loading: false, error: {} });
+            }
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_TOPIC.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        case CLEAN_TOPIC_DATA: {
+            return Object.assign(Object.assign({}, state), { data: undefined });
+        }
+        default:
+            return state;
+    }
+};
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export const cleanTopicData = () => {
+    return {
+        type: CLEAN_TOPIC_DATA,
+    };
+};
+export function getTopic(path) {
+    return createApiRequest({
+        request: window.api.getTopic({ path }),
+        actions: FETCH_TOPIC,
+    });
+}
+const selectTopicStats = (state) => { var _a; return (_a = state.topic.data) === null || _a === void 0 ? void 0 : _a.topic_stats; };
+const selectConsumers = (state) => { var _a; return (_a = state.topic.data) === null || _a === void 0 ? void 0 : _a.consumers; };
+export const selectConsumersNames = createSelector([selectConsumers], (consumers) => {
+    return consumers === null || consumers === void 0 ? void 0 : consumers.map((consumer) => consumer === null || consumer === void 0 ? void 0 : consumer.name).filter((consumer) => consumer !== undefined);
+});
+export const selectPreparedTopicStats = createSelector([selectTopicStats], (rawTopicStats) => {
+    if (!rawTopicStats) {
+        return undefined;
+    }
+    const { store_size_bytes = '0', min_last_write_time, max_write_time_lag, bytes_written, } = rawTopicStats || {};
+    return {
+        storeSize: store_size_bytes,
+        partitionsIdleTime: parseTimestampToIdleTime(min_last_write_time),
+        partitionsWriteLag: parseLag(max_write_time_lag),
+        writeSpeed: convertBytesObjectToSpeed(bytes_written),
+    };
+});
+export const selectPreparedConsumersData = createSelector([selectConsumers], (consumers) => {
+    return consumers === null || consumers === void 0 ? void 0 : consumers.map((consumer) => {
+        const { name, consumer_stats } = consumer || {};
+        const { min_partitions_last_read_time, max_read_time_lag, max_write_time_lag, bytes_read } = consumer_stats || {};
+        return {
+            name,
+            readSpeed: convertBytesObjectToSpeed(bytes_read),
+            writeLag: parseLag(max_write_time_lag),
+            readLag: parseLag(max_read_time_lag),
+            readIdleTime: parseTimestampToIdleTime(min_partitions_last_read_time),
+        };
+    });
+});
+export default topic;

package/dist/store/state-url-mapping.d.ts

@@ -0,0 +1,4 @@
+export default function getLocationMiddleware(history: any, rootReducer: any): {
+    locationMiddleware: any;
+    reducersWithLocation: (state: any, action: any) => any;
+};

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

@@ -1,14 +1,23 @@
-import {createReduxLocationActions} from 'redux-location-state';
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { createReduxLocationActions } from 'redux-location-state';
 import qs from 'qs';
 import _ from 'lodash';
-import {stateToParams} from 'redux-location-state/lib/stateToParams';
-import {parseQuery} from 'redux-location-state/lib/parseQuery';
-import {LOCATION_PUSH, LOCATION_POP} from 'redux-location-state/lib/constants';
-import {getMatchingDeclaredPath} from 'redux-location-state/lib/helpers';
-
-import {initialState as initialSettingsState} from './reducers/settings/settings';
-import {initialState as initialHeatmapState} from './reducers/heatmap';
-
+import { stateToParams } from 'redux-location-state/lib/stateToParams';
+import { parseQuery } from 'redux-location-state/lib/parseQuery';
+import { LOCATION_PUSH, LOCATION_POP } from 'redux-location-state/lib/constants';
+import { getMatchingDeclaredPath } from 'redux-location-state/lib/helpers';
+import { initialState as initialSettingsState } from './reducers/settings/settings';
+import { initialState as initialHeatmapState } from './reducers/heatmap';
 const paramSetup = {
     global: {
         problemFilter: {
@@ -81,19 +90,15 @@ const paramSetup = {
         },
     },
 };
-
 function mergeLocationToState(state, location) {
     return _.merge({}, state, location.query);
 }
-
 function restoreUnknownParams(location, prevLocation) {
-    const {search, ...rest} = location;
+    const { search } = location, rest = __rest(location, ["search"]);
     const params = qs.parse(prevLocation.search.slice(1));
-
     // figure out which path key inside paramSetup matches location.pathname
     const declaredPath = getMatchingDeclaredPath(paramSetup, location);
     const entries = declaredPath && paramSetup[declaredPath];
-
     // remove params which are mapped for this page
     _.each(_.keys(entries), (param) => {
         delete params[param];
@@ -102,38 +107,31 @@ function restoreUnknownParams(location, prevLocation) {
     _.each(_.keys(paramSetup.global || {}), (param) => {
         delete params[param];
     });
-
-    const restoredParams = qs.stringify(params, {encoder: encodeURIComponent});
+    const restoredParams = qs.stringify(params, { encoder: encodeURIComponent });
     const searchDelimiter = search.startsWith('?') ? '&' : '?';
-
-    return {search: `${search}${searchDelimiter}${restoredParams}`, ...rest};
+    return Object.assign({ search: `${search}${searchDelimiter}${restoredParams}` }, rest);
 }
-
 let prevSearchStringFromState = '';
-
 // Keep intact params that are not present in paramSetup
 function overwriteLocationHandling(setupObject, nextState, prevLocation) {
     const nextLocation = stateToParams(setupObject, nextState, prevLocation);
-    let {location} = nextLocation;
-
+    let { location } = nextLocation;
     if (location.search !== prevSearchStringFromState) {
         const searchRe = /\?\w+/;
         prevSearchStringFromState = location.search;
-
         if (searchRe.test(prevLocation.search)) {
             location = restoreUnknownParams(location, prevLocation);
         }
-
-        return {...nextLocation, location};
-    } else {
+        return Object.assign(Object.assign({}, nextLocation), { location });
+    }
+    else {
         // nothing to do here, state parts represented in query params didn't change
-        return {location: prevLocation, shouldPush: false};
+        return { location: prevLocation, shouldPush: false };
     }
 }
-
 function makeReducersWithLocation(setupObject, mapLocationToState, rootReducer) {
     const locationReducer = (state, action) => {
-        const {type, payload} = action;
+        const { type, payload } = action;
         if (!payload) {
             return state;
         }
@@ -143,28 +141,15 @@ function makeReducersWithLocation(setupObject, mapLocationToState, rootReducer)
         }
         return state;
     };
-
     return (state, action) => {
         const postReducerState = rootReducer(state, action);
         const postLocationState = locationReducer(postReducerState, action);
         const hasChanged = postLocationState !== state;
-
         return hasChanged ? postLocationState : state;
     };
 }
-
 export default function getLocationMiddleware(history, rootReducer) {
-    const {locationMiddleware} = createReduxLocationActions(
-        paramSetup,
-        mergeLocationToState,
-        history,
-        rootReducer,
-        overwriteLocationHandling,
-    );
-    const reducersWithLocation = makeReducersWithLocation(
-        paramSetup,
-        mergeLocationToState,
-        rootReducer,
-    );
-    return {locationMiddleware, reducersWithLocation};
+    const { locationMiddleware } = createReduxLocationActions(paramSetup, mergeLocationToState, history, rootReducer, overwriteLocationHandling);
+    const reducersWithLocation = makeReducersWithLocation(paramSetup, mergeLocationToState, rootReducer);
+    return { locationMiddleware, reducersWithLocation };
 }

package/dist/store/utils.d.ts

@@ -0,0 +1,24 @@
+import type { Dispatch } from 'redux';
+import type { GetState } from './reducers';
+export declare const nop: (result: any) => any;
+export declare function createRequestActionTypes<Prefix extends string, Type extends string>(prefix: Prefix, type: Type): {
+    readonly REQUEST: `${Prefix}/${Type}_REQUEST`;
+    readonly SUCCESS: `${Prefix}/${Type}_SUCCESS`;
+    readonly FAILURE: `${Prefix}/${Type}_FAILURE`;
+};
+declare type CreateApiRequestParams<Actions, Response, HandledResponse> = {
+    actions: Actions;
+    request: Promise<Response>;
+    dataHandler?: (data: Response, getState: GetState) => HandledResponse;
+};
+export declare function createApiRequest<Actions extends ReturnType<typeof createRequestActionTypes>, Response, HandledResponse>({ actions, request, dataHandler, }: CreateApiRequestParams<Actions, Response, HandledResponse>): (dispatch: Dispatch, getState: GetState) => Promise<HandledResponse | undefined>;
+export declare type ApiRequestAction<Actions extends ReturnType<typeof createRequestActionTypes>, SuccessResponse = unknown, ErrorResponse = unknown> = {
+    type: Actions['REQUEST'];
+} | {
+    type: Actions['SUCCESS'];
+    data: SuccessResponse;
+} | {
+    type: Actions['FAILURE'];
+    error: ErrorResponse;
+};
+export {};

package/dist/store/utils.js

@@ -0,0 +1,49 @@
+import createToast from '../utils/createToast';
+import { SET_UNAUTHENTICATED } from './reducers/authentication/authentication';
+export const nop = (result) => result;
+export function createRequestActionTypes(prefix, type) {
+    return {
+        REQUEST: `${prefix}/${type}_REQUEST`,
+        SUCCESS: `${prefix}/${type}_SUCCESS`,
+        FAILURE: `${prefix}/${type}_FAILURE`,
+    };
+}
+const isAxiosResponse = (response) => response && 'status' in response;
+export function createApiRequest({ actions, request, dataHandler = nop, }) {
+    const doRequest = async function (dispatch, getState) {
+        dispatch({
+            type: actions.REQUEST,
+        });
+        try {
+            const result = await request;
+            const data = dataHandler(result, getState);
+            dispatch({
+                type: actions.SUCCESS,
+                data,
+            });
+            return data;
+        }
+        catch (error) {
+            if (isAxiosResponse(error) && error.status === 401) {
+                dispatch({
+                    type: SET_UNAUTHENTICATED.SUCCESS,
+                });
+            }
+            else if (isAxiosResponse(error) && error.status >= 500 && error.statusText) {
+                createToast({
+                    name: 'Request failure',
+                    title: 'Request failure',
+                    type: 'error',
+                    content: `${error.status} ${error.statusText}`,
+                });
+            }
+            dispatch({
+                type: actions.FAILURE,
+                error,
+            });
+            // TODO should probably throw the received error here, but this change requires a thorough revision of all api calls
+            return undefined;
+        }
+    };
+    return doRequest;
+}

package/dist/types/additionalProps.d.ts

@@ -0,0 +1,25 @@
+import type { ReactNode } from 'react';
+import type { InfoViewerItem } from '../components/InfoViewer';
+import type { ETenantType } from './api/tenant';
+import type { TSystemStateInfo } from './api/nodes';
+import type { VersionToColorMap } from './versions';
+export interface AdditionalVersionsProps {
+    getVersionToColorMap?: () => VersionToColorMap;
+}
+export interface ClusterLink {
+    title: string;
+    url: string;
+}
+export interface AdditionalClusterProps {
+    info?: InfoViewerItem[];
+    links?: ClusterLink[];
+}
+export interface AdditionalTenantsProps {
+    prepareTenantBackend?: (backend: string | undefined) => string | undefined;
+    getMonitoringLink?: (name?: string, type?: ETenantType) => ReactNode;
+}
+export declare type NodeAddress = Pick<TSystemStateInfo, 'Host' | 'Endpoints' | 'NodeId'>;
+export declare type GetNodeRefFunc = (node?: NodeAddress) => string | null;
+export interface AdditionalNodesProps extends Record<string, unknown> {
+    getNodeRef?: GetNodeRefFunc;
+}

package/dist/types/additionalProps.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/acl.d.ts

@@ -0,0 +1,23 @@
+/**
+ * endpoint: /viewer/json/acl
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ *
+ * incomplete, only fields that present for ACL requests
+ */
+export interface TMetaInfo {
+    Common: TMetaCommonInfo;
+}
+/** incomplete */
+export interface TMetaCommonInfo {
+    Path: string;
+    Owner?: string;
+    ACL?: TACE[];
+}
+export interface TACE {
+    AccessType: string;
+    AccessRights?: string[];
+    Subject: string;
+    InheritanceType?: string[];
+    AccessRule: string;
+}

package/dist/types/api/acl.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/cluster.d.ts

@@ -0,0 +1,37 @@
+import type { EFlag } from './enums';
+import type { TTabletStateInfo } from './tablet';
+/**
+ * endpoint: viewer/json/cluster
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ */
+export interface TClusterInfo {
+    Name?: string;
+    Overall?: EFlag;
+    NodesTotal?: number;
+    NodesAlive?: number;
+    NumberOfCpus?: number;
+    /** double */
+    LoadAverage?: number;
+    /** uint64 */
+    MemoryTotal?: string;
+    /** uint64 */
+    MemoryUsed?: string;
+    /** uint64 */
+    StorageTotal?: string;
+    /** uint64 */
+    StorageUsed?: string;
+    DataCenters?: string[];
+    Versions?: string[];
+    SystemTablets?: TTabletStateInfo[];
+    /** uint64 */
+    Hosts?: string;
+    /** uint64 */
+    Tenants?: string;
+    /** uint64 */
+    Tablets?: string;
+    /** Cluster root database */
+    Domain?: string;
+    Balancer?: string;
+    Solomon?: string;
+}

package/dist/types/api/cluster.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/common.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/compute.d.ts

@@ -0,0 +1,60 @@
+import { EFlag } from './enums';
+import { TEndpoint, TLegacyNodeLocation, TPoolStats } from './nodes';
+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[];
+    Errors?: string[];
+    /** uint64 */
+    TotalNodes: string;
+    /** uint64 */
+    FoundNodes: string;
+    Nodes?: TComputeNodeInfo[];
+}
+export interface TComputeTenantInfo {
+    Overall: EFlag;
+    Name: string;
+    Nodes?: TComputeNodeInfo[];
+}
+export interface TComputeNodeInfo {
+    /** uint64 */
+    StartTime: string;
+    /** uint64 */
+    ChangeTime: string;
+    SystemLocation: TLegacyNodeLocation;
+    /** double */
+    LoadAverage: number[];
+    NumberOfCpus: number;
+    Overall: EFlag;
+    NodeId: number;
+    DataCenter: string;
+    Rack: string;
+    Host: string;
+    Version: string;
+    PoolStats?: TPoolStats[];
+    Endpoints?: TEndpoint[];
+    Roles?: string[];
+    /** uint64 */
+    MemoryUsed?: string;
+    /** uint64 */
+    MemoryLimit?: string;
+    Metrics: TMetrics;
+    Tablets?: TTabletStateInfo[];
+    Tenant?: string;
+}
+export interface TTabletStateInfo {
+    Type: string;
+    State: EFlag;
+    Count: number;
+}
+export declare enum EVersion {
+    v1 = "v1",
+    v2 = "v2"
+}

package/dist/types/api/compute.js

@@ -0,0 +1,5 @@
+export var EVersion;
+(function (EVersion) {
+    EVersion["v1"] = "v1";
+    EVersion["v2"] = "v2";
+})(EVersion || (EVersion = {}));