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 15+
  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);
}