ydb-embedded-ui 0.1.0

package/dist/store/reducers/executeQuery.js

@@ -0,0 +1,158 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+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 SELECT_RUN_ACTION = 'query/SELECT_RUN_ACTION';
+
+export const RUN_ACTIONS_VALUES = {
+    script: 'execute-script',
+    scan: 'execute-scan',
+};
+
+const initialState = {
+    loading: false,
+    input: '',
+    history: {
+        queries: [],
+        currentIndex: -1,
+    },
+    runAction: RUN_ACTIONS_VALUES.script,
+};
+
+const executeQuery = (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.result ?? action.data,
+                stats: action.data.stats,
+                loading: false,
+                error: undefined,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case SEND_QUERY.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+
+        case SELECT_RUN_ACTION: {
+            return {
+                ...state,
+                runAction: action.data,
+            };
+        }
+
+        case CHANGE_USER_INPUT: {
+            return {
+                ...state,
+                input: action.data.input,
+            };
+        }
+
+        case SAVE_QUERY_TO_HISTORY: {
+            const query = action.data;
+            const newQueries = [...state.history.queries, query];
+            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,
+                },
+            };
+        }
+
+        default:
+            return state;
+    }
+};
+
+export const sendQuery = ({query, database, action}) => {
+    return createApiRequest({
+        request: window.api.sendQuery(query, database, action, 'profile'),
+        actions: SEND_QUERY,
+        dataHandler: (result) => {
+            const resultData = result.result ?? result;
+            if (resultData && typeof resultData === 'string') {
+                throw 'Unexpected token in JSON.';
+            }
+            return result;
+        },
+    });
+};
+
+export const saveQueryToHistory = (query) => {
+    return {
+        type: SAVE_QUERY_TO_HISTORY,
+        data: query,
+    };
+};
+
+export const selectRunAction = (value) => {
+    return {
+        type: SELECT_RUN_ACTION,
+        data: value,
+    };
+};
+
+export const goToPreviousQuery = () => {
+    return {
+        type: GO_TO_PREVIOUS_QUERY,
+    };
+};
+
+export const goToNextQuery = () => {
+    return {
+        type: GO_TO_NEXT_QUERY,
+    };
+};
+
+export const changeUserInput = ({input}) => {
+    return (dispatch) => {
+        dispatch({type: CHANGE_USER_INPUT, data: {input}});
+    };
+};
+
+export default executeQuery;

package/dist/store/reducers/executeTopQueries.js

@@ -0,0 +1,69 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const SEND_QUERY = createRequestActionTypes('top-queries', 'SEND_QUERY');
+const SET_QUERY_OPTIONS = createRequestActionTypes('top-queries', 'SET_QUERY_OPTIONS');
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+const executeTopQueries = (state = initialState, action) => {
+    switch (action.type) {
+        case SEND_QUERY.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                error: undefined,
+            };
+        }
+        case SEND_QUERY.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case SEND_QUERY.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+        case SET_QUERY_OPTIONS:
+            return {
+                ...state,
+                ...action.data,
+            };
+        default:
+            return state;
+    }
+};
+
+export const sendQuery = ({query, database, action}) => {
+    return createApiRequest({
+        request: window.api.sendQuery(query, database, action),
+        actions: SEND_QUERY,
+        dataHandler: (result) => {
+            if (result && typeof result === 'string') {
+                throw 'Unexpected token in JSON.';
+            }
+
+            return result;
+        },
+    });
+};
+
+export function setQueryOptions(options) {
+    return {
+        type: SET_QUERY_OPTIONS,
+        data: options,
+    };
+}
+
+export default executeTopQueries;

package/dist/store/reducers/explainQuery.js

@@ -0,0 +1,174 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+import _ from 'lodash';
+import {getExplainNodeId, getMetaForExplainNode} from '../../utils';
+import {preparePlan} from '../../utils/prepareQueryExplain';
+
+const GET_EXPLAIN_QUERY = createRequestActionTypes('query', 'GET_EXPLAIN_QUERY');
+const GET_EXPLAIN_QUERY_AST = createRequestActionTypes('query', 'GET_EXPLAIN_QUERY_AST');
+
+const initialState = {
+    loading: false,
+};
+
+const explainQuery = (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,
+                loading: false,
+                error: undefined,
+            };
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case GET_EXPLAIN_QUERY.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                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,
+                loadingAst: false,
+                error: undefined,
+            };
+        }
+        case GET_EXPLAIN_QUERY_AST.FAILURE: {
+            return {
+                ...state,
+                errorAst: action.error || 'Unauthorized',
+                loadingAst: false,
+            };
+        }
+
+        default:
+            return state;
+    }
+};
+
+export const getExplainQueryAst = ({query, database}) => {
+    return createApiRequest({
+        request: window.api.getExplainQueryAst(query, database),
+        actions: GET_EXPLAIN_QUERY_AST,
+    });
+};
+
+export const explainVersions = {
+    v1: '0.1',
+    v2: '0.2',
+};
+
+const supportedExplainQueryVersions = Object.values(explainVersions);
+
+export const getExplainQuery = ({query, database}) => {
+    return createApiRequest({
+        request: window.api.getExplainQuery(query, database),
+        actions: GET_EXPLAIN_QUERY,
+        dataHandler: (result) => {
+            let links = [];
+            let nodes = [];
+            let graphDepth;
+            const {tables, meta, Plan} = result;
+
+            if (supportedExplainQueryVersions.indexOf(meta.version) === -1) {
+                return {
+                    pristine: result,
+                    version: meta.version,
+                };
+            }
+            if (meta.version === explainVersions.v2) {
+                const preparedPlan = preparePlan(Plan);
+                links = preparedPlan.links;
+                nodes = preparedPlan.nodes;
+                graphDepth = preparedPlan.graphDepth;
+            } else {
+                graphDepth = tables.length;
+                _.forEach(tables, (table) => {
+                    nodes.push({
+                        name: table.name,
+                    });
+
+                    const tableTypes = {};
+
+                    const {reads = [], writes = []} = table;
+                    let prevEl = null;
+
+                    _.forEach([...reads, ...writes], (node) => {
+                        if (tableTypes[node.type]) {
+                            tableTypes[node.type] = tableTypes[node.type] + 1;
+                        } else {
+                            tableTypes[node.type] = 1;
+                        }
+
+                        const nodeId = getExplainNodeId(
+                            table.name,
+                            node.type,
+                            tableTypes[node.type],
+                        );
+
+                        let prevNodeId = table.name;
+                        if (prevEl) {
+                            prevNodeId =
+                                node.type === prevEl.type
+                                    ? getExplainNodeId(
+                                          table.name,
+                                          prevEl.type,
+                                          tableTypes[prevEl.type] - 1,
+                                      )
+                                    : getExplainNodeId(
+                                          table.name,
+                                          prevEl.type,
+                                          tableTypes[prevEl.type],
+                                      );
+                        }
+
+                        links.push({
+                            from: prevNodeId,
+                            to: nodeId,
+                        });
+                        nodes.push({
+                            name: nodeId,
+                            meta: getMetaForExplainNode(node),
+                            id: nodeId,
+                        });
+
+                        prevEl = node;
+                    });
+                });
+            }
+
+            return {
+                links,
+                nodes,
+                tables,
+                version: meta.version,
+                pristine: result,
+                graphDepth,
+            };
+        },
+    });
+};
+
+export default explainQuery;

package/dist/store/reducers/group.js

@@ -0,0 +1,49 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_GROUP = createRequestActionTypes('GROUP', 'FETCH_GROUP');
+
+const initialState = {loading: true, wasLoaded: false, data: undefined};
+
+const group = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_GROUP.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_GROUP.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_GROUP.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case 'CLEAR_STORE': {
+            return initialState;
+        }
+        default:
+            return state;
+    }
+};
+
+export const clearStore = () => ({type: 'CLEAR_STORE'});
+
+export const getGroupInfo = (nodeId) => {
+    return createApiRequest({
+        request: window.api.getGroupInfo(nodeId),
+        actions: FETCH_GROUP,
+    });
+};
+
+export default group;

package/dist/store/reducers/healthcheckInfo.js

@@ -0,0 +1,45 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_HEALTHCHECK = createRequestActionTypes('cluster', 'FETCH_HEALTHCHECK');
+
+const initialState = {loading: false, wasLoaded: false};
+const healthcheckInfo = function (state = initialState, action) {
+    switch (action.type) {
+        case FETCH_HEALTHCHECK.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_HEALTHCHECK.SUCCESS: {
+            const {data} = action;
+
+            return {
+                ...state,
+                data,
+                wasLoaded: true,
+                loading: false,
+                error: undefined,
+            };
+        }
+        case FETCH_HEALTHCHECK.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getHealthcheckInfo(database) {
+    return createApiRequest({
+        request: window.api.getHealthcheckInfo(database),
+        actions: FETCH_HEALTHCHECK,
+    });
+}
+
+export default healthcheckInfo;

package/dist/store/reducers/heatmap.js

@@ -0,0 +1,105 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_TABLETS = createRequestActionTypes('heatmap', 'FETCH_TABLETS');
+const SET_HEATMAP_OPTIONS = 'heatmap/SET_HEATMAP_OPTIONS';
+
+export const initialState = {
+    loading: false,
+    wasLoaded: false,
+    currentMetric: undefined,
+    sort: false,
+    heatmap: false,
+};
+
+const tablets = function z(state = initialState, action) {
+    switch (action.type) {
+        case FETCH_TABLETS.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_TABLETS.SUCCESS: {
+            return {
+                ...state,
+                ...action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_TABLETS.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+                wasLoaded: false,
+            };
+        }
+        case SET_HEATMAP_OPTIONS:
+            return {
+                ...state,
+                ...action.data,
+            };
+        default:
+            return state;
+    }
+};
+
+export function getTabletsInfo({nodes, path}) {
+    return createApiRequest({
+        request: Promise.all([
+            window.api.getTabletsInfo({nodes, path}),
+            window.api.getHeatmapData({path}),
+        ]),
+        actions: FETCH_TABLETS,
+        dataHandler: ([tabletsData = [], describe = {}]) => {
+            const {TabletStateInfo: tablets = []} = tabletsData;
+            const TabletsMap = new Map();
+            const {PathDescription = {}} = describe;
+            const {
+                TablePartitions = [],
+                TablePartitionStats = [],
+                TablePartitionMetrics = [],
+            } = PathDescription;
+
+            tablets.forEach((item) => {
+                TabletsMap.set(item.TabletId, item);
+            });
+
+            TablePartitions.forEach((item, index) => {
+                const metrics = Object.assign(
+                    {},
+                    TablePartitionStats[index],
+                    TablePartitionMetrics[index],
+                );
+                TabletsMap.set(item.DatashardId, {
+                    ...TabletsMap.get(item.DatashardId),
+                    metrics,
+                });
+            });
+
+            const preparedTablets = Array.from(TabletsMap.values());
+            const selectMetrics =
+                preparedTablets[0] &&
+                Object.keys(preparedTablets[0].metrics).map((item) => {
+                    return {
+                        value: item,
+                        content: item,
+                    };
+                });
+
+            return {data: preparedTablets, metrics: selectMetrics};
+        },
+    });
+}
+
+export function setHeatmapOptions(options) {
+    return {
+        type: SET_HEATMAP_OPTIONS,
+        data: options,
+    };
+}
+
+export default tablets;

package/dist/store/reducers/host.js

@@ -0,0 +1,44 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_HOST = createRequestActionTypes('host', 'FETCH_HOST');
+
+const initialState = {loading: true, wasLoaded: false, data: {}};
+
+const cluster = function (state = initialState, action) {
+    switch (action.type) {
+        case FETCH_HOST.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_HOST.SUCCESS: {
+            return {
+                ...state,
+                data: action.data.SystemStateInfo[0],
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_HOST.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getHostInfo() {
+    return createApiRequest({
+        request: window.api.getHostInfo(),
+        actions: FETCH_HOST,
+    });
+}
+
+export default cluster;

package/dist/store/reducers/hotKeys.js

@@ -0,0 +1,57 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_HOT_KEYS = createRequestActionTypes('hot_keys', 'FETCH_HOT_KEYS');
+const SET_HOT_KEYS_OPTIONS = createRequestActionTypes('hot_keys', 'SET_HOT_KEYS_OPTIONS');
+
+const initialState = {loading: true, data: {}, wasLoaded: false};
+
+const hotKeys = function (state = initialState, action) {
+    switch (action.type) {
+        case FETCH_HOT_KEYS.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_HOT_KEYS.SUCCESS: {
+            return {
+                ...state,
+                data: action.data.hotkeys,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        case FETCH_HOT_KEYS.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_HOT_KEYS_OPTIONS:
+            return {
+                ...state,
+                ...action.data,
+            };
+        default:
+            return state;
+    }
+};
+
+export function getHotKeys(currentSchemaPath, enableSampling) {
+    return createApiRequest({
+        request: window.api.getHotKeys(currentSchemaPath, enableSampling),
+        actions: FETCH_HOT_KEYS,
+    });
+}
+
+export function setHotKeysOptions(options) {
+    return {
+        type: SET_HOT_KEYS_OPTIONS,
+        data: options,
+    };
+}
+
+export default hotKeys;