Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

fix(studio): sync table editor filters from the URL on back/forward (#51437)

Alaister Youngb328ca6d5a9b
diff --git a/apps/studio/components/grid/hooks/useFilterLifeCycle.navigation.test.tsx b/apps/studio/components/grid/hooks/useFilterLifeCycle.navigation.test.tsx
new file mode 100644
index 00000000000..d2492cbac45
--- /dev/null
+++ b/apps/studio/components/grid/hooks/useFilterLifeCycle.navigation.test.tsx
@@ -0,0 +1,195 @@
+import {
+ createBrowserHistory,
+ createRootRoute,
+ createRoute,
+ createRouter,
+ Outlet,
+ RouterProvider,
+} from '@tanstack/react-router'
+import { act, render, screen, waitFor } from '@testing-library/react'
+import { flushSync } from 'react-dom'
+import { describe, expect, it, vi } from 'vitest'
+
+import { useInitializeFiltersFromUrl, useSyncFiltersToUrl } from './useFilterLifeCycle'
+import { ENTITY_TYPE } from '@/data/entity-types/entity-type-constants'
+import type { ForeignTable } from '@/data/table-editor/table-editor-types'
+import { useTableEditorFiltersSort } from '@/hooks/misc/useTableEditorFiltersSort'
+import { parseSearch, stringifySearch } from '@/lib/router-search-params'
+import {
+ TableEditorTableStateContextProvider,
+ useTableEditorTableStateSnapshot,
+} from '@/state/table-editor-table'
+
+vi.mock('next/router', () => import('@/compat/next/router'))
+
+const unfiltered = '/project/default/editor/1?schema=public'
+
+// The hooks only read `id`; a foreign table is the smallest complete `Entity`.
+const table: ForeignTable = {
+ entity_type: ENTITY_TYPE.FOREIGN_TABLE,
+ id: 1,
+ // Empty schema skips the index advisor provider and its project queries.
+ schema: '',
+ name: 'colors',
+ comment: null,
+ foreign_server_name: '',
+ foreign_data_wrapper_name: '',
+ foreign_data_wrapper_handler: '',
+ columns: [],
+}
+
+let snap: ReturnType<typeof useTableEditorTableStateSnapshot>
+let sortParams: ReturnType<typeof useTableEditorFiltersSort>
+
+function FiltersProbe() {
+ snap = useTableEditorTableStateSnapshot()
+ useInitializeFiltersFromUrl()
+ useSyncFiltersToUrl()
+ return <output data-testid="filters">{snap.filters.map((f) => f.value).join(',')}</output>
+}
+
+// A separate instance, like the sort controls.
+function SortProbe() {
+ sortParams = useTableEditorFiltersSort()
+ return null
+}
+
+const getHistoryIndex = () => (window.history.state as { __TSR_index?: number }).__TSR_index
+
+async function renderTableAt(url: string) {
+ window.history.replaceState(null, '', url)
+ const history = createBrowserHistory()
+ // Browsers run microtasks between `popstate` listeners, so React renders (and runs effects for)
+ // the router's update before the hook's own listener. jsdom doesn't; flush here to match.
+ const flushReact = () => flushSync(() => {})
+ window.addEventListener('popstate', flushReact)
+ const root = createRootRoute({ component: Outlet })
+ const route = createRoute({
+ getParentRoute: () => root,
+ path: '/project/$ref/editor/$id',
+ component: () => (
+ <TableEditorTableStateContextProvider projectRef="default" table={table}>
+ <FiltersProbe />
+ <SortProbe />
+ </TableEditorTableStateContextProvider>
+ ),
+ })
+ const router = createRouter({
+ routeTree: root.addChildren([route]),
+ history,
+ parseSearch,
+ stringifySearch,
+ isServer: false,
+ })
+ await router.load()
+ const view = render(<RouterProvider router={router} />)
+ return {
+ history,
+ cleanup: () => {
+ view.unmount()
+ history.destroy()
+ window.removeEventListener('popstate', flushReact)
+ },
+ }
+}
+
+// Outlasts the 500ms state → URL debounce, so any sync push would have landed.
+const settle = () => act(() => new Promise((resolve) => setTimeout(resolve, 700)))
+
+const red = { column: 'name', operator: '=' as const, value: 'Red' }
+const filteredByRed = `${unfiltered}&filter=name%3Aeq%3ARed`
+
+describe('useSyncFiltersToUrl', () => {
+ it('follows Back/Forward between entries of the same table without adding entries', async () => {
+ const { history, cleanup } = await renderTableAt(unfiltered)
+
+ try {
+ await act(async () => snap.setFilters([{ column: 'name', operator: '=', value: 'Red' }]))
+ await waitFor(() => expect(window.location.search).toContain('filter=name%3Aeq%3ARed'))
+ const filteredIndex = getHistoryIndex()
+
+ await act(async () => history.back())
+ await waitFor(() => expect(window.location.search).not.toContain('filter'))
+ await waitFor(() => expect(screen.getByTestId('filters')).toBeEmptyDOMElement())
+
+ await act(async () => history.forward())
+ await waitFor(() => expect(screen.getByTestId('filters')).toHaveTextContent('Red'))
+
+ await settle()
+ expect(getHistoryIndex()).toBe(filteredIndex)
+ expect(window.location.search).toContain('filter=name%3Aeq%3ARed')
+ } finally {
+ cleanup()
+ }
+ })
+
+ it('discards a pending edit on Back to an entry that differs only by sort', async () => {
+ const { history, cleanup } = await renderTableAt(filteredByRed)
+
+ try {
+ await waitFor(() => expect(screen.getByTestId('filters')).toHaveTextContent('Red'))
+ await settle()
+ const unsortedIndex = getHistoryIndex()
+ await act(async () => sortParams.setParams((prev) => ({ ...prev, sort: ['name:asc'] })))
+ await waitFor(() => expect(window.location.search).toContain('sort='))
+
+ // Edit, then Back before the debounced push; the router's popstate listener runs first
+ await act(async () => snap.setFilters([{ ...red, value: 'Green' }]))
+ await act(async () => history.back())
+ await settle()
+
+ expect(screen.getByTestId('filters')).toHaveTextContent('Red')
+ expect(window.location.pathname + window.location.search).toBe(filteredByRed)
+ expect(getHistoryIndex()).toBe(unsortedIndex)
+ } finally {
+ cleanup()
+ }
+ })
+
+ it("builds a later sort push on the current URL, not the router's lagging query", async () => {
+ const { cleanup } = await renderTableAt(unfiltered)
+
+ try {
+ await act(async () => snap.setFilters([red]))
+ await waitFor(() => expect(window.location.search).toContain('filter=name%3Aeq%3ARed'))
+ await settle()
+
+ await act(async () => sortParams.setParams((prev) => ({ ...prev, sort: ['name:asc'] })))
+ await waitFor(() => expect(window.location.search).toContain('sort=name%3Aasc'))
+ expect(window.location.search).toContain('filter=name%3Aeq%3ARed')
+
+ await act(async () => sortParams.setParams((prev) => ({ ...prev, sort: [] })))
+ await waitFor(() => expect(window.location.search).not.toContain('sort='))
+ expect(window.location.search).toContain('filter=name%3Aeq%3ARed')
+ } finally {
+ cleanup()
+ }
+ })
+
+ it('does not re-push restored filters, which would reorder params and drop Forward', async () => {
+ const filteredSorted = `${unfiltered}&filter=name%3Aeq%3ARed&sort=name%3Aasc`
+ const { history, cleanup } = await renderTableAt(filteredSorted)
+
+ try {
+ await waitFor(() => expect(screen.getByTestId('filters')).toHaveTextContent('Red'))
+ await settle()
+ const loadedIndex = getHistoryIndex()
+
+ await act(async () => snap.setFilters([]))
+ await waitFor(() => expect(window.location.search).not.toContain('filter'))
+ expect(getHistoryIndex()).toBe(loadedIndex! + 1)
+
+ await act(async () => history.back())
+ await waitFor(() => expect(screen.getByTestId('filters')).toHaveTextContent('Red'))
+ await settle()
+ expect(getHistoryIndex()).toBe(loadedIndex)
+ expect(window.location.pathname + window.location.search).toBe(filteredSorted)
+
+ await act(async () => history.forward())
+ await waitFor(() => expect(screen.getByTestId('filters')).toBeEmptyDOMElement())
+ expect(getHistoryIndex()).toBe(loadedIndex! + 1)
+ } finally {
+ cleanup()
+ }
+ })
+})
diff --git a/apps/studio/components/grid/hooks/useFilterLifeCycle.test.tsx b/apps/studio/components/grid/hooks/useFilterLifeCycle.test.tsx
new file mode 100644
index 00000000000..927e49f6d92
--- /dev/null
+++ b/apps/studio/components/grid/hooks/useFilterLifeCycle.test.tsx
@@ -0,0 +1,198 @@
+import { act, render, screen } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { useSyncFiltersToUrl } from './useFilterLifeCycle'
+import { ENTITY_TYPE } from '@/data/entity-types/entity-type-constants'
+import type { ForeignTable } from '@/data/table-editor/table-editor-types'
+import {
+ TableEditorTableStateContextProvider,
+ useTableEditorTableStateSnapshot,
+} from '@/state/table-editor-table'
+
+// Router-agnostic: the hook only sees what useTableEditorFiltersSort reads from the URL.
+const url = vi.hoisted(() => ({
+ path: '/project/default/editor/1',
+ filters: [] as string[],
+ sorts: [] as string[],
+ setParams: vi.fn(),
+}))
+vi.mock('@/hooks/misc/useTableEditorFiltersSort', () => ({
+ // Like the real hook, setParams changes identity whenever the URL params do.
+ useTableEditorFiltersSort: () => ({
+ path: url.path,
+ filters: url.filters,
+ sorts: url.sorts,
+ setParams: (...args: unknown[]) => url.setParams(...args),
+ }),
+}))
+
+const table: ForeignTable = {
+ entity_type: ENTITY_TYPE.FOREIGN_TABLE,
+ id: 1,
+ // Empty schema skips the index advisor provider and its project queries.
+ schema: '',
+ name: 'colors',
+ comment: null,
+ foreign_server_name: '',
+ foreign_data_wrapper_name: '',
+ foreign_data_wrapper_handler: '',
+ columns: [],
+}
+
+let snap: ReturnType<typeof useTableEditorTableStateSnapshot>
+
+function Probe() {
+ snap = useTableEditorTableStateSnapshot()
+ useSyncFiltersToUrl()
+ return <output data-testid="filters">{snap.filters.map((f) => f.value).join(',')}</output>
+}
+
+// A fresh element each time, so a rerender re-reads the mocked URL.
+const getUi = () => (
+ <TableEditorTableStateContextProvider projectRef="default" table={table}>
+ <Probe />
+ </TableEditorTableStateContextProvider>
+)
+
+const renderProbe = () => {
+ const view = render(getUi())
+ // valtio notifies subscribers in a microtask, so flush it with an async act
+ return { rerender: () => act(async () => view.rerender(getUi())) }
+}
+
+const red = { column: 'name', operator: '=' as const, value: 'Red' }
+
+// Like a browser Back/Forward: the URL is already the destination when `popstate` fires, and the
+// router (here, the mocked URL source) catches up on the next render.
+const popStateTo = (filters: string[]) => {
+ const search = new URLSearchParams(filters.map((filter) => ['filter', filter]))
+ window.history.replaceState(null, '', `${url.path}?${search}`)
+ window.dispatchEvent(new PopStateEvent('popstate'))
+}
+
+describe('useSyncFiltersToUrl', () => {
+ beforeEach(() => {
+ vi.useFakeTimers()
+ url.path = '/project/default/editor/1'
+ url.filters = []
+ url.sorts = []
+ url.setParams.mockClear()
+ })
+ afterEach(() => vi.useRealTimers())
+
+ it('adopts an external URL change without pushing it back', async () => {
+ const { rerender } = renderProbe()
+ act(() => vi.runAllTimers())
+ url.setParams.mockClear()
+
+ url.filters = ['name:eq:Red']
+ await rerender()
+ expect(screen.getByTestId('filters')).toHaveTextContent('Red')
+
+ act(() => vi.advanceTimersByTime(1000))
+ expect(url.setParams).not.toHaveBeenCalled()
+ })
+
+ it('lets the URL win over a pending state → URL update', async () => {
+ const { rerender } = renderProbe()
+ await act(async () => snap.setFilters([red]))
+
+ url.filters = ['name:eq:Blue']
+ await rerender()
+ act(() => vi.advanceTimersByTime(1000))
+
+ expect(screen.getByTestId('filters')).toHaveTextContent('Blue')
+ expect(url.setParams).not.toHaveBeenCalled()
+ })
+
+ it('ignores the echo of its own push even if state moved on', async () => {
+ const { rerender } = renderProbe()
+ await act(async () => snap.setFilters([red]))
+ act(() => vi.advanceTimersByTime(500))
+ expect(url.setParams).toHaveBeenCalledTimes(1)
+
+ await act(async () => snap.setFilters([{ ...red, value: 'Green' }]))
+ url.filters = ['name:eq:Red']
+ await rerender()
+
+ expect(screen.getByTestId('filters')).toHaveTextContent('Green')
+ // The newer edit is still pushed once its debounce elapses
+ act(() => vi.advanceTimersByTime(500))
+ expect(url.setParams).toHaveBeenCalledTimes(2)
+ expect(url.setParams.mock.lastCall?.[0]({})).toEqual({ filter: ['name:eq:Green'] })
+ })
+
+ it('discards a pending edit on Back to an entry with the same filters', async () => {
+ url.sorts = ['name:asc']
+ const { rerender } = renderProbe()
+ await act(async () => snap.setFilters([red]))
+
+ // Back to the pre-sort entry: `filter` is unchanged, only `sort` differs
+ await act(async () => popStateTo([]))
+ url.sorts = []
+ await rerender()
+ act(() => vi.advanceTimersByTime(1000))
+
+ expect(screen.getByTestId('filters')).toBeEmptyDOMElement()
+ expect(url.setParams).not.toHaveBeenCalled()
+ })
+
+ it('cancels a pending push on Back to an entry that already has the edited filters', async () => {
+ const { rerender } = renderProbe()
+ await act(async () => snap.setFilters([red]))
+
+ await act(async () => popStateTo(['name:eq:Red']))
+ url.filters = ['name:eq:Red']
+ await rerender()
+ act(() => vi.advanceTimersByTime(1000))
+
+ expect(screen.getByTestId('filters')).toHaveTextContent('Red')
+ expect(url.setParams).not.toHaveBeenCalled()
+ })
+
+ it('keeps a pending filter edit when a sort changes the URL', async () => {
+ const { rerender } = renderProbe()
+ await act(async () => snap.setFilters([red]))
+
+ url.sorts = ['name:asc']
+ await rerender()
+ act(() => vi.advanceTimersByTime(500))
+
+ expect(screen.getByTestId('filters')).toHaveTextContent('Red')
+ expect(url.setParams).toHaveBeenCalledTimes(1)
+ })
+
+ it('still pushes when identical filters are re-applied before the debounce fires', async () => {
+ const { rerender } = renderProbe()
+ await act(async () => snap.setFilters([red]))
+ act(() => vi.advanceTimersByTime(300))
+
+ // The filter bar re-applies the same filters on blur/Escape as a new array. valtio alone
+ // doesn't re-render for equal contents; the blur's own UI state update does.
+ await act(async () => snap.setFilters([{ ...red }]))
+ await rerender()
+ act(() => vi.advanceTimersByTime(500))
+
+ expect(url.setParams).toHaveBeenCalledTimes(1)
+ expect(url.setParams.mock.lastCall?.[0]({})).toEqual({ filter: ['name:eq:Red'] })
+ })
+
+ it('cancels a pending push on unmount', async () => {
+ const view = render(getUi())
+ await act(async () => snap.setFilters([red]))
+ view.unmount()
+ act(() => vi.advanceTimersByTime(1000))
+
+ expect(url.setParams).not.toHaveBeenCalled()
+ })
+
+ it("ignores another table's URL while navigation is pending", async () => {
+ const { rerender } = renderProbe()
+
+ url.path = '/project/default/editor/2'
+ url.filters = ['name:eq:Red']
+ await rerender()
+
+ expect(screen.getByTestId('filters')).toBeEmptyDOMElement()
+ })
+})
diff --git a/apps/studio/components/grid/hooks/useFilterLifeCycle.ts b/apps/studio/components/grid/hooks/useFilterLifeCycle.ts
index a86f43cb67d..4fced12b623 100644
--- a/apps/studio/components/grid/hooks/useFilterLifeCycle.ts
+++ b/apps/studio/components/grid/hooks/useFilterLifeCycle.ts
@@ -1,9 +1,17 @@
import { useEffect, useEffectEvent, useRef } from 'react'
import { filtersToUrlParams, formatFilterURLParams } from '../SupabaseGrid.utils'
+import type { Filter } from '../types'
import { useTableEditorFiltersSort } from '@/hooks/misc/useTableEditorFiltersSort'
import { useTableEditorTableStateSnapshot } from '@/state/table-editor-table'
+const getUrlTableId = (path: string) => path.match(/\/editor\/(\d+)\/?$/)?.[1]
+
+const toUrlFilters = (filters: readonly Filter[]) =>
+ filtersToUrlParams(
+ filters.filter(({ value }) => value !== '' && value !== null && value !== undefined)
+ )
+
/**
* Hook to initialize filters from URL on mount.
* This runs once when the component mounts to handle bookmarked/filtered URLs.
@@ -26,16 +34,76 @@ export function useInitializeFiltersFromUrl() {
}
/**
- * Hook to sync filters from snap state to URL params.
- * This is a one-way sync: snap state → URL (for bookmarking/sharing).
- * Debounced by 500ms to avoid excessive URL updates.
+ * Hook to keep filters in snap state and URL params in sync.
+ * snap state → URL is debounced by 500ms to avoid excessive URL updates.
+ * URL → snap state covers URL changes that don't remount the grid (e.g. Back/Forward within the
+ * same table). The URL wins over a pending state → URL update since it reflects the user's latest
+ * navigation: a filter applied less than 500ms before Back/Forward is intentionally discarded rather
+ * than pushed over the entry the user navigated to.
*/
export function useSyncFiltersToUrl() {
const snap = useTableEditorTableStateSnapshot()
- const { setParams } = useTableEditorFiltersSort()
+ const { path, filters: urlFilters, setParams } = useTableEditorFiltersSort()
const timeoutRef = useRef<NodeJS.Timeout | null>(null)
const previousFiltersRef = useRef<string>('')
+ const urlFiltersKey = JSON.stringify(urlFilters)
+ // Under TanStack the URL moves to the next table before this grid unmounts.
+ const isOwnTableUrl = getUrlTableId(path) === String(snap.originalTable.id)
+ const lastUrlFiltersKeyRef = useRef(urlFiltersKey)
+ const pushedUrlFiltersKeyRef = useRef<string | null>(null)
+
+ // Back/Forward cancels a pending push outright and re-adopts the destination's filters, even if
+ // its `filter` param matches the previous entry (e.g. only the sort differs). Other URL changes
+ // (e.g. a sort) must not drop an in-flight filter edit. The browser URL is already updated when
+ // `popstate` fires, so this doesn't depend on whether the router's own listener runs first.
+ const handleHistoryNavigation = useEffectEvent(() => {
+ if (timeoutRef.current) {
+ clearTimeout(timeoutRef.current)
+ timeoutRef.current = null
+ }
+ pushedUrlFiltersKeyRef.current = null
+ if (getUrlTableId(window.location.pathname) !== String(snap.originalTable.id)) return
+
+ const filters = new URLSearchParams(window.location.search).getAll('filter')
+ const filtersKey = JSON.stringify(filters)
+ lastUrlFiltersKeyRef.current = filtersKey
+ if (filtersKey !== JSON.stringify(toUrlFilters(snap.filters))) {
+ snap.setFilters(formatFilterURLParams(filters))
+ }
+ })
+
+ useEffect(() => {
+ const handlePopState = () => handleHistoryNavigation()
+ window.addEventListener('popstate', handlePopState)
+ return () => window.removeEventListener('popstate', handlePopState)
+ }, [])
+
+ const syncFiltersFromUrl = useEffectEvent(() => {
+ if (!isOwnTableUrl || urlFiltersKey === lastUrlFiltersKeyRef.current) return
+ lastUrlFiltersKeyRef.current = urlFiltersKey
+
+ // Our own debounced push arriving, or a URL that already matches state
+ const isOwnPush = urlFiltersKey === pushedUrlFiltersKeyRef.current
+ pushedUrlFiltersKeyRef.current = null
+ if (isOwnPush || urlFiltersKey === JSON.stringify(toUrlFilters(snap.filters))) return
+
+ if (timeoutRef.current) {
+ clearTimeout(timeoutRef.current)
+ timeoutRef.current = null
+ }
+ snap.setFilters(formatFilterURLParams(urlFilters))
+ })
+
+ useEffect(() => {
+ syncFiltersFromUrl()
+ }, [urlFiltersKey, isOwnTableUrl])
+
+ // An Effect Event so URL changes (new `setParams`) don't cancel a pending push.
+ const pushFiltersToUrl = useEffectEvent((filter: string[]) => {
+ setParams((prev) => ({ ...prev, filter }))
+ })
+
useEffect(() => {
// Serialize filters for comparison
const currentFiltersStr = JSON.stringify(snap.filters)
@@ -52,28 +120,24 @@ export function useSyncFiltersToUrl() {
clearTimeout(timeoutRef.current)
}
+ // The URL already reflects these filters (e.g. they were just read from it)
+ const nextUrlFilters = toUrlFilters(snap.filters)
+ const nextUrlFiltersKey = JSON.stringify(nextUrlFilters)
+ if (nextUrlFiltersKey === lastUrlFiltersKeyRef.current) return
+
// Debounce URL updates by 500ms
timeoutRef.current = setTimeout(() => {
- const completeFilters = snap.filters.filter((filter) => {
- const value = filter.value
- return value !== '' && value !== null && value !== undefined
- })
-
- // Convert filters to URL format
- const urlFilters = filtersToUrlParams(completeFilters)
-
- // Update URL params
- setParams((prev) => ({
- ...prev,
- filter: urlFilters,
- }))
+ pushedUrlFiltersKeyRef.current = nextUrlFiltersKey
+ pushFiltersToUrl(nextUrlFilters)
}, 500)
+ // No cleanup here: a re-run with identical filters (e.g. the filter bar re-applying them on
+ // blur) must not cancel the pending push. Real changes clear it above.
+ }, [snap.filters])
- // Cleanup on unmount or filter change
+ // Cancel on unmount so a previous table's pending push can't land on the next table's URL.
+ useEffect(() => {
return () => {
- if (timeoutRef.current) {
- clearTimeout(timeoutRef.current)
- }
+ if (timeoutRef.current) clearTimeout(timeoutRef.current)
}
- }, [snap.filters, setParams])
+ }, [])
}
diff --git a/apps/studio/components/interfaces/TableGridEditor/TableGridEditor.tsx b/apps/studio/components/interfaces/TableGridEditor/TableGridEditor.tsx
index d0620dbde74..cbda689496a 100644
--- a/apps/studio/components/interfaces/TableGridEditor/TableGridEditor.tsx
+++ b/apps/studio/components/interfaces/TableGridEditor/TableGridEditor.tsx
@@ -158,7 +158,8 @@ export const TableGridEditor = ({
</div>
) : (
<TableEditorTableStateContextProvider
- key={`table-editor-table-${selectedTable.id}`}
+ // Table ids are per-database OIDs, so the same id can exist in another project.
+ key={`table-editor-table-${projectRef}-${selectedTable.id}`}
projectRef={projectRef}
table={selectedTable}
editable={editable}
diff --git a/apps/studio/hooks/misc/__tests__/useTableEditorFiltersSort.overlap.navigation.test.tsx b/apps/studio/hooks/misc/__tests__/useTableEditorFiltersSort.overlap.navigation.test.tsx
new file mode 100644
index 00000000000..72076cfd56a
--- /dev/null
+++ b/apps/studio/hooks/misc/__tests__/useTableEditorFiltersSort.overlap.navigation.test.tsx
@@ -0,0 +1,84 @@
+import {
+ createBrowserHistory,
+ createRootRoute,
+ createRoute,
+ createRouter,
+ Outlet,
+ RouterProvider,
+} from '@tanstack/react-router'
+import { act, render, waitFor } from '@testing-library/react'
+import { describe, expect, it, vi } from 'vitest'
+
+import { useTableEditorFiltersSort } from '../useTableEditorFiltersSort'
+import { parseSearch, stringifySearch } from '@/lib/router-search-params'
+
+vi.mock('next/router', () => import('@/compat/next/router'))
+
+type SetParams = ReturnType<typeof useTableEditorFiltersSort>['setParams']
+const hooks: { sort?: SetParams; filter?: SetParams } = {}
+
+// Separate instances, like useTableSort and useSyncFiltersToUrl in the grid.
+function SortProbe() {
+ hooks.sort = useTableEditorFiltersSort().setParams
+ return null
+}
+function FilterProbe() {
+ hooks.filter = useTableEditorFiltersSort().setParams
+ return null
+}
+
+async function renderAt(url: string) {
+ window.history.replaceState(null, '', url)
+ const history = createBrowserHistory()
+ const root = createRootRoute({ component: Outlet })
+ const route = createRoute({
+ getParentRoute: () => root,
+ path: '/project/$ref/editor/$id',
+ component: () => (
+ <>
+ <SortProbe />
+ <FilterProbe />
+ </>
+ ),
+ })
+ const router = createRouter({
+ routeTree: root.addChildren([route]),
+ history,
+ parseSearch,
+ stringifySearch,
+ isServer: false,
+ })
+ await router.load()
+ const view = render(<RouterProvider router={router} />)
+ return () => {
+ view.unmount()
+ history.destroy()
+ }
+}
+
+const getParams = () => new URLSearchParams(window.location.search)
+
+describe('useTableEditorFiltersSort setParams with overlapping pushes (TanStack)', () => {
+ it.each([
+ ['sort then filter', ['sort', 'filter'] as const],
+ ['filter then sort', ['filter', 'sort'] as const],
+ ])('keeps both params when pushed %s before the router updates', async (_, order) => {
+ const cleanup = await renderAt('/project/default/editor/1?schema=public&filter=name:eq:Red')
+ try {
+ act(() => {
+ for (const key of order) {
+ if (key === 'sort') hooks.sort?.((prev) => ({ ...prev, sort: ['id:desc'] }))
+ else hooks.filter?.((prev) => ({ ...prev, filter: ['name:eq:Green'] }))
+ }
+ })
+ await waitFor(() => {
+ expect(getParams().getAll('filter')).toEqual(['name:eq:Green'])
+ expect(getParams().getAll('sort')).toEqual(['id:desc'])
+ })
+ expect(window.location.pathname).toBe('/project/default/editor/1')
+ expect(getParams().get('schema')).toBe('public')
+ } finally {
+ cleanup()
+ }
+ })
+})
diff --git a/apps/studio/hooks/misc/__tests__/useTableEditorFiltersSort.overlap.test.tsx b/apps/studio/hooks/misc/__tests__/useTableEditorFiltersSort.overlap.test.tsx
new file mode 100644
index 00000000000..f036880dd69
--- /dev/null
+++ b/apps/studio/hooks/misc/__tests__/useTableEditorFiltersSort.overlap.test.tsx
@@ -0,0 +1,134 @@
+import { act, renderHook } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { useTableEditorFiltersSort } from '../useTableEditorFiltersSort'
+
+type Query = Record<string, string | string[]>
+
+// Like the Next pages router: `query`/`asPath` only reflect a shallow push once it settles.
+const router = vi.hoisted(() => {
+ const state = {
+ pathname: '/project/[ref]/editor/[id]',
+ query: {} as Query,
+ asPath: '',
+ settles: [] as Array<() => void>,
+ push: vi.fn(),
+ }
+ return state
+})
+vi.mock('next/router', () => ({ useRouter: () => router }))
+
+const toAsPath = (query: Query) => {
+ const { ref, id, ...search } = query
+ const params = new URLSearchParams()
+ for (const [key, value] of Object.entries(search)) {
+ for (const v of ([] as string[]).concat(value)) params.append(key, v)
+ }
+ return `/project/${ref}/editor/${id}?${params.toString()}`
+}
+
+const navigateTo = (query: Query) => {
+ router.query = query
+ router.asPath = toAsPath(query)
+}
+
+const settleAll = () =>
+ act(async () => {
+ for (const settle of router.settles.splice(0)) settle()
+ })
+
+const initialQuery: Query = { ref: 'default', id: '1', schema: 'public', filter: 'name:eq:Red' }
+
+describe('useTableEditorFiltersSort setParams with overlapping pushes', () => {
+ beforeEach(() => {
+ navigateTo(initialQuery)
+ router.settles = []
+ router.push.mockReset()
+ router.push.mockImplementation(({ query }: { query: Query }) => {
+ return new Promise<boolean>((resolve) => {
+ router.settles.push(() => {
+ navigateTo(query)
+ resolve(true)
+ })
+ })
+ })
+ })
+
+ it('a filter push after an unsettled sort push keeps the sort', async () => {
+ const sortHook = renderHook(() => useTableEditorFiltersSort()).result
+ const filterHook = renderHook(() => useTableEditorFiltersSort()).result
+
+ sortHook.current.setParams((prev) => ({ ...prev, sort: ['id:desc'] }))
+ filterHook.current.setParams((prev) => ({ ...prev, filter: ['name:eq:Green'] }))
+
+ expect(router.push.mock.lastCall?.[0].query).toEqual({
+ ...initialQuery,
+ filter: ['name:eq:Green'],
+ sort: ['id:desc'],
+ })
+ await settleAll()
+ expect(router.asPath).toContain('filter=name%3Aeq%3AGreen&sort=id%3Adesc')
+ })
+
+ it('a sort push after an unsettled filter push keeps the filter edit', async () => {
+ const filterHook = renderHook(() => useTableEditorFiltersSort()).result
+ const sortHook = renderHook(() => useTableEditorFiltersSort()).result
+
+ filterHook.current.setParams((prev) => ({ ...prev, filter: ['name:eq:Blue'] }))
+ sortHook.current.setParams((prev) => ({ ...prev, sort: ['id:asc'] }))
+
+ expect(router.push.mock.lastCall?.[0].query).toEqual({
+ ...initialQuery,
+ filter: ['name:eq:Blue'],
+ sort: ['id:asc'],
+ })
+ })
+
+ it('bases pushes on the router again once the previous push settled', async () => {
+ const { result } = renderHook(() => useTableEditorFiltersSort())
+ result.current.setParams((prev) => ({ ...prev, sort: ['id:desc'] }))
+ await settleAll()
+
+ // The URL moved on independently (e.g. another param) after the push settled
+ navigateTo({ ...router.query, schema: 'other' })
+ result.current.setParams((prev) => ({ ...prev, filter: [] }))
+
+ expect(router.push.mock.lastCall?.[0].query).toEqual({
+ ...initialQuery,
+ schema: 'other',
+ filter: [],
+ sort: ['id:desc'],
+ })
+ })
+
+ it('ignores an unsettled push once Back/Forward moved the router elsewhere', async () => {
+ const { result } = renderHook(() => useTableEditorFiltersSort())
+ result.current.setParams((prev) => ({ ...prev, sort: ['id:desc'] }))
+
+ navigateTo({ ref: 'default', id: '1', schema: 'public' })
+ result.current.setParams((prev) => ({ ...prev, filter: ['name:eq:Green'] }))
+
+ expect(router.push.mock.lastCall?.[0].query).toEqual({
+ ref: 'default',
+ id: '1',
+ schema: 'public',
+ filter: ['name:eq:Green'],
+ sort: [],
+ })
+ })
+
+ it('drops an unsettled push on Back/Forward even if it lands on the URL the push started from', async () => {
+ const { result } = renderHook(() => useTableEditorFiltersSort())
+ result.current.setParams((prev) => ({ ...prev, sort: ['id:desc'] }))
+
+ // The router is still on the starting URL, so only the popstate itself marks the push stale
+ window.dispatchEvent(new PopStateEvent('popstate'))
+ result.current.setParams((prev) => ({ ...prev, filter: ['name:eq:Green'] }))
+
+ expect(router.push.mock.lastCall?.[0].query).toEqual({
+ ...initialQuery,
+ filter: ['name:eq:Green'],
+ sort: [],
+ })
+ })
+})
diff --git a/apps/studio/hooks/misc/useTableEditorFiltersSort.ts b/apps/studio/hooks/misc/useTableEditorFiltersSort.ts
index e4c18a54ff0..830436444c5 100644
--- a/apps/studio/hooks/misc/useTableEditorFiltersSort.ts
+++ b/apps/studio/hooks/misc/useTableEditorFiltersSort.ts
@@ -1,11 +1,53 @@
import { useRouter } from 'next/router'
-import { useCallback, useMemo } from 'react'
+import { useCallback, useEffect, useMemo } from 'react'
+
+import { useLatest } from './useLatest'
+
+// Filter and sort pushes come from separate hook instances but write the same URL, and the router
+// only reflects a push once it settles. Until then, a later push merges onto the in-flight query
+// instead of the stale `router.query`. It only applies while the router still shows the URL it was
+// built from, so a settled push or a Back/Forward makes it obsolete.
+let inFlightPush: { fromAsPath: string; query: ReturnType<typeof useRouter>['query'] } | null = null
+
+const toParamArray = (value: string | string[] | undefined) =>
+ value === undefined ? [] : ([] as string[]).concat(value)
+
+type Router = ReturnType<typeof useRouter>
+
+/**
+ * The router's current query, with search params read from `asPath`. Under TanStack the compat
+ * router's `asPath` updates a render before its `query`, so `query` alone can be stale. Route
+ * params (the bracketed segments of the route pattern, e.g. `ref`, `id`) still come from `query`.
+ */
+const getCurrentQuery = (router: Router): Router['query'] => {
+ const search = new URLSearchParams(router.asPath.split('#')[0].split('?')[1] ?? '')
+ const query: Router['query'] = {}
+ for (const key of new Set(search.keys())) {
+ const values = search.getAll(key)
+ query[key] = values.length === 1 ? values[0] : values
+ }
+ for (const [, name] of router.pathname.matchAll(/\[{1,2}(?:\.\.\.)?([^\]]+)\]{1,2}/g)) {
+ if (router.query[name] !== undefined) query[name] = router.query[name]
+ }
+ return query
+}
export const useTableEditorFiltersSort = () => {
const router = useRouter()
+ // setParams runs from handlers and timers, possibly long after the render it was created in.
+ const latestRouter = useLatest(router)
const path = router.asPath.split(/[?#]/)[0]
+ // Back/Forward supersedes any in-flight push, even if it lands on the URL that push started from.
+ useEffect(() => {
+ const clearInFlightPush = () => {
+ inFlightPush = null
+ }
+ window.addEventListener('popstate', clearInFlightPush)
+ return () => window.removeEventListener('popstate', clearInFlightPush)
+ }, [])
+
const urlParams = useMemo(() => {
return new URLSearchParams(router.asPath.split('?')[1])
}, [router.asPath])
@@ -25,26 +67,30 @@ export const useTableEditorFiltersSort = () => {
const setParams = useCallback(
(fn: (prevParams: SetParamsArgs) => SetParamsArgs) => {
- const prevParams = { filter: filters, sort: sorts }
+ const router = latestRouter.current
+ const pending = inFlightPush?.fromAsPath === router.asPath ? inFlightPush : null
+ const baseQuery = pending?.query ?? getCurrentQuery(router)
+ const prevParams = {
+ filter: toParamArray(baseQuery.filter),
+ sort: toParamArray(baseQuery.sort),
+ }
const newParams = fn(prevParams)
const hasFilter = newParams.filter !== undefined
const hasSort = newParams.sort !== undefined
- router.push(
- {
- query: {
- ...router.query,
- ...(hasFilter ? { filter: newParams.filter } : {}),
- ...(hasSort ? { sort: newParams.sort } : {}),
- },
- },
- undefined,
- { shallow: true }
- )
+ const query = {
+ ...baseQuery,
+ ...(hasFilter ? { filter: newParams.filter } : {}),
+ ...(hasSort ? { sort: newParams.sort } : {}),
+ }
+ const push = { fromAsPath: router.asPath, query }
+ inFlightPush = push
+ void router.push({ query }, undefined, { shallow: true }).finally(() => {
+ if (inFlightPush === push) inFlightPush = null
+ })
},
- // eslint-disable-next-line react-hooks/exhaustive-deps
- [filters, sorts]
+ [latestRouter]
)
return {