From 24db1b08b968ded6ab73fa334cb0b9b776a442f7 Mon Sep 17 00:00:00 2001 From: Harshul Rathod Date: Fri, 25 Sep 2026 00:12:30 +0530 Subject: [PATCH 1/3] fix(app): keep table tile rows on screen while a dashboard refreshes A dashboard refresh moves the time range, so the table tile refetches under a new query key. useOffsetPaginatedQuery only keeps previous data in live mode, and a refetch doesn't stream its first page, so the tile had no data until the whole result arrived: the table disappeared and "Loading Chart Data..." showed in its place. Add an opt-in `keepPreviousData` option to useOffsetPaginatedQuery and return `isPlaceholderData`. DBTableChart opts in and pulses the table while it is showing placeholder rows, like the other dashboard tiles. Default behaviour is unchanged for the search and trace views. Refs #3205 --- .changeset/table-tile-refresh-pulse.md | 9 ++ packages/app/src/HDXMultiSeriesTableChart.tsx | 9 +- packages/app/src/components/DBTableChart.tsx | 20 +++-- .../__tests__/DBTableChart.test.tsx | 29 +++++++ .../useOffsetPaginatedQuery.test.tsx | 83 +++++++++++++++++++ .../app/src/hooks/useOffsetPaginatedQuery.tsx | 9 +- 6 files changed, 151 insertions(+), 8 deletions(-) create mode 100644 .changeset/table-tile-refresh-pulse.md diff --git a/.changeset/table-tile-refresh-pulse.md b/.changeset/table-tile-refresh-pulse.md new file mode 100644 index 0000000000..12c73f5d08 --- /dev/null +++ b/.changeset/table-tile-refresh-pulse.md @@ -0,0 +1,9 @@ +--- +'@hyperdx/app': patch +--- + +fix: keep table tile rows on screen while a dashboard refreshes + +A dashboard refresh cleared the table tile and showed "Loading Chart Data..." +until the new result arrived. The tile now keeps its current rows and pulses +while the refetch runs, like the other dashboard tiles. diff --git a/packages/app/src/HDXMultiSeriesTableChart.tsx b/packages/app/src/HDXMultiSeriesTableChart.tsx index 9a48664d92..fb035d76ea 100644 --- a/packages/app/src/HDXMultiSeriesTableChart.tsx +++ b/packages/app/src/HDXMultiSeriesTableChart.tsx @@ -60,6 +60,7 @@ export const Table = ({ onSortingChange, variant = 'default', alternateRowBackground = false, + className, }: { data: any[]; columns: { @@ -101,6 +102,9 @@ export const Table = ({ // dedicated `.stripedRow` hover rule keeps row hover visible over a stripe // (see the CSS module). alternateRowBackground?: boolean; + // Extra classes for the scroll container, e.g. `effect-pulse` while the + // tile is refreshing. + className?: string; }) => { const brandName = useBrandDisplayName(); const MIN_COLUMN_WIDTH_PX = 100; @@ -403,7 +407,10 @@ export const Table = ({ ); return ( -
+
diff --git a/packages/app/src/components/__tests__/DBTableChart.test.tsx b/packages/app/src/components/__tests__/DBTableChart.test.tsx index 980524cccc..9b35a415fb 100644 --- a/packages/app/src/components/__tests__/DBTableChart.test.tsx +++ b/packages/app/src/components/__tests__/DBTableChart.test.tsx @@ -170,6 +170,35 @@ describe('DBTableChart', () => { expect(dateRangeIndicatorCall.mvGranularity).toBe('1 minute'); }); + describe('refresh indicator', () => { + it('asks the query to keep the previous rows during a refetch', () => { + renderWithMantine(); + + const options = jest.mocked(useOffsetPaginatedQuery).mock.calls[0][1]; + expect(options?.keepPreviousData).toBe(true); + }); + + it('pulses while a refetch is showing the previous rows', () => { + jest.mocked(useOffsetPaginatedQuery).mockReturnValue({ + ...jest.mocked(useOffsetPaginatedQuery)(baseTestConfig), + isFetching: true, + isPlaceholderData: true, + }); + + renderWithMantine(); + expect(jest.mocked(Table).mock.calls.at(-1)![0].className).toBe( + 'effect-pulse', + ); + }); + + it('does not pulse once fresh rows have loaded', () => { + renderWithMantine(); + expect( + jest.mocked(Table).mock.calls.at(-1)![0].className, + ).toBeUndefined(); + }); + }); + describe('groupByColumnsOnLeft', () => { // Emulates how the ClickHouse query returns rows for a builder table chart: // series columns are produced before groupBy columns. diff --git a/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx b/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx index edc70c9af4..8f729b2372 100644 --- a/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx +++ b/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx @@ -753,6 +753,89 @@ describe('useOffsetPaginatedQuery', () => { }); }); + describe('Refetching for a new date range', () => { + // A single, non-windowed page so each query is one read of the stream + const rangeA = createMockChartConfig({ orderBy: 'ServiceName' }); + const rangeB = createMockChartConfig({ + orderBy: 'ServiceName', + dateRange: [ + new Date('2024-01-01T00:05:00Z'), + new Date('2024-01-02T00:05:00Z'), + ] as [Date, Date], + }); + + const page = (service: string) => ({ + done: false, + value: [ + { json: () => ['ServiceName'] }, + { json: () => ['String'] }, + { json: () => [service] }, + ], + }); + + // Loads rangeA, then switches to rangeB and holds its response until + // the returned `finish` is called, so the refetch can be inspected. + const loadThenRefetch = async (options: { keepPreviousData?: boolean }) => { + let releaseRangeB!: (value: unknown) => void; + mockReader.read + .mockResolvedValueOnce(page('from-range-a')) + .mockResolvedValueOnce({ done: true }) + .mockReturnValueOnce( + new Promise(resolve => { + releaseRangeB = resolve; + }), + ) + .mockResolvedValueOnce({ done: true }); + + const { result, rerender } = renderHook( + ({ config }) => useOffsetPaginatedQuery(config, options), + { wrapper, initialProps: { config: rangeA } }, + ); + await waitFor(() => + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-a'), + ); + + rerender({ config: rangeB }); + await waitFor(() => + expect(mockClickhouseClient.query).toHaveBeenCalledTimes(2), + ); + + return { + result, + finish: () => act(async () => releaseRangeB(page('from-range-b'))), + }; + }; + + it('keeps the previous rows as placeholder data when keepPreviousData is set', async () => { + const { result, finish } = await loadThenRefetch({ + keepPreviousData: true, + }); + + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-a'); + expect(result.current.isPlaceholderData).toBe(true); + expect(result.current.isFetching).toBe(true); + + await finish(); + await waitFor(() => + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-b'), + ); + expect(result.current.isPlaceholderData).toBe(false); + }); + + it('clears the previous rows by default', async () => { + const { result, finish } = await loadThenRefetch({}); + + expect(result.current.data).toBeNull(); + expect(result.current.isPlaceholderData).toBe(false); + expect(result.current.isLoading).toBe(true); + + await finish(); + await waitFor(() => + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-b'), + ); + }); + }); + describe('Query Key Management', () => { it('should generate unique query keys for different configurations', async () => { const config1 = createMockChartConfig({ diff --git a/packages/app/src/hooks/useOffsetPaginatedQuery.tsx b/packages/app/src/hooks/useOffsetPaginatedQuery.tsx index 5a27d39b96..f1b0d2672e 100644 --- a/packages/app/src/hooks/useOffsetPaginatedQuery.tsx +++ b/packages/app/src/hooks/useOffsetPaginatedQuery.tsx @@ -444,11 +444,14 @@ export default function useOffsetPaginatedQuery( config: ChartConfigWithOptTimestamp, { isLive, + keepPreviousData, enabled = true, queryKeyPrefix = '', enableSmallFirstWindow, }: { isLive?: boolean; + /** Keep showing the previous result while a new query key loads */ + keepPreviousData?: boolean; enabled?: boolean; queryKeyPrefix?: string; enableSmallFirstWindow?: boolean; @@ -489,6 +492,7 @@ export default function useOffsetPaginatedQuery( isError, error, isLoading, + isPlaceholderData, } = useInfiniteQuery< TQueryFnData, Error | ClickHouseQueryError, @@ -498,8 +502,8 @@ export default function useOffsetPaginatedQuery( >({ queryKey: key, placeholderData: (prev: TData | undefined) => { - // Only preserve previous query in live mode - return isLive ? prev : undefined; + // Only preserve previous query in live mode, or when the caller asks + return isLive || keepPreviousData ? prev : undefined; }, enabled: enabled && !isLoadingMe && !isLoadingMVOptimization && !isSourceLoading, @@ -538,5 +542,6 @@ export default function useOffsetPaginatedQuery( hasNextPage, isFetching: isFetching || isLoadingMe || isLoadingMVOptimization, isLoading: isLoading || isLoadingMe || isLoadingMVOptimization, + isPlaceholderData, }; } From 8ae2627e06c06e618777282538cef71e046cf4e6 Mon Sep 17 00:00:00 2001 From: Harshul Rathod Date: Fri, 25 Sep 2026 00:30:17 +0530 Subject: [PATCH 2/3] fix(app): keep placeholder table rows unclickable during a refresh Rows kept from the previous query would build their search links and row actions from the new date range and config, so clicking one could open a search that doesn't match the row. Leave rows inert while they are placeholder data, and enable links again once fresh rows arrive. Also cover paging during a refresh: while placeholder rows are shown the hook reports no next page, so the table can't request more rows for the old result, and paging resumes against the new range once it loads. --- packages/app/src/components/DBTableChart.tsx | 10 +++- .../__tests__/DBTableChart.test.tsx | 39 +++++++++++++++ .../useOffsetPaginatedQuery.test.tsx | 48 +++++++++++++++++++ 3 files changed, 95 insertions(+), 2 deletions(-) diff --git a/packages/app/src/components/DBTableChart.tsx b/packages/app/src/components/DBTableChart.tsx index edf891c117..1a89b7f2b6 100644 --- a/packages/app/src/components/DBTableChart.tsx +++ b/packages/app/src/components/DBTableChart.tsx @@ -311,8 +311,14 @@ export default function DBTableChart({
{ jest.mocked(Table).mock.calls.at(-1)![0].className, ).toBeUndefined(); }); + + describe('row links', () => { + const getRowSearchLink = jest.fn(() => '/search'); + const rowAction = jest.fn(); + + afterEach(() => { + jest.mocked(useOnClickLinkBuilder).mockReturnValue(null); + }); + + const renderTable = (isPlaceholderData: boolean) => { + jest.mocked(useOffsetPaginatedQuery).mockReturnValue({ + ...jest.mocked(useOffsetPaginatedQuery)(baseTestConfig), + isPlaceholderData, + }); + renderWithMantine( + , + ); + return jest.mocked(Table).mock.calls.at(-1)![0]; + }; + + it('disables search links on rows kept from the previous query', () => { + expect(renderTable(true).getRowSearchLink).toBeUndefined(); + }); + + it('enables search links once fresh rows have loaded', () => { + expect(renderTable(false).getRowSearchLink).toBe(getRowSearchLink); + }); + + it('disables the configured row action on rows kept from the previous query', () => { + jest.mocked(useOnClickLinkBuilder).mockReturnValue(rowAction); + + expect(renderTable(true).getRowAction).toBeUndefined(); + expect(renderTable(false).getRowAction).toBe(rowAction); + }); + }); }); describe('groupByColumnsOnLeft', () => { diff --git a/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx b/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx index 8f729b2372..4a94cb9a13 100644 --- a/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx +++ b/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx @@ -834,6 +834,54 @@ describe('useOffsetPaginatedQuery', () => { expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-b'), ); }); + + it('does not offer more pages while showing placeholder rows', async () => { + // Ordered by timestamp, so each range is paged through time windows + const windowedA = createMockChartConfig(); + const windowedB = createMockChartConfig({ + dateRange: rangeB.dateRange, + }); + + let releaseRangeB!: (value: unknown) => void; + mockReader.read + .mockResolvedValueOnce(page('from-range-a')) + .mockResolvedValueOnce({ done: true }) + .mockReturnValueOnce( + new Promise(resolve => { + releaseRangeB = resolve; + }), + ) + .mockResolvedValueOnce({ done: true }); + + const { result, rerender } = renderHook( + ({ config }) => + useOffsetPaginatedQuery(config, { keepPreviousData: true }), + { wrapper, initialProps: { config: windowedA } }, + ); + await waitFor(() => + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-a'), + ); + // Range A has later time windows left to load + expect(result.current.hasNextPage).toBe(true); + + rerender({ config: windowedB }); + await waitFor(() => + expect(mockClickhouseClient.query).toHaveBeenCalledTimes(2), + ); + + // The old rows stay, but the "load more" trigger must not fire for them + expect(result.current.isPlaceholderData).toBe(true); + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-a'); + expect(result.current.hasNextPage).toBe(false); + + await act(async () => releaseRangeB(page('from-range-b'))); + await waitFor(() => + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-b'), + ); + expect(result.current.isPlaceholderData).toBe(false); + // Paging resumes against the new range + expect(result.current.hasNextPage).toBe(true); + }); }); describe('Query Key Management', () => { From 29e64e6fde4e808e278af2ba6dfc9d1b032c1c2f Mon Sep 17 00:00:00 2001 From: Harshul Rathod Date: Fri, 25 Sep 2026 01:07:33 +0530 Subject: [PATCH 3/3] fix(app): only keep table rows across a date-range refresh Review round 2: - keepPreviousData kept rows across any query-key change, so after a tile edit the old rows showed with the new config's columns, number formats and colours until fresh rows arrived. Keep previous data only when the key differs in nothing but dateRange. - A refresh over an empty previous result showed "No data found within time range." with no loading sign. Pulse it while a refetch runs. - Drop an isFetching flag from a test mock that the component ignores. --- packages/app/src/components/DBTableChart.tsx | 8 +++- .../__tests__/DBTableChart.test.tsx | 17 ++++++- .../useOffsetPaginatedQuery.test.tsx | 45 +++++++++++++++++++ .../app/src/hooks/useOffsetPaginatedQuery.tsx | 25 +++++++++-- 4 files changed, 89 insertions(+), 6 deletions(-) diff --git a/packages/app/src/components/DBTableChart.tsx b/packages/app/src/components/DBTableChart.tsx index 1a89b7f2b6..22180d26c6 100644 --- a/packages/app/src/components/DBTableChart.tsx +++ b/packages/app/src/components/DBTableChart.tsx @@ -1,4 +1,5 @@ import { useCallback, useMemo, useState } from 'react'; +import cx from 'classnames'; import { isRatioChartConfig } from '@hyperdx/common-utils/dist/core/renderChartConfig'; import { isBuilderChartConfig, @@ -304,7 +305,12 @@ export default function DBTableChart({ ) : isError && error ? ( ) : data?.data.length === 0 ? ( -
+
No data found within time range.
) : ( diff --git a/packages/app/src/components/__tests__/DBTableChart.test.tsx b/packages/app/src/components/__tests__/DBTableChart.test.tsx index 6a6d585ef8..9063f7744e 100644 --- a/packages/app/src/components/__tests__/DBTableChart.test.tsx +++ b/packages/app/src/components/__tests__/DBTableChart.test.tsx @@ -182,7 +182,6 @@ describe('DBTableChart', () => { it('pulses while a refetch is showing the previous rows', () => { jest.mocked(useOffsetPaginatedQuery).mockReturnValue({ ...jest.mocked(useOffsetPaginatedQuery)(baseTestConfig), - isFetching: true, isPlaceholderData: true, }); @@ -199,6 +198,22 @@ describe('DBTableChart', () => { ).toBeUndefined(); }); + it('pulses the empty state while a refetch is running', () => { + const current = jest.mocked(useOffsetPaginatedQuery)(baseTestConfig); + jest.mocked(useOffsetPaginatedQuery).mockReturnValue({ + ...current, + data: { ...current.data!, data: [] }, + isPlaceholderData: true, + }); + + const { getByText } = renderWithMantine( + , + ); + expect(getByText('No data found within time range.')).toHaveClass( + 'effect-pulse', + ); + }); + describe('row links', () => { const getRowSearchLink = jest.fn(() => '/search'); const rowAction = jest.fn(); diff --git a/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx b/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx index 4a94cb9a13..60935680f2 100644 --- a/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx +++ b/packages/app/src/hooks/__tests__/useOffsetPaginatedQuery.test.tsx @@ -835,6 +835,51 @@ describe('useOffsetPaginatedQuery', () => { ); }); + it('clears the previous rows when more than the date range changes', async () => { + // e.g. a tile edit: rows from the old query would otherwise be rendered + // with the new config's columns, formats and colours + const edited = { ...rangeB, where: "ServiceName = 'api'" }; + + let releaseQuery!: () => void; + mockClickhouseClient.query + .mockImplementationOnce(() => + Promise.resolve({ stream: () => mockStream }), + ) + .mockImplementationOnce( + () => + new Promise(resolve => { + releaseQuery = () => resolve({ stream: () => mockStream }); + }), + ); + mockReader.read + .mockResolvedValueOnce(page('from-range-a')) + .mockResolvedValueOnce({ done: true }) + .mockResolvedValueOnce(page('edited')) + .mockResolvedValueOnce({ done: true }); + + const { result, rerender } = renderHook( + ({ config }) => + useOffsetPaginatedQuery(config, { keepPreviousData: true }), + { wrapper, initialProps: { config: rangeA } }, + ); + await waitFor(() => + expect(result.current.data?.data[0]?.ServiceName).toBe('from-range-a'), + ); + + rerender({ config: edited }); + await waitFor(() => + expect(mockClickhouseClient.query).toHaveBeenCalledTimes(2), + ); + + expect(result.current.data).toBeNull(); + expect(result.current.isPlaceholderData).toBe(false); + + await act(async () => releaseQuery()); + await waitFor(() => + expect(result.current.data?.data[0]?.ServiceName).toBe('edited'), + ); + }); + it('does not offer more pages while showing placeholder rows', async () => { // Ordered by timestamp, so each range is paged through time windows const windowedA = createMockChartConfig(); diff --git a/packages/app/src/hooks/useOffsetPaginatedQuery.tsx b/packages/app/src/hooks/useOffsetPaginatedQuery.tsx index f1b0d2672e..32f635ee2c 100644 --- a/packages/app/src/hooks/useOffsetPaginatedQuery.tsx +++ b/packages/app/src/hooks/useOffsetPaginatedQuery.tsx @@ -1,5 +1,5 @@ import { useMemo } from 'react'; -import { omit } from 'lodash'; +import { isEqual, omit } from 'lodash'; import ms from 'ms'; import type { ClickHouseSettings, @@ -61,6 +61,16 @@ function queryKeyFn( return [prefix, config, queryTimeout]; } +// True when two keys describe the same query over a different time range, +// e.g. a dashboard refresh. +function differsOnlyInDateRange(a: TQueryKey, b: TQueryKey) { + return ( + a[0] === b[0] && + a[2] === b[2] && + isEqual(omit(a[1], ['dateRange']), omit(b[1], ['dateRange'])) + ); +} + type TPageParam = { windowIndex: number; offset: number; @@ -450,7 +460,7 @@ export default function useOffsetPaginatedQuery( enableSmallFirstWindow, }: { isLive?: boolean; - /** Keep showing the previous result while a new query key loads */ + /** Keep showing the previous result while the same query loads a new date range */ keepPreviousData?: boolean; enabled?: boolean; queryKeyPrefix?: string; @@ -501,9 +511,16 @@ export default function useOffsetPaginatedQuery( TPageParam >({ queryKey: key, - placeholderData: (prev: TData | undefined) => { + placeholderData: (prev: TData | undefined, prevQuery) => { // Only preserve previous query in live mode, or when the caller asks - return isLive || keepPreviousData ? prev : undefined; + // and only the date range changed. Rows from a different config would + // be rendered with the new config's columns and formats. + if (isLive) return prev; + return keepPreviousData && + prevQuery != null && + differsOnlyInDateRange(prevQuery.queryKey, key) + ? prev + : undefined; }, enabled: enabled && !isLoadingMe && !isLoadingMVOptimization && !isSourceLoading,