Skip to content

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

42.5 KB
Raw Blame
import { expect } from '@playwright/test'

import { createTable, dropTable, query } from '../utils/db/index.js'
import {
  addFilter,
  addFilterWithDropdownValue,
  getFilterBarInput,
  navigateToTable,
  selectColumnFilter,
  selectOperator,
  selectOperatorByClick,
  setupFilterBarPage,
  switchProperty,
} from '../utils/filter-bar-helpers.js'
import { test } from '../utils/test.js'
import { toUrl } from '../utils/to-url.js'
import { createApiResponseWaiter, waitForTableToLoad } from '../utils/wait-for-response.js'

const tableNamePrefix = 'pw_filter_bar'

function getDateValue(daysAgo: number): string {
  const date = new Date()
  date.setDate(date.getDate() - daysAgo)
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  return `${year}-${month}-${day}`
}

test.describe('Filter Bar', () => {
  test.beforeEach(async ({ page, ref }) => {
    await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
  })

  test.describe('Basic Filter Operations', () => {
    test('selecting a column creates a filter condition', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_col_sel`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await selectColumnFilter(page, columnName)

        await expect(page.getByTestId(`filter-condition-${columnName}`)).toBeVisible()
        await expect(page.getByTestId(`filter-operator-${columnName}`)).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('selecting a column without a value does not trigger a row request', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_no_value_no_req`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }, { name: 'Bob' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await expect(page.getByRole('gridcell', { name: 'Alice' })).toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'Bob' })).toBeVisible()

        // Count any new table-rows requests fired after the column/operator are picked.
        // A request here means the filter applied before a value was entered — the regression.
        let tableRowsRequests = 0
        const rowsListener = (request: { url: () => string }) => {
          if (request.url().includes('query?key=table-rows-')) tableRowsRequests++
        }
        page.on('request', rowsListener)

        try {
          await selectColumnFilter(page, columnName)
          await expect(page.getByTestId(`filter-condition-${columnName}`)).toBeVisible()

          await selectOperator(page, columnName, '=')

          // Allow any debounced request to fire before we assert.
          await page.waitForTimeout(500)

          expect(
            tableRowsRequests,
            'No table-rows request should fire until a filter value is entered'
          ).toBe(0)

          await expect(page.getByRole('gridcell', { name: 'Alice' })).toBeVisible()
          await expect(page.getByRole('gridcell', { name: 'Bob' })).toBeVisible()
        } finally {
          page.off('request', rowsListener)
        }
      } finally {
        await dropTable(tableName)
      }
    })

    test('entering value filters the grid', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_val_filt`
      const columnName = 'name'

      await createTable(tableName, columnName, [
        { name: 'Alice' },
        { name: 'Bob' },
        { name: 'Charlie' },
      ])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        await expect(page.getByRole('gridcell', { name: 'Alice' })).toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'Bob' })).not.toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'Charlie' })).not.toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('removing filter via X button restores all data', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_remove_x`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }, { name: 'Bob' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')
        await expect(page.getByRole('gridcell', { name: 'Bob' })).not.toBeVisible()

        await page.getByTestId(`filter-remove-${columnName}`).click()

        await expect(page.getByTestId(`filter-condition-${columnName}`)).not.toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'Alice' })).toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'Bob' })).toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('multiple filters can be added', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_multi`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          first_name text,
          last_name text
        )`
      )
      await query(
        `INSERT INTO ${tableName} (first_name, last_name) VALUES ('Alice', 'Smith'), ('Bob', 'Smith'), ('Alice', 'Jones')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, 'first_name', '=', 'Alice')
        await addFilter(page, ref, 'last_name', '=', 'Smith')

        await expect(page.getByTestId('filter-condition-first_name')).toBeVisible()
        await expect(page.getByTestId('filter-condition-last_name')).toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Keyboard Navigation - Freeform Input', () => {
    test('Enter selects column from dropdown', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_enter_col`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await freeformInput.fill(columnName)
        await expect(page.getByTestId(`filter-menu-item-${columnName}`)).toBeVisible()

        await page.keyboard.press('Enter')

        await expect(page.getByTestId(`filter-condition-${columnName}`)).toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('Tab exits filter bar to next DOM element', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_tab_exit`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await expect(freeformInput).toBeFocused()

        await page.keyboard.press('Tab')

        await expect(freeformInput).not.toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('ArrowDown/ArrowUp navigates dropdown items', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_arrow_nav`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          alpha text,
          beta text,
          gamma text
        )`
      )
      await query(`INSERT INTO ${tableName} (alpha, beta, gamma) VALUES ('a', 'b', 'g')`)

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()

        // Items: id (0), alpha (1), beta (2), gamma (3)
        await page.keyboard.press('ArrowDown')
        await page.keyboard.press('ArrowDown')
        await page.keyboard.press('Enter')

        await expect(page.getByTestId('filter-condition-beta')).toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('Backspace on empty input highlights last filter, second Backspace deletes it', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_bksp_hl_del`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await page.keyboard.press('Backspace')

        await expect(page.getByTestId(`filter-condition-${columnName}`)).toHaveAttribute(
          'data-highlighted',
          'true'
        )

        await page.keyboard.press('Backspace')

        await expect(page.getByTestId(`filter-condition-${columnName}`)).not.toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('ArrowLeft highlights previous condition', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_arrowl_hl`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await page.keyboard.press('ArrowLeft')

        await expect(page.getByTestId(`filter-condition-${columnName}`)).toHaveAttribute(
          'data-highlighted',
          'true'
        )
      } finally {
        await dropTable(tableName)
      }
    })

    test('ArrowRight clears highlight at end', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_arrowr_cl`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await page.keyboard.press('ArrowLeft')
        await expect(page.getByTestId(`filter-condition-${columnName}`)).toHaveAttribute(
          'data-highlighted',
          'true'
        )

        await page.keyboard.press('ArrowRight')
        await expect(page.getByTestId(`filter-condition-${columnName}`)).not.toHaveAttribute(
          'data-highlighted',
          'true'
        )
      } finally {
        await dropTable(tableName)
      }
    })

    test('Escape clears highlight', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_esc_cl`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await page.keyboard.press('ArrowLeft')
        await expect(page.getByTestId(`filter-condition-${columnName}`)).toHaveAttribute(
          'data-highlighted',
          'true'
        )

        await page.keyboard.press('Escape')
        await expect(page.getByTestId(`filter-condition-${columnName}`)).not.toHaveAttribute(
          'data-highlighted',
          'true'
        )
      } finally {
        await dropTable(tableName)
      }
    })

    test('Enter on highlighted condition focuses value input', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_enter_hl`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await page.keyboard.press('Backspace')
        await expect(page.getByTestId(`filter-condition-${columnName}`)).toHaveAttribute(
          'data-highlighted',
          'true'
        )

        await page.keyboard.press('Enter')
        await expect(page.getByTestId(`filter-value-${columnName}`)).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Keyboard Navigation - Operator Input', () => {
    test('Enter selects operator and focuses value', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_op_enter`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await selectColumnFilter(page, columnName)
        await page.keyboard.press('Enter')

        await expect(page.getByTestId(`filter-value-${columnName}`)).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('Enter on equals fallback applies filter and returns focus to freeform', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_op_default_equals`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'forgecode' }, { name: 'other' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await selectColumnFilter(page, columnName)

        const operatorInput = page.getByTestId(`filter-operator-${columnName}`)
        await operatorInput.fill('forgecode')

        await expect(page.getByText('Equals: "forgecode"')).toBeVisible()

        const rowsWaiter = createApiResponseWaiter(page, 'pg-meta', ref, 'query?key=table-rows-')
        await page.keyboard.press('Enter')
        await rowsWaiter

        await expect(getFilterBarInput(page)).toBeFocused()
        await expect(page.getByRole('gridcell', { name: 'forgecode' })).toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'other' })).not.toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('Backspace on empty operator removes condition', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_op_bksp`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await selectColumnFilter(page, columnName)

        const operatorInput = page.getByTestId(`filter-operator-${columnName}`)
        await operatorInput.fill('')
        await page.keyboard.press('Backspace')

        await expect(page.getByTestId(`filter-condition-${columnName}`)).not.toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Keyboard Navigation - Value Input', () => {
    test('Enter on value moves focus to group freeform', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_val_enter`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        await expect(getFilterBarInput(page)).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('Backspace on empty value moves to operator', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_val_bksp`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await selectColumnFilter(page, columnName)
        await selectOperator(page, columnName, '=')

        await page.keyboard.press('Backspace')

        await expect(page.getByTestId(`filter-operator-${columnName}`)).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('ArrowLeft at position 0 moves to previous condition value', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_val_arrowl`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          first_name text,
          last_name text
        )`
      )
      await query(
        `INSERT INTO ${tableName} (first_name, last_name) VALUES ('Alice', 'Smith'), ('Bob', 'Jones')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, 'first_name', '=', 'Alice')
        await addFilter(page, ref, 'last_name', '=', 'Smith')

        const lastNameValue = page.getByTestId('filter-value-last_name')
        await lastNameValue.click()
        // Drive the cursor to position 0 directly rather than via `Home` —
        // macOS Chromium doesn't honor the Home key inside text inputs (the
        // OS-level binding is Cmd+ArrowLeft / Fn+ArrowLeft).
        await lastNameValue.evaluate((el) => (el as HTMLInputElement).setSelectionRange(0, 0))

        await page.keyboard.press('ArrowLeft')

        await expect(page.getByTestId('filter-value-first_name')).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('ArrowRight at end moves to next condition or freeform', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_val_arrowr`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        // Use keyboard to focus value: highlight condition then Enter to avoid re-opening dropdown
        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await page.keyboard.press('Backspace')
        await page.keyboard.press('Enter')

        await expect(page.getByTestId(`filter-value-${columnName}`)).toBeFocused()
        await page.keyboard.press('End')
        await page.keyboard.press('ArrowRight')

        await expect(freeformInput).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('editing value in the middle preserves cursor position', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_cursor_pos`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'test' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await selectColumnFilter(page, columnName)
        await selectOperator(page, columnName, '=')

        const valueInput = page.getByTestId(`filter-value-${columnName}`)
        await valueInput.fill('HelloWorld')

        // See "ArrowLeft at position 0" — macOS Chromium ignores the Home
        // key inside text inputs, so set the cursor programmatically.
        await valueInput.evaluate((el) => (el as HTMLInputElement).setSelectionRange(5, 5))
        await page.keyboard.type('_Middle_')

        await expect(valueInput).toHaveValue('Hello_Middle_World')
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Boolean Column Filters', () => {
    test('filtering by true shows only true rows', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_bool_true`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          is_active boolean
        )`
      )
      await query(`INSERT INTO ${tableName} (is_active) VALUES (true), (false), (true)`)

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'is_active', '=', 'true')

        const rows = page.locator('[role="row"]')
        // Header row + 2 data rows with true
        await expect(rows).toHaveCount(3)
      } finally {
        await dropTable(tableName)
      }
    })

    test('filtering by false shows only false rows', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_bool_false`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          is_active boolean
        )`
      )
      await query(`INSERT INTO ${tableName} (is_active) VALUES (true), (false), (true)`)

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'is_active', '=', 'false')

        const rows = page.locator('[role="row"]')
        // Header row + 1 data row with false
        await expect(rows).toHaveCount(2)
      } finally {
        await dropTable(tableName)
      }
    })

    test('not equal operator with boolean filters correctly', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_bool_neq`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          is_active boolean
        )`
      )
      await query(`INSERT INTO ${tableName} (is_active) VALUES (true), (false), (true)`)

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'is_active', '<>', 'true')

        const rows = page.locator('[role="row"]')
        // Header row + 1 data row with false (not equal to true)
        await expect(rows).toHaveCount(2)
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Date Column Filters', () => {
    test('filtering by Today shows only today rows', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_date_today`
      const todayValue = getDateValue(0)
      const yesterdayValue = getDateValue(1)
      const lastWeekValue = getDateValue(7)

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          created_at date
        )`
      )
      // Insert exact date strings computed from the test's `getDateValue`
      // (JS local TZ) rather than `CURRENT_DATE` (postgres session TZ ≈ UTC).
      // The studio's "Today" dropdown is built from JS local time too, so
      // aligning the inserted rows with the filter's expected value keeps
      // these tests deterministic across timezones — otherwise on non-UTC
      // hosts the local "today" can land on a different day than postgres'
      // CURRENT_DATE and the filter matches zero rows.
      await query(
        `INSERT INTO ${tableName} (created_at) VALUES
          ('${todayValue}'),
          ('${yesterdayValue}'),
          ('${lastWeekValue}')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'created_at', '=', todayValue)

        const rows = page.locator('[role="row"]')
        await expect(rows).toHaveCount(2)
      } finally {
        await dropTable(tableName)
      }
    })

    test('filtering by Yesterday shows only yesterday rows', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_date_yest`
      const todayValue = getDateValue(0)
      const yesterdayValue = getDateValue(1)
      const lastWeekValue = getDateValue(7)

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          created_at date
        )`
      )
      // See "filtering by Today" — align inserts with JS-local getDateValue.
      await query(
        `INSERT INTO ${tableName} (created_at) VALUES
          ('${todayValue}'),
          ('${yesterdayValue}'),
          ('${lastWeekValue}')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'created_at', '=', yesterdayValue)

        const rows = page.locator('[role="row"]')
        await expect(rows).toHaveCount(2)
      } finally {
        await dropTable(tableName)
      }
    })

    test('filtering by Last 7 days with greater or equal operator', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_date_7d`
      const todayValue = getDateValue(0)
      const threeDaysAgoValue = getDateValue(3)
      const last7DaysValue = getDateValue(7)
      const lastMonthValue = getDateValue(30)

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          created_at date
        )`
      )
      // See "filtering by Today" — align inserts with JS-local getDateValue.
      await query(
        `INSERT INTO ${tableName} (created_at) VALUES
          ('${todayValue}'),
          ('${threeDaysAgoValue}'),
          ('${last7DaysValue}'),
          ('${lastMonthValue}')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'created_at', '>=', last7DaysValue)

        const rows = page.locator('[role="row"]')
        await expect(rows).toHaveCount(4)
      } finally {
        await dropTable(tableName)
      }
    })

    test('date less than operator filters correctly', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_date_lt`
      const todayValue = getDateValue(0)
      const yesterdayValue = getDateValue(1)
      const lastWeekValue = getDateValue(7)

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          created_at date
        )`
      )
      // See "filtering by Today" — align inserts with JS-local getDateValue.
      await query(
        `INSERT INTO ${tableName} (created_at) VALUES
          ('${todayValue}'),
          ('${yesterdayValue}'),
          ('${lastWeekValue}')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'created_at', '<', todayValue)

        const rows = page.locator('[role="row"]')
        await expect(rows).toHaveCount(3)
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Timestamp Column Filters', () => {
    test('timestamp column shows date preset dropdown options', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_ts_today`
      const todayValue = getDateValue(0)
      const yesterdayValue = getDateValue(1)
      const lastWeekValue = getDateValue(7)

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          created_at timestamp
        )`
      )
      // See "filtering by Today" — pin timestamps to mid-day of each
      // JS-local date so the row falls on the correct calendar day from
      // postgres's perspective regardless of the host timezone.
      await query(
        `INSERT INTO ${tableName} (created_at) VALUES
          ('${todayValue} 12:00:00'),
          ('${yesterdayValue} 12:00:00'),
          ('${lastWeekValue} 12:00:00')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'created_at', '>=', todayValue)

        const rows = page.locator('[role="row"]')
        await expect(rows).toHaveCount(2)
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Keyboard Navigation - Dropdown Values', () => {
    test('ArrowDown/Enter navigates and selects dropdown value option', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_kb_dropdown`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          is_active boolean
        )`
      )
      await query(`INSERT INTO ${tableName} (is_active) VALUES (true), (false)`)

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await selectColumnFilter(page, 'is_active')
        await selectOperator(page, 'is_active', '=')

        await page.keyboard.press('ArrowDown')
        await page.keyboard.press('Enter')

        await expect(page.getByTestId('filter-condition-is_active')).toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('Shift+Tab exits filter bar to previous DOM element', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_shifttab_exit`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const freeformInput = getFilterBarInput(page)
        await freeformInput.click()
        await expect(freeformInput).toBeFocused()

        await page.keyboard.press('Shift+Tab')

        await expect(freeformInput).not.toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('IS NULL Filters', () => {
    test('IS NULL on a text column shows only null rows', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_is_null_txt`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          name text
        )`
      )
      await query(`INSERT INTO ${tableName} (name) VALUES ('Alice'), (NULL), ('Charlie')`)

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'name', 'is', 'null')

        const rows = page.locator('[role="row"]')
        // Header row + 1 data row with NULL
        await expect(rows).toHaveCount(2)
      } finally {
        await dropTable(tableName)
      }
    })

    test('IS NOT NULL on a text column shows only non-null rows', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_is_nnull_txt`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          name text
        )`
      )
      await query(`INSERT INTO ${tableName} (name) VALUES ('Alice'), (NULL), ('Charlie')`)

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'name', 'is', 'not null')

        const rows = page.locator('[role="row"]')
        // Header row + 2 data rows (Alice, Charlie)
        await expect(rows).toHaveCount(3)
      } finally {
        await dropTable(tableName)
      }
    })

    test('IS NULL on a timestamptz column shows only null rows', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_is_null_ts`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          created_at timestamptz
        )`
      )
      await query(
        `INSERT INTO ${tableName} (created_at) VALUES (NOW()), (NULL), (NOW() - INTERVAL '1 day')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilterWithDropdownValue(page, ref, 'created_at', 'is', 'null')

        const rows = page.locator('[role="row"]')
        // Header row + 1 data row with NULL
        await expect(rows).toHaveCount(2)
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Filter Error Feedback', () => {
    test('invalid filter value shows friendly error and remove button clears filters', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_err_fb`

      await createTable(tableName, 'name', [{ name: 'Alice' }, { name: 'Bob' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        // Apply a filter using the 'is' operator with an invalid value
        // 'is' only accepts null/not null/true/false, so 'badvalue' triggers a syntax error
        await selectColumnFilter(page, 'name')
        await selectOperatorByClick(page, 'name', 'is')

        const valueInput = page.getByTestId('filter-value-name')
        const rowsWaiter = createApiResponseWaiter(page, 'pg-meta', ref, 'query?key=table-rows-')
        await valueInput.fill('badvalue')
        await page.keyboard.press('Enter')
        await rowsWaiter

        // Should show the friendly filter error, not the scary general error
        await expect(page.getByText('No results found — check your filter values')).toBeVisible({
          timeout: 10000,
        })
        await expect(page.getByText("doesn't match the column's data type")).toBeVisible()

        const removeButton = page.getByRole('button', { name: 'Remove filters' })
        await expect(removeButton).toBeVisible()

        await removeButton.click()

        await expect(page.getByTestId('filter-condition-name')).not.toBeVisible({ timeout: 10000 })
        await expect(page.getByRole('gridcell', { name: 'Alice' })).toBeVisible({ timeout: 10000 })
        await expect(page.getByRole('gridcell', { name: 'Bob' })).toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Property Switching', () => {
    test('clicking property label opens picker and selecting new column switches the filter', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_prop_switch`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          first_name text,
          last_name text
        )`
      )
      await query(
        `INSERT INTO ${tableName} (first_name, last_name) VALUES ('Alice', 'Smith'), ('Bob', 'Jones')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, 'first_name', '=', 'Alice')
        await expect(page.getByTestId('filter-condition-first_name')).toBeVisible()

        await switchProperty(page, 'first_name', 'last_name')

        await expect(page.getByTestId('filter-condition-first_name')).not.toBeVisible()
        await expect(page.getByTestId('filter-condition-last_name')).toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })

    test('switching between same-type columns preserves compatible operator and value', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_prop_compat`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          first_name text,
          last_name text
        )`
      )
      await query(
        `INSERT INTO ${tableName} (first_name, last_name) VALUES ('Alice', 'Smith'), ('Bob', 'Smith'), ('Alice', 'Jones')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, 'first_name', '=', 'Alice')
        await expect(page.getByRole('gridcell', { name: 'Bob' })).not.toBeVisible()

        // '=' is compatible with text→text, so operator and value ("Alice") are preserved
        const rowsWaiter = createApiResponseWaiter(page, 'pg-meta', ref, 'query?key=table-rows-')
        await switchProperty(page, 'first_name', 'last_name')
        await rowsWaiter

        // last_name = Alice matches no rows (last names are Smith/Jones)
        const rows = page.locator('[role="row"]')
        await expect(rows).toHaveCount(1) // header only
      } finally {
        await dropTable(tableName)
      }
    })

    test('switching to column with incompatible operator resets operator', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_prop_incompat`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          name text,
          is_active boolean
        )`
      )
      await query(
        `INSERT INTO ${tableName} (name, is_active) VALUES ('Alice', true), ('Bob', false)`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        // '~~' (Like) only exists on text columns, not boolean
        await selectColumnFilter(page, 'name')
        await selectOperatorByClick(page, 'name', '~~')
        const valueInput = page.getByTestId('filter-value-name')
        await valueInput.fill('Alice')
        await page.keyboard.press('Enter')

        await switchProperty(page, 'name', 'is_active')

        await expect(page.getByTestId('filter-operator-is_active')).toBeFocused()
      } finally {
        await dropTable(tableName)
      }
    })

    test('Escape closes property picker without changing the filter', async ({ page, ref }) => {
      const tableName = `${tableNamePrefix}_prop_esc`
      const columnName = 'name'

      await createTable(tableName, columnName, [{ name: 'Alice' }, { name: 'Bob' }])

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, columnName, '=', 'Alice')

        const conditionEl = page.getByTestId(`filter-condition-${columnName}`)
        await conditionEl
          .getByRole('button', { name: `Change property from ${columnName}` })
          .click()

        const searchInput = page.getByTestId(`filter-property-search-${columnName}`)
        await expect(searchInput).toBeVisible()

        await page.keyboard.press('Escape')

        await expect(page.getByTestId(`filter-condition-${columnName}`)).toBeVisible()
        await expect(searchInput).not.toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })
  })

  test.describe('Stale Filter Cleanup', () => {
    test('stale filter on dropped column shows filter error with remove button', async ({
      page,
      ref,
    }) => {
      const tableName = `${tableNamePrefix}_stale_drop`

      await query(
        `CREATE TABLE IF NOT EXISTS ${tableName} (
          id bigint generated by default as identity primary key,
          first_name text,
          last_name text
        )`
      )
      await query(
        `INSERT INTO ${tableName} (first_name, last_name) VALUES ('Alice', 'Smith'), ('Bob', 'Jones')`
      )

      try {
        await setupFilterBarPage(page, ref, toUrl(`/project/${ref}/editor?schema=public`))
        await navigateToTable(page, ref, tableName)

        await addFilter(page, ref, 'first_name', '=', 'Alice')
        await expect(page.getByTestId('filter-condition-first_name')).toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'Alice' })).toBeVisible()
        await expect(page.getByRole('gridcell', { name: 'Bob' })).not.toBeVisible()

        await query(`ALTER TABLE ${tableName} DROP COLUMN first_name`)

        // Wait for the filter bar's debounced URL sync (500ms) before reloading
        await page.waitForURL(/filter=/, { timeout: 5000 })
        await page.reload({ waitUntil: 'networkidle' })

        await expect(page.getByText('No results found — check your filter values')).toBeVisible({
          timeout: 10000,
        })
        await expect(page.getByText('Failed to retrieve rows from table')).not.toBeVisible()

        const removeButton = page.getByRole('button', { name: 'Remove filters' })
        await expect(removeButton).toBeVisible()
        await removeButton.click()

        await expect(page.getByRole('gridcell', { name: 'Smith' })).toBeVisible({ timeout: 10000 })
        await expect(page.getByRole('gridcell', { name: 'Jones' })).toBeVisible()

        await expect(
          page.getByText('No results found — check your filter values')
        ).not.toBeVisible()
      } finally {
        await dropTable(tableName)
      }
    })
  })
})