ydb-embedded-ui 4.32.0 → 5.0.0

package/dist/store/reducers/clusters/selectors.js

@@ -0,0 +1,106 @@
+import { createSelector } from 'reselect';
+import { escapeRegExp } from 'lodash/fp';
+import { getMinorVersion } from '../../../utils/versions';
+// ==== Filters ====
+const isMatchesByStatus = (clusterData, selectedStatuses) => {
+    return (selectedStatuses.length === 0 ||
+        (clusterData.status && selectedStatuses.includes(clusterData.status)));
+};
+const isMatchesByService = (clusterData, selectedServices) => {
+    return (selectedServices.length === 0 ||
+        (clusterData.service && selectedServices.includes(clusterData.service)));
+};
+const isMatchesByVersion = (clusterData, selectedVersions) => {
+    return (selectedVersions.length === 0 ||
+        selectedVersions.some((selectedVersion) => {
+            var _a, _b;
+            return (_b = (_a = clusterData.cluster) === null || _a === void 0 ? void 0 : _a.Versions) === null || _b === void 0 ? void 0 : _b.some((clusterVersion) => clusterVersion.startsWith(selectedVersion));
+        }));
+};
+const isMatchesByTextQuery = (clusterData, searchQuery = '') => {
+    var _a;
+    if (!searchQuery) {
+        return true;
+    }
+    const preparedSearchQuery = searchQuery.toLowerCase();
+    const searchTokens = preparedSearchQuery.split(' ');
+    // splits a string into words, treating digits as a separate word
+    // 'my_cluster env-dev vla03' => ['my', 'cluster', 'env', 'dev', 'vla', '03']
+    const splitRegExp = /[^\d\s]+|\d+|[^-\s]+|[^_\s]+/g;
+    const clusterNameParts = ((_a = clusterData.title) === null || _a === void 0 ? void 0 : _a.toLowerCase().match(splitRegExp)) || [];
+    const filteredByName = searchTokens.every((token) => {
+        const escapedToken = escapeRegExp(token);
+        const startsWithTokenRegExp = new RegExp(`^${escapedToken}|[\\s\\-_]${escapedToken}`, 'i');
+        // both tests are required so that both searches '03' and 'vla03' would match 'YDB DEV VLA03'
+        return ((clusterData.title && startsWithTokenRegExp.test(clusterData.title)) ||
+            clusterNameParts.some((name) => name.startsWith(token)));
+    });
+    const filteredByVersion = clusterData.preparedVersions.some((item) => item.version.includes(preparedSearchQuery));
+    const filteredByHost = Boolean(clusterData.hosts && clusterData.hosts[preparedSearchQuery]);
+    return filteredByName || filteredByVersion || filteredByHost;
+};
+// ==== Simple selectors ====
+export const selectLoadingFlag = (state) => state.clusters.loading;
+export const selectClustersList = (state) => state.clusters.list;
+export const selectClusterNameFilter = (state) => state.clusters.clusterName;
+export const selectStatusFilter = (state) => state.clusters.status;
+export const selectServiceFilter = (state) => state.clusters.service;
+export const selectVersionFilter = (state) => state.clusters.version;
+// ==== Complex selectors ====
+export const selectVersions = createSelector(selectClustersList, (clusters) => {
+    const uniqVersions = new Set();
+    clusters
+        .map(({ cluster }) => cluster === null || cluster === void 0 ? void 0 : cluster.Versions)
+        .forEach((clusterVersions) => clusterVersions === null || clusterVersions === void 0 ? void 0 : clusterVersions.forEach((version) => {
+        uniqVersions.add(getMinorVersion(version));
+    }));
+    return Array.from(uniqVersions).map((version) => ({
+        value: version,
+        content: version,
+    }));
+});
+export const selectFilteredClusters = createSelector([
+    selectClustersList,
+    selectClusterNameFilter,
+    selectStatusFilter,
+    selectServiceFilter,
+    selectVersionFilter,
+], (clusters, textSearchQuery, selectedStatuses, selectedServices, selectedVersions) => {
+    return clusters.filter((cluster) => {
+        return (isMatchesByStatus(cluster, selectedStatuses) &&
+            isMatchesByService(cluster, selectedServices) &&
+            isMatchesByVersion(cluster, selectedVersions) &&
+            isMatchesByTextQuery(cluster, textSearchQuery));
+    });
+});
+export const selectClustersAggregation = createSelector(selectFilteredClusters, (clusters) => {
+    let NodesTotal = 0, NodesAlive = 0, LoadAverage = 0, NumberOfCpus = 0, StorageUsed = 0, StorageTotal = 0, Tenants = 0;
+    const Hosts = new Set();
+    const filteredClusters = clusters.filter(({ cluster }) => !(cluster === null || cluster === void 0 ? void 0 : cluster.error));
+    filteredClusters.forEach(({ cluster, hosts = {} }) => {
+        NodesTotal += (cluster === null || cluster === void 0 ? void 0 : cluster.NodesTotal) || 0;
+        NodesAlive += (cluster === null || cluster === void 0 ? void 0 : cluster.NodesAlive) || 0;
+        Object.keys(hosts).forEach((host) => Hosts.add(host));
+        Tenants += Number(cluster === null || cluster === void 0 ? void 0 : cluster.Tenants) || 0;
+        LoadAverage += Number(cluster === null || cluster === void 0 ? void 0 : cluster.LoadAverage) || 0;
+        NumberOfCpus += (cluster === null || cluster === void 0 ? void 0 : cluster.NumberOfCpus) || 0;
+        StorageUsed += (cluster === null || cluster === void 0 ? void 0 : cluster.StorageUsed) ? Math.floor(parseInt(cluster.StorageUsed, 10)) : 0;
+        StorageTotal += (cluster === null || cluster === void 0 ? void 0 : cluster.StorageTotal)
+            ? Math.floor(parseInt(cluster.StorageTotal, 10))
+            : 0;
+    });
+    return {
+        NodesTotal,
+        NodesAlive,
+        Hosts: Hosts.size,
+        Tenants,
+        LoadAverage,
+        NumberOfCpus,
+        StorageUsed,
+        StorageTotal,
+    };
+});
+export const selectClusterInfo = createSelector(selectClustersList, (_, clusterName) => clusterName, (clusters, clusterName) => {
+    const info = clusters.filter((item) => item.name === clusterName)[0] || {};
+    return info;
+});

package/dist/store/reducers/clusters/types.d.ts

@@ -0,0 +1,32 @@
+import type { ApiRequestAction } from '../../utils';
+import type { MetaExtendedClusterInfo } from '../../../types/api/meta';
+import type { ExtendedMetaClusterVersion } from '../../../utils/clusterVersionColors';
+import { FETCH_CLUSTERS, changeClustersFilters } from './clusters';
+export interface PreparedCluster extends MetaExtendedClusterInfo {
+    preparedVersions: ExtendedMetaClusterVersion[];
+}
+export interface ClusterDataAggregation {
+    NodesTotal: number;
+    NodesAlive: number;
+    Hosts: number;
+    Tenants: number;
+    LoadAverage: number;
+    NumberOfCpus: number;
+    StorageUsed: number;
+    StorageTotal: number;
+}
+export interface ClustersFilters {
+    status: string[];
+    service: string[];
+    version: string[];
+    clusterName: string;
+}
+export interface ClustersState extends ClustersFilters {
+    loading: boolean;
+    error?: unknown;
+    list: PreparedCluster[];
+}
+export declare type ClustersAction = ApiRequestAction<typeof FETCH_CLUSTERS, PreparedCluster[], unknown> | ReturnType<typeof changeClustersFilters>;
+export interface ClustersStateSlice {
+    clusters: ClustersState;
+}

package/dist/store/reducers/clusters/types.js

@@ -0,0 +1 @@
+export {};

package/dist/store/reducers/clusters/utils.d.ts

@@ -0,0 +1,3 @@
+import type { MetaClusters } from '../../../types/api/meta';
+import type { PreparedCluster } from './types';
+export declare const prepareClustersData: (data: MetaClusters) => PreparedCluster[];

package/dist/store/reducers/clusters/utils.js

@@ -0,0 +1,13 @@
+import { getVersionColors, getVersionMap, prepareClusterVersions, } from '../../../utils/clusterVersionColors';
+export const prepareClustersData = (data) => {
+    const { clusters = [] } = data;
+    let allMinorVersions = new Map();
+    // Collect all clusters minor versions
+    clusters.forEach(({ versions = [] }) => {
+        allMinorVersions = getVersionMap(versions, allMinorVersions);
+    });
+    // Get colors map for all clusters colors
+    const versionToColor = getVersionColors(allMinorVersions);
+    // Apply color map to every cluster in the list
+    return clusters.map((cluster) => (Object.assign(Object.assign({}, cluster), { preparedVersions: prepareClusterVersions(cluster.versions, versionToColor) })));
+};

package/dist/store/reducers/describe.d.ts

@@ -0,0 +1,20 @@
+import { Reducer } from 'redux';
+import type { IDescribeState, IDescribeAction, IDescribeHandledResponse } from '../../types/store/describe';
+export declare const FETCH_DESCRIBE: {
+    readonly REQUEST: "describe/FETCH_DESCRIBE_REQUEST";
+    readonly SUCCESS: "describe/FETCH_DESCRIBE_SUCCESS";
+    readonly FAILURE: "describe/FETCH_DESCRIBE_FAILURE";
+};
+declare const describe: Reducer<IDescribeState, IDescribeAction>;
+export declare const setCurrentDescribePath: (path: string) => {
+    readonly type: "describe/SET_CURRENT_DESCRIBE_PATH";
+    readonly data: string;
+};
+export declare const setDataWasNotLoaded: () => {
+    readonly type: "describe/SET_DATA_WAS_NOT_LOADED";
+};
+export declare function getDescribe({ path }: {
+    path: string;
+}): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<IDescribeHandledResponse | undefined>;
+export declare function getDescribeBatched(paths: string[]): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<IDescribeHandledResponse | undefined>;
+export default describe;

package/dist/store/reducers/describe.js

@@ -0,0 +1,97 @@
+import { createRequestActionTypes, createApiRequest } from '../utils';
+export const FETCH_DESCRIBE = createRequestActionTypes('describe', 'FETCH_DESCRIBE');
+const SET_CURRENT_DESCRIBE_PATH = 'describe/SET_CURRENT_DESCRIBE_PATH';
+const SET_DATA_WAS_NOT_LOADED = 'describe/SET_DATA_WAS_NOT_LOADED';
+const initialState = {
+    loading: false,
+    wasLoaded: false,
+    data: {},
+    currentDescribe: undefined,
+    currentDescribePath: undefined,
+};
+const describe = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_DESCRIBE.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_DESCRIBE.SUCCESS: {
+            const isCurrentDescribePath = action.data.path === state.currentDescribePath;
+            const newData = Object.assign(Object.assign({}, state.data), action.data.data);
+            if (!isCurrentDescribePath) {
+                return Object.assign(Object.assign({}, state), { data: newData });
+            }
+            return Object.assign(Object.assign({}, state), { data: newData, currentDescribe: action.data.currentDescribe, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_DESCRIBE.FAILURE: {
+            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
+                return state;
+            }
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case SET_CURRENT_DESCRIBE_PATH: {
+            return Object.assign(Object.assign({}, state), { currentDescribePath: action.data });
+        }
+        case SET_DATA_WAS_NOT_LOADED: {
+            return Object.assign(Object.assign({}, state), { wasLoaded: false });
+        }
+        default:
+            return state;
+    }
+};
+export const setCurrentDescribePath = (path) => {
+    return {
+        type: SET_CURRENT_DESCRIBE_PATH,
+        data: path,
+    };
+};
+export const setDataWasNotLoaded = () => {
+    return {
+        type: SET_DATA_WAS_NOT_LOADED,
+    };
+};
+export function getDescribe({ path }) {
+    const request = window.api.getDescribe({ path });
+    return createApiRequest({
+        request,
+        actions: FETCH_DESCRIBE,
+        dataHandler: (data) => {
+            const dataPath = data.Path;
+            const currentDescribe = {};
+            const newData = {};
+            if (dataPath) {
+                currentDescribe[dataPath] = data;
+                newData[dataPath] = data;
+            }
+            return {
+                path: dataPath,
+                currentDescribe,
+                data: newData,
+            };
+        },
+    });
+}
+export function getDescribeBatched(paths) {
+    const requestsArray = paths.map((p) => window.api.getDescribe({ path: p }));
+    const request = Promise.all(requestsArray);
+    return createApiRequest({
+        request,
+        actions: FETCH_DESCRIBE,
+        dataHandler: (data) => {
+            const currentDescribe = {};
+            const newData = {};
+            data.forEach((dataItem) => {
+                if (dataItem.Path) {
+                    newData[dataItem.Path] = dataItem;
+                    currentDescribe[dataItem.Path] = dataItem;
+                }
+            });
+            return {
+                path: data[0].Path,
+                currentDescribe,
+                data: newData,
+            };
+        },
+    });
+}
+export default describe;

package/dist/store/reducers/executeQuery.d.ts

@@ -0,0 +1,51 @@
+import type { Reducer } from 'redux';
+import type { Schemas } from '../../types/api/query';
+import type { ExecuteQueryAction, ExecuteQueryState, ExecuteQueryStateSlice, MonacoHotKeyAction, QueryInHistory } from '../../types/store/executeQuery';
+import type { QueryRequestParams, QueryMode } from '../../types/store/query';
+export declare const SEND_QUERY: {
+    readonly REQUEST: "query/SEND_QUERY_REQUEST";
+    readonly SUCCESS: "query/SEND_QUERY_SUCCESS";
+    readonly FAILURE: "query/SEND_QUERY_FAILURE";
+};
+export declare const MONACO_HOT_KEY_ACTIONS: {
+    readonly sendQuery: "sendQuery";
+    readonly goPrev: "goPrev";
+    readonly goNext: "goNext";
+};
+declare const executeQuery: Reducer<ExecuteQueryState, ExecuteQueryAction>;
+interface SendQueryParams extends QueryRequestParams {
+    mode?: QueryMode;
+    schema?: Schemas;
+}
+export declare const sendExecuteQuery: ({ query, database, mode, schema }: SendQueryParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<import("../../types/store/query").IQueryResult | undefined>;
+export declare const saveQueryToHistory: (queryText: string, mode: QueryMode) => {
+    readonly type: "query/SAVE_QUERY_TO_HISTORY";
+    readonly data: {
+        readonly queryText: string;
+        readonly mode: QueryMode;
+    };
+};
+export declare const goToPreviousQuery: () => {
+    readonly type: "query/GO_TO_PREVIOUS_QUERY";
+};
+export declare const goToNextQuery: () => {
+    readonly type: "query/GO_TO_NEXT_QUERY";
+};
+export declare const changeUserInput: ({ input }: {
+    input: string;
+}) => {
+    readonly type: "query/CHANGE_USER_INPUT";
+    readonly data: {
+        readonly input: string;
+    };
+};
+export declare const setMonacoHotKey: (value: MonacoHotKeyAction | null) => {
+    readonly type: "query/SET_MONACO_HOT_KEY";
+    readonly data: MonacoHotKeyAction | null;
+};
+export declare const setTenantPath: (value: string) => {
+    readonly type: "query/SET_TENANT_PATH";
+    readonly data: string;
+};
+export declare const selectQueriesHistory: (state: ExecuteQueryStateSlice) => QueryInHistory[];
+export default executeQuery;

package/dist/store/reducers/executeQuery.js

@@ -0,0 +1,144 @@
+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 { 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, []);
+const sliceLimit = queriesHistoryInitial.length - MAXIMUM_QUERIES_IN_HISTORY;
+export const MONACO_HOT_KEY_ACTIONS = {
+    sendQuery: 'sendQuery',
+    goPrev: 'goPrev',
+    goNext: 'goNext',
+};
+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 = (state = initialState, action) => {
+    switch (action.type) {
+        case SEND_QUERY.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, data: undefined, error: undefined });
+        }
+        case SEND_QUERY.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, stats: action.data.stats, loading: false, error: undefined });
+        }
+        case SEND_QUERY.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: parseQueryError(action.error), loading: false });
+        }
+        case CHANGE_USER_INPUT: {
+            return Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { history: {
+                    queries: newQueries,
+                    currentIndex,
+                } });
+        }
+        case GO_TO_PREVIOUS_QUERY: {
+            const newCurrentIndex = Math.max(0, state.history.currentIndex - 1);
+            return Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, 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 Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, state.history), { currentIndex: newCurrentIndex }) });
+        }
+        case SET_MONACO_HOT_KEY: {
+            return Object.assign(Object.assign({}, state), { monacoHotKey: action.data });
+        }
+        case SET_TENANT_PATH: {
+            return Object.assign(Object.assign({}, state), { tenantPath: action.data });
+        }
+        default:
+            return state;
+    }
+};
+export const sendExecuteQuery = ({ query, database, mode, schema = 'modern' }) => {
+    let action = 'execute';
+    let syntax = 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, mode) => {
+    return {
+        type: SAVE_QUERY_TO_HISTORY,
+        data: { queryText, mode },
+    };
+};
+export const goToPreviousQuery = () => {
+    return {
+        type: GO_TO_PREVIOUS_QUERY,
+    };
+};
+export const goToNextQuery = () => {
+    return {
+        type: GO_TO_NEXT_QUERY,
+    };
+};
+export const changeUserInput = ({ input }) => {
+    return {
+        type: CHANGE_USER_INPUT,
+        data: { input },
+    };
+};
+export const setMonacoHotKey = (value) => {
+    return {
+        type: SET_MONACO_HOT_KEY,
+        data: value,
+    };
+};
+export const setTenantPath = (value) => {
+    return {
+        type: SET_TENANT_PATH,
+        data: value,
+    };
+};
+export const selectQueriesHistory = (state) => {
+    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.d.ts

@@ -0,0 +1,25 @@
+import type { AnyAction, Reducer } from 'redux';
+import type { ThunkAction } from 'redux-thunk';
+import type { IQueryResult } from '../../../types/store/query';
+import type { RootState } from '..';
+import type { ITopQueriesAction, ITopQueriesFilters, ITopQueriesState } from './types';
+export declare const FETCH_TOP_QUERIES: {
+    readonly REQUEST: "top-queries/FETCH_TOP_QUERIES_REQUEST";
+    readonly SUCCESS: "top-queries/FETCH_TOP_QUERIES_SUCCESS";
+    readonly FAILURE: "top-queries/FETCH_TOP_QUERIES_FAILURE";
+};
+declare const executeTopQueries: Reducer<ITopQueriesState, ITopQueriesAction>;
+declare type FetchTopQueries = (params: {
+    database: string;
+    filters?: ITopQueriesFilters;
+}) => ThunkAction<Promise<IQueryResult | undefined>, RootState, unknown, AnyAction>;
+export declare const fetchTopQueries: FetchTopQueries;
+export declare function setTopQueriesState(state: Partial<ITopQueriesState>): {
+    readonly type: "top-queries/SET_TOP_QUERIES_STATE";
+    readonly data: Partial<ITopQueriesState>;
+};
+export declare function setTopQueriesFilters(filters: Partial<ITopQueriesFilters>): {
+    readonly type: "top-queries/SET_TOP_QUERIES_FILTERS";
+    readonly filters: Partial<ITopQueriesFilters>;
+};
+export default executeTopQueries;

package/dist/store/reducers/executeTopQueries/executeTopQueries.js

@@ -0,0 +1,71 @@
+import { parseQueryAPIExecuteResponse } from '../../../utils/query';
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+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, filters) => {
+    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 = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_TOP_QUERIES.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true, error: undefined });
+        }
+        case FETCH_TOP_QUERIES.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { data: action.data, loading: false, error: undefined, wasLoaded: true });
+        }
+        // 401 Unauthorized error is handled by GenericAPI
+        case FETCH_TOP_QUERIES.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error || 'Unauthorized', loading: false });
+        }
+        case SET_TOP_QUERIES_STATE:
+            return Object.assign(Object.assign({}, state), action.data);
+        case SET_TOP_QUERIES_FILTERS:
+            return Object.assign(Object.assign({}, state), { filters: Object.assign(Object.assign({}, state.filters), action.filters) });
+        default:
+            return state;
+    }
+};
+export const 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) {
+    return {
+        type: SET_TOP_QUERIES_STATE,
+        data: state,
+    };
+}
+export function setTopQueriesFilters(filters) {
+    return {
+        type: SET_TOP_QUERIES_FILTERS,
+        filters,
+    };
+}
+export default executeTopQueries;

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

@@ -0,0 +1,21 @@
+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 declare 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/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,2 @@
+import { ITopQueriesFilters } from './types';
+export declare function getFiltersConditions(path: string, filters?: ITopQueriesFilters): string;

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

@@ -0,0 +1,27 @@
+const getMaxIntervalSubquery = (path) => `(
+    SELECT
+        MAX(IntervalEnd)
+    FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
+)`;
+export function getFiltersConditions(path, filters) {
+    const conditions = [];
+    if ((filters === null || filters === void 0 ? void 0 : filters.from) && (filters === null || filters === void 0 ? void 0 : filters.to) && filters.from > filters.to) {
+        throw new Error('Invalid date range');
+    }
+    if (filters === null || filters === void 0 ? void 0 : 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 === null || filters === void 0 ? void 0 : filters.to) {
+        conditions.push(`IntervalEnd <= Timestamp('${new Date(filters.to).toISOString()}')`);
+    }
+    if (!(filters === null || filters === void 0 ? void 0 : filters.from) && !(filters === null || filters === void 0 ? void 0 : filters.to)) {
+        conditions.push(`IntervalEnd IN ${getMaxIntervalSubquery(path)}`);
+    }
+    if (filters === null || filters === void 0 ? void 0 : filters.text) {
+        conditions.push(`QueryText ILIKE '%${filters.text}%'`);
+    }
+    return conditions.join(' AND ');
+}

package/dist/store/reducers/explainQuery.d.ts

@@ -0,0 +1,23 @@
+import type { Reducer } from 'redux';
+import type { ExplainQueryAction, ExplainQueryState, PreparedExplainResponse } from '../../types/store/explainQuery';
+import type { QueryRequestParams, QueryMode } from '../../types/store/query';
+export declare const GET_EXPLAIN_QUERY: {
+    readonly REQUEST: "query/GET_EXPLAIN_QUERY_REQUEST";
+    readonly SUCCESS: "query/GET_EXPLAIN_QUERY_SUCCESS";
+    readonly FAILURE: "query/GET_EXPLAIN_QUERY_FAILURE";
+};
+export declare const GET_EXPLAIN_QUERY_AST: {
+    readonly REQUEST: "query/GET_EXPLAIN_QUERY_AST_REQUEST";
+    readonly SUCCESS: "query/GET_EXPLAIN_QUERY_AST_SUCCESS";
+    readonly FAILURE: "query/GET_EXPLAIN_QUERY_AST_FAILURE";
+};
+declare const explainQuery: Reducer<ExplainQueryState, ExplainQueryAction>;
+export declare const getExplainQueryAst: ({ query, database }: QueryRequestParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<import("../../types/store/query").IQueryResult | undefined>;
+export declare const explainVersions: {
+    v2: string;
+};
+interface ExplainQueryParams extends QueryRequestParams {
+    mode?: QueryMode;
+}
+export declare const getExplainQuery: ({ query, database, mode }: ExplainQueryParams) => (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import(".").GetState) => Promise<PreparedExplainResponse | undefined>;
+export default explainQuery;