@aurabase/aurabase-js 0.3.0

package/packages/functions/src/FunctionsService.ts

@@ -0,0 +1,188 @@
+import { BaseService, AuraError, isTokenExpired, refreshOnce, isAbortError } from '@aurabase/core'
+import type { AuraResponse, CronJob, FunctionDef, Job } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+import { FunctionsRelayError, toFunctionsError } from './errors'
+
+/** Type de réponse attendu de l'invocation (parité `@supabase/functions-js`). */
+export type FunctionsResponseType = 'json' | 'text' | 'blob' | 'arrayBuffer'
+
+export class FunctionsService extends BaseService {
+  constructor(client: AuraClientLike) {
+    super(client)
+  }
+
+  private get prefix(): string {
+    return `/v1/functions/${this.client.projectId}`
+  }
+
+  // -- Function invocation ----------------------------------------------------
+
+  /**
+   * Invoque une edge function.
+   *
+   * `responseType` (parité `@supabase/functions-js`, défaut `'json'`) :
+   *  - `'json'` : chemin PIPELINE inchangé (refresh proactif centralisé, injection
+   *    apikey/Authorization, dé-wrapping `{data,meta}`, retryConfig). Non-régression.
+   *  - `'text' | 'blob' | 'arrayBuffer'` : chemin TRANSPORT BRUT `client.fetchFn`
+   *    (patron `StorageService`, SANS toucher `core/fetch.ts`) — refresh proactif
+   *    manuel, pose de `Authorization`/`apikey`, puis `res.text()/blob()/arrayBuffer()`
+   *    sans dé-wrapping (le corps HTTP est renvoyé tel quel).
+   *
+   * Erreurs typées (parité) : une réponse HTTP non-2xx → `FunctionsHttpError`, une
+   * panne de relais/infra (réseau, 502/503/504) → `FunctionsRelayError` ; les deux
+   * sous-classent `AuraError` (rétrocompat `isAuraError`/champ `error`). `timeout`/
+   * `signal` continuent de produire le code `timeout`.
+   */
+  async invoke<T = unknown>(
+    slug: string,
+    options?: {
+      body?: unknown
+      method?: string
+      path?: string
+      headers?: Record<string, string>
+      signal?: AbortSignal
+      timeout?: number
+      responseType?: FunctionsResponseType
+    },
+  ): Promise<AuraResponse<T>> {
+    const controller = new AbortController()
+    let timeoutId: ReturnType<typeof setTimeout> | undefined
+    const userSignal = options?.signal
+    const onAbort = () => controller.abort()
+    if (options?.timeout) timeoutId = setTimeout(() => controller.abort(), options.timeout)
+    if (userSignal) {
+      // Un signal déjà avorté à l'entrée doit couper immédiatement (addEventListener ne
+      // rejouerait pas un 'abort' déjà émis).
+      if (userSignal.aborted) controller.abort()
+      else userSignal.addEventListener('abort', onAbort, { once: true })
+    }
+    // Nettoyage exécuté en succès ET en erreur — évite de fuir le listener quand l'appelant
+    // réutilise un même AbortSignal longue-durée sur plusieurs invoke().
+    const cleanup = () => {
+      if (timeoutId) clearTimeout(timeoutId)
+      if (userSignal) userSignal.removeEventListener('abort', onAbort)
+    }
+
+    const envelope = { method: options?.method, path: options?.path, headers: options?.headers, body: options?.body }
+    const responseType = options?.responseType ?? 'json'
+    const timeoutError = (): AuraResponse<T> => ({
+      data: null,
+      error: new AuraError(0, {
+        error: { code: 'timeout', message: 'Function invocation aborted or timed out' },
+      }),
+    })
+
+    try {
+      if (responseType === 'json') {
+        // Passe par le pipeline unifié (fetchWithAuth via BaseService.request) : refresh
+        // proactif à marge CENTRALISÉE, injection apikey/Authorization, dé-wrapping
+        // `{data,meta}` et respect de `retryConfig`. Un POST n'est jamais rejoué.
+        const res = await this.request<T>('POST', `${this.prefix}/${slug}/invoke`, envelope, {
+          signal: controller.signal,
+        })
+        if (res.error && controller.signal.aborted) return timeoutError()
+        // Taxonomie d'erreurs : mappe une erreur HTTP vers FunctionsHttpError/RelayError.
+        if (res.error) return { data: null, error: toFunctionsError(res.error) }
+        return res
+      }
+
+      // ── Chemin transport BRUT (text/blob/arrayBuffer) ──────────────────────
+      const client = this.client
+      const store = client.authStore
+      if (store.token && store.refreshToken && isTokenExpired(store.token, 30)) {
+        await refreshOnce(client)
+      }
+      const headers: Record<string, string> = {
+        'Content-Type': 'application/json',
+        // Négocie le mode passthrough côté backend : réponse HTTP BRUTE (statut réel de la
+        // fonction + content-type réel + corps brut) au lieu de l'enveloppe `{data,meta}`.
+        // Indispensable pour que `res.text()/blob()/arrayBuffer()` reçoive le corps de la
+        // fonction (et non l'enveloppe JSON) et que `res.status` porte le statut fonction.
+        'X-Aurabase-Invoke-Mode': 'raw',
+      }
+      if (store.token) headers['Authorization'] = `Bearer ${store.token}`
+      if (client.apiKey) headers['apikey'] = client.apiKey
+
+      const res = await client.fetchFn(this.url(`${this.prefix}/${slug}/invoke`), {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(envelope),
+        signal: controller.signal,
+      })
+      if (!res.ok) {
+        let parsed: { error?: { code?: string; message?: string }; message?: string } | null = null
+        try {
+          parsed = (await res.json()) as typeof parsed
+        } catch {
+          // corps non-JSON → AuraError générique sur le status
+        }
+        return { data: null, error: toFunctionsError(new AuraError(res.status, parsed)) }
+      }
+      let data: unknown
+      if (responseType === 'text') data = await res.text()
+      else if (responseType === 'blob') data = await res.blob()
+      else data = await res.arrayBuffer()
+      return { data: data as T, error: null }
+    } catch (err) {
+      // Annulation/timeout : conserve le code `timeout` (non-régression).
+      if (controller.signal.aborted || isAbortError(err)) return timeoutError()
+      // Toute autre exception (panne réseau : fonction injoignable) → relais.
+      return {
+        data: null,
+        error: new FunctionsRelayError(0, {
+          error: { code: 'network_error', message: err instanceof Error ? err.message : 'Function relay error' },
+        }),
+      }
+    } finally {
+      cleanup()
+    }
+  }
+
+  // -- Function CRUD ----------------------------------------------------------
+
+  async list(): Promise<AuraResponse<FunctionDef[]>> {
+    return this.request('GET', `${this.prefix}`)
+  }
+
+  async get(id: string): Promise<AuraResponse<FunctionDef>> {
+    return this.request('GET', `${this.prefix}/${id}`)
+  }
+
+  // -- Jobs -------------------------------------------------------------------
+
+  async listJobs(options?: { status?: string; limit?: number }): Promise<AuraResponse<Job[]>> {
+    const params = new URLSearchParams()
+    if (options?.status) params.set('status', options.status)
+    if (options?.limit !== undefined) params.set('limit', String(options.limit))
+    const qs = params.toString() ? `?${params.toString()}` : ''
+    return this.request('GET', `${this.prefix}/jobs${qs}`)
+  }
+
+  async getJob(jobId: string): Promise<AuraResponse<Job>> {
+    return this.request('GET', `${this.prefix}/jobs/${jobId}`)
+  }
+
+  // -- Cron -------------------------------------------------------------------
+
+  async listCronJobs(): Promise<AuraResponse<CronJob[]>> {
+    return this.request('GET', `${this.prefix}/cron`)
+  }
+
+  async createCronJob(
+    name: string,
+    schedule: string,
+    functionName: string,
+    options?: { payload?: unknown },
+  ): Promise<AuraResponse<CronJob>> {
+    return this.request('POST', `${this.prefix}/cron`, {
+      name,
+      schedule,
+      function_name: functionName,
+      payload: options?.payload,
+    })
+  }
+
+  async deleteCronJob(name: string): Promise<AuraResponse<null>> {
+    return this.request('DELETE', `${this.prefix}/cron/${name}`)
+  }
+}

package/packages/functions/src/errors.ts

@@ -0,0 +1,70 @@
+import { AuraError } from '@aurabase/core'
+
+/**
+ * Statuts HTTP considérés comme des pannes de RELAIS/infra (passerelle, cold
+ * start, service indisponible) plutôt que des erreurs applicatives de la fonction.
+ * `0` = échec réseau (aucune réponse HTTP).
+ */
+const RELAY_STATUSES = new Set([502, 503, 504])
+
+export function isRelayStatus(status: number): boolean {
+  return status === 0 || RELAY_STATUSES.has(status)
+}
+
+/**
+ * Erreur HTTP APPLICATIVE renvoyée par l'invocation d'une edge function
+ * (réponse HTTP non-2xx). Parité `FunctionsHttpError` de `@supabase/functions-js`.
+ * Sous-classe `AuraError` → `isAuraError()` reste vrai, `status` porte le code HTTP.
+ * `context` conserve le corps déjà lu (JSON/texte) pour inspection.
+ */
+export class FunctionsHttpError extends AuraError {
+  readonly context: unknown
+
+  constructor(
+    status: number,
+    body?: { error?: { code?: string; message?: string }; message?: string } | null,
+    context?: unknown,
+  ) {
+    super(status, body)
+    this.name = 'FunctionsHttpError'
+    this.context = context
+    Object.setPrototypeOf(this, FunctionsHttpError.prototype)
+  }
+}
+
+/**
+ * Erreur de RELAIS/infra : fonction injoignable (échec réseau), 502/503/504 de la
+ * passerelle, cold start échoué, corps non exploitable. Parité `FunctionsRelayError`
+ * de `@supabase/functions-js`. Sous-classe `AuraError`.
+ */
+export class FunctionsRelayError extends AuraError {
+  readonly context: unknown
+
+  constructor(
+    status: number,
+    body?: { error?: { code?: string; message?: string }; message?: string } | null,
+    context?: unknown,
+  ) {
+    super(status, body)
+    this.name = 'FunctionsRelayError'
+    this.context = context
+    Object.setPrototypeOf(this, FunctionsRelayError.prototype)
+  }
+}
+
+/**
+ * Convertit une `AuraError` générique (produite par le pipeline ou un `!res.ok`)
+ * en la sous-classe Functions appropriée, selon le statut HTTP :
+ *  - relais (0/502/503/504) → `FunctionsRelayError` ;
+ *  - toute autre erreur HTTP → `FunctionsHttpError`.
+ * Préserve le corps original (`details`) → code/message conservés.
+ */
+export function toFunctionsError(err: AuraError, context?: unknown): AuraError {
+  const body =
+    err.details != null
+      ? (err.details as { error?: { code?: string; message?: string }; message?: string })
+      : { error: { code: err.code, message: err.message } }
+  return isRelayStatus(err.status)
+    ? new FunctionsRelayError(err.status, body, context ?? err.details)
+    : new FunctionsHttpError(err.status, body, context ?? err.details)
+}

package/packages/functions/src/index.ts

@@ -0,0 +1,6 @@
+export { FunctionsService } from './FunctionsService'
+export type { FunctionsResponseType } from './FunctionsService'
+export { FunctionsHttpError, FunctionsRelayError, isRelayStatus } from './errors'
+
+// Types publics (utilisables en consommant `@aurabase/functions` seul).
+export type { AuraResponse, FunctionDef, Job, CronJob } from '@aurabase/core'

package/packages/functions/tests/invoke.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { FunctionsService } from '../src/FunctionsService'
+import { BaseAuthStore } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+afterEach(() => vi.useRealTimers())
+
+function b64url(o: unknown) { return btoa(JSON.stringify(o)).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '') }
+function expiredJwt() { return `${b64url({ alg: 'HS256' })}.${b64url({ exp: Math.floor(Date.now() / 1000) - 60 })}.s` }
+function validJwt() { return `${b64url({ alg: 'HS256' })}.${b64url({ exp: Math.floor(Date.now() / 1000) + 3600 })}.s` }
+function fakeUser() { return { id: 'u', email: null, role: 'authenticated', email_verified: true, is_banned: false, is_anonymous: false, mfa_enabled: false, user_metadata: {}, app_metadata: {}, created_at: '2025-01-01T00:00:00Z' } }
+
+function make(responder: (url: string, init: RequestInit) => Response | Promise<Response>, store = new BaseAuthStore()) {
+  const calls: string[] = []
+  const client: AuraClientLike = {
+    baseUrl: 'http://x', projectId: 'p', apiKey: 'k', authStore: store,
+    fetchFn: (async (url: string, init: RequestInit) => { calls.push(String(url)); return responder(String(url), init) }) as unknown as typeof globalThis.fetch,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+  return { fns: new FunctionsService(client), calls }
+}
+const json = (o: unknown, s = 200) => new Response(JSON.stringify(o), { status: s, headers: { 'Content-Type': 'application/json' } })
+
+describe('functions.invoke — dé-wrap enveloppe + timeout', () => {
+  it('dé-wrappe l’enveloppe ApiResponse {data, meta}', async () => {
+    const { fns } = make(() => json({ data: { status: 200, body: { ok: true } }, meta: null }))
+    const { data, error } = await fns.invoke('hello')
+    expect(error).toBeNull()
+    expect(data).toEqual({ status: 200, body: { ok: true } }) // contenu, pas l'enveloppe
+  })
+  it('réponse sans enveloppe → renvoyée telle quelle (fallback data ?? parsed)', async () => {
+    const { fns } = make(() => json({ ok: true }))
+    const { data } = await fns.invoke('hello')
+    expect(data).toEqual({ ok: true })
+  })
+  it('propage meta', async () => {
+    const { fns } = make(() => json({ data: { x: 1 }, meta: { total: 5 } }))
+    const { meta } = await fns.invoke('hello')
+    expect(meta).toEqual({ total: 5 })
+  })
+  it('signal déjà avorté à l’entrée → coupe la requête (controller interne aborté)', async () => {
+    const ac = new AbortController()
+    ac.abort()
+    // Le responder rejette UNIQUEMENT si le signal reçu est déjà aborté → prouve le pré-abort.
+    const { fns } = make((_url, init) =>
+      init.signal?.aborted
+        ? Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' }))
+        : Promise.resolve(json({ data: { ok: 1 } })),
+    )
+    const { error } = await fns.invoke('hello', { signal: ac.signal })
+    expect(error?.code).toBe('timeout') // aborté, pas résolu
+  })
+  it('!ok → erreur status', async () => {
+    const { fns } = make(() => json({ error: { code: 'boom', message: 'x' } }, 500))
+    const { error } = await fns.invoke('hello')
+    expect(error?.status).toBe(500)
+  })
+  it('timeout → error code timeout', async () => {
+    vi.useFakeTimers()
+    const { fns } = make((_url, init) => new Promise<Response>((_res, rej) => {
+      init.signal?.addEventListener('abort', () => rej(Object.assign(new Error('aborted'), { name: 'AbortError' })))
+    }))
+    const p = fns.invoke('slow', { timeout: 100 })
+    await vi.advanceTimersByTimeAsync(100)
+    const { error } = await p
+    expect(error?.code).toBe('timeout')
+  })
+  it('passe par le pipeline unifié : injecte apikey/Authorization et ne rejoue PAS un POST (503)', async () => {
+    const store = new BaseAuthStore()
+    store.save(validJwt(), 'rt', fakeUser())
+    let count = 0
+    const seen: Record<string, string> = {}
+    const { fns } = make((_url, init) => {
+      count++
+      Object.assign(seen, init.headers as Record<string, string>)
+      return json({ error: { code: 'unavailable', message: 'x' } }, 503)
+    }, store)
+    const { error } = await fns.invoke('hello')
+    expect(count).toBe(1) // POST non-idempotent → jamais rejoué même sur 503
+    expect(error?.status).toBe(503)
+    expect(seen['apikey']).toBe('k')
+    expect(seen['Authorization']).toBe(`Bearer ${store.token}`)
+  })
+
+  it('refresh proactif si token expiré', async () => {
+    const store = new BaseAuthStore()
+    store.save(expiredJwt(), 'rt', fakeUser())
+    const { fns, calls } = make((url) => {
+      if (url.includes('/v1/auth/')) return json({ access_token: validJwt(), refresh_token: 'rt2', token_type: 'bearer', expires_in: 3600, user: fakeUser() })
+      return json({ ok: 1 })
+    }, store)
+    await fns.invoke('hello')
+    expect(calls[0]).toContain('/v1/auth/p/refresh')
+    expect(calls[1]).toContain('/hello/invoke')
+  })
+})

package/packages/functions/tests/response-type-errors.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect } from 'vitest'
+import { FunctionsService } from '../src/FunctionsService'
+import { FunctionsHttpError, FunctionsRelayError } from '../src/errors'
+import { BaseAuthStore, isAuraError } from '@aurabase/core'
+import type { AuraClientLike } from '@aurabase/core'
+
+function make(responder: (url: string, init: RequestInit) => Response | Promise<Response>, store = new BaseAuthStore()) {
+  const calls: Array<{ url: string; init: RequestInit }> = []
+  const client: AuraClientLike = {
+    baseUrl: 'http://x', projectId: 'p', apiKey: 'k', authStore: store,
+    fetchFn: (async (url: string, init: RequestInit) => { calls.push({ url: String(url), init }); return responder(String(url), init) }) as unknown as typeof globalThis.fetch,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
+  }
+  return { fns: new FunctionsService(client), calls }
+}
+const json = (o: unknown, s = 200) => new Response(JSON.stringify(o), { status: s, headers: { 'Content-Type': 'application/json' } })
+
+describe('functions.invoke — responseType', () => {
+  it("défaut = json : dé-wrappe l'enveloppe (non-régression)", async () => {
+    const { fns } = make(() => json({ data: { ok: true } }))
+    const { data, error } = await fns.invoke('hello')
+    expect(error).toBeNull()
+    expect(data).toEqual({ ok: true })
+  })
+
+  it("responseType 'text' → data est la chaîne brute (pas de dé-wrapping)", async () => {
+    const { fns } = make(() => new Response('bonjour brut', { status: 200, headers: { 'Content-Type': 'text/plain' } }))
+    const { data, error } = await fns.invoke<string>('hello', { responseType: 'text' })
+    expect(error).toBeNull()
+    expect(data).toBe('bonjour brut')
+  })
+
+  it("responseType 'blob' → data est un Blob", async () => {
+    const { fns } = make(() => new Response(new Blob([new Uint8Array([1, 2, 3])]), { status: 200 }))
+    const { data, error } = await fns.invoke<Blob>('hello', { responseType: 'blob' })
+    expect(error).toBeNull()
+    expect(data).toBeInstanceOf(Blob)
+  })
+
+  it("responseType 'arrayBuffer' → data est un ArrayBuffer", async () => {
+    const { fns } = make(() => new Response(new Uint8Array([1, 2, 3]), { status: 200 }))
+    const { data, error } = await fns.invoke<ArrayBuffer>('hello', { responseType: 'arrayBuffer' })
+    expect(error).toBeNull()
+    expect(data).toBeInstanceOf(ArrayBuffer)
+    expect(new Uint8Array(data as ArrayBuffer)).toEqual(new Uint8Array([1, 2, 3]))
+  })
+
+  it("chemin brut : POST vers /invoke avec apikey + Authorization", async () => {
+    const store = new BaseAuthStore()
+    const jwt = `${btoa(JSON.stringify({ alg: 'HS256' }))}.${btoa(JSON.stringify({ exp: Math.floor(Date.now() / 1000) + 3600 }))}.s`.replace(/=+/g, '')
+    store.save(jwt, 'rt', { id: 'u', email: null, role: 'authenticated', email_verified: true, is_banned: false, is_anonymous: false, mfa_enabled: false, user_metadata: {}, app_metadata: {}, created_at: '2025-01-01T00:00:00Z' })
+    const { fns, calls } = make(() => new Response('x', { status: 200 }), store)
+    await fns.invoke('hello', { responseType: 'text' })
+    expect(calls[0]!.url).toBe('http://x/v1/functions/p/hello/invoke')
+    expect(calls[0]!.init.method).toBe('POST')
+    const h = calls[0]!.init.headers as Record<string, string>
+    expect(h['apikey']).toBe('k')
+    expect(h['Authorization']).toBe(`Bearer ${store.token}`)
+    // Négocie le mode passthrough backend (réponse brute, pas l'enveloppe).
+    expect(h['X-Aurabase-Invoke-Mode']).toBe('raw')
+  })
+
+  it("chemin json (défaut) : n'envoie PAS X-Aurabase-Invoke-Mode (enveloppe, non-régression)", async () => {
+    const { fns, calls } = make(() => json({ data: { ok: true } }))
+    await fns.invoke('hello')
+    const h = (calls[0]!.init.headers ?? {}) as Record<string, string>
+    expect(h['X-Aurabase-Invoke-Mode']).toBeUndefined()
+  })
+})
+
+describe('functions.invoke — erreurs typées', () => {
+  it('4xx applicatif (json) → FunctionsHttpError, status correct, isAuraError', async () => {
+    const { fns } = make(() => json({ error: { code: 'bad', message: 'nope' } }, 400))
+    const { data, error } = await fns.invoke('hello')
+    expect(data).toBeNull()
+    expect(error).toBeInstanceOf(FunctionsHttpError)
+    expect(error?.status).toBe(400)
+    expect(isAuraError(error)).toBe(true)
+  })
+
+  it('4xx applicatif (chemin brut text) → FunctionsHttpError', async () => {
+    const { fns } = make(() => new Response('nope', { status: 422, headers: { 'Content-Type': 'text/plain' } }))
+    const { error } = await fns.invoke('hello', { responseType: 'text' })
+    expect(error).toBeInstanceOf(FunctionsHttpError)
+    expect(error?.status).toBe(422)
+  })
+
+  it('503 relais → FunctionsRelayError', async () => {
+    const { fns } = make(() => json({ error: { code: 'unavailable', message: 'x' } }, 503))
+    const { error } = await fns.invoke('hello')
+    expect(error).toBeInstanceOf(FunctionsRelayError)
+    expect(error?.status).toBe(503)
+  })
+
+  it('502 relais (chemin brut) → FunctionsRelayError', async () => {
+    const { fns } = make(() => new Response('bad gateway', { status: 502 }))
+    const { error } = await fns.invoke('hello', { responseType: 'text' })
+    expect(error).toBeInstanceOf(FunctionsRelayError)
+    expect(error?.status).toBe(502)
+  })
+
+  it('panne réseau (chemin brut) → FunctionsRelayError', async () => {
+    const { fns } = make(() => Promise.reject(new TypeError('fetch failed')))
+    const { error } = await fns.invoke('hello', { responseType: 'text' })
+    expect(error).toBeInstanceOf(FunctionsRelayError)
+    expect(error?.status).toBe(0)
+  })
+
+  it('timeout → code timeout (non-régression, PAS une FunctionsError)', async () => {
+    const ac = new AbortController()
+    ac.abort()
+    const { fns } = make((_url, init) =>
+      init.signal?.aborted
+        ? Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' }))
+        : Promise.resolve(json({ data: { ok: 1 } })),
+    )
+    const { error } = await fns.invoke('hello', { signal: ac.signal })
+    expect(error?.code).toBe('timeout')
+    expect(error).not.toBeInstanceOf(FunctionsHttpError)
+    expect(error).not.toBeInstanceOf(FunctionsRelayError)
+  })
+
+  it("timeout sur chemin brut (text) → code timeout", async () => {
+    const ac = new AbortController()
+    ac.abort()
+    const { fns } = make((_url, init) =>
+      init.signal?.aborted
+        ? Promise.reject(Object.assign(new Error('aborted'), { name: 'AbortError' }))
+        : Promise.resolve(new Response('x', { status: 200 })),
+    )
+    const { error } = await fns.invoke('hello', { responseType: 'text', signal: ac.signal })
+    expect(error?.code).toBe('timeout')
+  })
+})

package/packages/functions/tsconfig.json

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

package/packages/functions/tsup.config.ts

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

package/packages/gen/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/gen/README.md

@@ -0,0 +1,84 @@
+# @aurabase/gen
+
+Générateur de types TypeScript `Database` pour le SDK Aurabase : introspecte le schéma d'un projet et produit un fichier de types compatible avec l'inférence de `@aurabase/db` (parité `Database` façon Supabase).
+
+![npm](https://img.shields.io/npm/v/@aurabase/gen) ![license](https://img.shields.io/badge/license-MIT-blue)
+
+> Pre-release — pas encore publié sur npm.
+
+Fait partie de l'écosystème du SDK **[aurabase](../aurabase)**, mais publié et installé **séparément** : contrairement aux autres packages `@aurabase/*`, le méta-package `aurabase` ne dépend pas de `@aurabase/gen` — c'est un outil de développement (CLI de génération de types), pas une dépendance runtime de votre application.
+
+## Installation
+
+```bash
+npm i -D @aurabase/gen
+```
+
+> S'installe typiquement en devDependency (ou s'exécute via `npx` sans installation) : c'est un outil exécuté ponctuellement (local ou CI) pour régénérer un fichier `.ts`, pas un module importé par votre application en production.
+
+## Usage
+
+### CLI `aurabase-gen`
+
+```bash
+npx aurabase-gen --url http://localhost:8080 --project my-project --key aura_anon_xxx --out database.types.ts
+```
+
+Options complètes :
+
+```
+aurabase-gen --url <baseUrl> --project <id> [--key <apiKey>] [--out database.types.ts] [--schema public] [--type-name Database]
+```
+
+Sans `--out`, la sortie est écrite sur `stdout` plutôt que dans un fichier.
+
+### Utilisation programmatique
+
+```ts
+import { generateDatabaseTypes } from '@aurabase/gen'
+import type { SchemaTable } from '@aurabase/core'
+
+const tables: SchemaTable[] = [
+  {
+    name: 'posts',
+    primary_key: 'id',
+    columns: [
+      { name: 'id', col_type: 'uuid', nullable: false, unique: true, default_val: 'gen_random_uuid()', references: null },
+      { name: 'title', col_type: 'text', nullable: false, unique: false, default_val: null, references: null },
+    ],
+    indexes: [],
+    rls_enabled: false,
+    realtime_enabled: false,
+  },
+]
+
+const source = generateDatabaseTypes(tables, { schemaName: 'public', typeName: 'Database' })
+```
+
+### Workflow complet (typage bout-en-bout avec `@aurabase/db`)
+
+```bash
+npx aurabase-gen --url http://localhost:8080 --project my-project --key aura_anon_xxx --out database.types.ts
+```
+
+```ts
+import { createClient } from 'aurabase'
+import type { Database } from './database.types' // fichier généré à l'étape précédente
+
+const aura = createClient<Database>('http://localhost:8080', 'my-project', 'aura_anon_xxx')
+
+// select()/insert()/update() sont désormais inférés depuis les colonnes réelles de `posts`.
+const { data } = await aura.db.from('posts').select('id,title').eq('id', 'post-id').single()
+```
+
+## Limitations
+
+- `Views`, `Functions`, `Enums` et `CompositeTypes` sont toujours générés vides (`Record<string, never>`) — seules les `Tables` sont introspectées et typées.
+- Un seul schéma à la fois (`--schema`, défaut `public`) : pas de génération multi-schémas en une seule invocation.
+- Dépend de l'endpoint `/schema` exposé par `aura.db.schema()` côté backend — un projet ou une clé sans droit de lecture du schéma ne peut pas générer de types (erreur explicite, pas de repli silencieux).
+- Pas de détection de types enum Postgres dédiés : un `col_type` non reconnu retombe sur `unknown`.
+- Le fichier généré est un instantané : il ne se met pas à jour automatiquement quand le schéma change côté backend (pas de mode watch).
+
+## Documentation
+
+Référence complète du SDK (tous les services, types partagés, SSR) : [README racine](../../README.md).