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

Implementacja Clerk w Next.js

10 min czytania ·
W tej lekcji11

W nowoczesnych aplikacjach, niezawodna i bezpieczna obsługa uwierzytelniania oraz zarządzania użytkownikami stanowi fundament dobrego doświadczenia użytkownika. Clerk to kompleksowe rozwiązanie, które upraszcza ten aspekt tworzenia aplikacji, oferując gotowe komponenty i API do zarządzania tożsamością użytkowników w aplikacjach Next.js.

Czym jest Clerk?

Clerk to kompleksowa platforma zarządzania tożsamością (Identity-as-a-Service), zaprojektowana specjalnie pod kątem aplikacji Next.js i React. W przeciwieństwie do innych rozwiązań, Clerk oferuje pełny pakiet narzędzi do uwierzytelniania, zarządzania użytkownikami i zarządzania sesjami.

Główne zalety Clerk:

  1. Gotowe komponenty UI - pre-stylowane komponenty do logowania, rejestracji, weryfikacji dwustopniowej i więcej
  2. Natywne wsparcie dla Next.js App Router - zoptymalizowane do pracy z najnowszymi wersjami Next.js
  3. Wieloplatformowa obsługa - wsparcie dla wielu urządzeń i platform
  4. Wieloczynnikowe uwierzytelnianie - wbudowana obsługa 2FA
  5. Zarządzanie organizacjami i teamami - funkcje dla aplikacji B2B
  6. Zgodność z GDPR i innymi regulacjami - wbudowane mechanizmy ochrony prywatności

Instalacja i konfiguracja

Rozpocznijmy od instalacji pakietów Clerk w projekcie Next.js:

npm install @clerk/nextjs
# lub
yarn add @clerk/nextjs
# lub
pnpm add @clerk/nextjs

Konfiguracja kluczy API

Po utworzeniu konta na clerk.com i nowej aplikacji, otrzymasz klucze API. Dodaj je do zmiennych środowiskowych w pliku .env.local:

NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_test_...
CLERK_SECRET_KEY=sk_test_...

Jeśli korzystasz z GitHub lub innego systemu kontroli wersji, upewnij się, że plik .env.local jest dodany do .gitignore.

Owinięcie aplikacji w provider Clerk

Aby Clerk działał w całej aplikacji, musimy dodać ClerkProvider w głównym layoucie:

// app/layout.tsx
import { ClerkProvider } from '@clerk/nextjs';

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

Konfiguracja ścieżek publicznych i chronionych

Ważnym krokiem jest określenie, które ścieżki są publiczne (dostępne dla niezalogowanych użytkowników), a które chronione (wymagające zalogowania). Można to zrobić za pomocą middleware:

// middleware.ts
import { authMiddleware } from "@clerk/nextjs";

export default authMiddleware({
  publicRoutes: ["/", "/contact", "/about", "/api/public"],
});

export const config = {
  matcher: ["/((?!.+\.[\w]+$|_next).*)", "/", "/(api|trpc)(.*)"],
};

W powyższym przykładzie strony główna, kontaktowa i "o nas" są publiczne, a wszystkie inne wymagają zalogowania.

Komponenty uwierzytelniania

Clerk dostarcza gotowe komponenty do najczęstszych operacji związanych z uwierzytelnianiem.

SignIn i SignUp

Zaimplementowanie stron logowania i rejestracji jest bardzo proste:

// app/sign-in/[[...sign-in]]/page.tsx
import { SignIn } from "@clerk/nextjs";

export default function SignInPage() {
  return (
    <div className="flex justify-center items-center min-h-screen">
      <SignIn
        appearance={{
          elements: {
            formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
            footerActionLink: "text-blue-500 hover:text-blue-600"
          }
        }}
      />
    </div>
  );
}

// app/sign-up/[[...sign-up]]/page.tsx
import { SignUp } from "@clerk/nextjs";

export default function SignUpPage() {
  return (
    <div className="flex justify-center items-center min-h-screen">
      <SignUp
        appearance={{
          elements: {
            formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
            footerActionLink: "text-blue-500 hover:text-blue-600"
          }
        }}
      />
    </div>
  );
}

Zwróć uwagę na wzorzec [[...sign-in]] w nazwie folderu - podwójne nawiasy kwadratowe oznaczają opcjonalny parametr catch-all, co pozwala Clerk obsługiwać różne stany uwierzytelniania.

UserButton - przycisk profilu użytkownika

Dodaj przycisk profilu użytkownika do nagłówka, który wyświetla menu z opcjami zarządzania kontem:

// components/Header.tsx
import { UserButton } from "@clerk/nextjs";

export function Header() {
  return (
    <header className="flex justify-between items-center p-4 bg-white shadow">
      <div className="font-bold text-xl">Moja aplikacja</div>
      <UserButton afterSignOutUrl="/" />
    </header>
  );
}

Dostęp do informacji o użytkowniku

W komponentach po stronie klienta możemy użyć hooków Clerk, aby uzyskać informacje o zalogowanym użytkowniku:

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

import { useUser } from "@clerk/nextjs";

export function Profile() {
  const { user, isLoaded } = useUser();

  if (!isLoaded) {
    return <div>Ładowanie...</div>;
  }

  return (
    <div className="p-4">
      <h1 className="text-2xl font-bold mb-4">Twój profil</h1>
      <div className="mb-4">
        <img
          src={user?.imageUrl}
          alt="Zdjęcie profilowe"
          className="w-16 h-16 rounded-full"
        />
      </div>
      <p><strong>Imię:</strong> {user?.firstName}</p>
      <p><strong>Nazwisko:</strong> {user?.lastName}</p>
      <p><strong>Email:</strong> {user?.primaryEmailAddress?.emailAddress}</p>
    </div>
  );
}

W komponentach po stronie serwera, możemy użyć funkcji pomocniczych:

// app/dashboard/page.tsx
import { currentUser } from "@clerk/nextjs";

export default async function DashboardPage() {
  const user = await currentUser();

  if (!user) {
    return <div>Nie jesteś zalogowany</div>;
  }

  return (
    <div className="p-4">
      <h1 className="text-2xl font-bold mb-4">Panel użytkownika</h1>
      <p>Witaj, {user.firstName}! Oto Twój panel użytkownika.</p>
    </div>
  );
}

Zarządzanie organizacjami

Jedną z mocnych stron Clerk jest wbudowana obsługa organizacji (teamów), co jest szczególnie przydatne w aplikacjach B2B.

Komponent selekcji organizacji

// components/OrganizationSwitcher.tsx
import { OrganizationSwitcher } from "@clerk/nextjs";

export function OrgSwitcher() {
  return (
    <OrganizationSwitcher
      appearance={{
        elements: {
          organizationSwitcherTrigger: "p-2 border rounded-md"
        }
      }}
    />
  );
}

Tworzenie nowej organizacji

// app/organizations/new/page.tsx
import { CreateOrganization } from "@clerk/nextjs";

export default function NewOrganizationPage() {
  return (
    <div className="flex justify-center items-center min-h-screen">
      <CreateOrganization
        appearance={{
          elements: {
            formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
          }
        }}
      />
    </div>
  );
}

Dostęp do danych organizacji

// app/dashboard/organization/page.tsx
import { currentUser, clerkClient } from "@clerk/nextjs";
import { redirect } from "next/navigation";

export default async function OrganizationDashboard() {
  const user = await currentUser();

  if (!user) {
    return redirect("/sign-in");
  }

  // Pobierz aktywną organizację
  const org = await clerkClient.organizations.getOrganization({
    organizationId: user.organizationId || ""
  });

  if (!org) {
    return (
      <div className="p-4">
        <h1 className="text-2xl font-bold mb-4">Nie wybrano organizacji</h1>
        <p>Wybierz organizację, aby zobaczyć jej dashboard.</p>
      </div>
    );
  }

  return (
    <div className="p-4">
      <h1 className="text-2xl font-bold mb-4">Dashboard organizacji: {org.name}</h1>
      <p>Członkowie: {org.membersCount}</p>
      <p>Utworzono: {new Date(org.createdAt).toLocaleDateString()}</p>
    </div>
  );
}

Zabezpieczanie API Routes

W Next.js App Router możemy łatwo zabezpieczać trasy API używając funkcji pomocniczych Clerk:

// app/api/protected/route.ts
import { auth } from "@clerk/nextjs";
import { NextResponse } from "next/server";

export async function GET() {
  const { userId } = auth();

  if (!userId) {
    return new NextResponse(JSON.stringify({ error: "Unauthorized" }), {
      status: 401,
      headers: { "Content-Type": "application/json" }
    });
  }

  return NextResponse.json({
    message: "To są chronione dane tylko dla zalogowanych użytkowników"
  });
}

Dostosowywanie wyglądu

Clerk oferuje rozbudowane opcje dostosowywania wyglądu. Można to zrobić na trzy sposoby:

1. Za pomocą prop appearance

import { SignIn } from "@clerk/nextjs";

export default function SignInPage() {
  return (
    <SignIn
      appearance={{
        elements: {
          formButtonPrimary: "bg-gradient-to-r from-blue-500 to-purple-500 text-white",
          card: "shadow-xl border-0",
          socialButtonsBlockButton: "border border-gray-300 hover:bg-gray-100"
        }
      }}
    />
  );
}

2. Za pomocą dostawcy wyglądu

// app/layout.tsx
import { ClerkProvider } from '@clerk/nextjs';

const appearance = {
  elements: {
    formButtonPrimary: "bg-blue-500 hover:bg-blue-600 text-white",
    footerActionLink: "text-blue-500 hover:text-blue-600",
    card: "shadow-md"
  },
  variables: {
    colorPrimary: "#3B82F6"
  }
};

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

3. Za pomocą niestandardowych stylów CSS

Można również utworzyć plik CSS z własnymi stylami:

/* styles/clerk.css */
.cl-card {
  border-radius: 12px;
  box-shadow: 0 10px 25px rgba(0, 0, 0, 0.1);
}

.cl-formButtonPrimary {
  background: linear-gradient(45deg, #3B82F6, #6366F1);
  border-radius: 6px;
  transition: transform 0.2s;
}

.cl-formButtonPrimary:hover {
  transform: translateY(-2px);
}

A następnie zaimportować do aplikacji:

// app/layout.tsx
import "../styles/clerk.css";

Webhook i integracja z bazą danych

W większości aplikacji będziesz chciał synchronizować dane użytkowników Clerk z własną bazą danych. Najlepszym sposobem na to jest użycie webhooków:

Konfiguracja endpointu webhook

// app/api/webhooks/clerk/route.ts
import { WebhookEvent } from "@clerk/nextjs/server";
import { headers } from "next/headers";
import { NextResponse } from "next/server";
import { Webhook } from "svix";

export async function POST(req: Request) {
  const WEBHOOK_SECRET = process.env.CLERK_WEBHOOK_SECRET;

  if (!WEBHOOK_SECRET) {
    throw new Error('Brak CLERK_WEBHOOK_SECRET');
  }

  // Pobierz nagłówki
  const headerPayload = await headers();
  const svix_id = headerPayload.get("svix-id");
  const svix_timestamp = headerPayload.get("svix-timestamp");
  const svix_signature = headerPayload.get("svix-signature");

  if (!svix_id || !svix_timestamp || !svix_signature) {
    return new NextResponse(JSON.stringify({ error: "Brak wymaganych nagłówków" }), {
      status: 400
    });
  }

  // Pobierz treść żądania
  const payload = await req.json();
  const body = JSON.stringify(payload);

  // Zweryfikuj webhook
  const webhook = new Webhook(WEBHOOK_SECRET);
  let event: WebhookEvent;

  try {
    event = webhook.verify(body, {
      "svix-id": svix_id,
      "svix-timestamp": svix_timestamp,
      "svix-signature": svix_signature,
    }) as WebhookEvent;
  } catch (err) {
    console.error('Błąd weryfikacji webhooka:', err);
    return new NextResponse(JSON.stringify({ error: "Nieprawidłowy podpis" }), {
      status: 400
    });
  }

  // Obsługa różnych typów zdarzeń
  const { type } = event;

  switch (type) {
    case 'user.created': {
      const { id, email_addresses, username, first_name, last_name } = event.data;
      const primaryEmail = email_addresses?.[0]?.email_address;

      // Tutaj dodaj logikę zapisania użytkownika w bazie danych
      // Na przykład używając Prisma:
      // await prisma.user.create({
      //   data: {
      //     clerkId: id,
      //     email: primaryEmail,
      //     username: username || "",
      //     firstName: first_name || "",
      //     lastName: last_name || ""
      //   }
      // });

      break;
    }

    case 'user.updated': {
      const { id, email_addresses, username, first_name, last_name } = event.data;
      const primaryEmail = email_addresses?.[0]?.email_address;

      // Tutaj zaktualizuj użytkownika w bazie danych
      break;
    }

    case 'user.deleted': {
      const { id } = event.data;

      // Tutaj usuń użytkownika z bazy danych
      break;
    }

    // Obsłuż inne typy zdarzeń, takie jak organization.created, organization.updated, itp.
  }

  return NextResponse.json({ message: "Webhook odebrany" }, { status: 200 });
}

Zaawansowane funkcje

Wieloczynnikowe uwierzytelnianie (2FA)

Clerk oferuje wbudowane wsparcie dla 2FA. Możesz włączyć tę funkcję w panelu administracyjnym Clerk.

Logowanie bezhasłowe

Możesz skonfigurować logowanie za pomocą linków magic link (bez hasła):

// app/sign-in/magic-link/page.tsx
import { SignIn } from "@clerk/nextjs";

export default function MagicLinkPage() {
  return (
    <div className="flex justify-center items-center min-h-screen">
      <SignIn path="/sign-in/magic-link" />
    </div>
  );
}

Wieloetapowe logowanie

Możesz utworzyć niestandardowy proces logowania z wieloma etapami:

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

import { useSignIn } from "@clerk/nextjs";
import { useState } from "react";

export function CustomSignIn() {
  const { isLoaded, signIn, setActive } = useSignIn();
  const [email, setEmail] = useState("");
  const [password, setPassword] = useState("");
  const [verificationCode, setVerificationCode] = useState("");
  const [stage, setStage] = useState("email");
  const [error, setError] = useState("");

  if (!isLoaded) {
    return <div>Ładowanie...</div>;
  }

  async function handleSubmitEmail(e: React.FormEvent) {
    e.preventDefault();
    setError("");

    try {
      await signIn.create({
        identifier: email
      });

      await signIn.prepareFirstFactor({
        strategy: "email_code",
        email
      });

      setStage("verification");
    } catch (err: any) {
      setError(err.errors?.[0]?.message || "Wystąpił błąd");
    }
  }

  async function handleVerifyCode(e: React.FormEvent) {
    e.preventDefault();
    setError("");

    try {
      const result = await signIn.attemptFirstFactor({
        strategy: "email_code",
        code: verificationCode
      });

      if (result.status === "complete") {
        await setActive({ session: result.createdSessionId });
        // Przekierowanie po zalogowaniu
        window.location.href = "/dashboard";
      }
    } catch (err: any) {
      setError(err.errors?.[0]?.message || "Kod nieprawidłowy");
    }
  }

  return (
    <div className="p-4 max-w-sm mx-auto">
      <h1 className="text-2xl font-bold mb-4 text-center">Logowanie</h1>

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

      {stage === "email" ? (
        <form onSubmit={handleSubmitEmail} className="space-y-4">
          <div>
            <label htmlFor="email" className="block mb-1">Email</label>
            <input
              id="email"
              type="email"
              value={email}
              onChange={(e) => setEmail(e.target.value)}
              required
              className="w-full p-2 border rounded-md"
            />
          </div>

          <button
            type="submit"
            className="w-full bg-blue-500 text-white p-2 rounded-md hover:bg-blue-600"
          >
            Kontynuuj
          </button>
        </form>
      ) : (
        <form onSubmit={handleVerifyCode} className="space-y-4">
          <div>
            <label htmlFor="code" className="block mb-1">Kod weryfikacyjny</label>
            <input
              id="code"
              type="text"
              value={verificationCode}
              onChange={(e) => setVerificationCode(e.target.value)}
              required
              className="w-full p-2 border rounded-md"
            />
          </div>

          <button
            type="submit"
            className="w-full bg-blue-500 text-white p-2 rounded-md hover:bg-blue-600"
          >
            Weryfikuj
          </button>

          <button
            type="button"
            className="w-full text-blue-500 hover:text-blue-600"
            onClick={() => setStage("email")}
          >
            Wróć
          </button>
        </form>
      )}
    </div>
  );
}

Wady i ograniczenia Clerk

Choć Clerk oferuje wiele korzyści, warto być świadomym kilku ograniczeń:

  1. Koszt - w przeciwieństwie do Auth.js, Clerk działa na modelu freemium i dla większych aplikacji wymaga płatnej subskrypcji
  2. Zależność od zewnętrznej usługi - dane uwierzytelniania są przechowywane na serwerach Clerk
  3. Mniejsza kontrola - masz mniejszą kontrolę nad implementacją szczegółów uwierzytelniania
  4. Kustomizacja - mimo wielu opcji dostosowywania, czasami natywne rozwiązanie może oferować więcej swobody

Kiedy wybrać Clerk zamiast Auth.js?

Przy podejmowaniu decyzji warto rozważyć następujące czynniki:

  1. Wybierz Clerk, gdy:

    • Potrzebujesz gotowego, kompletnego rozwiązania uwierzytelniania
    • Chcesz szybko wdrożyć funkcje uwierzytelniania z minimalnym wysiłkiem
    • Potrzebujesz zarządzania organizacjami i teamami
    • Potrzebujesz zaawansowanych funkcji jak 2FA, magic links, etc.
    • Nie chcesz zarządzać infrastrukturą uwierzytelniania
  2. Wybierz Auth.js, gdy:

    • Potrzebujesz większej kontroli nad procesem uwierzytelniania
    • Preferujesz rozwiązanie open-source
    • Nie chcesz polegać na zewnętrznym serwisie
    • Masz ograniczony budżet dla większego projektu
    • Musisz przechowywać dane uwierzytelniania we własnej bazie danych

Podsumowanie

Clerk to potężne narzędzie, które może znacząco przyspieszyć implementację uwierzytelniania w aplikacjach Next.js. Oferuje bogaty zestaw funkcji, które mogłyby wymagać tygodni pracy do samodzielnej implementacji. Dla wielu zespołów deweloperskich oszczędność czasu i gotowe rozwiązania bezpieczeństwa przeważają nad kosztami i mniejszą kontrolą.

Jednak wybór między Clerk, Auth.js, czy własnym rozwiązaniem uwierzytelniania powinien być oparty na konkretnych wymaganiach projektu, dostępnym budżecie i potrzebach biznesowych.

Kod do tej lekcji: App.tsx
import React, { useState } from 'react';

// Demo: Clerk w Next.js
interface ClerkComponent {
  name: string; icon: string; description: string; code: string;
  category: 'ui' | 'hook' | 'middleware' | 'config';
}

const components: ClerkComponent[] = [
  { name: '<SignIn />', icon: 'K', category: 'ui',
    description: 'Gotowy komponent logowania z OAuth, email i haslem',
    code: "import { SignIn } from '@clerk/nextjs';\n\nexport default function SignInPage() {\n  return <SignIn redirectUrl=\"/dashboard\" />;\n}" },
  { name: '<SignUp />', icon: 'R', category: 'ui',
    description: 'Komponent rejestracji z weryfikacja email',
    code: "import { SignUp } from '@clerk/nextjs';\n\nexport default function SignUpPage() {\n  return <SignUp />;\n}" },
  { name: '<UserButton />', icon: 'U', category: 'ui',
    description: 'Awatar z menu (profil, wylogowanie)',
    code: "import { UserButton } from '@clerk/nextjs';\n\nfunction Navbar() {\n  return <UserButton afterSignOutUrl=\"/\" />;\n}" },
  { name: 'useUser()', icon: 'H', category: 'hook',
    description: 'Hook do danych zalogowanego uzytkownika',
    code: "import { useUser } from '@clerk/nextjs';\n\nfunction Profile() {\n  const { user, isLoaded, isSignedIn } = useUser();\n  if (!isLoaded) return <div>Loading...</div>;\n  return <h1>Welcome, {user.firstName}!</h1>;\n}" },
  { name: 'useAuth()', icon: 'A', category: 'hook',
    description: 'Hook do stanu auth i tokenow',
    code: "import { useAuth } from '@clerk/nextjs';\n\nfunction ApiCall() {\n  const { getToken, userId } = useAuth();\n  // const token = await getToken();\n}" },
  { name: 'clerkMiddleware()', icon: 'M', category: 'middleware',
    description: 'Middleware do ochrony tras na edge',
    code: "import { clerkMiddleware, createRouteMatcher } from '@clerk/nextjs/server';\n\nconst isProtected = createRouteMatcher(['/dashboard(.*)']);\n\nexport default clerkMiddleware((auth, req) => {\n  if (isProtected(req)) auth().protect();\n});" },
  { name: 'ClerkProvider', icon: 'P', category: 'config',
    description: 'Provider opakowujacy aplikacje',
    code: "import { ClerkProvider } from '@clerk/nextjs';\n\nexport default function RootLayout({ children }) {\n  return (\n    <ClerkProvider>\n      <html><body>{children}</body></html>\n    </ClerkProvider>\n  );\n}" },
];

const catColors: Record<string, string> = { ui: '#3b82f6', hook: '#8b5cf6', middleware: '#f59e0b', config: '#10b981' };

function ClerkDemo() {
  const [selected, setSelected] = useState(components[0]);
  const [filter, setFilter] = useState('all');
  const [setupStep, setSetupStep] = useState(0);

  const setupSteps = [
    { title: 'Instalacja', cmd: 'npm install @clerk/nextjs' },
    { title: 'Env vars', cmd: 'NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_...\nCLERK_SECRET_KEY=sk_...' },
    { title: 'Provider', cmd: 'Opakuj <html> w <ClerkProvider>' },
    { title: 'Middleware', cmd: 'Utworz middleware.ts z clerkMiddleware()' },
    { title: 'Gotowe!', cmd: 'Uzyj <SignIn />, <UserButton />, useUser()' },
  ];

  const filtered = filter === 'all' ? components : components.filter(c => c.category === filter);

  return (
    <div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
      <h1 style={{ color: '#64ffda', marginBottom: '8px' }}>Clerk - Auth w Next.js</h1>
      <p style={{ color: '#8892b0', marginBottom: '24px' }}>Gotowe komponenty i hooki do uwierzytelniania</p>

      <div style={{ background: '#1a1a2e', padding: '16px', borderRadius: '12px', border: '1px solid #333', marginBottom: '24px' }}>
        <h3 style={{ color: '#64ffda', marginTop: 0, fontSize: '16px' }}>Setup</h3>
        <div style={{ display: 'flex', gap: '8px', marginBottom: '12px', flexWrap: 'wrap' }}>
          {setupSteps.map((s, i) => (
            <button key={i} onClick={() => setSetupStep(i)} style={{
              padding: '6px 12px', borderRadius: '6px', border: 'none', cursor: 'pointer', fontSize: '12px',
              background: setupStep === i ? '#64ffda' : i < setupStep ? '#10b98130' : '#333',
              color: setupStep === i ? '#0f0f23' : '#8892b0',
            }}>{i + 1}. {s.title}</button>
          ))}
        </div>
        <pre style={{ background: '#0f0f23', padding: '12px', borderRadius: '6px', fontSize: '13px', color: '#f59e0b', margin: 0, whiteSpace: 'pre-wrap' }}>{setupSteps[setupStep].cmd}</pre>
      </div>

      <div style={{ display: 'flex', gap: '8px', marginBottom: '20px' }}>
        {['all', 'ui', 'hook', 'middleware', 'config'].map(f => (
          <button key={f} onClick={() => setFilter(f)} style={{
            padding: '6px 14px', borderRadius: '6px', border: 'none', cursor: 'pointer',
            background: filter === f ? '#64ffda' : '#1a1a2e', color: filter === f ? '#0f0f23' : '#8892b0',
          }}>{f}</button>
        ))}
      </div>

      <div style={{ display: 'grid', gridTemplateColumns: '260px 1fr', gap: '20px' }}>
        <div style={{ display: 'grid', gap: '8px', alignContent: 'start' }}>
          {filtered.map(comp => (
            <button key={comp.name} onClick={() => setSelected(comp)} style={{
              padding: '12px', borderRadius: '8px', textAlign: 'left',
              border: selected.name === comp.name ? '1px solid #64ffda' : '1px solid #333',
              background: selected.name === comp.name ? '#1a2a3e' : '#1a1a2e', color: '#e0e0e0', cursor: 'pointer',
            }}>
              <code style={{ color: '#64ffda', fontSize: '14px' }}>{comp.name}</code>
              <div><span style={{ fontSize: '11px', padding: '2px 6px', borderRadius: '4px', background: catColors[comp.category] + '30', color: catColors[comp.category] }}>{comp.category}</span></div>
            </button>
          ))}
        </div>
        <div style={{ background: '#1a1a2e', padding: '20px', borderRadius: '12px', border: '1px solid #333' }}>
          <h3 style={{ color: '#64ffda', margin: '0 0 8px' }}>{selected.name}</h3>
          <span style={{ fontSize: '12px', color: catColors[selected.category] }}>{selected.category}</span>
          <p style={{ color: '#8892b0', fontSize: '14px' }}>{selected.description}</p>
          <pre style={{ background: '#0f0f23', padding: '16px', borderRadius: '8px', fontSize: '13px', color: '#e0e0e0', overflow: 'auto', lineHeight: 1.5, whiteSpace: 'pre-wrap' }}>{selected.code}</pre>
        </div>
      </div>
    </div>
  );
}

export default ClerkDemo;

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. Co zapewnia Clerk jako rozwiązanie do autentykacji w Next.js?

  2. 2. Jaka jest fundamentalna różnica między uwierzytelnianiem (authentication) a autoryzacją (authorization)?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj cykl zarządzania sesją:

  • Klikanie w kolejności

    Ułóż ścieżkę callback URL w NextAuth:

  • Układanie w poziomie

    Ułóż składnię pobierania sesji serwerowej w NextAuth:

  • Układanie w pionie

    Uporządkuj proces hashowania hasła:

  • Układanie w poziomie

    Ułóż składnię weryfikacji tokena JWT:

  • Układanie w pionie

    Ułóż elementy w prawidłowej kolejności: Header (typ i algorytm) → Payload (claim

  • Układanie w poziomie

    Ułóż składnię sprawdzania sesji w middleware:

  • Układanie w pionie

    Ułóż elementy w prawidłowej kolejności: User authorization na provider → Authori

  • Układanie w poziomie

    Ułóż składnię porównywania hasła z bcrypt:

  • Klikanie w kolejności

    Ułóż etapy weryfikacji JWT tokena:

  • Edytor kodu

    Utwórz system logowania authentication events: logins, logouts, failed attempts, security events

  • Klikanie w kolejności

    Ułóż etapy OAuth authorization code flow:

  1. PytanieClerk - zarządzanie użytkownikami
  2. Ułóż w kolejnościCykl zarządzania sesją
  3. Kliknij w kolejnościŚcieżka callback NextAuth
  4. Ułóż w kolejnościSkładnia getServerSession w NextAuth
  5. Ułóż w kolejnościProces hashowania hasła
  6. PytanieUwierzytelnianie vs autoryzacja
  7. Ułóż w kolejnościSkładnia weryfikacji JWT
  8. Ułóż w kolejnościKolejność: Header (typ i algorytm) → Payload (claims/da
  9. Ułóż w kolejnościSkładnia sprawdzania sesji w middleware
  10. Ułóż w kolejnościKolejność: User authorization na provider → Authorizati
  11. Ułóż w kolejnościSkładnia porównywania hasła z bcrypt
  12. PytaniePierwszy krok w zabezpieczaniu aplikacji Next.js
  13. Kliknij w kolejnościEtapy weryfikacji JWT tokena
  14. Zadanie z kodemPraktyka: Utwórz system logowania authentication events:
  15. Kliknij w kolejnościEtapy OAuth authorization code flow

Przydatne artykuły