ydb-embedded-ui 4.33.0 → 5.0.0

package/dist/store/reducers/authentication/authentication.js

@@ -0,0 +1,50 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+export const SET_UNAUTHENTICATED = createRequestActionTypes('authentication', 'SET_UNAUTHENTICATED');
+export const SET_AUTHENTICATED = createRequestActionTypes('authentication', 'SET_AUTHENTICATED');
+export const FETCH_USER = createRequestActionTypes('authentication', 'FETCH_USER');
+const initialState = {
+    isAuthenticated: true,
+    user: '',
+    error: undefined,
+};
+const authentication = (state = initialState, action) => {
+    switch (action.type) {
+        case SET_UNAUTHENTICATED.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { isAuthenticated: false, user: '', error: undefined });
+        }
+        case SET_AUTHENTICATED.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { isAuthenticated: true, error: undefined });
+        }
+        case SET_AUTHENTICATED.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error });
+        }
+        case FETCH_USER.SUCCESS: {
+            return Object.assign(Object.assign({}, state), { user: action.data });
+        }
+        default:
+            return Object.assign({}, state);
+    }
+};
+export const authenticate = (user, password) => {
+    return createApiRequest({
+        request: window.api.authenticate(user, password),
+        actions: SET_AUTHENTICATED,
+    });
+};
+export const logout = () => {
+    return createApiRequest({
+        request: window.api.logout(),
+        actions: SET_UNAUTHENTICATED,
+    });
+};
+export const getUser = () => {
+    return createApiRequest({
+        request: window.api.whoami(),
+        actions: FETCH_USER,
+        dataHandler: (data) => {
+            const { UserSID, AuthType } = data;
+            return AuthType === 'Login' ? UserSID : undefined;
+        },
+    });
+};
+export default authentication;

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

@@ -0,0 +1,9 @@
+import type { AuthErrorResponse } from '../../../types/api/error';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_USER, SET_AUTHENTICATED, SET_UNAUTHENTICATED } from './authentication';
+export interface AuthenticationState {
+    isAuthenticated: boolean;
+    user: string | undefined;
+    error: AuthErrorResponse | undefined;
+}
+export declare type AuthenticationAction = ApiRequestAction<typeof SET_UNAUTHENTICATED, unknown, unknown> | ApiRequestAction<typeof SET_AUTHENTICATED, unknown, AuthErrorResponse> | ApiRequestAction<typeof FETCH_USER, string | undefined, unknown>;

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

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

package/dist/store/reducers/cluster/__test__/parseGroupsStatsQueryResponse.test.d.ts

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

package/dist/store/reducers/cluster/__test__/parseGroupsStatsQueryResponse.test.js

@@ -0,0 +1,117 @@
+import { parseGroupsStatsQueryResponse } from '../utils';
+describe('parseGroupsStatsQueryResponse', () => {
+    const columns = [
+        {
+            name: 'PDiskFilter',
+            type: 'Utf8?',
+        },
+        {
+            name: 'ErasureSpecies',
+            type: 'Utf8?',
+        },
+        {
+            name: 'CurrentAvailableSize',
+            type: 'Uint64?',
+        },
+        {
+            name: 'CurrentAllocatedSize',
+            type: 'Uint64?',
+        },
+        {
+            name: 'CurrentGroupsCreated',
+            type: 'Uint32?',
+        },
+        {
+            name: 'AvailableGroupsToCreate',
+            type: 'Uint32?',
+        },
+    ];
+    // 2 disk types and 2 erasure types
+    const dataSet1 = {
+        columns,
+        result: [
+            ['Type:SSD', 'block-4-2', '1000', '2000', 100, 50],
+            ['Type:ROT', 'block-4-2', '2000', '1000', 50, 0],
+            ['Type:ROT', 'mirror-3of4', '1000', '0', 15, 0],
+            ['Type:SSD', 'mirror-3of4', '1000', '0', 5, 50],
+            ['Type:ROT', 'mirror-3-dc', null, null, null, 0],
+            ['Type:SSD', 'mirror-3-dc', null, null, null, 0],
+        ],
+    };
+    // 2 disk types and 1 erasure types, but with additional disks params
+    const dataSet2 = {
+        columns,
+        result: [
+            ['Type:ROT,SharedWithOs:0,ReadCentric:0,Kind:0', 'mirror-3-dc', '1000', '500', 16, 16],
+            ['Type:ROT,SharedWithOs:1,ReadCentric:0,Kind:0', 'mirror-3-dc', '2000', '1000', 8, 24],
+            ['Type:SSD', 'mirror-3-dc', '3000', '400', 2, 10],
+            ['Type:ROT', 'mirror-3-dc', null, null, null, 32],
+            ['Type:ROT', 'block-4-2', null, null, null, 20],
+            ['Type:SSD', 'block-4-2', null, null, null, 0],
+        ],
+    };
+    const parsedDataSet1 = {
+        SSD: {
+            'block-4-2': {
+                diskType: 'SSD',
+                erasure: 'block-4-2',
+                createdGroups: 100,
+                totalGroups: 150,
+                allocatedSize: 2000,
+                availableSize: 1000,
+            },
+            'mirror-3of4': {
+                diskType: 'SSD',
+                erasure: 'mirror-3of4',
+                createdGroups: 5,
+                totalGroups: 55,
+                allocatedSize: 0,
+                availableSize: 1000,
+            },
+        },
+        HDD: {
+            'block-4-2': {
+                diskType: 'HDD',
+                erasure: 'block-4-2',
+                createdGroups: 50,
+                totalGroups: 50,
+                allocatedSize: 1000,
+                availableSize: 2000,
+            },
+            'mirror-3of4': {
+                diskType: 'HDD',
+                erasure: 'mirror-3of4',
+                createdGroups: 15,
+                totalGroups: 15,
+                allocatedSize: 0,
+                availableSize: 1000,
+            },
+        },
+    };
+    const parsedDataSet2 = {
+        HDD: {
+            'mirror-3-dc': {
+                diskType: 'HDD',
+                erasure: 'mirror-3-dc',
+                createdGroups: 24,
+                totalGroups: 64,
+                allocatedSize: 1500,
+                availableSize: 3000,
+            },
+        },
+        SSD: {
+            'mirror-3-dc': {
+                diskType: 'SSD',
+                erasure: 'mirror-3-dc',
+                createdGroups: 2,
+                totalGroups: 12,
+                allocatedSize: 400,
+                availableSize: 3000,
+            },
+        },
+    };
+    it('should correctly parse data', () => {
+        expect(parseGroupsStatsQueryResponse(dataSet1)).toEqual(parsedDataSet1);
+        expect(parseGroupsStatsQueryResponse(dataSet2)).toEqual(parsedDataSet2);
+    });
+});

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

@@ -0,0 +1,10 @@
+import type { Reducer } from 'redux';
+import type { ClusterAction, ClusterState } from './types';
+export declare const FETCH_CLUSTER: {
+    readonly REQUEST: "cluster/FETCH_CLUSTER_REQUEST";
+    readonly SUCCESS: "cluster/FETCH_CLUSTER_SUCCESS";
+    readonly FAILURE: "cluster/FETCH_CLUSTER_FAILURE";
+};
+declare const cluster: Reducer<ClusterState, ClusterAction>;
+export declare function getClusterInfo(clusterName?: string): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<unknown>;
+export default cluster;

package/dist/store/reducers/cluster/cluster.js

@@ -0,0 +1,66 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { createSelectClusterGroupsQuery, parseGroupsStatsQueryResponse } from './utils';
+export const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
+const initialState = { loading: true, wasLoaded: false };
+const cluster = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_CLUSTER.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_CLUSTER.SUCCESS: {
+            const { clusterData, groupsStats } = action.data;
+            return Object.assign(Object.assign({}, state), { data: clusterData, groupsStats, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_CLUSTER.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 });
+        }
+        default:
+            return state;
+    }
+};
+export function getClusterInfo(clusterName) {
+    async function requestClusterData() {
+        // Error here is handled by createApiRequest
+        const clusterData = await window.api.getClusterInfo(clusterName);
+        try {
+            const clusterRoot = clusterData.Domain;
+            // Without domain we cannot get stats from system tables
+            if (!clusterRoot) {
+                return {
+                    clusterData,
+                };
+            }
+            const query = createSelectClusterGroupsQuery(clusterRoot);
+            // Normally query request should be fulfilled within 300-400ms even on very big clusters
+            // Table with stats is supposed to be very small (less than 10 rows)
+            // So we batch this request with cluster request to prevent possible layout shifts, if data is missing
+            const groupsStatsResponse = await window.api.sendQuery({
+                schema: 'modern',
+                query: query,
+                database: clusterRoot,
+                action: 'execute-scan',
+            });
+            return {
+                clusterData,
+                groupsStats: parseGroupsStatsQueryResponse(groupsStatsResponse),
+            };
+        }
+        catch (_a) {
+            // Doesn't return groups stats on error
+            // It could happen if user doesn't have access rights
+            // Or there are no system tables in cluster root
+            return {
+                clusterData,
+            };
+        }
+    }
+    return createApiRequest({
+        request: requestClusterData(),
+        actions: FETCH_CLUSTER,
+    });
+}
+export default cluster;

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

@@ -0,0 +1,28 @@
+import type { TClusterInfo } from '../../../types/api/cluster';
+import type { IResponseError } from '../../../types/api/error';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_CLUSTER } from './cluster';
+export interface DiskErasureGroupsStats {
+    diskType: string;
+    erasure: string;
+    createdGroups: number;
+    totalGroups: number;
+    allocatedSize: number;
+    availableSize: number;
+}
+/** Keys - erasure types */
+export declare type DiskGroupsStats = Record<string, DiskErasureGroupsStats>;
+/** Keys - PDisks types */
+export declare type ClusterGroupsStats = Record<string, DiskGroupsStats>;
+export interface ClusterState {
+    loading: boolean;
+    wasLoaded: boolean;
+    data?: TClusterInfo;
+    error?: IResponseError;
+    groupsStats?: ClusterGroupsStats;
+}
+export interface HandledClusterResponse {
+    clusterData: TClusterInfo;
+    groupsStats: ClusterGroupsStats;
+}
+export declare type ClusterAction = ApiRequestAction<typeof FETCH_CLUSTER, HandledClusterResponse, IResponseError>;

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

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

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

@@ -0,0 +1,4 @@
+import type { ExecuteQueryResponse } from '../../../types/api/query';
+import type { ClusterGroupsStats } from './types';
+export declare const createSelectClusterGroupsQuery: (clusterRoot: string) => string;
+export declare const parseGroupsStatsQueryResponse: (data: ExecuteQueryResponse<'modern'>) => ClusterGroupsStats;

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

@@ -0,0 +1,68 @@
+import { parseQueryAPIExecuteResponse } from '../../../utils/query';
+export const createSelectClusterGroupsQuery = (clusterRoot) => {
+    return `
+SELECT 
+    PDiskFilter,
+    ErasureSpecies,
+    CurrentAvailableSize,
+    CurrentAllocatedSize,
+    CurrentGroupsCreated,
+    AvailableGroupsToCreate
+    FROM \`${clusterRoot}/.sys/ds_storage_stats\`
+    ORDER BY CurrentGroupsCreated DESC;
+`;
+};
+const getDiskType = (rawTypeString) => {
+    var _a, _b;
+    // Check if value math regexp and put disk type in type group
+    const diskTypeRe = /^Type:(?<type>[A-Za-z]+)/;
+    const diskType = (_b = (_a = rawTypeString.match(diskTypeRe)) === null || _a === void 0 ? void 0 : _a.groups) === null || _b === void 0 ? void 0 : _b['type'];
+    if (diskType === 'ROT') {
+        // Display ROT as HDD
+        return 'HDD';
+    }
+    return diskType;
+};
+export const parseGroupsStatsQueryResponse = (data) => {
+    const parsedData = parseQueryAPIExecuteResponse(data).result;
+    const result = {};
+    parsedData === null || parsedData === void 0 ? void 0 : parsedData.forEach((stats) => {
+        const { PDiskFilter, ErasureSpecies: erasure, CurrentAvailableSize, CurrentAllocatedSize, CurrentGroupsCreated, AvailableGroupsToCreate, } = stats;
+        const createdGroups = Number(CurrentGroupsCreated) || 0;
+        const availableGroupsToCreate = Number(AvailableGroupsToCreate) || 0;
+        const totalGroups = createdGroups + availableGroupsToCreate;
+        const allocatedSize = Number(CurrentAllocatedSize) || 0;
+        const availableSize = Number(CurrentAvailableSize) || 0;
+        const diskType = PDiskFilter && typeof PDiskFilter === 'string' && getDiskType(PDiskFilter);
+        if (diskType && erasure && typeof erasure === 'string' && createdGroups) {
+            const preparedStats = {
+                diskType,
+                erasure,
+                createdGroups,
+                totalGroups,
+                allocatedSize,
+                availableSize,
+            };
+            if (result[diskType]) {
+                if (result[diskType][erasure]) {
+                    const currentValue = Object.assign({}, result[diskType][erasure]);
+                    result[diskType][erasure] = {
+                        diskType,
+                        erasure,
+                        createdGroups: currentValue.createdGroups + createdGroups,
+                        totalGroups: currentValue.totalGroups + totalGroups,
+                        allocatedSize: currentValue.allocatedSize + allocatedSize,
+                        availableSize: currentValue.availableSize + availableSize,
+                    };
+                }
+                else {
+                    result[diskType][erasure] = preparedStats;
+                }
+            }
+            else {
+                result[diskType] = { [erasure]: preparedStats };
+            }
+        }
+    });
+    return result;
+};

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

@@ -0,0 +1,10 @@
+import { Reducer } from 'redux';
+import type { ClusterNodesAction, ClusterNodesState, PreparedClusterNode } from './types';
+export declare const FETCH_CLUSTER_NODES: {
+    readonly REQUEST: "cluster/FETCH_CLUSTER_NODES_REQUEST";
+    readonly SUCCESS: "cluster/FETCH_CLUSTER_NODES_SUCCESS";
+    readonly FAILURE: "cluster/FETCH_CLUSTER_NODES_FAILURE";
+};
+declare const clusterNodes: Reducer<ClusterNodesState, ClusterNodesAction>;
+export declare function getClusterNodes(): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<PreparedClusterNode[] | undefined>;
+export default clusterNodes;

package/dist/store/reducers/clusterNodes/clusterNodes.js

@@ -0,0 +1,37 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { calcUptime } from '../../../utils/dataFormatters/dataFormatters';
+export const FETCH_CLUSTER_NODES = createRequestActionTypes('cluster', 'FETCH_CLUSTER_NODES');
+const initialState = { loading: false, wasLoaded: false };
+const clusterNodes = (state = initialState, action) => {
+    var _a;
+    switch (action.type) {
+        case FETCH_CLUSTER_NODES.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_CLUSTER_NODES.SUCCESS: {
+            const { data = [] } = action;
+            return Object.assign(Object.assign({}, state), { nodes: data, loading: false, wasLoaded: true, error: undefined });
+        }
+        case FETCH_CLUSTER_NODES.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 });
+        }
+        default:
+            return state;
+    }
+};
+export function getClusterNodes() {
+    return createApiRequest({
+        request: window.api.getClusterNodes(),
+        actions: FETCH_CLUSTER_NODES,
+        dataHandler: (data) => {
+            const { SystemStateInfo: nodes = [] } = data;
+            return nodes.map((node) => {
+                return Object.assign(Object.assign({}, node), { uptime: calcUptime(node.StartTime) });
+            });
+        },
+    });
+}
+export default clusterNodes;

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

@@ -0,0 +1,14 @@
+import type { IResponseError } from '../../../types/api/error';
+import type { TSystemStateInfo } from '../../../types/api/nodes';
+import type { ApiRequestAction } from '../../utils';
+import { FETCH_CLUSTER_NODES } from './clusterNodes';
+export interface PreparedClusterNode extends TSystemStateInfo {
+    uptime: string;
+}
+export interface ClusterNodesState {
+    loading: boolean;
+    wasLoaded: boolean;
+    nodes?: PreparedClusterNode[];
+    error?: IResponseError;
+}
+export declare type ClusterNodesAction = ApiRequestAction<typeof FETCH_CLUSTER_NODES, PreparedClusterNode[], IResponseError>;

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

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

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

@@ -0,0 +1,14 @@
+import type { Reducer } from 'redux';
+import type { ClustersAction, ClustersFilters, ClustersState } from './types';
+export declare const FETCH_CLUSTERS: {
+    readonly REQUEST: "clusters/FETCH_CLUSTERS_REQUEST";
+    readonly SUCCESS: "clusters/FETCH_CLUSTERS_SUCCESS";
+    readonly FAILURE: "clusters/FETCH_CLUSTERS_FAILURE";
+};
+declare const clusters: Reducer<ClustersState, ClustersAction>;
+export declare function fetchClustersList(): (dispatch: import("redux").Dispatch<import("redux").AnyAction>, getState: import("..").GetState) => Promise<import("./types").PreparedCluster[] | undefined>;
+export declare function changeClustersFilters(filters: Partial<ClustersFilters>): {
+    readonly type: "clusters/CHANGE_FILTER";
+    readonly data: Partial<ClustersFilters>;
+};
+export default clusters;

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

@@ -0,0 +1,45 @@
+import { createRequestActionTypes, createApiRequest } from '../../utils';
+import { prepareClustersData } from './utils';
+export const FETCH_CLUSTERS = createRequestActionTypes('clusters', 'FETCH_CLUSTERS');
+const CHANGE_FILTERS = 'clusters/CHANGE_FILTER';
+const initialState = {
+    loading: false,
+    list: [],
+    clusterName: '',
+    status: [],
+    service: [],
+    version: [],
+};
+const clusters = (state = initialState, action) => {
+    switch (action.type) {
+        case FETCH_CLUSTERS.REQUEST: {
+            return Object.assign(Object.assign({}, state), { loading: true });
+        }
+        case FETCH_CLUSTERS.SUCCESS: {
+            const { data = [] } = action;
+            return Object.assign(Object.assign({}, state), { loading: false, list: data, error: undefined });
+        }
+        case FETCH_CLUSTERS.FAILURE: {
+            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
+        }
+        case CHANGE_FILTERS: {
+            return Object.assign(Object.assign({}, state), action.data);
+        }
+        default:
+            return state;
+    }
+};
+export function fetchClustersList() {
+    return createApiRequest({
+        request: window.api.getClustersList(),
+        actions: FETCH_CLUSTERS,
+        dataHandler: prepareClustersData,
+    });
+}
+export function changeClustersFilters(filters) {
+    return {
+        type: CHANGE_FILTERS,
+        data: filters,
+    };
+}
+export default clusters;

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

@@ -0,0 +1,22 @@
+import { type Selector } from 'reselect';
+import type { MetaExtendedClusterInfo } from '../../../types/api/meta';
+import type { ClusterDataAggregation, ClustersStateSlice, PreparedCluster } from './types';
+export declare const selectLoadingFlag: (state: ClustersStateSlice) => boolean;
+export declare const selectClustersList: (state: ClustersStateSlice) => PreparedCluster[];
+export declare const selectClusterNameFilter: (state: ClustersStateSlice) => string;
+export declare const selectStatusFilter: (state: ClustersStateSlice) => string[];
+export declare const selectServiceFilter: (state: ClustersStateSlice) => string[];
+export declare const selectVersionFilter: (state: ClustersStateSlice) => string[];
+export declare const selectVersions: Selector<ClustersStateSlice, {
+    value: string;
+    content: string;
+}[]>;
+export declare const selectFilteredClusters: Selector<ClustersStateSlice, PreparedCluster[]>;
+export declare const selectClustersAggregation: Selector<ClustersStateSlice, ClusterDataAggregation>;
+export declare const selectClusterInfo: ((state: {
+    clusters: import("./types").ClustersState;
+}, params_0: string) => MetaExtendedClusterInfo) & import("reselect").OutputSelectorFields<(args_0: PreparedCluster[], args_1: string) => MetaExtendedClusterInfo & {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};

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 {};