@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/aurabase/tests/readme-smoke-e2e.test.ts

@@ -1,231 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel de smoke des README (stack live) — Task 6 (chantier H, DX).
-//
-// Complément du compile-check statique (tests/types/docs-snippets.test-d.ts,
-// preuve compile-time) : ce fichier exécute RÉELLEMENT, contre le déploiement
-// Docker local (gateway :8080, control :8090), les exemples clés documentés
-// dans packages/auth/README.md, packages/db/README.md et
-// packages/storage/README.md — preuve runtime que la doc est fidèle au
-// comportement observé, pas seulement à la signature TypeScript.
-//
-// Périmètre volontairement réduit à un flux « smoke » par domaine (pas une
-// couverture exhaustive de chaque méthode documentée — c'est le rôle des
-// suites unitaires par package) :
-//   - Auth   : signUp → signInWithPassword → getUser (id/email cohérents) →
-//              signOut. Cleanup authAdmin.deleteUser en finally.
-//   - DB     : table jetable créée via aura.db.sql() (CREATE TABLE + GRANT +
-//              reload schema PostgREST + délai de démarrage du reload, comme
-//              db-types-e2e.test.ts) → from(table).insert(...).select(...).single() →
-//              from(table).select(...).eq(...).single() → vérifie la forme
-//              réelle de la ligne retournée. Le reload de cache PostgREST étant
-//              asynchrone, insert/select rejouent sur 503 (reload en cours) ET
-//              404 (cache pas encore rechargé) via retryReload, avec skip
-//              gracieux si le backend reste indisponible après retries.
-//              Cleanup DROP TABLE en finally.
-//   - Storage: createBucket (service_role) → upload → download (builder
-//              paresseux, .text() sur le Blob résolu) → remove →
-//              deleteBucket. Cleanup deleteBucket en finally.
-//
-// Gaté par RUN_E2E + credentials (identique à auth-e2e.test.ts /
-// db-types-e2e.test.ts) : describe.runIf(RUN) SKIPPE proprement la suite
-// entière (pas d'échec) quand les variables d'env manquent — vérifié sans
-// RUN_E2E via `pnpm --filter aurabase test`.
-// ---------------------------------------------------------------------------
-
-import { describe, it, expect } from 'vitest'
-import { createClient, createAdminClient } from '../src/index'
-import type { AuraResponse } from '../src/index'
-
-const URL = process.env.AURA_E2E_URL
-const PROJECT = process.env.AURA_E2E_PROJECT
-const ANON = process.env.AURA_E2E_ANON_KEY
-const SERVICE = process.env.AURA_E2E_SERVICE_KEY
-const RUN = Boolean(process.env.RUN_E2E && URL && PROJECT && ANON && SERVICE)
-
-/** Statuts transitoires observés sur la stack locale (timeout gateway→service sous charge). */
-const TRANSIENT_STATUS = new Set([408, 429, 502, 503, 504])
-
-/** Rejoue une requête tant qu'elle renvoie un statut transitoire, borné (cf. auth-e2e.test.ts). */
-async function retryTransient<T>(fn: () => Promise<AuraResponse<T>>): Promise<AuraResponse<T>> {
-  let res = await fn()
-  for (let i = 0; i < 10 && res.error && TRANSIENT_STATUS.has(res.error.status); i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await fn()
-  }
-  return res
-}
-
-/** Rejoue une requête tant qu'elle renvoie un statut transitoire (jeu complet
- *  TRANSIENT_STATUS : 408/429/502/503/504) OU 404 (cache pas encore rechargé — table
- *  inconnue de PostgREST), borné. Cf. db-types-e2e.test.ts : le reload de cache
- *  (pg_notify) est ASYNCHRONE — juste après la création d'une table via SQL brut,
- *  PostgREST peut d'abord renvoyer un 404 (POSTGREST_ERROR, cache pas encore rechargé)
- *  puis un 503 (reload en cours) avant d'être prêt. Sur stack locale saturée, peut aussi
- *  voir 408 (timeout gateway = transitoire). Réservé au flux db de setup ci-dessous
- *  (insert/select juste après CREATE TABLE) — ne pas réutiliser ce 404 élargi ailleurs,
- *  un 404 hors reload de schéma est une vraie erreur. */
-async function retryReload<T>(fn: () => Promise<AuraResponse<T>>): Promise<AuraResponse<T>> {
-  let res = await fn()
-  for (let i = 0; i < 20 && (TRANSIENT_STATUS.has(res.error?.status) || res.error?.status === 404); i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await fn()
-  }
-  return res
-}
-
-describe.runIf(RUN)('README smoke E2E réel (stack live) — auth / db / storage', () => {
-  it(
-    'auth : signUp → signInWithPassword → getUser (id/email cohérents) → signOut',
-    async () => {
-      const client = createClient(URL!, PROJECT!, ANON!)
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const email = `readme-smoke-auth-${suffix}@aurabase.dev`
-      const password = 'ReadmeSmokeAuth123!'
-
-      let userId: string | null = null
-      try {
-        // README auth § "Mot de passe"
-        const signUpRes = await retryTransient(() => client.auth.signUp({ email, password }))
-        expect(signUpRes.error).toBeNull()
-
-        const signInRes = await retryTransient(() => client.auth.signInWithPassword({ email, password }))
-        expect(signInRes.error).toBeNull()
-        const signInData = signInRes.data as { access_token: string; user: { id: string } }
-        expect(signInData.access_token).toBeTruthy()
-        userId = signInData.user.id
-        expect(userId).toBeTruthy()
-
-        // README auth § "Utilisateur, claims, mot de passe" — const { data: user } = await aura.auth.getUser()
-        const { data: user, error: userError } = await client.auth.getUser()
-        expect(userError).toBeNull()
-        expect(user).not.toBeNull()
-        expect(user!.id).toBe(userId)
-        expect(user!.email).toBe(email)
-
-        // README auth § "Mot de passe" — await aura.auth.signOut()
-        const signOutRes = await client.auth.signOut()
-        expect(signOutRes.error).toBeNull()
-      } finally {
-        if (userId) {
-          try {
-            await admin.authAdmin.deleteUser(userId)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    120_000,
-  )
-
-  it(
-    'db : from(table).insert(...).select(...).single() puis from(table).select(...).eq(...).single()',
-    async () => {
-      const client = createClient(URL!, PROJECT!, ANON!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const table = `e2e_readme_smoke_${suffix}`
-
-      // Table jetable — même mécanique que db-types-e2e.test.ts (SQL brut,
-      // GRANT large intentionnel, reload du cache de schéma PostgREST).
-      await client.db.sql(`DROP TABLE IF EXISTS ${table}`)
-      await client.db.sql(
-        `CREATE TABLE ${table} (id uuid PRIMARY KEY DEFAULT gen_random_uuid(), title text NOT NULL, published boolean NOT NULL DEFAULT false)`,
-      )
-      await client.db.sql(`GRANT ALL ON ${table} TO PUBLIC`)
-      await client.db.sql(`SELECT pg_notify('pgrst', 'reload schema')`)
-      // Laisse le reload asynchrone démarrer avant le premier appel — sans ce délai,
-      // le premier insert tombe quasi systématiquement en 404 (cache pas encore invalidé).
-      await new Promise((r) => setTimeout(r, 1500))
-
-      try {
-        // README db § "Mutations — update/delete ciblent par id"
-        const inserted = await retryReload(() =>
-          client.db.from(table).insert({ title: 'Hello Aurabase', published: true }).select('id').single(),
-        )
-        if (TRANSIENT_STATUS.has(inserted.error?.status) || inserted.error?.status === 404) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[readme-smoke-e2e] SKIP db (infra: reload/503/404 persistant après retries sur insert) — ' +
-            'NON un succès : assertion runtime db ignorée, pas un défaut de la doc.',
-          )
-          return
-        }
-        expect(inserted.error).toBeNull()
-        const id = (inserted.data as { id: string } | null)?.id
-        expect(id).toBeTruthy()
-
-        // README db § "Select, filtres, embeds"
-        const selected = await retryReload(() =>
-          client.db.from(table).select('id,title,published').eq('id', id!).single(),
-        )
-        if (TRANSIENT_STATUS.has(selected.error?.status) || selected.error?.status === 404) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[readme-smoke-e2e] SKIP db (infra: reload/503/404 persistant après retries sur select) — ' +
-            'NON un succès : assertion runtime db ignorée, pas un défaut de la doc.',
-          )
-          return
-        }
-        expect(selected.error).toBeNull()
-        const row = selected.data as { id: string; title: string; published: boolean }
-        expect(row.id).toBe(id)
-        expect(row.title).toBe('Hello Aurabase')
-        expect(row.published).toBe(true)
-      } finally {
-        await client.db.sql(`DROP TABLE IF EXISTS ${table}`)
-      }
-    },
-    120_000,
-  )
-
-  it(
-    'storage : createBucket (service_role) → upload → download → remove → deleteBucket',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const bucket = `e2e-readme-smoke-${suffix}`
-      const path = 'readme-smoke.txt'
-      const content = 'Aurabase README smoke E2E'
-
-      let created = false
-      try {
-        // README storage § "Buckets"
-        const createRes = await retryTransient(() => admin.storage.createBucket(bucket, { public: false }))
-        expect(createRes.error).toBeNull()
-        created = true
-
-        // README storage § "Upload, liste, métadonnées"
-        const uploadRes = await admin.storage.upload(
-          bucket,
-          path,
-          new Blob([content], { type: 'text/plain' }),
-          { contentType: 'text/plain' },
-        )
-        expect(uploadRes.error).toBeNull()
-        const key = uploadRes.data!.key
-        expect(key).toBeTruthy()
-
-        // README storage § "Download — builder paresseux"
-        const { data: blob, error: downloadError } = await admin.storage.download(bucket, key)
-        expect(downloadError).toBeNull()
-        expect(blob).not.toBeNull()
-        const text = await blob!.text()
-        expect(text).toBe(content)
-
-        // README storage § "Copie, déplacement, suppression"
-        const removeRes = await admin.storage.remove(bucket, [key])
-        expect(removeRes.error).toBeNull()
-      } finally {
-        if (created) {
-          try {
-            await admin.storage.deleteBucket(bucket)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    120_000,
-  )
-})

package/packages/aurabase/tests/realtime-filter-e2e.test.ts

@@ -1,344 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel (stack live) — LOT A / Task A2 du plan
-// docs/superpowers/plans/2026-07-13-realtime-column-filters.md.
-//
-// Prouve en conditions réelles que le filtre colonne serveur `aura-realtime`
-// (protocol.rs::event_matches_filters, câblé handlers/websocket.rs:~1173) ne
-// livre AU CALLBACK que les events postgres_changes dont le `record` (ou
-// `old_record` pour DELETE) satisfait le prédicat `filter: 'col=op.value'`.
-// Le Lot B (fallback client `columnFilter.ts`) n'est PAS encore implémenté à
-// ce stade (AuraChannel._dispatchEvent ne vérifie que schema/table, jamais
-// `filter` — cf. packages/realtime/src/AuraChannel.ts:~411-426) : ce test
-// isole donc bien le comportement SERVEUR, seul en jeu ici.
-//
-// ── Mécanisme d'activation realtime d'une table (repéré dans le code) ──────
-// Le CDC (`services/aura-realtime/src/cdc/postgres.rs`) ne route que les
-// tables listées dans `{project_schema}_platform.realtime_tables WHERE
-// enabled = true` (lu par `SubscriptionManager::get_active_realtime_tables`,
-// rafraîchi toutes les 3s — `services/aura-realtime/src/cdc/postgres.rs:341`
-// `filter_refresh_interval`). Il existe une route HTTP DÉDIÉE côté aura-db
-// pour activer/désactiver ça proprement (pas besoin d'INSERT SQL manuel dans
-// le schéma platform, verrouillé au master_pool) :
-//   PUT /v1/db/{project_id}/schema/tables/{table}/realtime
-//   body: { enabled: true }
-//   (service_role requis — `require_service_role` via header x-aura-role posé
-//   par le gateway à partir de la clé API service_role ; voir
-//   `services/aura-db/src/handlers/schema.rs::toggle_realtime`, routes
-//   enregistrées dans `services/aura-db/src/main.rs:783/983`)
-// Cet endpoint fait aussi `ALTER TABLE ... REPLICA IDENTITY FULL`, nécessaire
-// pour que `old_record` soit peuplé sur UPDATE/DELETE. Pas de méthode SDK
-// dédiée (comme pour `/settings` storage) → fetch direct authentifié par la
-// clé service_role, même pattern que storage-transform-e2e.test.ts.
-//
-// ── Piège trouvé et évité : `schema` dans le filtre postgres_changes ───────
-// Le payload CDC (`build_payload`, cdc/postgres.rs:590-646) porte
-// `"schema": change.schema` = le schéma PHYSIQUE `project_<uuid>` (PAS
-// littéralement "public"). L'alias `db:public.{table}` (cdc/postgres.rs:528)
-// n'est qu'un ALIAS DE ROUTAGE DE TOPIC (permet de s'abonner sans connaître
-// le schéma interne) — il ne réécrit PAS le champ `schema` du payload livré.
-// Si le filtre `.on('postgres_changes', { schema: 'public', ... })` était
-// utilisé, la comparaison stricte `fs != schema` dans `event_matches_filters`
-// (protocol.rs) EXCLURAIT alors TOUT event (fail-closed) puisque
-// `"public" !== "project_<uuid>"` — et le fallback client (dispatch,
-// AuraChannel.ts:423) ferait la même comparaison littérale en second rideau.
-// Ce test omet donc volontairement `schema` dans le filtre (le champ est
-// `Option<String>` côté serveur ET `schema?: string` côté SDK — absent ⇒
-// check sauté, seuls `event`/`table`/`filter` s'appliquent), ce qui isole
-// proprement le filtre COLONNE (objet de ce test) de ce défaut d'alias
-// séparé (signalé ici, hors scope de A2 — potentiel suivi backlog).
-//
-// ── Auth WS ──────────────────────────────────────────────────────────────
-// `GET /v1/realtime/ws` exige un VRAI JWT en query `?token=` (validate_jwt,
-// handlers/websocket.rs:243-249) — une clé anon seule ne suffit pas. Le test
-// signUp + signInWithPassword un utilisateur jetable via la clé anon pour
-// peupler `authStore.token` avant `realtime.connect()`.
-//
-// Gaté par RUN_E2E + credentials (identique aux autres *-e2e.test.ts). Le
-// run réel n'est PAS lancé ici (pas de creds dans cet environnement) — le
-// contrôleur le fera après rebuild `aura-realtime`. Ce fichier doit
-// seulement compiler et skip proprement (`describe.runIf`).
-// ---------------------------------------------------------------------------
-
-import { describe, it, expect } from 'vitest'
-import { createClient, createAdminClient } from '../src/index'
-import type { AuraResponse, RealtimeEvent, RealtimeSubscribeStatus } from '../src/index'
-
-const URL = process.env.AURA_E2E_URL
-const PROJECT = process.env.AURA_E2E_PROJECT
-const ANON = process.env.AURA_E2E_ANON_KEY
-const SERVICE = process.env.AURA_E2E_SERVICE_KEY
-const RUN = Boolean(process.env.RUN_E2E && URL && PROJECT && ANON && SERVICE)
-
-/** Statuts transitoires observés sur la stack locale (timeout gateway→service sous charge). */
-const TRANSIENT_STATUS = new Set([408, 429, 502, 503, 504])
-
-/** Rejoue une requête (AuraResponse) tant qu'elle renvoie un statut transitoire, borné. */
-async function retryTransient<T>(fn: () => Promise<AuraResponse<T>>): Promise<AuraResponse<T>> {
-  let res = await fn()
-  for (let i = 0; i < 10 && res.error && TRANSIENT_STATUS.has(res.error.status); i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await fn()
-  }
-  return res
-}
-
-/** Rejoue un fetch() brut tant que le statut est transitoire, borné. */
-async function retryFetchTransient(fn: () => Promise<Response>): Promise<Response> {
-  let res = await fn()
-  for (let i = 0; i < 10 && TRANSIENT_STATUS.has(res.status); i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await fn()
-  }
-  return res
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((r) => setTimeout(r, ms))
-}
-
-type CdcRecord = Record<string, unknown>
-interface CdcPayload {
-  schema: string
-  table: string
-  type: 'INSERT' | 'UPDATE' | 'DELETE'
-  record: CdcRecord
-  old_record: CdcRecord | null
-}
-
-/**
- * Attend le PREMIER statut renvoyé par `channel.subscribe(cb)`, borné dans le temps.
- * Retourne `'timeout'` si aucun statut n'arrive (WS/CDC pas prêt) — le test doit alors
- * SKIPPER proprement plutôt que d'échouer sur une infra transitoire.
- */
-function waitForSubscribeStatus(
-  doSubscribe: (cb: (status: RealtimeSubscribeStatus, err?: Error) => void) => void,
-  timeoutMs: number,
-): Promise<{ status: RealtimeSubscribeStatus; err?: Error } | 'timeout'> {
-  return new Promise((resolve) => {
-    let done = false
-    const timer = setTimeout(() => {
-      if (!done) {
-        done = true
-        resolve('timeout')
-      }
-    }, timeoutMs)
-    doSubscribe((status, err) => {
-      if (done) return
-      done = true
-      clearTimeout(timer)
-      resolve({ status, err })
-    })
-  })
-}
-
-describe.runIf(RUN)('realtime filtre colonne E2E réel (stack live) — seuls les events matchant sont livrés', () => {
-  it(
-    'eq / gt / AND — le serveur ne délivre que les postgres_changes dont le record matche le filtre',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const anon = createClient(URL!, PROJECT!, ANON!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const table = `rt_${suffix}`
-      // Le CDC calcule le RLS `allowed_sub_ids` sur le canal GÉNÉRIQUE au schéma
-      // PHYSIQUE (`project_<uuid>`), pas sur l'alias `db:public.*` (limite backend
-      // pré-existante : un abonné via l'alias public n'est jamais dans allowed_sub_ids).
-      // On s'abonne donc au canal générique pour recevoir les events.
-      const physicalSchema = `project_${PROJECT!.replace(/-/g, '_')}`
-      const channelName = `db:${physicalSchema}.${table}`
-      const email = `realtime-filter-e2e-${suffix}@aurabase.dev`
-      const password = 'EndUserPassword123!'
-
-      let tableCreated = false
-      let userId: string | null = null
-
-      try {
-        // -- 1. Setup service_role : table jetable + GRANT + reload PostgREST ----
-        await admin.db.sql(`DROP TABLE IF EXISTS ${table}`)
-        const createRes = await admin.db.sql(
-          `CREATE TABLE ${table} (
-             id serial PRIMARY KEY,
-             room_id int NOT NULL,
-             qty int NOT NULL DEFAULT 0,
-             name text NOT NULL DEFAULT '',
-             status text NOT NULL DEFAULT 'open'
-           )`,
-        )
-        if (createRes.error) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            `[realtime-filter-e2e] SKIP (infra: CREATE TABLE a échoué — ${createRes.error.status} ` +
-              `${createRes.error.message ?? ''}) — table de test indisponible.`,
-          )
-          return
-        }
-        tableCreated = true
-        await admin.db.sql(`GRANT ALL ON ${table} TO PUBLIC`)
-        await admin.db.sql(`SELECT pg_notify('pgrst', 'reload schema')`)
-
-        // -- 2. Activer le realtime CDC pour cette table (service_role) ---------
-        const enableRes = await retryFetchTransient(() =>
-          fetch(`${admin.baseUrl}/v1/db/${admin.projectId}/schema/tables/${table}/realtime`, {
-            method: 'PUT',
-            headers: { apikey: SERVICE!, 'content-type': 'application/json' },
-            body: JSON.stringify({ enabled: true }),
-          }),
-        )
-        if (!enableRes.ok) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            `[realtime-filter-e2e] SKIP (infra: PUT .../schema/tables/${table}/realtime → ` +
-              `${enableRes.status} — activation realtime indisponible dans ce contexte E2E).`,
-          )
-          return
-        }
-
-        // -- 3. Utilisateur jetable (anon key) — le WS exige un vrai JWT --------
-        const signUpRes = await retryTransient(() => anon.auth.signUp({ email, password }))
-        if (signUpRes.error && TRANSIENT_STATUS.has(signUpRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            `[realtime-filter-e2e] SKIP (infra: signUp indisponible après retries — ` +
-              `${signUpRes.error.status} persistant).`,
-          )
-          return
-        }
-        expect(signUpRes.error).toBeNull()
-
-        const loginRes = await retryTransient(() => anon.auth.signInWithPassword({ email, password }))
-        if (loginRes.error && TRANSIENT_STATUS.has(loginRes.error.status)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            `[realtime-filter-e2e] SKIP (infra: signInWithPassword indisponible après retries — ` +
-              `${loginRes.error.status} persistant).`,
-          )
-          return
-        }
-        expect(loginRes.error).toBeNull()
-        const loginData = loginRes.data as { user: { id: string } } | null
-        userId = loginData?.user.id ?? null
-
-        // -- 4. Laisser le filtre CDC se rafraîchir (add-tables, ~3s) -----------
-        await sleep(4000)
-
-        // -- 5. Une seule connexion WS pour les 3 scénarios ---------------------
-        anon.realtime.connect()
-
-        /**
-         * Un scénario = un channel FRAIS (même nom `db:public.<table>` — c'est
-         * l'alias de routage CDC, cf. commentaire en tête de fichier) avec UN SEUL
-         * listener `postgres_changes` (filtre isolé — pas de faux-négatif dû à un
-         * OR entre plusieurs filtres coexistant sur le même channel), un INSERT
-         * de deux lignes (une qui matche, une qui ne matche pas), une fenêtre de
-         * collecte bornée, puis une assertion stricte. Retourne `false` si le
-         * scénario doit SKIP (WS/CDC pas prêt) — auquel cas l'appelant arrête tout.
-         */
-        async function runScenario(
-          label: string,
-          filter: string,
-          matchingRow: { room_id: number; qty: number; name: string; status: string },
-          nonMatchingRow: { room_id: number; qty: number; name: string; status: string },
-        ): Promise<'ok' | 'skip'> {
-          const received: RealtimeEvent<CdcPayload>[] = []
-          const channel = anon.channel(channelName)
-          channel.on(
-            'postgres_changes',
-            // `schema` omis à dessein — voir commentaire en tête de fichier.
-            { event: '*', table, filter },
-            (payload) => received.push(payload as RealtimeEvent<CdcPayload>),
-          )
-
-          const result = await waitForSubscribeStatus((cb) => channel.subscribe(cb), 15_000)
-          if (result === 'timeout' || result.status !== 'SUBSCRIBED') {
-            // eslint-disable-next-line no-console
-            console.warn(
-              `[realtime-filter-e2e] SKIP scénario ${label} (WS/CDC pas prêt — ` +
-                `${result === 'timeout' ? 'timeout attente SUBSCRIBED' : `statut ${result.status}`}).`,
-            )
-            anon.realtime.removeChannel(channelName)
-            return 'skip'
-          }
-
-          const insMatch = await admin.db.sql(
-            `INSERT INTO ${table} (room_id, qty, name, status) VALUES ($1, $2, $3, $4)`,
-            [matchingRow.room_id, matchingRow.qty, matchingRow.name, matchingRow.status],
-          )
-          expect(insMatch.error).toBeNull()
-          const insOther = await admin.db.sql(
-            `INSERT INTO ${table} (room_id, qty, name, status) VALUES ($1, $2, $3, $4)`,
-            [nonMatchingRow.room_id, nonMatchingRow.qty, nonMatchingRow.name, nonMatchingRow.status],
-          )
-          expect(insOther.error).toBeNull()
-
-          // Fenêtre de collecte CDC (poll WAL + refresh add-tables + latence pub/sub).
-          await sleep(8_000)
-
-          const matches = (r: CdcRecord | null | undefined, expected: typeof matchingRow): boolean =>
-            !!r && r.room_id === expected.room_id && r.qty === expected.qty
-
-          const gotMatching = received.some((e) => matches(e.payload.record, matchingRow))
-          const gotNonMatching = received.some((e) => matches(e.payload.record, nonMatchingRow))
-
-          expect(gotMatching).toBe(true)
-          expect(gotNonMatching).toBe(false)
-
-          anon.realtime.removeChannel(channelName)
-          return 'ok'
-        }
-
-        // -- 6. Scénario eq : room_id=eq.42 --------------------------------------
-        const r1 = await runScenario(
-          'eq (room_id=eq.42)',
-          'room_id=eq.42',
-          { room_id: 42, qty: 1, name: 'alpha', status: 'open' },
-          { room_id: 7, qty: 1, name: 'beta', status: 'open' },
-        )
-        if (r1 === 'skip') return
-
-        // -- 7. Scénario gt : qty=gt.5 --------------------------------------------
-        const r2 = await runScenario(
-          'gt (qty=gt.5)',
-          'qty=gt.5',
-          { room_id: 1, qty: 10, name: 'gamma', status: 'open' },
-          { room_id: 1, qty: 1, name: 'delta', status: 'open' },
-        )
-        if (r2 === 'skip') return
-
-        // -- 8. Scénario AND : room_id=eq.42,qty=gt.5 -----------------------------
-        const r3 = await runScenario(
-          'AND (room_id=eq.42,qty=gt.5)',
-          'room_id=eq.42,qty=gt.5',
-          { room_id: 42, qty: 10, name: 'epsilon', status: 'open' },
-          // Ne matche que la moitié du AND (room_id ok, qty non) — doit rester exclu.
-          { room_id: 42, qty: 1, name: 'zeta', status: 'open' },
-        )
-        if (r3 === 'skip') return
-      } finally {
-        try {
-          anon.realtime.removeAllChannels()
-        } catch {
-          // best-effort cleanup
-        }
-        try {
-          anon.realtime.disconnect()
-        } catch {
-          // best-effort cleanup
-        }
-        if (userId) {
-          try {
-            await admin.authAdmin.deleteUser(userId)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-        if (tableCreated) {
-          try {
-            await admin.db.sql(`DROP TABLE IF EXISTS ${table}`)
-          } catch {
-            // best-effort cleanup
-          }
-        }
-      }
-    },
-    120_000,
-  )
-})