La construcción de APIs REST se ha convertido en una tarea esencial para muchos desarrolladores. Con la creciente demanda de aplicaciones web y móviles que requieren interacción con bases de datos y otros servicios, es fundamental crear APIs que no solo sean funcionales, sino también seguras. En este contexto, Next.js 15 y Prisma emergen como herramientas poderosas para construir APIs robustas y eficientes.
En este artículo, exploraremos cómo puedes aprovechar Next.js 15 y Prisma para desarrollar una API REST segura. Veremos desde los desafíos que enfrentan los desarrolladores al crear APIs, hasta las mejores prácticas y una implementación práctica que te permitirá iniciar tu propio proyecto.
Dónde se rompen las APIs en la práctica
En la era de la digitalización, las APIs desempeñan un papel crucial en la interconexión de servicios y aplicaciones. Sin embargo, muchas veces los desarrolladores se enfrentan a problemas de seguridad y escalabilidad. Las brechas de seguridad pueden resultar en pérdida de datos, robos de información y daños a la reputación de una empresa.
Y conviene decirlo sin cifras infladas: no hace falta un porcentaje para justificar asegurar una API. Los dos huecos que aparecen una y otra vez son concretos y aburridos — endpoints sin autorización por recurso, y entrada que nadie validó.
Autenticación y autorización
Una de las principales preocupaciones al desarrollar una API REST es la autenticación y autorización. Sin estas medidas, cualquier persona podría acceder a los datos sensibles de tu aplicación. La autenticación asegura que solo los usuarios válidos puedan acceder a tu API, mientras que la autorización determina qué datos pueden ver y qué acciones pueden realizar esos usuarios.
La trampa más común es implementar la primera y olvidar la segunda: verificar que el token es válido, y luego devolver el recurso sin comprobar que ese usuario tiene derecho a ese recurso. Un endpoint como /api/pedidos/123 que solo valida la firma deja que cualquier usuario autenticado lea los pedidos de todos.
Validación de datos
Otra cuestión importante es la validación de datos. Cuando se reciben solicitudes en tu API, es fundamental asegurarse de que los datos sean correctos y estén en el formato esperado. La validación inadecuada puede abrir la puerta a ataques como inyección SQL o cross-site scripting (XSS), comprometiendo la seguridad de tu aplicación.
Una nota a favor de Prisma: sus consultas son parametrizadas, así que la inyección SQL clásica no es tu problema mientras uses su API y no $queryRawUnsafe. Lo que sí sigue siendo tu problema es todo lo demás que puede traer un cuerpo de petición malformado.
Mejores prácticas
Para abordar estos problemas, existen una serie de mejores prácticas que se pueden implementar al construir una API REST.
-
Usar HTTPS: Asegúrate de que todas las comunicaciones se realicen a través de HTTPS para cifrar los datos en tránsito.
-
Implementar autenticación robusta: Utiliza métodos como OAuth 2.0 o JWT (JSON Web Tokens) para gestionar la autenticación de usuarios.
-
Validar y sanitizar datos: Siempre valida y sanitiza los datos que recibes para proteger tu API de inyecciones y otros ataques.
-
Limitar la tasa de solicitudes: Implementa límites en la cantidad de solicitudes que un usuario puede realizar en un periodo de tiempo determinado para evitar abusos.
-
Registrar y monitorear: Mantén registros de las actividades en tu API para detectar patrones inusuales que puedan indicar un intento de ataque.
-
Nunca devuelvas el hash: Selecciona explícitamente los campos que sales. Un
findUniquesinselectte devuelve la contraseña hasheada, y de ahí al JSON de respuesta hay un paso.
¿Necesitas una API que aguante producción?
La construimos con autenticación, autorización por recurso y validación desde el primer endpoint, no después del primer incidente.
Implementación con App Router
Ahora que hemos discutido las mejores prácticas, es hora de implementar una API REST segura utilizando Next.js 15 y Prisma. Supongamos que estamos construyendo una API para gestionar un sistema de usuarios.
Una aclaración de entrada, porque muchos tutoriales siguen mostrando lo contrario: en Next.js 15 los endpoints se escriben como route handlers del App Router, en app/api/.../route.ts, no como archivos en pages/api.
-
Instala Next.js y Prisma en tu proyecto:
npx create-next-app@latest my-api cd my-api npm install @prisma/client prisma zod @node-rs/argon2 npx prisma init -
Configura Prisma:
En
prisma/schema.prisma, define tu modelo de usuario:datasource db { provider = "postgresql" url = env("DATABASE_URL") } model User { id Int @id @default(autoincrement()) email String @unique hashedPassword String createdAt DateTime @default(now()) }Luego, ejecuta el siguiente comando para crear la base de datos:
npx prisma migrate dev --name init -
Crea el cliente de Prisma una sola vez:
Éste es el paso que más se salta, y el que causa el error
too many connectionsen desarrollo. Con recarga en caliente, cada cambio crea un cliente nuevo y abre otra conexión. La solución es un singleton:// lib/db.ts import { PrismaClient } from "@prisma/client" const globalForPrisma = globalThis as unknown as { prisma: PrismaClient | undefined } export const db = globalForPrisma.prisma ?? new PrismaClient() if (process.env.NODE_ENV !== "production") { globalForPrisma.prisma = db } -
Crea el endpoint de registro:
// app/api/auth/register/route.ts import { NextRequest } from "next/server" import { z } from "zod" import { hash } from "@node-rs/argon2" import { db } from "@/lib/db" const schema = z.object({ email: z.string().email(), password: z.string().min(8), }) export async function POST(request: NextRequest) { const body = await request.json().catch(() => null) const parsed = schema.safeParse(body) if (!parsed.success) { return Response.json({ error: "Datos inválidos" }, { status: 400 }) } const existing = await db.user.findUnique({ where: { email: parsed.data.email }, select: { id: true }, }) // No confirmamos si el correo ya existe if (existing) { return Response.json({ error: "No se pudo registrar" }, { status: 409 }) } const hashedPassword = await hash(parsed.data.password) const user = await db.user.create({ data: { email: parsed.data.email, hashedPassword }, select: { id: true, email: true, createdAt: true }, }) return Response.json({ user }, { status: 201 }) }Fíjate en el
selectdelcreate: sin él, la respuesta incluiríahashedPassword. -
Genera el token al iniciar sesión:
import jwt from "jsonwebtoken" const token = jwt.sign({ sub: String(user.id) }, process.env.JWT_SECRET!, { expiresIn: "1h", }) -
Protege tus endpoints:
En el App Router no hay
next(): un helper devuelve el usuario o una respuesta de error, y el handler decide.// lib/require-auth.ts import { NextRequest } from "next/server" import jwt from "jsonwebtoken" export function requireAuth(request: NextRequest) { const header = request.headers.get("authorization") const token = header?.startsWith("Bearer ") ? header.slice(7) : null if (!token) { return { error: Response.json({ error: "No autorizado" }, { status: 401 }) } } try { const payload = jwt.verify(token, process.env.JWT_SECRET!) as { sub: string } return { userId: Number(payload.sub) } } catch { return { error: Response.json({ error: "Token inválido" }, { status: 401 }) } } }Y en el handler, la parte que casi nadie escribe — la autorización por recurso:
// app/api/pedidos/[id]/route.ts export async function GET(request: NextRequest, { params }) { const auth = requireAuth(request) if ("error" in auth) return auth.error const { id } = await params const pedido = await db.pedido.findFirst({ // El dueño va en el WHERE, no en un if posterior where: { id: Number(id), userId: auth.userId }, }) if (!pedido) return Response.json({ error: "No encontrado" }, { status: 404 }) return Response.json({ pedido }) }Poner
userIddentro delwhereen lugar de comparar después es lo que convierte "autenticado" en "autorizado", y devuelve 404 en lugar de 403 para no revelar que el recurso existe.
Hacia dónde va
El desarrollo de APIs REST está en constante evolución. Se espera que las APIs GraphQL continúen ganando terreno debido a su flexibilidad en la obtención de datos, aunque a costa de una superficie de ataque distinta y más difícil de limitar. Además, la adopción de microservicios y el uso de contenedores para desplegar APIs sigue creciendo, lo que permite mayor escalabilidad y facilidad de mantenimiento.
Conclusión
Construir una API REST segura con Next.js 15 y Prisma es un proceso que requiere atención a detalles clave como la autenticación, la autorización y la validación de datos. Siguiendo las mejores prácticas mencionadas, puedes crear una API que no solo sea funcional, sino también resistente frente a ataques.
Si te llevas solo tres cosas: el cliente de Prisma se crea una vez, no por petición; la validación va antes de tocar la base; y el dueño del recurso va dentro de la consulta, no en un if después. Esas tres cubren la mayoría de lo que se rompe en una API joven.