ydb-embedded-ui 4.33.0 → 5.0.0

package/dist/store/reducers/executeQuery.ts

@@ -1,239 +0,0 @@
-import type {Reducer} from 'redux';
-
-import type {ExecuteActions, Schemas} from '../../types/api/query';
-import type {
-    ExecuteQueryAction,
-    ExecuteQueryState,
-    ExecuteQueryStateSlice,
-    MonacoHotKeyAction,
-    QueryInHistory,
-} from '../../types/store/executeQuery';
-import type {QueryRequestParams, QueryMode, QuerySyntax} from '../../types/store/query';
-import {QUERIES_HISTORY_KEY} from '../../utils/constants';
-import {QUERY_MODES, QUERY_SYNTAX, parseQueryAPIExecuteResponse} from '../../utils/query';
-import {parseQueryError} from '../../utils/error';
-import {settingsManager} from '../../services/settings';
-import '../../services/api';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
-
-const MAXIMUM_QUERIES_IN_HISTORY = 20;
-
-export const SEND_QUERY = createRequestActionTypes('query', 'SEND_QUERY');
-
-const CHANGE_USER_INPUT = 'query/CHANGE_USER_INPUT';
-const SAVE_QUERY_TO_HISTORY = 'query/SAVE_QUERY_TO_HISTORY';
-const GO_TO_PREVIOUS_QUERY = 'query/GO_TO_PREVIOUS_QUERY';
-const GO_TO_NEXT_QUERY = 'query/GO_TO_NEXT_QUERY';
-const SET_MONACO_HOT_KEY = 'query/SET_MONACO_HOT_KEY';
-const SET_TENANT_PATH = 'query/SET_TENANT_PATH';
-
-const queriesHistoryInitial = settingsManager.readUserSettingsValue(
-    QUERIES_HISTORY_KEY,
-    [],
-) as string[];
-
-const sliceLimit = queriesHistoryInitial.length - MAXIMUM_QUERIES_IN_HISTORY;
-
-export const MONACO_HOT_KEY_ACTIONS = {
-    sendQuery: 'sendQuery',
-    goPrev: 'goPrev',
-    goNext: 'goNext',
-} as const;
-
-const initialState = {
-    loading: false,
-    input: '',
-    history: {
-        queries: queriesHistoryInitial.slice(sliceLimit < 0 ? 0 : sliceLimit),
-        currentIndex:
-            queriesHistoryInitial.length > MAXIMUM_QUERIES_IN_HISTORY
-                ? MAXIMUM_QUERIES_IN_HISTORY - 1
-                : queriesHistoryInitial.length - 1,
-    },
-    monacoHotKey: null,
-};
-
-const executeQuery: Reducer<ExecuteQueryState, ExecuteQueryAction> = (
-    state = initialState,
-    action,
-) => {
-    switch (action.type) {
-        case SEND_QUERY.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-                data: undefined,
-                error: undefined,
-            };
-        }
-        case SEND_QUERY.SUCCESS: {
-            return {
-                ...state,
-                data: action.data,
-                stats: action.data.stats,
-                loading: false,
-                error: undefined,
-            };
-        }
-        case SEND_QUERY.FAILURE: {
-            return {
-                ...state,
-                error: parseQueryError(action.error),
-                loading: false,
-            };
-        }
-
-        case CHANGE_USER_INPUT: {
-            return {
-                ...state,
-                input: action.data.input,
-            };
-        }
-
-        case SAVE_QUERY_TO_HISTORY: {
-            const queryText = action.data.queryText;
-
-            // Do not save explicit yql syntax value for easier further support (use yql by default)
-            const syntax = action.data.mode === QUERY_MODES.pg ? QUERY_SYNTAX.pg : undefined;
-
-            const newQueries = [...state.history.queries, {queryText, syntax}].slice(
-                state.history.queries.length >= MAXIMUM_QUERIES_IN_HISTORY ? 1 : 0,
-            );
-            settingsManager.setUserSettingsValue(QUERIES_HISTORY_KEY, newQueries);
-            const currentIndex = newQueries.length - 1;
-
-            return {
-                ...state,
-                history: {
-                    queries: newQueries,
-                    currentIndex,
-                },
-            };
-        }
-
-        case GO_TO_PREVIOUS_QUERY: {
-            const newCurrentIndex = Math.max(0, state.history.currentIndex - 1);
-
-            return {
-                ...state,
-                history: {
-                    ...state.history,
-                    currentIndex: newCurrentIndex,
-                },
-            };
-        }
-
-        case GO_TO_NEXT_QUERY: {
-            const lastIndexInHistory = state.history.queries.length - 1;
-            const newCurrentIndex = Math.min(lastIndexInHistory, state.history.currentIndex + 1);
-
-            return {
-                ...state,
-                history: {
-                    ...state.history,
-                    currentIndex: newCurrentIndex,
-                },
-            };
-        }
-
-        case SET_MONACO_HOT_KEY: {
-            return {
-                ...state,
-                monacoHotKey: action.data,
-            };
-        }
-        case SET_TENANT_PATH: {
-            return {
-                ...state,
-                tenantPath: action.data,
-            };
-        }
-
-        default:
-            return state;
-    }
-};
-
-interface SendQueryParams extends QueryRequestParams {
-    mode?: QueryMode;
-    schema?: Schemas;
-}
-
-export const sendExecuteQuery = ({query, database, mode, schema = 'modern'}: SendQueryParams) => {
-    let action: ExecuteActions = 'execute';
-    let syntax: QuerySyntax = QUERY_SYNTAX.yql;
-
-    if (mode === 'pg') {
-        action = 'execute-query';
-        syntax = QUERY_SYNTAX.pg;
-    } else if (mode) {
-        action = `execute-${mode}`;
-    }
-
-    return createApiRequest({
-        request: window.api.sendQuery({
-            schema,
-            query,
-            database,
-            action,
-            syntax,
-            stats: 'profile',
-        }),
-        actions: SEND_QUERY,
-        dataHandler: parseQueryAPIExecuteResponse,
-    });
-};
-
-export const saveQueryToHistory = (queryText: string, mode: QueryMode) => {
-    return {
-        type: SAVE_QUERY_TO_HISTORY,
-        data: {queryText, mode},
-    } as const;
-};
-
-export const goToPreviousQuery = () => {
-    return {
-        type: GO_TO_PREVIOUS_QUERY,
-    } as const;
-};
-
-export const goToNextQuery = () => {
-    return {
-        type: GO_TO_NEXT_QUERY,
-    } as const;
-};
-
-export const changeUserInput = ({input}: {input: string}) => {
-    return {
-        type: CHANGE_USER_INPUT,
-        data: {input},
-    } as const;
-};
-
-export const setMonacoHotKey = (value: MonacoHotKeyAction | null) => {
-    return {
-        type: SET_MONACO_HOT_KEY,
-        data: value,
-    } as const;
-};
-
-export const setTenantPath = (value: string) => {
-    return {
-        type: SET_TENANT_PATH,
-        data: value,
-    } as const;
-};
-
-export const selectQueriesHistory = (state: ExecuteQueryStateSlice): QueryInHistory[] => {
-    return state.executeQuery.history.queries.map((rawQuery) => {
-        if (typeof rawQuery === 'string') {
-            return {
-                queryText: rawQuery,
-            };
-        }
-        return rawQuery;
-    });
-};
-
-export default executeQuery;

package/dist/store/reducers/executeTopQueries/executeTopQueries.ts

@@ -1,122 +0,0 @@
-import type {AnyAction, Reducer} from 'redux';
-import type {ThunkAction} from 'redux-thunk';
-
-import '../../../services/api';
-import type {IQueryResult} from '../../../types/store/query';
-import {parseQueryAPIExecuteResponse} from '../../../utils/query';
-
-import {createRequestActionTypes, createApiRequest} from '../../utils';
-import type {RootState} from '..';
-import type {ITopQueriesAction, ITopQueriesFilters, ITopQueriesState} from './types';
-import {getFiltersConditions} from './utils';
-
-export const FETCH_TOP_QUERIES = createRequestActionTypes('top-queries', 'FETCH_TOP_QUERIES');
-const SET_TOP_QUERIES_STATE = 'top-queries/SET_TOP_QUERIES_STATE';
-const SET_TOP_QUERIES_FILTERS = 'top-queries/SET_TOP_QUERIES_FILTERS';
-
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-    filters: {},
-};
-
-const getQueryText = (path: string, filters?: ITopQueriesFilters) => {
-    const filterConditions = getFiltersConditions(path, filters);
-    return `
-SELECT
-    CPUTime as CPUTimeUs,
-    QueryText,
-    IntervalEnd,
-    EndTime,
-    ReadRows,
-    ReadBytes,
-    UserSID
-FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
-WHERE ${filterConditions || 'true'}
-`;
-};
-
-const executeTopQueries: Reducer<ITopQueriesState, ITopQueriesAction> = (
-    state = initialState,
-    action,
-) => {
-    switch (action.type) {
-        case FETCH_TOP_QUERIES.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-                error: undefined,
-            };
-        }
-        case FETCH_TOP_QUERIES.SUCCESS: {
-            return {
-                ...state,
-                data: action.data,
-                loading: false,
-                error: undefined,
-                wasLoaded: true,
-            };
-        }
-        // 401 Unauthorized error is handled by GenericAPI
-        case FETCH_TOP_QUERIES.FAILURE: {
-            return {
-                ...state,
-                error: action.error || 'Unauthorized',
-                loading: false,
-            };
-        }
-        case SET_TOP_QUERIES_STATE:
-            return {
-                ...state,
-                ...action.data,
-            };
-        case SET_TOP_QUERIES_FILTERS:
-            return {
-                ...state,
-                filters: {
-                    ...state.filters,
-                    ...action.filters,
-                },
-            };
-        default:
-            return state;
-    }
-};
-
-type FetchTopQueries = (params: {
-    database: string;
-    filters?: ITopQueriesFilters;
-}) => ThunkAction<Promise<IQueryResult | undefined>, RootState, unknown, AnyAction>;
-
-export const fetchTopQueries: FetchTopQueries = ({database, filters}) =>
-    createApiRequest({
-        request: window.api.sendQuery(
-            {
-                schema: 'modern',
-                query: getQueryText(database, filters),
-                database,
-                action: 'execute-scan',
-            },
-            {
-                concurrentId: 'executeTopQueries',
-            },
-        ),
-        actions: FETCH_TOP_QUERIES,
-        dataHandler: parseQueryAPIExecuteResponse,
-    });
-
-export function setTopQueriesState(state: Partial<ITopQueriesState>) {
-    return {
-        type: SET_TOP_QUERIES_STATE,
-        data: state,
-    } as const;
-}
-
-export function setTopQueriesFilters(filters: Partial<ITopQueriesFilters>) {
-    return {
-        type: SET_TOP_QUERIES_FILTERS,
-        filters,
-    } as const;
-}
-
-export default executeTopQueries;

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

@@ -1,28 +0,0 @@
-import {FETCH_TOP_QUERIES, setTopQueriesState, setTopQueriesFilters} from './executeTopQueries';
-import type {ApiRequestAction} from '../../utils';
-import type {IQueryResult, QueryErrorResponse} from '../../../types/store/query';
-
-export interface ITopQueriesFilters {
-    /** ms from epoch */
-    from?: number;
-    /** ms from epoch */
-    to?: number;
-    text?: string;
-}
-
-export interface ITopQueriesState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data?: IQueryResult;
-    error?: QueryErrorResponse;
-    filters: ITopQueriesFilters;
-}
-
-export type ITopQueriesAction =
-    | ApiRequestAction<typeof FETCH_TOP_QUERIES, IQueryResult, QueryErrorResponse>
-    | ReturnType<typeof setTopQueriesState>
-    | ReturnType<typeof setTopQueriesFilters>;
-
-export interface ITopQueriesRootStateSlice {
-    executeTopQueries: ITopQueriesState;
-}

package/dist/store/reducers/executeTopQueries/utils.ts

@@ -1,36 +0,0 @@
-import {ITopQueriesFilters} from './types';
-
-const getMaxIntervalSubquery = (path: string) => `(
-    SELECT
-        MAX(IntervalEnd)
-    FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
-)`;
-
-export function getFiltersConditions(path: string, filters?: ITopQueriesFilters) {
-    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()}')`);
-    }
-
-    if (!filters?.from && !filters?.to) {
-        conditions.push(`IntervalEnd IN ${getMaxIntervalSubquery(path)}`);
-    }
-
-    if (filters?.text) {
-        conditions.push(`QueryText ILIKE '%${filters.text}%'`);
-    }
-
-    return conditions.join(' AND ');
-}

package/dist/store/reducers/explainQuery.ts

@@ -1,162 +0,0 @@
-import type {Reducer} from 'redux';
-import type {ExplainPlanNodeData, GraphNode, Link} from '@gravity-ui/paranoid';
-import _ from 'lodash';
-
-import '../../services/api';
-import type {ExplainActions} from '../../types/api/query';
-import type {
-    ExplainQueryAction,
-    ExplainQueryState,
-    PreparedExplainResponse,
-} from '../../types/store/explainQuery';
-import type {QueryRequestParams, QueryMode, QuerySyntax} from '../../types/store/query';
-
-import {preparePlan} from '../../utils/prepareQueryExplain';
-import {QUERY_SYNTAX, parseQueryAPIExplainResponse, parseQueryExplainPlan} from '../../utils/query';
-import {parseQueryError} from '../../utils/error';
-
-import {createRequestActionTypes, createApiRequest} from '../utils';
-
-export const GET_EXPLAIN_QUERY = createRequestActionTypes('query', 'GET_EXPLAIN_QUERY');
-export const GET_EXPLAIN_QUERY_AST = createRequestActionTypes('query', 'GET_EXPLAIN_QUERY_AST');
-
-const initialState = {
-    loading: false,
-};
-
-const explainQuery: Reducer<ExplainQueryState, ExplainQueryAction> = (
-    state = initialState,
-    action,
-) => {
-    switch (action.type) {
-        case GET_EXPLAIN_QUERY.REQUEST: {
-            return {
-                ...state,
-                loading: true,
-                data: undefined,
-                error: undefined,
-                dataAst: undefined,
-                errorAst: undefined,
-            };
-        }
-        case GET_EXPLAIN_QUERY.SUCCESS: {
-            return {
-                ...state,
-                data: action.data.plan,
-                dataAst: action.data.ast,
-                loading: false,
-                error: undefined,
-            };
-        }
-        case GET_EXPLAIN_QUERY.FAILURE: {
-            return {
-                ...state,
-                error: parseQueryError(action.error),
-                loading: false,
-            };
-        }
-        case GET_EXPLAIN_QUERY_AST.REQUEST: {
-            return {
-                ...state,
-                loadingAst: true,
-                dataAst: undefined,
-                errorAst: undefined,
-            };
-        }
-        case GET_EXPLAIN_QUERY_AST.SUCCESS: {
-            return {
-                ...state,
-                dataAst: action.data.ast,
-                loadingAst: false,
-                error: undefined,
-            };
-        }
-        case GET_EXPLAIN_QUERY_AST.FAILURE: {
-            return {
-                ...state,
-                errorAst: parseQueryError(action.error),
-                loadingAst: false,
-            };
-        }
-
-        default:
-            return state;
-    }
-};
-
-export const getExplainQueryAst = ({query, database}: QueryRequestParams) => {
-    return createApiRequest({
-        request: window.api.getExplainQueryAst(query, database),
-        actions: GET_EXPLAIN_QUERY_AST,
-        dataHandler: parseQueryAPIExplainResponse,
-    });
-};
-
-export const explainVersions = {
-    v2: '0.2',
-};
-
-const supportedExplainQueryVersions = Object.values(explainVersions);
-
-interface ExplainQueryParams extends QueryRequestParams {
-    mode?: QueryMode;
-}
-
-export const getExplainQuery = ({query, database, mode}: ExplainQueryParams) => {
-    let action: ExplainActions = 'explain';
-    let syntax: QuerySyntax = QUERY_SYNTAX.yql;
-
-    if (mode === 'pg') {
-        action = 'explain-query';
-        syntax = QUERY_SYNTAX.pg;
-    } else if (mode) {
-        action = `explain-${mode}`;
-    }
-
-    return createApiRequest({
-        request: window.api.getExplainQuery(query, database, action, syntax),
-        actions: GET_EXPLAIN_QUERY,
-        dataHandler: (response): PreparedExplainResponse => {
-            const {plan: rawPlan, ast} = parseQueryAPIExplainResponse(response);
-
-            if (!rawPlan) {
-                return {ast};
-            }
-
-            const {tables, meta, Plan} = parseQueryExplainPlan(rawPlan);
-
-            if (supportedExplainQueryVersions.indexOf(meta.version) === -1) {
-                // Do not prepare plan for not supported versions
-                return {
-                    plan: {
-                        pristine: rawPlan,
-                        version: meta.version,
-                    },
-                    ast,
-                };
-            }
-
-            let links: Link[] = [];
-            let nodes: GraphNode<ExplainPlanNodeData>[] = [];
-
-            if (Plan) {
-                const preparedPlan = preparePlan(Plan);
-                links = preparedPlan.links;
-                nodes = preparedPlan.nodes;
-            }
-
-            return {
-                plan: {
-                    links,
-                    nodes,
-                    tables,
-                    version: meta.version,
-                    pristine: rawPlan,
-                },
-                ast,
-            };
-        },
-    });
-};
-
-export default explainQuery;

package/dist/store/reducers/fullscreen.ts

@@ -1,31 +0,0 @@
-const ENABLE_FULLSCREEN_MODE = 'ENABLE_FULLSCREEN_MODE';
-const DISABLE_FULLSCREEN_MODE = 'DISABLE_FULLSCREEN_MODE';
-
-const initialState = false;
-
-const fullscreen = function (
-    state = initialState,
-    action: ReturnType<typeof enableFullscreen> | ReturnType<typeof disableFullscreen>,
-) {
-    switch (action.type) {
-        case DISABLE_FULLSCREEN_MODE:
-            return false;
-        case ENABLE_FULLSCREEN_MODE:
-            return true;
-        default:
-            return state;
-    }
-};
-
-export function enableFullscreen() {
-    return {
-        type: ENABLE_FULLSCREEN_MODE,
-    } as const;
-}
-export function disableFullscreen() {
-    return {
-        type: DISABLE_FULLSCREEN_MODE,
-    } as const;
-}
-
-export default fullscreen;

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

@@ -1,31 +0,0 @@
-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

@@ -1,54 +0,0 @@
-import type {ClusterTab} from '../../../containers/Cluster/utils';
-import type {EType} from '../../../types/api/tablet';
-
-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[];
-}
-
-export interface TabletBreadcrumbsOptions extends TabletsBreadcrumbsOptions {
-    tabletId?: string;
-    tabletType?: EType;
-}
-
-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>;