Saltar al contenido
Logotipo de Aurabase
aurabase

Páginas de inicio de sesión listas para usar para Next.js

Ocho archivos pequeños le dan a una aplicación Next.js un flujo de inicio de sesión completo, incluidas las páginas a las que apuntan los enlaces en los correos electrónicos Aurabase.

Tutorial8 min leerNivel intermedioRevisado el 25 oct 2026

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

1. Clientes y apoderados#

Estas páginas utilizan App Router con sesiones de cookies (consulte Next.js SSR). Configure NEXT_PUBLIC_AURABASE_URL y NEXT_PUBLIC_AURABASE_ANON_KEY, luego agregue el cliente del servidor y el proxy. En Next.js 15, nombre el archivo middleware.ts y la función middleware.

Información

create-next-app en Next.js 16 activa Cache Components: una página solo puede leer cookies() o searchParams dentro de un componente renderizado bajo <Suspense>; de lo contrario next build se detiene con « uncached or runtime data during prerendering ». Las páginas de abajo están escritas así: la página es estática y la parte que depende de la solicitud llega en streaming.

lib/aurabase/server.tstypescript
import { cookies } from 'next/headers'
import { createServerClient } from '@aurabase/aurabase-js/ssr'

export async function serverClient() {
  const store = await cookies()
  return createServerClient(process.env.NEXT_PUBLIC_AURABASE_URL!, process.env.NEXT_PUBLIC_AURABASE_ANON_KEY!, {
    cookies: {
      getAll: () => store.getAll(),
      // Server Components cannot write cookies: the proxy below refreshes the session instead.
      setAll(list) {
        try {
          list.forEach(({ name, value, options }) => store.set(name, value, options))
        } catch {}
      },
    },
  })
}
proxy.tstypescript
import { NextResponse, type NextRequest } from 'next/server'
import { createServerClient } from '@aurabase/aurabase-js/ssr'

const PROTECTED = ['/dashboard']

export async function proxy(request: NextRequest) {
  const response = NextResponse.next({ request })
  const aura = createServerClient(process.env.NEXT_PUBLIC_AURABASE_URL!, process.env.NEXT_PUBLIC_AURABASE_ANON_KEY!, {
    cookies: {
      getAll: () => request.cookies.getAll(),
      setAll(list) {
        list.forEach(({ name, value, options }) => {
          request.cookies.set(name, value)
          response.cookies.set(name, value, options)
        })
      },
    },
  })
  // getUser() refreshes the tokens AND asks the server who the user is. Never authorize with getSession().
  const { data: user } = await aura.auth.getUser()
  if (!user && PROTECTED.some((p) => request.nextUrl.pathname.startsWith(p))) {
    return NextResponse.redirect(new URL('/login', request.url))
  }
  return response
}

export const config = { matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'] }

2. Inicia sesión y regístrate#

app/login/actions.tstypescript
'use server'
import { redirect } from 'next/navigation'
import { serverClient } from '@/lib/aurabase/server'

export async function login(formData: FormData) {
  const aura = await serverClient()
  const { data, error } = await aura.auth.signInWithPassword({
    email: String(formData.get('email')),
    password: String(formData.get('password')),
  })
  if (error) redirect(`/login?error=${encodeURIComponent(error.code ?? 'ERROR')}`)
  // A user with MFA enabled gets a challenge instead of a session: ask for the code here.
  if (data && 'mfa_required' in data) redirect(`/login?error=MFA_REQUIRED`)
  redirect('/dashboard')
}

export async function sendMagicLink(formData: FormData) {
  const aura = await serverClient()
  await aura.auth.signInWithMagicLink({ email: String(formData.get('email')) })
  redirect('/login?sent=1')
}
app/login/page.tsxtsx
import { Suspense } from 'react'
import Link from 'next/link'
import { login, sendMagicLink } from './actions'

type Search = Promise<{ error?: string; sent?: string }>

// Reads the query string: must render under <Suspense> (Next.js 16 Cache Components).
async function Notices({ searchParams }: { searchParams: Search }) {
  const { error, sent } = await searchParams
  return (
    <>
      {error && <p role="alert">Sign-in failed: {error}</p>}
      {sent && <p>If this address has an account, a sign-in link was sent.</p>}
    </>
  )
}

export default function LoginPage({ searchParams }: { searchParams: Search }) {
  return (
    <main>
      <h1>Sign in</h1>
      <Suspense fallback={null}>
        <Notices searchParams={searchParams} />
      </Suspense>
      <form action={login}>
        <input name="email" type="email" placeholder="Email" required />
        <input name="password" type="password" placeholder="Password" required />
        <button type="submit">Sign in</button>
      </form>
      <form action={sendMagicLink}>
        <input name="email" type="email" placeholder="Email" required />
        <button type="submit">Email me a sign-in link</button>
      </form>
      <p>
        <Link href="/signup">Create an account</Link> · <Link href="/forgot-password">Forgot your password?</Link>
      </p>
    </main>
  )
}
app/signup/actions.tstypescript
'use server'
import { redirect } from 'next/navigation'
import { serverClient } from '@/lib/aurabase/server'

export async function signup(formData: FormData) {
  const aura = await serverClient()
  const { data, error } = await aura.auth.signUp({
    email: String(formData.get('email')),
    password: String(formData.get('password')),
  })
  if (error) redirect(`/signup?error=${encodeURIComponent(error.message)}`)
  // When the project requires email confirmation there is no session yet: `data.session` is null.
  redirect(data?.session ? '/dashboard' : '/signup?check=1')
}
app/signup/page.tsxtsx
import { Suspense } from 'react'
import Link from 'next/link'
import { signup } from './actions'

type Search = Promise<{ error?: string; check?: string }>

async function Notices({ searchParams }: { searchParams: Search }) {
  const { error, check } = await searchParams
  return (
    <>
      {error && <p role="alert">{error}</p>}
      {check && <p>Check your inbox: confirm your email address to finish.</p>}
    </>
  )
}

export default function SignupPage({ searchParams }: { searchParams: Search }) {
  return (
    <main>
      <h1>Create an account</h1>
      <Suspense fallback={null}>
        <Notices searchParams={searchParams} />
      </Suspense>
      <form action={signup}>
        <input name="email" type="email" placeholder="Email" required />
        <input name="password" type="password" placeholder="Password" required minLength={8} />
        <button type="submit">Sign up</button>
      </form>
      <p>
        <Link href="/login">Already have an account?</Link>
      </p>
    </main>
  )
}

3. Restablecer contraseña#

El correo electrónico de restablecimiento se vincula a <Site URL>/reset-password?token=…. Establezca la URL del sitio en Studio › Autenticación › Configuración.

app/forgot-password/actions.tstypescript
'use server'
import { redirect } from 'next/navigation'
import { serverClient } from '@/lib/aurabase/server'

export async function requestReset(formData: FormData) {
  const aura = await serverClient()
  await aura.auth.resetPasswordForEmail(String(formData.get('email')))
  // Same answer whether or not the address has an account (no account enumeration).
  redirect('/forgot-password?sent=1')
}
app/forgot-password/page.tsxtsx
import { Suspense } from 'react'
import { requestReset } from './actions'

type Search = Promise<{ sent?: string }>

async function Notice({ searchParams }: { searchParams: Search }) {
  const { sent } = await searchParams
  return sent ? <p>If this address has an account, a reset link was sent.</p> : null
}

export default function ForgotPasswordPage({ searchParams }: { searchParams: Search }) {
  return (
    <main>
      <h1>Reset your password</h1>
      <Suspense fallback={null}>
        <Notice searchParams={searchParams} />
      </Suspense>
      <form action={requestReset}>
        <input name="email" type="email" placeholder="Email" required />
        <button type="submit">Send the link</button>
      </form>
    </main>
  )
}
app/reset-password/actions.tstypescript
'use server'
import { redirect } from 'next/navigation'
import { serverClient } from '@/lib/aurabase/server'

export async function resetPassword(formData: FormData) {
  const token = String(formData.get('token'))
  const aura = await serverClient()
  const { error } = await aura.auth.resetPassword(token, String(formData.get('password')))
  if (error) redirect(`/reset-password?token=${encodeURIComponent(token)}&error=${encodeURIComponent(error.message)}`)
  // The reset signs the user in with a new session; older sessions were revoked.
  redirect('/dashboard')
}
app/reset-password/page.tsxtsx
import { Suspense } from 'react'
import { resetPassword } from './actions'

type Search = Promise<{ token?: string; error?: string }>

async function ResetForm({ searchParams }: { searchParams: Search }) {
  const { token, error } = await searchParams
  if (!token) return <p role="alert">This link is incomplete. Request a new one.</p>
  return (
    <>
      <h1>Choose a new password</h1>
      {error && <p role="alert">{error}</p>}
      <form action={resetPassword}>
        <input type="hidden" name="token" value={token} />
        <input name="password" type="password" placeholder="New password" required minLength={8} />
        <button type="submit">Save</button>
      </form>
    </>
  )
}

export default function ResetPasswordPage({ searchParams }: { searchParams: Search }) {
  return (
    <main>
      <Suspense fallback={null}>
        <ResetForm searchParams={searchParams} />
      </Suspense>
    </main>
  )
}

Los correos electrónicos de confirmación y enlace mágico enlazan a <Site URL>/verify-email?token=… y <Site URL>/magic-link/verify?token=…. Un controlador de ruta consume el token y luego lo redirige.

app/verify-email/route.tstypescript
import { NextResponse, type NextRequest } from 'next/server'
import { serverClient } from '@/lib/aurabase/server'

export async function GET(request: NextRequest) {
  const token = request.nextUrl.searchParams.get('token')
  if (token) {
    const aura = await serverClient()
    const { error } = await aura.auth.verifyOtp({ type: 'signup', token })
    if (!error) return NextResponse.redirect(new URL('/dashboard', request.url))
  }
  return NextResponse.redirect(new URL('/login?error=LINK_INVALID', request.url))
}
app/magic-link/verify/route.tstypescript
import { NextResponse, type NextRequest } from 'next/server'
import { serverClient } from '@/lib/aurabase/server'

export async function GET(request: NextRequest) {
  const token = request.nextUrl.searchParams.get('token')
  if (token) {
    const aura = await serverClient()
    const { error } = await aura.auth.verifyMagicLink(token)
    if (!error) return NextResponse.redirect(new URL('/dashboard', request.url))
  }
  return NextResponse.redirect(new URL('/login?error=LINK_INVALID', request.url))
}

5. Página protegida#

app/dashboard/actions.tstypescript
'use server'
import { redirect } from 'next/navigation'
import { serverClient } from '@/lib/aurabase/server'

export async function logout() {
  const aura = await serverClient()
  await aura.auth.signOut()
  redirect('/login')
}
app/dashboard/page.tsxtsx
import { Suspense } from 'react'
import { redirect } from 'next/navigation'
import { serverClient } from '@/lib/aurabase/server'
import { logout } from './actions'

// Reads the session cookie: must render under <Suspense> (Next.js 16 Cache Components).
async function Account() {
  const aura = await serverClient()
  const { data: user } = await aura.auth.getUser()
  if (!user) redirect('/login')
  return (
    <>
      <p>Signed in as {user.email}</p>
      <form action={logout}>
        <button type="submit">Sign out</button>
      </form>
    </>
  )
}

export default function DashboardPage() {
  return (
    <main>
      <h1>Dashboard</h1>
      <Suspense fallback={<p>Loading…</p>}>
        <Account />
      </Suspense>
    </main>
  )
}

6. Pruébalo localmente#

En la pila local, los correos los captura Mailpit en lugar de enviarse, y la pantalla « verifica tu correo » de la consola muestra el propio enlace de verificación (modo desarrollo). Para los correos de tu propia aplicación, abre la bandeja de Mailpit con kubectl -n aurabase-dev port-forward svc/aurabase-mailpit 8025:8025 y luego http://localhost:8025. Añade el origen de tu aplicación (por ejemplo http://localhost:3000/*) en Studio › Authentication › Configuration › Redirect URLs y establece la Site URL con él.

Información

proxy.ts solo redirecciona en las rutas enumeradas en PROTECTED; la página del panel verifica al usuario nuevamente con getUser() porque un proxy no es un límite de autorización en sí mismo.