Aurabase Logo
aurabasedocs
docs›Référence›SDK JavaScript

SDK JavaScript

@aurabase/aurabase-js — client typé pour Node, Bun, Deno, Next.js, React, SvelteKit, Vue. Couvre Database, Auth, Realtime, Storage, Functions.

Référence10 min de lecture·Niveau référence·Révisé le 15 avr. 2026
#
Installation

Un package, quatre managers

terminalBASH
pnpm add @aurabase/aurabase-js
Astuce
Le SDK inclut directement l'export @aurabase/aurabase-js/ssr pour Next.js (App Router, Server Actions, Middleware), Remix, Nuxt et SvelteKit avec gestion automatique des cookies de session et chunking anti-troncature.
#
Initialisation

Créer le client

src/lib/aurabase.ts
TYPESCRIPT
import { createClient } from '@aurabase/aurabase-js'
import type { Database } from './aurabase.types'
export const aura = createClient<Database>(
  process.env.AURA_URL!,
  process.env.AURA_PROJECT_ID!,
  process.env.AURA_ANON_KEY!,
  { auth: { persistSession: true, autoRefreshToken: true } }
)
#
SSR & Next.js

Support natif Server-Side Rendering

Pour les architectures SSR (Next.js App Router, Middleware, Server Actions, SvelteKit), importez createServerClient depuis @aurabase/aurabase-js/ssr. La session utilisateur est automatiquement stockée dans des cookies httpOnly sécurisés, avec support du multi-chunk pour les tokens volumineux :

src/middleware.ts
TYPESCRIPT
import { createServerClient } from '@aurabase/aurabase-js/ssr'
import { NextResponse, type NextRequest } from 'next/server'
export async function middleware(request: NextRequest) {
  let response = NextResponse.next({ request })
  const aura = createServerClient(
    process.env.AURA_URL!,
    process.env.AURA_PROJECT_ID!,
    {
      apiKey: process.env.AURA_ANON_KEY,
      cookies: {
        getAll() { return request.cookies.getAll() },
        setAll(cookies) {
          cookies.forEach(({ name, value, options }) => {
            request.cookies.set(name, value)
            response.cookies.set(name, value, options)
          })
        },
      },
    })
  await aura.auth.getSession()
  return response
}
#
Types

Codegen depuis votre schéma

aura db generate (ou npx @aurabase/gen) génère un fichier aurabase.types.ts à partir de votre schéma complet (tables, vues, enums, fonctions RPC). À brancher dans createClient<Database> pour typer l'ensemble de vos requêtes.

package.json
JSON
{
  "scripts": {
    "types:gen": "aura db generate > src/aurabase.types.ts",
    "migrate": "aura db push && pnpm types:gen"
  }
}
#
Méthodes

Par service

Database

SignatureRetour
.from(table).select(cols?)SelectBuilder<T>
.from(table).insert(row)Promise<{ data, error }>
.from(table).update(patch)UpdateBuilder<T>
.from(table).delete()DeleteBuilder<T>
.rpc(fn, args)Promise<{ data, error }>

Auth

SignatureRetour
.auth.signUp({ email, password })Promise<AuthResponse>
.auth.signInWithPassword({ ... })Promise<AuthResponse>
.auth.signInWithOAuth({ provider })Promise<{ url }>
.auth.getSession()Promise<Session | null>
.auth.signOut()Promise<void>
.auth.mfa.enroll({ factor_type })Promise<Factor>

Realtime

SignatureRetour
.channel(name, config?)Channel
channel.on(event, filter, cb)Channel
channel.subscribe()Channel
channel.send({ type, event, payload })Promise<void>
channel.unsubscribe()Promise<void>

Storage

SignatureRetour
.storage.from(bucket).upload(path, file, opts?)Promise<{ data, error }>
.storage.from(bucket).download(path)Promise<Blob>
.storage.from(bucket).getPublicUrl(path, opts?){ publicUrl }
.storage.from(bucket).createSignedUrl(path, expiresIn)Promise<{ signedUrl }>
.storage.from(bucket).remove(paths[])Promise<{ data, error }>

Functions

SignatureRetour
.functions.invoke(name, { body?, method?, path?, headers?, responseType?, signal?, timeout? })Promise<{ data, error }>
.functions.list()Promise<{ data: FunctionDef[], error }>
.functions.get(nameOrId)Promise<{ data: FunctionDef, error }>
.functions.listJobs({ status?, limit? })Promise<{ data: Job[], error }>
.functions.getJob(jobId)Promise<{ data: Job, error }>
.functions.listCronJobs()Promise<{ data: CronJob[], error }>
.functions.createCronJob(name, schedule, functionName, { payload? })Promise<{ data: CronJob, error }>
.functions.deleteCronJob(name)Promise<{ data, error }>
#
Erreurs

Shape uniforme { data, error }

Chaque méthode async retourne { data, error }. error est null en cas de succès, sinon un objet avec code, message, details.

errors.ts
TYPESCRIPT
const { data, error } = await aura.from('users').select(
'*').single()
if (error) {
  if (error.code === 'PGRST116') notFound()
  throw new AurabaseError(error)
}
Dernière mise à jour · 15 avr. 2026