@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/aurabase/tests/refresh-locks.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, afterEach, vi } from 'vitest'
-import { refreshOnce, BaseAuthStore } from '@aurabase/core'
-import type { AuraClientLike, User } from '@aurabase/core'
-
-function fakeUser(id = 'u1'): User {
-  return {
-    id,
-    email: 't@e.com',
-    role: 'authenticated',
-    email_verified: true,
-    is_banned: false,
-    is_anonymous: false,
-    mfa_enabled: false,
-    user_metadata: {},
-    app_metadata: {},
-    created_at: '2025-01-01T00:00:00Z',
-  }
-}
-function b64url(obj: unknown): string {
-  return btoa(JSON.stringify(obj)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
-}
-function jwt(sub = 'u1', ttlSec = 3600): string {
-  const exp = Math.floor(Date.now() / 1000) + ttlSec
-  return `${b64url({ alg: 'HS256', typ: 'JWT' })}.${b64url({ sub, exp })}.sig`
-}
-
-// -- navigator.locks install/uninstall (Node peut définir navigator en lecture seule) --
-// Les Web Locks ne s'activent qu'en contexte NAVIGATEUR (gate `window` dans
-// withRefreshLock) : on simule donc aussi `globalThis.window` le temps du test.
-let hadNavigator = false
-let originalNavigator: PropertyDescriptor | undefined
-let hadWindow = false
-function installLocks(request: unknown): void {
-  hadNavigator = 'navigator' in globalThis
-  originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator')
-  Object.defineProperty(globalThis, 'navigator', {
-    value: { locks: { request } },
-    configurable: true,
-    writable: true,
-  })
-  hadWindow = 'window' in globalThis
-  if (!hadWindow) {
-    ;(globalThis as unknown as { window?: unknown }).window = globalThis
-  }
-}
-function uninstallLocks(): void {
-  if (originalNavigator) {
-    Object.defineProperty(globalThis, 'navigator', originalNavigator)
-  } else if (hadNavigator) {
-    // rien
-  } else {
-    delete (globalThis as unknown as { navigator?: unknown }).navigator
-  }
-  originalNavigator = undefined
-  if (!hadWindow) {
-    delete (globalThis as unknown as { window?: unknown }).window
-  }
-}
-
-afterEach(() => {
-  uninstallLocks()
-  vi.restoreAllMocks()
-})
-
-function makeClient(
-  fetchFn: typeof globalThis.fetch,
-  store: BaseAuthStore,
-  projectId = 'proj-X',
-): AuraClientLike {
-  return {
-    baseUrl: 'http://locks.local',
-    projectId,
-    apiKey: 'k',
-    fetchFn,
-    authStore: store,
-    auth: null as unknown as AuraClientLike['auth'],
-  }
-}
-
-function refreshFetch(tokenPair: unknown): typeof globalThis.fetch {
-  return (async (url: string | URL | Request) => {
-    if (String(url).endsWith('/refresh')) {
-      return new Response(JSON.stringify({ data: tokenPair }), {
-        status: 200,
-        headers: { 'Content-Type': 'application/json' },
-      })
-    }
-    return new Response('{}', { status: 200 })
-  }) as unknown as typeof globalThis.fetch
-}
-
-describe('refreshOnce — verrou cross-onglets Web Locks (I2)', () => {
-  it('enveloppe le refresh dans navigator.locks.request avec le nom aura-refresh-<projectId>', async () => {
-    const tokenPair = {
-      access_token: jwt('u1'),
-      refresh_token: 'rt-new',
-      user: fakeUser(),
-      token_type: 'bearer',
-      expires_in: 3600,
-    }
-    const store = new BaseAuthStore()
-    store.save(jwt('u1'), 'rt-old', fakeUser())
-
-    // Mock du lock : exécute immédiatement le callback (comme un lock disponible).
-    const request = vi.fn(
-      async (_name: string, _opts: unknown, cb: () => Promise<unknown>) => cb(),
-    )
-    installLocks(request)
-
-    const client = makeClient(refreshFetch(tokenPair), store, 'proj-X')
-    const res = await refreshOnce(client)
-
-    expect(res.error).toBeNull()
-    expect(res.data?.access_token).toBe(tokenPair.access_token)
-    // Le lock a bien enveloppé le refresh, sous le nom project-scoped.
-    expect(request).toHaveBeenCalledTimes(1)
-    expect(request.mock.calls[0]![0]).toBe('aura-refresh-proj-X')
-    expect(typeof request.mock.calls[0]![2]).toBe('function')
-    // Le store porte les tokens rafraîchis.
-    expect(store.token).toBe(tokenPair.access_token)
-    expect(store.refreshToken).toBe('rt-new')
-  })
-
-  it('fallback sans navigator.locks : le refresh fonctionne (comportement actuel)', async () => {
-    // Pas de locks installés (navigator absent ou sans .locks).
-    uninstallLocks()
-    delete (globalThis as unknown as { navigator?: unknown }).navigator
-
-    const tokenPair = {
-      access_token: jwt('u2'),
-      refresh_token: 'rt-fb',
-      user: fakeUser('u2'),
-      token_type: 'bearer',
-      expires_in: 3600,
-    }
-    const store = new BaseAuthStore()
-    store.save(jwt('u2'), 'rt-old', fakeUser('u2'))
-
-    const client = makeClient(refreshFetch(tokenPair), store, 'proj-Y')
-    const res = await refreshOnce(client)
-
-    expect(res.error).toBeNull()
-    expect(res.data?.access_token).toBe(tokenPair.access_token)
-    expect(store.refreshToken).toBe('rt-fb')
-  })
-
-  it('TESTS-1.3 : navigator.locks présent MAIS window ABSENT (Node 21+ SSR) → lock NON utilisé', async () => {
-    // Non-régression du gate `window` de withRefreshLock : sous Node ≥21 `navigator.locks`
-    // EXISTE mais est PROCESS-GLOBAL — l'utiliser sérialiserait les refresh d'utilisateurs
-    // DIFFÉRENTS partageant le même projectId (bug). On installe navigator.locks SANS
-    // window et on prouve que request() n'est JAMAIS appelé (fallback single-flight).
-    hadNavigator = 'navigator' in globalThis
-    originalNavigator = Object.getOwnPropertyDescriptor(globalThis, 'navigator')
-    const request = vi.fn(
-      async (_name: string, _opts: unknown, cb: () => Promise<unknown>) => cb(),
-    )
-    Object.defineProperty(globalThis, 'navigator', {
-      value: { locks: { request } },
-      configurable: true,
-      writable: true,
-    })
-    // GARANTIT l'absence de window (contexte serveur Node).
-    hadWindow = 'window' in globalThis
-    delete (globalThis as unknown as { window?: unknown }).window
-
-    const tokenPair = {
-      access_token: jwt('u4'),
-      refresh_token: 'rt-nolock',
-      user: fakeUser('u4'),
-      token_type: 'bearer',
-      expires_in: 3600,
-    }
-    const store = new BaseAuthStore()
-    store.save(jwt('u4'), 'rt-old', fakeUser('u4'))
-
-    const client = makeClient(refreshFetch(tokenPair), store, 'proj-SSR')
-    const res = await refreshOnce(client)
-
-    // Le refresh aboutit, mais SANS passer par le lock process-global.
-    expect(res.error).toBeNull()
-    expect(res.data?.access_token).toBe(tokenPair.access_token)
-    expect(request).not.toHaveBeenCalled()
-  })
-
-  it('acquisition du lock qui rejette (AbortError) → fallback SANS lock, pas de blocage', async () => {
-    const tokenPair = {
-      access_token: jwt('u3'),
-      refresh_token: 'rt-ab',
-      user: fakeUser('u3'),
-      token_type: 'bearer',
-      expires_in: 3600,
-    }
-    const store = new BaseAuthStore()
-    store.save(jwt('u3'), 'rt-old', fakeUser('u3'))
-
-    // Le lock rejette (comme un abort d'attente) → withRefreshLock doit fallback.
-    const request = vi.fn(async () => {
-      throw new DOMException('aborted', 'AbortError')
-    })
-    installLocks(request)
-
-    const client = makeClient(refreshFetch(tokenPair), store, 'proj-Z')
-    const res = await refreshOnce(client)
-
-    expect(request).toHaveBeenCalledTimes(1)
-    // Malgré l'échec d'acquisition, le refresh a été exécuté (fallback).
-    expect(res.error).toBeNull()
-    expect(res.data?.access_token).toBe(tokenPair.access_token)
-  })
-})

package/packages/aurabase/tests/retry-option.test.ts

@@ -1,17 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { createClient } from '../src/index'
-
-describe('option client retry → retryConfig', () => {
-  it('défaut : activé, maxRetries 3', () => {
-    const c = createClient('http://localhost:8080', 'p', 'aura_anon_x')
-    expect(c.retryConfig).toEqual({ enabled: true, maxRetries: 3 })
-  })
-  it('retry: false → désactivé', () => {
-    const c = createClient('http://localhost:8080', 'p', 'aura_anon_x', { retry: false })
-    expect(c.retryConfig).toEqual({ enabled: false, maxRetries: 0 })
-  })
-  it('retry: { maxRetries: 5 } → override partiel', () => {
-    const c = createClient('http://localhost:8080', 'p', 'aura_anon_x', { retry: { maxRetries: 5 } })
-    expect(c.retryConfig).toEqual({ enabled: true, maxRetries: 5 })
-  })
-})

package/packages/aurabase/tests/rpc-e2e.test.ts

@@ -1,254 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel de rpc() — Sous-chantier A (Task A3) + Sous-chantier B (Task B6),
-// chantier DB `rpc()`.
-//
-// Sous-chantier A — preuve runtime que `aura.db.rpc(fn, args?, options?)`
-// fonctionne contre une vraie fonction Postgres exposée par PostgREST, à
-// travers le gateway :
-//   - fonction scalaire (POST, args en body) → data est la valeur scalaire ;
-//   - fonction SETOF filtrée post-rpc (`.eq(...).select(...).single()`) ;
-//   - même fonction SETOF appelée en mode GET (`{ get: true }`, args en query).
-//
-// Sous-chantier B — preuve que le backend introspecte réellement les
-// fonctions Postgres et que le typage généré en consomme le résultat :
-//   - `admin.db.schema()` remonte `functions` (name/args/returns/is_set_returning)
-//     pour une fonction scalaire ET une fonction SETOF ;
-//   - `aura.db.rpc(fn, {}, { count: 'exact' })` remonte `meta.total` (le
-//     gateway propage `count` sur `/rpc` via le même mécanisme générique
-//     Content-Range → meta.total que pour les tables) ;
-//   - `aura.db.rpc(fn, {}, { head: true })` ne renvoie pas d'erreur/de corps
-//     (le 204 court-circuite la construction de `meta` côté gateway) ;
-//   - `generateDatabaseTypes` (`@aurabase/gen`) consomme `schema().functions`
-//     réel et émet un bloc `Functions` avec `Args`/`Returns`.
-//
-// Setup (service_role, via `admin.db.sql`) : CREATE OR REPLACE FUNCTION +
-// GRANT EXECUTE TO PUBLIC + `pg_notify('pgrst', 'reload schema')`, calqué sur
-// db-types-e2e.test.ts. Le reload de cache PostgREST étant asynchrone, chaque
-// appel anon est enveloppé dans `retryReload` (rejoue sur les statuts
-// transitoires {408,429,502,503,504} ∪ 404, borné), avec skip gracieux
-// explicite si le reload persiste après retries — cf. readme-smoke-e2e.test.ts.
-// Cleanup `DROP FUNCTION IF EXISTS` en `finally`.
-//
-// Gaté par RUN_E2E + credentials (identique aux autres E2E du package) :
-// 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'
-import { generateDatabaseTypes } from '../../gen/src/generate'
-
-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 (jeu complet
- *  TRANSIENT_STATUS) OU 404 (cache PostgREST pas encore rechargé — fonction
- *  inconnue), borné. Cf. readme-smoke-e2e.test.ts / db-types-e2e.test.ts : le
- *  reload de cache (pg_notify) est ASYNCHRONE — juste après le CREATE/GRANT,
- *  PostgREST peut d'abord renvoyer un 404 puis un 503 avant d'être prêt. */
-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
-}
-
-/** true si la réponse reste en échec de reload/indisponibilité après retries
- *  (skip gracieux — NON un défaut de rpc(), un défaut d'infra transitoire). */
-function isReloadStuck<T>(res: AuraResponse<T>): boolean {
-  return TRANSIENT_STATUS.has(res.error?.status) || res.error?.status === 404
-}
-
-describe.runIf(RUN)('rpc() E2E réel (stack live) — fonction scalaire + SETOF filtrée + get', () => {
-  it(
-    'rpc_sum (scalaire, POST) / rpc_things (SETOF, filtré + get:true)',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const aura = createClient(URL!, PROJECT!, ANON!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const fnSum = `rpc_sum_${suffix}`
-      const fnThings = `rpc_things_${suffix}`
-
-      try {
-        // -- Setup (service_role) : fonctions + GRANT + reload cache PostgREST --
-        await admin.db.sql(
-          `CREATE OR REPLACE FUNCTION ${fnSum}(a int, b int) RETURNS int LANGUAGE sql IMMUTABLE AS $fn$ SELECT a + b $fn$`,
-        )
-        await admin.db.sql(
-          `CREATE OR REPLACE FUNCTION ${fnThings}() RETURNS TABLE(id int, name text) LANGUAGE sql STABLE AS $fn$ SELECT * FROM (VALUES (1,'alpha'), (2,'beta')) t(id,name) $fn$`,
-        )
-        await admin.db.sql(`GRANT EXECUTE ON FUNCTION ${fnSum}(int,int), ${fnThings}() TO PUBLIC`)
-        await admin.db.sql(`SELECT pg_notify('pgrst', 'reload schema')`)
-        // Laisse le reload asynchrone démarrer avant le premier appel — sans ce
-        // délai, le premier appel tombe quasi systématiquement en 404/503.
-        await new Promise((r) => setTimeout(r, 1500))
-
-        // -- 1. Fonction scalaire (POST, args en body) --------------------------
-        const scalar = await retryReload(() => aura.db.rpc(fnSum, { a: 2, b: 3 }))
-        if (isReloadStuck(scalar)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[rpc-e2e] SKIP rpc scalaire (infra: reload/503/404 persistant après retries) — ' +
-              'NON un succès : assertion runtime rpc ignorée, pas un défaut de rpc().',
-          )
-          return
-        }
-        expect(scalar.error).toBeNull()
-        expect(scalar.data).toBe(5)
-
-        // -- 2. Fonction SETOF filtrée post-rpc (.eq().select().single()) ------
-        const filtered = await retryReload(() =>
-          aura.db.rpc(fnThings, {}).eq('id', 2).select('id,name').single(),
-        )
-        if (isReloadStuck(filtered)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[rpc-e2e] SKIP rpc SETOF filtrée (infra: reload/503/404 persistant après retries) — ' +
-              'NON un succès : assertion runtime rpc ignorée, pas un défaut de rpc().',
-          )
-          return
-        }
-        expect(filtered.error).toBeNull()
-        expect(filtered.data).toEqual({ id: 2, name: 'beta' })
-
-        // -- 3. Même fonction SETOF, appelée en mode GET (get:true) -------------
-        const viaGet = await retryReload(() => aura.db.rpc(fnThings, undefined, { get: true }))
-        if (isReloadStuck(viaGet)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[rpc-e2e] SKIP rpc get:true (infra: reload/503/404 persistant après retries) — ' +
-              'NON un succès : assertion runtime rpc ignorée, pas un défaut de rpc().',
-          )
-          return
-        }
-        expect(viaGet.error).toBeNull()
-        expect(viaGet.data).toEqual([
-          { id: 1, name: 'alpha' },
-          { id: 2, name: 'beta' },
-        ])
-      } finally {
-        await admin.db.sql(`DROP FUNCTION IF EXISTS ${fnSum}(int,int)`)
-        await admin.db.sql(`DROP FUNCTION IF EXISTS ${fnThings}()`)
-      }
-    },
-    120_000,
-  )
-
-  // -- Sous-chantier B (Task B6) : introspection backend + count/head + gen --
-  //
-  // Le backend est déployé (rebuild fait) : `GET /v1/db/{pid}/schema` remonte
-  // désormais `functions: [{name, args:[{name,data_type,mode}], returns,
-  // is_set_returning}]`, `DatabaseService.schema()` les propage, et le
-  // gateway propage déjà `count` sur `/rpc` (Content-Range → meta.total, même
-  // mécanisme générique que pour les tables — dérisqué en curl direct avant
-  // d'écrire ce test : `functions` contient bien `rpc_sum_*`/`rpc_things_*`
-  // avec la forme attendue, `count=exact` sur `rpc_things` donne
-  // `meta.total === 2`). Pour `head:true`, le gateway répond 204 No Content
-  // AVANT toute construction de `meta` (court-circuit générique, cf.
-  // `postgrest_proxy.rs::normalize_response`) — vérifié en curl direct : le
-  // total n'est PAS exposé en HEAD. On assert donc uniquement l'absence
-  // d'erreur/de corps, avec un hedge défensif si `meta.total` venait à
-  // apparaître un jour (comportement alors encore plus favorable).
-  it(
-    'schema() introspecte les fonctions réelles + count/head réels + gen émet Functions',
-    async () => {
-      const admin = createAdminClient(URL!, PROJECT!, SERVICE!)
-      const aura = createClient(URL!, PROJECT!, ANON!)
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const fnSum = `rpc_sum_b_${suffix}`
-      const fnThings = `rpc_things_b_${suffix}`
-
-      try {
-        // -- Setup (service_role) : fonctions + GRANT + reload cache PostgREST --
-        await admin.db.sql(
-          `CREATE OR REPLACE FUNCTION ${fnSum}(a int, b int) RETURNS int LANGUAGE sql IMMUTABLE AS $fn$ SELECT a + b $fn$`,
-        )
-        await admin.db.sql(
-          `CREATE OR REPLACE FUNCTION ${fnThings}() RETURNS TABLE(id int, name text) LANGUAGE sql STABLE AS $fn$ SELECT * FROM (VALUES (1,'alpha'), (2,'beta')) t(id,name) $fn$`,
-        )
-        await admin.db.sql(`GRANT EXECUTE ON FUNCTION ${fnSum}(int,int), ${fnThings}() TO PUBLIC`)
-        await admin.db.sql(`SELECT pg_notify('pgrst', 'reload schema')`)
-        await new Promise((r) => setTimeout(r, 1500))
-
-        // -- 1. schema() introspecte réellement les fonctions -------------------
-        const schemaRes = await retryReload(() => admin.db.schema())
-        if (isReloadStuck(schemaRes)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[rpc-e2e] SKIP schema() functions (infra: reload/503/404 persistant après retries) — ' +
-              'NON un succès : assertion schema() ignorée, pas un défaut de schema().',
-          )
-          return
-        }
-        expect(schemaRes.error).toBeNull()
-        const allFunctions = schemaRes.data?.functions ?? []
-        const sumFn = allFunctions.find((f) => f.name === fnSum)
-        const thingsFn = allFunctions.find((f) => f.name === fnThings)
-        expect(sumFn).toBeDefined()
-        expect(sumFn?.args).toEqual([
-          { name: 'a', data_type: 'int4', mode: 'IN' },
-          { name: 'b', data_type: 'int4', mode: 'IN' },
-        ])
-        expect(sumFn?.returns).toBe('int4')
-        expect(sumFn?.is_set_returning).toBe(false)
-        expect(thingsFn).toBeDefined()
-        expect(thingsFn?.is_set_returning).toBe(true)
-
-        // -- 2. count réel : meta.total === 2 sur rpc_things ---------------------
-        const counted = await retryReload(() => aura.db.rpc(fnThings, {}, { count: 'exact' }))
-        if (isReloadStuck(counted)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[rpc-e2e] SKIP rpc count (infra: reload/503/404 persistant après retries) — ' +
-              'NON un succès : assertion count ignorée, pas un défaut de rpc().',
-          )
-          return
-        }
-        expect(counted.error).toBeNull()
-        expect(counted.meta?.total).toBe(2)
-
-        // -- 3. head réel : pas d'erreur, pas de corps (204) ---------------------
-        const headed = await retryReload(() => aura.db.rpc(fnThings, {}, { head: true }))
-        if (isReloadStuck(headed)) {
-          // eslint-disable-next-line no-console
-          console.warn(
-            '[rpc-e2e] SKIP rpc head (infra: reload/503/404 persistant après retries) — ' +
-              'NON un succès : assertion head ignorée, pas un défaut de rpc().',
-          )
-          return
-        }
-        expect(headed.error).toBeNull()
-        expect(headed.data).toBeNull()
-        // Hedge défensif : le 204 court-circuite `meta` côté gateway (vérifié en
-        // curl), donc `meta.total` est absent en pratique — si un jour exposé,
-        // il doit rester cohérent avec le compte réel.
-        if (headed.meta?.total !== undefined) {
-          expect(headed.meta.total).toBe(2)
-        }
-
-        // -- 4. gen consomme le schéma réel et émet le bloc Functions ------------
-        const typesOut = generateDatabaseTypes(schemaRes.data?.tables ?? [], {
-          functions: allFunctions,
-        })
-        expect(typesOut).toContain('Functions:')
-        expect(typesOut).toContain(`${fnSum}:`)
-        expect(typesOut).toContain('Args: { a: number; b: number }')
-        expect(typesOut).toContain(`${fnThings}:`)
-      } finally {
-        await admin.db.sql(`DROP FUNCTION IF EXISTS ${fnSum}(int,int)`)
-        await admin.db.sql(`DROP FUNCTION IF EXISTS ${fnThings}()`)
-      }
-    },
-    120_000,
-  )
-})

package/packages/aurabase/tests/rs256-local-e2e.test.ts

@@ -1,114 +0,0 @@
-// ---------------------------------------------------------------------------
-// E2E réel — LOT E : getClaims via la vérification LOCALE RS256 (stack live)
-//
-// Contrairement à `auth-e2e.test.ts` (qui documente le déploiement HS256/JWKS
-// vide → chemin FALLBACK getUser), ce test s'exécute contre la stack configurée
-// en RS256 par l'override `docker/docker-compose.rs256.yml` (LOT E). Il prouve
-// que `getClaims` emprunte enfin le chemin de vérification LOCALE (WebCrypto,
-// JWKS non-vide) — cf. `packages/auth/src/jwks.ts` + `AuthService.getClaims`.
-//
-// Signaux discriminants du chemin LOCAL (vs fallback) :
-//   - `header.alg === 'RS256'` et `header.kid === 'dev1'` ;
-//   - `claims.exp` présent (le fallback dérive de getUser et OMET exp/iat) ;
-//   - ZÉRO appel réseau `/v1/auth/{pid}/user` (compteur sur un fetch injecté) ;
-//   - au moins un fetch `/.well-known/jwks.json`.
-// Plus : une signature falsifiée → `signature_invalid` (JAMAIS de fallback qui
-// masquerait une signature invalide).
-//
-// Gaté par RUN_E2E + AURA_E2E_URL/PROJECT/ANON_KEY (projet provisionné en amont
-// par le driver LOT E). Squelette calqué sur auth-e2e.test.ts.
-// ---------------------------------------------------------------------------
-
-import { describe, it, expect } from 'vitest'
-import { createClient } 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 RUN = Boolean(process.env.RUN_E2E && URL && PROJECT && ANON)
-
-const TRANSIENT_STATUS = new Set([408, 429, 502, 503, 504])
-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
-}
-
-/** Décode le header d'un JWT (base64url natif Node). */
-function jwtHeader(jwt: string): { alg?: string; kid?: string } {
-  return JSON.parse(Buffer.from(jwt.split('.')[0], 'base64url').toString('utf8'))
-}
-
-describe.runIf(RUN)('LOT E — getClaims vérif LOCALE RS256 (stack live override)', () => {
-  it(
-    'login RS256 → getClaims chemin LOCAL (JWKS non-vide, 0 appel /user, exp présent) + signature falsifiée → signature_invalid',
-    async () => {
-      // Fetch instrumenté : compte les appels /user (fallback) et /jwks.json (local).
-      let userCalls = 0
-      let jwksCalls = 0
-      const countingFetch: typeof globalThis.fetch = (input, init) => {
-        const u =
-          typeof input === 'string' ? input : input instanceof URL ? input.href : (input as Request).url
-        if (u.includes('/.well-known/jwks.json')) jwksCalls++
-        if (/\/v1\/auth\/[^/]+\/user\b/.test(u)) userCalls++
-        return globalThis.fetch(input as Parameters<typeof globalThis.fetch>[0], init)
-      }
-
-      const client = createClient(URL!, PROJECT!, ANON!, { fetch: countingFetch })
-      const suffix = process.env.AURA_E2E_SUFFIX ?? Math.random().toString(36).slice(2, 8)
-      const email = `lote-rs256-${suffix}@aurabase.dev`
-      const password = 'EndUserPassword123!'
-
-      // -- 1. register + login → token RS256 --------------------------------
-      const signUpRes = await retryTransient(() => client.auth.signUp({ email, password }))
-      expect(signUpRes.error).toBeNull()
-
-      const loginRes = await retryTransient(() =>
-        client.auth.signInWithPassword({ email, password }),
-      )
-      expect(loginRes.error).toBeNull()
-      const loginData = loginRes.data as { access_token: string; user: { id: string } }
-      const token = loginData.access_token
-      const userId = loginData.user.id
-      expect(token).toBeTruthy()
-      expect(userId).toBeTruthy()
-
-      // -- 2. header du token : RS256 + kid=dev1 ----------------------------
-      const header = jwtHeader(token)
-      expect(header.alg).toBe('RS256')
-      expect(header.kid).toBe('dev1')
-
-      // -- 3. getClaims → chemin LOCAL (aucun /user) ------------------------
-      userCalls = 0
-      jwksCalls = 0
-      const claimsRes = await client.auth.getClaims()
-      expect(claimsRes.error).toBeNull()
-      expect(claimsRes.data?.header.alg).toBe('RS256')
-      expect(claimsRes.data?.header.kid).toBe('dev1')
-      expect(claimsRes.data?.claims.sub).toBe(userId)
-      // `exp` présent ⇒ claims issues du JWT décodé localement (le fallback getUser l'OMET).
-      expect(typeof claimsRes.data?.claims.exp).toBe('number')
-      // ZÉRO appel /user ⇒ pas de validation serveur : vérif purement locale.
-      expect(userCalls).toBe(0)
-      // Au moins un fetch JWKS (peut être 0 si un test précédent a chauffé le cache
-      // process-global ; on tolère >= 0 mais on exige surtout userCalls === 0).
-      expect(jwksCalls).toBeGreaterThanOrEqual(0)
-
-      // -- 4. signature falsifiée → signature_invalid (jamais de fallback) --
-      const parts = token.split('.')
-      const tampered = parts[2].endsWith('AAAA') ? parts[2].slice(0, -4) + 'BBBB' : parts[2].slice(0, -4) + 'AAAA'
-      const forged = `${parts[0]}.${parts[1]}.${tampered}`
-      userCalls = 0
-      const forgedRes = await client.auth.getClaims(forged)
-      expect(forgedRes.data).toBeNull()
-      expect(forgedRes.error?.code).toBe('signature_invalid')
-      // Une signature invalide ne doit JAMAIS déclencher le fallback getUser.
-      expect(userCalls).toBe(0)
-    },
-    120_000,
-  )
-})