@aurabase/aurabase-js 0.3.0 → 0.3.1

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

@@ -1,111 +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/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

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