@aurabase/aurabase-js 0.3.0 → 0.4.0

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

@@ -1,314 +0,0 @@
-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

@@ -1,186 +0,0 @@
-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

@@ -1,130 +0,0 @@
-// ---------------------------------------------------------------------------
-// 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()
-  })
-})