Saltar al contenido principal
Tutoriales

Cada usuario ve solo sus datos: cómo se hace con Next.js 16, Prisma y Better Auth

Estar logueado no dice qué filas puedes ver. Sesión en el servidor, `userId` en cada query de Prisma y un test con dos cuentas para no exponer datos ajenos.

Israel Palma Sebastià

Este blog es de CREA.MBA, un boilerplate de Next.js con auth, pagos y panel de admin ya montados. Ver qué incluye

En noviembre, Crissy Field, una consultora de seguridad de Hamburgo, publicó junto a Handelsblatt un análisis de 159.041 proyectos hechos con Lovable entre diciembre de 2025 y septiembre de 2026. De los 34.545 que usaban Supabase, 24.664 mandaban registros de la base de datos nada más cargar la página, sin iniciar sesión. Y en 7.403 de esas webs había tablas con direcciones de email.

Ellos mismos piden prudencia con la cifra: parte de esos datos puede ser pública a propósito, y el porcentaje mide exposición sin confirmar filtraciones. Aun así, entre lo que encontraron hay pasaportes, facturas, conversaciones de chat y, en un caso, 280.000 emails enviados. Y la frase con la que lo resumen vale para cualquier stack: los errores de control de acceso pasan en cualquier aplicación, la haya escrito una persona o una IA.

Si estás montando tu SaaS con Next.js, no te salva no usar Lovable. El fallo de fondo es el mismo en todas partes, y tiene nombre: confundir autenticación con autorización.

  • Autenticación: quién eres. Better Auth lo resuelve: email y contraseña, OAuth, 2FA, una cookie de sesión.
  • Autorización: qué puedes ver y tocar. Eso no lo resuelve ninguna librería de login, porque depende de tu modelo de datos.

Estar logueado te dice que hay un usuario. No te dice si la factura cm4x9… es suya. Broken Access Control encabeza el OWASP Top 10 de 2025, y casi siempre aparece por ese hueco.

El error típico: cambiar el id en la URL

Tienes una página /dashboard/proyectos/[id] y una server action para borrar un proyecto. El primer impulso, y lo que te suele generar un asistente si no le das contexto, es esto:

// ❌ Busca por id y compara después (o ni compara)
const project = await db.project.findUnique({ where: { id } });
if (!project) notFound();
return project;

Cualquier usuario logueado que cambie el id en la URL ve el proyecto de otro. Se llama IDOR (Insecure Direct Object Reference) y no hace falta ser hacker: basta con copiar un id que aparezca en una URL compartida, un email o una respuesta de la API.

La versión «arreglada» que más se ve tampoco es buena:

// ⚠️ Funciona, pero depende de que nadie olvide el if
const project = await db.project.findUnique({ where: { id } });
if (!project || project.userId !== session.user.id) notFound();

Funciona hasta el día en que alguien copia la query a otro sitio y se deja el if. Y ya has leído de la base de datos algo que no debías.

La regla: el userId va dentro de la query

// ✅ La base de datos solo puede devolver filas del usuario de la sesión
const project = await db.project.findFirst({
  where: { id, userId: session.user.id },
});
if (!project) notFound();

Si el proyecto no es suyo, para tu código es como si no existiera. Devuelves un 404 en lugar de un 403, y así tampoco confirmas que ese id existe.

Para escribir y borrar, lo mismo con updateMany / deleteMany, que aceptan cualquier filtro y te dicen cuántas filas han tocado:

const { count } = await db.project.deleteMany({
  where: { id, userId: session.user.id },
});
if (count === 0) notFound();

Es justo lo que hace el boilerplate de CREA.MBA para marcar una notificación como leída:

// src/lib/notifications/service.ts
export async function markAsRead(notificationId: string, userId: string) {
  return db.notification.updateMany({
    where: { id: notificationId, userId },
    data: { read: true },
  });
}

Si mandas el id de una notificación ajena, count sale a 0 y no pasa nada.

De dónde sale el userId: siempre de la sesión, leída en el servidor

La otra mitad del problema es de dónde sacas ese userId. Nunca del cliente: ni del body, ni de un query param, ni de un campo oculto del formulario. Siempre de la sesión, y la sesión se lee en el servidor.

Con Better Auth en Next.js 16:

import { headers } from 'next/headers';
import { auth } from '@/lib/auth/server';

const session = await auth.api.getSession({ headers: await headers() });
if (!session) redirect('/login');
// session.user.id es el único userId en el que puedes confiar

Y esto va en cada punto de entrada al servidor:

  • Server actions. La documentación de Next.js 16 lo dice sin rodeos: una server action es un POST que cualquiera puede mandar aunque no exista un botón que la llame. «Treat every action as an untrusted entry point.»
  • Route handlers (app/api/**/route.ts), con el mismo criterio que cualquier API pública.
  • Páginas y componentes de servidor que leen datos.

El useSession() del cliente sirve para pintar el avatar o redirigir si no hay sesión. Mejora la experiencia, pero quien quiera saltárselo hace la petición a mano.

En el boilerplate, en vez de repetir esas líneas en cada endpoint, hay dos envoltorios. createAuthenticatedApiHandler para route handlers y createAuthenticatedAction para server actions. Los dos leen la sesión con auth.api.getSession, devuelven UNAUTHORIZED si no hay, y le pasan al handler el usuario ya resuelto:

// src/app/api/notifications/route.ts
export const POST = createAuthenticatedApiHandler({
  schema: markReadSchema,
  handler: async (input, _req, user) => {
    await markAsRead(input.notificationId, user.id);
    return { success: true };
  },
});

El cliente manda notificationId y nada más. El userId lo pone el servidor. El panel funciona así entero: el hook de créditos llama a /api/credits/balance sin parámetros, y el endpoint consulta paymentService.getCreditBalance(user.id) con el usuario de la sesión.

Por qué el proxy no basta

En Next.js 16 el middleware.ts se llama proxy.ts (el nombre antiguo está deprecado). Es tentador poner ahí un «si no hay cookie, a /login» y darlo por cerrado. Tres razones para no hacerlo:

  1. Next.js te dice que no. La guía de autenticación de la v16 lo deja claro: el proxy sirve para comprobaciones optimistas (leer la cookie y redirigir), pero «should not be your only line of defense in protecting your data». Las comprobaciones de verdad, lo más cerca posible de los datos.
  2. Better Auth te dice que no. Su helper para el proxy, getSessionCookie, solo mira si existe la cookie, no la valida. La documentación lo avisa: cualquiera puede crearse una cookie a mano.
  3. Ya ha fallado. En marzo de 2025 se publicó la CVE-2025-29927 (CVSS 9.1): con una cabecera concreta se podía saltar el middleware entero en Next.js 12 a 15. Las apps que solo protegían ahí quedaron abiertas. Las que comprobaban también en el handler, no.

Y aunque el proxy funcionara perfecto, solo sabe si hay sesión, no de quién es cada fila. El IDOR de arriba lo pasa sin problema.

Por eso el proxy.ts del boilerplate no mira la sesión. Hace rate limiting por tipo de ruta, valida el Origin en las peticiones de API que no son GET y resuelve el idioma. La autorización está en los handlers.

Lo mismo vale para los layouts. La guía de Next.js 16 avisa de que no se vuelven a renderizar al navegar, y de que un layout no impide que las páginas de dentro se ejecuten. El check va en la página o, mejor, en la función que lee el dato.

El patrón que no se olvida: una capa de acceso a datos

Si cada página y cada action tiene que acordarse de leer la sesión y de meter el userId, tarde o temprano alguien se lo salta, y con más motivo si escribe un agente. La solución que recomienda Next.js es una capa de acceso a datos (DAL): un único sitio desde donde se lee la base de datos, y que ya trae la autorización dentro.

// src/lib/dal/projects.ts
import 'server-only';

import { cache } from 'react';
import { headers } from 'next/headers';
import { redirect } from 'next/navigation';

import { auth } from '@/lib/auth/server';
import { db } from '@/lib/db/client';

export const requireUser = cache(async () => {
  const session = await auth.api.getSession({ headers: await headers() });
  if (!session) redirect('/login');
  return session.user;
});

export async function getProject(id: string) {
  const user = await requireUser();
  return db.project.findFirst({
    where: { id, userId: user.id },
    select: { id: true, name: true, createdAt: true },
  });
}

export async function deleteProject(id: string) {
  const user = await requireUser();
  const { count } = await db.project.deleteMany({ where: { id, userId: user.id } });
  return count > 0;
}

Tres detalles:

  • import 'server-only' (bun add server-only) hace que el build falle si alguien importa este fichero desde un componente de cliente. Un error al compilar es mucho mejor que una fuga en producción.
  • cache de React evita leer la sesión varias veces en el mismo render. Ojo: en server actions y route handlers no hay render, así que ahí se ejecuta en cada llamada (lo dice la propia documentación).
  • select devuelve solo los campos que necesita la vista. Si un día pasas el objeto a un componente de cliente, no viaja nada que no toque.

Las funciones de la DAL no reciben el userId como parámetro: lo sacan ellas. Así no hay forma de llamarlas con el id equivocado.

La página queda así:

// src/app/[locale]/dashboard/proyectos/[id]/page.tsx
import { notFound } from 'next/navigation';
import { getProject } from '@/lib/dal/projects';

export default async function ProjectPage({ params }: { params: Promise<{ id: string }> }) {
  const { id } = await params;
  const project = await getProject(id);
  if (!project) notFound();
  return <h1>{project.name}</h1>;
}

Y la action:

'use server';
import { notFound } from 'next/navigation';
import { deleteProject } from '@/lib/dal/projects';

export async function deleteProjectAction(id: string) {
  if (!(await deleteProject(id))) notFound();
}

Siendo transparentes: el boilerplate de CREA.MBA no trae hoy una carpeta dal/ ni usa server-only. Su forma de centralizarlo son los envoltorios de antes y los servicios que reciben el usuario ya resuelto, como markAsRead(id, user.id). Funciona, pero la responsabilidad de pasar user.id sigue en quien llama. Para los modelos que añadas tú (proyectos, documentos, lo que sea tu producto), la DAL con server-only es la opción más difícil de romper.

El test de dos cuentas (diez minutos)

Ninguna revisión de código sustituye a probarlo. Antes de cada despliegue que toque datos de usuario:

  1. Crea dos cuentas, A y B. Una en tu navegador normal y otra en una ventana privada.
  2. Con A, crea un recurso (un proyecto, una factura) y copia su id de la URL o de la pestaña de red.
  3. Con B, pega la URL de A cambiando solo lo necesario: /dashboard/proyectos/. Tiene que salir un 404.
  4. Repite contra la API. Copia la cookie de sesión de B desde las DevTools (con Better Auth se llama better-auth.session_token, con el prefijo __Secure- en HTTPS) y lanza la petición con el id de A:
curl -X POST http://localhost:3000/api/notifications \
  -H "Origin: http://localhost:3000" \
  -H "Content-Type: application/json" \
  -H "Cookie: better-auth.session_token=" \
  -d '{"notificationId":""}'

(En producción, el proxy del boilerplate rechaza los POST a la API que no traen Origin ni Referer; en local los deja pasar, pero con la cabecera la prueba es igual que en producción. Tiene que coincidir con la URL de tu app).

  1. Comprueba en la base de datos que el recurso de A sigue igual. Una respuesta 200 no prueba nada si el updateMany tocó cero filas, y tampoco prueba que no tocara nada.

Si lo haces a menudo, conviértelo en un test de Playwright con dos contextos de navegador, uno por cuenta. Es el test con mejor relación entre lo que cuesta escribirlo y lo que te evita.

Lo que te llevas

  • La autenticación te dice quién es. La autorización la escribes tú, en cada query.
  • El userId sale de la sesión leída en el servidor, nunca de lo que manda el cliente.
  • where: { id, userId } dentro de la query, no un if después.
  • El proxy redirige; los datos se protegen junto a los datos.
  • Dos cuentas y diez minutos antes de desplegar.

CREA.MBA trae resuelta la parte aburrida: Better Auth configurado, sesión comprobada en el servidor en los envoltorios de API y de server actions, y los endpoints del panel (notificaciones, créditos, pagos, suscripciones) filtrando por el usuario de la sesión. Los modelos de tu producto los vas a escribir tú, y ahí la regla es la misma.

¿Has probado alguna vez a abrir tu app con la sesión de otra cuenta?

Next.jsPrismaBetter AuthSecurityAuthorization

¿Te gustó este artículo?

Suscríbete para más tutoriales y tips sobre crear productos con IA