@aurabase/aurabase-js 0.3.0

package/packages/aurabase/tests/live-production-validation.js

@@ -0,0 +1,241 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+// URL unique de la Gateway d'Aurabase comme en production
+const API_URL = 'http://localhost:8080';
+
+async function run() {
+  const runId = Math.random().toString(36).substring(2, 10);
+  const email = `live-prod-${runId}@aurabase.dev`;
+  const password = 'LiveSecurePassword123!';
+  const projectName = `live-project-${runId}`;
+  
+  console.log(`[1] Inscription du compte développeur via la Gateway : ${email}`);
+  const regRes = await fetch(`${API_URL}/v1/control/accounts/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email, password }),
+  });
+  console.log(`Statut HTTP Inscription : ${regRes.status}`);
+  const regData = await regRes.json();
+  console.log('Réponse Inscription :', JSON.stringify(regData, null, 2));
+
+  const devToken = regData.data.access_token;
+  if (!devToken) {
+    throw new Error("Impossible d'obtenir le token développeur");
+  }
+
+  console.log('\n[2] Création de l\'organisation via la Gateway...');
+  const orgRes = await fetch(`${API_URL}/v1/control/orgs`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ name: 'Live Validation Org', slug: `live-org-${runId}` }),
+  });
+  console.log(`Statut HTTP Org : ${orgRes.status}`);
+  const orgData = await orgRes.json();
+  console.log('Réponse Org :', JSON.stringify(orgData, null, 2));
+  const orgId = orgData.id;
+
+  console.log('\n[3] Création du projet via la Gateway...');
+  const projRes = await fetch(`${API_URL}/v1/control/orgs/${orgId}/projects`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ name: projectName, engine: 'postgres', region: 'eu-west-1' }),
+  });
+  console.log(`Statut HTTP Création Projet : ${projRes.status}`);
+  const projData = await projRes.json();
+  console.log('Réponse Création Projet :', JSON.stringify(projData, null, 2));
+  const projectId = projData.id;
+
+  console.log('\n[4] Attente du provisioning actif du projet via la Gateway...');
+  let active = false;
+  for (let i = 0; i < 30; i++) {
+    const statusRes = await fetch(`${API_URL}/v1/control/projects/${projectId}`, {
+      headers: { 'Authorization': `Bearer ${devToken}` },
+    });
+    const statusData = await statusRes.json();
+    console.log(`Vérification ${i+1} : statut = ${statusData.status}`);
+    if (statusData && statusData.status === 'active') {
+      active = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+  if (!active) {
+    throw new Error("Le provisioning du projet a expiré");
+  }
+
+  console.log('\n[5] Récupération des clés API via la Gateway (avec retry)...');
+  let keysData = null;
+  for (let i = 0; i < 15; i++) {
+    const keysRes = await fetch(`${API_URL}/v1/control/projects/${projectId}/initial-keys`, {
+      headers: { 'Authorization': `Bearer ${devToken}` },
+    });
+    console.log(`Tentative ${i+1} : statut HTTP = ${keysRes.status}`);
+    if (keysRes.status === 200) {
+      keysData = await keysRes.json();
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+  }
+  if (!keysData) {
+    throw new Error("Impossible de récupérer les clés API initiales (timeout/expiré)");
+  }
+  console.log('Réponse Clés API :', JSON.stringify(keysData, null, 2));
+  const keys = keysData.data || keysData;
+  const anonKey = keys.find((k) => k.scope === 'anon').key;
+  const serviceKey = keys.find((k) => k.scope === 'service_role').key;
+
+  console.log('\n[6] Création de la table "live_tasks" via l\'API schéma de la Gateway...');
+  const tableDef = {
+    name: 'live_tasks',
+    columns: [
+      {
+        name: 'id',
+        col_type: 'uuid',
+        nullable: false,
+        unique: true,
+        default_val: 'gen_random_uuid()',
+        references: null
+      },
+      {
+        name: 'title',
+        col_type: 'text',
+        nullable: false,
+        unique: false,
+        default_val: null,
+        references: null
+      },
+      {
+        name: 'description',
+        col_type: 'text',
+        nullable: true,
+        unique: false,
+        default_val: null,
+        references: null
+      }
+    ],
+    primary_key: 'id',
+    indexes: [],
+    rls_enabled: true,
+    realtime_enabled: true
+  };
+
+  const tableRes = await fetch(`${API_URL}/v1/db/${projectId}/schema/tables`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(tableDef),
+  });
+  console.log(`Statut HTTP Création Table : ${tableRes.status}`);
+  const tableData = await tableRes.json();
+  console.log('Réponse Création Table :', JSON.stringify(tableData, null, 2));
+
+  console.log('\n[7] Attente active de la synchronisation PostgREST (Probe loop)...');
+  let pgrstReady = false;
+  for (let i = 0; i < 20; i++) {
+    const probeRes = await fetch(`${API_URL}/v1/db/${projectId}/live_tasks`, {
+      headers: { 'apikey': anonKey },
+    });
+    console.log(`Probe PostgREST ${i+1} : statut HTTP = ${probeRes.status}`);
+    if (probeRes.status === 200) {
+      pgrstReady = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1500));
+  }
+  if (!pgrstReady) {
+    throw new Error("PostgREST n'a pas synchronisé la table live_tasks dans les temps.");
+  }
+
+  // Petit délai supplémentaire de sécurité pour s'assurer que toutes les instances sont stabilisées
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  console.log('\n[8] Test d\'écriture (INSERT) à travers la Gateway (avec retry)...');
+  let insertData = null;
+  let insertStatus = 0;
+  for (let i = 0; i < 15; i++) {
+    const insertRes = await fetch(`${API_URL}/v1/db/${projectId}/live_tasks`, {
+      method: 'POST',
+      headers: {
+        'apikey': serviceKey,
+        'Content-Type': 'application/json',
+        'Prefer': 'return=representation'
+      },
+      body: JSON.stringify({
+        title: 'Tâche de production réelle',
+        description: 'Ceci est une insertion via la Gateway Aurabase.'
+      })
+    });
+    insertStatus = insertRes.status;
+    console.log(`Tentative d'insertion ${i+1} : statut HTTP = ${insertStatus}`);
+    if (insertStatus === 201 || insertStatus === 200) {
+      insertData = await insertRes.json();
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+  if (!insertData) {
+    throw new Error(`L'insertion a échoué avec le statut final ${insertStatus}`);
+  }
+  console.log('Réponse Insertion :', JSON.stringify(insertData, null, 2));
+
+  console.log('\n[9] Test de lecture (SELECT) à travers la Gateway...');
+  const selectRes = await fetch(`${API_URL}/v1/db/${projectId}/live_tasks`, {
+    headers: { 'apikey': serviceKey }
+  });
+  console.log(`Statut HTTP Sélection : ${selectRes.status}`);
+  const selectData = await selectRes.json();
+  console.log('Réponse Sélection :', JSON.stringify(selectData, null, 2));
+
+  console.log('\n[10] Test de l\'API d\'observabilité (db-stats) via la Gateway...');
+  const statsRes = await fetch(`${API_URL}/v1/db/${projectId}/observability/db-stats`, {
+    headers: { 'Authorization': `Bearer ${devToken}` }
+  });
+  console.log(`Statut HTTP Métriques DB : ${statsRes.status}`);
+  const statsData = await statsRes.json();
+  console.log('Réponse Métriques DB :', JSON.stringify(statsData, null, 2));
+
+  console.log('\n[11] Lancement d\'un backup SQL en direct via la Gateway...');
+  const backupRes = await fetch(`${API_URL}/v1/db/${projectId}/backups`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ label: `live_backup_${runId}` })
+  });
+  console.log(`Statut HTTP Backup : ${backupRes.status}`);
+  const backupData = await backupRes.json();
+  console.log('Réponse Backup :', JSON.stringify(backupData, null, 2));
+  const backupId = backupData.data.id;
+
+  console.log('\n[12] Liste des backups via la Gateway...');
+  const listRes = await fetch(`${API_URL}/v1/db/${projectId}/backups`, {
+    headers: { 'Authorization': `Bearer ${devToken}` }
+  });
+  console.log(`Statut HTTP Liste Backups : ${listRes.status}`);
+  const listData = await listRes.json();
+  console.log('Réponse Liste Backups (extraits) :', JSON.stringify(listData.data.slice(0, 3), null, 2));
+
+  console.log('\n[13] Nettoyage en cours via la Gateway (Suppression du projet)...');
+  const delRes = await fetch(`${API_URL}/v1/control/projects/${projectId}`, {
+    method: 'DELETE',
+    headers: { 'Authorization': `Bearer ${devToken}` },
+  });
+  console.log(`Statut HTTP Suppression Projet : ${delRes.status}`);
+
+  console.log('\n VALIDATION DE PRODUCTION UNIFIÉE TERMINÉE AVEC SUCCÈS !');
+}
+
+run().catch((err) => {
+  console.error('Erreur lors de la validation :', err);
+});

package/packages/aurabase/tests/live-sdk-production-validation.js

@@ -0,0 +1,293 @@
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+import { createClient } from '../dist/index.js';
+
+const GATEWAY_URL = 'http://localhost:8080';
+const MGMT_URL = 'http://localhost:8090';
+
+async function run() {
+  const runId = Math.random().toString(36).substring(2, 10);
+  const email = `live-sdk-${runId}@aurabase.dev`;
+  const password = 'LiveSecurePassword123!';
+  const projectName = `live-sdk-project-${runId}`;
+  
+  console.log(`[1] Inscription d'un nouveau compte développeur : ${email}`);
+  const regRes = await fetch(`${MGMT_URL}/v1/control/accounts/register`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ email, password }),
+  });
+  console.log(`Statut HTTP Inscription : ${regRes.status}`);
+  const regData = await regRes.json();
+  console.log('Réponse Inscription :', JSON.stringify(regData, null, 2));
+
+  const devToken = regData.data.access_token;
+  if (!devToken) {
+    throw new Error("Impossible d'obtenir le token développeur");
+  }
+
+  console.log('\n[2] Création d\'une organisation...');
+  const orgRes = await fetch(`${MGMT_URL}/v1/control/orgs`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ name: 'Live SDK Validation Org', slug: `live-sdk-org-${runId}` }),
+  });
+  console.log(`Statut HTTP Org : ${orgRes.status}`);
+  const orgData = await orgRes.json();
+  console.log('Réponse Org :', JSON.stringify(orgData, null, 2));
+  const orgId = orgData.id;
+
+  console.log('\n[3] Création d\'un projet PostgreSQL dataplane...');
+  const projRes = await fetch(`${MGMT_URL}/v1/control/orgs/${orgId}/projects`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ name: projectName, engine: 'postgres', region: 'eu-west-1' }),
+  });
+  console.log(`Statut HTTP Création Projet : ${projRes.status}`);
+  const projData = await projRes.json();
+  console.log('Réponse Création Projet :', JSON.stringify(projData, null, 2));
+  const projectId = projData.id;
+
+  console.log('\n[4] Attente du provisioning actif du projet...');
+  let active = false;
+  for (let i = 0; i < 30; i++) {
+    const statusRes = await fetch(`${MGMT_URL}/v1/control/projects/${projectId}`, {
+      headers: { 'Authorization': `Bearer ${devToken}` },
+    });
+    const statusData = await statusRes.json();
+    console.log(`Vérification ${i+1} : statut = ${statusData.status}`);
+    if (statusData && statusData.status === 'active') {
+      active = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+  if (!active) {
+    throw new Error("Le provisioning du projet a expiré");
+  }
+
+  console.log('\n[5] Récupération des clés API (anon et service_role)...');
+  let keysRes = null;
+  for (let i = 0; i < 15; i++) {
+    keysRes = await fetch(`${MGMT_URL}/v1/control/projects/${projectId}/initial-keys`, {
+      headers: { 'Authorization': `Bearer ${devToken}` },
+    });
+    if (keysRes.status === 200) {
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+  if (!keysRes || keysRes.status !== 200) {
+    throw new Error("Impossible d'obtenir les clés API");
+  }
+  const keysData = await keysRes.json();
+  console.log('Réponse Clés API :', JSON.stringify(keysData, null, 2));
+  const keys = keysData.data || keysData;
+  const anonKey = keys.find((k) => k.scope === 'anon').key;
+  const serviceKey = keys.find((k) => k.scope === 'service_role').key;
+
+  console.log('\n[6] Création de la table "live_tasks" via l\'API schéma d\'administration...');
+  const tableDef = {
+    name: 'live_tasks',
+    columns: [
+      {
+        name: 'id',
+        col_type: 'uuid',
+        nullable: false,
+        unique: true,
+        default_val: 'gen_random_uuid()',
+        references: null
+      },
+      {
+        name: 'title',
+        col_type: 'text',
+        nullable: false,
+        unique: false,
+        default_val: null,
+        references: null
+      },
+      {
+        name: 'description',
+        col_type: 'text',
+        nullable: true,
+        unique: false,
+        default_val: null,
+        references: null
+      },
+      {
+        name: 'owner_id',
+        col_type: 'text',
+        nullable: false,
+        unique: false,
+        default_val: null,
+        references: null
+      }
+    ],
+    primary_key: 'id',
+    indexes: [],
+    rls_enabled: true,
+    realtime_enabled: true
+  };
+
+  const tableRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/schema/tables`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(tableDef),
+  });
+  console.log(`Statut HTTP Création Table : ${tableRes.status}`);
+  const tableData = await tableRes.json();
+  console.log('Réponse Création Table :', JSON.stringify(tableData, null, 2));
+
+  console.log('\n[7] Création d\'une policy RLS (propriétaire uniquement)...');
+  const policyDef = {
+    name: 'live_tasks_owner_policy',
+    table: 'live_tasks',
+    command: 'ALL',
+    using_expr: 'auth.uid()::text = owner_id',
+    check_expr: 'auth.uid()::text = owner_id'
+  };
+
+  const policyRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/policies`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(policyDef),
+  });
+  console.log(`Statut HTTP Création Policy : ${policyRes.status}`);
+
+  console.log('\n[8] Attente active de la synchronisation PostgREST (Probe loop)...');
+  let ready = false;
+  for (let i = 0; i < 20; i++) {
+    const probeRes = await fetch(`${GATEWAY_URL}/v1/db/${projectId}/live_tasks`, {
+      headers: { 'apikey': anonKey },
+    });
+    console.log(`Probe PostgREST ${i+1} : statut = ${probeRes.status}`);
+    if (probeRes.status === 200) {
+      ready = true;
+      break;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+  }
+  if (!ready) {
+    throw new Error("PostgREST n'a pas réussi à synchroniser la table");
+  }
+
+  // ─── INITIALISATION DU SDK CLIENT ───
+  console.log('\n[9] Initialisation du client SDK (AuraClient)...');
+  const clientA = createClient(GATEWAY_URL, projectId, anonKey, {
+    auth: { persistSession: false }
+  });
+  const clientB = createClient(GATEWAY_URL, projectId, anonKey, {
+    auth: { persistSession: false }
+  });
+
+  const userAEmail = `usera-${runId}@example.com`;
+  const userAPassword = 'UserAPassword123!';
+  const userBEmail = `userb-${runId}@example.com`;
+  const userBPassword = 'UserBPassword123!';
+
+  console.log(`\n[10] Inscription de User A (${userAEmail}) et User B (${userBEmail}) via le SDK...`);
+  const signUpARes = await clientA.auth.signUp({ email: userAEmail, password: userAPassword });
+  if (signUpARes.error) throw new Error(`SignUp A échoué : ${signUpARes.error.message}`);
+  const userA = signUpARes.data.user;
+  console.log('User A inscrit :', userA.id);
+
+  const signUpBRes = await clientB.auth.signUp({ email: userBEmail, password: userBPassword });
+  if (signUpBRes.error) throw new Error(`SignUp B échoué : ${signUpBRes.error.message}`);
+  const userB = signUpBRes.data.user;
+  console.log('User B inscrit :', userB.id);
+
+  console.log('\n[11] Connexion de User A et User B via le SDK...');
+  const signInARes = await clientA.auth.signInWithPassword({ email: userAEmail, password: userAPassword });
+  if (signInARes.error) throw new Error(`SignIn A échoué : ${signInARes.error.message}`);
+  console.log('User A connecté.');
+
+  const signInBRes = await clientB.auth.signInWithPassword({ email: userBEmail, password: userBPassword });
+  if (signInBRes.error) throw new Error(`SignIn B échoué : ${signInBRes.error.message}`);
+  console.log('User B connecté.');
+
+  console.log('\n[12] Insertion d\'une ligne via le SDK par User A...');
+  const insertARes = await clientA.db.from('live_tasks').insert({
+    title: 'Tâche de User A',
+    description: 'Ceci est ma tâche privée.',
+    owner_id: userA.id
+  });
+  if (insertARes.error) {
+    console.error('Détails de l\'erreur d\'insertion :', JSON.stringify(insertARes.error, null, 2));
+    throw new Error(`Insertion A échouée : ${insertARes.error.message}`);
+  }
+  console.log('Insertion A réussie :', JSON.stringify(insertARes.data, null, 2));
+
+  console.log('\n[13] Lecture (SELECT) par User A via le SDK...');
+  const selectARes = await clientA.db.from('live_tasks').select('*');
+  if (selectARes.error) throw new Error(`Sélection A échouée : ${selectARes.error.message}`);
+  console.log('Résultats pour User A :', JSON.stringify(selectARes.data, null, 2));
+  if (!selectARes.data || selectARes.data.length === 0) {
+    throw new Error("User A n'arrive pas à lire sa propre tâche");
+  }
+
+  console.log('\n[14] Test d\'isolation RLS : Tentative de lecture (SELECT) par User B via le SDK...');
+  const selectBRes = await clientB.db.from('live_tasks').select('*');
+  if (selectBRes.error) throw new Error(`Sélection B échouée : ${selectBRes.error.message}`);
+  console.log('Résultats pour User B (doivent être vides en raison de la RLS) :', JSON.stringify(selectBRes.data, null, 2));
+  if (selectBRes.data && selectBRes.data.length > 0) {
+    throw new Error("CRITIQUE : Faille d'isolation RLS ! User B peut lire les tâches de User A !");
+  }
+  console.log("-> Isolation RLS vérifiée avec succès !");
+
+  console.log('\n[15] Test de l\'API d\'observabilité (db-stats)...');
+  const statsRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/observability/db-stats`, {
+    headers: { 'Authorization': `Bearer ${devToken}` }
+  });
+  console.log(`Statut HTTP Métriques DB : ${statsRes.status}`);
+  const statsData = await statsRes.status === 200 ? await statsRes.json() : null;
+  console.log('Réponse Métriques DB :', JSON.stringify(statsData, null, 2));
+
+  console.log('\n[16] Lancement d\'un backup SQL en direct...');
+  const backupRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups`, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${devToken}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ label: `live_backup_${runId}` })
+  });
+  console.log(`Statut HTTP Backup : ${backupRes.status}`);
+  const backupData = await backupRes.json();
+  console.log('Réponse Backup :', JSON.stringify(backupData, null, 2));
+  const backupId = backupData.data.id;
+
+  console.log('\n[17] Liste des backups...');
+  const listRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups`, {
+    headers: { 'Authorization': `Bearer ${devToken}` }
+  });
+  console.log(`Statut HTTP Liste Backups : ${listRes.status}`);
+  const listData = await listRes.json();
+  console.log('Réponse Liste Backups (extraits) :', JSON.stringify(listData.data.slice(0, 3), null, 2));
+
+  console.log('\n[18] Nettoyage en cours (Suppression du projet)...');
+  const delRes = await fetch(`${MGMT_URL}/v1/control/projects/${projectId}`, {
+    method: 'DELETE',
+    headers: { 'Authorization': `Bearer ${devToken}` },
+  });
+  console.log(`Statut HTTP Suppression Projet : ${delRes.status}`);
+
+  console.log('\n VALIDATION DE PRODUCTION VIA LE SDK TERMINÉE AVEC SUCCÈS !');
+}
+
+run().catch((err) => {
+  console.error('Erreur critique lors de la validation :', err);
+  process.exit(1);
+});

package/packages/aurabase/tests/mocks.ts

@@ -0,0 +1,139 @@
+// ---------------------------------------------------------------------------
+// FetchMock -- intercepts globalThis.fetch for deterministic SDK tests
+// ---------------------------------------------------------------------------
+
+export interface RequestMock {
+  method: string
+  url: string | RegExp
+  replyCode: number
+  replyBody?: unknown
+  replyHeaders?: Record<string, string>
+}
+
+export interface FetchCall {
+  url: string
+  method: string
+  headers: Headers
+  body?: unknown
+}
+
+export class FetchMock {
+  private originalFetch?: typeof fetch
+  private mocks: RequestMock[] = []
+  calls: FetchCall[] = []
+
+  /** Register a mock response. */
+  on(mock: RequestMock): void {
+    this.mocks.push(mock)
+  }
+
+  /** Replace globalThis.fetch with the mock implementation. */
+  init(): void {
+    this.originalFetch = globalThis.fetch
+    globalThis.fetch = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+      const url = typeof input === 'string' ? input : input.toString()
+      const method = (init?.method ?? 'GET').toUpperCase()
+      const headers = new Headers(init?.headers)
+      let body: unknown
+      if (typeof init?.body === 'string') {
+        try {
+          body = JSON.parse(init.body)
+        } catch {
+          body = init.body
+        }
+      } else {
+        body = init?.body
+      }
+      this.calls.push({ url, method, headers, body })
+
+      for (const mock of this.mocks) {
+        const urlMatch =
+          mock.url instanceof RegExp ? mock.url.test(url) : mock.url === url
+        if (urlMatch && mock.method.toUpperCase() === method) {
+          return new Response(
+            mock.replyBody !== undefined ? JSON.stringify(mock.replyBody) : null,
+            {
+              status: mock.replyCode,
+              headers: {
+                'Content-Type': 'application/json',
+                ...mock.replyHeaders,
+              },
+            },
+          )
+        }
+      }
+
+      throw new Error(`FetchMock: no mock for ${method} ${url}`)
+    }
+  }
+
+  /** Restore the original globalThis.fetch. */
+  restore(): void {
+    if (this.originalFetch) {
+      globalThis.fetch = this.originalFetch
+    }
+  }
+
+  /** Remove all registered mocks. */
+  clearMocks(): void {
+    this.mocks = []
+    this.calls = []
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers -- reusable test data factories
+// ---------------------------------------------------------------------------
+
+import type { User, TokenPair } from '@aurabase/core'
+
+/** Build a fake JWT whose payload encodes the given exp (seconds since epoch). */
+export function fakeJwt(exp: number): string {
+  const header = btoa(JSON.stringify({ alg: 'HS256', typ: 'JWT' }))
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '')
+  const payload = btoa(JSON.stringify({ sub: 'user-1', exp }))
+    .replace(/\+/g, '-')
+    .replace(/\//g, '_')
+    .replace(/=+$/, '')
+  const sig = 'fake_sig'
+  return `${header}.${payload}.${sig}`
+}
+
+/** A JWT that expires far in the future. */
+export function validJwt(): string {
+  return fakeJwt(Math.floor(Date.now() / 1000) + 3600)
+}
+
+/** A JWT that is already expired. */
+export function expiredJwt(): string {
+  return fakeJwt(Math.floor(Date.now() / 1000) - 60)
+}
+
+export function fakeUser(overrides: Partial<User> = {}): User {
+  return {
+    id: 'user-1',
+    email: 'test@example.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',
+    ...overrides,
+  }
+}
+
+export function fakeTokenPair(overrides: Partial<TokenPair> = {}): TokenPair {
+  return {
+    access_token: validJwt(),
+    refresh_token: 'rt_fake_refresh',
+    token_type: 'bearer',
+    expires_in: 3600,
+    user: fakeUser(),
+    ...overrides,
+  }
+}