@svgrid/enterprise 2.5.2 → 2.6.0

package/src/sources/field-inference.ts

@@ -1,63 +0,0 @@
-/**
- * Infer a richer form editor for an introspected field from its name + type, so
- * a database connected through Studio produces the same rich forms as the curated
- * sample apps (a `phone` column becomes a phone input, `rating` a star rating,
- * `email` an email field, `ssn` a masked input) instead of a wall of text boxes.
- *
- * DELIBERATELY CONSERVATIVE: it only refines on a clear name match, never touches
- * a primary key / relation / enum field, and never adds range validation that
- * could reject rows already in the user's database. Pure + node-safe. Applied by
- * the shared `buildEntitySchema` (Drizzle / Prisma / PostgREST / sample row) and
- * by the SQL-catalog path (`introspectDatabase`).
- */
-import type { RowData } from '@svgrid/grid'
-import type { EntityField } from '../schema.js'
-
-/** Masked-code patterns keyed by a field-name test. `#`=digit, `A`=letter, `*`=alnum. */
-const MASKS: Array<[RegExp, string]> = [
-  [/(^|_)ssn$|social.?security/, '###-##-####'],
-  [/(^|_)vin$/, '*****************'],
-  [/plate|registration/, 'AAA-####'],
-  [/isbn/, '###-#-#####-###-#'],
-  [/zip|postal/, '#####'],
-  [/(^|_)ein$|tax.?id|vat/, '##-#######'],
-]
-
-/**
- * Return a copy of `field` with an inferred `format` / `input.editorType` when the
- * name (and type) clearly imply one; otherwise return it unchanged.
- */
-export function refineField<T extends RowData = RowData>(field: EntityField<T>): EntityField<T> {
-  // Never override an explicit editor, a key, a relation, or an enum.
-  if (field.primaryKey || field.readonly || field.type === 'relation' || field.options?.length || field.input?.editorType) {
-    return field
-  }
-  const name = String(field.field).toLowerCase()
-  const withEditor = (editorType: NonNullable<EntityField['input']>['editorType'], extra: Record<string, unknown> = {}): EntityField<T> =>
-    ({ ...field, input: { ...(field.input ?? {}), editorType, ...extra } })
-
-  if (field.type === 'text') {
-    if (field.format == null) {
-      if (/e-?mail/.test(name)) return { ...field, format: 'email' }
-      if (/url|website|link|homepage|domain/.test(name)) return { ...field, format: 'url' }
-    }
-    if (/phone|mobile|(^|_)fax$|(^|_)tel(ephone)?$/.test(name)) return withEditor('phone')
-    if (/(^|_)country$|nationality/.test(name)) return withEditor('country')
-    if (/password|passwd|(^|_)pwd$/.test(name)) return { ...withEditor('password'), hidden: { grid: true } }
-    if (/colou?r$/.test(name)) return withEditor('color')
-    for (const [re, mask] of MASKS) if (re.test(name)) return withEditor('mask', { mask })
-  }
-
-  if (field.type === 'number') {
-    // Star rating (panel defaults max 5) or a 0-100 slider (panel defaults max 100).
-    if (/(^|_)(rating|score|stars|satisfaction|csat)$/.test(name)) return withEditor('rating')
-    if (/percent|progress|probability|completion|utili[sz]ation|occupancy|fuel.?level/.test(name)) return withEditor('slider')
-  }
-
-  return field
-}
-
-/** Refine every field of a schema's field list (leaves keys/relations/enums alone). */
-export function refineFields<T extends { fields: EntityField[] }>(schema: T): T {
-  return { ...schema, fields: schema.fields.map(refineField) }
-}

package/src/sources/filters.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import type { ServerFilterModel } from '@svgrid/grid'
-import { normalizeFilters } from './filters'
-
-const model = (columns: ServerFilterModel['columns'], global?: string): ServerFilterModel => ({
-  columns,
-  ...(global !== undefined ? { global } : {}),
-})
-
-describe('normalizeFilters', () => {
-  it('maps each operator to a neutral predicate', () => {
-    const { predicates } = normalizeFilters(
-      model({
-        a: { operator: 'contains', value: 'x' },
-        b: { operator: 'startsWith', value: 'y' },
-        c: { operator: 'equals', value: 'z' },
-        d: { operator: 'greaterThan', value: '5' },
-        e: { operator: 'lessThan', value: '9' },
-        f: { operator: 'between', value: '1', valueTo: '4' },
-        g: { operator: 'isBlank', value: '' },
-      }),
-    )
-    expect(predicates).toEqual([
-      { column: 'a', op: 'contains', value: 'x' },
-      { column: 'b', op: 'startsWith', value: 'y' },
-      { column: 'c', op: 'eq', value: 'z' },
-      { column: 'd', op: 'gt', value: '5' },
-      { column: 'e', op: 'lt', value: '9' },
-      { column: 'f', op: 'between', value: '1', valueTo: '4' },
-      { column: 'g', op: 'isNull' },
-    ])
-  })
-
-  it('prefers selectedValues (set filter) as an in predicate', () => {
-    const { predicates } = normalizeFilters(
-      model({ tier: { operator: 'contains', value: 'ignored', selectedValues: ['pro', 'free'] } }),
-    )
-    expect(predicates).toEqual([{ column: 'tier', op: 'in', values: ['pro', 'free'] }])
-  })
-
-  it('drops empty column values but keeps isBlank', () => {
-    const { predicates } = normalizeFilters(
-      model({ a: { operator: 'contains', value: '   ' }, b: { operator: 'isBlank', value: '' } }),
-    )
-    expect(predicates).toEqual([{ column: 'b', op: 'isNull' }])
-  })
-
-  it('backfills a one-sided between with the given bound', () => {
-    const { predicates } = normalizeFilters(model({ a: { operator: 'between', value: '3', valueTo: '' } }))
-    expect(predicates).toEqual([{ column: 'a', op: 'between', value: '3', valueTo: '3' }])
-  })
-
-  it('trims the global search and omits it when blank', () => {
-    expect(normalizeFilters(model({}, '  hi ')).search).toBe('hi')
-    expect(normalizeFilters(model({}, '   ')).search).toBeUndefined()
-    expect(normalizeFilters(undefined)).toEqual({ predicates: [], search: undefined })
-  })
-})

package/src/sources/filters.ts

@@ -1,70 +0,0 @@
-/**
- * Shared filter normalization for data-source adapters. The grid emits a
- * `ServerFilterModel` (per-column `{ operator, value, valueTo, selectedValues }`
- * plus a global search string); every backend then has to translate that into
- * its own query language. This turns the grid's model into one small, uniform
- * list of predicates so each adapter (Supabase, REST, ...) maps a handful of
- * clear cases instead of re-parsing the raw model.
- */
-import type { ServerFilterModel } from '@svgrid/grid'
-
-/** A backend-neutral predicate over a single column. */
-export type NormalizedPredicate =
-  | { column: string; op: 'in'; values: string[] }
-  | { column: string; op: 'isNull' }
-  | { column: string; op: 'contains' | 'startsWith' | 'eq' | 'gt' | 'lt'; value: string }
-  | { column: string; op: 'between'; value: string; valueTo: string }
-
-export type NormalizedFilter = {
-  /** Column predicates, empty ones dropped. */
-  predicates: NormalizedPredicate[]
-  /** Free-text global search term (trimmed), if any. */
-  search?: string
-}
-
-/** Map the grid's per-column filter model into neutral predicates. */
-export function normalizeFilters(model: ServerFilterModel | undefined): NormalizedFilter {
-  const predicates: NormalizedPredicate[] = []
-  for (const [column, f] of Object.entries(model?.columns ?? {})) {
-    // Set / checklist filter takes precedence when present.
-    if (f.selectedValues?.length) {
-      predicates.push({ column, op: 'in', values: f.selectedValues })
-      continue
-    }
-    const value = (f.value ?? '').trim()
-    switch (f.operator) {
-      case 'isBlank':
-        predicates.push({ column, op: 'isNull' })
-        break
-      case 'between': {
-        const valueTo = (f.valueTo ?? '').trim()
-        if (value || valueTo) predicates.push({ column, op: 'between', value, valueTo: valueTo || value })
-        break
-      }
-      case 'startsWith':
-        if (value) predicates.push({ column, op: 'startsWith', value })
-        break
-      case 'equals':
-        if (value) predicates.push({ column, op: 'eq', value })
-        break
-      case 'greaterThan':
-        if (value) predicates.push({ column, op: 'gt', value })
-        break
-      case 'lessThan':
-        if (value) predicates.push({ column, op: 'lt', value })
-        break
-      // The grid's client-side filter row supports a wider operator set
-      // (notContains, notEquals, endsWith, regex, in, notIn, isNotBlank).
-      // Server data sources don't translate those yet - they fall through to
-      // `contains` below so a backend query stays valid and predictable
-      // rather than silently dropping the predicate. Widen this switch when
-      // per-backend support for the extra operators lands.
-      case 'contains':
-      default:
-        if (value) predicates.push({ column, op: 'contains', value })
-        break
-    }
-  }
-  const search = model?.global?.trim()
-  return { predicates, search: search ? search : undefined }
-}

package/src/sources/index.ts

@@ -1,67 +0,0 @@
-/**
- * Data-source adapters + introspection. Each adapter implements the grid's
- * `ServerDataSource` over a specific backend, so the grid, edit form, sorting,
- * filtering, and paging work identically regardless of where the data lives.
- */
-export { normalizeFilters, type NormalizedFilter, type NormalizedPredicate } from './filters'
-export {
-  buildEntitySchema,
-  pickLabelField,
-  linkRelationLabels,
-  type IntrospectedColumn,
-  type ColumnReference,
-} from './schema-from-columns'
-export { createSupabaseDataSource, type SupabaseDataSourceConfig, type SupabaseClientLike } from './supabase'
-export { createRestDataSource, type RestDataSourceConfig } from './rest'
-export {
-  offsetLimitAdapter,
-  dummyJsonAdapter,
-  jsonServerAdapter,
-  type RestAdapter,
-  type OffsetLimitOptions,
-} from './rest-adapters'
-export { introspectSupabaseTable, listSupabaseTables, type IntrospectSupabaseOptions } from './introspect-supabase'
-export {
-  createSupabaseRealtime,
-  type SupabaseRealtimeConfig,
-  type SupabaseRealtimeClientLike,
-  type SupabaseRealtimeHandle,
-  type RealtimeChannelLike,
-  type RealtimeChange,
-} from './realtime-supabase'
-export {
-  createRelationLookup,
-  type RelationLookup,
-  type RelationLookupConfig,
-  type RelationOption,
-} from './relation-lookup'
-export {
-  createSupabaseAuth,
-  type SupabaseAuthConfig,
-  type SupabaseAuthController,
-  type SupabaseAuthClientLike,
-  type AuthState,
-  type AuthUser,
-} from './auth-supabase'
-export {
-  aggregateRows,
-  chartFieldsFromSchema,
-  type AggregateReduce,
-  type AggregateRequest,
-  type AggregateBucket,
-  type AggregateSource,
-} from './aggregate'
-export { withEntityRules } from './with-entity-rules'
-export { withRelationLabels, type RelationLabelConfig } from './with-relation-labels'
-export {
-  reduceValue,
-  kpiSeries,
-  sparklinePoints,
-  seriesDelta,
-  formatKpiValue,
-  dashboardFromSchema,
-  type DashboardSpec,
-  type DashboardWidget,
-  type KpiWidget,
-  type ChartWidget,
-} from './dashboard'

package/src/sources/introspect-supabase.test.ts

@@ -1,112 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { introspectSupabaseTable, listSupabaseTables } from './introspect-supabase'
-
-type Parts = { openapi?: unknown; openapiStatus?: number; csv?: string; sample?: unknown }
-
-function resp(opts: { status?: number; json?: unknown; text?: string; headers?: Record<string, string> }) {
-  const status = opts.status ?? 200
-  return {
-    ok: status >= 200 && status < 300,
-    status,
-    statusText: 'OK',
-    headers: { get: (k: string) => opts.headers?.[k.toLowerCase()] ?? null },
-    json: async () => opts.json,
-    text: async () => opts.text ?? '',
-  } as unknown as Response
-}
-
-function fetchFor(parts: Parts): typeof globalThis.fetch {
-  return (async (url: string | URL, init?: RequestInit) => {
-    const u = String(url)
-    const accept = (init?.headers as Record<string, string>)?.Accept
-    if (u.endsWith('/rest/v1/')) return resp({ status: parts.openapiStatus ?? 200, json: parts.openapi })
-    if (accept === 'text/csv') return resp({ text: parts.csv ?? '' })
-    return resp({ json: parts.sample ?? [] })
-  }) as unknown as typeof globalThis.fetch
-}
-
-const opts = (fetch: typeof globalThis.fetch) => ({ url: 'https://x.supabase.co', key: 'anon', table: 'customers', fetch })
-
-describe('introspectSupabaseTable', () => {
-  it('reads columns, types, and the primary key from the OpenAPI doc', async () => {
-    const openapi = {
-      definitions: {
-        customers: {
-          required: ['name'],
-          properties: {
-            id: { type: 'integer', description: 'Note:\nThis is a Primary Key.<pk/>' },
-            name: { type: 'string' },
-            active: { type: 'boolean' },
-            tier: { type: 'string', enum: ['free', 'pro'] },
-          },
-        },
-      },
-    }
-    const schema = await introspectSupabaseTable(opts(fetchFor({ openapi })))
-    expect(schema?.idField).toBe('id')
-    expect(schema?.fields.map((f) => [f.field, f.type])).toEqual([
-      ['id', 'number'], ['name', 'text'], ['active', 'boolean'], ['tier', 'enum'],
-    ])
-    expect(schema?.fields.find((f) => f.field === 'id')).toMatchObject({ primaryKey: true, readonly: true })
-    expect(schema?.fields.find((f) => f.field === 'name')?.required).toBe(true)
-  })
-
-  it('detects a foreign key from the OpenAPI description', async () => {
-    const openapi = {
-      definitions: {
-        customers: {
-          properties: {
-            id: { type: 'integer', description: '<pk/>' },
-            name: { type: 'string' },
-            company_id: { type: 'integer', description: "Note:\nThis is a Foreign Key to `companies.id`.<fk table='companies' column='id'/>" },
-          },
-        },
-      },
-    }
-    const schema = await introspectSupabaseTable(opts(fetchFor({ openapi })))
-    const rel = schema?.fields.find((f) => f.field === 'company_id')
-    expect(rel?.type).toBe('relation')
-    expect(rel?.relation).toEqual({ entity: 'companies', foreignKey: 'company_id', labelField: 'name' })
-  })
-
-  it('supports the OpenAPI 3 components.schemas shape', async () => {
-    const openapi = { components: { schemas: { customers: { properties: { name: { type: 'string' } } } } } }
-    const schema = await introspectSupabaseTable(opts(fetchFor({ openapi })))
-    expect(schema?.fields.map((f) => f.field)).toEqual(['name'])
-  })
-
-  it('falls back to the CSV header for an empty table when OpenAPI is blocked', async () => {
-    // OpenAPI 404 (CORS/blocked), sample empty, CSV header present.
-    const schema = await introspectSupabaseTable(
-      opts(fetchFor({ openapiStatus: 404, sample: [], csv: 'id,Name\n' })),
-    )
-    expect(schema?.fields.map((f) => f.field)).toEqual(['id', 'Name'])
-    expect(schema?.idField).toBe('id')
-  })
-
-  it('falls back to a sample row when OpenAPI is blocked and the table has data', async () => {
-    const schema = await introspectSupabaseTable(
-      opts(fetchFor({ openapiStatus: 404, sample: [{ id: 1, name: 'Ada', active: true }] })),
-    )
-    expect(schema?.fields.map((f) => [f.field, f.type])).toEqual([
-      ['id', 'number'], ['name', 'text'], ['active', 'boolean'],
-    ])
-  })
-
-  it('returns null when nothing can determine the columns', async () => {
-    const schema = await introspectSupabaseTable(opts(fetchFor({ openapiStatus: 404, sample: [], csv: '' })))
-    expect(schema).toBeNull()
-  })
-})
-
-describe('listSupabaseTables', () => {
-  it('lists table names from the OpenAPI definitions (sorted)', async () => {
-    const openapi = { definitions: { orders: {}, customers: {}, deals: {} } }
-    const tables = await listSupabaseTables('https://x.supabase.co', 'anon', fetchFor({ openapi }))
-    expect(tables).toEqual(['customers', 'deals', 'orders'])
-  })
-
-  it('returns [] when the OpenAPI doc is blocked or the key is wrong', async () => {
-    expect(await listSupabaseTables('https://x.supabase.co', 'anon', fetchFor({ openapiStatus: 401 }))).toEqual([])
-  })
-})

package/src/sources/introspect-supabase.ts

@@ -1,139 +0,0 @@
-/**
- * Browser-side introspection for Supabase / PostgREST. Discovers a table's
- * columns from the REST API alone (URL + anon key), so a screen can adapt to an
- * arbitrary table with no server. Tries the most informative source first:
- *
- *   1. OpenAPI doc   - names + types + primary key (best; sometimes CORS-blocked)
- *   2. CSV header    - names only, but works on an EMPTY table and is CORS-safe
- *   3. sample row    - names + types inferred from one row of data
- *
- * Returns null when none of them can determine the columns (e.g. an empty table
- * whose OpenAPI is blocked) - the caller can then ask the user to list columns.
- */
-import type { RowData } from '@svgrid/grid'
-import type { EntityFieldType, EntitySchema } from '../schema.js'
-import { buildEntitySchema, type IntrospectedColumn } from './schema-from-columns.js'
-
-export type IntrospectSupabaseOptions = {
-  /** Project URL, e.g. `https://xxxx.supabase.co`. */
-  url: string
-  /** anon public key. */
-  key: string
-  table: string
-  /** Custom fetch (SSR, tests). Defaults to the global `fetch`. */
-  fetch?: typeof fetch
-}
-
-const mapOpenApiType = (prop: { type?: string; enum?: unknown }): EntityFieldType => {
-  if (Array.isArray(prop.enum)) return 'enum'
-  if (prop.type === 'integer' || prop.type === 'number') return 'number'
-  if (prop.type === 'boolean') return 'boolean'
-  return 'text'
-}
-
-async function viaOpenApi(o: Required<IntrospectSupabaseOptions>, base: string): Promise<IntrospectedColumn[] | null> {
-  let res: Response
-  try {
-    res = await o.fetch(`${base}/rest/v1/`, {
-      headers: { apikey: o.key, Authorization: `Bearer ${o.key}`, Accept: 'application/json' },
-    })
-  } catch {
-    return null // network / CORS - let another path try
-  }
-  if (!res.ok) return null
-  let spec: any
-  try { spec = await res.json() } catch { return null }
-
-  const defs: Record<string, any> = spec?.definitions ?? spec?.components?.schemas ?? {}
-  let def = defs[o.table]
-  if (!def) {
-    const key = Object.keys(defs).find((k) => k.toLowerCase() === o.table.toLowerCase())
-    if (key) def = defs[key]
-  }
-  const props = def?.properties
-  if (!props || !Object.keys(props).length) return null
-
-  const required: string[] = Array.isArray(def.required) ? def.required : []
-  return Object.entries<any>(props).map(([name, prop]) => {
-    const desc: string = prop?.description ?? ''
-    // PostgREST annotates a foreign key in the column description:
-    // "...<fk table='companies' column='id'/>"
-    const fk = /<fk\s+table=['"]([^'"]+)['"]\s+column=['"]([^'"]+)['"]/i.exec(desc)
-    return {
-      name,
-      type: mapOpenApiType(prop),
-      primaryKey: /primary key|<pk\/>/i.test(desc),
-      required: required.includes(name),
-      enumValues: Array.isArray(prop?.enum) ? (prop.enum as string[]) : undefined,
-      references: fk ? { table: fk[1]!, column: fk[2]! } : undefined,
-    }
-  })
-}
-
-async function viaCsv(o: Required<IntrospectSupabaseOptions>, base: string): Promise<IntrospectedColumn[] | null> {
-  let res: Response
-  try {
-    res = await o.fetch(`${base}/rest/v1/${encodeURIComponent(o.table)}?select=*&limit=1`, {
-      headers: { apikey: o.key, Authorization: `Bearer ${o.key}`, Accept: 'text/csv' },
-    })
-  } catch {
-    return null
-  }
-  if (!res.ok) return null
-  const text = (await res.text()).trim()
-  const header = text.split(/\r?\n/)[0] ?? ''
-  const names = header.split(',').map((h) => h.trim().replace(/^"|"$/g, '')).filter(Boolean)
-  return names.length ? names.map((name) => ({ name })) : null
-}
-
-async function viaSample(o: Required<IntrospectSupabaseOptions>, base: string): Promise<IntrospectedColumn[] | null> {
-  let res: Response
-  try {
-    res = await o.fetch(`${base}/rest/v1/${encodeURIComponent(o.table)}?select=*&limit=1`, {
-      headers: { apikey: o.key, Authorization: `Bearer ${o.key}`, Accept: 'application/json' },
-    })
-  } catch {
-    return null
-  }
-  if (!res.ok) return null
-  let rows: any
-  try { rows = await res.json() } catch { return null }
-  const sample = Array.isArray(rows) ? rows[0] : undefined
-  if (!sample) return null
-  return Object.entries(sample).map(([name, v]) => ({
-    name,
-    type: (typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'text') as EntityFieldType,
-  }))
-}
-
-/** List a Supabase project's tables from its PostgREST OpenAPI doc (URL + anon key).
- *  Returns the exposed table names (sorted), or `[]` when the doc can't be read
- *  (CORS-blocked, bad key). Lets the Studio wizard offer a table picker instead of
- *  making the user hand-type the table name. */
-export async function listSupabaseTables(url: string, key: string, fetchFn: typeof fetch = globalThis.fetch): Promise<string[]> {
-  const base = url.replace(/\/+$/, '')
-  let res: Response
-  try {
-    res = await fetchFn(`${base}/rest/v1/`, { headers: { apikey: key, Authorization: `Bearer ${key}`, Accept: 'application/json' } })
-  } catch {
-    return []
-  }
-  if (!res.ok) return []
-  let spec: any
-  try { spec = await res.json() } catch { return [] }
-  const defs: Record<string, unknown> = spec?.definitions ?? spec?.components?.schemas ?? {}
-  // PostgREST also lists RPCs under `paths` as `/rpc/...`; `definitions` are the tables/views.
-  return Object.keys(defs).sort((a, b) => a.localeCompare(b))
-}
-
-/** Introspect a Supabase/PostgREST table into an EntitySchema, or null. */
-export async function introspectSupabaseTable<TData extends RowData = RowData>(
-  options: IntrospectSupabaseOptions,
-): Promise<EntitySchema<TData> | null> {
-  const o: Required<IntrospectSupabaseOptions> = { fetch: globalThis.fetch, ...options }
-  const base = o.url.replace(/\/+$/, '')
-  const columns =
-    (await viaOpenApi(o, base)) ?? (await viaSample(o, base)) ?? (await viaCsv(o, base))
-  if (!columns || !columns.length) return null
-  return buildEntitySchema<TData>(o.table, columns)
-}

package/src/sources/realtime-supabase.test.ts

@@ -1,93 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
-import { createSupabaseRealtime } from './realtime-supabase'
-
-/** A supabase-js-like realtime client that captures the wiring and can fire payloads. */
-function makeClient() {
-  const state: {
-    name?: string
-    filter?: Record<string, unknown>
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    cb?: (payload: any) => void
-    status?: (s: string) => void
-    removed: unknown[]
-  } = { removed: [] }
-
-  const channel: any = {
-    on(_type: string, filter: Record<string, unknown>, cb: (p: unknown) => void) {
-      state.filter = filter
-      state.cb = cb
-      return channel
-    },
-    subscribe(cb?: (s: string) => void) {
-      state.status = cb
-      return channel
-    },
-  }
-  const client = {
-    channel(name: string) { state.name = name; return channel },
-    removeChannel(ch: unknown) { state.removed.push(ch) },
-  }
-  return { client, channel, state }
-}
-
-afterEach(() => vi.useRealTimers())
-
-describe('createSupabaseRealtime', () => {
-  it('subscribes to postgres_changes for the table with defaults', () => {
-    const { client, state } = makeClient()
-    createSupabaseRealtime({ client, table: 'customers', onChange: () => {} })
-    expect(state.name).toBe('svgrid:public:customers')
-    expect(state.filter).toEqual({ event: '*', schema: 'public', table: 'customers' })
-  })
-
-  it('honors schema, event, filter, and channelName', () => {
-    const { client, state } = makeClient()
-    createSupabaseRealtime({
-      client, table: 't', schema: 'app', event: 'INSERT', filter: 'tier=eq.pro', channelName: 'c', onChange: () => {},
-    })
-    expect(state.name).toBe('c')
-    expect(state.filter).toEqual({ event: 'INSERT', schema: 'app', table: 't', filter: 'tier=eq.pro' })
-  })
-
-  it('normalizes a change payload', () => {
-    const { client, state } = makeClient()
-    const onChange = vi.fn()
-    createSupabaseRealtime({ client, table: 't', onChange })
-    state.cb!({ eventType: 'UPDATE', new: { id: 1, name: 'X' }, old: { id: 1 } })
-    expect(onChange).toHaveBeenCalledWith({ type: 'UPDATE', new: { id: 1, name: 'X' }, old: { id: 1 } })
-  })
-
-  it('passes status through', () => {
-    const { client, state } = makeClient()
-    const onStatus = vi.fn()
-    createSupabaseRealtime({ client, table: 't', onChange: () => {}, onStatus })
-    state.status!('SUBSCRIBED')
-    expect(onStatus).toHaveBeenCalledWith('SUBSCRIBED')
-  })
-
-  it('coalesces a burst into one call when debounced', () => {
-    vi.useFakeTimers()
-    const { client, state } = makeClient()
-    const onChange = vi.fn()
-    createSupabaseRealtime({ client, table: 't', debounceMs: 200, onChange })
-    state.cb!({ eventType: 'INSERT', new: { id: 1 } })
-    state.cb!({ eventType: 'INSERT', new: { id: 2 } })
-    state.cb!({ eventType: 'INSERT', new: { id: 3 } })
-    expect(onChange).not.toHaveBeenCalled()
-    vi.advanceTimersByTime(200)
-    expect(onChange).toHaveBeenCalledTimes(1)
-    expect(onChange).toHaveBeenCalledWith({ type: 'INSERT', new: { id: 3 }, old: null })
-  })
-
-  it('unsubscribe removes the channel and cancels a pending debounce', () => {
-    vi.useFakeTimers()
-    const { client, state, channel } = makeClient()
-    const onChange = vi.fn()
-    const live = createSupabaseRealtime({ client, table: 't', debounceMs: 200, onChange })
-    state.cb!({ eventType: 'DELETE', old: { id: 9 } })
-    live.unsubscribe()
-    vi.advanceTimersByTime(500)
-    expect(onChange).not.toHaveBeenCalled()
-    expect(state.removed).toEqual([channel])
-  })
-})