Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja

Middleware do ochrony tras

18 min czytania ·
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:

  1. Lokalizacja - middleware jest definiowane w pliku middleware.ts (lub middleware.js) w głównym katalogu projektu Next.js. Od Next.js 16 ten plik nazywa się proxy.ts (z funkcją proxy), nazwa middleware jest przestarzała, a proxy działa w środowisku Node.js.
  2. Wykonanie - middleware uruchamia się przed zrenderowaniem strony lub obsługą żądania API.
  3. Dopasowanie - możesz określić, dla których ścieżek middleware powinno być wykonywane.
  4. 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:

  1. Podstawy middleware w Next.js - jak działa i jak go skonfigurować
  2. Implementację middleware uwierzytelniania - jak chronić trasy przed nieautoryzowanym dostępem
  3. Middleware z kontrolą ról i uprawnień - jak zapewniać dostęp na podstawie ról użytkowników
  4. Specjalizowane middleware - jak implementować rate limiting, geolokalizację, nagłówki bezpieczeństwa i A/B testy
  5. Testowanie middleware - jak pisać testy do middleware
  6. 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. 1. bcrypt używa się do:

  2. 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:

  1. Pytaniebcrypt używa się do:
  2. PytanieRefresh tokens służą do:
  3. Zadanie z kodemPraktyka: Panel administracyjny z middleware
  4. Kliknij w kolejnościMiddleware sprawdzający sesję
  5. Zadanie z kodemPraktyka: Utwórz system weryfikacji email z token
  6. Ułóż w kolejnościEtapy audytu zdarzeń uwierzytelniania

Przydatne artykuły