Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Middleware do ochrony tras
W tej lekcji6
W poprzednich modułach poznaliśmy podstawy uwierzytelniania, podłączanie zewnętrznych dostawców, zarządzanie sesjami i implementację systemu ról i uprawnień. Teraz skupimy się na middleware - potężnym mechanizmie Next.js, który pozwala na wykonanie kodu przed dotarciem do żądania docelowego, co jest idealnym miejscem do implementacji ochrony tras.
Middleware w Next.js działa na poziomie serwera, ale jest wykonywane przed renderowaniem strony lub obsługą żądania API. Daje to możliwość centralnego zarządzania dostępem, przekierowywania, modyfikacji nagłówków i wielu innych operacji.
Podstawy middleware w Next.js
Zacznijmy od zrozumienia, jak działa middleware w Next.js:
- Lokalizacja - middleware jest definiowane w pliku
middleware.ts(lubmiddleware.js) w głównym katalogu projektu Next.js. Od Next.js 16 ten plik nazywa sięproxy.ts(z funkcjąproxy), nazwamiddlewarejest przestarzała, a proxy działa w środowisku Node.js. - Wykonanie - middleware uruchamia się przed zrenderowaniem strony lub obsługą żądania API.
- Dopasowanie - możesz określić, dla których ścieżek middleware powinno być wykonywane.
- Działanie - middleware może przekierować użytkownika, zmodyfikować żądanie/odpowiedź lub po prostu przejść do następnego kroku w łańcuchu przetwarzania.
Prosty przykład middleware:
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
export function middleware(request: NextRequest) {
console.log('Middleware uruchomione dla:', request.nextUrl.pathname);
// Kontynuuj normalne przetwarzanie żądania
return NextResponse.next();
}
// Zastosuj middleware tylko do określonych ścieżek
export const config = {
matcher: ['/dashboard/:path*', '/api/:path*'],
};Implementacja middleware do ochrony tras
Teraz przejdźmy do pełnej implementacji middleware do ochrony tras w aplikacji Next.js.
1. Podstawowe middleware uwierzytelniania
Zacznijmy od prostego middleware, które sprawdza, czy użytkownik jest zalogowany, i chroni określone ścieżki:
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { getToken } from 'next-auth/jwt';
export async function middleware(request: NextRequest) {
// Pobierz token sesji z ciasteczka
const token = await getToken({ req: request });
// Sprawdź, czy użytkownik jest zalogowany
const isLoggedIn = !!token;
// Aktualna ścieżka
const { pathname } = request.nextUrl;
// Ścieżki chronione - wymagające zalogowania
const protectedPaths = [
'/dashboard',
'/profile',
'/settings',
];
// Ścieżki tylko dla niezalogowanych (np. strona logowania)
const authPaths = ['/auth/login', '/auth/register'];
// Sprawdź, czy aktualna ścieżka jest chroniona
const isProtectedPath = protectedPaths.some(path =>
pathname === path || pathname.startsWith(`${path}/`)
);
// Sprawdź, czy aktualna ścieżka jest stroną uwierzytelniania
const isAuthPath = authPaths.some(path => pathname === path);
// Jeśli użytkownik próbuje dostać się do chronionej ścieżki, ale nie jest zalogowany
if (isProtectedPath && !isLoggedIn) {
// Przekieruj do strony logowania z informacją o docelowej ścieżce
const url = new URL('/auth/login', request.url);
url.searchParams.set('callbackUrl', encodeURI(pathname));
return NextResponse.redirect(url);
}
// Jeśli użytkownik jest zalogowany i próbuje dostać się do strony logowania/rejestracji
if (isAuthPath && isLoggedIn) {
// Przekieruj na dashboard
return NextResponse.redirect(new URL('/dashboard', request.url));
}
// W innych przypadkach kontynuuj normalne przetwarzanie
return NextResponse.next();
}
// Określ, dla których ścieżek middleware powinno być uruchamiane
export const config = {
matcher: [
/*
* Dopasuj wszystkie ścieżki z wyjątkiem:
* 1. Plików statycznych (np. /favicon.ico, /images/*, itd.)
* 2. API Route next-auth (/api/auth/*, które obsługuje samo uwierzytelnianie)
*/
'/((?!api/auth|_next/static|_next/image|favicon.ico).*)',
],
};2. Zaawansowane middleware z kontrolą ról i uprawnień
Rozbudujmy nasze middleware, aby uwzględniało również role i uprawnienia użytkowników:
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { getToken } from 'next-auth/jwt';
// Struktura opisująca wymagania dostępu dla ścieżki
interface PathConfig {
requireAuth: boolean; // Czy wymagane jest zalogowanie
roles?: string[]; // Dozwolone role (jeśli puste, wszystkie role mają dostęp)
permissions?: string[]; // Wymagane uprawnienia
}
// Konfiguracja dostępu do ścieżek
const pathAccessConfig: Record<string, PathConfig> = {
// Ścieżki administracyjne
'/admin': {
requireAuth: true,
roles: ['admin'],
},
// Ścieżki moderatorów
'/moderator': {
requireAuth: true,
roles: ['admin', 'moderator'],
},
// Ścieżki dashboard - wymagają zalogowania
'/dashboard': {
requireAuth: true,
},
// Strona zarządzania użytkownikami - wymaga uprawnienia user:manage
'/admin/users': {
requireAuth: true,
roles: ['admin'],
permissions: ['user:manage'],
},
// Ścieżki publiczne - dostępne dla wszystkich
'/': {
requireAuth: false,
},
'/about': {
requireAuth: false,
},
'/contact': {
requireAuth: false,
},
// Ścieżki uwierzytelniania - dostępne tylko dla niezalogowanych
'/auth/login': {
requireAuth: false,
},
'/auth/register': {
requireAuth: false,
},
};
// Funkcja pomocnicza do sprawdzania, czy ścieżka pasuje do konfiguracji
function matchPathConfig(pathname: string): [string, PathConfig] | null {
// Sprawdź dokładne dopasowanie
if (pathAccessConfig[pathname]) {
return [pathname, pathAccessConfig[pathname]];
}
// Sprawdź dopasowanie prefiksu
for (const configPath in pathAccessConfig) {
// Ignoruj dokładne dopasowania, ponieważ już je sprawdziliśmy
if (configPath === pathname) continue;
// Sprawdź, czy aktualna ścieżka zaczyna się od konfigurowanej ścieżki + /
if (pathname.startsWith(`${configPath}/`)) {
return [configPath, pathAccessConfig[configPath]];
}
}
// Brak dopasowania
return null;
}
export async function middleware(request: NextRequest) {
// Pobierz token sesji z ciasteczka
const token = await getToken({ req: request });
// Aktualna ścieżka
const { pathname } = request.nextUrl;
// Znajdź konfigurację dostępu dla aktualnej ścieżki
const pathMatch = matchPathConfig(pathname);
// Jeśli nie znaleziono konfiguracji dla tej ścieżki, kontynuuj normalne przetwarzanie
if (!pathMatch) {
return NextResponse.next();
}
const [configPath, config] = pathMatch;
// Strony uwierzytelniania - przekieruj do dashboard, jeśli użytkownik jest już zalogowany
if (
!config.requireAuth &&
(pathname === '/auth/login' || pathname === '/auth/register') &&
token
) {
return NextResponse.redirect(new URL('/dashboard', request.url));
}
// Jeśli ścieżka wymaga uwierzytelnienia, a użytkownik nie jest zalogowany
if (config.requireAuth && !token) {
// Przekieruj do strony logowania z informacją o docelowej ścieżce
const url = new URL('/auth/login', request.url);
url.searchParams.set('callbackUrl', pathname);
return NextResponse.redirect(url);
}
// Jeśli ścieżka wymaga określonych ról, sprawdź uprawnienia użytkownika
if (token && config.roles && config.roles.length > 0) {
const userRole = token.role as string;
if (!config.roles.includes(userRole)) {
// Użytkownik nie ma wymaganej roli - przekieruj do strony braku uprawnień
return NextResponse.redirect(new URL('/auth/unauthorized', request.url));
}
}
// Jeśli ścieżka wymaga określonych uprawnień, sprawdź uprawnienia użytkownika
if (token && config.permissions && config.permissions.length > 0) {
const userPermissions = token.permissions as string[] || [];
// Sprawdź, czy użytkownik ma wszystkie wymagane uprawnienia
const hasAllPermissions = config.permissions.every(permission =>
userPermissions.includes(permission)
);
if (!hasAllPermissions) {
// Użytkownik nie ma wymaganych uprawnień - przekieruj do strony braku uprawnień
return NextResponse.redirect(new URL('/auth/unauthorized', request.url));
}
}
// Wszystkie warunki spełnione - kontynuuj
return NextResponse.next();
}
// Dopasowanie dla wszystkich tras z wyjątkiem plików statycznych i API uwierzytelniania
export const config = {
matcher: [
'/((?!api/auth|_next/static|_next/image|images|favicon.ico).*)',
],
};3. Middleware dla uwierzytelniania API
Jak widać, opisane middleware działa dla stron, przekierowując użytkownika w przypadku braku uprawnień. W przypadku API routes powinniśmy zwrócić odpowiednie kody błędów, a nie przekierowywać użytkownika. Oto implementacja middleware specjalnie dla API:
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { getToken } from 'next-auth/jwt';
// Konfiguracja dostępu do tras API
const apiAccessConfig: Record<string, {
roles?: string[];
permissions?: string[];
}> = {
// API administratora
'/api/admin': {
roles: ['admin'],
},
// API moderatora
'/api/moderator': {
roles: ['admin', 'moderator'],
},
// API zarządzania użytkownikami
'/api/users': {
permissions: ['user:read'],
},
'/api/users/create': {
permissions: ['user:create'],
},
'/api/users/update': {
permissions: ['user:update'],
},
'/api/users/delete': {
permissions: ['user:delete'],
},
};
// Funkcja pomocnicza do sprawdzania, czy ścieżka API pasuje do konfiguracji
function matchApiConfig(pathname: string) {
// Sprawdź dokładne dopasowanie
if (apiAccessConfig[pathname]) {
return [pathname, apiAccessConfig[pathname]];
}
// Sprawdź dopasowanie prefiksu
for (const configPath in apiAccessConfig) {
if (pathname.startsWith(`${configPath}/`)) {
return [configPath, apiAccessConfig[configPath]];
}
}
return null;
}
export async function middleware(request: NextRequest) {
// Pobierz token sesji
const token = await getToken({ req: request });
// Aktualna ścieżka
const { pathname } = request.nextUrl;
// Sprawdź, czy to żądanie API
const isApiRequest = pathname.startsWith('/api/');
// Jeśli to nie jest API, przejdź do następnego middleware
if (!isApiRequest) {
return NextResponse.next();
}
// Pomiń routes uwierzytelniania
if (pathname.startsWith('/api/auth/')) {
return NextResponse.next();
}
// Jeśli to API i użytkownik nie jest zalogowany
if (!token) {
return NextResponse.json(
{ error: 'Unauthorized - Authentication required' },
{ status: 401 }
);
}
// Znajdź konfigurację dostępu dla tego endpointu API
const apiMatch = matchApiConfig(pathname);
// Jeśli brak konfiguracji, zakładamy, że wystarczy być zalogowanym
if (!apiMatch) {
return NextResponse.next();
}
const [configPath, config] = apiMatch;
// Sprawdź rolę użytkownika
if (config.roles && config.roles.length > 0) {
const userRole = token.role as string;
if (!config.roles.includes(userRole)) {
return NextResponse.json(
{ error: 'Forbidden - Insufficient role permissions' },
{ status: 403 }
);
}
}
// Sprawdź uprawnienia użytkownika
if (config.permissions && config.permissions.length > 0) {
const userPermissions = token.permissions as string[] || [];
const hasAllPermissions = config.permissions.every(permission =>
userPermissions.includes(permission)
);
if (!hasAllPermissions) {
return NextResponse.json(
{ error: 'Forbidden - Insufficient permissions' },
{ status: 403 }
);
}
}
// Wszystkie warunki spełnione
return NextResponse.next();
}
// Dopasowanie dla wszystkich tras API
export const config = {
matcher: ['/api/:path*'],
};4. Łączenie middleware dla stron i API
Możemy połączyć oba podejścia w jednym middleware:
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
import { getToken } from 'next-auth/jwt';
// Konfiguracja dostępu do stron
const pageAccessConfig: Record<string, {
requireAuth: boolean;
roles?: string[];
permissions?: string[];
}> = {
'/admin': { requireAuth: true, roles: ['admin'] },
'/moderator': { requireAuth: true, roles: ['admin', 'moderator'] },
'/dashboard': { requireAuth: true },
'/profile': { requireAuth: true },
'/settings': { requireAuth: true },
'/': { requireAuth: false },
'/about': { requireAuth: false },
'/auth/login': { requireAuth: false },
'/auth/register': { requireAuth: false },
};
// Konfiguracja dostępu do API
const apiAccessConfig: Record<string, {
roles?: string[];
permissions?: string[];
}> = {
'/api/admin': { roles: ['admin'] },
'/api/moderator': { roles: ['admin', 'moderator'] },
'/api/users': { permissions: ['user:read'] },
'/api/users/create': { permissions: ['user:create'] },
};
// Funkcje pomocnicze do dopasowywania ścieżek (pominięte dla zwięzłości)
//
export async function middleware(request: NextRequest) {
// Pobierz token sesji
const token = await getToken({ req: request });
const { pathname } = request.nextUrl;
// Sprawdź, czy to żądanie API
const isApiRequest = pathname.startsWith('/api/');
// Pomiń routes uwierzytelniania
if (pathname.startsWith('/api/auth/')) {
return NextResponse.next();
}
// Obsługa żądań API
if (isApiRequest) {
// Jeśli to API i użytkownik nie jest zalogowany (dla chronionych endpointów)
if (!token && !pathname.startsWith('/api/public/')) {
return NextResponse.json(
{ error: 'Unauthorized - Authentication required' },
{ status: 401 }
);
}
// Dopasuj konfigurację API
const apiMatch = matchApiConfig(pathname);
if (apiMatch && token) {
const [configPath, config] = apiMatch;
// Sprawdź role i uprawnienia
if (!hasRequiredRole(token, config.roles) ||
!hasRequiredPermissions(token, config.permissions)) {
return NextResponse.json(
{ error: 'Forbidden - Insufficient permissions' },
{ status: 403 }
);
}
}
}
// Obsługa stron
else {
// Dopasuj konfigurację strony
const pageMatch = matchPageConfig(pathname);
if (pageMatch) {
const [configPath, config] = pageMatch;
// Strony uwierzytelniania - przekieruj, jeśli użytkownik jest zalogowany
if (
!config.requireAuth &&
(pathname === '/auth/login' || pathname === '/auth/register') &&
token
) {
return NextResponse.redirect(new URL('/dashboard', request.url));
}
// Jeśli strona wymaga uwierzytelnienia, a użytkownik nie jest zalogowany
if (config.requireAuth && !token) {
const url = new URL('/auth/login', request.url);
url.searchParams.set('callbackUrl', pathname);
return NextResponse.redirect(url);
}
// Jeśli użytkownik jest zalogowany, sprawdź role i uprawnienia
if (token && config.requireAuth) {
if (!hasRequiredRole(token, config.roles) ||
!hasRequiredPermissions(token, config.permissions)) {
return NextResponse.redirect(new URL('/auth/unauthorized', request.url));
}
}
}
}
// Wszystkie warunki spełnione
return NextResponse.next();
}
// Funkcje pomocnicze do sprawdzania ról i uprawnień
function hasRequiredRole(token: any, requiredRoles?: string[]): boolean {
if (!requiredRoles || requiredRoles.length === 0) return true;
const userRole = token.role as string;
return requiredRoles.includes(userRole);
}
function hasRequiredPermissions(token: any, requiredPermissions?: string[]): boolean {
if (!requiredPermissions || requiredPermissions.length === 0) return true;
const userPermissions = token.permissions as string[] || [];
return requiredPermissions.every(permission => userPermissions.includes(permission));
}
// Funkcje dopasowujące konfigurację ścieżek (implementacja pominięta dla zwięzłości)
function matchPageConfig(pathname: string) { /* ... */ }
function matchApiConfig(pathname: string) { /* ... */ }
export const config = {
matcher: [
'/((?!_next/static|_next/image|images|favicon.ico).*)',
],
};Middleware dla obsługi konkretnych wzorów dostępu
Często potrzebujemy middleware, które obsługuje konkretne przypadki użycia. Przyjrzyjmy się niektórym przykładom:
1. Middleware do kontroli limitu żądań (Rate Limiting)
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
// Prosta implementacja limitu żądań w pamięci
// W produkcji należy użyć Redis lub podobnego rozwiązania
const REQUESTS_PER_MINUTE = 60;
const WINDOW_SIZE_MS = 60 * 1000; // 1 minuta
interface RateLimitState {
requests: number;
timestamp: number;
}
const ipRequestCounts = new Map<string, RateLimitState>();
export function middleware(request: NextRequest) {
// Pobierz adres IP użytkownika
const ip = request.ip || 'unknown';
// Sprawdź, czy to jest API
if (!request.nextUrl.pathname.startsWith('/api/')) {
return NextResponse.next();
}
// Pobierz aktualny stan limitów dla tego IP
const now = Date.now();
const state = ipRequestCounts.get(ip) || { requests: 0, timestamp: now };
// Jeśli upłynęło okno czasowe, zresetuj licznik
if (now - state.timestamp > WINDOW_SIZE_MS) {
state.requests = 0;
state.timestamp = now;
}
// Zwiększ licznik żądań
state.requests++;
ipRequestCounts.set(ip, state);
// Jeśli przekroczono limit, zwróć błąd 429 (Too Many Requests)
if (state.requests > REQUESTS_PER_MINUTE) {
const response = NextResponse.json(
{ error: 'Rate limit exceeded. Please try again later.' },
{ status: 429 }
);
// Ustaw nagłówki informujące o limitach
response.headers.set('X-RateLimit-Limit', REQUESTS_PER_MINUTE.toString());
response.headers.set('X-RateLimit-Remaining', '0');
response.headers.set('Retry-After',
Math.ceil((state.timestamp + WINDOW_SIZE_MS - now) / 1000).toString()
);
return response;
}
// W granicach limitu - kontynuuj
const response = NextResponse.next();
// Ustaw nagłówki informujące o limitach
response.headers.set('X-RateLimit-Limit', REQUESTS_PER_MINUTE.toString());
response.headers.set(
'X-RateLimit-Remaining',
Math.max(0, REQUESTS_PER_MINUTE - state.requests).toString()
);
return response;
}
export const config = {
matcher: ['/api/:path*'],
};2. Middleware dla geolokalizacji (Country-based access)
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
// Lista dozwolonych kodów krajów
const ALLOWED_COUNTRIES = ['US', 'CA', 'GB', 'DE', 'FR', 'PL'];
// Lista stron objętych restrykcjami geograficznymi
const GEO_RESTRICTED_PATHS = [
'/premium-content',
'/members-only',
];
export function middleware(request: NextRequest) {
// Sprawdź, czy ścieżka podlega restrykcjom geograficznym
const isGeoRestrictedPath = GEO_RESTRICTED_PATHS.some(path =>
request.nextUrl.pathname === path ||
request.nextUrl.pathname.startsWith(`${path}/`)
);
if (isGeoRestrictedPath) {
// Pobierz informacje o kraju użytkownika z nagłówków (dostępne na platformie Vercel)
const country = request.geo?.country || 'Unknown';
// Jeśli kraj użytkownika nie jest na liście dozwolonych
if (!ALLOWED_COUNTRIES.includes(country)) {
return NextResponse.redirect(new URL('/geo-restricted', request.url));
}
}
return NextResponse.next();
}
export const config = {
matcher: [
'/premium-content/:path*',
'/members-only/:path*',
],
};3. Middleware dla modyfikacji nagłówków bezpieczeństwa
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
export function middleware(request: NextRequest) {
// Pobierz oryginalną odpowiedź
const response = NextResponse.next();
// Dodaj nagłówki bezpieczeństwa
// Chroń przed atakami XSS
response.headers.set('X-XSS-Protection', '1; mode=block');
// Zapobiegaj "sniffing" MIME typów
response.headers.set('X-Content-Type-Options', 'nosniff');
// Kontroluj, jak strona może być osadzona w iframe
response.headers.set('X-Frame-Options', 'SAMEORIGIN');
// Content Security Policy - bardziej zaawansowana ochrona przed XSS
response.headers.set(
'Content-Security-Policy',
"default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com; img-src 'self' data: https:; connect-src 'self' https://api.example.com;"
);
// HTTP Strict Transport Security - wymusza użycie HTTPS
response.headers.set(
'Strict-Transport-Security',
'max-age=31536000; includeSubDomains; preload'
);
// Permissions Policy - ogłoś, które funkcje przeglądarki są dozwolone
response.headers.set(
'Permissions-Policy',
'camera=(), microphone=(), geolocation=(self), interest-cohort=()'
);
return response;
}
export const config = {
matcher: [
'/((?!_next/static|_next/image|images|favicon.ico).*)',
],
};4. Middleware dla A/B testowania
// middleware.ts
import { NextResponse } from 'next/server';
import type { NextRequest } from 'next/server';
// Konfiguracja eksperymentów A/B
const AB_TESTS = {
'new-landing-page': {
variants: ['control', 'variant-a', 'variant-b'],
weights: [0.34, 0.33, 0.33], // Podział ruchu
paths: ['/'], // Ścieżki objęte testem
cookieName: 'ab-new-landing',
},
'checkout-flow': {
variants: ['original', 'simplified'],
weights: [0.5, 0.5],
paths: ['/checkout', '/cart'],
cookieName: 'ab-checkout',
},
};
export function middleware(request: NextRequest) {
const url = request.nextUrl;
const response = NextResponse.next();
// Iteruj przez zdefiniowane testy
for (const [testName, test] of Object.entries(AB_TESTS)) {
// Sprawdź, czy aktualna ścieżka jest objęta testem
const isTestPath = test.paths.some(path =>
url.pathname === path || url.pathname.startsWith(`${path}/`)
);
if (isTestPath) {
// Sprawdź, czy użytkownik ma już przypisany wariant testu
const existingVariant = request.cookies.get(test.cookieName)?.value;
let variant = existingVariant;
// Jeśli użytkownik nie ma przypisanego wariantu, przydziel nowy
if (!variant) {
variant = assignVariant(test.variants, test.weights);
// Ustaw ciasteczko z przypisanym wariantem
response.cookies.set(test.cookieName, variant, {
maxAge: 60 * 60 * 24 * 30, // 30 dni
path: '/',
});
}
// Dodaj nagłówek z informacją o wariancie testu
response.headers.set(`X-AB-Test-${testName}`, variant);
// Możesz również ustawić rewrite do innej strony dla różnych wariantów
if (testName === 'new-landing-page' && url.pathname === '/') {
if (variant === 'variant-a') {
// Przekierowanie wewnętrzne (niewidoczne dla użytkownika)
return NextResponse.rewrite(new URL('/landing-a', request.url));
} else if (variant === 'variant-b') {
return NextResponse.rewrite(new URL('/landing-b', request.url));
}
}
}
}
return response;
}
// Funkcja przydzielająca wariant na podstawie wag
function assignVariant(variants: string[], weights: number[]): string {
const randomNum = Math.random();
let cumulativeWeight = 0;
for (let i = 0; i < variants.length; i++) {
cumulativeWeight += weights[i];
if (randomNum < cumulativeWeight) {
return variants[i];
}
}
// Fallback na pierwszy wariant
return variants[0];
}
export const config = {
matcher: [
'/', '/checkout', '/cart',
'/landing-a', '/landing-b',
],
};Testowanie middleware
Testy są bardzo ważne dla sprawdzenia poprawności działania middleware, zwłaszcza że obsługuje ono kluczowe aspekty bezpieczeństwa aplikacji. Oto prosty przykład testów jednostkowych:
// __tests__/middleware.test.ts
import { NextRequest } from 'next/server';
import { middleware } from '../middleware';
import { getToken } from 'next-auth/jwt';
// Mockujemy getToken z next-auth/jwt
jest.mock('next-auth/jwt', () => ({
getToken: jest.fn(),
}));
describe('Auth Middleware', () => {
// Setup i reset przed każdym testem
beforeEach(() => {
jest.clearAllMocks();
});
it('should redirect unauthenticated user from protected route to login page', async () => {
// Mockuj getToken zwracający null (niezalogowany użytkownik)
(getToken as jest.Mock).mockResolvedValueOnce(null);
// Utwórz testowy request do chronionej ścieżki
const req = new NextRequest(new URL('http://localhost:3000/dashboard'));
// Uruchom middleware
const response = await middleware(req);
// Sprawdź, czy przekierowuje do strony logowania
expect(response).not.toBeNull();
expect(response.status).toBe(307); // Kod przekierowania
expect(response.headers.get('location')).toBe('http://localhost:3000/auth/login?callbackUrl=%2Fdashboard');
});
it('should allow authenticated user to access protected route', async () => {
// Mockuj getToken zwracający token (zalogowany użytkownik)
(getToken as jest.Mock).mockResolvedValueOnce({
name: 'Test User',
email: 'test@example.com',
role: 'user',
permissions: ['content:read']
});
// Utwórz testowy request do chronionej ścieżki
const req = new NextRequest(new URL('http://localhost:3000/dashboard'));
// Uruchom middleware
const response = await middleware(req);
// Sprawdź, czy zezwala na dostęp
expect(response).not.toBeNull();
expect(response.status).toBe(200);
});
it('should redirect authenticated user from login page to dashboard', async () => {
// Mockuj getToken zwracający token (zalogowany użytkownik)
(getToken as jest.Mock).mockResolvedValueOnce({
name: 'Test User',
email: 'test@example.com',
});
// Utwórz testowy request do strony logowania
const req = new NextRequest(new URL('http://localhost:3000/auth/login'));
// Uruchom middleware
const response = await middleware(req);
// Sprawdź, czy przekierowuje do dashboardu
expect(response).not.toBeNull();
expect(response.status).toBe(307);
expect(response.headers.get('location')).toBe('http://localhost:3000/dashboard');
});
it('should redirect user without admin role from admin page', async () => {
// Mockuj getToken zwracający token z rolą user
(getToken as jest.Mock).mockResolvedValueOnce({
name: 'Test User',
email: 'test@example.com',
role: 'user',
permissions: ['content:read']
});
// Utwórz testowy request do strony administratora
const req = new NextRequest(new URL('http://localhost:3000/admin/dashboard'));
// Uruchom middleware
const response = await middleware(req);
// Sprawdź, czy przekierowuje do strony braku uprawnień
expect(response).not.toBeNull();
expect(response.status).toBe(307);
expect(response.headers.get('location')).toBe('http://localhost:3000/auth/unauthorized');
});
});Dobre praktyki i wzorce
1. Optymalizacja wydajności middleware
Middleware jest wykonywane przy każdym żądaniu, więc ważne jest, aby było jak najbardziej wydajne:
- Ogranicz wywołania zewnętrznych API - Middleware powinno być szybkie. Unikaj wywołań API w middleware, jeśli to możliwe.
- Używaj cachowania - Jeśli musisz pobierać dane, rozważ ich cachowanie.
- Precyzyjnie definiuj matcher - Ograniczaj działanie middleware tylko do ścieżek, które go potrzebują.
2. Debugging middleware
Debugging middleware może być trudny, ponieważ działa "za kulisami":
- Dodaj logi - Użyj
console.log()do śledzenia działania middleware. - Dodaj nagłówki debugowania - Możesz dodać niestandardowe nagłówki do odpowiedzi, aby śledzić co się dzieje.
// Przykład dodawania nagłówków debugowania
const response = NextResponse.next();
response.headers.set('X-Debug-Path', request.nextUrl.pathname);
response.headers.set('X-Debug-Auth', token ? 'Authenticated' : 'Unauthenticated');
return response;3. Organizacja kodu middleware
Dla złożonych aplikacji warto rozważyć modularyzację middleware:
// middleware/auth.ts
import { NextRequest, NextResponse } from 'next/server';
import { getToken } from 'next-auth/jwt';
export async function authMiddleware(req: NextRequest) {
// Implementacja middleware uwierzytelniania
//
}
// middleware/security.ts
import { NextRequest, NextResponse } from 'next/server';
export function securityHeadersMiddleware(req: NextRequest) {
// Implementacja middleware nagłówków bezpieczeństwa
//
}
// middleware.ts
import { NextRequest, NextResponse } from 'next/server';
import { authMiddleware } from './middleware/auth';
import { securityHeadersMiddleware } from './middleware/security';
export async function middleware(req: NextRequest) {
// Sprawdź, czy ścieżka wymaga uwierzytelniania
if (req.nextUrl.pathname.startsWith('/dashboard') ||
req.nextUrl.pathname.startsWith('/admin')) {
return await authMiddleware(req);
}
// Dodaj nagłówki bezpieczeństwa do wszystkich odpowiedzi
return securityHeadersMiddleware(req);
}
export const config = { /* ... */ };Podsumowanie
Middleware w Next.js oferuje potężny mechanizm do implementacji ochrony tras i wielu innych funkcji na poziomie serwera. W tym module poznaliśmy:
- Podstawy middleware w Next.js - jak działa i jak go skonfigurować
- Implementację middleware uwierzytelniania - jak chronić trasy przed nieautoryzowanym dostępem
- Middleware z kontrolą ról i uprawnień - jak zapewniać dostęp na podstawie ról użytkowników
- Specjalizowane middleware - jak implementować rate limiting, geolokalizację, nagłówki bezpieczeństwa i A/B testy
- Testowanie middleware - jak pisać testy do middleware
- Dobre praktyki i wzorce - jak optymalizować i organizować kod middleware
Dobra implementacja middleware jest kluczowym elementem bezpieczeństwa i wydajności aplikacji Next.js. Dzięki technikom przedstawionym w tym module, możesz tworzyć zaawansowane, wielowarstwowe zabezpieczenia dla swoich aplikacji.
W następnym module przejdziemy do implementacji Context Provider dla uwierzytelniania, co umożliwi łatwy dostęp do danych uwierzytelniania w całej aplikacji.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Demo: Middleware do ochrony tras w Next.js
interface Route {
path: string;
label: string;
isProtected: boolean;
requiredRole?: string;
icon: string;
}
const routes: Route[] = [
{ path: '/', label: 'Strona glowna', isProtected: false, icon: 'H' },
{ path: '/about', label: 'O nas', isProtected: false, icon: 'A' },
{ path: '/dashboard', label: 'Dashboard', isProtected: true, requiredRole: 'user', icon: 'D' },
{ path: '/admin', label: 'Panel Admin', isProtected: true, requiredRole: 'admin', icon: 'S' },
{ path: '/admin/users', label: 'Uzytkownicy', isProtected: true, requiredRole: 'admin', icon: 'U' },
{ path: '/api/data', label: 'API: Dane', isProtected: true, requiredRole: 'user', icon: 'P' },
{ path: '/login', label: 'Logowanie', isProtected: false, icon: 'L' },
{ path: '/profile', label: 'Profil', isProtected: true, requiredRole: 'user', icon: 'R' },
];
function MiddlewareDemo() {
const [isLoggedIn, setIsLoggedIn] = useState(false);
const [userRole, setUserRole] = useState<'user' | 'admin'>('user');
const [requestLog, setRequestLog] = useState<{ path: string; result: string; color: string }[]>([]);
const simulateRequest = (route: Route) => {
let result = '';
let color = '';
if (!route.isProtected) {
result = '200 OK - Strona publiczna';
color = '#10b981';
} else if (!isLoggedIn) {
result = '302 Redirect -> /login (brak tokenu)';
color = '#f59e0b';
} else if (route.requiredRole === 'admin' && userRole !== 'admin') {
result = '403 Forbidden - wymagana rola: admin';
color = '#ef4444';
} else {
result = '200 OK - Dostep przyznany (' + userRole + ')';
color = '#10b981';
}
setRequestLog(prev => [{ path: route.path, result, color }, ...prev.slice(0, 9)]);
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Middleware - Ochrona Tras</h1>
<p style={{ color: '#8892b0', marginBottom: '24px' }}>Symulacja middleware Next.js do ochrony tras</p>
<div style={{ display: 'flex', gap: '16px', marginBottom: '24px', alignItems: 'center', flexWrap: 'wrap' }}>
<label style={{ display: 'flex', alignItems: 'center', gap: '8px', cursor: 'pointer' }}>
<input type="checkbox" checked={isLoggedIn} onChange={e => setIsLoggedIn(e.target.checked)} />
<span>Zalogowany</span>
</label>
{isLoggedIn && (
<select value={userRole} onChange={e => setUserRole(e.target.value as 'user' | 'admin')} style={{ padding: '6px 12px', borderRadius: '6px', background: '#1a1a2e', color: '#fff', border: '1px solid #333' }}>
<option value="user">user</option>
<option value="admin">admin</option>
</select>
)}
</div>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
<div>
<h3 style={{ color: '#64ffda', fontSize: '16px' }}>Trasy</h3>
{routes.map(route => (
<button key={route.path} onClick={() => simulateRequest(route)} style={{
display: 'block', width: '100%', padding: '12px', marginBottom: '8px', borderRadius: '8px', border: '1px solid #333',
background: '#1a1a2e', color: '#e0e0e0', cursor: 'pointer', textAlign: 'left',
}}>
<code style={{ color: '#64ffda' }}>{route.path}</code>
<div style={{ fontSize: '12px', color: '#8892b0' }}>
{route.isProtected ? 'Chroniona (rola: ' + route.requiredRole + ')' : 'Publiczna'}
</div>
</button>
))}
</div>
<div>
<h3 style={{ color: '#64ffda', fontSize: '16px' }}>Log zapytan</h3>
{requestLog.map((log, i) => (
<div key={i} style={{ padding: '10px', borderRadius: '6px', background: '#1a1a2e', border: '1px solid #333', marginBottom: '8px', fontSize: '13px' }}>
<code style={{ color: '#64ffda' }}>{log.path}</code>
<div style={{ color: log.color, marginTop: '4px' }}>{log.result}</div>
</div>
))}
{requestLog.length === 0 && <p style={{ color: '#555' }}>Kliknij na trase, aby symulowac zapytanie</p>}
</div>
</div>
</div>
);
}
export default MiddlewareDemo;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. bcrypt używa się do:
2. Refresh tokens służą do:
Zadania praktyczne w grze
- Edytor kodu
Stwórz panel kontrolny z systemem uprawnień i middleware
- Klikanie w kolejności
Ułóż składnię middleware sprawdzającego sesję w Next.js
- Edytor kodu
Utwórz system weryfikacji email z token generation, email sending i verification endpoint
- Układanie w pionie
Uporządkuj etapy audytu zdarzeń uwierzytelniania: