ydb-embedded-ui 4.33.0 → 5.0.0

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

@@ -1,53 +0,0 @@
-import type {ApiRequestAction} from '../../utils';
-import type {IResponseError} from '../../../types/api/error';
-import type {TEvDescribeSchemeResult} from '../../../types/api/schema';
-
-import {
-    disableAutorefresh,
-    enableAutorefresh,
-    FETCH_SCHEMA,
-    preloadSchemas,
-    resetLoadingState,
-    setCurrentSchemaPath,
-    setShowPreview,
-} from './schema';
-
-export type SchemaData = Record<string, TEvDescribeSchemeResult>;
-
-export interface SchemaState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data: SchemaData;
-    currentSchema?: TEvDescribeSchemeResult;
-    currentSchemaPath?: string;
-    autorefresh: boolean;
-    showPreview: boolean;
-    error?: IResponseError;
-}
-
-export interface SchemaHandledResponse {
-    path?: string;
-    currentSchema?: TEvDescribeSchemeResult;
-    data?: SchemaData;
-}
-
-type SchemaApiRequestAction = ApiRequestAction<
-    typeof FETCH_SCHEMA,
-    SchemaHandledResponse,
-    IResponseError
->;
-
-export type SchemaAction =
-    | SchemaApiRequestAction
-    | (
-          | ReturnType<typeof setCurrentSchemaPath>
-          | ReturnType<typeof enableAutorefresh>
-          | ReturnType<typeof disableAutorefresh>
-          | ReturnType<typeof setShowPreview>
-          | ReturnType<typeof preloadSchemas>
-          | ReturnType<typeof resetLoadingState>
-      );
-
-export interface SchemaStateSlice {
-    schema: SchemaState;
-}

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

@@ -1,72 +0,0 @@
-import type {Reducer} from 'redux';
-
-import '../../../services/api';
-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,
-    wasLoaded: false,
-};
-
-const schemaAcl: Reducer<SchemaAclState, SchemaAclAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case FETCH_SCHEMA_ACL.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-            };
-        }
-        case FETCH_SCHEMA_ACL.SUCCESS: {
-            const acl = action.data.Common?.ACL;
-            const owner = action.data.Common?.Owner;
-
-            return {
-                ...state,
-                acl,
-                owner,
-                loading: false,
-                wasLoaded: true,
-                error: undefined,
-            };
-        }
-        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;
-    }
-};
-
-export function getSchemaAcl({path}: {path: string}) {
-    return createApiRequest({
-        request: window.api.getSchemaAcl({path}),
-        actions: FETCH_SCHEMA_ACL,
-    });
-}
-
-export const setAclWasNotLoaded = () => {
-    return {
-        type: SET_ACL_WAS_NOT_LOADED,
-    } as const;
-};
-
-export default schemaAcl;

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

@@ -1,17 +0,0 @@
-import type {TACE, TMetaInfo} from '../../../types/api/acl';
-import type {IResponseError} from '../../../types/api/error';
-import type {ApiRequestAction} from '../../utils';
-
-import {FETCH_SCHEMA_ACL, setAclWasNotLoaded} 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>
-    | ReturnType<typeof setAclWasNotLoaded>;

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

@@ -1,95 +0,0 @@
-import type {Reducer} from 'redux';
-import type {ThunkAction} from 'redux-thunk';
-
-import '../../../services/api';
-import {DEFAULT_USER_SETTINGS, SettingsObject, settingsManager} from '../../../services/settings';
-
-import type {RootState} from '..';
-import type {
-    ProblemFilterValue,
-    SetSettingValueAction,
-    SettingsAction,
-    SettingsRootStateSlice,
-    SettingsState,
-} from './types';
-
-const CHANGE_PROBLEM_FILTER = 'settings/CHANGE_PROBLEM_FILTER';
-export const SET_SETTING_VALUE = 'settings/SET_VALUE';
-export const SET_USER_SETTINGS = 'settings/SET_USER_SETTINGS';
-
-export const ProblemFilterValues = {
-    ALL: 'All',
-    PROBLEMS: 'With problems',
-} as const;
-
-const userSettings = settingsManager.extractSettingsFromLS(DEFAULT_USER_SETTINGS);
-const systemSettings = window.systemSettings || {};
-
-export const initialState = {
-    problemFilter: ProblemFilterValues.ALL,
-    userSettings,
-    systemSettings,
-};
-
-const settings: Reducer<SettingsState, SettingsAction> = (state = initialState, action) => {
-    switch (action.type) {
-        case CHANGE_PROBLEM_FILTER:
-            return {
-                ...state,
-                problemFilter: action.data,
-            };
-
-        case SET_SETTING_VALUE: {
-            const newSettings = {
-                ...state.userSettings,
-                [action.data.name]: action.data.value,
-            };
-
-            return {
-                ...state,
-                userSettings: newSettings,
-            };
-        }
-        case SET_USER_SETTINGS: {
-            return {
-                ...state,
-                userSettings: {
-                    ...state.userSettings,
-                    ...action.data,
-                },
-            };
-        }
-        default:
-            return state;
-    }
-};
-
-export const setSettingValue = (
-    name: string,
-    value: unknown,
-): ThunkAction<void, RootState, unknown, SetSettingValueAction> => {
-    return (dispatch) => {
-        dispatch({type: SET_SETTING_VALUE, data: {name, value}});
-
-        settingsManager.setUserSettingsValue(name, value);
-    };
-};
-
-export const setUserSettings = (data: SettingsObject) => {
-    return {type: SET_USER_SETTINGS, data} as const;
-};
-
-export const getSettingValue = (state: SettingsRootStateSlice, name: string) => {
-    return state.settings.userSettings[name];
-};
-
-export const changeFilter = (filter: ProblemFilterValue) => {
-    return {
-        type: CHANGE_PROBLEM_FILTER,
-        data: filter,
-    } as const;
-};
-
-export const selectProblemFilter = (state: SettingsRootStateSlice) => state.settings.problemFilter;
-
-export default settings;

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

@@ -1,25 +0,0 @@
-import type {ValueOf} from '../../../types/common';
-import type {SettingsObject} from '../../../services/settings';
-import {changeFilter, setUserSettings, ProblemFilterValues, SET_SETTING_VALUE} from './settings';
-
-export type ProblemFilterValue = ValueOf<typeof ProblemFilterValues>;
-
-export interface SettingsState {
-    problemFilter: ProblemFilterValue;
-    userSettings: SettingsObject;
-    systemSettings: SettingsObject;
-}
-
-export type SetSettingValueAction = {
-    type: typeof SET_SETTING_VALUE;
-    data: {name: string; value: unknown};
-};
-
-export type SettingsAction =
-    | ReturnType<typeof changeFilter>
-    | ReturnType<typeof setUserSettings>
-    | SetSettingValueAction;
-
-export interface SettingsRootStateSlice {
-    settings: SettingsState;
-}

package/dist/store/reducers/shardsWorkload/shardsWorkload.ts

@@ -1,207 +0,0 @@
-import type {Reducer} from 'redux';
-
-import '../../../services/api';
-import {parseQueryAPIExecuteResponse} from '../../../utils/query';
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-import type {IShardsWorkloadAction, IShardsWorkloadFilters, IShardsWorkloadState} from './types';
-import {EShardsWorkloadMode} from './types';
-
-export const SEND_SHARD_QUERY = createRequestActionTypes('query', 'SEND_SHARD_QUERY');
-const SET_SHARD_STATE = 'query/SET_SHARD_STATE';
-const SET_SHARD_QUERY_FILTERS = 'shardsWorkload/SET_SHARD_QUERY_FILTERS';
-
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-    filters: {},
-};
-
-export interface SortOrder {
-    columnId: string;
-    order: string;
-}
-
-function formatSortOrder({columnId, order}: SortOrder) {
-    return `${columnId} ${order}`;
-}
-
-function getFiltersConditions(filters?: IShardsWorkloadFilters) {
-    const conditions: string[] = [];
-
-    if (filters?.from && filters?.to && filters.from > filters.to) {
-        throw new Error('Invalid date range');
-    }
-
-    if (filters?.from) {
-        // matching `from` & `to` is an edge case
-        // other cases should not include the starting point, since intervals are stored using the ending time
-        const gt = filters.to === filters.from ? '>=' : '>';
-        conditions.push(`IntervalEnd ${gt} Timestamp('${new Date(filters.from).toISOString()}')`);
-    }
-
-    if (filters?.to) {
-        conditions.push(`IntervalEnd <= Timestamp('${new Date(filters.to).toISOString()}')`);
-    }
-
-    return conditions.join(' AND ');
-}
-
-function createShardQueryHistorical(
-    path: string,
-    filters?: IShardsWorkloadFilters,
-    sortOrder?: SortOrder[],
-    tenantName?: string,
-) {
-    const pathSelect = tenantName
-        ? `CAST(SUBSTRING(CAST(Path AS String), ${tenantName.length}) AS Utf8) AS Path`
-        : 'Path';
-
-    let where = `Path='${path}' OR Path LIKE '${path}/%'`;
-
-    const filterConditions = getFiltersConditions(filters);
-    if (filterConditions.length) {
-        where = `(${where}) AND ${filterConditions}`;
-    }
-
-    const orderBy = sortOrder ? `ORDER BY ${sortOrder.map(formatSortOrder).join(', ')}` : '';
-
-    return `SELECT
-    ${pathSelect},
-    TabletId,
-    CPUCores,
-    DataSize,
-    NodeId,
-    PeakTime,
-    InFlightTxCount,
-    IntervalEnd
-FROM \`.sys/top_partitions_one_hour\`
-WHERE ${where}
-${orderBy}
-LIMIT 20`;
-}
-
-function createShardQueryImmediate(path: string, sortOrder?: SortOrder[], tenantName?: string) {
-    const pathSelect = tenantName
-        ? `CAST(SUBSTRING(CAST(Path AS String), ${tenantName.length}) AS Utf8) AS Path`
-        : 'Path';
-
-    const orderBy = sortOrder ? `ORDER BY ${sortOrder.map(formatSortOrder).join(', ')}` : '';
-
-    return `SELECT
-    ${pathSelect},
-    TabletId,
-    CPUCores,
-    DataSize,
-    NodeId,
-    InFlightTxCount
-FROM \`.sys/partition_stats\`
-WHERE
-    Path='${path}'
-    OR Path LIKE '${path}/%'
-${orderBy}
-LIMIT 20`;
-}
-
-const queryAction = 'execute-scan';
-
-const shardsWorkload: Reducer<IShardsWorkloadState, IShardsWorkloadAction> = (
-    state = initialState,
-    action,
-) => {
-    switch (action.type) {
-        case SEND_SHARD_QUERY.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-                error: undefined,
-            };
-        }
-        case SEND_SHARD_QUERY.SUCCESS: {
-            return {
-                ...state,
-                data: action.data,
-                loading: false,
-                error: undefined,
-                wasLoaded: true,
-            };
-        }
-        // 401 Unauthorized error is handled by GenericAPI
-        case SEND_SHARD_QUERY.FAILURE: {
-            if (action.error?.isCancelled) {
-                return state;
-            }
-
-            return {
-                ...state,
-                error: action.error || 'Unauthorized',
-                loading: false,
-            };
-        }
-        case SET_SHARD_STATE:
-            return {
-                ...state,
-                ...action.data,
-            };
-        case SET_SHARD_QUERY_FILTERS:
-            return {
-                ...state,
-                filters: {
-                    ...state.filters,
-                    ...action.filters,
-                },
-            };
-        default:
-            return state;
-    }
-};
-
-interface SendShardQueryParams {
-    database?: string;
-    path?: string;
-    sortOrder?: SortOrder[];
-    filters?: IShardsWorkloadFilters;
-}
-
-export const sendShardQuery = ({database, path = '', sortOrder, filters}: SendShardQueryParams) => {
-    try {
-        return createApiRequest({
-            request: window.api.sendQuery(
-                {
-                    schema: 'modern',
-                    query:
-                        filters?.mode === EShardsWorkloadMode.Immediate
-                            ? createShardQueryImmediate(path, sortOrder, database)
-                            : createShardQueryHistorical(path, filters, sortOrder, database),
-                    database,
-                    action: queryAction,
-                },
-                {
-                    concurrentId: 'shardsWorkload',
-                },
-            ),
-            actions: SEND_SHARD_QUERY,
-            dataHandler: parseQueryAPIExecuteResponse,
-        });
-    } catch (error) {
-        return {
-            type: SEND_SHARD_QUERY.FAILURE,
-            error,
-        };
-    }
-};
-
-export function setShardsState(options: Partial<IShardsWorkloadState>) {
-    return {
-        type: SET_SHARD_STATE,
-        data: options,
-    } as const;
-}
-
-export function setShardsQueryFilters(filters: Partial<IShardsWorkloadFilters>) {
-    return {
-        type: SET_SHARD_QUERY_FILTERS,
-        filters,
-    } as const;
-}
-
-export default shardsWorkload;

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

@@ -1,33 +0,0 @@
-import {SEND_SHARD_QUERY, setShardsState, setShardsQueryFilters} from './shardsWorkload';
-import type {ApiRequestAction} from '../../utils';
-import type {IQueryResult, QueryErrorResponse} from '../../../types/store/query';
-
-export enum EShardsWorkloadMode {
-    Immediate = 'immediate',
-    History = 'history',
-}
-
-export interface IShardsWorkloadFilters {
-    /** ms from epoch */
-    from?: number;
-    /** ms from epoch */
-    to?: number;
-    mode?: EShardsWorkloadMode;
-}
-
-export interface IShardsWorkloadState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data?: IQueryResult;
-    error?: QueryErrorResponse;
-    filters: IShardsWorkloadFilters;
-}
-
-export type IShardsWorkloadAction =
-    | ApiRequestAction<typeof SEND_SHARD_QUERY, IQueryResult, QueryErrorResponse>
-    | ReturnType<typeof setShardsState>
-    | ReturnType<typeof setShardsQueryFilters>;
-
-export interface IShardsWorkloadRootStateSlice {
-    shardsWorkload: IShardsWorkloadState;
-}

package/dist/store/reducers/singleClusterMode.ts

@@ -1,5 +0,0 @@
-function singleClusterMode(state = true) {
-    return state;
-}
-
-export default singleClusterMode;

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

@@ -1,10 +0,0 @@
-export const VISIBLE_ENTITIES = {
-    all: 'all',
-    missing: 'missing',
-    space: 'space',
-} as const;
-
-export const STORAGE_TYPES = {
-    groups: 'groups',
-    nodes: 'nodes',
-} as const;

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

@@ -1,159 +0,0 @@
-import {Selector, createSelector} from 'reselect';
-
-import type {OrderType} from '@gravity-ui/react-data-table';
-import {ASCENDING, DESCENDING} from '@gravity-ui/react-data-table/build/esm/lib/constants';
-
-import {NODES_SORT_VALUES, type NodesSortValue} from '../../../utils/nodes';
-import {STORAGE_SORT_VALUES, type StorageSortValue, getUsage} from '../../../utils/storage';
-
-import {filterNodesByUptime} from '../nodes/selectors';
-import type {
-    PreparedStorageGroup,
-    PreparedStorageNode,
-    StorageStateSlice,
-    UsageFilter,
-} from './types';
-import {VISIBLE_ENTITIES} from './constants';
-
-// ==== Filters ====
-
-const prepareSearchText = (text: string) => text.trim().toLowerCase();
-
-const filterNodesByText = (entities: PreparedStorageNode[], text: string) => {
-    const preparedSearch = prepareSearchText(text);
-
-    if (!preparedSearch) {
-        return entities;
-    }
-
-    return entities.filter((entity) => {
-        return (
-            entity.NodeId?.toString().includes(preparedSearch) ||
-            entity.Host?.toLowerCase().includes(preparedSearch)
-        );
-    });
-};
-const filterGroupsByText = (entities: PreparedStorageGroup[], text: string) => {
-    const preparedSearch = prepareSearchText(text);
-
-    if (!preparedSearch) {
-        return entities;
-    }
-
-    return entities.filter((entity) => {
-        return (
-            entity.PoolName?.toLowerCase().includes(preparedSearch) ||
-            entity.GroupID?.toString().includes(preparedSearch)
-        );
-    });
-};
-
-const filterGroupsByUsage = (entities: PreparedStorageGroup[], usage?: string[]) => {
-    if (!Array.isArray(usage) || usage.length === 0) {
-        return entities;
-    }
-
-    return entities.filter((entity) => {
-        const entityUsage = entity.Usage;
-        return usage.some((val) => Number(val) <= entityUsage && entityUsage < Number(val) + 5);
-    });
-};
-
-// ==== Simple selectors ====
-
-export const selectEntitiesCount = (state: StorageStateSlice) => ({
-    total: state.storage.total,
-    found: state.storage.found,
-});
-
-export const selectStorageGroups = (state: StorageStateSlice) => state.storage.groups;
-export const selectStorageNodes = (state: StorageStateSlice) => state.storage.nodes;
-
-export const selectStorageFilter = (state: StorageStateSlice) => state.storage.filter;
-export const selectUsageFilter = (state: StorageStateSlice) => state.storage.usageFilter;
-export const selectVisibleEntities = (state: StorageStateSlice) => state.storage.visible;
-export const selectNodesUptimeFilter = (state: StorageStateSlice) =>
-    state.storage.nodesUptimeFilter;
-export const selectStorageType = (state: StorageStateSlice) => state.storage.type;
-
-// ==== Sort params selectors ====
-export const selectNodesSortParams = (state: StorageStateSlice) => {
-    const defaultSortValue: NodesSortValue = NODES_SORT_VALUES.NodeId;
-    const defaultSortOrder: OrderType = ASCENDING;
-
-    return {
-        sortValue: state.storage.nodesSortValue || defaultSortValue,
-        sortOrder: state.storage.nodesSortOrder || defaultSortOrder,
-    };
-};
-
-export const selectGroupsSortParams = (state: StorageStateSlice) => {
-    const visibleEntities = state.storage.visible;
-
-    let defaultSortValue: StorageSortValue = STORAGE_SORT_VALUES.PoolName;
-    let defaultSortOrder: OrderType = ASCENDING;
-
-    if (visibleEntities === VISIBLE_ENTITIES.missing) {
-        defaultSortValue = STORAGE_SORT_VALUES.Degraded;
-        defaultSortOrder = DESCENDING;
-    }
-
-    if (visibleEntities === VISIBLE_ENTITIES.space) {
-        defaultSortValue = STORAGE_SORT_VALUES.Usage;
-        defaultSortOrder = DESCENDING;
-    }
-
-    return {
-        sortValue: state.storage.groupsSortValue || defaultSortValue,
-        sortOrder: state.storage.groupsSortOrder || defaultSortOrder,
-    };
-};
-// ==== Complex selectors ====
-
-export const selectUsageFilterOptions: Selector<StorageStateSlice, UsageFilter[]> = createSelector(
-    selectStorageGroups,
-    (groups) => {
-        const items: Record<number, number> = {};
-
-        groups?.forEach((group) => {
-            // Get groups usage with step 5
-            const usage = getUsage(group, 5);
-
-            if (!Object.prototype.hasOwnProperty.call(items, usage)) {
-                items[usage] = 0;
-            }
-
-            items[usage] += 1;
-        });
-
-        return Object.entries(items)
-            .map(([threshold, count]) => ({threshold: Number(threshold), count}))
-            .sort((a, b) => b.threshold - a.threshold);
-    },
-);
-
-// ==== Complex selectors with filters ====
-
-export const selectFilteredNodes: Selector<StorageStateSlice, PreparedStorageNode[]> =
-    createSelector(
-        [selectStorageNodes, selectStorageFilter, selectNodesUptimeFilter],
-        (storageNodes, textFilter, uptimeFilter) => {
-            let result = storageNodes || [];
-            result = filterNodesByText(result, textFilter);
-            result = filterNodesByUptime(result, uptimeFilter);
-
-            return result;
-        },
-    );
-
-export const selectFilteredGroups: Selector<StorageStateSlice, PreparedStorageGroup[]> =
-    createSelector(
-        [selectStorageGroups, selectStorageFilter, selectUsageFilter],
-        (storageGroups, textFilter, usageFilter) => {
-            let result = storageGroups || [];
-            result = filterGroupsByText(result, textFilter);
-            result = filterGroupsByUsage(result, usageFilter);
-
-            return result;
-        },
-    );