Kurs Next.js · Moduł 2: Routing i layouty
Middleware i przechwytywanie żądań
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ć:
- Autoryzację dla stref chronionych
- Internacjonalizację i wykrywanie języka
- Ś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:
- Dopasowanie dokładne:
'/about' - Dopasowanie z parametrami:
'/blog/:path' - Dopasowanie z parametrami catch-all:
'/blog/:path*' - Kilka ścieżek naraz: tablica
['/dashboard/:path*', '/admin/:path*']albo grupa w nawiasach'/(dashboard|admin)/:path*' - 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:
Implementować zaawansowane systemy autoryzacji - weryfikować tokeny JWT, przekierowywać niezalogowanych użytkowników, kontrolować dostęp do chronionych zasobów.
Dodawać funkcje internacjonalizacji - wykrywać preferowany język użytkownika, przekierowywać do odpowiednich wersji językowych.
Personalizować doświadczenie użytkownika - dostosowywać treści na podstawie lokalizacji, preferencji i historii użytkownika.
Optymalizować wydajność - kontrolować nagłówki cachowania, modyfikować odpowiedzi, implementować rate limiting.
Integrować się z zewnętrznymi systemami - łączyć się z systemami analityki, uwierzytelniania i innymi usługami.
Przeprowadzać testy A/B - przydzielać użytkowników do grup testowych i personalizować doświadczenie.
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. Metadata w App Routerze definiuje się przez:
2. Private Folders w App Routerze oznacza się prefiksem:
3. Komponenty w App Routerze bez dyrektywy 'use client' domyślnie:
4. Aby stworzyć Client Component należy dodać:
5. Czym jest prefetching w Next.js?
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. Czym różni się router.replace() od router.push() z hooka useRouter?
8. Jaki prefiks musi mieć zmienna środowiskowa, aby była dostępna po stronie klienta w Next.js?
9. Parallel Routes w App Routerze używają konwencji nazewnictwa:
10. Co się stanie, gdy w Next.js 16 wywołasz funkcję notFound() wewnątrz Server Component?
11. Dlaczego plik error.tsx w Next.js 16 musi być Client Component (z dyrektywą 'use client')?
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
Zadania po tej lekcji
- PytanieMetadata w App Routerze
- PytaniePrivate Folders w App Routerze
- Zadanie z kodemPraktyka: Catch-all Route
- Ułóż w kolejnościObsługa błędów w error.js
- Kliknij w kolejnościSkładnia catch-all route
- Ułóż w kolejnościStruktura layout.tsx
- PytanieDomyślne renderowanie w App Routerze
- PytanieTworzenie Client Component
- Ułóż w kolejnościGenerowanie statycznych stron
- Ułóż w kolejnościRoot Layout z html i body
- PytaniePrefetching w Next.js
- Kliknij w kolejnościŚcieżka dynamicznej trasy produktu
- Ułóż w kolejnościProces ISR
- PytaniePlik uruchamiany przed obsługą żądania
- Kliknij w kolejnościSkładnia usePathname w komponencie
- Pytanierouter.push a router.replace
- Ułóż w kolejnościNawigacja z komponentem Link
- PytaniePubliczne zmienne środowiskowe w Next.js
- PytanieKonwencja Parallel Routes
- Ułóż w kolejnościRozwiązywanie metadata
- Ułóż w kolejnościImport i użycie useRouter
- Kliknij w kolejnościSkładnia generateMetadata
- Ułóż w kolejnościPipeline optymalizacji fontów
- Ułóż w kolejnościUżycie komponentu Script
- Ułóż w kolejnościCykl renderowania Server Components
- PytanieKomponent not-found.tsx w Next.js
- PytanieError Boundary z error.tsx
- PytanieZastosowanie template.tsx