@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/aurabase/tests/database.test.ts

@@ -1,230 +0,0 @@
-// ---------------------------------------------------------------------------
-// DatabaseService CRUD tests
-// ---------------------------------------------------------------------------
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { AuraClient } from '../src/AuraClient'
-import { FetchMock, fakeTokenPair } from './mocks'
-
-const BASE = 'http://localhost:8080'
-const PROJECT = 'test-project'
-const TABLE_URL = `${BASE}/v1/db/${PROJECT}/posts`
-
-let fetchMock: FetchMock
-let client: AuraClient
-
-beforeEach(() => {
-  fetchMock = new FetchMock()
-  fetchMock.init()
-  client = new AuraClient(BASE, PROJECT, {
-    auth: { persistSession: false },
-  })
-  // Pre-populate so fetchWithAuth does not attempt a refresh
-  const tp = fakeTokenPair()
-  client.authStore.save(tp.access_token, tp.refresh_token, tp.user)
-})
-
-afterEach(() => {
-  fetchMock.restore()
-  fetchMock.clearMocks()
-})
-
-// ---------------------------------------------------------------------------
-describe('SELECT (list with filters)', () => {
-  it('fetches rows with eq filter', async () => {
-    const rows = [
-      { id: '1', title: 'A', published: true },
-      { id: '2', title: 'B', published: true },
-    ]
-    fetchMock.on({
-      method: 'GET',
-      url: /\/posts\?/,
-      replyCode: 200,
-      replyBody: { data: rows, meta: { total: 2 } },
-    })
-
-    const res = await client.db
-      .from('posts')
-      .eq('published', true)
-      .limit(10)
-
-    expect(res.error).toBeNull()
-    expect(res.data).toHaveLength(2)
-    expect(res.meta?.total).toBe(2)
-  })
-
-  it('returns empty array when no rows', async () => {
-    fetchMock.on({
-      method: 'GET',
-      url: /\/posts/,
-      replyCode: 200,
-      replyBody: { data: [] },
-    })
-
-    const res = await client.db.from('posts').eq('id', 'none')
-
-    expect(res.error).toBeNull()
-    expect(res.data).toEqual([])
-  })
-})
-
-// ---------------------------------------------------------------------------
-describe('GET single record', () => {
-  it('fetches a single record via single()', async () => {
-    fetchMock.on({
-      method: 'GET',
-      url: /\/posts\?/,
-      replyCode: 200,
-      replyBody: { data: [{ id: '1', title: 'Hello' }] },
-    })
-
-    const res = await client.db.from('posts').eq('id', '1').single()
-
-    expect(res.error).toBeNull()
-    expect(res.data).toEqual({ id: '1', title: 'Hello' })
-  })
-})
-
-// ---------------------------------------------------------------------------
-describe('INSERT', () => {
-  it('inserts a single record', async () => {
-    const newPost = { id: '3', title: 'New Post' }
-    fetchMock.on({
-      method: 'POST',
-      url: TABLE_URL,
-      replyCode: 201,
-      replyBody: { data: newPost },
-    })
-
-    const res = await client.db
-      .from('posts')
-      .insert({ title: 'New Post' })
-
-    expect(res.error).toBeNull()
-    expect(res.data).toBeDefined()
-    // DB-F3 (parité postgrest-js) : `insert()` renvoie TOUJOURS un tableau `Row[]`,
-    // même sur une ligne unique (le gateway déballe le 201 mono-ligne en objet, le
-    // SDK le re-emballe). Avant : objet nu (divergence).
-    expect(Array.isArray(res.data)).toBe(true)
-    expect((res.data as any)[0].title).toBe('New Post')
-  })
-
-  it('inserts a batch of records', async () => {
-    const batch = [
-      { id: '4', title: 'A' },
-      { id: '5', title: 'B' },
-    ]
-    fetchMock.on({
-      method: 'POST',
-      url: TABLE_URL,
-      replyCode: 201,
-      replyBody: { data: batch },
-    })
-
-    const res = await client.db
-      .from('posts')
-      .insert([{ title: 'A' }, { title: 'B' }])
-
-    expect(res.error).toBeNull()
-    expect(Array.isArray(res.data)).toBe(true)
-    expect((res.data as any[]).length).toBe(2)
-  })
-})
-
-// ---------------------------------------------------------------------------
-describe('UPDATE (PATCH)', () => {
-  it('updates a record by id', async () => {
-    const updated = { id: '1', title: 'Updated' }
-    fetchMock.on({
-      method: 'PATCH',
-      url: `${TABLE_URL}/1`,
-      replyCode: 200,
-      replyBody: { data: updated },
-    })
-
-    const res = await client.db
-      .from('posts')
-      .update('1', { title: 'Updated' })
-
-    expect(res.error).toBeNull()
-    expect((res.data as any).title).toBe('Updated')
-  })
-})
-
-// ---------------------------------------------------------------------------
-describe('DELETE', () => {
-  it('deletes a record by id', async () => {
-    fetchMock.on({
-      method: 'DELETE',
-      url: `${TABLE_URL}/1`,
-      replyCode: 204,
-    })
-
-    const res = await client.db.from('posts').delete('1')
-
-    expect(res.error).toBeNull()
-  })
-})
-
-// ---------------------------------------------------------------------------
-describe('Raw SQL', () => {
-  it('executes raw SQL via POST /raw', async () => {
-    const rows = [{ count: 42 }]
-    fetchMock.on({
-      method: 'POST',
-      url: `${BASE}/v1/db/${PROJECT}/raw`,
-      replyCode: 200,
-      replyBody: { data: rows },
-    })
-
-    const res = await client.db.sql('SELECT count(*) FROM posts')
-
-    expect(res.error).toBeNull()
-    expect(res.data).toEqual([{ count: 42 }])
-  })
-
-  it('returns error for invalid SQL', async () => {
-    fetchMock.on({
-      method: 'POST',
-      url: `${BASE}/v1/db/${PROJECT}/raw`,
-      replyCode: 400,
-      replyBody: { error: { code: 'sql_error', message: 'syntax error' } },
-    })
-
-    const res = await client.db.sql('SELEC invalid')
-
-    expect(res.error).toBeDefined()
-    expect(res.error!.code).toBe('sql_error')
-  })
-})
-
-// ---------------------------------------------------------------------------
-describe('Schema', () => {
-  it('fetches schema information', async () => {
-    const tables = [
-      {
-        name: 'posts',
-        columns: [
-          { name: 'id', data_type: 'uuid', is_nullable: false, is_primary_key: true },
-          { name: 'title', data_type: 'text', is_nullable: false, is_primary_key: false },
-        ],
-      },
-    ]
-    // Le backend renvoie un SchemaDefinition `{ project_id, engine, tables, functions }` ;
-    // `db.schema()` expose `{ tables, functions }`.
-    fetchMock.on({
-      method: 'GET',
-      url: `${BASE}/v1/db/${PROJECT}/schema`,
-      replyCode: 200,
-      replyBody: { data: { project_id: PROJECT, engine: 'postgres', tables } },
-    })
-
-    const res = await client.db.schema()
-
-    expect(res.error).toBeNull()
-    expect(res.data?.tables).toHaveLength(1)
-    expect(res.data?.tables[0].name).toBe('posts')
-    expect(res.data?.tables[0].columns).toHaveLength(2)
-    expect(res.data?.functions).toEqual([])
-  })
-})

package/packages/aurabase/tests/db-types-e2e.test.ts

@@ -1,217 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel typé (stack live) — Phase 2 Task 7
-//
-// Preuve bout-en-bout que le typage généré (`@aurabase/gen`) pilote une vraie
-// inférence via `createClient<Database>` :
-//   1. crée 2 tables liées par FK (authors 1—N books) via SQL brut ;
-//   2. lit le schéma réel et génère `Database` avec `generateDatabaseTypes` ;
-//   3. écrit ce `Database` généré + un "probe" TS consommant
-//      `createClient<Database>(...).db.from('authors').select('id, books(title)').single()`
-//      dans un dossier temporaire sous `tests/types/` ;
-//   4. compile ce probe avec le pipeline `tsc` du package
-//      (`tsconfig.test-d.json`, mêmes options strictes que `npm run test:types`) —
-//      si l'inférence casse, la compilation échoue ;
-//   5. exécute une vraie requête (même forme) contre le backend live et vérifie
-//      la forme runtime réelle des données ;
-//   6. nettoie (drop tables + fichiers temporaires) en `finally`.
-//
-// Gaté par RUN_E2E + credentials — squelette calqué sur
-// `packages/gen/tests/e2e.test.ts` (provisioning-free, env-based) et
-// `packages/gen/tests/compile.test.ts` (mécanique de compilation tsc).
-//
-// Approche de résolution du probe : import RELATIF vers `../../../src/index`
-// (source, pas le package `aurabase` construit) — cf. `tests/types/*.test-d.ts`
-// qui font déjà exactement ça. Le probe est nommé `*.test-d.ts` et placé sous
-// `tests/types/` pour être ramassé par le même `tsconfig.test-d.json` que les
-// tests de type existants (include: `tests/**/*.test-d.ts`), ce qui réutilise
-// telles quelles les options de compilation strictes du package (strict,
-// moduleResolution bundler, lib ES2022+DOM) sans avoir à les dupliquer sur la
-// ligne de commande — plus robuste que d'assembler des flags `tsc` ad hoc.
-// ---------------------------------------------------------------------------
-
-import { describe, it, expect } from 'vitest'
-import { execFileSync } from 'node:child_process'
-import { mkdtempSync, writeFileSync, rmSync } from 'node:fs'
-import { join, dirname, relative, sep } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { createClient } from '../src/index'
-import type { AuraResponse } from '../src/index'
-import { generateDatabaseTypes } from '../../gen/src/generate'
-
-const __dirname = dirname(fileURLToPath(import.meta.url))
-const PACKAGE_DIR = join(__dirname, '..')
-
-const URL = process.env.AURA_E2E_URL
-const PROJECT = process.env.AURA_E2E_PROJECT
-const KEY = process.env.AURA_E2E_KEY
-const RUN = Boolean(process.env.RUN_E2E && URL && PROJECT && KEY)
-
-/** Chemin relatif POSIX, normalisé en spécificateur d'import (`./x` / `../x`). */
-function relativeImport(fromDir: string, toFileNoExt: string): string {
-  const rel = relative(fromDir, toFileNoExt).split(sep).join('/')
-  return rel.startsWith('.') ? rel : `./${rel}`
-}
-
-/** Rejoue une requête tant qu'elle renvoie un 503 (reload/indispo PostgREST, transitoire),
- *  borné. Renvoie la dernière réponse — le caller décide de skip si elle est encore 503. */
-async function retry503<T>(fn: () => Promise<AuraResponse<T>>): Promise<AuraResponse<T>> {
-  let res = await fn()
-  for (let i = 0; i < 20 && res.error?.status === 503; i++) {
-    await new Promise((r) => setTimeout(r, 1000))
-    res = await fn()
-  }
-  return res
-}
-
-describe.runIf(RUN)('db types E2E — schéma réel → génère → createClient<Database> compile + requête typée', () => {
-  it(
-    'crée authors/books (FK), génère Database, compile un probe typé (tsc), exécute une requête réelle typée',
-    async () => {
-      const client = createClient(URL!, PROJECT!, KEY!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? 'dbtypes'
-      const authors = `e2e_authors_${suffix}`
-      const books = `e2e_books_${suffix}`
-
-      // Nettoyage + création via SQL brut (service_role requis).
-      await client.db.sql(`DROP TABLE IF EXISTS ${books}`)
-      await client.db.sql(`DROP TABLE IF EXISTS ${authors}`)
-      await client.db.sql(
-        `CREATE TABLE ${authors} (id uuid PRIMARY KEY DEFAULT gen_random_uuid(), name text NOT NULL)`,
-      )
-      await client.db.sql(
-        `CREATE TABLE ${books} (id uuid PRIMARY KEY DEFAULT gen_random_uuid(), author_id uuid NOT NULL REFERENCES ${authors}(id), title text NOT NULL)`,
-      )
-      // Les tables créées en SQL brut ne sont PAS accessibles à la couche CRUD/embed
-      // PostgREST tant que (a) les GRANTs ne sont pas posés et (b) le cache de schéma
-      // n'est pas rechargé. Approximation large (GRANT ALL TO PUBLIC) suffisante pour
-      // débloquer la couche CRUD/embed sur ces tables de test jetables — le chemin
-      // console applique des GRANTs plus fins par rôle (aura_anon/aura_authenticated/
-      // aura_service_role), pas un blanket ALL TO PUBLIC.
-      await client.db.sql(`GRANT ALL ON ${authors}, ${books} TO PUBLIC`)
-      await client.db.sql(`SELECT pg_notify('pgrst', 'reload schema')`)
-
-      let probeDir: string | null = null
-      try {
-        // -- 1. Schéma réel → types générés -----------------------------------
-        const { data: schemaData, error: schemaError } = await client.db.schema()
-        expect(schemaError).toBeNull()
-        const tables = (schemaData?.tables ?? []).filter((t) => t.name === authors || t.name === books)
-        expect(tables.length).toBe(2)
-
-        const typesOut = generateDatabaseTypes(tables)
-        expect(typesOut).toContain(`referencedRelation: '${authors}'`)
-        expect(typesOut).toContain(`columns: ['author_id']`)
-
-        // -- 2. Écrit database.types.ts + probe.test-d.ts dans un dossier temp --
-        // sous tests/types/, ramassé par tsconfig.test-d.json (include:
-        // "tests/**/*.test-d.ts"), nettoyé dans `finally`.
-        probeDir = mkdtempSync(join(__dirname, 'types', '.e2e-probe-'))
-        const typesFile = join(probeDir, 'database.types.ts')
-        writeFileSync(typesFile, typesOut)
-
-        const probeFile = join(probeDir, 'probe.test-d.ts')
-        const createClientImport = relativeImport(probeDir, join(PACKAGE_DIR, 'src', 'index'))
-        writeFileSync(
-          probeFile,
-          [
-            `// Fichier généré par tests/db-types-e2e.test.ts — ne pas committer, nettoyé en finally.`,
-            `import { createClient } from '${createClientImport}'`,
-            `import type { Database } from './database.types'`,
-            ``,
-            `async function probe() {`,
-            `  const c = createClient<Database>('${URL}', '${PROJECT}', '${KEY}')`,
-            `  const { data } = await c.db.from('${authors}').select('id, ${books}(title)').single()`,
-            `  // Assertion de type : si l'inférence casse (colonnes/embed FK), ceci ne compile plus.`,
-            `  if (data) {`,
-            `    const id: string = data.id`,
-            `    const relatedTitles: string[] = data['${books}'].map((b) => b.title)`,
-            `    void id`,
-            `    void relatedTitles`,
-            `  }`,
-            `  return data`,
-            `}`,
-            ``,
-            `void probe`,
-            ``,
-          ].join('\n'),
-        )
-
-        // -- 3. Compile le probe avec le pipeline tsc du package (mêmes options
-        // strictes que `npm run test:types`) — preuve que les types générés
-        // pilotent réellement l'inférence de createClient<Database>.
-        expect(() =>
-          execFileSync('npx', ['tsc', '--noEmit', '-p', 'tsconfig.test-d.json'], {
-            cwd: PACKAGE_DIR,
-            stdio: 'pipe',
-          }),
-        ).not.toThrow()
-
-        // -- 4. Requête runtime réelle (BEST-EFFORT) : valide la forme runtime SI le
-        // backend est disponible. La PREUVE du livrable Phase 2 est la compilation
-        // typée ci-dessus (étape 3) ; la disponibilité runtime du backend est
-        // orthogonale. Le reload du cache PostgREST (pg_notify) renvoie des 503
-        // transitoires (« schema cache. Retrying. » / service indisponible) — on
-        // rejoue brièvement pour CHAQUE appel runtime (insert authors, insert books,
-        // select embed final), et si le backend reste en 503 on n'échoue PAS (skip
-        // gracieux avec avertissement), car ce n'est pas un défaut du typage.
-        const insertedAuthor = await retry503(() =>
-          client.db.from(authors).insert({ name: 'Ada Lovelace' }).select('id').single(),
-        )
-        if (insertedAuthor.error?.status === 503) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[db-types-e2e] backend en 503 (reload/indisponible) après retries — ' +
-            'assertion runtime ignorée. La preuve de compilation typée (étape 3) a réussi.',
-          )
-          return
-        }
-        expect(insertedAuthor.error).toBeNull()
-        const authorId = (insertedAuthor.data as { id: string } | null)?.id
-        expect(authorId).toBeTruthy()
-
-        const insertedBook = await retry503(() =>
-          client.db.from(books).insert({ author_id: authorId, title: 'Notes on the Analytical Engine' }),
-        )
-        if (insertedBook.error?.status === 503) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[db-types-e2e] backend en 503 (reload/indisponible) après retries sur insert books — ' +
-            'assertion runtime ignorée. La preuve de compilation typée (étape 3) a réussi.',
-          )
-          return
-        }
-        expect(insertedBook.error).toBeNull()
-
-        const { data: real, error: realError } = await retry503(() =>
-          client.db
-            .from(authors)
-            .select(`id, ${books}(title)`)
-            .eq('id', authorId!)
-            .single(),
-        )
-        if (realError?.status === 503) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[db-types-e2e] backend en 503 (reload/indisponible) après retries sur select embed — ' +
-            'assertion runtime ignorée. La preuve de compilation typée (étape 3) a réussi.',
-          )
-          return
-        }
-
-        expect(realError).toBeNull()
-        expect(real).not.toBeNull()
-        const row = real as { id: string; [key: string]: unknown }
-        expect(row.id).toBe(authorId)
-        const relatedBooks = row[books] as Array<{ title: string }>
-        expect(Array.isArray(relatedBooks)).toBe(true)
-        expect(relatedBooks.length).toBe(1)
-        expect(relatedBooks[0]!.title).toBe('Notes on the Analytical Engine')
-      } finally {
-        if (probeDir) rmSync(probeDir, { recursive: true, force: true })
-        await client.db.sql(`DROP TABLE IF EXISTS ${books}`)
-        await client.db.sql(`DROP TABLE IF EXISTS ${authors}`)
-      }
-    },
-    120_000,
-  )
-})

package/packages/aurabase/tests/dispose.test.ts

@@ -1,23 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest'
-import { createClient } from '../src/index'
-
-afterEach(() => vi.useRealTimers())
-
-describe('AuraClient.dispose()', () => {
-  it('est idempotent et arrête le realtime', () => {
-    const c = createClient('http://localhost:8080', 'p', 'k')
-    const spy = vi.spyOn(c.realtime, 'disconnect')
-    c.dispose()
-    c.dispose() // 2e appel sans erreur
-    expect(spy).toHaveBeenCalled()
-  })
-
-  it('après dispose, onAuthStateChange ne reçoit plus rien', async () => {
-    const c = createClient('http://localhost:8080', 'p', 'k')
-    const cb = vi.fn()
-    c.auth.onAuthStateChange(cb)
-    c.dispose()
-    await Promise.resolve() // flush le microtask INITIAL_SESSION
-    expect(cb).not.toHaveBeenCalled()
-  })
-})

package/packages/aurabase/tests/foreign-token.e2e.test.ts

@@ -1,129 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel LOT D — getClaims/getUser d'un token ARBITRAIRE du même projet
-// (foreign-token), contre la stack live (gateway :8080).
-//
-// Prouve en conditions réelles le déblocage du fallback foreign-token :
-//   1. Enregistre 2 users A et B du MÊME projet (anon key).
-//   2. Depuis un client dont le STORE porte le token de A, appelle
-//      `getClaims(tokenB)` → le backend valide le token de B (présenté via
-//      l'override `authToken`, PAS celui du store A) et renvoie SON identité :
-//      `data.claims.sub === userB.id`. Preuve anti-misattribution : c'est bien
-//      le token étranger qui est validé, pas la session courante.
-//   3. Un JWT forgé/invalide → `error` (le backend refuse) ; jamais de claims
-//      fabriquées.
-//
-// Le JWKS de la stack locale est vide (HS256) → `getClaims` passe par le chemin
-// FALLBACK `getUser(token)` (pas la vérif locale JWKS/WebCrypto). L'isolation
-// projet est native côté gateway (un token d'un autre projet → 403).
-//
-// Gaté par RUN_E2E + credentials (URL/PROJECT/ANON) : `describe.runIf(RUN)`
-// SKIPPE proprement la suite entière quand l'env manque (vérifié sans RUN_E2E
-// via `pnpm --filter aurabase test`). Cleanup best-effort (deleteUser si une
-// clé service_role est fournie via AURA_E2E_SERVICE_KEY).
-// ---------------------------------------------------------------------------
-
-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)
-
-/** 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é. */
-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
-}
-
-/** b64url d'un objet JSON (sans padding). */
-function b64url(obj: unknown): string {
-  return Buffer.from(JSON.stringify(obj)).toString('base64url')
-}
-
-describe.runIf(RUN)('foreign-token E2E réel — getClaims(tokenB) validé serveur (LOT D)', () => {
-  it(
-    '2 users même projet : client(store=A).getClaims(tokenB) → claims.sub===userB.id ; JWT forgé → error',
-    async () => {
-      const clientA = createClient(URL!, PROJECT!, ANON!)
-      const clientB = createClient(URL!, PROJECT!, ANON!)
-      const admin = SERVICE ? createAdminClient(URL!, PROJECT!, SERVICE) : null
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const emailA = `foreign-a-${suffix}@aurabase.dev`
-      const emailB = `foreign-b-${suffix}@aurabase.dev`
-      const password = 'EndUserPassword123!'
-
-      let userIdA: string | null = null
-      let userIdB: string | null = null
-      try {
-        // -- 1. register + login des 2 users (même projet, anon key) ----------
-        await retryTransient(() => clientA.auth.signUp({ email: emailA, password }))
-        const loginA = await retryTransient(() =>
-          clientA.auth.signInWithPassword({ email: emailA, password }),
-        )
-        expect(loginA.error).toBeNull()
-        const dataA = loginA.data as { access_token: string; user: { id: string } }
-        userIdA = dataA.user.id
-
-        await retryTransient(() => clientB.auth.signUp({ email: emailB, password }))
-        const loginB = await retryTransient(() =>
-          clientB.auth.signInWithPassword({ email: emailB, password }),
-        )
-        expect(loginB.error).toBeNull()
-        const dataB = loginB.data as { access_token: string; user: { id: string } }
-        userIdB = dataB.user.id
-        const tokenB = dataB.access_token
-        expect(userIdA).toBeTruthy()
-        expect(userIdB).toBeTruthy()
-        expect(userIdA).not.toBe(userIdB)
-
-        // Le store de clientA porte bien le token de A.
-        const { accessToken: storeA } = await clientA.auth.getSession()
-        expect(storeA).toBe(dataA.access_token)
-
-        // -- 2. getClaims(tokenB) depuis clientA (store=A) --------------------
-        // Le token ÉTRANGER de B est validé côté serveur (présenté via authToken),
-        // PAS le token du store A → claims.sub === userB.id (anti-misattribution).
-        const claimsB = await retryTransient(() => clientA.auth.getClaims(tokenB))
-        expect(claimsB.error).toBeNull()
-        expect(claimsB.data?.claims.sub).toBe(userIdB)
-        expect(claimsB.data?.claims.sub).not.toBe(userIdA)
-
-        // Le store de A n'a PAS été altéré par la validation du token étranger.
-        const { accessToken: storeStill } = await clientA.auth.getSession()
-        expect(storeStill).toBe(dataA.access_token)
-
-        // -- 3. JWT forgé/invalide → error (jamais de claims fabriquées) ------
-        const forged = `${b64url({ alg: 'HS256', typ: 'JWT' })}.${b64url({
-          sub: 'attacker',
-          exp: Math.floor(Date.now() / 1000) + 3600,
-        })}.not-a-valid-signature`
-        const claimsForged = await clientA.auth.getClaims(forged)
-        expect(claimsForged.data).toBeNull()
-        expect(claimsForged.error).not.toBeNull()
-      } finally {
-        if (admin) {
-          for (const id of [userIdA, userIdB]) {
-            if (id) {
-              try {
-                await admin.authAdmin.deleteUser(id)
-              } catch {
-                // best-effort cleanup
-              }
-            }
-          }
-        }
-      }
-    },
-    120_000,
-  )
-})