feat(infra-monitoring): migrate nodes to shared component

frontend/src/api/infraMonitoring/getK8sNodesList.ts

@@ -1,127 +0,0 @@
-import axios from 'api';
-import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
-import { AxiosError } from 'axios';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
-
-import { UnderscoreToDotMap } from '../utils';
-
-export interface K8sNodesListPayload {
-	filters: TagFilter;
-	groupBy?: BaseAutocompleteData[];
-	offset?: number;
-	limit?: number;
-	orderBy?: {
-		columnName: string;
-		order: 'asc' | 'desc';
-	};
-}
-
-export interface K8sNodesData {
-	nodeUID: string;
-	nodeCPUUsage: number;
-	nodeCPUAllocatable: number;
-	nodeMemoryUsage: number;
-	nodeMemoryAllocatable: number;
-	meta: {
-		k8s_node_name: string;
-		k8s_node_uid: string;
-		k8s_cluster_name: string;
-	};
-}
-
-export interface K8sNodesListResponse {
-	status: string;
-	data: {
-		type: string;
-		records: K8sNodesData[];
-		groups: null;
-		total: number;
-		sentAnyHostMetricsData: boolean;
-		isSendingK8SAgentMetrics: boolean;
-	};
-}
-
-export const nodesMetaMap = [
-	{ dot: 'k8s.node.name', under: 'k8s_node_name' },
-	{ dot: 'k8s.node.uid', under: 'k8s_node_uid' },
-	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
-] as const;
-
-export function mapNodesMeta(
-	raw: Record<string, unknown>,
-): K8sNodesData['meta'] {
-	const out: Record<string, unknown> = { ...raw };
-	nodesMetaMap.forEach(({ dot, under }) => {
-		if (dot in raw) {
-			const v = raw[dot];
-			out[under] = typeof v === 'string' ? v : raw[under];
-		}
-	});
-	return out as K8sNodesData['meta'];
-}
-
-export const getK8sNodesList = async (
-	props: K8sNodesListPayload,
-	signal?: AbortSignal,
-	headers?: Record<string, string>,
-	dotMetricsEnabled = false,
-): Promise<SuccessResponse<K8sNodesListResponse> | ErrorResponse> => {
-	try {
-		const requestProps =
-			dotMetricsEnabled && Array.isArray(props.filters?.items)
-				? {
-						...props,
-						filters: {
-							...props.filters,
-							items: props.filters.items.reduce<typeof props.filters.items>(
-								(acc, item) => {
-									if (item.value === undefined) {
-										return acc;
-									}
-									if (
-										item.key &&
-										typeof item.key === 'object' &&
-										'key' in item.key &&
-										typeof item.key.key === 'string'
-									) {
-										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
-										acc.push({
-											...item,
-											key: { ...item.key, key: mappedKey },
-										});
-									} else {
-										acc.push(item);
-									}
-									return acc;
-								},
-								[] as typeof props.filters.items,
-							),
-						},
-				  }
-				: props;
-
-		const response = await axios.post('/nodes/list', requestProps, {
-			signal,
-			headers,
-		});
-		const payload: K8sNodesListResponse = response.data;
-
-		// one-liner to map dot→underscore
-		payload.data.records = payload.data.records.map((record) => ({
-			...record,
-			meta: mapNodesMeta(record.meta as Record<string, unknown>),
-		}));
-
-		return {
-			statusCode: 200,
-			error: null,
-			message: 'Success',
-			payload,
-			params: requestProps,
-		};
-	} catch (error) {
-		return ErrorResponseHandler(error as AxiosError);
-	}
-};

frontend/src/container/InfraMonitoringK8s/InfraMonitoringK8s.tsx

@@ -379,11 +379,7 @@ export default function InfraMonitoringK8s(): JSX.Element {
 						)}
 
 						{selectedCategory === K8sCategories.NODES && (
-							<K8sNodesList
-								isFiltersVisible={showFilters}
-								handleFilterVisibilityChange={handleFilterVisibilityChange}
-								quickFiltersLastUpdated={quickFiltersLastUpdated}
-							/>
+							<K8sNodesList controlListPrefix={showFiltersComp} />
 						)}
 
 						{selectedCategory === K8sCategories.CLUSTERS && (

frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.styles.scss

@@ -1,17 +0,0 @@
-.infra-monitoring-container {
-	.nodes-list-table {
-		.expanded-table-container {
-			padding-left: 40px;
-		}
-
-		.ant-table-cell {
-			min-width: 223px !important;
-			max-width: 223px !important;
-		}
-
-		.ant-table-row-expand-icon-cell {
-			min-width: 30px !important;
-			max-width: 30px !important;
-		}
-	}
-}

frontend/src/container/InfraMonitoringK8s/Nodes/K8sNodesList.tsx

@@ -1,695 +1,116 @@
-import React, { useCallback, useEffect, useMemo, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { LoadingOutlined } from '@ant-design/icons';
-import {
-	Button,
-	Spin,
-	Table,
-	TableColumnType as ColumnType,
-	TablePaginationConfig,
-	TableProps,
-	Typography,
-} from 'antd';
-import type { SorterResult } from 'antd/es/table/interface';
-import logEvent from 'api/common/logEvent';
-import { K8sNodesListPayload } from 'api/infraMonitoring/getK8sNodesList';
+import React, { useCallback } from 'react';
 import { InfraMonitoringEvents } from 'constants/events';
 import { FeatureKeys } from 'constants/features';
-import { useGetK8sNodesList } from 'hooks/infraMonitoring/useGetK8sNodesList';
-import { useGetAggregateKeys } from 'hooks/queryBuilder/useGetAggregateKeys';
-import { useQueryBuilder } from 'hooks/queryBuilder/useQueryBuilder';
-import { useQueryOperations } from 'hooks/queryBuilder/useQueryBuilderOperations';
-import { ChevronDown, ChevronRight } from 'lucide-react';
 import { useAppContext } from 'providers/App/App';
-import { AppState } from 'store/reducers';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { buildAbsolutePath, isModifierKeyPressed } from 'utils/app';
-import { openInNewTab } from 'utils/navigation';
 
+import K8sBaseDetails, { K8sDetailsFilters } from '../Base/K8sBaseDetails';
+import { K8sBaseFilters, K8sBaseList } from '../Base/K8sBaseList';
+import { K8sCategory } from '../constants';
+import { getK8sNodesList, K8sNodeData } from './api';
 import {
-	GetK8sEntityToAggregateAttribute,
-	INFRA_MONITORING_K8S_PARAMS_KEYS,
-	K8sCategory,
-} from '../constants';
+	getNodeMetricsQueryPayload,
+	k8sNodeDetailsMetadataConfig,
+	k8sNodeGetEntityName,
+	k8sNodeGetSelectedItemFilters,
+	k8sNodeInitialEventsFilter,
+	k8sNodeInitialFilters,
+	k8sNodeInitialLogTracesFilter,
+	nodeWidgetInfo,
+} from './constants';
 import {
-	useInfraMonitoringCurrentPage,
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringGroupBy,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringNodeUID,
-	useInfraMonitoringOrderBy,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from '../hooks';
-import K8sHeader from '../K8sHeader';
-import LoadingContainer from '../LoadingContainer';
-import { usePageSize } from '../utils';
-import NodeDetails from './NodeDetails';
-import {
-	defaultAddedColumns,
-	formatDataForTable,
-	getK8sNodesListColumns,
-	getK8sNodesListQuery,
-	K8sNodesRowData,
-} from './utils';
-
-import '../InfraMonitoringK8s.styles.scss';
-import './K8sNodesList.styles.scss';
+	k8sNodesColumns,
+	k8sNodesColumnsConfig,
+	k8sNodesRenderRowData,
+} from './table';
 
 function K8sNodesList({
-	isFiltersVisible,
-	handleFilterVisibilityChange,
-	quickFiltersLastUpdated,
+	controlListPrefix,
 }: {
-	isFiltersVisible: boolean;
-	handleFilterVisibilityChange: () => void;
-	quickFiltersLastUpdated: number;
+	controlListPrefix?: React.ReactNode;
 }): JSX.Element {
-	const { maxTime, minTime } = useSelector<AppState, GlobalReducer>(
-		(state) => state.globalTime,
-	);
-
-	const [currentPage, setCurrentPage] = useInfraMonitoringCurrentPage();
-	const [filtersInitialised, setFiltersInitialised] = useState(false);
-
-	const [expandedRowKeys, setExpandedRowKeys] = useState<string[]>([]);
-	const [orderBy, setOrderBy] = useInfraMonitoringOrderBy();
-
-	const [selectedNodeUID, setSelectedNodeUID] = useInfraMonitoringNodeUID();
-
-	const { pageSize, setPageSize } = usePageSize(K8sCategory.NODES);
-
-	const [groupBy, setGroupBy] = useInfraMonitoringGroupBy();
-
-	// These params are used only for clearing in handleCloseNodeDetail
-	const [, setView] = useInfraMonitoringView();
-	const [, setTracesFilters] = useInfraMonitoringTracesFilters();
-	const [, setEventsFilters] = useInfraMonitoringEventsFilters();
-	const [, setLogFilters] = useInfraMonitoringLogFilters();
-
-	const [selectedRowData, setSelectedRowData] = useState<K8sNodesRowData | null>(
-		null,
-	);
-
-	const [groupByOptions, setGroupByOptions] = useState<
-		{ value: string; label: string }[]
-	>([]);
-
-	const { currentQuery } = useQueryBuilder();
-
-	const queryFilters = useMemo(
-		() =>
-			currentQuery?.builder?.queryData[0]?.filters || {
-				items: [],
-				op: 'and',
-			},
-		[currentQuery?.builder?.queryData],
-	);
-
-	// Reset pagination every time quick filters are changed
-	useEffect(() => {
-		if (quickFiltersLastUpdated !== -1) {
-			setCurrentPage(1);
-		}
-	}, [quickFiltersLastUpdated, setCurrentPage]);
-
 	const { featureFlags } = useAppContext();
 	const dotMetricsEnabled =
 		featureFlags?.find((flag) => flag.name === FeatureKeys.DOT_METRICS_ENABLED)
 			?.active || false;
 
-	const createFiltersForSelectedRowData = (
-		selectedRowData: K8sNodesRowData,
-		groupBy: IBuilderQuery['groupBy'],
-	): IBuilderQuery['filters'] => {
-		const baseFilters: IBuilderQuery['filters'] = {
-			items: [...queryFilters.items],
-			op: 'and',
-		};
+	const fetchListData = useCallback(
+		async (filters: K8sBaseFilters, signal?: AbortSignal) => {
+			filters.orderBy ||= {
+				columnName: 'cpu',
+				order: 'desc',
+			};
 
-		if (!selectedRowData) {
-			return baseFilters;
-		}
-
-		const { groupedByMeta } = selectedRowData;
-
-		for (const key of groupBy) {
-			baseFilters.items.push({
-				key: {
-					key: key.key,
-					type: null,
-				},
-				op: '=',
-				value: groupedByMeta[key.key],
-				id: key.key,
-			});
-		}
-
-		return baseFilters;
-	};
-
-	const fetchGroupedByRowDataQuery = useMemo(() => {
-		if (!selectedRowData) {
-			return null;
-		}
-
-		const baseQuery = getK8sNodesListQuery();
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		return {
-			...baseQuery,
-			limit: 10,
-			offset: 0,
-			filters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-	}, [minTime, maxTime, orderBy, selectedRowData, groupBy]);
-
-	const groupedByRowDataQueryKey = useMemo(() => {
-		// be careful with what you serialize from selectedRowData
-		// since it's react node, it could contain circular references
-		const selectedRowDataKey = JSON.stringify(selectedRowData?.groupedByMeta);
-		if (selectedNodeUID) {
-			return [
-				'nodeList',
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				selectedRowDataKey,
-			];
-		}
-		return [
-			'nodeList',
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			selectedRowDataKey,
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		queryFilters,
-		orderBy,
-		selectedNodeUID,
-		minTime,
-		maxTime,
-		selectedRowData,
-	]);
-
-	const {
-		data: groupedByRowData,
-		isFetching: isFetchingGroupedByRowData,
-		isLoading: isLoadingGroupedByRowData,
-		isError: isErrorGroupedByRowData,
-		refetch: fetchGroupedByRowData,
-	} = useGetK8sNodesList(
-		fetchGroupedByRowDataQuery as K8sNodesListPayload,
-		{
-			queryKey: groupedByRowDataQueryKey,
-			enabled: !!fetchGroupedByRowDataQuery && !!selectedRowData,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const {
-		data: groupByFiltersData,
-		isLoading: isLoadingGroupByFilters,
-	} = useGetAggregateKeys(
-		{
-			dataSource: currentQuery.builder.queryData[0].dataSource,
-			aggregateAttribute: GetK8sEntityToAggregateAttribute(
-				K8sCategory.NODES,
+			const response = await getK8sNodesList(
+				filters,
+				signal,
+				undefined,
 				dotMetricsEnabled,
-			),
-			aggregateOperator: 'noop',
-			searchText: '',
-			tagType: '',
-		},
-		{
-			queryKey: [currentQuery.builder.queryData[0].dataSource, 'noop'],
-		},
-		true,
-		K8sCategory.NODES,
-	);
-
-	const query = useMemo(() => {
-		const baseQuery = getK8sNodesListQuery();
-		const queryPayload = {
-			...baseQuery,
-			limit: pageSize,
-			offset: (currentPage - 1) * pageSize,
-			filters: queryFilters,
-			start: Math.floor(minTime / 1000000),
-			end: Math.floor(maxTime / 1000000),
-			orderBy: orderBy || baseQuery.orderBy,
-		};
-		if (groupBy.length > 0) {
-			queryPayload.groupBy = groupBy;
-		}
-		return queryPayload;
-	}, [pageSize, currentPage, queryFilters, minTime, maxTime, orderBy, groupBy]);
-
-	const nestedNodesData = useMemo(() => {
-		if (!selectedRowData || !groupedByRowData?.payload?.data.records) {
-			return [];
-		}
-		return groupedByRowData?.payload?.data?.records || [];
-	}, [groupedByRowData, selectedRowData]);
-
-	const formattedGroupedByNodesData = useMemo(
-		() =>
-			formatDataForTable(groupedByRowData?.payload?.data?.records || [], groupBy),
-		[groupedByRowData, groupBy],
-	);
-
-	const queryKey = useMemo(() => {
-		if (selectedNodeUID) {
-			return [
-				'nodeList',
-				String(pageSize),
-				String(currentPage),
-				JSON.stringify(queryFilters),
-				JSON.stringify(orderBy),
-				JSON.stringify(groupBy),
-			];
-		}
-		return [
-			'nodeList',
-			String(pageSize),
-			String(currentPage),
-			JSON.stringify(queryFilters),
-			JSON.stringify(orderBy),
-			JSON.stringify(groupBy),
-			String(minTime),
-			String(maxTime),
-		];
-	}, [
-		selectedNodeUID,
-		pageSize,
-		currentPage,
-		queryFilters,
-		orderBy,
-		groupBy,
-		minTime,
-		maxTime,
-	]);
-
-	const { data, isFetching, isLoading, isError } = useGetK8sNodesList(
-		query as K8sNodesListPayload,
-		{
-			queryKey,
-			enabled: !!query,
-			keepPreviousData: true,
-		},
-		undefined,
-		dotMetricsEnabled,
-	);
-
-	const nodesData = useMemo(() => data?.payload?.data?.records || [], [data]);
-	const totalCount = data?.payload?.data?.total || 0;
-
-	const formattedNodesData = useMemo(
-		() => formatDataForTable(nodesData, groupBy),
-		[nodesData, groupBy],
-	);
-
-	const columns = useMemo(() => getK8sNodesListColumns(groupBy), [groupBy]);
-
-	const handleGroupByRowClick = (record: K8sNodesRowData): void => {
-		setSelectedRowData(record);
-
-		if (expandedRowKeys.includes(record.key)) {
-			setExpandedRowKeys(expandedRowKeys.filter((key) => key !== record.key));
-		} else {
-			setExpandedRowKeys([record.key]);
-		}
-	};
-
-	useEffect(() => {
-		if (selectedRowData) {
-			fetchGroupedByRowData();
-		}
-	}, [selectedRowData, fetchGroupedByRowData]);
-
-	const handleTableChange: TableProps<K8sNodesRowData>['onChange'] = useCallback(
-		(
-			pagination: TablePaginationConfig,
-			_filters: Record<string, (string | number | boolean)[] | null>,
-			sorter: SorterResult<K8sNodesRowData> | SorterResult<K8sNodesRowData>[],
-		): void => {
-			if (pagination.current) {
-				setCurrentPage(pagination.current);
-				logEvent(InfraMonitoringEvents.PageNumberChanged, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Node,
-				});
-			}
-
-			if ('field' in sorter && sorter.order) {
-				setOrderBy({
-					columnName: sorter.field as string,
-					order: (sorter.order === 'ascend' ? 'asc' : 'desc') as 'asc' | 'desc',
-				});
-			} else {
-				setOrderBy(null);
-			}
-		},
-		[setCurrentPage, setOrderBy],
-	);
-
-	const { handleChangeQueryData } = useQueryOperations({
-		index: 0,
-		query: currentQuery.builder.queryData[0],
-		entityVersion: '',
-	});
-
-	const handleFiltersChange = useCallback(
-		(value: IBuilderQuery['filters']): void => {
-			handleChangeQueryData('filters', value);
-			if (filtersInitialised) {
-				setCurrentPage(1);
-			} else {
-				setFiltersInitialised(true);
-			}
-
-			if (value?.items && value?.items?.length > 0) {
-				logEvent(InfraMonitoringEvents.FilterApplied, {
-					entity: InfraMonitoringEvents.K8sEntity,
-					page: InfraMonitoringEvents.ListPage,
-					category: InfraMonitoringEvents.Node,
-				});
-			}
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	useEffect(() => {
-		logEvent(InfraMonitoringEvents.PageVisited, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Node,
-			total: data?.payload?.data?.total,
-		});
-	}, [data?.payload?.data?.total]);
-
-	const selectedNodeData = useMemo(() => {
-		if (!selectedNodeUID) {
-			return null;
-		}
-		if (groupBy.length > 0) {
-			// If grouped by, return the node from the formatted grouped by nodes data
-			return (
-				nestedNodesData.find((node) => node.nodeUID === selectedNodeUID) || null
 			);
-		}
-		// If not grouped by, return the node from the nodes data
-		return nodesData.find((node) => node.nodeUID === selectedNodeUID) || null;
-	}, [selectedNodeUID, groupBy.length, nodesData, nestedNodesData]);
 
-	const openNodeInNewTab = (record: K8sNodesRowData): void => {
-		const newParams = new URLSearchParams(document.location.search);
-		newParams.set(INFRA_MONITORING_K8S_PARAMS_KEYS.NODE_UID, record.nodeUID);
-		openInNewTab(
-			buildAbsolutePath({
-				relativePath: '',
-				urlQueryString: newParams.toString(),
-			}),
-		);
-	};
-
-	const handleRowClick = (
-		record: K8sNodesRowData,
-		event: React.MouseEvent,
-	): void => {
-		if (event && isModifierKeyPressed(event)) {
-			openNodeInNewTab(record);
-			return;
-		}
-		if (groupBy.length === 0) {
-			setSelectedRowData(null);
-			setSelectedNodeUID(record.nodeUID);
-		} else {
-			handleGroupByRowClick(record);
-		}
-
-		logEvent(InfraMonitoringEvents.ItemClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Node,
-		});
-	};
-
-	const nestedColumns = useMemo(() => getK8sNodesListColumns([]), []);
-
-	const isGroupedByAttribute = groupBy.length > 0;
-
-	const handleExpandedRowViewAllClick = (): void => {
-		if (!selectedRowData) {
-			return;
-		}
-
-		const filters = createFiltersForSelectedRowData(selectedRowData, groupBy);
-
-		handleFiltersChange(filters);
-
-		setCurrentPage(1);
-		setSelectedRowData(null);
-		setGroupBy([]);
-		setOrderBy(null);
-	};
-
-	const expandedRowRender = (): JSX.Element => (
-		<div className="expanded-table-container">
-			{isErrorGroupedByRowData && (
-				<Typography>{groupedByRowData?.error || 'Something went wrong'}</Typography>
-			)}
-			{isFetchingGroupedByRowData || isLoadingGroupedByRowData ? (
-				<LoadingContainer />
-			) : (
-				<div className="expanded-table">
-					<Table
-						className="expanded-table-view"
-						columns={nestedColumns as ColumnType<K8sNodesRowData>[]}
-						dataSource={formattedGroupedByNodesData}
-						pagination={false}
-						scroll={{ x: true }}
-						tableLayout="fixed"
-						size="small"
-						loading={{
-							spinning: isFetchingGroupedByRowData || isLoadingGroupedByRowData,
-							indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-						}}
-						showHeader={false}
-						onRow={(
-							record,
-						): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-							onClick: (event: React.MouseEvent): void => {
-								if (isModifierKeyPressed(event)) {
-									openNodeInNewTab(record);
-									return;
-								}
-								setSelectedNodeUID(record.nodeUID);
-							},
-							className: 'expanded-clickable-row',
-						})}
-					/>
-
-					{groupedByRowData?.payload?.data?.total &&
-					groupedByRowData?.payload?.data?.total > 10 ? (
-						<div className="expanded-table-footer">
-							<Button
-								type="default"
-								size="small"
-								className="periscope-btn secondary"
-								onClick={handleExpandedRowViewAllClick}
-							>
-								View All
-							</Button>
-						</div>
-					) : null}
-				</div>
-			)}
-		</div>
-	);
-
-	const expandRowIconRenderer = ({
-		expanded,
-		onExpand,
-		record,
-	}: {
-		expanded: boolean;
-		onExpand: (
-			record: K8sNodesRowData,
-			e: React.MouseEvent<HTMLButtonElement>,
-		) => void;
-		record: K8sNodesRowData;
-	}): JSX.Element | null => {
-		if (!isGroupedByAttribute) {
-			return null;
-		}
-
-		return expanded ? (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronDown size={14} />
-			</Button>
-		) : (
-			<Button
-				className="periscope-btn ghost"
-				onClick={(e: React.MouseEvent<HTMLButtonElement>): void =>
-					onExpand(record, e)
-				}
-				role="button"
-			>
-				<ChevronRight size={14} />
-			</Button>
-		);
-	};
-
-	const handleCloseNodeDetail = (): void => {
-		setSelectedNodeUID(null);
-		setView(null);
-		setTracesFilters(null);
-		setEventsFilters(null);
-		setLogFilters(null);
-	};
-
-	const handleGroupByChange = useCallback(
-		(value: IBuilderQuery['groupBy']) => {
-			const newGroupBy = [];
-
-			for (let index = 0; index < value.length; index++) {
-				const element = (value[index] as unknown) as string;
-
-				const key = groupByFiltersData?.payload?.attributeKeys?.find(
-					(k) => k.key === element,
-				);
-
-				if (key) {
-					newGroupBy.push(key);
-				}
-			}
-			// Reset pagination on switching to groupBy
-			setCurrentPage(1);
-			setGroupBy(newGroupBy);
-			setExpandedRowKeys([]);
-
-			logEvent(InfraMonitoringEvents.GroupByChanged, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.ListPage,
-				category: InfraMonitoringEvents.Node,
-			});
+			return {
+				data: response.payload?.data.records || [],
+				total: response.payload?.data.total || 0,
+				error: response.error,
+			};
 		},
-		[groupByFiltersData, setCurrentPage, setGroupBy],
+		[dotMetricsEnabled],
 	);
 
-	useEffect(() => {
-		if (groupByFiltersData?.payload) {
-			setGroupByOptions(
-				groupByFiltersData?.payload?.attributeKeys?.map((filter) => ({
-					value: filter.key,
-					label: filter.key,
-				})) || [],
+	const fetchEntityData = useCallback(
+		async (
+			filters: K8sDetailsFilters,
+			signal?: AbortSignal,
+		): Promise<{ data: K8sNodeData | null; error?: string | null }> => {
+			const response = await getK8sNodesList(
+				{
+					filters: filters.filters,
+					start: filters.start,
+					end: filters.end,
+					limit: 1,
+					offset: 0,
+				},
+				signal,
+				undefined,
+				dotMetricsEnabled,
 			);
-		}
-	}, [groupByFiltersData]);
 
-	const onPaginationChange = (page: number, pageSize: number): void => {
-		setCurrentPage(page);
-		setPageSize(pageSize);
-		logEvent(InfraMonitoringEvents.PageNumberChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.ListPage,
-			category: InfraMonitoringEvents.Node,
-		});
-	};
+			const records = response.payload?.data.records || [];
 
-	const showTableLoadingState =
-		(isFetching || isLoading) && formattedNodesData.length === 0;
+			return {
+				data: records.length > 0 ? records[0] : null,
+				error: response.error,
+			};
+		},
+		[dotMetricsEnabled],
+	);
 
 	return (
-		<div className="k8s-list">
-			<K8sHeader
-				isFiltersVisible={isFiltersVisible}
-				handleFilterVisibilityChange={handleFilterVisibilityChange}
-				defaultAddedColumns={defaultAddedColumns}
-				handleFiltersChange={handleFiltersChange}
-				groupByOptions={groupByOptions}
-				isLoadingGroupByFilters={isLoadingGroupByFilters}
-				handleGroupByChange={handleGroupByChange}
-				selectedGroupBy={groupBy}
+		<>
+			<K8sBaseList<K8sNodeData>
+				controlListPrefix={controlListPrefix}
 				entity={K8sCategory.NODES}
-				showAutoRefresh={!selectedNodeData}
-			/>
-			{isError && <Typography>{data?.error || 'Something went wrong'}</Typography>}
-
-			<Table
-				className="k8s-list-table nodes-list-table"
-				dataSource={showTableLoadingState ? [] : formattedNodesData}
-				columns={columns}
-				pagination={{
-					current: currentPage,
-					pageSize,
-					total: totalCount,
-					showSizeChanger: true,
-					hideOnSinglePage: false,
-					onChange: onPaginationChange,
-				}}
-				scroll={{ x: true }}
-				loading={{
-					spinning: showTableLoadingState,
-					indicator: <Spin indicator={<LoadingOutlined size={14} spin />} />,
-				}}
-				locale={{
-					emptyText: showTableLoadingState ? null : (
-						<div className="no-filtered-hosts-message-container">
-							<div className="no-filtered-hosts-message-content">
-								<img
-									src="/Icons/emptyState.svg"
-									alt="thinking-emoji"
-									className="empty-state-svg"
-								/>
-
-								<Typography.Text className="no-filtered-hosts-message">
-									This query had no results. Edit your query and try again!
-								</Typography.Text>
-							</div>
-						</div>
-					),
-				}}
-				tableLayout="fixed"
-				onChange={handleTableChange}
-				onRow={(
-					record,
-				): { onClick: (event: React.MouseEvent) => void; className: string } => ({
-					onClick: (event: React.MouseEvent): void => handleRowClick(record, event),
-					className: 'clickable-row',
-				})}
-				expandable={{
-					expandedRowRender: isGroupedByAttribute ? expandedRowRender : undefined,
-					expandIcon: expandRowIconRenderer,
-					expandedRowKeys,
-				}}
+				tableColumnsDefinitions={k8sNodesColumns}
+				tableColumns={k8sNodesColumnsConfig}
+				fetchListData={fetchListData}
+				renderRowData={k8sNodesRenderRowData}
+				eventCategory={InfraMonitoringEvents.Node}
 			/>
 
-			<NodeDetails
-				node={selectedNodeData}
-				isModalTimeSelection
-				onClose={handleCloseNodeDetail}
+			<K8sBaseDetails<K8sNodeData>
+				category={K8sCategory.NODES}
+				eventCategory={InfraMonitoringEvents.Node}
+				getSelectedItemFilters={k8sNodeGetSelectedItemFilters}
+				fetchEntityData={fetchEntityData}
+				getEntityName={k8sNodeGetEntityName}
+				getInitialLogTracesFilters={k8sNodeInitialLogTracesFilter}
+				getInitialEventsFilters={k8sNodeInitialEventsFilter}
+				primaryFilterKeys={k8sNodeInitialFilters}
+				metadataConfig={k8sNodeDetailsMetadataConfig}
+				entityWidgetInfo={nodeWidgetInfo}
+				getEntityQueryPayload={getNodeMetricsQueryPayload}
+				queryKeyPrefix="node"
 			/>
-		</div>
+		</>
 	);
 }
 

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.interfaces.ts

@@ -1,7 +0,0 @@
-import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
-
-export type NodeDetailsProps = {
-	node: K8sNodesData | null;
-	isModalTimeSelection: boolean;
-	onClose: () => void;
-};

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails.tsx

@@ -1,635 +0,0 @@
-/* eslint-disable sonarjs/no-identical-functions */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-// eslint-disable-next-line no-restricted-imports
-import { useSelector } from 'react-redux';
-import { Color, Spacing } from '@signozhq/design-tokens';
-import { Button, Divider, Drawer, Radio, Tooltip, Typography } from 'antd';
-import type { RadioChangeEvent } from 'antd/lib';
-import logEvent from 'api/common/logEvent';
-import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
-import { VIEW_TYPES, VIEWS } from 'components/HostMetricsDetail/constants';
-import { InfraMonitoringEvents } from 'constants/events';
-import { QueryParams } from 'constants/query';
-import {
-	initialQueryBuilderFormValuesMap,
-	initialQueryState,
-} from 'constants/queryBuilder';
-import ROUTES from 'constants/routes';
-import { filterDuplicateFilters } from 'container/InfraMonitoringK8s/commonUtils';
-import { K8sCategory } from 'container/InfraMonitoringK8s/constants';
-import NodeEvents from 'container/InfraMonitoringK8s/EntityDetailsUtils/EntityEvents';
-import {
-	useInfraMonitoringEventsFilters,
-	useInfraMonitoringLogFilters,
-	useInfraMonitoringTracesFilters,
-	useInfraMonitoringView,
-} from 'container/InfraMonitoringK8s/hooks';
-import {
-	CustomTimeType,
-	Time,
-} from 'container/TopNav/DateTimeSelectionV2/types';
-import { useIsDarkMode } from 'hooks/useDarkMode';
-import useUrlQuery from 'hooks/useUrlQuery';
-import GetMinMax from 'lib/getMinMax';
-import {
-	BarChart2,
-	ChevronsLeftRight,
-	Compass,
-	DraftingCompass,
-	ScrollText,
-	X,
-} from 'lucide-react';
-import { AppState } from 'store/reducers';
-import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
-import {
-	IBuilderQuery,
-	TagFilterItem,
-} from 'types/api/queryBuilder/queryBuilderData';
-import {
-	LogsAggregatorOperator,
-	TracesAggregatorOperator,
-} from 'types/common/queryBuilder';
-import { GlobalReducer } from 'types/reducer/globalTime';
-import { v4 as uuidv4 } from 'uuid';
-
-import NodeLogs from '../../EntityDetailsUtils/EntityLogs';
-import NodeMetrics from '../../EntityDetailsUtils/EntityMetrics';
-import NodeTraces from '../../EntityDetailsUtils/EntityTraces';
-import { QUERY_KEYS } from '../../EntityDetailsUtils/utils';
-import { getNodeMetricsQueryPayload, nodeWidgetInfo } from './constants';
-import { NodeDetailsProps } from './NodeDetails.interfaces';
-
-import '../../EntityDetailsUtils/entityDetails.styles.scss';
-
-function NodeDetails({
-	node,
-	onClose,
-	isModalTimeSelection,
-}: NodeDetailsProps): JSX.Element {
-	const { maxTime, minTime, selectedTime } = useSelector<
-		AppState,
-		GlobalReducer
-	>((state) => state.globalTime);
-
-	const startMs = useMemo(() => Math.floor(Number(minTime) / 1000000000), [
-		minTime,
-	]);
-	const endMs = useMemo(() => Math.floor(Number(maxTime) / 1000000000), [
-		maxTime,
-	]);
-
-	const urlQuery = useUrlQuery();
-
-	const [modalTimeRange, setModalTimeRange] = useState(() => ({
-		startTime: startMs,
-		endTime: endMs,
-	}));
-
-	const lastSelectedInterval = useRef<Time | null>(null);
-
-	const [selectedInterval, setSelectedInterval] = useState<Time>(
-		lastSelectedInterval.current
-			? lastSelectedInterval.current
-			: (selectedTime as Time),
-	);
-
-	const [selectedView, setSelectedView] = useInfraMonitoringView();
-	const [logFiltersParam, setLogFiltersParam] = useInfraMonitoringLogFilters();
-	const [
-		tracesFiltersParam,
-		setTracesFiltersParam,
-	] = useInfraMonitoringTracesFilters();
-	const [
-		eventsFiltersParam,
-		setEventsFiltersParam,
-	] = useInfraMonitoringEventsFilters();
-	const isDarkMode = useIsDarkMode();
-
-	const initialFilters = useMemo(() => {
-		const filters =
-			selectedView === VIEW_TYPES.LOGS ? logFiltersParam : tracesFiltersParam;
-		if (filters) {
-			return filters;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_NODE_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s_node_name--string--resource--false',
-					},
-					op: '=',
-					value: node?.meta.k8s_node_name || '',
-				},
-			],
-		};
-	}, [
-		node?.meta.k8s_node_name,
-		selectedView,
-		logFiltersParam,
-		tracesFiltersParam,
-	]);
-
-	const initialEventsFilters = useMemo(() => {
-		if (eventsFiltersParam) {
-			return eventsFiltersParam;
-		}
-		return {
-			op: 'AND',
-			items: [
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_KIND,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.kind--string--resource--false',
-					},
-					op: '=',
-					value: 'Node',
-				},
-				{
-					id: uuidv4(),
-					key: {
-						key: QUERY_KEYS.K8S_OBJECT_NAME,
-						dataType: DataTypes.String,
-						type: 'resource',
-						id: 'k8s.object.name--string--resource--false',
-					},
-					op: '=',
-					value: node?.meta.k8s_node_name || '',
-				},
-			],
-		};
-	}, [node?.meta.k8s_node_name, eventsFiltersParam]);
-
-	const [logAndTracesFilters, setLogAndTracesFilters] = useState<
-		IBuilderQuery['filters']
-	>(initialFilters);
-
-	const [eventsFilters, setEventsFilters] = useState<IBuilderQuery['filters']>(
-		initialEventsFilters,
-	);
-
-	useEffect(() => {
-		if (node) {
-			logEvent(InfraMonitoringEvents.PageVisited, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Node,
-			});
-		}
-	}, [node]);
-
-	useEffect(() => {
-		setLogAndTracesFilters(initialFilters);
-		setEventsFilters(initialEventsFilters);
-	}, [initialFilters, initialEventsFilters]);
-
-	useEffect(() => {
-		const currentSelectedInterval = lastSelectedInterval.current || selectedTime;
-		setSelectedInterval(currentSelectedInterval as Time);
-
-		if (currentSelectedInterval !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(currentSelectedInterval);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-	}, [selectedTime, minTime, maxTime]);
-
-	const handleTabChange = (e: RadioChangeEvent): void => {
-		setSelectedView(e.target.value);
-		setLogFiltersParam(null);
-		setTracesFiltersParam(null);
-		setEventsFiltersParam(null);
-		logEvent(InfraMonitoringEvents.TabChanged, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Node,
-			view: e.target.value,
-		});
-	};
-
-	const handleTimeChange = useCallback(
-		(interval: Time | CustomTimeType, dateTimeRange?: [number, number]): void => {
-			lastSelectedInterval.current = interval as Time;
-			setSelectedInterval(interval as Time);
-
-			if (interval === 'custom' && dateTimeRange) {
-				setModalTimeRange({
-					startTime: Math.floor(dateTimeRange[0] / 1000),
-					endTime: Math.floor(dateTimeRange[1] / 1000),
-				});
-			} else {
-				const { maxTime, minTime } = GetMinMax(interval);
-
-				setModalTimeRange({
-					startTime: Math.floor(minTime / 1000000000),
-					endTime: Math.floor(maxTime / 1000000000),
-				});
-			}
-
-			logEvent(InfraMonitoringEvents.TimeUpdated, {
-				entity: InfraMonitoringEvents.K8sEntity,
-				page: InfraMonitoringEvents.DetailedPage,
-				category: InfraMonitoringEvents.Node,
-				interval,
-				view: selectedView,
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeLogFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-				const paginationFilter = value?.items?.find(
-					(item) => item.key?.key === 'id',
-				);
-				const newFilters = value?.items?.filter(
-					(item) =>
-						item.key?.key !== 'id' && item.key?.key !== QUERY_KEYS.K8S_NODE_NAME,
-				);
-
-				if (newFilters && newFilters?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Node,
-						view: InfraMonitoringEvents.LogsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(newFilters || []),
-							...(paginationFilter ? [paginationFilter] : []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setLogFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeTracesFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setLogAndTracesFilters((prevFilters) => {
-				const primaryFilters = prevFilters?.items?.filter((item) =>
-					[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME].includes(
-						item.key?.key ?? '',
-					),
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Node,
-						view: InfraMonitoringEvents.TracesView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: filterDuplicateFilters(
-						[
-							...(primaryFilters || []),
-							...(value?.items?.filter(
-								(item) => item.key?.key !== QUERY_KEYS.K8S_NODE_NAME,
-							) || []),
-						].filter((item): item is TagFilterItem => item !== undefined),
-					),
-				};
-
-				setTracesFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleChangeEventsFilters = useCallback(
-		(value: IBuilderQuery['filters'], view: VIEWS) => {
-			setEventsFilters((prevFilters) => {
-				const nodeKindFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_KIND,
-				);
-				const nodeNameFilter = prevFilters?.items?.find(
-					(item) => item.key?.key === QUERY_KEYS.K8S_OBJECT_NAME,
-				);
-
-				if (value?.items && value?.items?.length > 0) {
-					logEvent(InfraMonitoringEvents.FilterApplied, {
-						entity: InfraMonitoringEvents.K8sEntity,
-						page: InfraMonitoringEvents.DetailedPage,
-						category: InfraMonitoringEvents.Node,
-						view: InfraMonitoringEvents.EventsView,
-					});
-				}
-
-				const updatedFilters = {
-					op: 'AND',
-					items: [
-						nodeKindFilter,
-						nodeNameFilter,
-						...(value?.items?.filter(
-							(item) =>
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_KIND &&
-								item.key?.key !== QUERY_KEYS.K8S_OBJECT_NAME,
-						) || []),
-					].filter((item): item is TagFilterItem => item !== undefined),
-				};
-
-				setEventsFiltersParam(updatedFilters);
-				setSelectedView(view);
-
-				return updatedFilters;
-			});
-		},
-		// eslint-disable-next-line react-hooks/exhaustive-deps
-		[],
-	);
-
-	const handleExplorePagesRedirect = (): void => {
-		if (selectedInterval !== 'custom') {
-			urlQuery.set(QueryParams.relativeTime, selectedInterval);
-		} else {
-			urlQuery.delete(QueryParams.relativeTime);
-			urlQuery.set(QueryParams.startTime, modalTimeRange.startTime.toString());
-			urlQuery.set(QueryParams.endTime, modalTimeRange.endTime.toString());
-		}
-
-		logEvent(InfraMonitoringEvents.ExploreClicked, {
-			entity: InfraMonitoringEvents.K8sEntity,
-			page: InfraMonitoringEvents.DetailedPage,
-			category: InfraMonitoringEvents.Node,
-			view: selectedView,
-		});
-
-		if (selectedView === VIEW_TYPES.LOGS) {
-			const filtersWithoutPagination = {
-				...logAndTracesFilters,
-				items:
-					logAndTracesFilters?.items?.filter((item) => item.key?.key !== 'id') || [],
-			};
-
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.logs,
-							aggregateOperator: LogsAggregatorOperator.NOOP,
-							filters: filtersWithoutPagination,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.LOGS_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		} else if (selectedView === VIEW_TYPES.TRACES) {
-			const compositeQuery = {
-				...initialQueryState,
-				queryType: 'builder',
-				builder: {
-					...initialQueryState.builder,
-					queryData: [
-						{
-							...initialQueryBuilderFormValuesMap.traces,
-							aggregateOperator: TracesAggregatorOperator.NOOP,
-							filters: logAndTracesFilters,
-						},
-					],
-				},
-			};
-
-			urlQuery.set('compositeQuery', JSON.stringify(compositeQuery));
-
-			window.open(
-				`${window.location.origin}${ROUTES.TRACES_EXPLORER}?${urlQuery.toString()}`,
-				'_blank',
-			);
-		}
-	};
-
-	const handleClose = (): void => {
-		lastSelectedInterval.current = null;
-		setSelectedInterval(selectedTime as Time);
-
-		if (selectedTime !== 'custom') {
-			const { maxTime, minTime } = GetMinMax(selectedTime);
-
-			setModalTimeRange({
-				startTime: Math.floor(minTime / 1000000000),
-				endTime: Math.floor(maxTime / 1000000000),
-			});
-		}
-		setSelectedView(VIEW_TYPES.METRICS);
-		onClose();
-	};
-
-	return (
-		<Drawer
-			width="70%"
-			title={
-				<>
-					<Divider type="vertical" />
-					<Typography.Text className="title">
-						{node?.meta.k8s_node_name}
-					</Typography.Text>
-				</>
-			}
-			placement="right"
-			onClose={handleClose}
-			open={!!node}
-			style={{
-				overscrollBehavior: 'contain',
-				background: isDarkMode ? Color.BG_INK_400 : Color.BG_VANILLA_100,
-			}}
-			className="entity-detail-drawer"
-			destroyOnClose
-			closeIcon={<X size={16} style={{ marginTop: Spacing.MARGIN_1 }} />}
-		>
-			{node && (
-				<>
-					<div className="entity-detail-drawer__entity">
-						<div className="entity-details-grid">
-							<div className="labels-row">
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Node Name
-								</Typography.Text>
-								<Typography.Text
-									type="secondary"
-									className="entity-details-metadata-label"
-								>
-									Cluster Name
-								</Typography.Text>
-							</div>
-							<div className="values-row">
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title={node.meta.k8s_node_name}>
-										{node.meta.k8s_node_name}
-									</Tooltip>
-								</Typography.Text>
-								<Typography.Text className="entity-details-metadata-value">
-									<Tooltip title="Cluster name">{node.meta.k8s_cluster_name}</Tooltip>
-								</Typography.Text>
-							</div>
-						</div>
-					</div>
-
-					<div className="views-tabs-container">
-						<Radio.Group
-							className="views-tabs"
-							onChange={handleTabChange}
-							value={selectedView}
-						>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.METRICS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.METRICS}
-							>
-								<div className="view-title">
-									<BarChart2 size={14} />
-									Metrics
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.LOGS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.LOGS}
-							>
-								<div className="view-title">
-									<ScrollText size={14} />
-									Logs
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.TRACES ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.TRACES}
-							>
-								<div className="view-title">
-									<DraftingCompass size={14} />
-									Traces
-								</div>
-							</Radio.Button>
-							<Radio.Button
-								className={
-									selectedView === VIEW_TYPES.EVENTS ? 'selected_view tab' : 'tab'
-								}
-								value={VIEW_TYPES.EVENTS}
-							>
-								<div className="view-title">
-									<ChevronsLeftRight size={14} />
-									Events
-								</div>
-							</Radio.Button>
-						</Radio.Group>
-
-						{(selectedView === VIEW_TYPES.LOGS ||
-							selectedView === VIEW_TYPES.TRACES) && (
-							<Button
-								icon={<Compass size={18} />}
-								className="compass-button"
-								onClick={handleExplorePagesRedirect}
-							/>
-						)}
-					</div>
-					{selectedView === VIEW_TYPES.METRICS && (
-						<NodeMetrics<K8sNodesData>
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							entity={node}
-							entityWidgetInfo={nodeWidgetInfo}
-							getEntityQueryPayload={getNodeMetricsQueryPayload}
-							category={K8sCategory.NODES}
-							queryKey="nodeMetrics"
-						/>
-					)}
-					{selectedView === VIEW_TYPES.LOGS && (
-						<NodeLogs
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeLogFilters={handleChangeLogFilters}
-							logFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKeyFilters={[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME]}
-							queryKey="nodeLogs"
-							category={K8sCategory.NODES}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.TRACES && (
-						<NodeTraces
-							timeRange={modalTimeRange}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							handleChangeTracesFilters={handleChangeTracesFilters}
-							tracesFilters={logAndTracesFilters}
-							selectedInterval={selectedInterval}
-							queryKeyFilters={[QUERY_KEYS.K8S_NODE_NAME, QUERY_KEYS.K8S_CLUSTER_NAME]}
-							queryKey="nodeTraces"
-							category={InfraMonitoringEvents.Node}
-						/>
-					)}
-					{selectedView === VIEW_TYPES.EVENTS && (
-						<NodeEvents
-							timeRange={modalTimeRange}
-							handleChangeEventFilters={handleChangeEventsFilters}
-							filters={eventsFilters}
-							isModalTimeSelection={isModalTimeSelection}
-							handleTimeChange={handleTimeChange}
-							selectedInterval={selectedInterval}
-							category={K8sCategory.NODES}
-							queryKey="nodeEvents"
-						/>
-					)}
-				</>
-			)}
-		</Drawer>
-	);
-}
-
-export default NodeDetails;

frontend/src/container/InfraMonitoringK8s/Nodes/NodeDetails/index.ts

@@ -1,3 +0,0 @@
-import NodeDetails from './NodeDetails';
-
-export default NodeDetails;

frontend/src/container/InfraMonitoringK8s/Nodes/api.ts

@@ -0,0 +1,128 @@
+import axios from 'api';
+import { ErrorResponseHandler } from 'api/ErrorResponseHandler';
+import { UnderscoreToDotMap } from 'api/utils';
+import { AxiosError } from 'axios';
+import { ErrorResponse, SuccessResponse } from 'types/api';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
+
+import { K8sBaseFilters } from '../Base/K8sBaseList';
+
+export interface K8sNodesListPayload {
+	filters: TagFilter;
+	groupBy?: BaseAutocompleteData[];
+	offset?: number;
+	limit?: number;
+	orderBy?: {
+		columnName: string;
+		order: 'asc' | 'desc';
+	};
+}
+
+export interface K8sNodeData {
+	nodeUID: string;
+	nodeCPUUsage: number;
+	nodeCPUAllocatable: number;
+	nodeMemoryUsage: number;
+	nodeMemoryAllocatable: number;
+	meta: {
+		k8s_node_name: string;
+		k8s_node_uid: string;
+		k8s_cluster_name: string;
+	};
+}
+
+export interface K8sNodesListResponse {
+	status: string;
+	data: {
+		type: string;
+		records: K8sNodeData[];
+		groups: null;
+		total: number;
+		sentAnyHostMetricsData: boolean;
+		isSendingK8SAgentMetrics: boolean;
+	};
+}
+
+export const nodesMetaMap = [
+	{ dot: 'k8s.node.name', under: 'k8s_node_name' },
+	{ dot: 'k8s.node.uid', under: 'k8s_node_uid' },
+	{ dot: 'k8s.cluster.name', under: 'k8s_cluster_name' },
+] as const;
+
+export function mapNodesMeta(
+	raw: Record<string, unknown>,
+): K8sNodeData['meta'] {
+	const out: Record<string, unknown> = { ...raw };
+	nodesMetaMap.forEach(({ dot, under }) => {
+		if (dot in raw) {
+			const v = raw[dot];
+			out[under] = typeof v === 'string' ? v : raw[under];
+		}
+	});
+	return out as K8sNodeData['meta'];
+}
+
+export const getK8sNodesList = async (
+	props: K8sBaseFilters,
+	signal?: AbortSignal,
+	headers?: Record<string, string>,
+	dotMetricsEnabled = false,
+): Promise<SuccessResponse<K8sNodesListResponse> | ErrorResponse> => {
+	try {
+		const requestProps =
+			dotMetricsEnabled && Array.isArray(props.filters?.items)
+				? {
+						...props,
+						filters: {
+							...props.filters,
+							items: props.filters?.items.reduce<typeof props.filters.items>(
+								(acc, item) => {
+									if (item.value === undefined) {
+										return acc;
+									}
+									if (
+										item.key &&
+										typeof item.key === 'object' &&
+										'key' in item.key &&
+										typeof item.key.key === 'string'
+									) {
+										const mappedKey = UnderscoreToDotMap[item.key.key] ?? item.key.key;
+										acc.push({
+											...item,
+											key: { ...item.key, key: mappedKey },
+										});
+									} else {
+										acc.push(item);
+									}
+									return acc;
+								},
+								[] as typeof props.filters.items,
+							),
+						},
+				  }
+				: props;
+
+		const response = await axios.post('/nodes/list', requestProps, {
+			signal,
+			headers,
+		});
+		const payload: K8sNodesListResponse = response.data;
+
+		// one-liner to map dot→underscore
+		payload.data.records = payload.data.records.map((record) => ({
+			...record,
+			meta: mapNodesMeta(record.meta as Record<string, unknown>),
+		}));
+
+		return {
+			statusCode: 200,
+			error: null,
+			message: 'Success',
+			payload,
+			params: requestProps,
+		};
+	} catch (error) {
+		return ErrorResponseHandler(error as AxiosError);
+	}
+};

frontend/src/container/InfraMonitoringK8s/Nodes/constants.ts

@@ -1,11 +1,67 @@
-import { K8sNodesData } from 'api/infraMonitoring/getK8sNodesList';
 import { PANEL_TYPES } from 'constants/queryBuilder';
 import { GetQueryResultsProps } from 'lib/dashboard/getQueryResults';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
+import { TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import { EQueryType } from 'types/common/dashboard';
 import { DataSource, ReduceOperators } from 'types/common/queryBuilder';
 import { v4 } from 'uuid';
 
+import {
+	createFilterItem,
+	K8sDetailsMetadataConfig,
+} from '../Base/K8sBaseDetails';
+import { QUERY_KEYS } from '../EntityDetailsUtils/utils';
+import { K8sNodeData } from './api';
+
+export const k8sNodeGetSelectedItemFilters = (
+	selectedItemId: string,
+): TagFilter => {
+	return {
+		op: 'AND',
+		items: [
+			{
+				id: 'k8s_node_name',
+				key: {
+					key: 'k8s_node_name',
+					type: null,
+				},
+				op: '=',
+				value: selectedItemId,
+			},
+		],
+	};
+};
+
+export const k8sNodeDetailsMetadataConfig: K8sDetailsMetadataConfig<K8sNodeData>[] = [
+	{ label: 'Node Name', getValue: (p): string => p.meta.k8s_node_name },
+	{
+		label: 'Cluster Name',
+		getValue: (p): string => p.meta.k8s_cluster_name,
+	},
+];
+
+export const k8sNodeInitialFilters = [
+	QUERY_KEYS.K8S_NODE_NAME,
+	QUERY_KEYS.K8S_CLUSTER_NAME,
+];
+
+export const k8sNodeInitialEventsFilter = (
+	item: K8sNodeData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_KIND, 'Node'),
+	createFilterItem(QUERY_KEYS.K8S_OBJECT_NAME, item.meta.k8s_node_name),
+];
+
+export const k8sNodeInitialLogTracesFilter = (
+	item: K8sNodeData,
+): ReturnType<typeof createFilterItem>[] => [
+	createFilterItem(QUERY_KEYS.K8S_NODE_NAME, item.meta.k8s_node_name),
+	createFilterItem(QUERY_KEYS.K8S_CLUSTER_NAME, item.meta.k8s_cluster_name),
+];
+
+export const k8sNodeGetEntityName = (item: K8sNodeData): string =>
+	item.meta.k8s_node_name;
+
 export const nodeWidgetInfo = [
 	{
 		title: 'CPU Usage (cores)',
@@ -50,7 +106,7 @@ export const nodeWidgetInfo = [
 ];
 
 export const getNodeMetricsQueryPayload = (
-	node: K8sNodesData,
+	node: K8sNodeData,
 	start: number,
 	end: number,
 	dotMetricsEnabled: boolean,

frontend/src/container/InfraMonitoringK8s/Nodes/table.module.scss

@@ -0,0 +1,6 @@
+.entityGroupHeader {
+	display: flex;
+	align-items: center;
+	padding-left: var(--spacing-5);
+	gap: var(--spacing-5);
+}

frontend/src/container/InfraMonitoringK8s/Nodes/table.tsx

@@ -0,0 +1,199 @@
+import { TableColumnType as ColumnType, Tooltip } from 'antd';
+import { Group } from 'lucide-react';
+import { BaseAutocompleteData } from 'types/api/queryBuilder/queryAutocompleteResponse';
+
+import { K8sRenderedRowData } from '../Base/K8sBaseList';
+import { IEntityColumn } from '../Base/useInfraMonitoringTableColumnsStore';
+import { getGroupByEl, getGroupedByMeta, getRowKey } from '../Base/utils';
+import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
+import { K8sNodeData, K8sNodesListPayload } from './api';
+
+import styles from './table.module.scss';
+
+export interface K8sNodesRowData {
+	key: string;
+	itemKey: string;
+	nodeUID: string;
+	nodeName: React.ReactNode;
+	clusterName: string;
+	cpu: React.ReactNode;
+	cpu_allocatable: React.ReactNode;
+	memory: React.ReactNode;
+	memory_allocatable: React.ReactNode;
+	groupedByMeta?: any;
+}
+
+export const k8sNodesColumns: IEntityColumn[] = [
+	{
+		label: 'Node Group',
+		value: 'nodeGroup',
+		id: 'nodeGroup',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-collapse',
+	},
+	{
+		label: 'Node Name',
+		value: 'nodeName',
+		id: 'nodeName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'hidden-on-expand',
+	},
+	{
+		label: 'Cluster Name',
+		value: 'clusterName',
+		id: 'clusterName',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Usage (cores)',
+		value: 'cpu',
+		id: 'cpu',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'CPU Alloc (cores)',
+		value: 'cpu_allocatable',
+		id: 'cpu_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Usage (WSS)',
+		value: 'memory',
+		id: 'memory',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+	{
+		label: 'Memory Alloc (bytes)',
+		value: 'memory_allocatable',
+		id: 'memory_allocatable',
+		canBeHidden: false,
+		defaultVisibility: true,
+		behavior: 'always-visible',
+	},
+];
+
+export const getK8sNodesListQuery = (): K8sNodesListPayload => ({
+	filters: {
+		items: [],
+		op: 'and',
+	},
+	orderBy: { columnName: 'cpu', order: 'desc' },
+});
+
+export const k8sNodesColumnsConfig: ColumnType<K8sRenderedRowData>[] = [
+	{
+		title: (
+			<div className={styles.entityGroupHeader}>
+				<Group size={14} /> NODE GROUP
+			</div>
+		),
+		dataIndex: 'nodeGroup',
+		key: 'nodeGroup',
+		ellipsis: true,
+		width: 150,
+		align: 'left',
+		sorter: false,
+	},
+	{
+		title: <div>Node Name</div>,
+		dataIndex: 'nodeName',
+		key: 'nodeName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>Cluster Name</div>,
+		dataIndex: 'clusterName',
+		key: 'clusterName',
+		ellipsis: true,
+		width: 80,
+		sorter: false,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Usage (cores)</div>,
+		dataIndex: 'cpu',
+		key: 'cpu',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>CPU Alloc (cores)</div>,
+		dataIndex: 'cpu_allocatable',
+		key: 'cpu_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Usage (WSS)</div>,
+		dataIndex: 'memory',
+		key: 'memory',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+	{
+		title: <div>Memory Allocatable</div>,
+		dataIndex: 'memory_allocatable',
+		key: 'memory_allocatable',
+		width: 80,
+		sorter: true,
+		align: 'left',
+	},
+];
+
+export const k8sNodesRenderRowData = (
+	node: K8sNodeData,
+	groupBy: BaseAutocompleteData[],
+): K8sRenderedRowData => ({
+	key: getRowKey(
+		node,
+		() => node.nodeUID || node.meta.k8s_node_uid || node.meta.k8s_node_name,
+		groupBy,
+	),
+	itemKey: node.meta.k8s_node_name,
+	nodeUID: node.nodeUID || node.meta.k8s_node_uid,
+	nodeName: (
+		<Tooltip title={node.meta.k8s_node_name}>
+			{node.meta.k8s_node_name || ''}
+		</Tooltip>
+	),
+	clusterName: node.meta.k8s_cluster_name,
+	cpu: (
+		<ValidateColumnValueWrapper value={node.nodeCPUUsage}>
+			{node.nodeCPUUsage}
+		</ValidateColumnValueWrapper>
+	),
+	memory: (
+		<ValidateColumnValueWrapper value={node.nodeMemoryUsage}>
+			{formatBytes(node.nodeMemoryUsage)}
+		</ValidateColumnValueWrapper>
+	),
+	cpu_allocatable: (
+		<ValidateColumnValueWrapper value={node.nodeCPUAllocatable}>
+			{node.nodeCPUAllocatable}
+		</ValidateColumnValueWrapper>
+	),
+	memory_allocatable: (
+		<ValidateColumnValueWrapper value={node.nodeMemoryAllocatable}>
+			{formatBytes(node.nodeMemoryAllocatable)}
+		</ValidateColumnValueWrapper>
+	),
+	nodeGroup: getGroupByEl(node, groupBy),
+	...node.meta,
+	groupedByMeta: getGroupedByMeta(node, groupBy),
+});

frontend/src/container/InfraMonitoringK8s/Nodes/utils.tsx

@@ -1,225 +0,0 @@
-import { Color } from '@signozhq/design-tokens';
-import { TableColumnType as ColumnType, Tag, Tooltip } from 'antd';
-import {
-	K8sNodesData,
-	K8sNodesListPayload,
-} from 'api/infraMonitoring/getK8sNodesList';
-import { Group } from 'lucide-react';
-import { IBuilderQuery } from 'types/api/queryBuilder/queryBuilderData';
-
-import { formatBytes, ValidateColumnValueWrapper } from '../commonUtils';
-import { IEntityColumn } from '../utils';
-
-export const defaultAddedColumns: IEntityColumn[] = [
-	{
-		label: 'Node Name',
-		value: 'nodeName',
-		id: 'nodeName',
-		canRemove: false,
-	},
-	{
-		label: 'Cluster Name',
-		value: 'clusterStatus',
-		id: 'clusterStatus',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Usage (cores)',
-		value: 'cpu',
-		id: 'cpu',
-		canRemove: false,
-	},
-	{
-		label: 'CPU Alloc (cores)',
-		value: 'cpu_allocatable',
-		id: 'cpu_allocatable',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Usage (WSS)',
-		value: 'memory',
-		id: 'memory',
-		canRemove: false,
-	},
-	{
-		label: 'Memory Alloc (bytes)',
-		value: 'memory_allocatable',
-		id: 'memory_allocatable',
-		canRemove: false,
-	},
-];
-
-export interface K8sNodesRowData {
-	key: string;
-	nodeUID: string;
-	nodeName: React.ReactNode;
-	clusterName: string;
-	cpu: React.ReactNode;
-	cpu_allocatable: React.ReactNode;
-	memory: React.ReactNode;
-	memory_allocatable: React.ReactNode;
-	groupedByMeta?: any;
-}
-
-const nodeGroupColumnConfig = {
-	title: (
-		<div className="column-header entity-group-header">
-			<Group size={14} /> NODE GROUP
-		</div>
-	),
-	dataIndex: 'nodeGroup',
-	key: 'nodeGroup',
-	ellipsis: true,
-	width: 150,
-	align: 'left',
-	sorter: false,
-	className: 'column entity-group-header',
-};
-
-export const getK8sNodesListQuery = (): K8sNodesListPayload => ({
-	filters: {
-		items: [],
-		op: 'and',
-	},
-	orderBy: { columnName: 'cpu', order: 'desc' },
-});
-
-const columnsConfig = [
-	{
-		title: <div className="column-header-left name-header">Node Name</div>,
-		dataIndex: 'nodeName',
-		key: 'nodeName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left name-header">Cluster Name</div>,
-		dataIndex: 'clusterName',
-		key: 'clusterName',
-		ellipsis: true,
-		width: 80,
-		sorter: false,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">CPU Usage (cores)</div>,
-		dataIndex: 'cpu',
-		key: 'cpu',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">CPU Alloc (cores)</div>,
-		dataIndex: 'cpu_allocatable',
-		key: 'cpu_allocatable',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Memory Usage (WSS)</div>,
-		dataIndex: 'memory',
-		key: 'memory',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-	{
-		title: <div className="column-header-left">Memory Allocatable</div>,
-		dataIndex: 'memory_allocatable',
-		key: 'memory_allocatable',
-		width: 80,
-		sorter: true,
-		align: 'left',
-	},
-];
-
-export const getK8sNodesListColumns = (
-	groupBy: IBuilderQuery['groupBy'],
-): ColumnType<K8sNodesRowData>[] => {
-	if (groupBy.length > 0) {
-		const filteredColumns = [...columnsConfig].filter(
-			(column) => column.key !== 'nodeName',
-		);
-		filteredColumns.unshift(nodeGroupColumnConfig);
-		return filteredColumns as ColumnType<K8sNodesRowData>[];
-	}
-
-	return columnsConfig as ColumnType<K8sNodesRowData>[];
-};
-
-const dotToUnder: Record<string, keyof K8sNodesData['meta']> = {
-	'k8s.node.name': 'k8s_node_name',
-	'k8s.cluster.name': 'k8s_cluster_name',
-	'k8s.node.uid': 'k8s_node_uid',
-};
-
-const getGroupByEle = (
-	node: K8sNodesData,
-	groupBy: IBuilderQuery['groupBy'],
-): React.ReactNode => {
-	const groupByValues: string[] = [];
-
-	groupBy.forEach((group) => {
-		const rawKey = group.key as string;
-
-		// Choose mapped key if present, otherwise use rawKey
-		const metaKey = (dotToUnder[rawKey] ?? rawKey) as keyof typeof node.meta;
-
-		const value = node.meta[metaKey];
-
-		groupByValues.push(value);
-	});
-
-	return (
-		<div className="pod-group">
-			{groupByValues.map((value) => (
-				<Tag key={value} color={Color.BG_SLATE_400} className="pod-group-tag-item">
-					{value === '' ? '<no-value>' : value}
-				</Tag>
-			))}
-		</div>
-	);
-};
-
-export const formatDataForTable = (
-	data: K8sNodesData[],
-	groupBy: IBuilderQuery['groupBy'],
-): K8sNodesRowData[] =>
-	data.map((node, index) => ({
-		key: `${node.nodeUID}-${index}`,
-		nodeUID: node.nodeUID || '',
-		nodeName: (
-			<Tooltip title={node.meta.k8s_node_name}>
-				{node.meta.k8s_node_name || ''}
-			</Tooltip>
-		),
-		clusterName: node.meta.k8s_cluster_name,
-		cpu: (
-			<ValidateColumnValueWrapper value={node.nodeCPUUsage}>
-				{node.nodeCPUUsage}
-			</ValidateColumnValueWrapper>
-		),
-		memory: (
-			<ValidateColumnValueWrapper value={node.nodeMemoryUsage}>
-				{formatBytes(node.nodeMemoryUsage)}
-			</ValidateColumnValueWrapper>
-		),
-		cpu_allocatable: (
-			<ValidateColumnValueWrapper value={node.nodeCPUAllocatable}>
-				{node.nodeCPUAllocatable}
-			</ValidateColumnValueWrapper>
-		),
-		memory_allocatable: (
-			<ValidateColumnValueWrapper value={node.nodeMemoryAllocatable}>
-				{formatBytes(node.nodeMemoryAllocatable)}
-			</ValidateColumnValueWrapper>
-		),
-		nodeGroup: getGroupByEle(node, groupBy),
-		meta: node.meta,
-		...node.meta,
-		groupedByMeta: node.meta,
-	}));

frontend/src/container/InfraMonitoringK8s/__tests__/Nodes/NodeDetails/NodeDetails.test.tsx

@@ -1,148 +0,0 @@
-import setupCommonMocks from '../../commonMocks';
-
-setupCommonMocks();
-
-import { QueryClient, QueryClientProvider } from 'react-query';
-// eslint-disable-next-line no-restricted-imports
-import { Provider } from 'react-redux';
-import { MemoryRouter } from 'react-router-dom';
-import { fireEvent, render, screen } from '@testing-library/react';
-import NodeDetails from 'container/InfraMonitoringK8s/Nodes/NodeDetails/NodeDetails';
-import { withNuqsTestingAdapter } from 'nuqs/adapters/testing';
-import store from 'store';
-
-const queryClient = new QueryClient();
-
-const Wrapper = withNuqsTestingAdapter({ searchParams: {} });
-
-describe('NodeDetails', () => {
-	const mockNode = {
-		meta: {
-			k8s_node_name: 'test-node',
-			k8s_cluster_name: 'test-cluster',
-		},
-	} as any;
-	const mockOnClose = jest.fn();
-
-	it('should render modal with relevant metadata', () => {
-		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
-		);
-
-		const nodeNameElements = screen.getAllByText('test-node');
-		expect(nodeNameElements.length).toBeGreaterThan(0);
-		expect(nodeNameElements[0]).toBeInTheDocument();
-
-		const clusterNameElements = screen.getAllByText('test-cluster');
-		expect(clusterNameElements.length).toBeGreaterThan(0);
-		expect(clusterNameElements[0]).toBeInTheDocument();
-	});
-
-	it('should render modal with 4 tabs', () => {
-		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
-		);
-
-		const metricsTab = screen.getByText('Metrics');
-		expect(metricsTab).toBeInTheDocument();
-
-		const eventsTab = screen.getByText('Events');
-		expect(eventsTab).toBeInTheDocument();
-
-		const logsTab = screen.getByText('Logs');
-		expect(logsTab).toBeInTheDocument();
-
-		const tracesTab = screen.getByText('Traces');
-		expect(tracesTab).toBeInTheDocument();
-	});
-
-	it('default tab should be metrics', () => {
-		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
-		);
-
-		const metricsTab = screen.getByRole('radio', { name: 'Metrics' });
-		expect(metricsTab).toBeChecked();
-	});
-
-	it('should switch to events tab when events tab is clicked', () => {
-		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
-		);
-
-		const eventsTab = screen.getByRole('radio', { name: 'Events' });
-		expect(eventsTab).not.toBeChecked();
-		fireEvent.click(eventsTab);
-		expect(eventsTab).toBeChecked();
-	});
-
-	it('should close modal when close button is clicked', () => {
-		render(
-			<Wrapper>
-				<QueryClientProvider client={queryClient}>
-					<Provider store={store}>
-						<MemoryRouter>
-							<NodeDetails
-								node={mockNode}
-								isModalTimeSelection
-								onClose={mockOnClose}
-							/>
-						</MemoryRouter>
-					</Provider>
-				</QueryClientProvider>
-			</Wrapper>,
-		);
-
-		const closeButton = screen.getByRole('button', { name: 'Close' });
-		fireEvent.click(closeButton);
-		expect(mockOnClose).toHaveBeenCalled();
-	});
-});

frontend/src/hooks/infraMonitoring/useGetK8sNodesList.ts

@@ -1,48 +0,0 @@
-import { useMemo } from 'react';
-import { useQuery, UseQueryOptions, UseQueryResult } from 'react-query';
-import {
-	getK8sNodesList,
-	K8sNodesListPayload,
-	K8sNodesListResponse,
-} from 'api/infraMonitoring/getK8sNodesList';
-import { REACT_QUERY_KEY } from 'constants/reactQueryKeys';
-import { ErrorResponse, SuccessResponse } from 'types/api';
-
-type UseGetK8sNodesList = (
-	requestData: K8sNodesListPayload,
-	options?: UseQueryOptions<
-		SuccessResponse<K8sNodesListResponse> | ErrorResponse,
-		Error
-	>,
-	headers?: Record<string, string>,
-	dotMetricsEnabled?: boolean,
-) => UseQueryResult<
-	SuccessResponse<K8sNodesListResponse> | ErrorResponse,
-	Error
->;
-
-export const useGetK8sNodesList: UseGetK8sNodesList = (
-	requestData,
-	options,
-	headers,
-	dotMetricsEnabled,
-) => {
-	const queryKey = useMemo(() => {
-		if (options?.queryKey && Array.isArray(options.queryKey)) {
-			return [...options.queryKey];
-		}
-
-		if (options?.queryKey && typeof options.queryKey === 'string') {
-			return options.queryKey;
-		}
-
-		return [REACT_QUERY_KEY.GET_NODE_LIST, requestData];
-	}, [options?.queryKey, requestData]);
-
-	return useQuery<SuccessResponse<K8sNodesListResponse> | ErrorResponse, Error>({
-		queryFn: ({ signal }) =>
-			getK8sNodesList(requestData, signal, headers, dotMetricsEnabled),
-		...options,
-		queryKey,
-	});
-};