Patrones de autenticación y autorización en Next.js

Petición HTTP entrante del cliente
         │
         ▼
[Capa 1: Edge Middleware] ──────────────────────► Rechazo: HTTP 307 Redirect (/login)
(Comprobación criptográfica rápida de JWT en Edge)
         │ Sesión válida
         ▼
[Capa 2: Server Layout / Page] ─────────────────► Rechazo: redirect('/unauthorized')
(Validación del rol del usuario: session.user.role)
         │ Renderizado de interfaz protegida
         ▼
[Capa 3: Server Action Guard] ──────────────────► Rechazo: throw new Error('Forbidden')
(Validación aislada de session dentro de la mutación)
         │ Acceso autorizado
         ▼
Ejecución de la transacción en la base de datos

import { type DefaultSession } from 'next-auth';
import { type JWT } from 'next-auth/jwt';

export type UserRole = 'USER' | 'ADMIN' | 'EDITOR';

declare module 'next-auth' {
  interface Session {
    user: {
      id: string;
      role: UserRole;
    } & DefaultSession['user'];
  }

  interface User {
    role?: UserRole;
  }
}

declare module 'next-auth/jwt' {
  interface JWT {
    id?: string;
    role?: UserRole;
  }
}

import { handlers } from '@/auth';

export const { GET, POST } = handlers;

import NextAuth from 'next-auth';
import { authConfig } from '@/auth.config';
import { NextResponse } from 'next/server';

const { auth } = NextAuth(authConfig);

export default auth((req) => {
  const { nextUrl } = req;
  const isLoggedIn = !!req.auth;
  const isDashboardRoute = nextUrl.pathname.startsWith('/dashboard');
  const isAuthRoute = nextUrl.pathname.startsWith('/login') || nextUrl.pathname.startsWith('/register');

  if (isAuthRoute && isLoggedIn) {
    return NextResponse.redirect(new URL('/dashboard', nextUrl));
  }

  if (isDashboardRoute && !isLoggedIn) {
    let callbackUrl = nextUrl.pathname;
    if (nextUrl.search) {
      callbackUrl += nextUrl.search;
    }
    const encodedCallbackUrl = encodeURIComponent(callbackUrl);

    return NextResponse.redirect(
      new URL(`/login?callbackUrl=${encodedCallbackUrl}`, nextUrl)
    );
  }

  return NextResponse.next();
});

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

import { auth } from '@/auth';
import { redirect } from 'next/navigation';

export default async function AdminManagementPage() {
  const session = await auth();

  if (!session?.user) {
    redirect('/login?callbackUrl=/admin');
  }

  if (session.user.role !== 'ADMIN') {
    // El usuario está autenticado pero carece de permisos suficientes
    redirect('/unauthorized');
  }

  return (
    <main className="p-8 max-w-6xl mx-auto">
      <h1 className="text-3xl font-bold tracking-tight text-text-primary mb-4">
        Consola de administración del sistema
      </h1>
      <p className="text-text-secondary">
        Bienvenido, {session.user.name} ({session.user.email}). Acceso verificado.
      </p>
    </main>
  );
}

'use server';

import { auth } from '@/auth';
import { db } from '@/shared/lib/db';
import { revalidatePath } from 'next/cache';
import { z } from 'zod';

const DeleteUserSchema = z.object({
  userId: z.string().uuid(),
});

export type DeleteUserState =
  | { status: 'idle' }
  | { status: 'success'; message: string }
  | { status: 'error'; message: string };

export async function deleteUserAction(
  _prevState: DeleteUserState,
  formData: FormData
): Promise<DeleteUserState> {
  // 1. Verificación obligatoria de la identidad del emisor
  const session = await auth();

  if (!session?.user) {
    return { status: 'error', message: 'Error de autenticación: inicie sesión' };
  }

  // 2. Control de privilegios según rol (RBAC)
  if (session.user.role !== 'ADMIN') {
    return { status: 'error', message: 'Acceso denegado: se requieren permisos de administrador' };
  }

  // 3. Validación de datos de entrada
  const parsed = DeleteUserSchema.safeParse({
    userId: formData.get('userId'),
  });

  if (!parsed.success) {
    return { status: 'error', message: 'Identificador de usuario no válido' };
  }

  try {
    await db.user.delete({
      where: { id: parsed.data.userId },
    });

    revalidatePath('/admin/users');
    return { status: 'success', message: 'Usuario eliminado correctamente' };
  } catch (err: unknown) {
    const errorMsg = err instanceof Error ? err.message : 'Error de base de datos desconocido';
    console.error('[DeleteUserAction Failed]:', errorMsg);
    return { status: 'error', message: 'No se pudo completar la eliminación' };
  }
}

'use client';

import { useSession, signOut } from 'next-auth/react';

export function UserMenu() {
  const { data: session, status } = useSession();

  if (status === 'loading') {
    return <div className="h-9 w-9 rounded-full bg-bg-surface animate-pulse" />;
  }

  if (!session?.user) {
    return (
      <a href="/login" className="text-sm font-medium text-text-primary hover:text-accent-violet">
        Iniciar sesión
      </a>
    );
  }

  return (
    <div className="flex items-center gap-3">
      <span className="text-sm text-text-secondary">{session.user.name}</span>
      <button
        onClick={() => signOut({ callbackUrl: '/' })}
        className="px-3 py-1.5 text-xs font-medium rounded-lg bg-bg-surface border border-border hover:bg-bg-subtle transition-colors"
      >
        Cerrar sesión
      </button>
    </div>
  );
}