Zum Inhalt springen
Aurabase-Logo
Aurabasis

JavaScript-SDK

@aurabase/aurabase-js – typisierter Client für Node, Bun, Deno, Next.js, React, SvelteKit, Vue. Deckt Datenbank, Authentifizierung, Echtzeit, Speicherung und Funktionen ab.

Referenz10 Min. gelesenEbene ReferenzÜberarbeitet am 15.04.2026

Diese Seite wurde automatisch übersetzt. Maßgeblich ist die englische Version.

Ein Paket, vier Manager#

terminalbash
pnpm add @aurabase/aurabase-js
Tipp

Das SDK umfasst direkt den @aurabase/aurabase-js/ssr-Export für Next.js (App Router, Serveraktionen, Middleware), Remix, Nuxt und SvelteKit mit automatischer Verwaltung von Sitzungscookies und Anti-Trunkation-Chunking.

Erstellen Sie den Client#

src/lib/aurabase.tstypescript
import { createClient } from '@aurabase/aurabase-js'
import type { Database } from './aurabase.types'

export const aura = createClient<Database>(
  process.env.NEXT_PUBLIC_AURABASE_URL!,
  process.env.NEXT_PUBLIC_AURABASE_ANON_KEY!,
  { auth: { persistSession: true } }
)

Unterstützung für natives serverseitiges Rendering#

Für SSR-Architekturen (Next.js App Router, Middleware, Server Actions, SvelteKit) importieren Sie createServerClient aus @aurabase/aurabase-js/ssr. Die Benutzersitzung wird automatisch in sicheren httpOnly-Cookies gespeichert, mit Multi-Chunk-Unterstützung für große Token:

src/middleware.tstypescript
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.NEXT_PUBLIC_AURABASE_URL!,
    process.env.NEXT_PUBLIC_AURABASE_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
}

Codegen aus Ihrem Schema#

npx @aurabase/gen --out lib/aurabase.types.ts (oder aura db generate, das types.ts in den aktuellen Ordner schreibt) generiert die Typendatei aus Ihrem vollständigen Schema (Tabellen, Ansichten, Aufzählungen, RPC-Funktionen). Zum Einbinden in createClient<Database>, um alle Ihre Abfragen einzugeben.

package.jsonjson
{
  "scripts": {
    "types:gen": "npx @aurabase/gen --out src/aurabase.types.ts",
    "migrate": "aura db push && pnpm types:gen"
  }
}

Durch Service#

Datenbank

  • .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 }>
  • .nosql.collection(name) → NoSqlCollectionClient (find(), insertOne(), aggregate(), createIndex())

Auth

  • .auth.signUp({ email, password, options? }) → Promise<AuraResponse<LoginResponse>>
  • .auth.signInWithPassword({ email, password }) → Promise<AuraResponse<LoginResponse>>
  • .auth.signInWithOAuth(provider, opts?) | ({ provider, ... }) → Promise<AuraResponse<{ url }>>
  • .auth.getSession() → Promise<{ data: { session }, error }>
  • .auth.signOut() → Promise<AuraResponse<void>>
  • .auth.mfa.enroll() | .auth.mfaEnroll() → Promise<AuraResponse<MfaEnrollResponse>>

Echtzeit

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

Lagerung

  • .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 }>

Funktionen

  • .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.enqueueJob(functionName, { payload?, delaySecs?, maxAttempts? }) → 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 }>

Nur invoke ist für den öffentlichen Schlüssel (anon) zugänglich. list, get, listJobs, getJob, enqueueJob, listCronJobs, createCronJob und deleteCronJob erfordern einen service_role-Schlüssel und gehören auf Ihren Server: Ein FunctionDef trägt den Quellcode und die Umgebungsvariablen der Funktion, sodass diese Aufrufe antworten 403 zu einem öffentlichen Schlüssel. invoke meldet Fehler als FunctionsHttpError (die Funktion antwortete mit einem Fehler, beliebiger Status) oder FunctionsRelayError (die Plattform ist fehlgeschlagen: Netzwerk, 502, 503, 504), beide exportiert von @aurabase/aurabase-js.

Einheitliche Form {Daten, Fehler}#

Jede asynchrone Methode gibt { data, error } zurück. error ist bei Erfolg null, andernfalls eine AuraError-Instanz (auch unter dem Alias ​​AurabaseError exportiert) mit code, message, status und details. Übergeben Sie { parseBigIntAsString: true } in createClient-Optionen, wenn Ihr Schema 64-Bit-bigint-Werte über Number.MAX_SAFE_INTEGER hinaus verwendet.

errors.tstypescript
import { AurabaseError } from '@aurabase/aurabase-js'

const { data, error } = await aura.from('users').select('*').single()

if (error) {
  if (error.code === 'PGRST116') notFound()
  throw error // Instanz von AuraError / AurabaseError
}

Um weiter zu gehen#