@aurabase/aurabase-js 0.3.0 → 0.3.1

package/packages/aurabase/tests/types/docs-snippets.test-d.ts

@@ -1,571 +0,0 @@
-// ---------------------------------------------------------------------------
-// Compile-check des snippets README — Task 6 (chantier H, DX).
-//
-// Ce fichier ne s'EXÉCUTE jamais (aucun test vitest ici, uniquement des
-// fonctions `async function _x() {}` jamais appelées) : il est ramassé par
-// `tsconfig.test-d.json` (include: `tests/**/*.test-d.ts`) et compilé par
-// `pnpm test:types` (`tsc --noEmit`). Le but est de reproduire fidèlement les
-// PRINCIPAUX snippets documentés dans les README des 7 packages de service
-// (auth, db, storage, realtime, functions, ai, notifications) pour qu'une
-// dérive doc ↔ code réel (renommage de méthode, signature changée, type de
-// retour modifié) casse la compilation ici plutôt que d'atteindre un
-// utilisateur qui copie-colle la doc. `@aurabase/core` et `@aurabase/gen`
-// (infrastructure / outil CLI, pas des services `aura.*`) sont hors périmètre
-// de ce fichier — leurs snippets ne s'expriment pas via `aura.<service>.*`.
-//
-// Règle (cf. brief Task 6) : un snippet qui ne compile pas est un bug de
-// README à corriger dans le README source — ne JAMAIS assouplir le snippet
-// ici pour le faire passer artificiellement.
-// ---------------------------------------------------------------------------
-
-import { createClient, createAdminClient } from '../../src/index'
-import type { AuthChangePayload } from '../../src/index'
-// `ImageTransform` n'est pas ré-exporté par le package `aurabase` (surface publique
-// actuelle) — importé directement depuis `@aurabase/core` (dépendance directe du
-// package `aurabase`) uniquement pour typer ce snippet de compile-check, cf. README
-// storage § "Transformations d'image".
-import type { ImageTransform } from '@aurabase/core'
-
-// Fixture `Database` minimale, cohérente avec la sortie de `@aurabase/gen`
-// (Row/Insert/Update/Relationships + Views/Functions/Enums/CompositeTypes
-// vides) — cf. packages/db/tests/types/fixtures.ts et
-// packages/aurabase/tests/types/client-generic.test-d.ts.
-//
-// `posts` porte une vraie FK vers `authors` (Relationships non vide, même
-// forme que packages/db/tests/types/fixtures.ts : foreignKeyName / columns /
-// isOneToOne / referencedRelation / referencedColumns) pour que le parser
-// vendoré (packages/db/src/select-query-parser) puisse réellement résoudre
-// l'embed many-to-one `author:authors(*)` prouvé dans `_dbSnippets` ci-dessous
-// — cf. select-inference.test-d.ts (`author:users(email)`) pour la forme
-// exacte d'un embed aliasé qui compile.
-type Database = {
-  public: {
-    Tables: {
-      posts: {
-        Row: {
-          id: string
-          title: string
-          published: boolean
-          author_id: string
-          created_at: string
-        }
-        Insert: {
-          id?: string
-          title: string
-          published?: boolean
-          author_id: string
-          created_at?: string
-        }
-        Update: {
-          id?: string
-          title?: string
-          published?: boolean
-          author_id?: string
-          created_at?: string
-        }
-        Relationships: [
-          {
-            foreignKeyName: 'posts_author_id_fkey'
-            columns: ['author_id']
-            isOneToOne: false
-            referencedRelation: 'authors'
-            referencedColumns: ['id']
-          },
-        ]
-      }
-      authors: {
-        Row: { id: string; name: string }
-        Insert: { id?: string; name: string }
-        Update: { id?: string; name?: string }
-        Relationships: []
-      }
-    }
-    Views: Record<string, never>
-    // `add` (scalaire) et `list_things` (SETOF lié à `authors` via SetofOptions.to)
-    // — parité avec la sortie réelle de `@aurabase/gen` (Task B5) et avec
-    // packages/db/tests/types/rpc.test-d.ts (même fixture Functions).
-    Functions: {
-      add: { Args: { a: number; b: number }; Returns: number }
-      list_things: {
-        Args: Record<string, never>
-        Returns: { id: string; name: string }[]
-        SetofOptions: { isSetofReturn: true; isOneToOne: false; to: 'authors'; from: '*' }
-      }
-    }
-    Enums: Record<string, never>
-    CompositeTypes: Record<string, never>
-  }
-}
-
-// -- auth (packages/auth/README.md) ------------------------------------------
-
-async function _authSnippets() {
-  const aura = createClient<Database>('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  // Mot de passe (§ "Mot de passe")
-  await aura.auth.signUp({ email: 'user@example.com', password: 'correct horse battery staple' })
-  await aura.auth.signInWithPassword({ email: 'user@example.com', password: 'correct horse battery staple' })
-  await aura.auth.signOut()
-
-  // Session (§ "Session")
-  const { accessToken, user } = await aura.auth.getSession()
-  void accessToken
-  void user
-  await aura.auth.refreshSession()
-  await aura.auth.setSession('stored-access-token', 'stored-refresh-token')
-  const sessions = await aura.auth.listSessions()
-  await aura.auth.revokeSession(sessions.data![0]!.id)
-  await aura.auth.revokeAllSessions()
-
-  // OAuth PKCE (§ "OAuth (implicite ou PKCE)") — renvoie toujours { url }.
-  const { data, error } = await aura.auth.signInWithOAuth('github', {
-    redirectTo: 'http://localhost:3000/auth/callback',
-    scopes: 'read:user user:email',
-    flowType: 'pkce',
-  })
-  if (error) throw error
-  const url: string = data!.url
-  void url
-
-  await aura.auth.exchangeCodeForSession('auth-code-from-callback')
-  await aura.auth.signInWithIdToken('google', 'id-token-from-provider')
-
-  // Magic link / OTP
-  await aura.auth.signInWithMagicLink({ email: 'user@example.com', redirect_url: 'http://localhost:3000/auth/callback' })
-  await aura.auth.verifyMagicLink('token-from-link')
-  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')
-
-  // Anonyme
-  await aura.auth.signInAnonymously()
-  await aura.auth.promoteAnonymous({ email: 'user@example.com', password: 'correct horse battery staple' })
-
-  // Utilisateur, claims, mot de passe
-  await aura.auth.getUser()
-  await aura.auth.getClaims()
-  await aura.auth.updateUser({ data: { display_name: 'Ada' } })
-  await aura.auth.updatePassword('new-password', 'current-password')
-  await aura.auth.deleteUser('current-password')
-
-  // Réinitialisation / vérification email
-  await aura.auth.resetPasswordForEmail({ email: 'user@example.com' })
-  await aura.auth.resetPassword('token-from-email', 'new-password')
-  await aura.auth.verifyEmail('token-from-email')
-  await aura.auth.resendVerificationEmail()
-  await aura.auth.confirmEmailChange('token-from-email')
-
-  // MFA (TOTP)
-  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')
-
-  // Configuration publique
-  await aura.auth.getSettings()
-  await aura.auth.getAnonKey()
-
-  // État d'authentification — événements documentés (AuthEvent réel).
-  const subscription = aura.auth.onAuthStateChange(
-    ({ event, user, accessToken }: AuthChangePayload) => {
-      const e: 'INITIAL_SESSION' | 'SIGNED_IN' | 'SIGNED_OUT' | 'TOKEN_REFRESHED' | 'USER_UPDATED' | 'MFA_CHALLENGE' | 'PASSWORD_RECOVERY' = event
-      void e
-      void user
-      void accessToken
-    },
-  )
-  subscription.unsubscribe()
-  aura.dispose()
-
-  // Administration (AuthAdminService) — via createAdminClient.
-  const admin = createAdminClient<Database>('http://localhost:8080', 'my-project', 'aura_service_role_xxx')
-  await admin.authAdmin.listUsers({ limit: 50 })
-}
-
-// -- db typé (packages/db/README.md) -----------------------------------------
-
-async function _dbSnippets() {
-  const aura = createClient<Database>('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  // Select, filtres, embeds, order/limit.
-  await aura.db
-    .from('posts')
-    .select('id,title,author_id')
-    .eq('published', true)
-    .order('id', 'desc')
-    .limit(10)
-
-  // Embed relationnel (§ "Select, filtres, embeds") — `posts.author_id` est
-  // NOT NULL dans la Row, donc l'embed many-to-one `author` est un objet non
-  // nullable (pas `| null`) : preuve que le README db (`author:authors(*)`)
-  // compile réellement contre le parser vendoré, pas seulement contre une
-  // fixture sans relation.
-  const { data: withAuthor } = await aura.db
-    .from('posts')
-    .select('id,title,author:authors(*)')
-    .eq('published', true)
-    .order('created_at', 'desc')
-    .limit(10)
-  const firstPostAuthorName: string | undefined = withAuthor?.[0]?.author.name
-  void firstPostAuthorName
-
-  await aura.db
-    .from('posts')
-    .or([
-      { column: 'published', op: 'eq', value: true },
-      { column: 'author_id', op: 'eq', value: 'user-id' },
-    ])
-    .textSearch('title', 'aurabase', { type: 'websearch' })
-
-  // single()/maybeSingle()/cursor().
-  const postId = 'post-id'
-  await aura.db.from('posts').eq('id', postId).single()
-  await aura.db.from('posts').eq('id', postId).maybeSingle()
-  const firstPage = await aura.db.from('posts').order('id').limit(20)
-  await aura.db.from('posts').order('id').cursor(firstPage.meta?.next_cursor ?? '')
-
-  // Mutations — update()/delete() ciblent par id (pas de .eq()).
-  await aura.db.from('posts').insert({ title: 'Hello', published: false, author_id: 'a' })
-  await aura.db.from('posts').insert([
-    { title: 'A', author_id: 'a' },
-    { title: 'B', author_id: 'a' },
-  ])
-  await aura.db.from('posts').update(postId, { published: true })
-  await aura.db.from('posts').delete(postId)
-  await aura.db.from('posts').upsert({ id: postId, title: 'Updated', author_id: 'a' }, { onConflict: 'id' })
-
-  // SQL brut et schéma.
-  await aura.db.sql('SELECT count(*) FROM posts WHERE published = $1', [true])
-  await aura.db.schema()
-
-  // rpc() — § "Fonctions Postgres (rpc)" (packages/db/README.md).
-  // Appel scalaire (POST par défaut, args typés strictement sur Functions.add).
-  const { data: sum } = await aura.db.rpc('add', { a: 1, b: 2 })
-  void sum
-
-  // Fonction SETOF filtrée (Row inféré de SetofOptions.to = 'authors').
-  const { data: thing } = await aura.db.rpc('list_things', {}).eq('id', 'author-1').select('id,name').single()
-  void thing
-
-  // Options : count → meta.total ; get/head → verbe HTTP sans body.
-  const rpcCount = await aura.db.rpc('list_things', {}, { count: 'exact' })
-  void rpcCount.meta?.total
-  await aura.db.rpc('list_things', {}, { get: true })
-  await aura.db.rpc('list_things', {}, { head: true, count: 'exact' })
-}
-
-// -- rpc : fallback permissif (Database = any, pas de bloc Functions) --------
-
-async function _dbRpcUntypedSnippet() {
-  const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  // Aucun Database générique fourni : args permissifs, résultat non typé.
-  await aura.db.rpc('whatever_fn', { anything: true })
-}
-
-// -- storage (packages/storage/README.md) ------------------------------------
-
-// `declare const` doit être au niveau module (interdit dans un corps de
-// fonction, cf. TS1184) : le README l'illustre au même niveau.
-declare const file: File
-
-async function _storageSnippets() {
-  const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  await aura.storage.listBuckets()
-  await aura.storage.createBucket('avatars', {
-    public: true,
-    fileSizeLimit: 5 * 1024 * 1024,
-    allowedMimeTypes: ['image/png', 'image/jpeg'],
-  })
-  await aura.storage.getBucket('avatars')
-  await aura.storage.deleteBucket('avatars')
-
-  const { data } = await aura.storage.upload('avatars', 'photo.png', file, {
-    contentType: 'image/png',
-    upsert: true,
-  })
-  await aura.storage.list('avatars', { prefix: 'users/', limit: 100 })
-  await aura.storage.getMetadata('avatars', data!.key)
-
-  // Download — builder paresseux : n'exécute la requête qu'une fois `await`é.
-  const { data: blob } = await aura.storage.download('avatars', 'photo.png')
-  void blob
-  const { data: stream } = await aura.storage.download('avatars', 'photo.png').asStream()
-  void stream
-
-  await aura.storage.copy('avatars', 'photo.png', 'archive/photo.png')
-  await aura.storage.move('avatars', 'archive/photo.png', 'photo.png')
-  await aura.storage.remove('avatars', ['photo.png'])
-
-  await aura.storage.createSignedUrl('avatars', 'photo.png', 600)
-  await aura.storage.createSignedUploadUrl('avatars', 'photo.png', 300)
-  const publicUrl: string = aura.storage.getPublicUrl('avatars', 'photo.png')
-  void publicUrl
-}
-
-// -- storage : transformations d'image (packages/storage/README.md § "Transformations
-// d'image") — les 3 méthodes acceptant `{ transform: ImageTransform }`.
-
-async function _storageTransformSnippets() {
-  const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  const cover: ImageTransform = { width: 200, resize: 'cover' }
-  const thumbnail: string = aura.storage.getPublicUrl('avatars', 'photo.png', { transform: cover })
-  void thumbnail
-
-  const { data: resized } = await aura.storage.download('avatars', 'photo.png', {
-    transform: { width: 800, height: 300, quality: 75 },
-  })
-  void resized
-
-  const webpSigned = await aura.storage.createSignedUrl('avatars', 'photo.png', 600, {
-    transform: { width: 200, format: 'webp' },
-  })
-  void webpSigned.data?.url
-}
-
-// -- realtime (packages/realtime/README.md) -----------------------------------
-
-async function _realtimeSnippets() {
-  const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  const unsubscribe = aura.realtime.onStateChange((state) => {
-    const s: 'disconnected' | 'connecting' | 'connected' | 'reconnecting' = state
-    void s
-  })
-  aura.realtime.connect()
-  const cs: 'disconnected' | 'connecting' | 'connected' | 'reconnecting' = aura.realtime.connectionState
-  void cs
-  aura.realtime.setAutoReconnect(true, 5)
-  aura.realtime.refreshToken('new-access-token')
-
-  // postgres_changes via le raccourci aura.channel(name).
-  aura.channel('db:public.posts')
-    .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'posts' }, (payload) => {
-      void payload
-    })
-    .subscribe((status, err) => {
-      const s: 'SUBSCRIBED' | 'CLOSED' | 'CHANNEL_ERROR' | 'TIMED_OUT' = status
-      void s
-      void err
-    })
-
-  // postgres_changes avec filtre de colonne (§ "Filtres de colonne (postgres_changes)",
-  // packages/realtime/README.md) — le champ `filter` doit typer/compiler.
-  aura.channel('room')
-    .on('postgres_changes', { event: '*', schema: 'public', table: 'x', filter: 'id=eq.1' }, (payload) => {
-      void payload
-    })
-    .subscribe()
-
-  // Broadcast.
-  const room = aura.realtime.channel('room-1', { broadcast: { ack: true, self: true } })
-  room
-    .on('broadcast', { event: 'cursor-pos' }, (payload) => {
-      void payload
-    })
-    .subscribe()
-  const sendStatus: 'ok' | 'timeout' | 'error' = await room.send({
-    type: 'broadcast',
-    event: 'cursor-pos',
-    payload: { x: 100, y: 200 },
-  })
-  void sendStatus
-
-  // Presence.
-  const lobby = aura.channel('room-1', { config: { presence: { key: 'user-1' } } })
-  lobby
-    .on('presence', { event: 'sync' }, () => {
-      lobby.presenceState()
-    })
-    .on('presence', { event: 'join' }, () => {})
-    .on('presence', { event: 'leave' }, () => {})
-    .subscribe()
-  await lobby.track({ online_at: new Date().toISOString() })
-  await lobby.untrack()
-
-  // Nettoyage.
-  aura.realtime.getChannels()
-  aura.realtime.removeChannel('room-1')
-  aura.realtime.removeAllChannels()
-  aura.realtime.disconnect()
-  unsubscribe()
-}
-
-// -- functions (packages/functions/README.md) ---------------------------------
-
-async function _functionsSnippets() {
-  const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  const { data, error } = await aura.functions.invoke<{ ok: boolean }>('hello-world', {
-    body: { name: 'Ada' },
-  })
-  if (error) throw error
-  const ok: boolean = data!.ok
-  void ok
-
-  const controller = new AbortController()
-  const invokeRes = await aura.functions.invoke('slow-job', {
-    method: 'POST',
-    path: '/process',
-    headers: { 'x-request-source': 'studio' },
-    timeout: 5000,
-    signal: controller.signal,
-  })
-  if (invokeRes.error?.code === 'timeout') {
-    // annulation timeout ou signal
-  }
-
-  const { data: fns } = await aura.functions.list()
-  await aura.functions.get(fns![0]!.id)
-
-  const { data: jobs } = await aura.functions.listJobs({ status: 'pending', limit: 20 })
-  await aura.functions.getJob(jobs![0]!.id)
-
-  await aura.functions.createCronJob('nightly-cleanup', '0 3 * * *', 'cleanup-fn', {
-    payload: { dryRun: false },
-  })
-  await aura.functions.listCronJobs()
-  await aura.functions.deleteCronJob('nightly-cleanup')
-}
-
-// -- ai (packages/ai/README.md) ------------------------------------------------
-
-async function _aiSnippets() {
-  const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  const { data, error } = await aura.ai.chat(
-    [{ role: 'user', content: 'Résume ce texte en une phrase.' }],
-    { model: 'gpt-4o-mini', temperature: 0.2, max_tokens: 200 },
-  )
-  if (error) throw error
-  const content: string = data!.content
-  void content
-
-  const { data: embedding } = await aura.ai.embed({
-    text: 'Aurabase est une plateforme Backend-as-a-Service.',
-    namespace: 'docs',
-  })
-  void embedding!.dimensions
-
-  await aura.ai.ragIngest({
-    namespace: 'docs',
-    content: 'Aurabase expose un service de fonctions edge invocables via aura.functions.invoke().',
-  })
-  const { data: answer } = await aura.ai.rag({
-    question: 'Comment invoquer une edge function ?',
-    namespace: 'docs',
-  })
-  void answer!.answer
-  void answer!.sources
-
-  const { data: results } = await aura.ai.semanticSearch('invocation de fonction', 'docs', {
-    top_k: 5,
-    threshold: 0.75,
-  })
-  for (const r of results ?? []) {
-    void r.similarity
-    void r.content
-  }
-
-  const schema = 'CREATE TABLE posts (id uuid, title text, published boolean);'
-  const { data: query } = await aura.ai.nl2sql('Combien de posts sont publiés ?', schema, {
-    dialect: 'postgres',
-  })
-  void query!.sql
-  void query!.explanation
-}
-
-// -- notifications (packages/notifications/README.md) -------------------------
-
-async function _notificationsSnippets() {
-  const aura = createClient('http://localhost:8080', 'my-project', 'aura_anon_xxx')
-
-  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
-  void data!.status
-
-  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) {
-    void item.status
-    void item.notification?.id
-  }
-
-  const { data: sent } = await aura.notifications.list({
-    channel: 'email',
-    status: 'delivered',
-    sort: 'created_at',
-    order: 'desc',
-    limit: 20,
-  })
-  const notificationId = sent![0]!.id
-  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).
-  const { data: settings } = await aura.notifications.admin.getSettings()
-  void settings
-  await aura.notifications.admin.updateSettings({ quotas: { daily_email: 10000 } })
-
-  await aura.notifications.admin.getStats({ window: '24h', channel: 'email' })
-  await aura.notifications.admin.getQueue()
-
-  const failedId = 'notification-id'
-  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)
-
-  await aura.notifications.admin.listEvents({ status: 'failed' })
-  await aura.notifications.admin.listProviderLogs({ channel: 'sms' })
-
-  const templateId = 'template-id'
-  const { data: preview } = await aura.notifications.admin.previewTemplate(templateId, { order_id: '1234' })
-  void preview!.subject
-  void preview!.body
-
-  // Règles déclenchées par événement.
-  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,
-  })
-  await aura.notifications.admin.listRules()
-  await aura.notifications.admin.updateRule(rule!.id, { enabled: false })
-  await aura.notifications.admin.deleteRule(rule!.id)
-}
-
-// Empêche "declared but never read" sur les fonctions non exécutées : chaque
-// snippet doit être référencé pour que `tsc --noEmit` le compile réellement
-// (un import/déclaration inutilisé n'est PAS une erreur `noUnusedLocals` tant
-// que la fonction elle-même est référencée quelque part).
-void _authSnippets
-void _dbSnippets
-void _dbRpcUntypedSnippet
-void _storageSnippets
-void _realtimeSnippets
-void _functionsSnippets
-void _aiSnippets
-void _notificationsSnippets

package/packages/aurabase/tests/types/error-code.test-d.ts

@@ -1,53 +0,0 @@
-// Test type-level (LOT 3, finding I4 + I8) :
-//  - `AuraErrorCode` exporté depuis le meta-package, `AuraError.code` typé dessus,
-//    union ouverte aux codes backend arbitraires (pattern LiteralUnion).
-//  - `AuraObservabilityEvent` (union discriminée par `kind`) + `AuraClientOptions.
-//    onEvent`/`debug` acceptés par `createClient`.
-import { expectTypeOf } from 'vitest'
-import { AuraError, createClient } from '../../src/index'
-import type { AuraErrorCode, AuraObservabilityEvent } from '../../src/index'
-
-test('AuraError.code est typé AuraErrorCode', () => {
-  const e = new AuraError(0, { error: { code: 'no_session', message: 'x' } })
-  expectTypeOf(e.code).toEqualTypeOf<AuraErrorCode>()
-})
-
-test('AuraErrorCode accepte un code connu ET un code backend arbitraire (LiteralUnion)', () => {
-  // La simple compilation de ces affectations EST le test : si `AuraErrorCode`
-  // n'acceptait pas un littéral connu OU un code backend arbitraire, `tsc` échouerait
-  // ici. (`toEqualTypeOf` générique se prête mal à `(string & {})` — cf. doc
-  // expect-type sur les intersections — `toMatchTypeOf` reste pertinent en subtype.)
-  const known: AuraErrorCode = 'timeout'
-  const arbitrary: AuraErrorCode = 'some_backend_code_not_in_the_union'
-  expectTypeOf(known).toMatchTypeOf<AuraErrorCode>()
-  expectTypeOf(arbitrary).toMatchTypeOf<AuraErrorCode>()
-})
-
-test('AuraObservabilityEvent est une union discriminée par kind', () => {
-  const retry: AuraObservabilityEvent = { kind: 'retry', attempt: 1, url: 'http://x' }
-  const retryWithStatus: AuraObservabilityEvent = { kind: 'retry', attempt: 1, status: 503, url: 'http://x' }
-  const timeout: AuraObservabilityEvent = { kind: 'timeout', url: 'http://x' }
-  const refreshSuccess: AuraObservabilityEvent = { kind: 'refresh-success' }
-  const refreshDiscarded: AuraObservabilityEvent = { kind: 'refresh-discarded', reason: 'x' }
-  const jwksFailed: AuraObservabilityEvent = { kind: 'jwks-fetch-failed', baseUrl: 'http://x' }
-  const storageBlocked: AuraObservabilityEvent = { kind: 'storage-blocked', op: 'setItem' }
-  expectTypeOf(retry).toMatchTypeOf<AuraObservabilityEvent>()
-  expectTypeOf(retryWithStatus).toMatchTypeOf<AuraObservabilityEvent>()
-  expectTypeOf(timeout).toMatchTypeOf<AuraObservabilityEvent>()
-  expectTypeOf(refreshSuccess).toMatchTypeOf<AuraObservabilityEvent>()
-  expectTypeOf(refreshDiscarded).toMatchTypeOf<AuraObservabilityEvent>()
-  expectTypeOf(jwksFailed).toMatchTypeOf<AuraObservabilityEvent>()
-  expectTypeOf(storageBlocked).toMatchTypeOf<AuraObservabilityEvent>()
-})
-
-test('createClient accepte onEvent/debug (optionnels — pas de breaking change)', () => {
-  // Compile sans onEvent/debug (rétro-compat) :
-  createClient('http://x', 'p', 'k')
-  // Compile avec onEvent/debug :
-  createClient('http://x', 'p', 'k', {
-    onEvent: (e) => {
-      expectTypeOf(e).toEqualTypeOf<AuraObservabilityEvent>()
-    },
-    debug: true,
-  })
-})

package/packages/aurabase/tsconfig.json

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

package/packages/aurabase/tsconfig.test-d.json

@@ -1,5 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": { "noEmit": true, "rootDir": "." },
-  "include": ["src", "tests/**/*.test-d.ts"]
-}

package/packages/aurabase/tsup.config.ts

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

package/packages/aurabase/vitest.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig, configDefaults } from 'vitest/config'
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    exclude: process.env.RUN_E2E
-      ? configDefaults.exclude
-      : [
-          ...configDefaults.exclude,
-          'tests/integration.test.ts',
-          'tests/observability-backup.test.ts',
-          'tests/production-robustness.test.ts',
-        ],
-  },
-})