@aurabase/aurabase-js 0.3.0 → 0.4.0

package/README.md

@@ -1,69 +1,29 @@
-# Aurabase JavaScript SDK
+# aurabase
 
-![npm](https://img.shields.io/npm/v/aurabase) ![license](https://img.shields.io/badge/license-MIT-blue) ![node](https://img.shields.io/badge/node-%3E%3D20-brightgreen) ![TypeScript](https://img.shields.io/badge/TypeScript-5-blue)
+Client JavaScript/TypeScript officiel d'Aurabase : point d'entrée principal du SDK, agrégeant les 8 packages de service (`@aurabase/*`) derrière `createClient`/`createAdminClient` et l'export `aurabase/ssr`.
 
-> **Pre-release — not yet published to npm.** Version numbers and badges above reflect the workspace version; there is no published `aurabase` package yet.
+![npm](https://img.shields.io/npm/v/aurabase) ![license](https://img.shields.io/badge/license-MIT-blue)
 
-Official JavaScript/TypeScript client for Aurabase.
-
-The package name is `aurabase`. It targets Node.js 20+ and browser runtimes with `fetch`, and it exports both ESM and CommonJS builds from `dist/`.
-
-## Structure (monorepo)
-
-Le SDK est un monorepo pnpm. Le package `aurabase` agrège tous les sous-packages et reste le point d'entrée principal (surface publique inchangée).
-
-| Package | Contenu |
-|---|---|
-| `aurabase` | `createClient`, `createAdminClient`, `AuraClient`, `./ssr` — point d'entrée principal |
-| `@aurabase/core` | fetch, erreurs, types, stores, `BaseService`, interface `AuraClientLike` |
-| `@aurabase/auth` | `AuthService`, `AuthAdminService` |
-| `@aurabase/db` | `DatabaseService`, `QueryBuilder` |
-| `@aurabase/storage` | `StorageService` |
-| `@aurabase/realtime` | `RealtimeService`, `AuraChannel`, `HeartbeatManager` |
-| `@aurabase/functions` | `FunctionsService` |
-| `@aurabase/ai` | `AiService` |
-| `@aurabase/notifications` | `NotificationsService`, `NotificationsAdminService` |
-| `@aurabase/gen` | CLI `aurabase-gen` — générateur de types `Database` (dev-dependency, non inclus dans `aurabase`) |
-
-Import principal (inchangé) :
-
-```ts
-import { createClient } from 'aurabase'
-```
-
-Import ciblé (tree-shaking / usage avancé) :
-
-```ts
-import { AuthService } from '@aurabase/auth'
-```
-
-Développement (workspace pnpm, à la racine `aurabase-js/`) :
-
-```bash
-pnpm install
-pnpm -r build      # build tous les packages (ordre topologique)
-pnpm -r typecheck
-pnpm -r test
-```
+> Pre-release — pas encore publié sur npm.
 
 ## Installation
 
 ```bash
-npm install aurabase
+npm i @aurabase/aurabase-js
 ```
 
-For local development inside this repository:
+## Rôle
 
-```bash
-cd aurabase-js
-npm install
-npm run build
-```
+Ce package ne réimplémente aucune logique de service : il compose `AuthService`, `DatabaseService`, `StorageService`, `RealtimeService`, `FunctionsService`, `AiService` et `NotificationsService` (chacun dans son propre package `@aurabase/*`) derrière un seul client.
+
+- `createClient(baseUrl, projectId, apiKey, options?)` — client applicatif standard.
+- `createAdminClient(baseUrl, projectId, serviceRoleKey, options?)` — client serveur avec `authAdmin` (clé `service_role`, jamais côté navigateur).
+- `aurabase/ssr` — `createServerClient`/`createBrowserClient` pour Next.js et frameworks SSR (cookies, session partagée serveur/navigateur).
 
 ## Quick Start
 
 ```ts
-import { createClient } from 'aurabase'
+import { createClient } from '@aurabase/aurabase-js'
 
 const aura = createClient(
   'http://localhost:8080',
@@ -83,751 +43,22 @@ if (error) {
 }
 ```
 
-## Client Creation
-
-```ts
-import { createClient } from 'aurabase'
-
-const aura = createClient(baseUrl, projectId, apiKey)
-```
-
-Arguments:
-
-- `baseUrl`: Aurabase gateway data-plane URL, for example `http://localhost:8080`.
-- `projectId`: project UUID or project identifier used by backend routes.
-- `apiKey`: project API key. Most data-plane operations require it.
-
-You can also pass options:
-
-```ts
-const aura = createClient('http://localhost:8080', projectId, apiKey, {
-  auth: { persistSession: true },
-  fetch: customFetch,
-})
-```
-
-Alternative form:
-
-```ts
-const aura = createClient('http://localhost:8080', projectId, {
-  apiKey,
-  auth: { persistSession: false },
-})
-```
-
-If no API key is provided, the SDK logs a warning. Public auth routes can still work, but most operations require the `apikey` header.
-
-## Response Shape
-
-All service methods return an `AuraResponse<T>`:
-
-```ts
-type AuraResponse<T> = {
-  data: T | null
-  error: {
-    code: string
-    message: string
-    details?: unknown
-  } | null
-  meta?: {
-    total?: number
-    next_cursor?: string
-  }
-}
-```
-
-Example:
-
-```ts
-const { data, error } = await aura.auth.getUser()
-
-if (error) {
-  throw new Error(error.message)
-}
-```
-
-Query builder calls can opt into throwing:
-
-```ts
-const { data: post } = await aura.db
-  .from('posts')
-  .eq('id', postId)
-  .single()
-  .throwOnError()
-```
-
-## Auth
-
-The auth service is available at `aura.auth`.
-
-### Email And Password
-
-```ts
-const signup = await aura.auth.signUp({
-  email: 'user@example.com',
-  password: 'correct horse battery staple',
-})
-
-const login = await aura.auth.signInWithPassword({
-  email: 'user@example.com',
-  password: 'correct horse battery staple',
-})
-
-await aura.auth.signOut()
-```
-
-Successful sign-up/sign-in responses save the access token, refresh token and user in the configured auth store.
-
-### Session
-
-```ts
-const session = await aura.auth.getSession()
-const refreshed = await aura.auth.refreshSession()
-
-const sessions = await aura.auth.listSessions()
-await aura.auth.revokeSession('session-id')
-await aura.auth.revokeAllSessions()
-```
-
-The SDK performs lazy token refresh before authenticated HTTP requests when the stored access token is near expiry and a refresh token exists.
-
-### Auth State
-
-```ts
-const subscription = aura.auth.onAuthStateChange(({ event, user }) => {
-  console.log(event, user?.email)
-})
-
-subscription.unsubscribe()
-```
-
-Events currently emitted by the SDK (`AuthChangePayload.event`):
-
-- `INITIAL_SESSION` (emitted once on subscribe, Supabase parity)
-- `SIGNED_IN`
-- `SIGNED_OUT`
-- `TOKEN_REFRESHED`
-- `USER_UPDATED`
-- `MFA_CHALLENGE`
-
-### User Profile
-
-```ts
-const user = await aura.auth.getUser()
-
-await aura.auth.updateUser({
-  email: 'new@example.com',
-  data: { display_name: 'Ada' },
-})
-
-await aura.auth.updatePassword('new-password', 'current-password')
-```
-
-### Magic Links, OTP And Anonymous Auth
-
-```ts
-await aura.auth.signInWithMagicLink({
-  email: 'user@example.com',
-  redirect_url: 'http://localhost:3000/auth/callback',
-})
-
-await aura.auth.signInWithEmailOtp('user@example.com')
-await aura.auth.verifyEmailOtp('user@example.com', '123456')
-
-await aura.auth.signInWithSmsOtp('+15551234567')
-await aura.auth.verifySmsOtp('+15551234567', '123456')
-
-await aura.auth.signInAnonymously()
-```
-
-### OAuth
-
-`signInWithOAuth` always returns `{ url }` in `data` (implicit flow by default), and additionally redirects the browser via `window.location.href` when a `window` is present.
-
-```ts
-const { data, error } = await aura.auth.signInWithOAuth('github', {
-  redirectTo: 'http://localhost:3000/auth/callback',
-  scopes: 'read:user user:email',
-  flowType: 'pkce', // opt-in; requires a persistent auth store (LocalAuthStore) in the browser
-})
-
-if (error) throw error
-
-// Server-side / SSR: no automatic redirect, redirect manually using data!.url
-console.log(data!.url)
-```
-
-Native/mobile ID token exchange:
-
-```ts
-await aura.auth.signInWithIdToken('google', idToken, accessToken)
-```
-
-### MFA
-
-```ts
-const enrollment = await aura.auth.mfaEnroll()
-
-await aura.auth.mfaVerifySetup('123456')
-
-await aura.auth.mfaVerify({
-  mfa_token: 'mfa-token-from-login-response',
-  code: '123456',
-})
-
-await aura.auth.regenerateRecoveryCodes('123456')
-await aura.auth.mfaUnenroll('current-password')
-```
-
-### Identity Linking
-
-```ts
-const identities = await aura.auth.listIdentities()
-const link = await aura.auth.linkIdentity('github')
-await aura.auth.unlinkIdentity('identity-id')
-```
-
-## Database
-
-The database service is available at `aura.db`.
-
-### Select
-
-```ts
-const posts = await aura.db
-  .from('posts')
-  .select('id,title,author_id')
-  .eq('published', true)
-  .order('created_at', 'desc')
-  .limit(20)
-```
-
-Supported filters:
-
-- `eq(column, value)`
-- `neq(column, value)`
-- `gt(column, value)`
-- `gte(column, value)`
-- `lt(column, value)`
-- `lte(column, value)`
-- `like(column, pattern)`
-- `ilike(column, pattern)`
-- `is(column, 'null' | 'not_null')`
-- `in(column, values)`
-- `or([{ column, op, value }])`
-
-Modifiers:
-
-- `select(columns)`
-- `order(column, 'asc' | 'desc')`
-- `limit(n)`
-- `offset(n)`
-- `count('exact' | 'estimated')`
-- `single()`
-- `throwOnError()`
-
-### Single Row
-
-```ts
-const post = await aura.db
-  .from('posts')
-  .eq('id', 'post-id')
-  .single()
-```
-
-### Insert, Update, Delete, Upsert
-
-```ts
-await aura.db.from('posts').insert({
-  title: 'Hello',
-  published: false,
-})
-
-await aura.db.from('posts').update('post-id', {
-  published: true,
-})
-
-await aura.db.from('posts').delete('post-id')
-
-await aura.db.from('posts').upsert(
-  { id: 'post-id', title: 'Updated' },
-  { onConflict: 'id' },
-)
-```
-
-### Raw SQL And Schema
-
-```ts
-const rows = await aura.db.sql('SELECT count(*) FROM posts')
-const schema = await aura.db.schema() // { tables, functions }
-```
-
-Raw SQL is sent to `POST /v1/db/{project_id}/raw` and is subject to backend validation and rate limiting.
-
-### RPC (Postgres Functions)
-
-```ts
-const { data: sum } = await aura.db.rpc('add', { a: 1, b: 2 })
-const { data: thing } = await aura.db.rpc('list_things', {}).eq('id', 2).select('id,name').single()
-const { data, meta } = await aura.db.rpc('list_things', {}, { count: 'exact' })
-```
-
-`options` accepts `{ count?: 'exact' | 'planned' | 'estimated'; head?: boolean; get?: boolean }`. Typed strictly when `Database['public']['Functions'][fn]` is known (see [Generated Database Types](#generated-database-types)); permissive otherwise. Postgres-only — see [`@aurabase/db` README](packages/db/README.md#fonctions-postgres-rpc) for the full reference.
-
-## Storage
-
-The storage service is available at `aura.storage`.
-
-### Buckets
-
-```ts
-const buckets = await aura.storage.listBuckets()
-
-await aura.storage.createBucket('avatars', {
-  public: true,
-  fileSizeLimit: 5 * 1024 * 1024,
-  allowedMimeTypes: ['image/png', 'image/jpeg'],
-})
-
-const bucket = await aura.storage.getBucket('avatars')
-await aura.storage.deleteBucket('avatars')
-```
-
-### Objects
-
-```ts
-await aura.storage.upload('avatars', 'users/1.png', file, {
-  contentType: 'image/png',
-  upsert: true,
-})
-
-const files = await aura.storage.list('avatars', {
-  prefix: 'users/',
-  limit: 100,
-})
-
-const blob = await aura.storage.download('avatars', 'users/1.png')
-
-await aura.storage.copy('avatars', 'users/1.png', 'archive/1.png')
-await aura.storage.move('avatars', 'archive/1.png', 'users/1.png')
-await aura.storage.remove('avatars', ['users/1.png'])
-
-const metadata = await aura.storage.getMetadata('avatars', 'users/1.png')
-```
-
-### URLs
-
-```ts
-const signed = await aura.storage.createSignedUrl('avatars', 'users/1.png', 600)
-const upload = await aura.storage.createSignedUploadUrl('avatars', 'users/1.png', 300)
-
-const publicUrl = aura.storage.getPublicUrl('avatars', 'users/1.png')
-```
-
-### Transformations d'image
-
-`getPublicUrl()`, `download()` et `createSignedUrl()` acceptent une option `{ transform: ImageTransform }` (`width`/`height`/`resize`/`quality`/`format`) pour un rendu à la volée côté backend (redimensionnement, recadrage, ré-encodage) :
-
-```ts
-const thumbnail = aura.storage.getPublicUrl('avatars', 'users/1.png', {
-  transform: { width: 200, resize: 'cover' },
-})
-```
-
-Détails (flag projet, borne 2500px, `quality` JPEG uniquement, cache serveur des dérivés) : [README `@aurabase/storage`](packages/storage/README.md#transformations-dimage).
-
-## Realtime
-
-The realtime service is available at `aura.realtime`, and `aura.channel(name)` is a shortcut for `aura.realtime.channel(name)`.
-
-```ts
-const unsubscribe = aura.realtime.onStateChange((state) => {
-  console.log('realtime state:', state)
-})
-
-aura.realtime.connect()
-```
-
-Connection states:
-
-- `disconnected`
-- `connecting`
-- `connected`
-- `reconnecting`
-
-An application-level heartbeat (`ping`) is sent every **25 seconds** via a dedicated Worker to avoid browser timer throttling in background tabs. Automatic reconnection uses exponential backoff with jitter.
-
-### Postgres Changes
-
-```ts
-const channel = aura.channel('db:public.posts')
-  .on(
-    'postgres_changes',
-    { event: 'INSERT', schema: 'public', table: 'posts' },
-    (payload) => {
-      console.log('insert:', payload)
-    },
-  )
-  .subscribe((status, error) => {
-    console.log(status, error)
-  })
-
-aura.realtime.connect()
-```
-
-An optional `filter` field (PostgREST/Supabase syntax, `"column=operator.value"`) restricts events to rows matching the condition, e.g. `filter: 'room_id=eq.42'`. Supported operators: `eq, neq, lt, lte, gt, gte, in, like, ilike, is, match, imatch, isdistinct`, negation via `not.` (`status=not.eq.done`), and AND via commas (`room_id=eq.42,qty=gt.5`, commas inside `in.(...)` don't split conditions). Filtering is server-authoritative with a client-side fail-closed fallback; `DELETE` events are matched against the old row. Full reference: [`@aurabase/realtime` README](packages/realtime/README.md#filtres-de-colonne-postgres_changes).
-
-### Broadcast
-
-```ts
-const channel = aura.realtime.channel('room-1', {
-  broadcast: { ack: true, self: true },
-})
-
-channel
-  .on('broadcast', { event: 'cursor-pos' }, (payload) => {
-    console.log(payload)
-  })
-  .subscribe()
-
-aura.realtime.connect()
-
-const status = await channel.send({
-  type: 'broadcast',
-  event: 'cursor-pos',
-  payload: { x: 100, y: 200 },
-})
-```
-
-`send()` resolves to `ok`, `timeout` or `error`.
-
-### Presence
-
-```ts
-const channel = aura.channel('room-1', {
-  config: { presence: { key: 'user-1' } },
-})
-
-channel
-  .on('presence', { event: 'sync' }, () => {
-    console.log(channel.presenceState())
-  })
-  .on('presence', { event: 'join' }, console.log)
-  .on('presence', { event: 'leave' }, console.log)
-  .subscribe()
-
-aura.realtime.connect()
-
-await channel.track({ online_at: new Date().toISOString() })
-await channel.untrack()
-```
-
-### Cleanup
-
-```ts
-aura.realtime.removeChannel('room-1')
-aura.realtime.removeAllChannels()
-aura.realtime.disconnect()
-unsubscribe()
-```
-
-## Functions
-
-The functions service is available at `aura.functions`.
-
-```ts
-const result = await aura.functions.invoke('hello', {
-  method: 'POST',
-  path: '/welcome',
-  headers: { 'x-request-source': 'sdk' },
-  body: { name: 'Ada' },
-})
-```
-
-Management helpers currently exposed by the SDK:
-
-```ts
-await aura.functions.list()
-await aura.functions.get('hello')
-
-await aura.functions.listJobs({ status: 'pending', limit: 10 })
-await aura.functions.getJob('job-id')
-
-await aura.functions.listCronJobs()
-await aura.functions.createCronJob('nightly', '0 0 * * * *', 'hello', {
-  payload: { ok: true },
-})
-await aura.functions.deleteCronJob('nightly')
-```
-
-## AI
-
-The AI service is available at `aura.ai`.
-
-```ts
-const chat = await aura.ai.chat([
-  { role: 'system', content: 'Answer briefly.' },
-  { role: 'user', content: 'What is Aurabase?' },
-], {
-  temperature: 0.2,
-})
-```
-
-Other methods:
-
-```ts
-await aura.ai.embed({
-  text: 'Aurabase is a BaaS platform.',
-  namespace: 'docs',
-  metadata: { source: 'readme' },
-})
-
-await aura.ai.semanticSearch('auth setup', 'docs', {
-  top_k: 5,
-  threshold: 0.7,
-})
-
-await aura.ai.ragIngest({
-  namespace: 'docs',
-  content: 'Aurabase uses a Rust gateway.',
-})
-
-await aura.ai.rag({
-  namespace: 'docs',
-  question: 'How does the gateway work?',
-})
-
-await aura.ai.nl2sql(
-  'How many users signed up today?',
-  'users(id uuid, created_at timestamptz)',
-)
-```
-
-## Notifications
+## Sous-packages
 
-The notifications service is available at `aura.notifications`.
-
-```ts
-await aura.notifications.send(
-  'email',
-  'user@example.com',
-  'Welcome to Aurabase',
-  {
-    subject: 'Welcome',
-    variables: { name: 'Ada' },
-  },
-)
-
-await aura.notifications.list({ limit: 20 })
-await aura.notifications.get('notification-id')
-```
-
-Templates:
-
-```ts
-await aura.notifications.listTemplates()
-await aura.notifications.getTemplate('template-id')
-
-await aura.notifications.createTemplate({
-  name: 'welcome',
-  channel: 'email',
-  subject: 'Welcome',
-  body: 'Hello {{ name }}',
-  variables: ['name'],
-})
-
-await aura.notifications.updateTemplate('template-id', {
-  subject: 'New subject',
-})
-
-await aura.notifications.deleteTemplate('template-id')
-```
-
-## SSR Helpers
-
-Import SSR helpers from `aurabase/ssr`.
-
-```ts
-import { createServerClient } from 'aurabase/ssr'
-
-const aura = createServerClient(baseUrl, projectId, {
-  apiKey,
-  cookies: {
-    getAll: () => request.cookies.getAll(),
-    setAll: (cookies) => {
-      for (const cookie of cookies) {
-        response.cookies.set(cookie.name, cookie.value, cookie.options)
-      }
-    },
-  },
-})
-```
-
-Browser helper:
-
-```ts
-import { createBrowserClient } from 'aurabase/ssr'
-
-const aura = createBrowserClient(baseUrl, projectId, apiKey)
-```
-
-Cookie utilities are also exported:
-
-```ts
-import { parseCookieHeader, serializeCookieHeader } from 'aurabase/ssr'
-```
-
-## Custom Auth Storage
-
-By default:
-
-- Browser runtime uses `LocalAuthStore` when `localStorage` exists.
-- Node/runtime without `localStorage` uses `BaseAuthStore`.
-- Passing `auth.persistSession: false` uses in-memory storage.
-- Passing `auth.storage` uses your provided `BaseAuthStore` implementation.
-
-```ts
-import { BaseAuthStore, createClient } from 'aurabase'
-
-const storage = new BaseAuthStore()
-
-const aura = createClient(baseUrl, projectId, apiKey, {
-  auth: { storage },
-})
-```
-
-## Advanced Admin Auth API
-
-`AuthAdminService` is exported for advanced usage, but it is not exposed as an `aura.auth.admin` shortcut in the current client.
-
-```ts
-import { AuthAdminService, createClient } from 'aurabase'
-
-const aura = createClient(baseUrl, projectId, apiKey)
-const authAdmin = new AuthAdminService(aura)
-
-await authAdmin.listUsers({ limit: 50 })
-await authAdmin.getSettings()
-```
-
-Available admin helpers include user CRUD, ban/unban, magic link generation, audit log, auth settings and email templates.
-
-## Headers And Authentication
-
-HTTP requests made through service helpers automatically inject:
-
-- `apikey: <apiKey>` when the client was created with an API key.
-- `Authorization: Bearer <access_token>` when the auth store has an access token.
-- `Content-Type: application/json` for JSON request bodies.
-
-Realtime WebSocket connections send auth through query params because browsers do not support custom WebSocket headers:
-
-- `?token=<access_token>`
-- `?apikey=<apiKey>`
-
-## Scripts
-
-```bash
-npm run build       # build ESM/CJS/types with tsup
-npm run typecheck   # run TypeScript without emitting files
-npm run test        # run Vitest once
-npm run test:watch  # run Vitest in watch mode
-```
-
-## Exports
-
-Root export:
-
-```ts
-import {
-  createClient,
-  AuraClient,
-  AuraError,
-  isAuraError,
-  BaseAuthStore,
-  LocalAuthStore,
-  QueryBuilder,
-} from 'aurabase'
-```
-
-Service classes and public types are also exported from the root package.
-
-SSR export:
-
-```ts
-import {
-  createServerClient,
-  createBrowserClient,
-  parseCookieHeader,
-  serializeCookieHeader,
-} from 'aurabase/ssr'
-```
-
-## Generated Database Types
-
-Database types are not hand-written: generate them from your project's live schema with the `@aurabase/gen` CLI, then pass them to `createClient<Database>` for typed `select()`/`insert()`/`update()`.
-
-```bash
-npm i -D @aurabase/gen
-
-npx aurabase-gen \
-  --url http://localhost:8080 \
-  --project my-project \
-  --key aura_anon_xxx \
-  --out database.types.ts \
-  --schema public \
-  --type-name Database
-```
-
-```ts
-import { createClient } from 'aurabase'
-import type { Database } from './database.types' // generated by @aurabase/gen
-
-const aura = createClient<Database>('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-// select()/insert()/update() are now inferred from the real columns of `posts`.
-const { data } = await aura.db.from('posts').select('id,title').eq('id', 'post-id').single()
-```
-
-`Functions` is now generated from the project's Postgres functions (used by `db.rpc()` for strict `args` typing and scalar return typing). Generated `SetofOptions.to` is a placeholder that never matches a real table — `@aurabase/gen` doesn't resolve which table a `SETOF` return actually targets — so a SETOF function's `.select()` falls back to `Record<string, unknown>[]`. Strict column-level typing of a SETOF return requires a hand-written `Database` type with `SetofOptions.to` pointing at a real table. `Views`, `Enums` and `CompositeTypes` are still always generated empty (`Record<string, never>`) — only `Tables` and `Functions` are introspected today. Full CLI reference and limitations: [`@aurabase/gen` README](packages/gen/README.md).
-
-## Current Limitations
-
-- `rpc()` is Postgres-only — not available on projects using MongoDB as the database engine (`aura.db.schema()` returns `functions: []` there).
-- No streaming responses (functions invocation and AI chat/RAG are request/response, not streamed).
-- No client-side query transforms/composition helpers beyond the `QueryBuilder` filters/modifiers listed above (parité postgrest-js partielle : pas de `range()`, `csv()`, `geojson()`, `explain()`, `abortSignal()`, `returns()`).
-- `AuthAdminService` is available via `client.authAdmin` (browser guard warns) or `createAdminClient()` (server-only, requires a `service_role` key).
-- Realtime requires a runtime with `WebSocket`.
-- File upload APIs require `FormData` and `Blob` support.
-- API behavior depends on the running Aurabase backend and project permissions.
-
-## Package Documentation
-
-Each package below has its own README with detailed usage, limitations and links back here:
-
-| Package | README |
+| Package | Contenu |
 |---|---|
-| `aurabase` (meta) | [packages/aurabase/README.md](packages/aurabase/README.md) |
-| `@aurabase/core` | [packages/core/README.md](packages/core/README.md) |
-| `@aurabase/auth` | [packages/auth/README.md](packages/auth/README.md) |
-| `@aurabase/db` | [packages/db/README.md](packages/db/README.md) |
-| `@aurabase/storage` | [packages/storage/README.md](packages/storage/README.md) |
-| `@aurabase/realtime` | [packages/realtime/README.md](packages/realtime/README.md) |
-| `@aurabase/functions` | [packages/functions/README.md](packages/functions/README.md) |
-| `@aurabase/ai` | [packages/ai/README.md](packages/ai/README.md) |
-| `@aurabase/notifications` | [packages/notifications/README.md](packages/notifications/README.md) |
-| `@aurabase/gen` | [packages/gen/README.md](packages/gen/README.md) |
+| [`@aurabase/core`](../core) | fetch, erreurs, types, stores, `BaseService`, interface `AuraClientLike` |
+| [`@aurabase/auth`](../auth) | `AuthService`, `AuthAdminService` |
+| [`@aurabase/db`](../db) | `DatabaseService`, `QueryBuilder` |
+| [`@aurabase/storage`](../storage) | `StorageService` |
+| [`@aurabase/realtime`](../realtime) | `RealtimeService`, `AuraChannel`, `HeartbeatManager` |
+| [`@aurabase/functions`](../functions) | `FunctionsService` |
+| [`@aurabase/ai`](../ai) | `AiService` |
+| [`@aurabase/notifications`](../notifications) | `NotificationsService`, `NotificationsAdminService` |
+| [`@aurabase/gen`](../gen) | générateur CLI de types `Database` (dev-dependency, non inclus dans `aurabase`) |
 
-## Releases & Versioning
-
-This monorepo uses [Changesets](https://github.com/changesets/changesets) to version and publish packages.
-
-```bash
-pnpm changeset          # describe the change (bump type + summary) — run per PR/feature
-pnpm changeset version  # consume changesets, bump package.json versions, update changelogs
-git add . && git commit -m "chore: version packages"
-```
+Tous ces packages (hors `@aurabase/gen`) sont des dépendances directes de `aurabase` : les installer séparément n'est utile que pour du tree-shaking ciblé ou pour composer votre propre client.
 
-Release history: [CHANGELOG.md](./CHANGELOG.md).
+## Documentation
 
-Note: `.changeset/config.json` currently has `"access": "restricted"` — switch it to `"public"` before the first npm publish (all `@aurabase/*` packages and `aurabase` are meant to be public, scoped packages).
+Cette page ne couvre que le rôle du package d'agrégation. Documentation de référence complète : voir le [README du dépôt](../../README.md).