@aurabase/aurabase-js 0.3.0

package/packages/gen/tests/generate.test.ts

@@ -0,0 +1,396 @@
+import { describe, it, expect } from 'vitest'
+import { generateDatabaseTypes } from '../src/generate'
+import type { SchemaTable, SchemaFunction } from '@aurabase/core'
+
+function col(name: string, col_type: unknown, extra: Partial<{ nullable: boolean; unique: boolean; default_val: string | null; references: { table: string; column: string } | null }> = {}) {
+  return { name, col_type: col_type as string, nullable: false, unique: false, default_val: null, references: null, ...extra }
+}
+function table(name: string, columns: ReturnType<typeof col>[], extra: Partial<SchemaTable> = {}): SchemaTable {
+  return { name, columns, indexes: [], rls_enabled: false, realtime_enabled: false, ...extra }
+}
+function fn(name: string, args: SchemaFunction['args'], returns: string, is_set_returning = false): SchemaFunction {
+  return { name, args, returns, is_set_returning }
+}
+
+describe('generateDatabaseTypes — Row', () => {
+  it('émet une propriété Row par colonne, nullable → | null', () => {
+    const out = generateDatabaseTypes([
+      table('users', [col('id', 'uuid'), col('email', 'text'), col('bio', 'text', { nullable: true })]),
+    ])
+    expect(out).toContain('users: {')
+    expect(out).toContain('id: string')
+    expect(out).toContain('email: string')
+    expect(out).toContain('bio: string | null')
+  })
+})
+
+describe('generateDatabaseTypes — mapping des types', () => {
+  it('mappe chaque type pg vers le bon type TS', () => {
+    const out = generateDatabaseTypes([
+      table('t', [
+        col('a_text', 'text'), col('a_uuid', 'uuid'), col('a_ts', 'timestamp'),
+        col('a_date', 'date'), col('a_time', 'time'), col('a_bytea', 'bytea'),
+        col('a_numeric', 'numeric'), col('a_int', 'int'), col('a_bigint', 'bigint'),
+        col('a_float', 'float'), col('a_bool', 'bool'), col('a_json', 'json'),
+        col('a_jsonb', 'jsonb'),
+        col('a_arr', { array: 'text' }), col('a_vec', { vector: 1536 }),
+      ]),
+    ])
+    expect(out).toContain('a_text: string')
+    expect(out).toContain('a_numeric: string') // NUMERIC = string (précision), jamais number
+    expect(out).toContain('a_int: number')
+    expect(out).toContain('a_bigint: number')
+    expect(out).toContain('a_float: number')
+    expect(out).toContain('a_bool: boolean')
+    expect(out).toContain('a_json: Json')
+    expect(out).toContain('a_jsonb: Json')
+    expect(out).toContain('a_arr: string[]') // C2 : array typé (plus `unknown[]`)
+    expect(out).toContain('a_vec: number[]')
+  })
+
+  it('C2 — arrays typés récursifs : {array:int} → number[], {array:{array:text}} → string[][]', () => {
+    const out = generateDatabaseTypes([
+      table('t', [
+        col('ints', { array: 'int' }),
+        col('nested', { array: { array: 'text' } }),
+        col('bools', { array: 'bool' }),
+      ]),
+    ])
+    expect(out).toContain('ints: number[]')
+    expect(out).toContain('nested: string[][]')
+    expect(out).toContain('bools: boolean[]')
+  })
+})
+
+describe('generateDatabaseTypes — Insert/Update', () => {
+  it('Insert : optionnel si nullable / default / colonne auto ; requis sinon', () => {
+    const out = generateDatabaseTypes([
+      table('posts', [
+        col('id', 'uuid', { default_val: 'gen_random_uuid()' }),
+        col('title', 'text'),                       // requis
+        col('subtitle', 'text', { nullable: true }), // optionnel (nullable)
+        col('views', 'int', { default_val: '0' }),    // optionnel (default)
+        col('created_at', 'timestamp'),               // optionnel (auto)
+      ]),
+    ])
+    const insert = out.slice(out.indexOf('Insert: {'), out.indexOf('Update: {'))
+    expect(insert).toContain('id?: string')
+    expect(insert).toContain('title: string')       // requis (pas de ?)
+    expect(insert).toContain('subtitle?: string | null')
+    expect(insert).toContain('views?: number')
+    expect(insert).toContain('created_at?: string')
+  })
+
+  it('Update : toutes les colonnes optionnelles', () => {
+    const out = generateDatabaseTypes([table('posts', [col('id', 'uuid'), col('title', 'text')])])
+    const update = out.slice(out.indexOf('Update: {'))
+    expect(update).toContain('id?: string')
+    expect(update).toContain('title?: string')
+  })
+})
+
+describe('generateDatabaseTypes — Relationships', () => {
+  it('table sans FK → Relationships: []', () => {
+    const out = generateDatabaseTypes([table('users', [col('id', 'uuid')])])
+    expect(out).toContain('Relationships: []')
+  })
+
+  it('FK → tuple avec foreignKeyName synthétisé, isOneToOne selon unique/PK', () => {
+    const out = generateDatabaseTypes([
+      table('posts', [
+        col('id', 'uuid'),
+        col('author_id', 'uuid', { references: { table: 'users', column: 'id' } }),
+        col('slug', 'text', { unique: true, references: { table: 'seo', column: 'slug' } }),
+      ], { primary_key: 'id' }),
+    ])
+    expect(out).toContain("foreignKeyName: 'posts_author_id_fkey'")
+    expect(out).toContain("columns: ['author_id']")
+    expect(out).toContain("referencedRelation: 'users'")
+    expect(out).toContain("referencedColumns: ['id']")
+    // author_id : ni unique ni PK → false
+    expect(out).toMatch(/author_id_fkey'[^}]*?isOneToOne: false/)
+    // slug : unique → true
+    expect(out).toMatch(/slug_fkey'[^}]*?isOneToOne: true/)
+  })
+
+  it('utilise references.constraint_name si présent', () => {
+    const out = generateDatabaseTypes([
+      table('posts', [col('author_id', 'uuid', { references: { table: 'users', column: 'id', constraint_name: 'fk_custom' } as unknown as { table: string; column: string } })]),
+    ])
+    expect(out).toContain("foreignKeyName: 'fk_custom'")
+  })
+
+  it('isOneToOne true via primary_key même sans unique', () => {
+    const out = generateDatabaseTypes([
+      table('profiles', [
+        col('id', 'uuid', { references: { table: 'users', column: 'id' } }),
+      ], { primary_key: 'id' }),
+    ])
+    expect(out).toMatch(/profiles_id_fkey'[^}]*?isOneToOne: true/)
+  })
+})
+
+describe('generateDatabaseTypes — Functions', () => {
+  it('aucune fonction → Functions: Record<string, never>', () => {
+    const out = generateDatabaseTypes([table('users', [col('id', 'uuid')])])
+    expect(out).toContain('Functions: Record<string, never>')
+  })
+
+  it('fonction scalaire (add(a int, b int) → int) : Args + Returns', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [fn('add', [
+        { name: 'a', data_type: 'int4', mode: 'IN' },
+        { name: 'b', data_type: 'int4', mode: 'IN' },
+      ], 'int4')],
+    })
+    expect(out).toContain('add: {')
+    const block = out.slice(out.indexOf('add: {'), out.indexOf('add: {') + 300)
+    expect(block).toMatch(/Args:\s*{\s*a: number;\s*b: number\s*}/)
+    expect(block).toContain('Returns: number')
+    expect(block).not.toContain('SetofOptions')
+  })
+
+  it('fonction sans argument → Args: Record<string, never>', () => {
+    const out = generateDatabaseTypes([], { functions: [fn('now_utc', [], 'timestamp')] })
+    const block = out.slice(out.indexOf('now_utc: {'))
+    expect(block).toContain('Args: Record<string, never>')
+  })
+
+  it('fonction SETOF (table-returning) : Returns tableau + SetofOptions', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [fn('list_things', [], 'record', true)],
+    })
+    const block = out.slice(out.indexOf('list_things: {'), out.indexOf('list_things: {') + 400)
+    expect(block).toContain('Returns: Record<string, unknown>[]')
+    expect(block).toContain('SetofOptions: {')
+    expect(block).toContain('isSetofReturn: true')
+    expect(block).toContain("to: 'list_things'")
+    expect(block).toContain("from: '*'")
+  })
+
+  it('GEN-M1 — overloads (même nom) fusionnés en UNE clé, Args/Returns en union', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [
+        fn('add', [{ name: 'a', data_type: 'int4', mode: 'IN' }, { name: 'b', data_type: 'int4', mode: 'IN' }], 'int4'),
+        fn('add', [{ name: 'a', data_type: 'text', mode: 'IN' }, { name: 'b', data_type: 'text', mode: 'IN' }], 'text'),
+      ],
+    })
+    // Une seule clé `add:` (pas de duplicate identifier TS2300).
+    expect(out.match(/add: {/g)).toHaveLength(1)
+    const block = out.slice(out.indexOf('add: {'), out.indexOf('add: {') + 300)
+    expect(block).toContain('Args: { a: number; b: number } | { a: string; b: string }')
+    expect(block).toContain('Returns: number | string')
+  })
+
+  it('GEN-M1 — overloads : membres identiques dédupliqués (Args unique)', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [
+        fn('f', [{ name: 'x', data_type: 'int4', mode: 'IN' }], 'int4'),
+        fn('f', [{ name: 'x', data_type: 'int4', mode: 'IN' }], 'text'), // même Args, Returns diff
+      ],
+    })
+    const block = out.slice(out.indexOf('f: {'), out.indexOf('f: {') + 200)
+    expect(block).toContain('Args: { x: number }') // pas `| { x: number }` dupliqué
+    expect(block).toContain('Returns: number | string')
+  })
+
+  it('sortie valide TypeScript (satisfait GenericSchema[\'Functions\'])', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [
+        fn('add', [{ name: 'a', data_type: 'int4', mode: 'IN' }, { name: 'b', data_type: 'int4', mode: 'IN' }], 'int4'),
+        fn('list_things', [], 'record', true),
+      ],
+    })
+    expect(out).toContain('export interface Database {')
+  })
+})
+
+describe('generateDatabaseTypes — SETOF <table> : SetofOptions.to résolu (P4)', () => {
+  it('RETURNS SETOF users → to: "users" (table connue)', () => {
+    const out = generateDatabaseTypes(
+      [table('users', [col('id', 'uuid'), col('email', 'text')])],
+      { functions: [fn('list_users', [], 'users', true)] },
+    )
+    const block = out.slice(out.indexOf('list_users: {'), out.indexOf('list_users: {') + 400)
+    expect(block).toContain('SetofOptions: {')
+    expect(block).toContain('isSetofReturn: true')
+    expect(block).toContain("to: 'users'")
+    expect(block).toContain("from: '*'")
+  })
+
+  it('RETURNS SETOF v_active (vue) → to: "v_active"', () => {
+    const out = generateDatabaseTypes([], {
+      views: [table('v_active', [col('id', 'uuid')])],
+      functions: [fn('active_rows', [], 'v_active', true)],
+    })
+    const block = out.slice(out.indexOf('active_rows: {'), out.indexOf('active_rows: {') + 400)
+    expect(block).toContain("to: 'v_active'")
+  })
+
+  it('RETURNS record → placeholder to: "<nom_fonction>" (aucune relation)', () => {
+    const out = generateDatabaseTypes([], { functions: [fn('list_things', [], 'record', true)] })
+    const block = out.slice(out.indexOf('list_things: {'), out.indexOf('list_things: {') + 400)
+    expect(block).toContain("to: 'list_things'")
+    expect(block).toContain('Returns: Record<string, unknown>[]')
+  })
+
+  it('returns matche un nom hors relations (type non-relation) → placeholder', () => {
+    // `mytype` n'est ni une table ni une vue fournie → repli sur le nom de la fonction.
+    const out = generateDatabaseTypes(
+      [table('users', [col('id', 'uuid')])],
+      { functions: [fn('weird', [], 'mytype', true)] },
+    )
+    const block = out.slice(out.indexOf('weird: {'), out.indexOf('weird: {') + 400)
+    expect(block).toContain("to: 'weird'")
+  })
+
+  it('fonction scalaire → pas de SetofOptions (inchangé)', () => {
+    const out = generateDatabaseTypes(
+      [table('users', [col('id', 'uuid')])],
+      { functions: [fn('count_users', [], 'int4', false)] },
+    )
+    const block = out.slice(out.indexOf('count_users: {'), out.indexOf('count_users: {') + 200)
+    expect(block).not.toContain('SetofOptions')
+  })
+
+  it('overloads set-returning même nom → SetofOptions omis (cible ambiguë)', () => {
+    const out = generateDatabaseTypes(
+      [table('users', [col('id', 'uuid')])],
+      {
+        functions: [
+          fn('search', [{ name: 'q', data_type: 'text', mode: 'IN' }], 'users', true),
+          fn('search', [{ name: 'q', data_type: 'int4', mode: 'IN' }], 'users', true),
+        ],
+      },
+    )
+    const block = out.slice(out.indexOf('search: {'), out.indexOf('search: {') + 400)
+    expect(block).not.toContain('SetofOptions')
+  })
+})
+
+describe('generateDatabaseTypes — FK composites (C3)', () => {
+  it('groupe 2 colonnes de même constraint_name → UNE relationship multi-colonnes', () => {
+    const out = generateDatabaseTypes([
+      table('order_items', [
+        col('order_tenant', 'uuid', { references: { table: 'orders', column: 'tenant', constraint_name: 'fk_order' } as unknown as { table: string; column: string } }),
+        col('order_id', 'uuid', { references: { table: 'orders', column: 'id', constraint_name: 'fk_order' } as unknown as { table: string; column: string } }),
+      ]),
+    ])
+    expect(out).toContain("foreignKeyName: 'fk_order'")
+    expect(out).toContain("columns: ['order_tenant', 'order_id']")
+    expect(out).toContain("referencedColumns: ['tenant', 'id']")
+    // Une seule entrée : la relationship n'apparaît qu'une fois.
+    expect(out.match(/foreignKeyName: 'fk_order'/g)).toHaveLength(1)
+  })
+
+  it("n'agrège PAS deux FK anonymes (constraint_name absent) — 2 entrées distinctes", () => {
+    const out = generateDatabaseTypes([
+      table('t', [
+        col('a_id', 'uuid', { references: { table: 'a', column: 'id' } }),
+        col('b_id', 'uuid', { references: { table: 'b', column: 'id' } }),
+      ]),
+    ])
+    expect(out).toContain("columns: ['a_id']")
+    expect(out).toContain("columns: ['b_id']")
+    expect(out).toContain("foreignKeyName: 't_a_id_fkey'")
+    expect(out).toContain("foreignKeyName: 't_b_id_fkey'")
+  })
+})
+
+describe('generateDatabaseTypes — Enums (C5)', () => {
+  it('émet le bloc Enums:{mood: union} et type les colonnes {enum}', () => {
+    const out = generateDatabaseTypes(
+      [table('users', [col('id', 'uuid'), col('mood', { enum: 'mood' })])],
+      { enums: [{ name: 'mood', values: ['happy', 'sad', 'ok'] }] },
+    )
+    expect(out).toMatch(/Enums: {\s*mood: 'happy' \| 'sad' \| 'ok'/)
+    // La colonne enum référence le bloc Enums (auto-référence Supabase).
+    expect(out).toContain("mood: Database['public']['Enums']['mood']")
+  })
+
+  it("enum inconnu du bloc → repli string (compile-safe)", () => {
+    const out = generateDatabaseTypes([table('t', [col('x', { enum: 'unlisted' })])])
+    expect(out).toContain('x: string')
+  })
+
+  it('array d’enum : {array:{enum:mood}} → Enums[mood][]', () => {
+    const out = generateDatabaseTypes(
+      [table('t', [col('moods', { array: { enum: 'mood' } })])],
+      { enums: [{ name: 'mood', values: ['a', 'b'] }] },
+    )
+    expect(out).toContain("moods: Database['public']['Enums']['mood'][]")
+  })
+})
+
+describe('generateDatabaseTypes — Views (C6)', () => {
+  it('émet Views:{v:{Row}} (Row seul, Relationships:[])', () => {
+    const out = generateDatabaseTypes([], {
+      views: [table('v_active_users', [col('id', 'uuid'), col('email', 'text', { nullable: true })])],
+    })
+    const block = out.slice(out.indexOf('Views: '))
+    expect(block).toContain('v_active_users: {')
+    expect(block).toContain('Row: {')
+    expect(block).toContain('id: string')
+    expect(block).toContain('email: string | null')
+    expect(block).toContain('Relationships: []')
+    // Pas d'Insert/Update pour une vue.
+    const viewBlock = out.slice(out.indexOf('v_active_users: {'), out.indexOf('Functions:'))
+    expect(viewBlock).not.toContain('Insert:')
+    expect(viewBlock).not.toContain('Update:')
+  })
+})
+
+describe('generateDatabaseTypes — Functions : mapping udt_name bruts (C4)', () => {
+  it('array udt (_text) → string[], _int4 → number[] (PAS unknown)', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [fn('tags_of', [{ name: 'ids', data_type: '_int4', mode: 'IN' }], '_text')],
+    })
+    const block = out.slice(out.indexOf('tags_of: {'), out.indexOf('tags_of: {') + 300)
+    expect(block).toContain('ids: number[]')
+    expect(block).toContain('Returns: string[]')
+    expect(block).not.toContain('unknown')
+  })
+
+  it('numeric → string (H5), timestamptz → string, bool → boolean', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [fn('calc', [
+        { name: 'amount', data_type: 'numeric', mode: 'IN' },
+        { name: 'flag', data_type: 'bool', mode: 'IN' },
+        { name: 'ts', data_type: 'timestamptz', mode: 'IN' },
+      ], 'numeric')],
+    })
+    const block = out.slice(out.indexOf('calc: {'), out.indexOf('calc: {') + 300)
+    expect(block).toContain('amount: string')
+    expect(block).toContain('flag: boolean')
+    expect(block).toContain('ts: string')
+    expect(block).toContain('Returns: string')
+  })
+
+  it('argument/retour de type enum → référence le bloc Enums', () => {
+    const out = generateDatabaseTypes([], {
+      functions: [fn('set_mood', [{ name: 'm', data_type: 'mood', mode: 'IN' }], 'mood')],
+      enums: [{ name: 'mood', values: ['a', 'b'] }],
+    })
+    const block = out.slice(out.indexOf('set_mood: {'), out.indexOf('set_mood: {') + 300)
+    expect(block).toContain("m: Database['public']['Enums']['mood']")
+    expect(block).toContain("Returns: Database['public']['Enums']['mood']")
+  })
+})
+
+describe('generateDatabaseTypes — assemblage complet', () => {
+  it('émet Json, les blocs vides, l’en-tête, et respecte les options', () => {
+    const out = generateDatabaseTypes([table('users', [col('id', 'uuid')])], { typeName: 'DB', schemaName: 'public' })
+    expect(out).toContain('export type Json =')
+    expect(out).toContain('export interface DB {')
+    expect(out).toContain('Views: Record<string, never>')
+    expect(out).toContain('Functions: Record<string, never>')
+    expect(out).toContain('Enums: Record<string, never>')
+    expect(out).toContain('CompositeTypes: Record<string, never>')
+    expect(out).toContain('auto-généré')
+  })
+
+  it('schéma vide → Tables: Record<string, never>', () => {
+    const out = generateDatabaseTypes([])
+    expect(out).toContain('Tables: Record<string, never>')
+  })
+})

package/packages/gen/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": { "outDir": "dist", "rootDir": "src", "types": ["node", "vitest/globals"] },
+  "include": ["src"]
+}

package/packages/gen/tsup.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'tsup'
+
+export default defineConfig({
+  entry: ['src/index.ts', 'src/cli.ts'],
+  format: ['cjs', 'esm'],
+  dts: true,
+  splitting: false,
+  clean: true,
+  treeshake: true,
+  minify: false,
+})

package/packages/notifications/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aurabase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/packages/notifications/README.md

@@ -0,0 +1,134 @@
+# @aurabase/notifications
+
+Service de notifications multi-canal du SDK Aurabase : email, SMS, push et webhook derrière une API unique, avec templates, règles déclenchées par événement et administration complète (`aura.notifications.admin`).
+
+![npm](https://img.shields.io/npm/v/@aurabase/notifications) ![license](https://img.shields.io/badge/license-MIT-blue)
+
+> Pre-release — pas encore publié sur npm.
+
+Fait partie du SDK **[aurabase](../aurabase)**. Installé automatiquement avec `aurabase` ; ce package est publié séparément pour un usage ciblé / tree-shaking.
+
+Le multi-canal unifié (un seul `send()` pour email/SMS/push/webhook, avec dead-letter, retries et règles) est un **différenciateur** face à des solutions push-only (FCM) ou tiers payantes (OneSignal).
+
+## Installation
+
+```bash
+npm i @aurabase/notifications
+```
+
+> Ce package dépend de `@aurabase/core` (`workspace:*` en interne, résolu en semver côté npm). Si vous utilisez déjà le package `aurabase`, `@aurabase/notifications` est déjà inclus — cette installation ciblée n'est utile que pour composer votre propre client ou limiter la taille du bundle.
+
+## Usage
+
+Dans l'usage courant, `NotificationsService` n'est jamais instancié directement : il est exposé par le client principal sous `aura.notifications` (et son admin sous `aura.notifications.admin`).
+
+```ts
+import { createClient } from 'aurabase'
+
+const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
+```
+
+### Envoi
+
+Canaux disponibles : `'email' | 'sms' | 'push' | 'webhook'`.
+
+```ts
+const { data, error } = await aura.notifications.send(
+  'email',
+  'user@example.com',
+  'Votre commande a été expédiée.',
+  { subject: 'Expédition', variables: { order_id: '1234' }, idempotencyKey: 'order-1234-shipped' },
+)
+
+if (error) throw error
+console.log(data!.status)
+```
+
+### Envoi en lot
+
+```ts
+const { data: batch } = await aura.notifications.sendBatch([
+  { channel: 'email', recipient: 'a@example.com', body: 'Bonjour A' },
+  { channel: 'sms', recipient: '+15551234567', body: 'Bonjour B' },
+])
+
+for (const item of batch!.items) {
+  console.log(item.status, item.notification?.id)
+}
+```
+
+### Historique et templates
+
+```ts
+const { data: sent } = await aura.notifications.list({
+  channel: 'email',
+  status: 'delivered',
+  sort: 'created_at',
+  order: 'desc',
+  limit: 20,
+})
+
+const notificationId = sent![0]!.id
+const { data: notif } = await aura.notifications.get(notificationId)
+
+const { data: template } = await aura.notifications.createTemplate({
+  name: 'order-shipped',
+  channel: 'email',
+  subject: 'Expédition {{order_id}}',
+  body: 'Votre commande {{order_id}} est en route.',
+  variables: ['order_id'],
+})
+
+await aura.notifications.updateTemplate(template!.id, { body: 'Mise à jour : {{order_id}} expédiée.' })
+```
+
+### Administration (`aura.notifications.admin`)
+
+```ts
+const { data: settings } = await aura.notifications.admin.getSettings()
+await aura.notifications.admin.updateSettings({ quotas: { daily_email: 10000 } })
+
+const { data: stats } = await aura.notifications.admin.getStats({ window: '24h', channel: 'email' })
+const { data: queue } = await aura.notifications.admin.getQueue()
+
+const failedId = 'notification-id'
+const { data: attempts } = await aura.notifications.admin.listAttempts(failedId)
+
+const { data: deadLetters } = await aura.notifications.admin.listDeadLetters({ channel: 'email', limit: 50 })
+await aura.notifications.admin.retryDeadLetter(deadLetters![0]!.id)
+
+const { data: events } = await aura.notifications.admin.listEvents({ status: 'failed' })
+const { data: logs } = await aura.notifications.admin.listProviderLogs({ channel: 'sms' })
+
+const templateId = 'template-id'
+const { data: preview } = await aura.notifications.admin.previewTemplate(templateId, { order_id: '1234' })
+console.log(preview!.subject, preview!.body)
+```
+
+### Règles déclenchées par événement
+
+```ts
+const { data: rule } = await aura.notifications.admin.createRule({
+  name: 'welcome-email',
+  trigger_type: 'user.created',
+  channel: 'email',
+  recipient_expr: 'user.email',
+  template_id: 'welcome-template-id',
+  delay_seconds: 0,
+})
+
+const { data: rules } = await aura.notifications.admin.listRules()
+await aura.notifications.admin.updateRule(rule!.id, { enabled: false })
+await aura.notifications.admin.deleteRule(rule!.id)
+```
+
+## Limitations
+
+- Pas de gestion d'audience/segments/devices : `recipient` est une chaîne brute (email, numéro, endpoint webhook, device token) — pas d'abstraction "device" ou "utilisateur" côté SDK.
+- Pas de scheduling explicite d'un envoi (« envoyer à telle date ») en dehors du `delay_seconds` des règles déclenchées.
+- Payloads génériques : `body` est une chaîne libre associée à des `variables` (interpolation côté backend), pas un objet structuré par canal (pas de builder push spécifique avec badge/son/icône, par exemple).
+- Pas d'API de désabonnement/préférences par canal exposée par le SDK.
+
+## Documentation
+
+Référence complète du SDK (tous les services, types partagés, SSR) : [README racine](../../README.md).