ydb-embedded-ui 4.0.0 → 4.1.0

package/dist/services/api.ts

@@ -0,0 +1,383 @@
+import AxiosWrapper from '@gravity-ui/axios-wrapper';
+
+import type {
+    Actions,
+    ExplainActions,
+    ExplainResponse,
+    QueryAPIResponse,
+    Schemas,
+} from '../types/api/query';
+import type {
+    TDomainKey,
+    TEvTabletStateResponse,
+    UnmergedTEvTabletStateResponse,
+} from '../types/api/tablet';
+import type {TMetaInfo} from '../types/api/acl';
+import type {TClusterInfo} from '../types/api/cluster';
+import type {TComputeInfo} from '../types/api/compute';
+import type {DescribeConsumerResult} from '../types/api/consumer';
+import type {HealthCheckAPIResponse} from '../types/api/healthcheck';
+import type {TNetInfo} from '../types/api/netInfo';
+import type {TNodesInfo} from '../types/api/nodes';
+import type {TEvNodesInfo} from '../types/api/nodesList';
+import type {TEvDescribeSchemeResult} from '../types/api/schema';
+import type {TStorageInfo} from '../types/api/storage';
+import type {TEvSystemStateResponse} from '../types/api/systemState';
+import type {TTenantInfo, TTenants} from '../types/api/tenant';
+import type {DescribeTopicResult} from '../types/api/topic';
+import type {TEvPDiskStateResponse} from '../types/api/pdisk';
+import type {TEvVDiskStateResponse} from '../types/api/vdisk';
+import type {TUserToken} from '../types/api/whoami';
+import type {INodesApiRequestParams} from '../types/store/nodes';
+
+import {backend as BACKEND} from '../store';
+
+const config = {withCredentials: !window.custom_backend};
+
+const settingsApi = window.web_version ? window.systemSettings?.settingsApi : undefined;
+
+type AxiosOptions = {
+    concurrentId?: string;
+};
+
+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,
+        });
+    }
+    getNodeInfo(id?: string) {
+        return this.get<TEvSystemStateResponse>(this.getPath('/viewer/json/sysinfo?enums=true'), {
+            node_id: id,
+        });
+    }
+    getTenants(clusterName?: string) {
+        return this.get<TTenantInfo>(this.getPath('/viewer/json/tenantinfo'), {
+            tablets: 1,
+            storage: 1,
+            cluster_name: clusterName,
+        });
+    }
+    getTenantInfo({path}: {path: string}) {
+        return this.get<TTenantInfo>(this.getPath('/viewer/json/tenantinfo'), {
+            path,
+            tablets: true,
+            storage: true,
+        });
+    }
+    getNodes(
+        {tenant, filter, storage, type = 'any', tablets = true}: INodesApiRequestParams,
+        {concurrentId}: AxiosOptions = {},
+    ) {
+        return this.get<TNodesInfo>(
+            this.getPath('/viewer/json/nodes?enums=true'),
+            {
+                tenant,
+                with: filter,
+                storage,
+                type,
+                tablets,
+            },
+            {
+                concurrentId,
+            },
+        );
+    }
+    getCompute(path: string) {
+        return this.get<TComputeInfo>(this.getPath('/viewer/json/compute?enums=true'), {path});
+    }
+    getStorageInfo(
+        {
+            tenant,
+            filter,
+            nodeId,
+        }: {
+            tenant: string;
+            filter: string;
+            nodeId: string;
+        },
+        {concurrentId}: AxiosOptions = {},
+    ) {
+        return this.get<TStorageInfo>(
+            this.getPath(`/viewer/json/storage?enums=true`),
+            {
+                tenant,
+                node_id: nodeId,
+                with: filter,
+            },
+            {
+                concurrentId,
+            },
+        );
+    }
+    getPdiskInfo(nodeId: string | number, pdiskId: string | number) {
+        return this.get<TEvPDiskStateResponse>(this.getPath('/viewer/json/pdiskinfo?enums=true'), {
+            filter: `(NodeId=${nodeId}${pdiskId ? `;PDiskId=${pdiskId}` : ''})`,
+        });
+    }
+    getVdiskInfo({
+        vdiskId,
+        pdiskId,
+        nodeId,
+    }: {
+        vdiskId: string | number;
+        pdiskId: string | number;
+        nodeId: string | number;
+    }) {
+        return this.get<TEvVDiskStateResponse>(this.getPath('/viewer/json/vdiskinfo?enums=true'), {
+            filter: `(VDiskId=${vdiskId ?? ''};PDiskId=${pdiskId ?? ''};NodeId=${nodeId ?? ''})`,
+        });
+    }
+    getGroupInfo(groupId: string | number) {
+        return this.get<TStorageInfo>(this.getPath('/viewer/json/storage?enums=true'), {
+            group_id: groupId,
+        });
+    }
+    getHostInfo() {
+        return this.get<TEvSystemStateResponse>(
+            this.getPath('/viewer/json/sysinfo?node_id=.&enums=true'),
+            {},
+        );
+    }
+    getTabletsInfo({nodes = [], path}: {nodes?: string[]; path?: string}) {
+        const filter = nodes.length > 0 && `(NodeId=[${nodes.join(',')}])`;
+        return this.get<TEvTabletStateResponse>(this.getPath('/viewer/json/tabletinfo'), {
+            filter,
+            path,
+            enums: true,
+        });
+    }
+    getSchema({path}: {path: string}, {concurrentId}: AxiosOptions = {}) {
+        return this.get<TEvDescribeSchemeResult>(
+            this.getPath('/viewer/json/describe'),
+            {
+                path,
+                enums: true,
+                backup: false,
+                private: true,
+                partition_config: true,
+                partition_stats: true,
+                partitioning_info: true,
+                subs: 1,
+            },
+            {concurrentId: concurrentId || `getSchema|${path}`},
+        );
+    }
+    getDescribe({path}: {path: string}, {concurrentId}: AxiosOptions = {}) {
+        return this.get<TEvDescribeSchemeResult>(
+            this.getPath('/viewer/json/describe'),
+            {
+                path,
+                enums: true,
+                partition_stats: true,
+                subs: 0,
+            },
+            {concurrentId: concurrentId || `getDescribe|${path}`},
+        );
+    }
+    getSchemaAcl({path}: {path: string}) {
+        return this.get<TMetaInfo>(
+            this.getPath('/viewer/json/acl'),
+            {
+                path,
+            },
+            {concurrentId: `getSchemaAcl|${path}`},
+        );
+    }
+    getHeatmapData({path}: {path: string}) {
+        return this.get<TEvDescribeSchemeResult>(this.getPath('/viewer/json/describe'), {
+            path,
+            enums: true,
+            backup: false,
+            children: false,
+            partition_config: false,
+            partition_stats: true,
+        });
+    }
+    getNetwork(path: string) {
+        return this.get<TNetInfo>(this.getPath('/viewer/json/netinfo'), {
+            enums: true,
+            path,
+        });
+    }
+    getTopic({path}: {path?: string}, {concurrentId}: AxiosOptions = {}) {
+        return this.get<DescribeTopicResult>(
+            this.getPath('/viewer/json/describe_topic'),
+            {
+                enums: true,
+                include_stats: true,
+                path,
+            },
+            {concurrentId: concurrentId || 'getTopic'},
+        );
+    }
+    getConsumer(
+        {path, consumer}: {path?: string; consumer?: string},
+        {concurrentId}: AxiosOptions = {},
+    ) {
+        return this.get<DescribeConsumerResult>(
+            this.getPath('/viewer/json/describe_consumer'),
+            {
+                enums: true,
+                include_stats: true,
+                path,
+                consumer,
+            },
+            {concurrentId: concurrentId || 'getConsumer'},
+        );
+    }
+    getPoolInfo(poolName: string) {
+        return this.get<TStorageInfo>(this.getPath('/viewer/json/storage'), {
+            pool: poolName,
+            enums: true,
+        });
+    }
+    getTablet({id}: {id?: string}) {
+        return this.get<TEvTabletStateResponse>(
+            this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`),
+            {
+                enums: true,
+            },
+        );
+    }
+    getTabletHistory({id}: {id?: string}) {
+        return this.get<UnmergedTEvTabletStateResponse>(
+            this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`),
+            {
+                enums: true,
+                merge: false,
+            },
+        );
+    }
+    getNodesList() {
+        return this.get<TEvNodesInfo>(this.getPath('/viewer/json/nodelist'), {enums: true});
+    }
+    getTenantsList() {
+        return this.get<TTenants>(this.getPath('/viewer/json/tenants'), {
+            enums: true,
+            state: 0,
+        });
+    }
+    sendQuery<Action extends Actions, Schema extends Schemas = undefined>(
+        {
+            query,
+            database,
+            action,
+            stats,
+            schema,
+        }: {
+            query?: string;
+            database?: string;
+            action?: Action;
+            stats?: string;
+            schema?: Schema;
+        },
+        {concurrentId}: AxiosOptions = {},
+    ) {
+        return this.post<QueryAPIResponse<Action, Schema>>(
+            this.getPath(`/viewer/json/query${schema ? `?schema=${schema}` : ''}`),
+            {
+                query,
+                database,
+                action,
+                stats,
+                timeout: 600000,
+            },
+            null,
+            {
+                concurrentId,
+                timeout: 9 * 60 * 1000,
+            },
+        );
+    }
+    getExplainQuery<Action extends ExplainActions>(
+        query: string,
+        database: string,
+        action: Action,
+    ) {
+        return this.post<ExplainResponse<Action>>(
+            this.getPath('/viewer/json/query'),
+            {
+                query,
+                database,
+                action: action || 'explain',
+                timeout: 600000,
+            },
+            null,
+        );
+    }
+    getExplainQueryAst(query: string, database: string) {
+        return this.post<ExplainResponse<'explain-ast'>>(
+            this.getPath('/viewer/json/query'),
+            {
+                query,
+                database,
+                action: 'explain-ast',
+                timeout: 600000,
+            },
+            null,
+        );
+    }
+    getHotKeys(path: string, enableSampling: boolean) {
+        return this.get(this.getPath('/viewer/json/hotkeys'), {
+            path,
+            enable_sampling: enableSampling,
+        });
+    }
+    getHealthcheckInfo(database: string) {
+        return this.get<HealthCheckAPIResponse>(this.getPath('/viewer/json/healthcheck'), {
+            tenant: database,
+        });
+    }
+    killTablet(id?: string) {
+        return this.get<string>(this.getPath(`/tablets?KillTabletID=${id}`), null);
+    }
+    stopTablet(id?: string, hiveId?: string) {
+        return this.get<string>(
+            this.getPath(`/tablets/app?TabletID=${hiveId}&page=StopTablet&tablet=${id}`),
+            null,
+        );
+    }
+    resumeTablet(id?: string, hiveId?: string) {
+        return this.get<string>(
+            this.getPath(`/tablets/app?TabletID=${hiveId}&page=ResumeTablet&tablet=${id}`),
+            null,
+        );
+    }
+    getTabletDescribe(tenantId: TDomainKey) {
+        return this.get<TEvDescribeSchemeResult>(this.getPath('/viewer/json/describe'), {
+            schemeshard_id: tenantId?.SchemeShard,
+            path_id: tenantId?.PathId,
+        });
+    }
+    postSetting(name: string, value: string) {
+        return this.request({
+            method: 'PATCH',
+            url: settingsApi || '',
+            data: {[name]: value},
+        });
+    }
+    authenticate(user: string, password: string) {
+        return this.post(
+            this.getPath('/login'),
+            {
+                user,
+                password,
+            },
+            null,
+        );
+    }
+    logout() {
+        return this.post(this.getPath('/logout'), null, null);
+    }
+    whoami() {
+        return this.get<TUserToken>(this.getPath('/viewer/json/whoami'), null);
+    }
+}
+
+const api = new YdbEmbeddedAPI({config: config});
+window.api = api;

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

@@ -1,11 +1,14 @@
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import '../../services/api';
+import type {Reducer} from 'redux';
 
-const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
+import '../../../services/api';
+import {createRequestActionTypes, createApiRequest} from '../../utils';
+import type {ClusterAction, ClusterState} from './types';
+
+export const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
 
 const initialState = {loading: true, wasLoaded: false};
 
-const cluster = function (state = initialState, action) {
+const cluster: Reducer<ClusterState, ClusterAction> = (state = initialState, action) => {
     switch (action.type) {
         case FETCH_CLUSTER.REQUEST: {
             return {
@@ -14,17 +17,9 @@ const cluster = function (state = initialState, action) {
             };
         }
         case FETCH_CLUSTER.SUCCESS: {
-            const {data} = action;
-            const clusterInfo = data.cluster ? data.cluster.cluster : data;
-            const clusterName = data.cluster?.title || data.Name;
             return {
                 ...state,
-                data: {
-                    ...clusterInfo,
-                    balancer: data.cluster?.balancer,
-                    solomon: data.cluster?.solomon,
-                    Name: clusterName,
-                },
+                data: action.data,
                 loading: false,
                 wasLoaded: true,
                 error: undefined,
@@ -42,7 +37,7 @@ const cluster = function (state = initialState, action) {
     }
 };
 
-export function getClusterInfo(clusterName) {
+export function getClusterInfo(clusterName?: string) {
     return createApiRequest({
         request: window.api.getClusterInfo(clusterName),
         actions: FETCH_CLUSTER,

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

@@ -0,0 +1,13 @@
+import {FETCH_CLUSTER} from './cluster';
+
+import type {TClusterInfo} from '../../../types/api/cluster';
+import type {ApiRequestAction} from '../../utils';
+
+export interface ClusterState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: TClusterInfo;
+    error?: unknown;
+}
+
+export type ClusterAction = ApiRequestAction<typeof FETCH_CLUSTER, TClusterInfo, unknown>;

package/dist/store/reducers/executeTopQueries.ts

@@ -13,7 +13,7 @@ import {parseQueryAPIExecuteResponse} from '../../utils/query';
 
 import {createRequestActionTypes, createApiRequest} from '../utils';
 
-import type {IRootState} from '.';
+import type {RootState} from '.';
 
 export const FETCH_TOP_QUERIES = createRequestActionTypes('top-queries', 'FETCH_TOP_QUERIES');
 const SET_TOP_QUERIES_STATE = 'top-queries/SET_TOP_QUERIES_STATE';
@@ -126,7 +126,7 @@ const executeTopQueries: Reducer<ITopQueriesState, ITopQueriesAction> = (
 type FetchTopQueries = (params: {
     database: string;
     filters?: ITopQueriesFilters;
-}) => ThunkAction<Promise<IQueryResult | undefined>, IRootState, unknown, AnyAction>;
+}) => ThunkAction<Promise<IQueryResult | undefined>, RootState, unknown, AnyAction>;
 
 export const fetchTopQueries: FetchTopQueries =
     ({database, filters}) =>

package/dist/store/reducers/index.ts

@@ -1,7 +1,7 @@
 import {combineReducers} from 'redux';
 
 import nodes from './nodes';
-import cluster from './cluster';
+import cluster from './cluster/cluster';
 import tenant from './tenant';
 import storage from './storage';
 import node from './node';
@@ -15,7 +15,7 @@ import schema from './schema';
 import host from './host';
 import network from './network';
 import pool from './pool';
-import tenants from './tenants';
+import tenants from './tenants/tenants';
 import tablet from './tablet';
 import topic from './topic';
 import consumer from './consumer';
@@ -82,7 +82,8 @@ const combinedReducer = combineReducers({
     ...rootReducer,
 });
 
-export type IRootReducer = typeof combinedReducer;
-export type IRootState = ReturnType<IRootReducer>;
+export type RootReducer = typeof combinedReducer;
+export type RootState = ReturnType<RootReducer>;
+export type GetState = () => RootState;
 
 export default combinedReducer;

package/dist/store/reducers/settings.js

@@ -26,16 +26,6 @@ export function readSavedSettingsValue(key, defaultValue) {
     return savedValue ?? defaultValue;
 }
 
-// navigation managed its compact state internally before, and its approach is not compatible with settings
-// try reading the old localStorage entry to use it as a default value, for backward compatibility
-// assume it is safe to remove this code block if it is at least a few months old
-// there a two of these, search for a similar comment
-let legacyAsideNavCompactState = '';
-try {
-    legacyAsideNavCompactState = String(JSON.parse(getValueFromLS('nvAsideHeader')).isCompact);
-    localStorage.removeItem('nvAsideHeader');
-} catch {}
-
 export const initialState = {
     problemFilter: ALL,
     userSettings: {
@@ -53,10 +43,7 @@ export const initialState = {
         [SAVED_QUERIES_KEY]: readSavedSettingsValue(SAVED_QUERIES_KEY, '[]'),
         [TENANT_INITIAL_TAB_KEY]: readSavedSettingsValue(TENANT_INITIAL_TAB_KEY),
         [QUERY_INITIAL_MODE_KEY]: readSavedSettingsValue(QUERY_INITIAL_MODE_KEY, QueryModes.script),
-        [ASIDE_HEADER_COMPACT_KEY]: readSavedSettingsValue(
-            ASIDE_HEADER_COMPACT_KEY,
-            legacyAsideNavCompactState || 'true',
-        ),
+        [ASIDE_HEADER_COMPACT_KEY]: readSavedSettingsValue(ASIDE_HEADER_COMPACT_KEY, 'true'),
         [PARTITIONS_SELECTED_COLUMNS_KEY]: readSavedSettingsValue(PARTITIONS_SELECTED_COLUMNS_KEY),
     },
     systemSettings,

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

@@ -1,12 +1,15 @@
-import _ from 'lodash';
-import {createRequestActionTypes, createApiRequest} from '../utils';
-import '../../services/api';
+import type {Reducer} from 'redux';
 
-const FETCH_TENANTS = createRequestActionTypes('tenants', 'FETCH_TENANTS');
+import '../../../services/api';
+import {createRequestActionTypes, createApiRequest} from '../../utils';
 
-const initialState = {loading: true, wasLoaded: false, data: {}};
+import type {TenantsAction, TenantsState} from './types';
 
-const tenants = function (state = initialState, action) {
+export const FETCH_TENANTS = createRequestActionTypes('tenants', 'FETCH_TENANTS');
+
+const initialState = {loading: true, wasLoaded: false};
+
+const tenants: Reducer<TenantsState, TenantsAction> = (state = initialState, action) => {
     switch (action.type) {
         case FETCH_TENANTS.REQUEST: {
             return {
@@ -35,20 +38,22 @@ const tenants = function (state = initialState, action) {
     }
 };
 
-export function getTenantsInfo(clusterName) {
+export function getTenantsInfo(clusterName?: string) {
     return createApiRequest({
         request: window.api.getTenants(clusterName),
         actions: FETCH_TENANTS,
         dataHandler: (response, getState) => {
             const {singleClusterMode} = getState();
+
             if (singleClusterMode) {
                 return response.TenantInfo;
             } else {
-                return response.databases?.map((tenant) => {
+                return response.TenantInfo?.map((tenant) => {
                     const node = tenant.Nodes ? tenant.Nodes[0] : {};
                     const address =
                         node.Host && node.Endpoints
-                            ? _.find(node.Endpoints, {Name: 'http-mon'})?.Address
+                            ? node.Endpoints.find((endpoint) => endpoint.Name === 'http-mon')
+                                  ?.Address
                             : undefined;
                     const backend = node.Host ? `${node.Host}${address ? address : ''}` : undefined;
                     return {...tenant, backend};

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

@@ -0,0 +1,17 @@
+import {FETCH_TENANTS} from './tenants';
+
+import type {TTenant} from '../../../types/api/tenant';
+import type {ApiRequestAction} from '../../utils';
+
+export interface PreparedTenant extends TTenant {
+    backend?: string;
+}
+
+export interface TenantsState {
+    loading: boolean;
+    wasLoaded: boolean;
+    tenants?: PreparedTenant[];
+    error?: unknown;
+}
+
+export type TenantsAction = ApiRequestAction<typeof FETCH_TENANTS, PreparedTenant[], unknown>;

package/dist/store/utils.ts

@@ -4,6 +4,7 @@ import {AxiosResponse} from 'axios';
 import createToast from '../utils/createToast';
 
 import {SET_UNAUTHENTICATED} from './reducers/authentication';
+import type {GetState} from './reducers';
 
 export const nop = (result: any) => result;
 
@@ -24,7 +25,7 @@ const isAxiosResponse = (response: any): response is AxiosResponse =>
 type CreateApiRequestParams<Actions, Response, HandledResponse> = {
     actions: Actions;
     request: Promise<Response>;
-    dataHandler?: (data: Response, getState?: () => any) => HandledResponse;
+    dataHandler?: (data: Response, getState: GetState) => HandledResponse;
 };
 
 export function createApiRequest<
@@ -36,7 +37,7 @@ export function createApiRequest<
     request,
     dataHandler = nop,
 }: CreateApiRequestParams<Actions, Response, HandledResponse>) {
-    const doRequest = async function (dispatch: Dispatch, getState: () => any) {
+    const doRequest = async function (dispatch: Dispatch, getState: GetState) {
         dispatch({
             type: actions.REQUEST,
         });

package/dist/types/api/acl.ts

@@ -0,0 +1,25 @@
+/**
+ * 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[];
+}
+
+interface TACE {
+    AccessType: string;
+    AccessRights?: string[];
+    Subject: string;
+    InheritanceType?: string[];
+    AccessRule: string;
+}

package/dist/types/api/cluster.ts

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

package/dist/types/api/compute.ts

@@ -2,9 +2,11 @@ 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
-
+/**
+ * endpoint: viewer/json/compute
+ * 
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ */
 export interface TComputeInfo {
     Overall: EFlag;
     Tenants?: TComputeTenantInfo[];