Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Podstawy uwierzytelniania w aplikacjach Next.js
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ż:
- Chroni dane użytkowników - zapewnia, że osobiste informacje są dostępne tylko dla ich właścicieli
- Umożliwia personalizację - pozwala na dostosowanie doświadczenia do konkretnego użytkownika
- Kontroluje dostęp - określa, do jakich zasobów i funkcji użytkownik ma dostęp
- 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:
- Renderowanie po stronie serwera (SSR) - umożliwia weryfikację uwierzytelnienia przed wysłaniem strony do klienta
- Statyczna generacja stron (SSG) - wymaga dodatkowej weryfikacji klienta dla chronionych treści
- 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ą:
- NextAuth.js / Auth.js - kompleksowe rozwiązanie oferujące integrację z wieloma dostawcami uwierzytelniania
- Własne rozwiązanie JWT - dla niestandardowych wymagań
- 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?