ydb-embedded-ui 0.1.0

package/dist/store/reducers/index.js

@@ -0,0 +1,78 @@
+import {combineReducers} from 'redux';
+
+import nodes from './nodes';
+import cluster from './cluster';
+import tenant from './tenant';
+import storage from './storage';
+import node from './node';
+import pdisk from './pdisk';
+import vdisk from './vdisk';
+import group from './group';
+import tooltip from './tooltip';
+import tablets from './tablets';
+import heatmap from './heatmap';
+import schema from './schema';
+import host from './host';
+import network from './network';
+import pool from './pool';
+import tenants from './tenants';
+import tablet from './tablet';
+import executeQuery from './executeQuery';
+import explainQuery from './explainQuery';
+import tabletsFilters from './tabletsFilters';
+import clusterInfo from './clusterInfo';
+import settings from './settings';
+import preview from './preview';
+import nodesList from './clusterNodes';
+import describe from './describe';
+import schemaAcl from './schemaAcl';
+import executeTopQueries from './executeTopQueries';
+import healthcheckInfo from './healthcheckInfo';
+import shardsWorkload from './shardsWorkload';
+import hotKeys from './hotKeys';
+import olapStats from './olapStats';
+import authentication from './authentication';
+
+function singleClusterMode(state = true) {
+    return state;
+}
+
+export const rootReducer = {
+    singleClusterMode,
+    nodes,
+    cluster,
+    tenant,
+    storage,
+    node,
+    pdisk,
+    vdisk,
+    group,
+    tooltip,
+    tablets,
+    schema,
+    olapStats,
+    host,
+    network,
+    pool,
+    tenants,
+    tablet,
+    executeQuery,
+    explainQuery,
+    tabletsFilters,
+    heatmap,
+    clusterInfo,
+    settings,
+    preview,
+    nodesList,
+    describe,
+    schemaAcl,
+    executeTopQueries,
+    healthcheckInfo,
+    shardsWorkload,
+    hotKeys,
+    authentication,
+};
+
+export default combineReducers({
+    ...rootReducer,
+});

package/dist/store/reducers/network.js

@@ -0,0 +1,45 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_ALL_NODES_NETWORK = createRequestActionTypes(
+    'ALL_NODES_NETWORK',
+    'FETCH_ALL_NODES_NETWORK',
+);
+
+const network = (state = {data: {}, loading: true, wasLoaded: false}, action) => {
+    switch (action.type) {
+        case FETCH_ALL_NODES_NETWORK.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_ALL_NODES_NETWORK.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_ALL_NODES_NETWORK.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const getNetworkInfo = (tenant) => {
+    return createApiRequest({
+        request: window.api.getNetwork(tenant),
+        actions: FETCH_ALL_NODES_NETWORK,
+    });
+};
+
+export default network;

package/dist/store/reducers/node.js

@@ -0,0 +1,42 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_NODE = createRequestActionTypes('NODE', 'FETCH_NODE');
+
+const NODE = (state = {data: {}, loading: true, wasLoaded: false}, action) => {
+    switch (action.type) {
+        case FETCH_NODE.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_NODE.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_NODE.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export const getNodeInfo = (id) => {
+    return createApiRequest({
+        request: window.api.getNodeInfo(id),
+        actions: FETCH_NODE,
+    });
+};
+
+export default NODE;

package/dist/store/reducers/nodes.js

@@ -0,0 +1,58 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+import {AUTO_RELOAD_INTERVAL} from '../../utils/constants';
+
+const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
+
+const nodes = function z(state = {loading: true, wasLoaded: false}, action) {
+    switch (action.type) {
+        case FETCH_NODES.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                requestTime: new Date().getTime(),
+            };
+        }
+        case FETCH_NODES.SUCCESS: {
+            const timeout = new Date().getTime() - state.requestTime;
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                timeoutForRequest: timeout > AUTO_RELOAD_INTERVAL ? timeout : AUTO_RELOAD_INTERVAL,
+                error: undefined,
+            };
+        }
+        case FETCH_NODES.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case 'CLEAR_NODES': {
+            return {
+                ...state,
+                loading: true,
+                data: undefined,
+                wasLoaded: false,
+                requestTime: new Date().getTime(),
+                error: undefined,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getNodes(path) {
+    return createApiRequest({
+        request: window.api.getNodes(path),
+        actions: FETCH_NODES,
+    });
+}
+
+export const clearNodes = () => ({type: 'CLEAR_NODES'});
+
+export default nodes;

package/dist/store/reducers/olapStats.js

@@ -0,0 +1,74 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_OLAP_STATS = createRequestActionTypes('query', 'SEND_OLAP_STATS_QUERY');
+const SET_OLAP_STATS_OPTIONS = createRequestActionTypes('query', 'SET_OLAP_STATS_OPTIONS');
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+function createOlatStatsQuery(path) {
+    return `SELECT * FROM \`${path}/.sys/primary_index_stats\``;
+}
+
+const queryAction = 'execute-scan';
+
+const olapStats = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_OLAP_STATS.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+                error: undefined,
+            };
+        }
+        case FETCH_OLAP_STATS.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                error: undefined,
+                wasLoaded: true,
+            };
+        }
+        case FETCH_OLAP_STATS.FAILURE: {
+            return {
+                ...state,
+                error: action.error || 'Unauthorized',
+                loading: false,
+            };
+        }
+        case SET_OLAP_STATS_OPTIONS:
+            return {
+                ...state,
+                ...action.data,
+            };
+        default:
+            return state;
+    }
+};
+
+export const getOlapStats = ({path = ''}) => {
+    return createApiRequest({
+        request: window.api.sendQuery(createOlatStatsQuery(path), path, queryAction),
+        actions: FETCH_OLAP_STATS,
+        dataHandler: (result) => {
+            if (result && typeof result === 'string') {
+                throw 'Unexpected token in JSON.';
+            }
+
+            return result;
+        },
+    });
+};
+
+export function setOlapStatsOptions(options) {
+    return {
+        type: SET_OLAP_STATS_OPTIONS,
+        data: options,
+    };
+}
+
+export default olapStats;

package/dist/store/reducers/pdisk.js

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

package/dist/store/reducers/pool.js

@@ -0,0 +1,42 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_POOL = createRequestActionTypes('pool', 'FETCH_POOL');
+
+const pool = function z(state = {loading: true, wasLoaded: false}, action) {
+    switch (action.type) {
+        case FETCH_POOL.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_POOL.SUCCESS: {
+            return {
+                ...state,
+                data: action.data,
+                loading: false,
+                wasLoaded: true,
+                error: undefined,
+            };
+        }
+        case FETCH_POOL.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getPoolInfo(poolName) {
+    return createApiRequest({
+        request: window.api.getPoolInfo(poolName),
+        actions: FETCH_POOL,
+    });
+}
+
+export default pool;

package/dist/store/reducers/preview.js

@@ -0,0 +1,73 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const SEND_QUERY = createRequestActionTypes('preview', 'SEND_QUERY');
+const SET_QUERY_OPTIONS = createRequestActionTypes('preview', 'SET_QUERY_OPTIONS');
+
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+};
+
+const preview = (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: (data) => {
+            if (!Array.isArray(data)) {
+                try {
+                    return JSON.parse(data);
+                } catch (e) {
+                    return [];
+                }
+            }
+
+            return data;
+        },
+    });
+};
+
+export function setQueryOptions(options) {
+    return {
+        type: SET_QUERY_OPTIONS,
+        data: options,
+    };
+}
+
+export default preview;

package/dist/store/reducers/schema.js

@@ -0,0 +1,95 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+
+const FETCH_SCHEMA = createRequestActionTypes('schema', 'FETCH_SCHEMA');
+const SET_SCHEMA = 'schema/SET_SCHEMA';
+const ENABLE_AUTOREFRESH = 'schema/ENABLE_AUTOREFRESH';
+const DISABLE_AUTOREFRESH = 'schema/DISABLE_AUTOREFRESH';
+
+export const initialState = {
+    loading: true,
+    wasLoaded: false,
+    data: {},
+    currentSchemaPath: undefined,
+    autorefresh: false,
+};
+
+const schema = function z(state = initialState, action) {
+    switch (action.type) {
+        case FETCH_SCHEMA.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_SCHEMA.SUCCESS: {
+            const newData = JSON.parse(JSON.stringify(state.data));
+            newData[action.data.Path] = action.data;
+            const currentSchema = state.currentSchemaPath
+                ? newData[state.currentSchemaPath]
+                : action.data;
+            const currentSchemaPath = state.currentSchemaPath || action.data.Path;
+            return {
+                ...state,
+                error: undefined,
+                data: newData,
+                currentSchema,
+                currentSchemaPath,
+                loading: false,
+                wasLoaded: true,
+            };
+        }
+        case FETCH_SCHEMA.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        case SET_SCHEMA: {
+            return {
+                ...state,
+                currentSchemaPath: action.data,
+            };
+        }
+        case ENABLE_AUTOREFRESH: {
+            return {
+                ...state,
+                autorefresh: true,
+            };
+        }
+        case DISABLE_AUTOREFRESH: {
+            return {
+                ...state,
+                autorefresh: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getSchema({path}) {
+    return createApiRequest({
+        request: window.api.getSchema({path}),
+        actions: FETCH_SCHEMA,
+    });
+}
+
+export function setCurrentSchemaPath(currentSchemaPath) {
+    return {
+        type: SET_SCHEMA,
+        data: currentSchemaPath,
+    };
+}
+export function enableAutorefresh() {
+    return {
+        type: ENABLE_AUTOREFRESH,
+    };
+}
+export function disableAutorefresh() {
+    return {
+        type: DISABLE_AUTOREFRESH,
+    };
+}
+export default schema;

package/dist/store/reducers/schemaAcl.js

@@ -0,0 +1,44 @@
+import {createRequestActionTypes, createApiRequest} from '../utils';
+import '../../services/api';
+import _ from 'lodash';
+
+const FETCH_SCHEMA_ACL = createRequestActionTypes('schemaAcl', 'FETCH_SCHEMA_ACL');
+
+const schemaAcl = function z(state = {loading: false, wasLoaded: false, acl: undefined}, action) {
+    switch (action.type) {
+        case FETCH_SCHEMA_ACL.REQUEST: {
+            return {
+                ...state,
+                loading: true,
+            };
+        }
+        case FETCH_SCHEMA_ACL.SUCCESS: {
+            return {
+                ...state,
+                error: undefined,
+                acl: _.get(action.data, 'Common.ACL'),
+                owner: _.get(action.data, 'Common.Owner'),
+                loading: false,
+                wasLoaded: true,
+            };
+        }
+        case FETCH_SCHEMA_ACL.FAILURE: {
+            return {
+                ...state,
+                error: action.error,
+                loading: false,
+            };
+        }
+        default:
+            return state;
+    }
+};
+
+export function getSchemaAcl({path}) {
+    return createApiRequest({
+        request: window.api.getSchemaAcl({path}),
+        actions: FETCH_SCHEMA_ACL,
+    });
+}
+
+export default schemaAcl;

package/dist/store/reducers/settings.js

@@ -0,0 +1,76 @@
+import {ALL, defaultUserSettings, SAVED_QUERIES_KEY, THEME_KEY} from '../../utils/constants';
+import '../../services/api';
+import {getValueFromLS} from '../../utils/utils';
+
+const CHANGE_PROBLEM_FILTER = 'settings/CHANGE_PROBLEM_FILTER';
+const SET_SETTING_VALUE = 'settings/SET_VALUE';
+
+const userSettings = window.userSettings || {};
+const systemSettings = window.systemSettings || {};
+const theme = window.web_version
+    ? userSettings.theme || 'light'
+    : getValueFromLS(THEME_KEY, 'light');
+const savedQueries = window.web_version
+    ? userSettings[SAVED_QUERIES_KEY]
+    : getValueFromLS(SAVED_QUERIES_KEY, '[]');
+
+export const initialState = {
+    problemFilter: ALL,
+    userSettings: {
+        ...defaultUserSettings,
+        ...userSettings,
+        theme,
+        [SAVED_QUERIES_KEY]: savedQueries,
+    },
+    systemSettings,
+};
+
+const settings = (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,
+            };
+        }
+
+        default:
+            return state;
+    }
+};
+
+export const setSettingValue = (name, value) => {
+    return (dispatch, getState) => {
+        dispatch({type: SET_SETTING_VALUE, data: {name, value}});
+        const {singleClusterMode} = getState();
+        if (singleClusterMode) {
+            localStorage.setItem(name, value);
+        } else {
+            window.api.postSetting(name, value);
+        }
+    };
+};
+
+export const getSettingValue = (state, name) => {
+    return state.settings.userSettings[name];
+};
+
+export const changeFilter = (filter) => {
+    return {
+        type: CHANGE_PROBLEM_FILTER,
+        data: filter,
+    };
+};
+
+export default settings;