@aurabase/aurabase-js 0.3.0 → 0.4.0

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

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

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

package/packages/gen/tsup.config.ts

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

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

@@ -1,134 +0,0 @@
-# @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).