Kurs Next.js · Moduł 2: Routing i layouty

Middleware i przechwytywanie żądań

16 min czytania ·
W tej lekcji15

W sercu Metropolii Quantum znajduje się zaawansowany system kontroli dostępu i przekierowań, znany jako Quantum Gateway. Ten system monitoruje każdą próbę dostępu do różnych stref miasta, weryfikuje uprawnienia, przekierowuje do odpowiednich punktów i modyfikuje trasy podróży w czasie rzeczywistym. To niezwykle ważny element infrastruktury, który zapewnia zarówno bezpieczeństwo, jak i optymalizację ruchu w całym mieście.

W świecie Next.js 16 podobną rolę odgrywa Proxy (do wersji 15 nazywane Middleware) - potężny mechanizm, który pozwala na przechwytywanie i modyfikowanie żądań HTTP zanim zostaną one obsłużone przez stronę lub API, co umożliwia implementację takich funkcji jak autoryzacja, przekierowania, czy modyfikacje odpowiedzi.

Czym jest Proxy (dawniej Middleware) w Next.js 16?

Proxy to funkcja, która jest wykonywana przed obsługą żądania przez stronę lub API route. Działa ona między żądaniem klienta a odpowiedzią serwera, co daje możliwość:

  • Wykonywania kodu przed załadowaniem strony
  • Modyfikowania obiektu żądania
  • Modyfikowania obiektu odpowiedzi
  • Przekierowywania użytkownika
  • Odrzucania żądań
  • Dodawania nagłówków HTTP
  • Modyfikowania cookies

Podstawowa struktura Middleware

W Next.js 16 ten kod umieszczasz w pliku proxy.ts (lub proxy.js) w katalogu głównym projektu (obok app lub pages, a w projekcie z katalogiem src w src). Do wersji 15 plik nazywał się middleware.ts, a eksportowana funkcja middleware: Next.js 16 zmienił obie nazwy, ale logika pozostała taka sama. Stary plik wciąż działa, jest jednak przestarzały, a proxy zawsze działa w środowisku Node.js.

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

// Funkcja proxy jest wykonywana przed każdym żądaniem
export function proxy(request: NextRequest) {
  // Tutaj możemy zaimplementować naszą logikę
  console.log('Proxy uruchomione dla:', request.nextUrl.pathname);

  // Możemy zmodyfikować obiekt odpowiedzi
  return NextResponse.next();
}

// Opcjonalnie możemy ograniczyć, dla których tras proxy będzie uruchamiane
export const config = {
  matcher: '/api/:path*',
};

Dostępne operacje w Middleware

1. Przekierowania i przepisywanie adresów (rewrite)

Podobnie jak w Metropolii Quantum, gdzie bramy bezpieczeństwa mogą automatycznie przekierować nieautoryzowanych gości do punktów kontrolnych, middleware w Next.js pozwala na przekierowanie żądań:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  // Sprawdzenie, czy użytkownik próbuje dostać się do strefy administracyjnej
  if (request.nextUrl.pathname.startsWith('/admin')) {
    // Sprawdzamy, czy użytkownik jest zalogowany (np. sprawdzając cookie)
    const isLoggedIn = request.cookies.has('auth-token');

    if (!isLoggedIn) {
      // Przekierowanie niezalogowanych użytkowników do strony logowania
      const loginUrl = new URL('/login', request.url);
      // Dodajemy oryginalny URL jako parametr, aby móc wrócić po zalogowaniu
      loginUrl.searchParams.set('from', request.nextUrl.pathname);
      return NextResponse.redirect(loginUrl);
    }
  }

  // W przeciwnym razie kontynuujemy normalne przetwarzanie żądania
  return NextResponse.next();
}

2. Modyfikowanie nagłówków żądania lub odpowiedzi

Możemy również modyfikować nagłówki, podobnie jak Quantum Gateway może dodawać specjalne identyfikatory do biletów transportowych:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  // Pobieramy oryginalną odpowiedź
  const response = NextResponse.next();

  // Dodajemy własne nagłówki do odpowiedzi
  response.headers.set('x-quantum-security', 'enabled');
  response.headers.set('x-quantum-gateway-version', '15.0.1');

  // Dodanie polityki bezpieczeństwa treści (CSP)
  response.headers.set(
    'Content-Security-Policy',
    "default-src 'self'; script-src 'self' 'unsafe-eval' 'unsafe-inline' quantum-cdn.example.com;"
  );

  return response;
}

3. Manipulowanie cookies

Middleware może również manipulować cookies, co przydaje się przy zarządzaniu sesjami:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  const response = NextResponse.next();

  // Odczyt wartości cookie
  const theme = request.cookies.get('theme')?.value;

  // Ustawienie nowego cookie
  response.cookies.set('last-visit', new Date().toISOString());

  // Zmiana wartości istniejącego cookie
  if (theme === 'dark') {
    response.cookies.set('theme-version', 'dark-v2');
  }

  // Usunięcie cookie
  if (request.nextUrl.pathname === '/logout') {
    response.cookies.delete('auth-token');
  }

  return response;
}

4. Rewrite - podmiana URL bez zmiany widocznego adresu

Rewrite pozwala na podmianę adresu URL wewnętrznie, bez zmiany adresu widocznego dla użytkownika:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  // Przykład: wewnętrzne przekierowanie wszystkich żądań z /docs do /documentation
  // Adres w pasku przeglądarki pozostaje /docs
  if (request.nextUrl.pathname.startsWith('/docs')) {
    const url = request.nextUrl.clone();
    url.pathname = url.pathname.replace(/^\/docs/, '/documentation');
    return NextResponse.rewrite(url);
  }

  return NextResponse.next();
}

Implementacja Middleware dla aplikacji Quantum Voyages

Przygotujmy kompleksowe middleware dla naszej aplikacji Quantum Voyages, które będzie obsługiwać:

  1. Autoryzację dla stref chronionych
  2. Internacjonalizację i wykrywanie języka
  3. Śledzenie i analitykę
// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { verifyAuthToken } from './lib/auth';

// Lista obsługiwanych języków
const SUPPORTED_LOCALES = ['pl', 'en', 'de', 'fr'];
// Domyślny język
const DEFAULT_LOCALE = 'pl';
// Ścieżki wymagające autoryzacji
const PROTECTED_PATHS = ['/dashboard', '/account', '/bookings'];
// Ścieżki administracyjne wymagające uprawnień admina
const ADMIN_PATHS = ['/admin'];

export async function proxy(request: NextRequest) {
  const { pathname } = request.nextUrl;

  // 1. Obsługa lokalizacji i internacjonalizacji
  const pathnameHasLocale = SUPPORTED_LOCALES.some(
    locale => pathname.startsWith(`/${locale}/`) || pathname === `/${locale}`
  );

  // Jeśli ścieżka nie zawiera jeszcze kodu języka, przekieruj i dodaj kod
  if (!pathnameHasLocale) {
    // Próba wykrycia preferowanego języka użytkownika
    const preferredLocale = getPreferredLocale(request);
    const url = new URL(request.url);
    url.pathname = `/${preferredLocale}${pathname}`;
    return NextResponse.redirect(url);
  }

  // Wyodrębnienie kodu języka z ścieżki
  const locale = pathname.split('/')[1];

  // 2. Autoryzacja dla stref chronionych
  // Sprawdzenie, czy ścieżka jest chroniona
  if (isProtectedPath(pathname)) {
    const authToken = request.cookies.get('auth-token')?.value;

    // Weryfikacja tokenu autoryzacji
    const authResult = await verifyAuthToken(authToken);

    // Jeśli użytkownik nie jest zalogowany lub token jest nieprawidłowy
    if (!authResult.isValid) {
      const loginUrl = new URL(`/${locale}/login`, request.url);
      loginUrl.searchParams.set('returnTo', request.nextUrl.pathname);
      return NextResponse.redirect(loginUrl);
    }

    // Sprawdzenie uprawnień admina dla ścieżek administracyjnych
    if (isAdminPath(pathname) && !authResult.isAdmin) {
      const accessDeniedUrl = new URL(`/${locale}/access-denied`, request.url);
      return NextResponse.redirect(accessDeniedUrl);
    }
  }

  // 3. Dodanie nagłówków analityki i bezpieczeństwa
  const response = NextResponse.next();

  // Dodanie informacji o użytkowniku dla narzędzi analitycznych (nie zawiera danych osobowych)
  const visitorId = request.cookies.get('visitor-id')?.value || generateVisitorId();
  response.cookies.set('visitor-id', visitorId, {
    httpOnly: true,
    sameSite: 'strict',
    maxAge: 60 * 60 * 24 * 365 // 1 rok
  });

  // Nagłówki bezpieczeństwa
  response.headers.set('X-Frame-Options', 'DENY');
  response.headers.set('X-Content-Type-Options', 'nosniff');
  response.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin');

  return response;
}

// Funkcje pomocnicze

// Wykrywanie preferowanego języka użytkownika
function getPreferredLocale(request: NextRequest): string {
  // Sprawdzenie zapisanego wcześniej preferowanego języka w cookie
  const savedLocale = request.cookies.get('preferred-locale')?.value;
  if (savedLocale && SUPPORTED_LOCALES.includes(savedLocale)) {
    return savedLocale;
  }

  // Sprawdzenie nagłówka Accept-Language
  const acceptLanguage = request.headers.get('accept-language');
  if (acceptLanguage) {
    // Analiza nagłówka Accept-Language i wyszukanie najlepszego dopasowania
    const userLocales = acceptLanguage.split(',')
      .map(item => {
        const [locale, priority = 'q=1.0'] = item.trim().split(';');
        const q = parseFloat(priority.replace('q=', '')) || 1.0;
        return { locale: locale.split('-')[0], q };
      })
      .sort((a, b) => b.q - a.q);

    // Znajdź pierwszy obsługiwany język
    for (const { locale } of userLocales) {
      if (SUPPORTED_LOCALES.includes(locale)) {
        return locale;
      }
    }
  }

  // Domyślny język, jeśli nie można określić preferencji
  return DEFAULT_LOCALE;
}

// Sprawdzenie, czy ścieżka jest chroniona
function isProtectedPath(pathname: string): boolean {
  return PROTECTED_PATHS.some(path => {
    // Usunięcie kodu języka z ścieżki przed porównaniem
    const pathWithoutLocale = pathname.split('/').slice(2).join('/');
    return `/${pathWithoutLocale}`.startsWith(path);
  });
}

// Sprawdzenie, czy ścieżka jest administracyjna
function isAdminPath(pathname: string): boolean {
  return ADMIN_PATHS.some(path => {
    // Usunięcie kodu języka z ścieżki przed porównaniem
    const pathWithoutLocale = pathname.split('/').slice(2).join('/');
    return `/${pathWithoutLocale}`.startsWith(path);
  });
}

// Generowanie unikalnego ID dla odwiedzającego
function generateVisitorId(): string {
  return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
}

// Określenie, dla których ścieżek proxy będzie uruchamiane
export const config = {
  matcher: [
    // Dopasowanie wszystkich ścieżek
    '/((?!api|_next/static|_next/image|favicon.ico).*)',
  ],
};

Selektywne uruchamianie Middleware z Matcher

Podobnie jak w Metropolii Quantum, gdzie nie każde przemieszczenie wymaga pełnej kontroli bezpieczeństwa, tak w Next.js 16 możemy określić, dla których ścieżek proxy będzie uruchamiane, używając konfiguracji matcher:

// proxy.ts
export const config = {
  matcher: [
    // Ścieżki, dla których proxy będzie uruchamiane
    '/dashboard/:path*',
    '/api/:path*',
    '/((?!_next/static|_next/image|favicon.ico).*)',
  ],
};

Dostępne są różne wzorce matcherów:

  1. Dopasowanie dokładne: '/about'
  2. Dopasowanie z parametrami: '/blog/:path'
  3. Dopasowanie z parametrami catch-all: '/blog/:path*'
  4. Kilka ścieżek naraz: tablica ['/dashboard/:path*', '/admin/:path*'] albo grupa w nawiasach '/(dashboard|admin)/:path*'
  5. Dopasowanie z negacją: /((?!api|_next/static|_next/image|favicon.ico).*)

Implementacja autoryzacji JWT z Middleware

W Metropolii Quantum identyfikatory mieszkańców są weryfikowane przy użyciu zaawansowanej technologii kryptograficznej. Zaimplementujmy podobny system autoryzacji JWT w naszej aplikacji:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { jwtVerify } from 'jose';

interface UserPayload {
  id: string;
  email: string;
  role: string;
  exp: number;
}

export async function proxy(request: NextRequest) {
  // Sprawdź, czy ścieżka wymaga autoryzacji
  if (request.nextUrl.pathname.startsWith('/dashboard') ||
      request.nextUrl.pathname.startsWith('/api/protected')) {

    // Pobierz token JWT z cookie lub nagłówka Authorization
    const authToken = request.cookies.get('auth-token')?.value ||
                     request.headers.get('Authorization')?.split(' ')[1];

    if (!authToken) {
      // Brak tokenu - przekierowanie do logowania
      return redirectToLogin(request);
    }

    try {
      // Weryfikacja tokenu JWT
      const secretKey = new TextEncoder().encode(process.env.JWT_SECRET!);
      const { payload } = await jwtVerify<UserPayload>(authToken, secretKey);

      // Sprawdzenie, czy token nie wygasł
      const currentTime = Math.floor(Date.now() / 1000);
      if (payload.exp < currentTime) {
        // Token wygasł - przekierowanie do logowania
        return redirectToLogin(request);
      }

      // Sprawdzenie uprawnień admina dla ścieżek administracyjnych
      if (request.nextUrl.pathname.startsWith('/admin') && payload.role !== 'admin') {
        return NextResponse.json(
          { message: 'Insufficient permissions' },
          { status: 403 }
        );
      }

      // Dodanie informacji o użytkowniku do nagłówków dla kolejnych obsług
      const response = NextResponse.next();
      response.headers.set('x-user-id', payload.id);
      response.headers.set('x-user-role', payload.role);

      return response;
    } catch (error) {
      // Błąd weryfikacji tokenu - przekierowanie do logowania
      return redirectToLogin(request);
    }
  }

  return NextResponse.next();
}

// Funkcja przekierowująca do logowania
function redirectToLogin(request: NextRequest) {
  const loginUrl = new URL('/login', request.url);
  loginUrl.searchParams.set('returnTo', request.nextUrl.pathname);
  return NextResponse.redirect(loginUrl);
}

export const config = {
  matcher: [
    '/dashboard/:path*',
    '/admin/:path*',
    '/api/protected/:path*',
  ],
};

Implementacja przełączania motywów z Middleware

Quantum City oferuje swoim mieszkańcom możliwość dostosowania wyglądu interfejsów miejskich. Zaimplementujmy podobny system przełączania między jasnymi i ciemnymi motywami:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  // Pobierz preferowany motyw
  const theme = request.cookies.get('theme')?.value || 'light';

  // Utwórz odpowiedź
  const response = NextResponse.next();

  // Ustaw zmienną preferencji motywu jako cookie
  response.cookies.set('theme', theme, {
    maxAge: 60 * 60 * 24 * 365, // ważne przez rok
    path: '/',
  });

  // Dodaj niestandardowy nagłówek, który może być odczytany przez klienta
  response.headers.set('x-theme', theme);

  return response;
}

export const config = {
  matcher: '/((?!api|_next/static|_next/image|favicon.ico).*)',
};

Obsługa wielu domen i subdomen z Middleware

W Metropolii Quantum różne dzielnice mogą mieć swoje własne systemy dostępu. Podobnie w Next.js możemy obsługiwać różne domeny i subdomeny:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  const { pathname, hostname } = request.nextUrl;

  // Obsługa różnych subdomen
  if (hostname === 'admin.quantumvoyages.com') {
    // Przekierowanie wszystkich żądań do panelu administracyjnego
    const url = new URL('/admin' + pathname, request.url);
    return NextResponse.rewrite(url);
  }

  if (hostname === 'api.quantumvoyages.com') {
    // Przekierowanie żądań do API
    const url = new URL('/api' + pathname, request.url);
    return NextResponse.rewrite(url);
  }

  if (hostname.startsWith('user-')) {
    // Obsługa subdomen użytkowników (np. user-john.quantumvoyages.com)
    const username = hostname.replace('user-', '').split('.')[0];
    const url = new URL(`/profile/${username}${pathname}`, request.url);
    return NextResponse.rewrite(url);
  }

  return NextResponse.next();
}

export const config = {
  matcher: '/((?!_next/static|_next/image|favicon.ico).*)',
};

Cachowanie i modyfikacja nagłówków odpowiedzi

W Metropolii Quantum system Gateway optymalizuje przepływ danych przez swoje systemy. Podobnie możemy zoptymalizować naszą aplikację:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  const response = NextResponse.next();

  // Ustawienie nagłówków cachowania dla zasobów statycznych
  if (request.nextUrl.pathname.match(/\.(jpg|jpeg|png|webp|svg|gif|ico)$/)) {
    response.headers.set('Cache-Control', 'public, max-age=31536000, immutable');
  }

  // Ustawienie nagłówków cachowania dla stron HTML
  else if (!request.nextUrl.pathname.startsWith('/api/')) {
    response.headers.set('Cache-Control', 'public, max-age=300, s-maxage=3600');
  }

  // Dodanie nagłówków bezpieczeństwa
  response.headers.set('Strict-Transport-Security', 'max-age=63072000');
  response.headers.set('X-Content-Type-Options', 'nosniff');
  response.headers.set('X-Frame-Options', 'DENY');
  response.headers.set('X-XSS-Protection', '1; mode=block');

  return response;
}

export const config = {
  matcher: '/((?!_next/static|_next/image|favicon.ico).*)',
};

Implementacja geolokalizacji i personalizacji treści

Metropolia Quantum dostosowuje dostępne usługi w zależności od położenia mieszkańców. Zaimplementujmy podobny system w naszej aplikacji, używając middleware do określenia lokalizacji użytkownika:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

// Tabela regionów i ich dostępnych destynacji
const REGION_DESTINATIONS = {
  'EU': ['mars', 'europa', 'titan'],
  'NA': ['mars', 'luna', 'titan', 'ganymede'],
  'ASIA': ['mars', 'venus-orbiter', 'luna'],
  'default': ['mars'] // domyślne destynacje dostępne globalnie
};

export function proxy(request: NextRequest) {
  // Pobierz region użytkownika (w rzeczywistości można użyć zewnętrznego API do geolokalizacji)
  const countryCode = request.headers.get('x-country') || 'default';
  const region = getRegionFromCountry(countryCode);

  // Utwórz odpowiedź
  const response = NextResponse.next();

  // Dodanie informacji o regionie i dostępnych destynacjach jako nagłówki
  response.headers.set('x-user-region', region);
  response.headers.set('x-available-destinations', JSON.stringify(REGION_DESTINATIONS[region] || REGION_DESTINATIONS.default));

  // Ustawienie cookie z regionem (będzie dostępne w przeglądarce)
  response.cookies.set('user-region', region, {
    maxAge: 60 * 60 * 24 * 30, // 30 dni
    path: '/',
  });

  return response;
}

// Funkcja mapująca kody krajów na regiony
function getRegionFromCountry(countryCode: string): keyof typeof REGION_DESTINATIONS {
  const EU_COUNTRIES = ['DE', 'FR', 'IT', 'ES', 'PL', 'NL', 'BE', 'SE', 'AT', 'DK'];
  const NA_COUNTRIES = ['US', 'CA', 'MX'];
  const ASIA_COUNTRIES = ['JP', 'CN', 'KR', 'IN', 'SG', 'TH', 'MY', 'PH', 'VN'];

  if (EU_COUNTRIES.includes(countryCode)) return 'EU';
  if (NA_COUNTRIES.includes(countryCode)) return 'NA';
  if (ASIA_COUNTRIES.includes(countryCode)) return 'ASIA';

  return 'default';
}

export const config = {
  matcher: '/((?!_next/static|_next/image|favicon.ico).*)',
};

Ograniczanie liczby żądań (Rate limiting)

W Metropolii Quantum system Gateway kontroluje ilość zapytań do krytycznych zasobów, aby zapobiec przeciążeniu. Zaimplementujmy podobny mechanizm rate limitingu:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

// Prosty system rate limitingu oparty na pamięci (w produkcji lepiej użyć Redis lub podobnej usługi)
const RATE_LIMIT_DURATION = 60 * 1000; // 1 minuta
const MAX_REQUESTS_PER_MINUTE = 60; // Maksymalna liczba żądań na minutę

// Przechowywanie liczników żądań dla różnych IP (w rzeczywistej aplikacji lepiej użyć Redis)
const ipRequestCounts = new Map<string, { count: number, resetAt: number }>();

export function proxy(request: NextRequest) {
  // Ograniczamy tylko żądania API
  if (request.nextUrl.pathname.startsWith('/api/')) {
    // NextRequest nie ma już pola ip (usunięte w Next.js 15) - adres klienta podaje nagłówek x-forwarded-for
    const ip = request.headers.get('x-forwarded-for')?.split(',')[0]?.trim() || 'unknown';
    const now = Date.now();

    // Pobierz lub utwórz licznik dla tego IP
    if (!ipRequestCounts.has(ip) || ipRequestCounts.get(ip)!.resetAt < now) {
      // Zresetuj licznik, jeśli upłynął czas
      ipRequestCounts.set(ip, { count: 1, resetAt: now + RATE_LIMIT_DURATION });
    } else {
      // Zwiększ licznik
      const record = ipRequestCounts.get(ip)!;
      record.count++;

      // Sprawdź, czy przekroczono limit
      if (record.count > MAX_REQUESTS_PER_MINUTE) {
        // Oblicz czas, po którym można ponownie wysyłać żądania
        const resetTime = Math.ceil((record.resetAt - now) / 1000);

        // Zwróć odpowiedź z kodem 429 Too Many Requests
        return new NextResponse('Rate limit exceeded', {
          status: 429,
          headers: {
            'Retry-After': `${resetTime}`,
            'X-RateLimit-Limit': `${MAX_REQUESTS_PER_MINUTE}`,
            'X-RateLimit-Remaining': '0',
            'X-RateLimit-Reset': `${resetTime}`,
          },
        });
      }
    }
  }

  return NextResponse.next();
}

export const config = {
  matcher: '/api/:path*',
};

Obsługa A/B testów z Middleware

W Metropolii Quantum niektóre nowe funkcje są testowane na wybranych grupach mieszkańców. Zaimplementujmy podobny system A/B testów:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

// Definicje testów A/B
const AB_TESTS = {
  'new-landing-page': {
    variants: ['control', 'variant-a', 'variant-b'],
    weights: [0.5, 0.25, 0.25], // 50% użytkowników zobaczy control, 25% variant-a, 25% variant-b
  },
  'checkout-flow': {
    variants: ['standard', 'simplified'],
    weights: [0.5, 0.5], // 50% użytkowników zobaczy każdy wariant
  },
};

export function proxy(request: NextRequest) {
  const response = NextResponse.next();

  // Przypisz użytkownika do grup testów
  Object.entries(AB_TESTS).forEach(([testName, test]) => {
    // Pobierz istniejący wariant z cookie lub przypisz nowy
    let variant = request.cookies.get(`ab-${testName}`)?.value;

    if (!variant || !test.variants.includes(variant)) {
      // Przypisz wariant na podstawie wag
      variant = assignVariant(test.variants, test.weights);

      // Zapisz wariant w cookie
      response.cookies.set(`ab-${testName}`, variant, {
        maxAge: 60 * 60 * 24 * 30, // 30 dni
        path: '/',
      });
    }

    // Dodaj informację o wariancie jako nagłówek dla klienta
    response.headers.set(`x-ab-${testName}`, variant);
  });

  return response;
}

// Funkcja przypisująca wariant na podstawie wag
function assignVariant(variants: string[], weights: number[]): string {
  const random = Math.random();
  let cumulativeWeight = 0;

  for (let i = 0; i < variants.length; i++) {
    cumulativeWeight += weights[i];
    if (random < cumulativeWeight) {
      return variants[i];
    }
  }

  // Domyślnie zwróć pierwszy wariant
  return variants[0];
}

export const config = {
  matcher: '/((?!api|_next/static|_next/image|favicon.ico).*)',
};

Monitorowanie i debugowanie Middleware

W zastosowaniach produkcyjnych ważne jest monitorowanie działania middleware. Możemy zaimplementować prosty system logowania:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export function proxy(request: NextRequest) {
  const startTime = Date.now();

  // Utwórz identyfikator żądania
  const requestId = generateRequestId();

  // Utwórz odpowiedź
  const response = NextResponse.next();

  // Dodaj identyfikator żądania do nagłówków
  response.headers.set('x-request-id', requestId);

  // Czas działania samego proxy (strona renderuje się dopiero po nim, więc to nie jest czas całego żądania)
  const duration = Date.now() - startTime;
  response.headers.set('x-response-time', `${duration}ms`);

  // W środowisku produkcyjnym można wysłać te dane do systemu monitorowania
  // logRequest(requestId, request.method, request.url, response.status, duration);

  return response;
}

// Generowanie unikalnego identyfikatora żądania
function generateRequestId(): string {
  return `${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
}

export const config = {
  matcher: '/((?!_next/static|_next/image|favicon.ico).*)',
};

Integracja z systemami zewnętrznymi

Middleware może również integrować się z zewnętrznymi systemami, takimi jak systemy uwierzytelniania lub analityki:

// proxy.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';

export async function proxy(request: NextRequest) {
  // Pobierz informacje o sesji z zewnętrznego serwisu
  const sessionId = request.cookies.get('session-id')?.value;
  let userInfo = null;

  if (sessionId) {
    try {
      // W rzeczywistej aplikacji, to mogłoby być wywołanie API
      userInfo = await fetchUserInfo(sessionId);
    } catch (error) {
      console.error('Error fetching user info:', error);
    }
  }

  // Utwórz odpowiedź
  const response = NextResponse.next();

  // Jeśli mamy informacje o użytkowniku, dodaj je do nagłówków
  if (userInfo) {
    response.headers.set('x-user-id', userInfo.id);
    response.headers.set('x-user-plan', userInfo.plan);

    // Wysyłanie danych do systemu analityki
    trackUserActivity(userInfo.id, request.url, request.method);
  }

  return response;
}

// Funkcja pobierająca informacje o użytkowniku (symulacja)
async function fetchUserInfo(sessionId: string) {
  // W rzeczywistej aplikacji, mogłoby to być wywołanie API
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({
        id: 'user-123',
        plan: 'premium',
        name: 'John Doe'
      });
    }, 50);
  });
}

// Funkcja śledząca aktywność użytkownika (symulacja)
function trackUserActivity(userId: string, url: string, method: string) {
  // W rzeczywistej aplikacji, mogłoby to wysyłać dane do Google Analytics, Mixpanel, itp.
  console.log(`User ${userId} accessed ${url} with method ${method}`);
}

export const config = {
  matcher: '/((?!_next/static|_next/image|favicon.ico).*)',
};

Podsumowanie

Proxy w Next.js 16 (dawniej Middleware) jest potężnym narzędziem, które, podobnie jak Quantum Gateway w Metropolii Quantum, umożliwia kontrolę i modyfikację ruchu w aplikacji na samym początku cyklu żądanie-odpowiedź. Dzięki temu możemy:

  1. Implementować zaawansowane systemy autoryzacji - weryfikować tokeny JWT, przekierowywać niezalogowanych użytkowników, kontrolować dostęp do chronionych zasobów.

  2. Dodawać funkcje internacjonalizacji - wykrywać preferowany język użytkownika, przekierowywać do odpowiednich wersji językowych.

  3. Personalizować doświadczenie użytkownika - dostosowywać treści na podstawie lokalizacji, preferencji i historii użytkownika.

  4. Optymalizować wydajność - kontrolować nagłówki cachowania, modyfikować odpowiedzi, implementować rate limiting.

  5. Integrować się z zewnętrznymi systemami - łączyć się z systemami analityki, uwierzytelniania i innymi usługami.

  6. Przeprowadzać testy A/B - przydzielać użytkowników do grup testowych i personalizować doświadczenie.

  7. Monitorować i debugować - śledzić żądania, mierzyć wydajność, zapisywać metryki.

Wykorzystując middleware, możemy znacząco rozszerzyć możliwości naszej aplikacji Next.js 16, dodając zaawansowane funkcje, które są wykonywane na wczesnym etapie cyklu życia żądania, co pozwala na większą kontrolę i lepszą wydajność.

W następnej lekcji poznasz prefetching i inne sposoby przyspieszania nawigacji w Next.js 16.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Metadata w App Routerze definiuje się przez:

  2. 2. Private Folders w App Routerze oznacza się prefiksem:

  3. 3. Komponenty w App Routerze bez dyrektywy 'use client' domyślnie:

  4. 4. Aby stworzyć Client Component należy dodać:

  5. 5. Czym jest prefetching w Next.js?

  6. 6. Jak w Next.js 16 musi się nazywać plik w katalogu głównym projektu, który zastąpił middleware.ts i uruchamia się przed obsługą żądania?

  7. 7. Czym różni się router.replace() od router.push() z hooka useRouter?

  8. 8. Jaki prefiks musi mieć zmienna środowiskowa, aby była dostępna po stronie klienta w Next.js?

  9. 9. Parallel Routes w App Routerze używają konwencji nazewnictwa:

  10. 10. Co się stanie, gdy w Next.js 16 wywołasz funkcję notFound() wewnątrz Server Component?

  11. 11. Dlaczego plik error.tsx w Next.js 16 musi być Client Component (z dyrektywą 'use client')?

  12. 12. Do czego najlepiej nadaje się plik template.tsx zamiast layout.tsx?

Zadania praktyczne w grze

  • Edytor kodu

    Utwórz catch-all route app/docs/[...slug]/page.js: wyeksportuj domyślnie async komponent DocsPage({ params }), odczytaj tablicę segmentów przez const { slug } = await params i wyświetl każdy segment URL w osobnym elemencie li listy ul.

  • Układanie w pionie

    Ułóż kolejność obsługi błędu przez plik error.js

  • Klikanie w kolejności

    Ułóż prawidłową ścieżkę do pliku catch-all route w Next.js

  • Układanie w pionie

    Ułóż składnię root layoutu (app/layout.tsx) w App Routerze

  • Układanie w pionie

    Ułóż kolejność generowania statycznych stron w App Routerze

  • Układanie w pionie

    Ułóż składnię root layout z tagami html i body

  • Klikanie w kolejności

    Ułóż prawidłową ścieżkę do dynamicznej strony produktu w App Routerze

  • Układanie w pionie

    Ułóż kolejność procesu Incremental Static Regeneration

  • Klikanie w kolejności

    Ułóż składnię usePathname w komponencie

  • Układanie w pionie

    Ułóż kroki nawigacji z komponentem Link: od pojawienia się linku na ekranie do aktualizacji strony

  • Układanie w pionie

    Ułóż kolejność rozwiązywania metadata w Next.js

  • Układanie w pionie

    Ułóż składnię importu i użycia hooka useRouter

  • Klikanie w kolejności

    Ułóż składnię generateMetadata

  • Układanie w pionie

    Ułóż kolejność optymalizacji fontu z next/font (od budowania do wyświetlenia tekstu)

  • Układanie w pionie

    Ułóż składnię użycia komponentu Script z Next.js

  • Układanie w pionie

    Ułóż kolejność renderowania Server Components

  1. PytanieMetadata w App Routerze
  2. PytaniePrivate Folders w App Routerze
  3. Zadanie z kodemPraktyka: Catch-all Route
  4. Ułóż w kolejnościObsługa błędów w error.js
  5. Kliknij w kolejnościSkładnia catch-all route
  6. Ułóż w kolejnościStruktura layout.tsx
  7. PytanieDomyślne renderowanie w App Routerze
  8. PytanieTworzenie Client Component
  9. Ułóż w kolejnościGenerowanie statycznych stron
  10. Ułóż w kolejnościRoot Layout z html i body
  11. PytaniePrefetching w Next.js
  12. Kliknij w kolejnościŚcieżka dynamicznej trasy produktu
  13. Ułóż w kolejnościProces ISR
  14. PytaniePlik uruchamiany przed obsługą żądania
  15. Kliknij w kolejnościSkładnia usePathname w komponencie
  16. Pytanierouter.push a router.replace
  17. Ułóż w kolejnościNawigacja z komponentem Link
  18. PytaniePubliczne zmienne środowiskowe w Next.js
  19. PytanieKonwencja Parallel Routes
  20. Ułóż w kolejnościRozwiązywanie metadata
  21. Ułóż w kolejnościImport i użycie useRouter
  22. Kliknij w kolejnościSkładnia generateMetadata
  23. Ułóż w kolejnościPipeline optymalizacji fontów
  24. Ułóż w kolejnościUżycie komponentu Script
  25. Ułóż w kolejnościCykl renderowania Server Components
  26. PytanieKomponent not-found.tsx w Next.js
  27. PytanieError Boundary z error.tsx
  28. PytanieZastosowanie template.tsx

Przydatne artykuły