Route Handlers: APIs REST y enrutamiento HTTP en Next.js

import { NextRequest, NextResponse } from 'next/server';
import { db } from '@/lib/db';
import { users } from '@/lib/schema';

// Manejador para solicitudes GET
export async function GET(request: NextRequest) {
  // Lectura de parámetros de consulta mediante la propiedad nextUrl
  const searchParams = request.nextUrl.searchParams;
  const limit = Math.min(Number(searchParams.get('limit') ?? '10'), 50);

  const userList = await db.query.users.findMany({
    limit,
  });

  return NextResponse.json(userList, {
    status: 200,
    headers: {
      'Cache-Control': 'public, s-maxage=60, stale-while-revalidate=120',
    },
  });
}

// Manejador para solicitudes POST
export async function POST(request: NextRequest) {
  try {
    // Análisis asíncrono y seguro del cuerpo JSON
    const body: unknown = await request.json();
    
    if (!body || typeof body !== 'object' || !('name' in body)) {
      return NextResponse.json(
        { error: 'Estructura de datos inválida' },
        { status: 400 }
      );
    }

    const newUser = await db.insert(users).values(body).returning();

    return NextResponse.json(newUser[0], { status: 201 });
  } catch (err: unknown) {
    const message = err instanceof Error ? err.message : 'Internal Server Error';
    return NextResponse.json({ error: message }, { status: 500 });
  }
}

import { NextRequest, NextResponse } from 'next/server';
import { db } from '@/lib/db';
import { users } from '@/lib/schema';
import { eq } from 'drizzle-orm';

interface RouteContext {
  params: Promise<{
    id: string;
  }>;
}

export async function DELETE(
  _request: NextRequest,
  { params }: RouteContext
) {
  // Resolución asíncrona obligatoria de parámetros de ruta en Next.js 15+
  const { id: userId } = await params;

  if (!userId) {
    return NextResponse.json({ error: 'El ID de usuario es obligatorio' }, { status: 400 });
  }

  await db.delete(users).where(eq(users.id, userId));

  // Retorno de respuesta vacía exitosa 204 No Content
  return new Response(null, { status: 204 });
}

import { cookies, headers } from 'next/headers';
import { NextRequest, NextResponse } from 'next/server';

export async function GET(request: NextRequest) {
  // 1. Lectura asíncrona de cabeceras del servidor
  const headerStore = await headers();
  const authorization = headerStore.get('authorization');

  // 2. Acceso asíncrono a cookies
  const cookieStore = await cookies();
  const theme = cookieStore.get('theme')?.value ?? 'dark';

  // 3. Obtención de IP del cliente mediante NextRequest
  const clientIp = request.headers.get('x-forwarded-for') ?? '127.0.0.1';

  // Creación de respuesta y establecimiento de nueva cookie de sesión
  const response = NextResponse.json({
    authorized: Boolean(authorization),
    theme,
    clientIp,
  });

  response.cookies.set('session_active', 'true', {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'lax',
    maxAge: 60 * 60 * 24, // 24 horas
    path: '/',
  });

  return response;
}

const CORS_HEADERS = {
  'Access-Control-Allow-Origin': 'https://dashboard.example.com',
  'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
  'Access-Control-Allow-Headers': 'Content-Type, Authorization',
};

// Petición preflight enviada por el navegador antes de la solicitud real
export async function OPTIONS() {
  return new Response(null, {
    status: 204,
    headers: CORS_HEADERS,
  });
}

export async function GET() {
  return Response.json(
    { status: 'healthy', timestamp: Date.now() },
    {
      status: 200,
      headers: CORS_HEADERS,
    }
  );
}

export async function GET() {
  const encoder = new TextEncoder();

  // Inicialización de un ReadableStream nativo
  const stream = new ReadableStream({
    async start(controller) {
      const chunks = ['Flujo ', 'de datos ', 'generado ', 'en tiempo ', 'real.\n'];

      for (const chunk of chunks) {
        controller.enqueue(encoder.encode(chunk));
        // Simulación de latencia de red entre fragmentos
        await new Promise((resolve) => setTimeout(resolve, 300));
      }

      controller.close();
    },
  });

  return new Response(stream, {
    headers: {
      'Content-Type': 'text/plain; charset=utf-8',
      'Transfer-Encoding': 'chunked',
    },
  });
}

import { headers } from 'next/headers';
import { NextRequest, NextResponse } from 'next/server';
import Stripe from 'stripe';

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY ?? '', {
  apiVersion: '2025-02-24.acacia',
});

export async function POST(req: NextRequest) {
  // Para verificar la firma HMAC se requiere la cadena exacta de bytes
  const payload = await req.text();
  const headerStore = await headers();
  const signature = headerStore.get('stripe-signature');

  if (!signature) {
    return new Response('Falta la cabecera de firma', { status: 400 });
  }

  let event: Stripe.Event;

  try {
    event = stripe.webhooks.constructEvent(
      payload,
      signature,
      process.env.STRIPE_WEBHOOK_SECRET ?? ''
    );
  } catch (err: unknown) {
    const errMsg = err instanceof Error ? err.message : 'Unknown signature error';
    return new Response(`Fallo de verificación de webhook: ${errMsg}`, { status: 400 });
  }

  if (event.type === 'payment_intent.succeeded') {
    const paymentIntent = event.data.object as Stripe.PaymentIntent;
    // Lógica de procesamiento del pago...
  }

  return NextResponse.json({ received: true }, { status: 200 });
}

// ❌ ERROR: Consumo duplicado del flujo del cuerpo
export async function POST(req: Request) {
  const text = await req.text();
  const json = await req.json(); // Lanza TypeError fatal: Body already consumed!
}

// ✅ CORRECTO: Guardar el texto en una variable y parsearlo si es necesario
export async function POST(req: Request) {
  const rawText = await req.text();
  const parsedData = JSON.parse(rawText);
}