Saltar al contenido
Logotipo de Aurabase
aurabase

SDK de JavaScript

@aurabase/aurabase-js: cliente escrito para Node, Bun, Deno, Next.js, React, SvelteKit, Vue. Cubre base de datos, autenticación, tiempo real, almacenamiento y funciones.

Referencia10 min leerNivel referenciaRevisado el 15 abr 2026

Esta página fue traducida automáticamente. La versión en inglés es autorizada.

Un paquete, cuatro gerentes#

terminalbash
pnpm add @aurabase/aurabase-js
Consejo

El SDK incluye directamente la exportación @aurabase/aurabase-js/ssr para Next.js (App Router, Server Actions, Middleware), Remix, Nuxt y SvelteKit con gestión automática de cookies de sesión y fragmentación antitruncamiento.

crear el cliente#

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 } }
)

Soporte de renderizado nativo del lado del servidor#

Para arquitecturas SSR (Next.js App Router, Middleware, Server Actions, SvelteKit), importe createServerClient desde @aurabase/aurabase-js/ssr. La sesión del usuario se almacena automáticamente en cookies seguras httpOnly, con soporte de múltiples fragmentos para tokens grandes:

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 desde tu esquema#

npx @aurabase/gen --out lib/aurabase.types.ts (o aura db generate, que escribe types.ts en la carpeta actual) genera el archivo de tipos a partir de su esquema completo (tablas, vistas, enumeraciones, funciones RPC). Para conectarse a createClient<Database> para escribir todas sus consultas.

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

Por servicio#

Base de datos

  • .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())

autenticación

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

En tiempo real

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

Almacenamiento

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

Funciones

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

Sólo invoke está abierto a la clave pública (anon). list, get, listJobs, getJob, enqueueJob, listCronJobs, createCronJob y deleteCronJob requieren una clave service_role y pertenecen a su servidor: un FunctionDef lleva el código fuente de la función y las variables de entorno, por lo que estas llamadas responden 403 a una clave pública. invoke reporta errores como FunctionsHttpError (la función respondió con un error, cualquier estado) o FunctionsRelayError (la plataforma falló: red, 502, 503, 504), ambos exportados por @aurabase/aurabase-js.

Forma uniforme {datos, error}#

Cada método asíncrono devuelve { data, error }. error es null en caso de éxito; de lo contrario, una instancia AuraError (también exportada con el alias AurabaseError) con code, message, status y details. Pase { parseBigIntAsString: true } en las opciones createClient si su esquema usa valores bigint de 64 bits más allá de Number.MAX_SAFE_INTEGER.

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 // instancia de AuraError / AurabaseError
}

para ir más lejos#