ydb-embedded-ui 6.3.0 → 6.5.0

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

@@ -3,7 +3,7 @@ import type { EVersion, TTabletStateInfo as TComputeTabletStateInfo } from '../.
 import type { EFlag } from '../../../types/api/enums';
 import type { TEndpoint, TPoolStats } from '../../../types/api/nodes';
 import type { TTabletStateInfo as TFullTabletStateInfo } from '../../../types/api/tablet';
-import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { NodesSortValue } from '../../../utils/nodes';
 import type { VisibleEntities } from '../storage/types';
 export interface NodesPreparedEntity {
     NodeId: number;
@@ -27,18 +27,12 @@ export interface NodesPreparedEntity {
     Endpoints?: TEndpoint[];
     TotalSessions?: number;
 }
-export interface NodesState {
-    uptimeFilter: NodesUptimeFilterValues;
-    searchValue: string;
-    sortValue?: NodesSortValue;
-    sortOrder?: OrderType;
-}
 export type NodeType = 'static' | 'dynamic' | 'any';
 export interface NodesSortParams {
-    sortOrder?: OrderType;
-    sortValue?: NodesSortValue;
+    sortOrder: OrderType | undefined;
+    sortValue: NodesSortValue | undefined;
 }
-export interface NodesGeneralRequestParams extends NodesSortParams {
+export interface NodesGeneralRequestParams extends Partial<NodesSortParams> {
     filter?: string;
     uptime?: number;
     problems_only?: boolean;
@@ -63,6 +57,3 @@ export interface NodesHandledResponse {
     TotalNodes: number;
     FoundNodes?: number;
 }
-export interface NodesStateSlice {
-    nodes: NodesState;
-}

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

@@ -5,10 +5,8 @@ export declare const nodesListApi: import("@reduxjs/toolkit/query").Api<import("
 export declare const selectNodesMap: ((state: {
     api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
-    nodes: import("./nodes/types").NodesState;
     cluster: import("./cluster/types").ClusterState;
     tenant: import("./tenant/types").TenantState;
-    storage: import("./storage/types").StorageState;
     tooltip: import("../../types/store/tooltip").ITooltipState;
     tablets: import("../../types/store/tablets").TabletsState;
     schema: import("./schema/types").SchemaState;
@@ -16,7 +14,6 @@ export declare const selectNodesMap: ((state: {
     tenants: import("./tenants/types").TenantsState;
     partitions: import("./partitions/types").PartitionsState;
     executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
         loading: boolean;
         requestTime: number;

package/dist/store/reducers/olapStats.js

@@ -1,4 +1,4 @@
-import { parseQueryAPIExecuteResponse } from '../../utils/query';
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../utils/query';
 import { api } from './api';
 function createOlatStatsQuery(path) {
     return `SELECT * FROM \`${path}/.sys/primary_index_stats\``;
@@ -15,6 +15,9 @@ export const olapApi = api.injectEndpoints({
                         database: path,
                         action: queryAction,
                     }, { signal });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
                     return { data: parseQueryAPIExecuteResponse(response) };
                 }
                 catch (error) {

package/dist/store/reducers/preview.js

@@ -1,4 +1,4 @@
-import { parseQueryAPIExecuteResponse } from '../../utils/query';
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../utils/query';
 import { api } from './api';
 export const previewApi = api.injectEndpoints({
     endpoints: (build) => ({
@@ -6,6 +6,9 @@ export const previewApi = api.injectEndpoints({
             queryFn: async ({ query, database, action }, { signal }) => {
                 try {
                     const response = await window.api.sendQuery({ schema: 'modern', query, database, action }, { signal });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
                     return { data: parseQueryAPIExecuteResponse(response) };
                 }
                 catch (error) {

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

@@ -18,13 +18,71 @@ export declare const initialState: {
 declare const schema: Reducer<SchemaState, SchemaAction>;
 export declare function getSchema({ path }: {
     path: string;
-}): (dispatch: Dispatch<import("redux").UnknownAction>, getState: () => {
+}): (dispatch: import("redux-thunk").ThunkDispatch<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("../cluster/types").ClusterState;
+    tenant: import("../tenant/types").TenantState;
+    tooltip: import("../../../types/store/tooltip").ITooltipState;
+    tablets: import("../../../types/store/tablets").TabletsState;
+    schema: SchemaState;
+    host: import("../../../types/store/host").IHostState;
+    tenants: import("../tenants/types").TenantsState;
+    partitions: import("../partitions/types").PartitionsState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../../types/store/heatmap").IHeatmapState;
+    settings: import("../settings/types").SettingsState;
+    schemaAcl: import("../schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("../hotKeys/types").HotKeysState;
+    authentication: import("../authentication/types").AuthenticationState;
+    header: import("../header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersFilters;
+}, undefined, import("redux").UnknownAction> & Dispatch<any>, getState: () => {
     api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
-    nodes: import("../nodes/types").NodesState;
     cluster: import("../cluster/types").ClusterState;
     tenant: import("../tenant/types").TenantState;
-    storage: import("../storage/types").StorageState;
     tooltip: import("../../../types/store/tooltip").ITooltipState;
     tablets: import("../../../types/store/tablets").TabletsState;
     schema: SchemaState;
@@ -32,7 +90,6 @@ export declare function getSchema({ path }: {
     tenants: import("../tenants/types").TenantsState;
     partitions: import("../partitions/types").PartitionsState;
     executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
         loading: boolean;
         requestTime: number;

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

@@ -8,13 +8,71 @@ export declare const FETCH_SCHEMA_ACL: {
 declare const schemaAcl: Reducer<SchemaAclState, SchemaAclAction>;
 export declare function getSchemaAcl({ path }: {
     path: string;
-}): (dispatch: import("redux").Dispatch<import("redux").UnknownAction>, getState: () => {
+}): (dispatch: import("redux-thunk").ThunkDispatch<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("../cluster/types").ClusterState;
+    tenant: import("../tenant/types").TenantState;
+    tooltip: import("../../../types/store/tooltip").ITooltipState;
+    tablets: import("../../../types/store/tablets").TabletsState;
+    schema: import("../schema/types").SchemaState;
+    host: import("../../../types/store/host").IHostState;
+    tenants: import("../tenants/types").TenantsState;
+    partitions: import("../partitions/types").PartitionsState;
+    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../../types/store/heatmap").IHeatmapState;
+    settings: import("../settings/types").SettingsState;
+    schemaAcl: SchemaAclState;
+    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("../hotKeys/types").HotKeysState;
+    authentication: import("../authentication/types").AuthenticationState;
+    header: import("../header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("../clusters/types").ClustersFilters;
+}, undefined, import("redux").UnknownAction> & import("redux").Dispatch<any>, getState: () => {
     api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
     singleClusterMode: boolean;
-    nodes: import("../nodes/types").NodesState;
     cluster: import("../cluster/types").ClusterState;
     tenant: import("../tenant/types").TenantState;
-    storage: import("../storage/types").StorageState;
     tooltip: import("../../../types/store/tooltip").ITooltipState;
     tablets: import("../../../types/store/tablets").TabletsState;
     schema: import("../schema/types").SchemaState;
@@ -22,7 +80,6 @@ export declare function getSchemaAcl({ path }: {
     tenants: import("../tenants/types").TenantsState;
     partitions: import("../partitions/types").PartitionsState;
     executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    explainQuery: import("../../../types/store/explainQuery").ExplainQueryState;
     tabletsFilters: {
         loading: boolean;
         requestTime: number;

package/dist/store/reducers/shardsWorkload/shardsWorkload.js

@@ -1,5 +1,5 @@
 import { createSlice } from '@reduxjs/toolkit';
-import { parseQueryAPIExecuteResponse } from '../../../utils/query';
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../../utils/query';
 import { api } from '../api';
 import { EShardsWorkloadMode } from './types';
 const initialState = {};
@@ -92,6 +92,9 @@ export const shardApi = api.injectEndpoints({
                     }, {
                         signal,
                     });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
                     const data = parseQueryAPIExecuteResponse(response);
                     return { data };
                 }

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

@@ -1,20 +1,5 @@
-import type { OrderType } from '@gravity-ui/react-data-table';
-import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
-import type { StorageSortValue } from '../../../utils/storage';
-import type { PreparedStorageGroup, PreparedStorageNode, StorageStateSlice, UsageFilter } from './types';
+import type { NodesUptimeFilterValues } from '../../../utils/nodes';
+import type { PreparedStorageGroup, PreparedStorageNode, UsageFilter } from './types';
 export declare function filterNodes(storageNodes: PreparedStorageNode[], textFilter: string, uptimeFilter: NodesUptimeFilterValues): PreparedStorageNode[];
 export declare function filterGroups(storageGroups: PreparedStorageGroup[], textFilter: string, usageFilter: string[]): PreparedStorageGroup[];
-export declare const selectStorageFilter: (state: StorageStateSlice) => string;
-export declare const selectUsageFilter: (state: StorageStateSlice) => string[];
-export declare const selectVisibleEntities: (state: StorageStateSlice) => import("./types").VisibleEntities;
-export declare const selectNodesUptimeFilter: (state: StorageStateSlice) => NodesUptimeFilterValues;
-export declare const selectStorageType: (state: StorageStateSlice) => import("./types").StorageType;
-export declare const selectNodesSortParams: (state: StorageStateSlice) => {
-    sortValue: NodesSortValue;
-    sortOrder: OrderType;
-};
-export declare const selectGroupsSortParams: (state: StorageStateSlice) => {
-    sortValue: StorageSortValue;
-    sortOrder: OrderType;
-};
 export declare function getUsageFilterOptions(groups: PreparedStorageGroup[]): UsageFilter[];

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

@@ -1,8 +1,5 @@
-import { ASCENDING, DESCENDING } from '@gravity-ui/react-data-table/build/esm/lib/constants';
-import { NODES_SORT_VALUES } from '../../../utils/nodes';
-import { STORAGE_SORT_VALUES, getUsage } from '../../../utils/storage';
+import { getUsage } from '../../../utils/storage';
 import { filterNodesByUptime } from '../nodes/selectors';
-import { VISIBLE_ENTITIES } from './constants';
 // ==== Filters ====
 const prepareSearchText = (text) => text.trim().toLowerCase();
 const filterNodesByText = (entities, text) => {
@@ -48,38 +45,6 @@ export function filterGroups(storageGroups, textFilter, usageFilter) {
     result = filterGroupsByUsage(result, usageFilter);
     return result;
 }
-// ==== Simple selectors ====
-export const selectStorageFilter = (state) => state.storage.filter;
-export const selectUsageFilter = (state) => state.storage.usageFilter;
-export const selectVisibleEntities = (state) => state.storage.visible;
-export const selectNodesUptimeFilter = (state) => state.storage.uptimeFilter;
-export const selectStorageType = (state) => state.storage.type;
-// ==== Sort params selectors ====
-export const selectNodesSortParams = (state) => {
-    const defaultSortValue = NODES_SORT_VALUES.NodeId;
-    const defaultSortOrder = ASCENDING;
-    return {
-        sortValue: state.storage.nodesSortValue || defaultSortValue,
-        sortOrder: state.storage.nodesSortOrder || defaultSortOrder,
-    };
-};
-export const selectGroupsSortParams = (state) => {
-    const visibleEntities = state.storage.visible;
-    let defaultSortValue = STORAGE_SORT_VALUES.PoolName;
-    let defaultSortOrder = ASCENDING;
-    if (visibleEntities === VISIBLE_ENTITIES.missing) {
-        defaultSortValue = STORAGE_SORT_VALUES.Degraded;
-        defaultSortOrder = DESCENDING;
-    }
-    if (visibleEntities === VISIBLE_ENTITIES.space) {
-        defaultSortValue = STORAGE_SORT_VALUES.Usage;
-        defaultSortOrder = DESCENDING;
-    }
-    return {
-        sortValue: state.storage.groupsSortValue || defaultSortValue,
-        sortOrder: state.storage.groupsSortOrder || defaultSortOrder,
-    };
-};
 // ==== Complex selectors ====
 export function getUsageFilterOptions(groups) {
     const items = {};

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

@@ -1,9 +1,5 @@
-import { NodesUptimeFilterValues } from '../../../utils/nodes';
-import type { NodesApiRequestParams, NodesSortParams } from '../nodes/types';
-import type { StorageApiRequestParams, StorageSortParams, StorageState, StorageType, VisibleEntities } from './types';
-declare const _default: import("redux").Reducer<StorageState>;
-export default _default;
-export declare const setInitialState: import("@reduxjs/toolkit").ActionCreatorWithoutPayload<"storage/setInitialState">, setStorageTextFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, "storage/setStorageTextFilter">, setUsageFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<string[], "storage/setUsageFilter">, setVisibleEntities: import("@reduxjs/toolkit").ActionCreatorWithPayload<VisibleEntities, "storage/setVisibleEntities">, setStorageType: import("@reduxjs/toolkit").ActionCreatorWithPayload<StorageType, "storage/setStorageType">, setUptimeFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<NodesUptimeFilterValues, "storage/setUptimeFilter">, setNodesSortParams: import("@reduxjs/toolkit").ActionCreatorWithPayload<NodesSortParams, "storage/setNodesSortParams">, setGroupsSortParams: import("@reduxjs/toolkit").ActionCreatorWithPayload<StorageSortParams, "storage/setGroupsSortParams">;
+import type { NodesApiRequestParams } from '../nodes/types';
+import type { StorageApiRequestParams } from './types';
 export declare const storageApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
     getStorageNodesInfo: import("@reduxjs/toolkit/query").QueryDefinition<Omit<NodesApiRequestParams, "type">, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PreparedStorageResponse | undefined, "api">;
     getStorageGroupsInfo: import("@reduxjs/toolkit/query").QueryDefinition<StorageApiRequestParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", import("./types").PreparedStorageResponse | undefined, "api">;

package/dist/store/reducers/storage/storage.js

@@ -1,50 +1,6 @@
-import { createSlice } from '@reduxjs/toolkit';
 import { EVersion } from '../../../types/api/storage';
-import { NodesUptimeFilterValues } from '../../../utils/nodes';
 import { api } from '../api';
-import { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
 import { prepareStorageGroupsResponse, prepareStorageNodesResponse } from './utils';
-const initialState = {
-    filter: '',
-    usageFilter: [],
-    visible: VISIBLE_ENTITIES.all,
-    uptimeFilter: NodesUptimeFilterValues.All,
-    type: STORAGE_TYPES.groups,
-};
-const slice = createSlice({
-    name: 'storage',
-    initialState,
-    reducers: {
-        setUptimeFilter: (state, action) => {
-            state.uptimeFilter = action.payload;
-        },
-        setStorageType: (state, action) => {
-            state.type = action.payload;
-        },
-        setStorageTextFilter: (state, action) => {
-            state.filter = action.payload;
-        },
-        setUsageFilter: (state, action) => {
-            state.usageFilter = action.payload;
-        },
-        setVisibleEntities: (state, action) => {
-            state.visible = action.payload;
-        },
-        setNodesSortParams: (state, action) => {
-            state.nodesSortValue = action.payload.sortValue;
-            state.nodesSortOrder = action.payload.sortOrder;
-        },
-        setGroupsSortParams: (state, action) => {
-            state.groupsSortValue = action.payload.sortValue;
-            state.groupsSortOrder = action.payload.sortOrder;
-        },
-        setInitialState: () => {
-            return initialState;
-        },
-    },
-});
-export default slice.reducer;
-export const { setInitialState, setStorageTextFilter, setUsageFilter, setVisibleEntities, setStorageType, setUptimeFilter, setNodesSortParams, setGroupsSortParams, } = slice.actions;
 export const storageApi = api.injectEndpoints({
     endpoints: (builder) => ({
         getStorageNodesInfo: builder.query({

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

@@ -1,13 +1,20 @@
 import type { OrderType } from '@gravity-ui/react-data-table';
+import { z } from 'zod';
 import type { TSystemStateInfo } from '../../../types/api/nodes';
 import type { EVersion, TStorageGroupInfo } from '../../../types/api/storage';
-import type { ValueOf } from '../../../types/common';
 import type { PreparedPDisk, PreparedVDisk } from '../../../utils/disks/types';
-import type { NodesSortValue, NodesUptimeFilterValues } from '../../../utils/nodes';
 import type { StorageSortValue } from '../../../utils/storage';
-import type { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
-export type VisibleEntities = ValueOf<typeof VISIBLE_ENTITIES>;
-export type StorageType = ValueOf<typeof STORAGE_TYPES>;
+export declare const visibleEntitiesSchema: z.ZodCatch<z.ZodNativeEnum<{
+    readonly all: "all";
+    readonly missing: "missing";
+    readonly space: "space";
+}>>;
+export type VisibleEntities = z.infer<typeof visibleEntitiesSchema>;
+export declare const storageTypeSchema: z.ZodCatch<z.ZodNativeEnum<{
+    readonly groups: "groups";
+    readonly nodes: "nodes";
+}>>;
+export type StorageType = z.infer<typeof storageTypeSchema>;
 export interface PreparedStorageNode extends TSystemStateInfo {
     NodeId: number;
     PDisks?: PreparedPDisk[];
@@ -34,10 +41,10 @@ export interface UsageFilter {
     count: number;
 }
 export interface StorageSortParams {
-    sortOrder?: OrderType;
-    sortValue?: StorageSortValue;
+    sortOrder: OrderType | undefined;
+    sortValue: StorageSortValue | undefined;
 }
-export interface StorageSortAndFilterParams extends StorageSortParams {
+export interface StorageSortAndFilterParams extends Partial<StorageSortParams> {
     filter?: string;
     offset?: number;
     limit?: number;
@@ -50,23 +57,9 @@ export interface StorageApiRequestParams extends StorageSortAndFilterParams {
     visibleEntities?: VisibleEntities;
     version?: EVersion;
 }
-export interface StorageState {
-    filter: string;
-    usageFilter: string[];
-    visible: VisibleEntities;
-    uptimeFilter: NodesUptimeFilterValues;
-    groupsSortValue?: StorageSortValue;
-    groupsSortOrder?: OrderType;
-    nodesSortValue?: NodesSortValue;
-    nodesSortOrder?: OrderType;
-    type: StorageType;
-}
 export interface PreparedStorageResponse {
     nodes?: PreparedStorageNode[];
     groups?: PreparedStorageGroup[];
     found: number | undefined;
     total: number | undefined;
 }
-export interface StorageStateSlice {
-    storage: StorageState;
-}

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

@@ -1 +1,4 @@
-export {};
+import { z } from 'zod';
+import { STORAGE_TYPES, VISIBLE_ENTITIES } from './constants';
+export const visibleEntitiesSchema = z.nativeEnum(VISIBLE_ENTITIES).catch(VISIBLE_ENTITIES.all);
+export const storageTypeSchema = z.nativeEnum(STORAGE_TYPES).catch(STORAGE_TYPES.groups);

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

@@ -1,8 +1,98 @@
-import type { ETabletState, EType } from '../../types/api/tablet';
+import type { ETabletState, EType, TTabletStateInfo } from '../../types/api/tablet';
 import type { TabletsApiRequestParams, TabletsState } from '../../types/store/tablets';
+import type { RootState } from '../defaultStore';
 export declare const setStateFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<ETabletState[], "tablets/setStateFilter">, setTypeFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<EType[], "tablets/setTypeFilter">;
 declare const _default: import("redux").Reducer<TabletsState>;
 export default _default;
 export declare const tabletsApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
     getTabletsInfo: import("@reduxjs/toolkit/query").QueryDefinition<TabletsApiRequestParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/tablet").TEvTabletStateResponse | undefined, "api">;
 }, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export declare const selectTabletsWithFqdn: ((state: {
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
+    singleClusterMode: boolean;
+    cluster: import("./cluster/types").ClusterState;
+    tenant: import("./tenant/types").TenantState;
+    tooltip: import("../../types/store/tooltip").ITooltipState;
+    tablets: TabletsState;
+    schema: import("./schema/types").SchemaState;
+    host: import("../../types/store/host").IHostState;
+    tenants: import("./tenants/types").TenantsState;
+    partitions: import("./partitions/types").PartitionsState;
+    executeQuery: import("../../types/store/executeQuery").ExecuteQueryState;
+    tabletsFilters: {
+        loading: boolean;
+        requestTime: number;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        tabletsData: any;
+        nodes: any;
+        loading: boolean;
+        wasLoaded: boolean;
+        timeoutForRequest: number;
+        error: undefined;
+        data: undefined;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        error: any;
+        loading: boolean;
+        data: undefined;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | {
+        stateFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        typeFilter: never[];
+    } | {
+        typeFilter: any;
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+    };
+    heatmap: import("../../types/store/heatmap").IHeatmapState;
+    settings: import("./settings/types").SettingsState;
+    schemaAcl: import("./schemaAcl/types").SchemaAclState;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters;
+    hotKeys: import("./hotKeys/types").HotKeysState;
+    authentication: import("./authentication/types").AuthenticationState;
+    header: import("./header/types").HeaderState;
+    saveQuery: string | null;
+    fullscreen: boolean;
+    clusters: import("./clusters/types").ClustersFilters;
+}, nodeId: string | undefined, path: string | undefined) => (TTabletStateInfo & {
+    fqdn?: string | undefined;
+})[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../types/api/tablet").TEvTabletStateResponse | undefined, resultFuncArgs_1: import("../../types/store/nodesList").NodesMap | undefined) => (TTabletStateInfo & {
+        fqdn?: string | undefined;
+    })[];
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../types/api/tablet").TEvTabletStateResponse | undefined, resultFuncArgs_1: import("../../types/store/nodesList").NodesMap | undefined) => (TTabletStateInfo & {
+        fqdn?: string | undefined;
+    })[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => (TTabletStateInfo & {
+        fqdn?: string | undefined;
+    })[];
+    dependencies: [(state: RootState, nodeId: string | undefined, path: string | undefined) => import("../../types/api/tablet").TEvTabletStateResponse | undefined, (state: RootState) => import("../../types/store/nodesList").NodesMap | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

package/dist/store/reducers/tablets.js

@@ -1,5 +1,6 @@
-import { createSlice } from '@reduxjs/toolkit';
+import { createSelector, createSlice } from '@reduxjs/toolkit';
 import { api } from './api';
+import { selectNodesMap } from './nodesList';
 const initialState = {
     stateFilter: [],
     typeFilter: [],
@@ -35,3 +36,17 @@ export const tabletsApi = api.injectEndpoints({
     }),
     overrideExisting: 'throw',
 });
+const getTabletsInfoSelector = createSelector((nodeId, path) => ({ nodeId, path }), ({ nodeId, path }) => tabletsApi.endpoints.getTabletsInfo.select(nodeId === undefined ? { path } : { nodes: [nodeId] }));
+const selectGetTabletsInfo = createSelector((state) => state, (_state, nodeId, path) => getTabletsInfoSelector(nodeId, path), (state, selectTabletsInfo) => selectTabletsInfo(state).data);
+export const selectTabletsWithFqdn = createSelector((state, nodeId, path) => selectGetTabletsInfo(state, nodeId, path), (state) => selectNodesMap(state), (data, nodesMap) => {
+    if (!(data === null || data === void 0 ? void 0 : data.TabletStateInfo)) {
+        return [];
+    }
+    if (!nodesMap) {
+        return data.TabletStateInfo;
+    }
+    return data.TabletStateInfo.map((tablet) => {
+        const fqdn = tablet.NodeId === undefined ? undefined : nodesMap.get(tablet.NodeId);
+        return Object.assign(Object.assign({}, tablet), { fqdn });
+    });
+});