Route Handlers: API Маршрутизация в Next.js

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

// Обработчик для GET запросов
export async function GET(request: NextRequest) {
  // Чтение query-параметров через расширение 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',
    },
  });
}

// Обработчик для POST запросов
export async function POST(request: NextRequest) {
  try {
    // Безопасный асинхронный парсинг JSON-тела
    const body: unknown = await request.json();
    
    if (!body || typeof body !== 'object' || !('name' in body)) {
      return NextResponse.json(
        { error: 'Некорректные входные данные' },
        { 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
) {
  // Обязательное асинхронное разрешение параметров пути в Next.js 16
  const { id: userId } = await params;

  if (!userId) {
    return NextResponse.json({ error: 'ID пользователя обязателен' }, { status: 400 });
  }

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

  // Возврат пустого успешного ответа 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. Асинхронное чтение заголовков сервера
  const headerStore = await headers();
  const authorization = headerStore.get('authorization');

  // 2. Асинхронное чтение cookies
  const cookieStore = await cookies();
  const theme = cookieStore.get('theme')?.value ?? 'dark';

  // 3. Чтение параметров через объект NextRequest
  const clientIp = request.headers.get('x-forwarded-for') ?? '127.0.0.1';

  // Формирование ответа с установкой новой сессионной куки
  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 часа
    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',
};

// Preflight запрос браузера перед отправкой основного запроса
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();

  // Инициализация нативного ReadableStream
  const stream = new ReadableStream({
    async start(controller) {
      const chunks = ['Поток ', 'данных ', 'генерируется ', 'в реальном ', 'времени.\n'];

      for (const chunk of chunks) {
        controller.enqueue(encoder.encode(chunk));
        // Эмуляция серверной задержки между токенами
        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) {
  // Для валидации HMAC-подписи необходимо точное строковое представление байтов
  const payload = await req.text();
  const headerStore = await headers();
  const signature = headerStore.get('stripe-signature');

  if (!signature) {
    return new Response('Отсутствует заголовок подписи', { 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(`Ошибка подписи вебхука: ${errMsg}`, { status: 400 });
  }

  if (event.type === 'payment_intent.succeeded') {
    const paymentIntent = event.data.object as Stripe.PaymentIntent;
    // Бизнес-логика обработки платежа...
  }

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

// ❌ ОШИБКА: Повторное чтение тела запроса
export async function POST(req: Request) {
  const text = await req.text();
  const json = await req.json(); // Вызовет фатальное исключение TypeError!
}

// ✅ ПРАВИЛЬНО: Сохраняйте результат в переменную или парсите сырой текст
export async function POST(req: Request) {
  const rawText = await req.text();
  const parsedData = JSON.parse(rawText);
}