@aurabase/aurabase-js 0.3.0

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

@@ -0,0 +1,314 @@
+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 = '00000000-0000-0000-0000-000000000001'
+const PREFIX = `${BASE}/v1/notifications/${PROJECT}`
+
+let fetchMock: FetchMock
+let client: AuraClient
+
+beforeEach(() => {
+  fetchMock = new FetchMock()
+  fetchMock.init()
+  client = new AuraClient(BASE, PROJECT, 'aura_anon_test', {
+    auth: { persistSession: false },
+  })
+  const tp = fakeTokenPair()
+  client.authStore.save(tp.access_token, tp.refresh_token, tp.user)
+})
+
+afterEach(() => {
+  fetchMock.restore()
+  fetchMock.clearMocks()
+})
+
+describe('NotificationsService route contract', () => {
+  it('sends notifications to /send with backend payload names', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/send`,
+      replyCode: 202,
+      replyBody: { data: { id: 'notif-1', status: 'queued' } },
+    })
+
+    await client.notifications.send('email', 'user@example.com', 'Hello', {
+      subject: 'Hi',
+      templateId: 'tpl-1',
+      variables: { name: 'Ada' },
+      metadata: { campaign: 'welcome' },
+      idempotencyKey: 'notif-key-1',
+    })
+
+    expect(fetchMock.calls[0].body).toEqual({
+      channel: 'email',
+      recipient: 'user@example.com',
+      body: 'Hello',
+      subject: 'Hi',
+      template_id: 'tpl-1',
+      variables: { name: 'Ada' },
+      metadata: { campaign: 'welcome' },
+      idempotency_key: 'notif-key-1',
+    })
+  })
+
+  it('queues notification batches', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/send/batch`,
+      replyCode: 202,
+      replyBody: { data: { items: [{ index: 0, status: 'queued' }] } },
+    })
+
+    await client.notifications.sendBatch([
+      {
+        channel: 'email',
+        recipient: 'user@example.com',
+        subject: 'Hi',
+        body: 'Hello',
+        idempotency_key: 'batch-1',
+      },
+    ])
+
+    expect(fetchMock.calls[0].body).toEqual({
+      items: [
+        {
+          channel: 'email',
+          recipient: 'user@example.com',
+          subject: 'Hi',
+          body: 'Hello',
+          idempotency_key: 'batch-1',
+        },
+      ],
+    })
+  })
+
+  it('lists and gets notifications using backend routes', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}?limit=10&offset=5`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/notif-1`,
+      replyCode: 200,
+      replyBody: { data: { id: 'notif-1' } },
+    })
+
+    await client.notifications.list({ limit: 10, offset: 5 })
+    await client.notifications.get('notif-1')
+
+    expect(fetchMock.calls[0].url).toBe(`${PREFIX}?limit=10&offset=5`)
+    expect(fetchMock.calls[1].url).toBe(`${PREFIX}/notif-1`)
+  })
+
+  it('uses template routes including PATCH update', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/templates`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/templates/tpl-1`,
+      replyCode: 200,
+      replyBody: { data: { id: 'tpl-1' } },
+    })
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/templates`,
+      replyCode: 200,
+      replyBody: { data: { id: 'tpl-1' } },
+    })
+    fetchMock.on({
+      method: 'PATCH',
+      url: `${PREFIX}/templates/tpl-1`,
+      replyCode: 200,
+      replyBody: { data: { id: 'tpl-1' } },
+    })
+    fetchMock.on({
+      method: 'DELETE',
+      url: `${PREFIX}/templates/tpl-1`,
+      replyCode: 204,
+    })
+
+    await client.notifications.listTemplates()
+    await client.notifications.getTemplate('tpl-1')
+    await client.notifications.createTemplate({
+      name: 'Welcome',
+      channel: 'email',
+      subject: 'Hi',
+      body: 'Hello',
+      variables: ['name'],
+    })
+    await client.notifications.updateTemplate('tpl-1', { body: 'Updated' })
+    await client.notifications.deleteTemplate('tpl-1')
+
+    expect(fetchMock.calls.map((call) => call.method)).toEqual([
+      'GET',
+      'GET',
+      'POST',
+      'PATCH',
+      'DELETE',
+    ])
+    expect(fetchMock.calls[3].body).toEqual({ body: 'Updated' })
+  })
+
+  it('exposes admin template preview and observability routes', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/templates/tpl-1/preview`,
+      replyCode: 200,
+      replyBody: { data: { subject: 'Hi Ada', body: 'Hello Ada' } },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/settings`,
+      replyCode: 200,
+      replyBody: { data: { project_id: PROJECT } },
+    })
+    fetchMock.on({
+      method: 'PATCH',
+      url: `${PREFIX}/settings`,
+      replyCode: 200,
+      replyBody: { data: { project_id: PROJECT } },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/stats?window=24h&channel=email`,
+      replyCode: 200,
+      replyBody: { data: { total: 0 } },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/queue`,
+      replyCode: 200,
+      replyBody: { data: { queued_count: 0 } },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/notif-1/attempts`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/dead-letters?channel=email&limit=5&offset=0`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/dead-letters/dlq-1/retry`,
+      replyCode: 202,
+      replyBody: { data: { id: 'notif-1' } },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/events?status=failed&limit=10`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/providers/logs?status=sent&limit=10`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+
+    await client.notifications.admin.previewTemplate('tpl-1', { name: 'Ada' })
+    await client.notifications.admin.getSettings()
+    await client.notifications.admin.updateSettings({ webhook: { timeout_secs: 2 } })
+    await client.notifications.admin.getStats({ window: '24h', channel: 'email' })
+    await client.notifications.admin.getQueue()
+    await client.notifications.admin.listAttempts('notif-1')
+    await client.notifications.admin.listDeadLetters({ channel: 'email', limit: 5, offset: 0 })
+    await client.notifications.admin.retryDeadLetter('dlq-1')
+    await client.notifications.admin.listEvents({ status: 'failed', limit: 10 })
+    await client.notifications.admin.listProviderLogs({ status: 'sent', limit: 10 })
+
+    expect(fetchMock.calls.map((call) => call.url)).toEqual([
+      `${PREFIX}/templates/tpl-1/preview`,
+      `${PREFIX}/settings`,
+      `${PREFIX}/settings`,
+      `${PREFIX}/stats?window=24h&channel=email`,
+      `${PREFIX}/queue`,
+      `${PREFIX}/notif-1/attempts`,
+      `${PREFIX}/dead-letters?channel=email&limit=5&offset=0`,
+      `${PREFIX}/dead-letters/dlq-1/retry`,
+      `${PREFIX}/events?status=failed&limit=10`,
+      `${PREFIX}/providers/logs?status=sent&limit=10`,
+    ])
+    expect(fetchMock.calls[0].body).toEqual({ name: 'Ada' })
+    expect(fetchMock.calls[2].body).toEqual({ webhook: { timeout_secs: 2 } })
+  })
+
+  it('exposes admin rules routes', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/rules`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/rules`,
+      replyCode: 200,
+      replyBody: { data: { id: 'rule-1' } },
+    })
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/rules/rule-1`,
+      replyCode: 200,
+      replyBody: { data: { id: 'rule-1' } },
+    })
+    fetchMock.on({
+      method: 'PATCH',
+      url: `${PREFIX}/rules/rule-1`,
+      replyCode: 200,
+      replyBody: { data: { id: 'rule-1' } },
+    })
+    fetchMock.on({
+      method: 'DELETE',
+      url: `${PREFIX}/rules/rule-1`,
+      replyCode: 200,
+      replyBody: { data: null },
+    })
+
+    await client.notifications.admin.listRules()
+    await client.notifications.admin.createRule({
+      name: 'User created',
+      trigger_type: 'auth.user.created',
+      condition: {},
+      template_id: 'tpl-1',
+      channel: 'email',
+      recipient_expr: 'email',
+      delay_seconds: 0,
+    })
+    await client.notifications.admin.getRule('rule-1')
+    await client.notifications.admin.updateRule('rule-1', { enabled: false })
+    await client.notifications.admin.deleteRule('rule-1')
+
+    expect(fetchMock.calls.map((call) => call.method)).toEqual([
+      'GET',
+      'POST',
+      'GET',
+      'PATCH',
+      'DELETE',
+    ])
+    expect(fetchMock.calls[1].body).toEqual({
+      name: 'User created',
+      trigger_type: 'auth.user.created',
+      condition: {},
+      template_id: 'tpl-1',
+      channel: 'email',
+      recipient_expr: 'email',
+      delay_seconds: 0,
+    })
+    expect(fetchMock.calls[3].body).toEqual({ enabled: false })
+  })
+})

package/packages/aurabase/tests/observability-backup.test.ts

@@ -0,0 +1,186 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+
+const GATEWAY_URL = 'http://localhost:8080'
+const MGMT_URL = 'http://localhost:8090'
+
+describe('Tests d\'intégration Observabilité et Backups Database (E2E)', () => {
+  let devToken: string
+  let projectId: string
+  let anonKey: string
+  
+  const runId = Math.random().toString(36).substring(2, 10)
+  const devEmail = `observability-dev-${runId}@aurabase.dev`
+  const devPassword = 'DevPasswordE2E123!'
+  const projectName = `observability-proj-${runId}`
+
+  beforeAll(async () => {
+    // 1. Enregistrement développeur
+    const regRes = await fetch(`${MGMT_URL}/v1/control/accounts/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email: devEmail, password: devPassword }),
+    })
+    expect(regRes.status).toBe(200)
+    const regData = await regRes.json()
+    devToken = regData.data.access_token
+
+    // 2. Création organisation
+    const orgRes = await fetch(`${MGMT_URL}/v1/control/orgs`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${devToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ name: 'Observability Org', slug: `obs-org-${runId}` }),
+    })
+    expect(orgRes.status).toBeLessThan(300)
+    const orgData = await orgRes.json()
+    const orgId = orgData.id
+
+    // 3. Création projet
+    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' }),
+    })
+    expect(projRes.status).toBe(202)
+    const projData = await projRes.json()
+    projectId = projData.id
+
+    // Attente du provisioning
+    let active = false
+    for (let i = 0; i < 50; i++) {
+      const statusRes = await fetch(`${MGMT_URL}/v1/control/projects/${projectId}`, {
+        headers: { 'Authorization': `Bearer ${devToken}` },
+      })
+      const statusData = await statusRes.json()
+      if (statusData && statusData.status === 'active') {
+        active = true
+        break
+      }
+      await new Promise((resolve) => setTimeout(resolve, 1500))
+    }
+    expect(active).toBe(true)
+
+    // Récupération clés API
+    const keysRes = await fetch(`${MGMT_URL}/v1/control/projects/${projectId}/initial-keys`, {
+      headers: { 'Authorization': `Bearer ${devToken}` },
+    })
+    expect(keysRes.status).toBe(200)
+    const keysData = await keysRes.json()
+    const keys = keysData.data || keysData
+    anonKey = keys.find((k: any) => k.scope === 'anon').key
+    expect(anonKey).toBeDefined()
+  }, 50000)
+
+  afterAll(async () => {
+    // Suppression du projet de test
+    if (projectId && devToken) {
+      const delRes = await fetch(`${MGMT_URL}/v1/control/projects/${projectId}`, {
+        method: 'DELETE',
+        headers: { 'Authorization': `Bearer ${devToken}` },
+      })
+      expect(delRes.status).toBe(204)
+    }
+  })
+
+  it('devrait interroger les APIs d\'observabilité (db-stats, active-queries, slow-queries) avec succès', async () => {
+    // 1. Test des statistiques de la base de données
+    const statsRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/observability/db-stats`, {
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    expect(statsRes.status).toBe(200)
+    const stats = await statsRes.json()
+    expect(stats.data).toBeDefined()
+    expect(stats.data.active_connections).toBeGreaterThanOrEqual(0)
+    expect(stats.data.max_connections).toBeGreaterThan(0)
+    expect(stats.data.db_size_bytes).toBeGreaterThan(0)
+
+    // 2. Test des processus SQL actifs
+    const activeRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/observability/active-queries`, {
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    expect(activeRes.status).toBe(200)
+    const activeQueries = await activeRes.json()
+    expect(activeQueries.data).toBeInstanceOf(Array)
+
+    // 3. Test des slow-queries (pg_stat_statements)
+    const slowRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/observability/slow-queries`, {
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    expect(slowRes.status).toBe(200)
+    const slowQueries = await slowRes.json()
+    expect(slowQueries.data).toBeDefined()
+    expect(slowQueries.data.extension_available).toBeDefined()
+  })
+
+  it('devrait créer, lister, télécharger, restaurer et supprimer un backup logique SQL avec succès', async () => {
+    const backupLabel = `backup_e2e_${runId}`
+
+    // 1. Création d'un backup
+    const createRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${devToken}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({ label: backupLabel })
+    })
+    if (createRes.status !== 200) {
+      console.log('CREATE BACKUP ERROR STATUS:', createRes.status, 'BODY:', await createRes.text())
+    }
+    expect(createRes.status).toBe(200)
+    const createData = await createRes.json()
+    expect(createData.data).toBeDefined()
+    const backupId = createData.data.id
+    expect(backupId).toBeDefined()
+    expect(createData.data.label).toBe(backupLabel)
+
+    // 2. Liste des backups
+    const listRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups`, {
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    expect(listRes.status).toBe(200)
+    const listData = await listRes.json()
+    expect(listData.data).toBeInstanceOf(Array)
+    const found = listData.data.find((b: any) => b.id === backupId)
+    expect(found).toBeDefined()
+    expect(found.label).toBe(backupLabel)
+
+    // 3. Téléchargement du dump SQL
+    const getRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups/${backupId}`, {
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    expect(getRes.status).toBe(200)
+    const getData = await getRes.json()
+    expect(getData.data).toBeDefined()
+    expect(getData.data.sql_dump).toBeDefined()
+    expect(getData.data.sql_dump).toContain('Aurabase backup')
+    expect(getData.data.sql_dump).toContain(projectId)
+
+    // 4. Restauration du backup
+    const restoreRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups/${backupId}/restore`, {
+      method: 'POST',
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    expect(restoreRes.status).toBe(200)
+
+    // 5. Suppression du backup
+    const delRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups/${backupId}`, {
+      method: 'DELETE',
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    expect(delRes.status).toBe(200)
+
+    // 6. Vérification de la suppression de la liste
+    const listPostDelRes = await fetch(`${MGMT_URL}/v1/db/${projectId}/backups`, {
+      headers: { 'Authorization': `Bearer ${devToken}` }
+    })
+    const listPostDelData = await listPostDelRes.json()
+    const stillExists = listPostDelData.data.some((b: any) => b.id === backupId)
+    expect(stillExists).toBe(false)
+  })
+})

package/packages/aurabase/tests/observability-hook.test.ts

@@ -0,0 +1,130 @@
+// ---------------------------------------------------------------------------
+// Câblage bout-en-bout du hook d'observabilité (LOT 3, finding I8) :
+// AuraClientOptions.onEvent/debug -> AuraClient -> fetchWithAuth / LocalAuthStore.
+// Valide que le threading ajouté dans AuraClient.ts (hors périmètre strict du lot,
+// mais indispensable — voir rapport) fonctionne réellement de bout en bout, pas
+// seulement au niveau unitaire de `@aurabase/core`.
+// ---------------------------------------------------------------------------
+
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { AuraClient } from '../src/AuraClient'
+import { LocalAuthStore } from '@aurabase/core'
+import type { AuraObservabilityEvent } from '@aurabase/core'
+
+afterEach(() => {
+  vi.useRealTimers()
+  delete (globalThis as { localStorage?: unknown }).localStorage
+})
+
+/** fetch séquentiel minimal (mêmes réponses dans l'ordre, quel que soit le call count). */
+function seqFetch(responses: Array<{ status: number; body?: unknown }>): typeof globalThis.fetch {
+  let i = 0
+  return (async () => {
+    const r = responses[Math.min(i, responses.length - 1)]
+    i++
+    return new Response(r.body !== undefined ? JSON.stringify(r.body) : null, {
+      status: r.status,
+      headers: { 'Content-Type': 'application/json' },
+    })
+  }) as unknown as typeof globalThis.fetch
+}
+
+describe('AuraClientOptions.onEvent/debug — câblage bout-en-bout', () => {
+  it('un retry transitoire réel (via client.auth.getSettings()) émet {kind:"retry"}', async () => {
+    vi.useFakeTimers()
+    const events: AuraObservabilityEvent[] = []
+    const fetchFn = seqFetch([
+      { status: 503 },
+      { status: 200, body: { data: { disable_signup: false, external: {}, mailer_autoconfirm: true, mfa_enabled: false } } },
+    ])
+    const client = new AuraClient('http://localhost:8080', 'proj-1', 'aura_anon_x', {
+      fetch: fetchFn,
+      onEvent: (e) => events.push(e),
+      auth: { persistSession: false },
+    })
+
+    const p = client.auth.getSettings()
+    await vi.advanceTimersByTimeAsync(600)
+    const res = await p
+
+    expect(res.error).toBeNull()
+    expect(events).toContainEqual(
+      expect.objectContaining({ kind: 'retry', status: 503 }),
+    )
+  })
+
+  it('debug:true journalise les événements via console.debug', async () => {
+    const spy = vi.spyOn(console, 'debug').mockImplementation(() => {})
+    vi.useFakeTimers()
+    const fetchFn = seqFetch([{ status: 503 }, { status: 200, body: { data: {} } }])
+    const client = new AuraClient('http://localhost:8080', 'proj-1', 'aura_anon_x', {
+      fetch: fetchFn,
+      debug: true,
+      auth: { persistSession: false },
+    })
+
+    const p = client.auth.getSettings()
+    await vi.advanceTimersByTimeAsync(600)
+    await p
+
+    expect(spy).toHaveBeenCalled()
+    spy.mockRestore()
+  })
+
+  it('un store custom (LocalAuthStore fourni via auth.storage) émet storage-blocked via le client', () => {
+    // localStorage cassé (quota/navigation privée) — même mock que auth-store.test.ts.
+    const storage = {
+      getItem: vi.fn(() => null),
+      setItem: vi.fn(() => {
+        throw new Error('QuotaExceededError')
+      }),
+      removeItem: vi.fn(),
+      clear: vi.fn(),
+      length: 0,
+      key: vi.fn(() => null),
+    }
+    Object.defineProperty(globalThis, 'localStorage', {
+      value: storage,
+      writable: true,
+      configurable: true,
+    })
+
+    const events: AuraObservabilityEvent[] = []
+    const customStore = new LocalAuthStore('custom-key')
+    const client = new AuraClient('http://localhost:8080', 'proj-1', 'aura_anon_x', {
+      onEvent: (e) => events.push(e),
+      auth: { persistSession: true, storage: customStore },
+    })
+
+    expect(() =>
+      client.authStore.save('tok', 'rt', {
+        id: 'u1',
+        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',
+      }),
+    ).not.toThrow()
+
+    // save() persiste via `_persist()` (op 'persist'), pas via `setItem` (générique).
+    expect(events).toContainEqual({ kind: 'storage-blocked', op: 'persist' })
+  })
+
+  it('sans onEvent ni debug (défaut) : comportement inchangé, aucune émission', async () => {
+    vi.useFakeTimers()
+    const fetchFn = seqFetch([{ status: 503 }, { status: 200, body: { data: {} } }])
+    const client = new AuraClient('http://localhost:8080', 'proj-1', 'aura_anon_x', {
+      fetch: fetchFn,
+      auth: { persistSession: false },
+    })
+    const p = client.auth.getSettings()
+    await vi.advanceTimersByTimeAsync(600)
+    const res = await p
+    expect(res.error).toBeNull()
+  })
+})