The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
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)
}
})
})
})