@aurabase/aurabase-js 0.3.0

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

@@ -0,0 +1,111 @@
+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/ai/${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('AiService route contract', () => {
+  it('sends chat messages to /chat', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/chat`,
+      replyCode: 200,
+      replyBody: { data: { content: 'ok', model: 'test' } },
+    })
+
+    await client.ai.chat([{ role: 'user', content: 'hello' }], { max_tokens: 32 })
+
+    expect(fetchMock.calls[0].body).toEqual({
+      messages: [{ role: 'user', content: 'hello' }],
+      max_tokens: 32,
+    })
+  })
+
+  it('uses backend embed payload shape', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/embed`,
+      replyCode: 200,
+      replyBody: { data: { id: 'emb-1', dimensions: 1536 } },
+    })
+
+    await client.ai.embed({ text: 'doc', namespace: 'kb', metadata: { source: 'test' } })
+
+    expect(fetchMock.calls[0].body).toEqual({
+      text: 'doc',
+      namespace: 'kb',
+      metadata: { source: 'test' },
+    })
+  })
+
+  it('queries and ingests RAG using backend routes', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/rag/query`,
+      replyCode: 200,
+      replyBody: { data: { answer: 'ok', sources: [], model: 'test' } },
+    })
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/rag/ingest`,
+      replyCode: 200,
+      replyBody: { data: { id: 'ing-1', chunks: 1 } },
+    })
+
+    await client.ai.rag({ question: 'what?', namespace: 'kb' })
+    await client.ai.ragIngest({ namespace: 'kb', content: 'hello' })
+
+    expect(fetchMock.calls[0].body).toEqual({ question: 'what?', namespace: 'kb' })
+    expect(fetchMock.calls[1].body).toEqual({ namespace: 'kb', content: 'hello' })
+  })
+
+  it('performs semantic search with GET query params', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${PREFIX}/search?query=hello&namespace=kb&top_k=3&threshold=0.7`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+
+    await client.ai.semanticSearch('hello', 'kb', { top_k: 3, threshold: 0.7 })
+
+    expect(fetchMock.calls[0].url).toBe(`${PREFIX}/search?query=hello&namespace=kb&top_k=3&threshold=0.7`)
+  })
+
+  it('sends nl2sql backend payload shape', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${PREFIX}/nl2sql`,
+      replyCode: 200,
+      replyBody: { data: { sql: 'SELECT 1', explanation: 'ok' } },
+    })
+
+    await client.ai.nl2sql('count users', 'CREATE TABLE users (id uuid);', { dialect: 'postgres' })
+
+    expect(fetchMock.calls[0].body).toEqual({
+      question: 'count users',
+      schema: 'CREATE TABLE users (id uuid);',
+      dialect: 'postgres',
+    })
+  })
+})

package/packages/aurabase/tests/auth-admin.test.ts

@@ -0,0 +1,515 @@
+// ---------------------------------------------------------------------------
+// AuthAdminService tests
+// ---------------------------------------------------------------------------
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { AuraClient } from '../src/AuraClient'
+import { FetchMock, fakeUser } from './mocks'
+
+const BASE = 'http://localhost:8080'
+const PROJECT = 'test-project'
+const ADMIN_PREFIX = `${BASE}/v1/auth/${PROJECT}/admin`
+
+let fetchMock: FetchMock
+let client: AuraClient
+
+beforeEach(() => {
+  fetchMock = new FetchMock()
+  fetchMock.init()
+  client = new AuraClient(BASE, PROJECT, {
+    auth: { persistSession: false },
+  })
+})
+
+afterEach(() => {
+  fetchMock.restore()
+  fetchMock.clearMocks()
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.listUsers', () => {
+  it('sends GET /admin/users with query params', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: new RegExp(`${ADMIN_PREFIX}/users`),
+      replyCode: 200,
+      replyBody: { data: [fakeUser()] },
+    })
+
+    const res = await client.authAdmin.listUsers({ limit: 10, offset: 5, search: 'test' })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('GET')
+    expect(fetchMock.calls[0].url).toContain('limit=10')
+    expect(fetchMock.calls[0].url).toContain('offset=5')
+    expect(fetchMock.calls[0].url).toContain('search=test')
+  })
+
+  it('sends GET /admin/users without params', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/users`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+
+    const res = await client.authAdmin.listUsers()
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].url).toBe(`${ADMIN_PREFIX}/users`)
+  })
+
+  it('sends limit=0 and offset=0 explicitly (falsy-but-defined values must not be dropped)', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: new RegExp(`${ADMIN_PREFIX}/users`),
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+
+    const res = await client.authAdmin.listUsers({ limit: 0, offset: 0 })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].url).toContain('limit=0')
+    expect(fetchMock.calls[0].url).toContain('offset=0')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.getUser', () => {
+  it('sends GET /admin/users/{id}', async () => {
+    const user = fakeUser({ id: 'uid-42' })
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/users/uid-42`,
+      replyCode: 200,
+      replyBody: { data: user },
+    })
+
+    const res = await client.authAdmin.getUser('uid-42')
+
+    expect(res.error).toBeNull()
+    expect(res.data?.id).toBe('uid-42')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.createUser', () => {
+  it('sends POST /admin/users with body', async () => {
+    const user = fakeUser()
+    fetchMock.on({
+      method: 'POST',
+      url: `${ADMIN_PREFIX}/users`,
+      replyCode: 201,
+      replyBody: { data: user },
+    })
+
+    const res = await client.authAdmin.createUser({
+      email: 'new@example.com',
+      password: 'strongpass',
+    })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('POST')
+    expect((fetchMock.calls[0].body as any).email).toBe('new@example.com')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.updateUser', () => {
+  it('sends PUT /admin/users/{id} with body', async () => {
+    const user = fakeUser({ email: 'updated@example.com' })
+    fetchMock.on({
+      method: 'PUT',
+      url: `${ADMIN_PREFIX}/users/uid-42`,
+      replyCode: 200,
+      replyBody: { data: user },
+    })
+
+    const res = await client.authAdmin.updateUser('uid-42', { email: 'updated@example.com' })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('PUT')
+    expect((fetchMock.calls[0].body as any).email).toBe('updated@example.com')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.deleteUser', () => {
+  it('sends DELETE /admin/users/{id} and returns AuraResponse<null>', async () => {
+    fetchMock.on({
+      method: 'DELETE',
+      url: `${ADMIN_PREFIX}/users/uid-42`,
+      replyCode: 200,
+      replyBody: { data: null },
+    })
+
+    const res = await client.authAdmin.deleteUser('uid-42')
+
+    expect(res.error).toBeNull()
+    // LOT 3 (I5) : `deleteUser` backend (`services/aura-auth/src/handlers/admin.rs::
+    // delete_user_admin`) renvoie réellement `ApiResponse::<()>::empty()` (data null) —
+    // `fetch.ts` honore maintenant ce `null` explicite (`'data' in body`, pas
+    // `body.data ?? body`) au lieu de retomber sur l'enveloppe entière.
+    expect(res.data).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('DELETE')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.banUser', () => {
+  it('sends POST /admin/users/{id}/ban and returns AuraResponse<null>', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${ADMIN_PREFIX}/users/uid-42/ban`,
+      replyCode: 200,
+      replyBody: { data: null },
+    })
+
+    const res = await client.authAdmin.banUser('uid-42')
+
+    expect(res.error).toBeNull()
+    // LOT 3 (I5) : voir note deleteUser ci-dessus — `ban_user` backend renvoie aussi
+    // `ApiResponse::<()>::empty()`, honnêtement `null` côté SDK désormais.
+    expect(res.data).toBeNull()
+    expect(fetchMock.calls[0].url).toContain('/ban')
+    expect(fetchMock.calls[0].method).toBe('POST')
+    expect(fetchMock.calls[0].body).toEqual({})
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.unbanUser', () => {
+  it('sends POST /admin/users/{id}/unban and returns AuraResponse<null>', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${ADMIN_PREFIX}/users/uid-42/unban`,
+      replyCode: 200,
+      replyBody: { data: null },
+    })
+
+    const res = await client.authAdmin.unbanUser('uid-42')
+
+    expect(res.error).toBeNull()
+    // LOT 3 (I5) : voir note deleteUser ci-dessus.
+    expect(res.data).toBeNull()
+    expect(fetchMock.calls[0].url).toContain('/unban')
+    expect(fetchMock.calls[0].body).toEqual({})
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.generateLink', () => {
+  it('accepts the magic type and returns { link, token } (no redirect_to sent)', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${ADMIN_PREFIX}/users/uid-42/generate-link`,
+      replyCode: 200,
+      replyBody: { data: { link: 'https://example.com/verify?token=abc', token: 'abc' } },
+    })
+
+    const res = await client.authAdmin.generateLink('uid-42', 'magic')
+
+    expect(res.error).toBeNull()
+    expect(res.data).toEqual({ link: 'https://example.com/verify?token=abc', token: 'abc' })
+    expect((fetchMock.calls[0].body as any).type).toBe('magic')
+    expect((fetchMock.calls[0].body as any).redirect_to).toBeUndefined()
+  })
+
+  it('accepts the recovery and invite types', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${ADMIN_PREFIX}/users/uid-42/generate-link`,
+      replyCode: 200,
+      replyBody: { data: { link: 'https://example.com/recover', token: 'tok' } },
+    })
+
+    const res = await client.authAdmin.generateLink('uid-42', 'recovery')
+
+    expect(res.error).toBeNull()
+    expect((fetchMock.calls[0].body as any).type).toBe('recovery')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.getAuditLog', () => {
+  it('sends GET /admin/audit-log with pagination', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: new RegExp(`${ADMIN_PREFIX}/audit-log`),
+      replyCode: 200,
+      replyBody: { data: [{ id: 'evt-1', action: 'login' }] },
+    })
+
+    const res = await client.authAdmin.getAuditLog({ limit: 20, offset: 0 })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].url).toContain('limit=20')
+  })
+
+  it('sends GET /admin/audit-log with user_id filter', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: new RegExp(`${ADMIN_PREFIX}/audit-log`),
+      replyCode: 200,
+      replyBody: { data: [{ id: 'evt-1', user_id: 'uid-42', action: 'login' }] },
+    })
+
+    const res = await client.authAdmin.getAuditLog({ userId: 'uid-42' })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].url).toContain('user_id=uid-42')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.getUserStats', () => {
+  it('sends GET /admin/users/stats and returns the stats envelope', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/users/stats`,
+      replyCode: 200,
+      replyBody: { data: { total: 10, verified: 8, banned: 1, mfa_enabled: 3, new_7d: 2 } },
+    })
+
+    const res = await client.authAdmin.getUserStats()
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('GET')
+    expect(res.data).toEqual({ total: 10, verified: 8, banned: 1, mfa_enabled: 3, new_7d: 2 })
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.listSessions', () => {
+  it('sends GET /admin/sessions with limit/offset query params', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: new RegExp(`${ADMIN_PREFIX}/sessions`),
+      replyCode: 200,
+      replyBody: { data: [{ id: 'sess-1', user_id: 'uid-42' }] },
+    })
+
+    const res = await client.authAdmin.listSessions({ limit: 10, offset: 5 })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('GET')
+    expect(fetchMock.calls[0].url).toContain('limit=10')
+    expect(fetchMock.calls[0].url).toContain('offset=5')
+  })
+
+  it('sends GET /admin/sessions without query params', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/sessions`,
+      replyCode: 200,
+      replyBody: { data: [] },
+    })
+
+    const res = await client.authAdmin.listSessions()
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].url).toBe(`${ADMIN_PREFIX}/sessions`)
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.revokeSession', () => {
+  it('sends DELETE /admin/sessions/{id}', async () => {
+    fetchMock.on({
+      method: 'DELETE',
+      url: `${ADMIN_PREFIX}/sessions/sess-1`,
+      replyCode: 200,
+      replyBody: { data: null },
+    })
+
+    const res = await client.authAdmin.revokeSession('sess-1')
+
+    expect(res.error).toBeNull()
+    // LOT 3 (I5) : `revoke_session_admin` renvoie `ApiResponse::<()>::empty()`.
+    expect(res.data).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('DELETE')
+    expect(fetchMock.calls[0].url).toBe(`${ADMIN_PREFIX}/sessions/sess-1`)
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.listUserIdentities', () => {
+  it('sends GET /admin/users/{id}/identities', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/users/uid-42/identities`,
+      replyCode: 200,
+      replyBody: {
+        data: [
+          {
+            id: 'id-1',
+            provider: 'google',
+            provider_id: 'g-123',
+            identity_data: {},
+            auto_linked: false,
+            created_at: '2025-01-01T00:00:00Z',
+          },
+        ],
+      },
+    })
+
+    const res = await client.authAdmin.listUserIdentities('uid-42')
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('GET')
+    expect(res.data).toHaveLength(1)
+    expect((res.data as any)[0].provider).toBe('google')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.testEmailTemplate', () => {
+  it('sends POST /admin/email-templates/{type}/test with { to_email }', async () => {
+    fetchMock.on({
+      method: 'POST',
+      url: `${ADMIN_PREFIX}/email-templates/confirmation/test`,
+      replyCode: 200,
+      replyBody: { data: null },
+    })
+
+    const res = await client.authAdmin.testEmailTemplate('confirmation', {
+      to_email: 'dest@example.com',
+    })
+
+    expect(res.error).toBeNull()
+    // LOT 3 (I5) : `test_email_template` renvoie `ApiResponse::<()>::empty()`.
+    expect(res.data).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('POST')
+    expect(fetchMock.calls[0].url).toBe(`${ADMIN_PREFIX}/email-templates/confirmation/test`)
+    expect(fetchMock.calls[0].body).toEqual({ to_email: 'dest@example.com' })
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.updateUser (extended admin fields)', () => {
+  it('passes mfa_enabled and revoke_sessions through in the PUT body', async () => {
+    const user = fakeUser({ id: 'uid-42' })
+    fetchMock.on({
+      method: 'PUT',
+      url: `${ADMIN_PREFIX}/users/uid-42`,
+      replyCode: 200,
+      replyBody: { data: user },
+    })
+
+    const res = await client.authAdmin.updateUser('uid-42', {
+      mfa_enabled: false,
+      revoke_sessions: true,
+    })
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('PUT')
+    expect(fetchMock.calls[0].body).toEqual({ mfa_enabled: false, revoke_sessions: true })
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.getSettings', () => {
+  it('sends GET /admin/settings', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/settings`,
+      replyCode: 200,
+      replyBody: { data: { email_confirmation_required: true } },
+    })
+
+    const res = await client.authAdmin.getSettings()
+
+    expect(res.error).toBeNull()
+    expect((res.data as any).email_confirmation_required).toBe(true)
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.updateSettings', () => {
+  it('sends PUT /admin/settings with body', async () => {
+    fetchMock.on({
+      method: 'PUT',
+      url: `${ADMIN_PREFIX}/settings`,
+      replyCode: 200,
+      replyBody: { data: { email_confirmation_required: false } },
+    })
+
+    const res = await client.authAdmin.updateSettings({ email_confirmation_required: false } as any)
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('PUT')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.listEmailTemplates', () => {
+  it('sends GET /admin/email-templates', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/email-templates`,
+      replyCode: 200,
+      replyBody: { data: [{ type: 'confirmation' }, { type: 'recovery' }] },
+    })
+
+    const res = await client.authAdmin.listEmailTemplates()
+
+    expect(res.error).toBeNull()
+    expect(res.data).toHaveLength(2)
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.getEmailTemplate', () => {
+  it('sends GET /admin/email-templates/{type}', async () => {
+    fetchMock.on({
+      method: 'GET',
+      url: `${ADMIN_PREFIX}/email-templates/confirmation`,
+      replyCode: 200,
+      replyBody: { data: { type: 'confirmation', subject: 'Confirm' } },
+    })
+
+    const res = await client.authAdmin.getEmailTemplate('confirmation')
+
+    expect(res.error).toBeNull()
+    expect((res.data as any).type).toBe('confirmation')
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.updateEmailTemplate', () => {
+  it('sends PUT /admin/email-templates/{type} with { subject, html_body }', async () => {
+    fetchMock.on({
+      method: 'PUT',
+      url: `${ADMIN_PREFIX}/email-templates/confirmation`,
+      replyCode: 200,
+      replyBody: { data: { type: 'confirmation', subject: 'S' } },
+    })
+
+    await client.authAdmin.updateEmailTemplate('confirmation', {
+      subject: 'S',
+      html_body: '<p>x</p>',
+    })
+
+    expect(fetchMock.calls[0].method).toBe('PUT')
+    expect(fetchMock.calls[0].body).toEqual({ subject: 'S', html_body: '<p>x</p>' })
+    expect((fetchMock.calls[0].body as any).body).toBeUndefined()
+  })
+})
+
+// ---------------------------------------------------------------------------
+describe('AuthAdminService.deleteEmailTemplate', () => {
+  it('sends DELETE /admin/email-templates/{type}', async () => {
+    fetchMock.on({
+      method: 'DELETE',
+      url: `${ADMIN_PREFIX}/email-templates/confirmation`,
+      replyCode: 200,
+      replyBody: { data: { message: 'Reset to default' } },
+    })
+
+    const res = await client.authAdmin.deleteEmailTemplate('confirmation')
+
+    expect(res.error).toBeNull()
+    expect(fetchMock.calls[0].method).toBe('DELETE')
+  })
+})