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

Podstawy uwierzytelniania w aplikacjach Next.js

12 min czytania ·
W tej lekcji8

Uwierzytelnianie (ang. authentication) to fundamentalny aspekt nowoczesnych aplikacji webowych. Pozwala zweryfikować tożsamość użytkowników, co jest niezbędne do personalizacji doświadczeń, ochrony danych i udostępniania funkcji tylko uprawnionym osobom. W tym module poznamy podstawy implementacji uwierzytelniania w aplikacjach Next.js, które łączy zalety renderowania po stronie serwera (SSR) i klienta.

Czym jest uwierzytelnianie i dlaczego jest ważne?

Uwierzytelnianie to proces weryfikacji tożsamości użytkownika. Jest to kluczowy element zabezpieczeń aplikacji internetowych, ponieważ:

  1. Chroni dane użytkowników - zapewnia, że osobiste informacje są dostępne tylko dla ich właścicieli
  2. Umożliwia personalizację - pozwala na dostosowanie doświadczenia do konkretnego użytkownika
  3. Kontroluje dostęp - określa, do jakich zasobów i funkcji użytkownik ma dostęp
  4. Zapewnia odpowiedzialność - umożliwia śledzenie, kto i kiedy wykonywał określone działania

Uwierzytelnianie vs. Autoryzacja

Ważne jest rozróżnienie dwóch powiązanych, ale oddzielnych koncepcji:

  • Uwierzytelnianie (Authentication) - weryfikacja tożsamości użytkownika ("Czy jesteś tym, za kogo się podajesz?")
  • Autoryzacja (Authorization) - określanie, co uwierzytelniony użytkownik może robić ("Czy masz prawo to zrobić?")

W wielu przypadkach oba te procesy są ze sobą powiązane, ale pełnią różne funkcje w architekturze bezpieczeństwa.

Specyfika uwierzytelniania w Next.js

Next.js oferuje hybrydowy model renderowania, co ma znaczący wpływ na implementację uwierzytelniania:

  1. Renderowanie po stronie serwera (SSR) - umożliwia weryfikację uwierzytelnienia przed wysłaniem strony do klienta
  2. Statyczna generacja stron (SSG) - wymaga dodatkowej weryfikacji klienta dla chronionych treści
  3. Komponent App Router - zapewnia nowe, dedykowane mechanizmy do obsługi uwierzytelniania

Podstawowe modele uwierzytelniania

W aplikacjach Next.js można zastosować kilka głównych modeli uwierzytelniania:

1. Uwierzytelnianie oparte na sesji

Tradycyjne podejście polegające na utrzymywaniu stanu sesji na serwerze:

// Przykład API route do logowania z sesją
import { NextApiRequest, NextApiResponse } from 'next';
import { getServerSession } from 'next-auth/next';
import { authOptions } from '../auth/[...nextauth]';

export default async function handler(req: NextApiRequest, res: NextApiResponse) {
  const session = await getServerSession(req, res, authOptions);

  if (!session) {
    return res.status(401).json({ message: 'Unauthorized' });
  }

  // Użytkownik uwierzytelniony, można kontynuować
  return res.status(200).json({ user: session.user });
}

2. Uwierzytelnianie oparte na tokenach (JWT)

Popularne podejście wykorzystujące tokeny JWT (JSON Web Tokens):

// Przykład API route do weryfikacji tokenu JWT
import { NextApiRequest, NextApiResponse } from 'next';
import jwt from 'jsonwebtoken';

export default function handler(req: NextApiRequest, res: NextApiResponse) {
  const { authorization } = req.headers;

  if (!authorization || !authorization.startsWith('Bearer ')) {
    return res.status(401).json({ message: 'Unauthorized' });
  }

  const token = authorization.replace('Bearer ', '');

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET!);
    // Token prawidłowy, można kontynuować
    return res.status(200).json({ user: decoded });
  } catch (error) {
    return res.status(401).json({ message: 'Invalid token' });
  }
}

3. Uwierzytelnianie z zewnętrznymi dostawcami (OAuth)

Wykorzystanie serwisów zewnętrznych jak Google, Facebook czy GitHub:

// Przykład konfiguracji NextAuth.js z uwierzytelnianiem Google
import NextAuth from 'next-auth';
import GoogleProvider from 'next-auth/providers/google';

export default NextAuth({
  providers: [
    GoogleProvider({
      clientId: process.env.GOOGLE_CLIENT_ID!,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET!
    })
  ],
  // Dodatkowa konfiguracja...
});

Implementacja uwierzytelniania w Next.js App Router

W nowszych wersjach Next.js (13+) z App Router, podejście do uwierzytelniania zostało ulepszone. Poniżej przedstawiamy podstawowe kroki:

1. Konfiguracja dostawcy uwierzytelniania

Najpierw musimy skonfigurować dostawcę uwierzytelniania. W tym przykładzie użyjemy Auth.js (dawniej NextAuth.js):

// app/api/auth/[...nextauth]/route.ts
import NextAuth from 'next-auth';
import CredentialsProvider from 'next-auth/providers/credentials';
import { compare } from 'bcrypt';
import { prisma } from '@/lib/prisma';

export const authOptions = {
  providers: [
    CredentialsProvider({
      name: 'Credentials',
      credentials: {
        email: { label: "Email", type: "email" },
        password: { label: "Password", type: "password" }
      },
      async authorize(credentials) {
        if (!credentials?.email || !credentials?.password) {
          return null;
        }

        const user = await prisma.user.findUnique({
          where: {
            email: credentials.email
          }
        });

        if (!user) {
          return null;
        }

        const isPasswordValid = await compare(
          credentials.password,
          user.password
        );

        if (!isPasswordValid) {
          return null;
        }

        return {
          id: user.id,
          email: user.email,
          name: user.name
        };
      }
    })
  ],
  pages: {
    signIn: '/login',
    signOut: '/logout',
    error: '/login',
  },
  session: {
    strategy: 'jwt'
  }
};

const handler = NextAuth(authOptions);
export { handler as GET, handler as POST };

2. Tworzenie komponentów do logowania i rejestracji

Następnie potrzebujemy interfejsu użytkownika do logowania:

// app/login/page.tsx
'use client';

import { useState } from 'react';
import { signIn } from 'next-auth/react';
import { useRouter } from 'next/navigation';

export default function LoginPage() {
  const router = useRouter();
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const [error, setError] = useState('');
  const [loading, setLoading] = useState(false);

  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    setLoading(true);
    setError('');

    try {
      const result = await signIn('credentials', {
        redirect: false,
        email,
        password
      });

      if (result?.error) {
        setError('Nieprawidłowy email lub hasło');
      } else {
        router.push('/dashboard');
        router.refresh();
      }
    } catch (error) {
      setError('Wystąpił błąd podczas logowania');
    } finally {
      setLoading(false);
    }
  }

  return (
    <div className="max-w-md mx-auto mt-10 p-6 bg-white rounded-lg shadow-md">
      <h1 className="text-2xl font-bold mb-6">Logowanie</h1>

      {error && (
        <div className="mb-4 p-3 bg-red-100 text-red-700 rounded">
          {error}
        </div>
      )}

      <form onSubmit={handleSubmit} className="space-y-4">
        <div>
          <label htmlFor="email" className="block text-sm font-medium mb-1">
            Email
          </label>
          <input
            id="email"
            type="email"
            value={email}
            onChange={(e) => setEmail(e.target.value)}
            required
            className="w-full px-3 py-2 border border-gray-300 rounded"
          />
        </div>

        <div>
          <label htmlFor="password" className="block text-sm font-medium mb-1">
            Hasło
          </label>
          <input
            id="password"
            type="password"
            value={password}
            onChange={(e) => setPassword(e.target.value)}
            required
            className="w-full px-3 py-2 border border-gray-300 rounded"
          />
        </div>

        <button
          type="submit"
          disabled={loading}
          className="w-full bg-blue-500 text-white py-2 px-4 rounded hover:bg-blue-600 disabled:opacity-50"
        >
          {loading ? 'Logowanie...' : 'Zaloguj się'}
        </button>
      </form>
    </div>
  );
}

Oraz stronę do rejestracji:

// app/register/page.tsx
'use client';

import { useState } from 'react';
import { useRouter } from 'next/navigation';

export default function RegisterPage() {
  const router = useRouter();
  const [name, setName] = useState('');
  const [email, setEmail] = useState('');
  const [password, setPassword] = useState('');
  const [confirmPassword, setConfirmPassword] = useState('');
  const [error, setError] = useState('');
  const [loading, setLoading] = useState(false);

  async function handleSubmit(e: React.FormEvent) {
    e.preventDefault();
    setLoading(true);
    setError('');

    // Walidacja formularza
    if (password !== confirmPassword) {
      setError('Hasła nie są identyczne');
      setLoading(false);
      return;
    }

    try {
      const response = await fetch('/api/register', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ name, email, password })
      });

      const data = await response.json();

      if (!response.ok) {
        throw new Error(data.message || 'Wystąpił błąd podczas rejestracji');
      }

      // Rejestracja pomyślna, przekieruj do strony logowania
      router.push('/login?registered=true');
    } catch (error) {
      setError(error instanceof Error ? error.message : 'Wystąpił błąd');
    } finally {
      setLoading(false);
    }
  }

  return (
    <div className="max-w-md mx-auto mt-10 p-6 bg-white rounded-lg shadow-md">
      <h1 className="text-2xl font-bold mb-6">Rejestracja</h1>

      {error && (
        <div className="mb-4 p-3 bg-red-100 text-red-700 rounded">
          {error}
        </div>
      )}

      <form onSubmit={handleSubmit} className="space-y-4">
        <div>
          <label htmlFor="name" className="block text-sm font-medium mb-1">
            Imię i nazwisko
          </label>
          <input
            id="name"
            type="text"
            value={name}
            onChange={(e) => setName(e.target.value)}
            required
            className="w-full px-3 py-2 border border-gray-300 rounded"
          />
        </div>

        <div>
          <label htmlFor="email" className="block text-sm font-medium mb-1">
            Email
          </label>
          <input
            id="email"
            type="email"
            value={email}
            onChange={(e) => setEmail(e.target.value)}
            required
            className="w-full px-3 py-2 border border-gray-300 rounded"
          />
        </div>

        <div>
          <label htmlFor="password" className="block text-sm font-medium mb-1">
            Hasło
          </label>
          <input
            id="password"
            type="password"
            value={password}
            onChange={(e) => setPassword(e.target.value)}
            required
            minLength={8}
            className="w-full px-3 py-2 border border-gray-300 rounded"
          />
        </div>

        <div>
          <label htmlFor="confirmPassword" className="block text-sm font-medium mb-1">
            Potwierdź hasło
          </label>
          <input
            id="confirmPassword"
            type="password"
            value={confirmPassword}
            onChange={(e) => setConfirmPassword(e.target.value)}
            required
            className="w-full px-3 py-2 border border-gray-300 rounded"
          />
        </div>

        <button
          type="submit"
          disabled={loading}
          className="w-full bg-blue-500 text-white py-2 px-4 rounded hover:bg-blue-600 disabled:opacity-50"
        >
          {loading ? 'Rejestracja...' : 'Zarejestruj się'}
        </button>
      </form>
    </div>
  );
}

3. Implementacja API endpointu do rejestracji

Aby umożliwić rejestrację, potrzebujemy endpointu API:

// app/api/register/route.ts
import { NextResponse } from 'next/server';
import { hash } from 'bcrypt';
import { prisma } from '@/lib/prisma';
import { z } from 'zod';

// Schemat walidacji
const UserSchema = z.object({
  name: z.string().min(2, 'Imię musi mieć co najmniej 2 znaki'),
  email: z.string().email('Nieprawidłowy adres email'),
  password: z.string().min(8, 'Hasło musi mieć co najmniej 8 znaków')
});

export async function POST(request: Request) {
  try {
    const body = await request.json();

    // Walidacja danych
    const result = UserSchema.safeParse(body);

    if (!result.success) {
      return NextResponse.json(
        { message: result.error.errors[0].message },
        { status: 400 }
      );
    }

    const { name, email, password } = result.data;

    // Sprawdź, czy użytkownik już istnieje
    const existingUser = await prisma.user.findUnique({
      where: { email }
    });

    if (existingUser) {
      return NextResponse.json(
        { message: 'Użytkownik o podanym adresie email już istnieje' },
        { status: 409 }
      );
    }

    // Haszowanie hasła
    const hashedPassword = await hash(password, 10);

    // Utworzenie nowego użytkownika
    const user = await prisma.user.create({
      data: {
        name,
        email,
        password: hashedPassword
      }
    });

    // Zwróć odpowiedź bez hasła
    const { password: _, ...userWithoutPassword } = user;

    return NextResponse.json(
      { message: 'Rejestracja zakończona pomyślnie', user: userWithoutPassword },
      { status: 201 }
    );
  } catch (error) {
    console.error('Registration error:', error);
    return NextResponse.json(
      { message: 'Wystąpił błąd serwera' },
      { status: 500 }
    );
  }
}

4. Zabezpieczenie stron chronionych

Aby zabezpieczyć strony, które powinny być dostępne tylko dla zalogowanych użytkowników, możemy użyć middleware:

// 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) {
  const token = await getToken({ req: request });

  // Sprawdź, czy użytkownik jest zalogowany
  if (!token) {
    const url = new URL('/login', request.url);
    url.searchParams.set('callbackUrl', request.nextUrl.pathname);
    return NextResponse.redirect(url);
  }

  return NextResponse.next();
}

// Określ ścieżki, które mają być chronione
export const config = {
  matcher: ['/dashboard/:path*', '/profile/:path*', '/settings/:path*']
};

5. Wyświetlanie danych użytkownika i zarządzanie sesją

Aby wykorzystać informacje o zalogowanym użytkowniku w komponencie, możemy użyć hooka useSession:

// components/ProfileSection.tsx
'use client';

import { useSession } from 'next-auth/react';
import { signOut } from 'next-auth/react';

export default function ProfileSection() {
  const { data: session, status } = useSession();

  if (status === 'loading') {
    return <div>Ładowanie...</div>;
  }

  if (status === 'unauthenticated' || !session) {
    return <div>Nie jesteś zalogowany</div>;
  }

  return (
    <div className="p-4 bg-white rounded shadow">
      <h2 className="text-xl font-bold mb-4">Twój profil</h2>
      <p>Witaj, {session.user?.name || 'użytkowniku'}!</p>
      <p>Email: {session.user?.email}</p>

      <button
        onClick={() => signOut({ callbackUrl: '/' })}
        className="mt-4 px-4 py-2 bg-red-500 text-white rounded hover:bg-red-600"
      >
        Wyloguj się
      </button>
    </div>
  );
}

6. Inicjalizacja SessionProvider dla całej aplikacji

Aby uwierzytelnianie działało poprawnie, musimy dodać SessionProvider na poziomie layoutu:

// app/providers.tsx
'use client';

import { SessionProvider } from 'next-auth/react';
import { ReactNode } from 'react';

export function Providers({ children }: { children: ReactNode }) {
  return <SessionProvider>{children}</SessionProvider>;
}

// app/layout.tsx
import { Providers } from './providers';

export default function RootLayout({
  children,
}: {
  children: React.ReactNode;
}) {
  return (
    <html lang="en">
      <body>
        <Providers>{children}</Providers>
      </body>
    </html>
  );
}

Mechanizmy zabezpieczeń

Implementując uwierzytelnianie, należy pamiętać o kilku kluczowych mechanizmach zabezpieczeń:

1. Bezpieczne przechowywanie haseł

Nigdy nie przechowuj haseł w formie czystego tekstu! Zawsze używaj funkcji haszujących, takich jak bcrypt:

import { hash, compare } from 'bcrypt';

// Haszowanie hasła podczas rejestracji
const hashedPassword = await hash(password, 10);

// Weryfikacja hasła podczas logowania
const isValid = await compare(password, hashedPassword);

2. Ochrona przed atakami CSRF

Cross-Site Request Forgery (CSRF) to rodzaj ataku, który wykorzystuje uwierzytelnioną sesję użytkownika do wykonania nieautoryzowanych działań. Next.js i NextAuth.js domyślnie oferują pewne zabezpieczenia, ale warto zapewnić dodatkową ochronę:

// Dodanie tokenu CSRF do formularza
export default function LoginForm() {
  const csrfToken = await getCsrfToken();

  return (
    <form method="post" action="/api/auth/callback/credentials">
      <input name="csrfToken" type="hidden" defaultValue={csrfToken} />
      {/* Reszta formularza */}
    </form>
  );
}

3. Implementacja HTTPS

Używanie szyfrowanego połączenia HTTPS jest niezbędne do ochrony danych uwierzytelniających i tokenów sesji. W środowisku produkcyjnym upewnij się, że Twoja aplikacja jest dostępna tylko przez HTTPS.

4. Wygasanie tokenów JWT

Jeśli używasz tokenów JWT, ustaw im odpowiedni czas wygaśnięcia, aby ograniczyć ryzyko w przypadku kradzieży tokenu:

// Konfiguracja wygasania tokenów JWT w NextAuth.js
export const authOptions = {
  // ... inne opcje
  session: {
    strategy: 'jwt',
    maxAge: 30 * 24 * 60 * 60, // 30 dni
  },
  jwt: {
    secret: process.env.JWT_SECRET,
    maxAge: 30 * 24 * 60 * 60, // 30 dni
  }
};

Typowe wyzwania i rozwiązania

Problem: Wymuszanie uwierzytelnienia na stronach statycznych (SSG)

Wyzwaniem może być zabezpieczenie stron, które są generowane statycznie podczas budowania:

Rozwiązanie: Dodaj dodatkową warstwę weryfikacji po stronie klienta:

'use client';

import { useSession } from 'next-auth/react';
import { useRouter } from 'next/navigation';
import { useEffect } from 'react';

export default function ProtectedPage() {
  const { status } = useSession();
  const router = useRouter();

  useEffect(() => {
    if (status === 'unauthenticated') {
      router.push('/login');
    }
  }, [status, router]);

  if (status === 'loading') {
    return <div>Ładowanie...</div>;
  }

  if (status === 'unauthenticated') {
    return null; // Zamiast renderować zawartość, przekieruj do strony logowania
  }

  // Właściwa zawartość strony chronionej
  return (
    <div>
      <h1>Strona chroniona</h1>
      {/* Reszta zawartości */}
    </div>
  );
}

Problem: Różne role użytkowników

Czasami potrzebujemy różnych poziomów dostępu dla użytkowników:

Rozwiązanie: Rozszerz token/sesję o informacje o rolach i zaimplementuj sprawdzanie ról:

// Rozszerzenie typów NextAuth
declare module 'next-auth' {
  interface Session {
    user: {
      id: string;
      name?: string | null;
      email?: string | null;
      image?: string | null;
      role: string;
    };
  }

  interface User {
    id: string;
    name?: string | null;
    email?: string | null;
    image?: string | null;
    role: string;
  }
}

// Używanie informacji o rolach
function canAccessAdmin(session: Session | null) {
  return session?.user?.role === 'admin';
}

// W komponencie
const { data: session } = useSession();
const isAdmin = session?.user?.role === 'admin';

if (!isAdmin) {
  return <div>Brak dostępu. Ta sekcja jest tylko dla administratorów.</div>;
}

Podsumowanie

Uwierzytelnianie w Next.js może być implementowane na wiele sposobów, ale najczęściej używane podejścia obejmują:

  1. NextAuth.js / Auth.js - kompleksowe rozwiązanie oferujące integrację z wieloma dostawcami uwierzytelniania
  2. Własne rozwiązanie JWT - dla niestandardowych wymagań
  3. Zewnętrzne serwisy - np. Firebase Auth, Auth0, Clerk

Wybór odpowiedniego rozwiązania zależy od specyficznych wymagań Twojej aplikacji, takich jak:

  • Potrzeba integracji z zewnętrznymi dostawcami (Google, Facebook, itp.)
  • Wymagania dotyczące własności danych
  • Złożoność modelu uprawnień i ról
  • Skalowalność

W kolejnych modułach przyjrzymy się bardziej zaawansowanym aspektom uwierzytelniania, w tym szczegółowej implementacji NextAuth.js, zarządzaniu sesjami i tokenami, ochronie ścieżek za pomocą middleware, oraz zagadnieniom bezpieczeństwa.

Kod do tej lekcji: App.tsx
// Demo: Podstawy uwierzytelniania w aplikacjach Next.js
// Przegląd strategii auth: JWT, Session, OAuth
import React, { useState } from 'react';

// Uwierzytelnianie w Next.js:
// 1. JWT (JSON Web Token) - token w Authorization header
// 2. Session-based - cookie z session ID, dane na serwerze
// 3. OAuth - delegacja do zewnętrznego providera (Google, GitHub)
// 4. Auth.js (NextAuth) - najpopularniejsza biblioteka

interface AuthStrategy {
  name: string;
  description: string;
  flow: string[];
  pros: string[];
  cons: string[];
  color: string;
  nextjsCode: string;
}

const strategies: AuthStrategy[] = [
  {
    name: 'JWT (Stateless)',
    description: 'Token zawierający zakodowane dane użytkownika. Serwer nie przechowuje stanu sesji.',
    flow: ['User loguje się (email + hasło)', 'Serwer generuje JWT token', 'Token wysyłany w każdym request (Header)', 'Serwer weryfikuje podpis tokena'],
    pros: ['Skalowalny - brak stanu na serwerze', 'Działa z mikroserwisami', 'Łatwy do implementacji'],
    cons: ['Nie można łatwo unieważnić', 'Token może być duży', 'Ryzyko kradzieży tokena'],
    color: '#ff9800',
    nextjsCode: "// middleware.ts\nimport { jwtVerify } from 'jose';\n\nexport async function middleware(req) {\n  const token = req.headers.get('authorization');\n  const { payload } = await jwtVerify(token, secret);\n  // payload.userId, payload.role...\n}",
  },
  {
    name: 'Session (Stateful)',
    description: 'Serwer przechowuje dane sesji. Klient otrzymuje cookie z ID sesji.',
    flow: ['User loguje się', 'Serwer tworzy sesję w bazie/Redis', 'Cookie z session ID wysyłane do klienta', 'Przy każdym request serwer sprawdza sesję'],
    pros: ['Łatwe unieważnianie (usuń sesję)', 'Mniej danych w cookie', 'Bezpieczniejsze (HttpOnly cookies)'],
    cons: ['Wymaga storage (Redis/DB)', 'Trudniejsze skalowanie', 'Sticky sessions'],
    color: '#64ffda',
    nextjsCode: "// auth.ts (Auth.js v5)\nimport NextAuth from 'next-auth';\nimport Credentials from 'next-auth/providers/credentials';\n\nexport const { auth, signIn, signOut } = NextAuth({\n  providers: [Credentials({...})],\n  session: { strategy: 'database' },\n});",
  },
  {
    name: 'OAuth 2.0',
    description: 'Delegacja uwierzytelniania do zewnętrznego providera (Google, GitHub, etc.).',
    flow: ['User klika "Sign in with Google"', 'Redirect do Google login', 'Google potwierdza tożsamość', 'Callback z kodem autoryzacji', 'Serwer wymienia kod na token'],
    pros: ['Brak zarządzania hasłami', 'Zaufany provider', 'Szybkie logowanie dla usera'],
    cons: ['Zależność od external serwisu', 'Złożony flow (redirects)', 'Wymaga rejestracji aplikacji'],
    color: '#7c4dff',
    nextjsCode: "// auth.ts\nimport NextAuth from 'next-auth';\nimport Google from 'next-auth/providers/google';\nimport GitHub from 'next-auth/providers/github';\n\nexport const { handlers, auth } = NextAuth({\n  providers: [Google, GitHub],\n});\n\n// app/api/auth/[...nextauth]/route.ts\nexport const { GET, POST } = handlers;",
  },
];

function FlowDiagram({ steps, color }: { steps: string[]; color: string }) {
  return (
    <div style={{ display: 'grid', gap: '8px', marginTop: '12px' }}>
      {steps.map((step, i) => (
        <div key={i} style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
          <div style={{
            width: '28px', height: '28px', borderRadius: '50%',
            background: `${color}20`, color, flexShrink: 0,
            display: 'flex', alignItems: 'center', justifyContent: 'center',
            fontSize: '0.8rem', fontWeight: 'bold',
          }}>{i + 1}</div>
          <span style={{ color: '#b0bec5', fontSize: '0.85rem' }}>{step}</span>
        </div>
      ))}
    </div>
  );
}

export default function AuthIntroduction() {
  const [activeStrategy, setActiveStrategy] = useState(0);
  const s = strategies[activeStrategy];

  return (
    <div style={{
      background: '#0f0f23', minHeight: '100vh', padding: '24px',
      color: '#fff', fontFamily: 'system-ui, sans-serif',
    }}>
      <h1 style={{ color: '#64ffda', marginBottom: '4px' }}>Authentication in Next.js</h1>
      <p style={{ color: '#b0bec5', marginBottom: '20px' }}>
        JWT vs Session vs OAuth - porównanie strategii
      </p>

      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '10px', marginBottom: '24px' }}>
        {strategies.map((st, i) => (
          <button key={st.name} onClick={() => setActiveStrategy(i)} style={{
            background: i === activeStrategy ? `${st.color}15` : 'rgba(255,255,255,0.02)',
            border: `2px solid ${i === activeStrategy ? st.color : 'rgba(255,255,255,0.08)'}`,
            color: i === activeStrategy ? st.color : '#78909c',
            padding: '14px', borderRadius: '10px', cursor: 'pointer',
            textAlign: 'center', fontWeight: 500,
          }}>
            {st.name}
          </button>
        ))}
      </div>

      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px' }}>
        <div>
          <div style={{
            background: `${s.color}08`, border: `1px solid ${s.color}30`,
            borderRadius: '12px', padding: '20px',
          }}>
            <h3 style={{ color: s.color, marginBottom: '8px' }}>{s.name}</h3>
            <p style={{ color: '#b0bec5', fontSize: '0.9rem', lineHeight: 1.5, marginBottom: '0' }}>
              {s.description}
            </p>
            <FlowDiagram steps={s.flow} color={s.color} />
          </div>

          <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '12px', marginTop: '16px' }}>
            <div style={{ background: 'rgba(76,175,80,0.08)', borderRadius: '10px', padding: '14px' }}>
              <h4 style={{ color: '#4caf50', marginBottom: '8px', fontSize: '0.85rem' }}>Zalety</h4>
              {s.pros.map(p => (
                <p key={p} style={{ color: '#b0bec5', fontSize: '0.8rem', margin: '4px 0' }}>+ {p}</p>
              ))}
            </div>
            <div style={{ background: 'rgba(244,67,54,0.08)', borderRadius: '10px', padding: '14px' }}>
              <h4 style={{ color: '#f44336', marginBottom: '8px', fontSize: '0.85rem' }}>Wady</h4>
              {s.cons.map(c => (
                <p key={c} style={{ color: '#b0bec5', fontSize: '0.8rem', margin: '4px 0' }}>- {c}</p>
              ))}
            </div>
          </div>
        </div>

        <div style={{
          background: 'rgba(0,0,0,0.3)', borderRadius: '12px', padding: '20px',
        }}>
          <h4 style={{ color: s.color, marginBottom: '12px' }}>Implementacja w Next.js</h4>
          <pre style={{
            margin: 0, color: '#b0bec5', fontSize: '0.8rem',
            lineHeight: 1.6, whiteSpace: 'pre-wrap',
          }}>
            {s.nextjsCode}
          </pre>
        </div>
      </div>
    </div>
  );
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Przydatne artykuły