The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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 comparisonconst 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 500mstimeoutRef.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.tsxindex 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.tsxnew file mode 100644index 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.tsxnew file mode 100644index 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.tsindex 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 !== undefinedconst 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 {