Kurs Next.js · Moduł 7: Uwierzytelnianie i autoryzacja
Podłączanie dostawców (Google, GitHub, Facebook)
W tej lekcji6
W poprzednich lekcjach omówiliśmy podstawy uwierzytelniania w aplikacjach Next.js oraz różne strategie autoryzacji. Teraz skupimy się na praktycznej implementacji uwierzytelniania z popularnymi dostawcami zewnętrznymi - Google, GitHub i Facebook. Ta metoda jest niezwykle popularna, ponieważ oferuje użytkownikom szybkie i wygodne logowanie bez konieczności tworzenia nowego konta i zapamiętywania kolejnego hasła.
Dlaczego warto dodać zewnętrznych dostawców uwierzytelniania?
Logowanie z wykorzystaniem kont Google, GitHub czy Facebook przynosi kilka istotnych korzyści zarówno dla użytkowników, jak i dla nas - twórców aplikacji:
- Lepsze doświadczenie użytkownika - szybszy i wygodniejszy proces logowania, bez konieczności wymyślania i zapamiętywania nowych danych logowania
- Wyższy współczynnik rejestracji - mniejsza liczba porzuconych rejestracji dzięki uproszczonemu procesowi
- Większe bezpieczeństwo - dostawcy jak Google czy Facebook stosują zaawansowane mechanizmy ochrony kont
- Dodatkowe informacje - możliwość pozyskania dodatkowych danych o użytkowniku (za jego zgodą), takich jak zdjęcie profilowe czy informacje kontaktowe
- Uwierzytelnianie wieloskładnikowe - wielu dostawców oferuje już wbudowane mechanizmy 2FA/MFA
Przystąpmy więc do praktycznej implementacji logowania z tymi popularnymi dostawcami w aplikacji Next.js.
Konfiguracja OAuth dla dostawców
Zanim zaczniemy kodować, musimy utworzyć odpowiednie aplikacje OAuth u każdego z dostawców, aby uzyskać niezbędne klucze.
Google OAuth
- Przejdź do Google Cloud Console
- Utwórz nowy projekt lub wybierz istniejący
- Przejdź do "APIs & Services" > "Credentials"
- Kliknij "Create Credentials" > "OAuth client ID"
- Wybierz typ aplikacji (Web application)
- Dodaj nazwę i dozwolone przekierowania (redirect URIs):
http://localhost:3000/api/auth/callback/google(dla środowiska deweloperskiego)https://twoja-domena.com/api/auth/callback/google(dla produkcji)
- Zapisz ID klienta (Client ID) i tajny klucz klienta (Client Secret)
GitHub OAuth
- Zaloguj się na GitHub
- Przejdź do Settings > Developer settings > OAuth Apps
- Kliknij "New OAuth App"
- Wypełnij formularz:
- Application name: nazwa twojej aplikacji
- Homepage URL: np.
http://localhost:3000 - Authorization callback URL:
http://localhost:3000/api/auth/callback/github
- Zarejestruj aplikację
- Wygeneruj nowy Client Secret i zapisz go wraz z Client ID
Facebook OAuth
- Przejdź do Facebook Developers
- Utwórz nową aplikację (wybierz "For Everything Else" jako typ)
- W panelu aplikacji dodaj "Facebook Login" i wybierz "Web"
- W ustawieniach dodaj dozwolone domeny:
localhost(dla środowiska deweloperskiego)twoja-domena.com(dla produkcji)
- W ustawieniach uwierzytelniania dodaj przekierowanie OAuth:
http://localhost:3000/api/auth/callback/facebook
- Zapisz App ID i App Secret
Implementacja uwierzytelniania z Next-Auth/Auth.js
Teraz, gdy mamy już klucze OAuth, możemy przystąpić do implementacji uwierzytelniania w naszej aplikacji Next.js. Będziemy używać biblioteki NextAuth.js (obecnie znanej również jako Auth.js).
1. Konfiguracja zmiennych środowiskowych
Najpierw dodajmy nasze klucze OAuth do pliku .env.local:
# Podstawowa konfiguracja NextAuth.js
NEXTAUTH_URL=http://localhost:3000
NEXTAUTH_SECRET=twój_tajny_klucz_do_szyfrowania
# Google Provider
GOOGLE_CLIENT_ID=twoje_google_client_id
GOOGLE_CLIENT_SECRET=twoje_google_client_secret
# GitHub Provider
GITHUB_ID=twoje_github_client_id
GITHUB_SECRET=twoje_github_client_secret
# Facebook Provider
FACEBOOK_CLIENT_ID=twoje_facebook_app_id
FACEBOOK_CLIENT_SECRET=twoje_facebook_app_secret2. Konfiguracja dostawców w NextAuth
Teraz stwórzmy lub zaktualizujmy plik konfiguracyjny NextAuth.js:
// app/api/auth/[...nextauth]/route.ts
import NextAuth from "next-auth";
import GoogleProvider from "next-auth/providers/google";
import GitHubProvider from "next-auth/providers/github";
import FacebookProvider from "next-auth/providers/facebook";
import { PrismaAdapter } from "@auth/prisma-adapter";
import { PrismaClient } from "@prisma/client";
const prisma = new PrismaClient();
export const authOptions = {
adapter: PrismaAdapter(prisma),
providers: [
GoogleProvider({
clientId: process.env.GOOGLE_CLIENT_ID!,
clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
// Możemy zdefiniować, jakie dane profilu chcemy otrzymać
profile(profile) {
return {
id: profile.sub,
name: profile.name,
email: profile.email,
image: profile.picture,
// Możemy dodać dodatkowe pola specyficzne dla naszej aplikacji
emailVerified: profile.email_verified,
};
},
}),
GitHubProvider({
clientId: process.env.GITHUB_ID!,
clientSecret: process.env.GITHUB_SECRET!,
profile(profile) {
return {
id: profile.id.toString(),
name: profile.name || profile.login,
email: profile.email,
image: profile.avatar_url,
// Dodatkowe pole specyficzne dla GitHub
username: profile.login,
};
},
}),
FacebookProvider({
clientId: process.env.FACEBOOK_CLIENT_ID!,
clientSecret: process.env.FACEBOOK_CLIENT_SECRET!,
profile(profile) {
return {
id: profile.id,
name: profile.name,
email: profile.email,
image: profile.picture.data.url,
};
},
}),
// Możemy również dodać uwierzytelnianie przez email/hasło
// dla użytkowników, którzy wolą tradycyjne logowanie
],
callbacks: {
async session({ session, user }) {
// Dodaj ID użytkownika do sesji, aby łatwo identyfikować użytkownika
if (session.user) {
session.user.id = user.id;
}
return session;
},
async jwt({ token, user, account, profile }) {
// Jeśli mamy użytkownika (np. podczas logowania), dodaj jego ID do tokenu
if (user) {
token.uid = user.id;
}
// Możemy też dodać informacje o dostawcy uwierzytelniania
if (account) {
token.provider = account.provider;
}
return token;
},
},
pages: {
signIn: '/auth/login', // Niestandardowa strona logowania
signOut: '/auth/logout', // Niestandardowa strona wylogowania
error: '/auth/error', // Strona błędów uwierzytelniania
},
session: {
strategy: 'database', // Używamy bazy danych do przechowywania sesji
maxAge: 30 * 24 * 60 * 60, // 30 dni
},
debug: process.env.NODE_ENV === 'development',
};
const handler = NextAuth(authOptions);
export { handler as GET, handler as POST };3. Stworzenie interfejsu użytkownika do logowania
Teraz stwórzmy przyjazny interfejs logowania, który będzie oferował wszystkie skonfigurowane metody uwierzytelniania:
// app/auth/login/page.tsx
'use client';
import { signIn, useSession } from 'next-auth/react';
import { useRouter, useSearchParams } from 'next/navigation';
import { useEffect, useState } from 'react';
export default function LoginPage() {
const router = useRouter();
const searchParams = useSearchParams();
const callbackUrl = searchParams.get('callbackUrl') || '/dashboard';
const { status } = useSession();
const [email, setEmail] = useState('');
const [password, setPassword] = useState('');
const [isLoading, setIsLoading] = useState(false);
const [error, setError] = useState('');
// Jeśli użytkownik jest już zalogowany, przekieruj go
useEffect(() => {
if (status === 'authenticated') {
router.push(callbackUrl);
}
}, [status, router, callbackUrl]);
// Obsługa logowania przez email/hasło (jeśli skonfigurowano)
const handleEmailLogin = async (e: React.FormEvent) => {
e.preventDefault();
setIsLoading(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(callbackUrl);
}
} catch (error) {
setError('Wystąpił błąd podczas logowania');
} finally {
setIsLoading(false);
}
};
if (status === 'loading') {
return (
<div className="flex justify-center items-center min-h-screen">
<div className="animate-spin rounded-full h-12 w-12 border-t-2 border-b-2 border-blue-500" />
</div>
);
}
return (
<div className="max-w-md mx-auto mt-10 p-6 bg-white rounded-lg shadow-lg">
<h1 className="text-2xl font-bold mb-6 text-center">Zaloguj się do aplikacji</h1>
{error && (
<div className="mb-4 p-3 bg-red-100 text-red-700 rounded">
{error}
</div>
)}
<div className="space-y-4 mb-6">
<button
onClick={() => signIn('google', { callbackUrl })}
className="w-full flex items-center justify-center gap-3 p-3 border border-gray-300 rounded-md hover:bg-gray-50 transition-colors"
disabled={isLoading}
>
<svg viewBox="0 0 24 24" width="20" height="20">
{/* Logo Google */}
<path
d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z"
fill="#4285F4"
/>
<path
d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z"
fill="#34A853"
/>
<path
d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z"
fill="#FBBC05"
/>
<path
d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z"
fill="#EA4335"
/>
</svg>
Kontynuuj z Google
</button>
<button
onClick={() => signIn('github', { callbackUrl })}
className="w-full flex items-center justify-center gap-3 p-3 border border-gray-300 rounded-md hover:bg-gray-50 transition-colors"
disabled={isLoading}
>
<svg viewBox="0 0 24 24" width="20" height="20" fill="currentColor">
{/* Logo GitHub */}
<path d="M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12" />
</svg>
Kontynuuj z GitHub
</button>
<button
onClick={() => signIn('facebook', { callbackUrl })}
className="w-full flex items-center justify-center gap-3 p-3 border border-gray-300 rounded-md hover:bg-gray-50 transition-colors"
disabled={isLoading}
>
<svg viewBox="0 0 24 24" width="20" height="20" fill="#1877F2">
{/* Logo Facebook */}
<path d="M24 12.073c0-6.627-5.373-12-12-12s-12 5.373-12 12c0 5.99 4.388 10.954 10.125 11.854v-8.385H7.078v-3.47h3.047V9.43c0-3.007 1.792-4.669 4.533-4.669 1.312 0 2.686.235 2.686.235v2.953H15.83c-1.491 0-1.956.925-1.956 1.874v2.25h3.328l-.532 3.47h-2.796v8.385C19.612 23.027 24 18.062 24 12.073z" />
</svg>
Kontynuuj z Facebook
</button>
</div>
{/* Opcjonalnie: formularz logowania email/hasło */}
<div className="relative my-6">
<div className="absolute inset-0 flex items-center">
<div className="w-full border-t border-gray-300"></div>
</div>
<div className="relative flex justify-center text-sm">
<span className="px-2 bg-white text-gray-500">
lub użyj emaila
</span>
</div>
</div>
<form onSubmit={handleEmailLogin} 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)}
className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
required
/>
</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)}
className="w-full px-3 py-2 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500"
required
/>
</div>
<button
type="submit"
className="w-full bg-blue-600 text-white py-2 px-4 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 focus:ring-offset-2 transition-colors"
disabled={isLoading}
>
{isLoading ? 'Logowanie...' : 'Zaloguj się'}
</button>
</form>
<div className="mt-6 text-center">
<p className="text-sm text-gray-600">
Nie masz jeszcze konta?{' '}
<a href="/auth/register" className="text-blue-600 hover:underline">
Zarejestruj się
</a>
</p>
</div>
</div>
);
}4. Przygotowanie schematu bazy danych Prisma
Jeśli korzystamy z adaptera Prisma, musimy zapewnić odpowiedni schemat bazy danych:
// prisma/schema.prisma
datasource db {
provider = "postgresql" // lub inny dostawca bazy danych
url = env("DATABASE_URL")
}
generator client {
provider = "prisma-client-js"
}
model Account {
id String @id @default(cuid())
userId String
type String
provider String
providerAccountId String
refresh_token String? @db.Text
access_token String? @db.Text
expires_at Int?
token_type String?
scope String?
id_token String? @db.Text
session_state String?
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
@@unique([provider, providerAccountId])
}
model Session {
id String @id @default(cuid())
sessionToken String @unique
userId String
expires DateTime
user User @relation(fields: [userId], references: [id], onDelete: Cascade)
}
model User {
id String @id @default(cuid())
name String?
email String? @unique
emailVerified DateTime?
image String?
accounts Account[]
sessions Session[]
// Dodatkowe pola specyficzne dla twojej aplikacji
username String? @unique
role String? @default("user")
createdAt DateTime @default(now())
updatedAt DateTime @updatedAt
}
model VerificationToken {
identifier String
token String @unique
expires DateTime
@@unique([identifier, token])
}5. Utworzenie SessionProvider dla całej aplikacji
Aby uwierzytelnianie działało poprawnie w całej aplikacji, dodajmy SessionProvider w głównym layoucie:
// 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";
import "./globals.css";
export const metadata = {
title: "Moja Aplikacja",
description: "Opis mojej aplikacji",
};
export default function RootLayout({
children,
}: {
children: React.ReactNode;
}) {
return (
<html lang="pl">
<body>
<Providers>{children}</Providers>
</body>
</html>
);
}6. Dodanie komponentu nawigacyjnego z obsługą stanu uwierzytelniania
Teraz stwórzmy komponent nawigacyjny, który będzie pokazywał różne opcje w zależności od tego, czy użytkownik jest zalogowany:
// components/Navigation.tsx
'use client';
import { signOut, useSession } from 'next-auth/react';
import Link from 'next/link';
import Image from 'next/image';
export default function Navigation() {
const { data: session, status } = useSession();
const isLoading = status === 'loading';
return (
<nav className="bg-white shadow-sm">
<div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
<div className="flex justify-between h-16">
<div className="flex items-center">
<Link href="/" className="shrink-0 flex items-center">
<span className="text-xl font-bold">MojaAplikacja</span>
</Link>
<div className="hidden sm:ml-6 sm:flex sm:space-x-8">
<Link
href="/"
className="border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700 inline-flex items-center px-1 pt-1 border-b-2 text-sm font-medium"
>
Strona główna
</Link>
<Link
href="/features"
className="border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700 inline-flex items-center px-1 pt-1 border-b-2 text-sm font-medium"
>
Funkcje
</Link>
<Link
href="/pricing"
className="border-transparent text-gray-500 hover:border-gray-300 hover:text-gray-700 inline-flex items-center px-1 pt-1 border-b-2 text-sm font-medium"
>
Cennik
</Link>
</div>
</div>
<div className="flex items-center">
{isLoading ? (
<div className="h-8 w-8 animate-pulse rounded-full bg-gray-200" />
) : session ? (
<div className="relative ml-3">
<div className="flex items-center space-x-4">
<Link
href="/dashboard"
className="text-sm font-medium text-gray-700 hover:text-gray-800"
>
Dashboard
</Link>
<div className="flex items-center space-x-2">
{session.user?.image ? (
<Image
className="h-8 w-8 rounded-full"
src={session.user.image}
alt={session.user.name || "Avatar"}
width={32}
height={32}
/>
) : (
<div className="h-8 w-8 rounded-full bg-blue-600 flex items-center justify-center text-white text-sm">
{session.user?.name?.charAt(0) || "U"}
</div>
)}
<span className="text-sm font-medium text-gray-700">
{session.user?.name || session.user?.email?.split('@')[0]}
</span>
</div>
<button
onClick={() => signOut({ callbackUrl: '/' })}
className="text-sm font-medium text-gray-700 hover:text-gray-800"
>
Wyloguj
</button>
</div>
</div>
) : (
<div className="space-x-4">
<Link
href="/auth/login"
className="text-gray-700 hover:text-gray-900 font-medium"
>
Zaloguj się
</Link>
<Link
href="/auth/register"
className="bg-blue-600 text-white py-2 px-4 rounded-md hover:bg-blue-700 font-medium"
>
Zarejestruj się
</Link>
</div>
)}
</div>
</div>
</div>
</nav>
);
}7. Utworzenie strony Dashboard dostępnej tylko dla zalogowanych użytkowników
Stwórzmy stronę Dashboard, która będzie dostępna tylko dla zalogowanych użytkowników:
// app/dashboard/page.tsx
import { getServerSession } from "next-auth/next";
import { redirect } from "next/navigation";
import { authOptions } from "../api/auth/[...nextauth]/route";
export default async function DashboardPage() {
const session = await getServerSession(authOptions);
if (!session) {
redirect("/auth/login?callbackUrl=/dashboard");
}
return (
<div className="max-w-7xl mx-auto py-6 sm:px-6 lg:px-8">
<div className="px-4 py-6 sm:px-0">
<h1 className="text-2xl font-bold mb-4">Dashboard</h1>
<div className="bg-white shadow overflow-hidden sm:rounded-lg">
<div className="px-4 py-5 sm:px-6">
<h3 className="text-lg leading-6 font-medium text-gray-900">
Informacje o profilu
</h3>
<p className="mt-1 max-w-2xl text-sm text-gray-500">
Szczegóły Twojego konta i ustawienia.
</p>
</div>
<div className="border-t border-gray-200">
<dl>
<div className="bg-gray-50 px-4 py-5 sm:grid sm:grid-cols-3 sm:gap-4 sm:px-6">
<dt className="text-sm font-medium text-gray-500">Imię i nazwisko</dt>
<dd className="mt-1 text-sm text-gray-900 sm:mt-0 sm:col-span-2">
{session.user?.name || "Nie podano"}
</dd>
</div>
<div className="bg-white px-4 py-5 sm:grid sm:grid-cols-3 sm:gap-4 sm:px-6">
<dt className="text-sm font-medium text-gray-500">Adres email</dt>
<dd className="mt-1 text-sm text-gray-900 sm:mt-0 sm:col-span-2">
{session.user?.email}
</dd>
</div>
<div className="bg-gray-50 px-4 py-5 sm:grid sm:grid-cols-3 sm:gap-4 sm:px-6">
<dt className="text-sm font-medium text-gray-500">Metoda logowania</dt>
<dd className="mt-1 text-sm text-gray-900 sm:mt-0 sm:col-span-2">
{/* To pole wymaga rozszerzenia tokenu o informacje o dostawcy */}
Zewnętrzny dostawca uwierzytelniania
</dd>
</div>
</dl>
</div>
</div>
</div>
</div>
);
}8. Utworzenie middleware dla ochrony ścieżek
Zabezpieczmy określone ścieżki w naszej aplikacji za pomocą middleware Next.js:
// 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 });
const isAuthPage = request.nextUrl.pathname.startsWith('/auth');
if (isAuthPage) {
if (token) {
return NextResponse.redirect(new URL('/dashboard', request.url));
}
return NextResponse.next();
}
if (!token) {
const url = new URL('/auth/login', request.url);
url.searchParams.set('callbackUrl', request.nextUrl.pathname);
return NextResponse.redirect(url);
}
return NextResponse.next();
}
// Określ ścieżki, dla których ma być stosowane middleware
export const config = {
matcher: [
'/dashboard/:path*',
'/profile/:path*',
'/settings/:path*',
'/auth/:path*'
],
};Zaawansowana konfiguracja
Modyfikacja danych profilu użytkownika
Możemy modyfikować dane profilowe z dostawców zewnętrznych przed zapisaniem ich w naszej bazie danych:
GoogleProvider({
clientId: process.env.GOOGLE_CLIENT_ID!,
clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
profile(profile) {
// Transformacja danych profilu
return {
id: profile.sub,
name: profile.name,
email: profile.email,
image: profile.picture,
// Dodatkowe pola specyficzne dla aplikacji
role: profile.email.endsWith('@twojafirma.com') ? 'admin' : 'user',
emailVerified: profile.email_verified ? new Date() : null,
};
},
});Łączenie kont z różnych dostawców
NextAuth.js automatycznie obsługuje łączenie kont różnych dostawców, jeśli używają tego samego adresu email. Jeśli chcemy to dostosować, możemy zmodyfikować funkcję linkAccount w callbackach:
callbacks: {
// ...inne callbacki
async linkAccount({ user, account, profile }) {
// Tutaj możemy wykonać niestandardową logikę łączenia kont
console.log(`Linking account: ${account.provider} for user ${user.id}`);
return true;
},
}Dodanie własnej logiki do procesu uwierzytelniania
Możemy dodać dodatkowe kroki w procesie uwierzytelniania za pomocą callbacku signIn:
callbacks: {
// ...inne callbacki
async signIn({ user, account, profile, email, credentials }) {
// Sprawdź, czy użytkownik może się zalogować
// Na przykład: sprawdź, czy email jest w domenie firmy
const allowedDomains = ['twojafirma.com', 'partner.com'];
const emailDomain = user.email?.split('@')[1];
if (emailDomain && !allowedDomains.includes(emailDomain)) {
return false; // Odmów dostępu
}
// Możemy też zaktualizować dane użytkownika przy każdym logowaniu
if (user.id) {
await prisma.user.update({
where: { id: user.id },
data: { lastLogin: new Date() }
});
}
return true; // Zezwól na dostęp
},
}Obsługa błędów uwierzytelniania
Stwórzmy niestandardową stronę błędów uwierzytelniania:
// app/auth/error/page.tsx
'use client';
import { useSearchParams } from "next/navigation";
import Link from "next/link";
export default function AuthErrorPage() {
const searchParams = useSearchParams();
const error = searchParams.get('error');
let errorMessage = "Wystąpił błąd podczas próby uwierzytelnienia.";
let errorDescription = "Prosimy spróbować ponownie lub skontaktować się z administracją.";
// Mapuj kody błędów na przyjazne dla użytkownika komunikaty
switch (error) {
case "Configuration":
errorMessage = "Wystąpił błąd konfiguracji serwera.";
errorDescription = "Skontaktuj się z administratorem systemu.";
break;
case "AccessDenied":
errorMessage = "Brak dostępu.";
errorDescription = "Nie masz wystarczających uprawnień, aby się zalogować.";
break;
case "Verification":
errorMessage = "Link weryfikacyjny wygasł lub jest nieprawidłowy.";
errorDescription = "Spróbuj wysłać link weryfikacyjny ponownie.";
break;
case "OAuthSignin":
case "OAuthCallback":
case "OAuthCreateAccount":
case "EmailCreateAccount":
case "Callback":
errorMessage = "Wystąpił błąd podczas komunikacji z dostawcą uwierzytelniania.";
errorDescription = "Spróbuj ponownie za chwilę lub wybierz inną metodę logowania.";
break;
case "OAuthAccountNotLinked":
errorMessage = "Konto z tym adresem email już istnieje.";
errorDescription = "Zaloguj się metodą, której użyłeś wcześniej.";
break;
case "EmailSignin":
errorMessage = "Nie można wysłać emaila z linkiem do logowania.";
errorDescription = "Sprawdź, czy podany adres email jest poprawny.";
break;
case "CredentialsSignin":
errorMessage = "Nieprawidłowe dane logowania.";
errorDescription = "Sprawdź, czy podany email i hasło są poprawne.";
break;
case "SessionRequired":
errorMessage = "Wymagane zalogowanie.";
errorDescription = "Zaloguj się, aby uzyskać dostęp do tej strony.";
break;
default:
// Domyślny komunikat już ustawiony
break;
}
return (
<div className="min-h-screen flex items-center justify-center bg-gray-50 py-12 px-4 sm:px-6 lg:px-8">
<div className="max-w-md w-full space-y-8">
<div>
<h2 className="mt-6 text-center text-3xl font-extrabold text-gray-900">
{errorMessage}
</h2>
<p className="mt-2 text-center text-sm text-gray-600">
{errorDescription}
</p>
</div>
<div className="flex flex-col items-center space-y-4">
<Link
href="/auth/login"
className="group relative w-full flex justify-center py-2 px-4 border border-transparent text-sm font-medium rounded-md text-white bg-blue-600 hover:bg-blue-700 focus:outline-none"
>
Wróć do strony logowania
</Link>
<Link
href="/"
className="text-sm text-blue-600 hover:text-blue-500"
>
Wróć do strony głównej
</Link>
</div>
</div>
</div>
);
}Podsumowanie
W tym module omówiliśmy szczegółowo, jak zaimplementować uwierzytelnianie z popularnymi dostawcami zewnętrznymi (Google, GitHub, Facebook) w aplikacji Next.js. Poznaliśmy:
- Proces rejestracji aplikacji u dostawców OAuth i uzyskiwania kluczy
- Konfigurację NextAuth.js / Auth.js z różnymi dostawcami
- Tworzenie interfejsu użytkownika do logowania i rejestracji
- Zabezpieczanie tras za pomocą middleware
- Dostosowywanie procesu uwierzytelniania do naszych potrzeb
- Obsługę błędów uwierzytelniania
Dzięki tej implementacji nasza aplikacja Next.js zyskuje profesjonalny, wieloplatformowy system uwierzytelniania, który poprawia doświadczenie użytkownika i jednocześnie wzmacnia bezpieczeństwo naszej aplikacji.
W następnym module zajmiemy się szczegółowo sesjami użytkownika i zarządzaniem tokenami, co pozwoli nam lepiej zrozumieć, jak działają mechanizmy uwierzytelniania po zalogowaniu użytkownika.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Demo: OAuth Providers - Google, GitHub, Facebook
interface OAuthProvider {
id: string;
name: string;
icon: string;
color: string;
scopes: string[];
requiredEnvVars: string[];
}
const providers: OAuthProvider[] = [
{ id: 'google', name: 'Google', icon: 'G', color: '#4285f4', scopes: ['openid', 'profile', 'email'], requiredEnvVars: ['GOOGLE_CLIENT_ID', 'GOOGLE_CLIENT_SECRET'] },
{ id: 'github', name: 'GitHub', icon: 'GH', color: '#333', scopes: ['read:user', 'user:email'], requiredEnvVars: ['GITHUB_ID', 'GITHUB_SECRET'] },
{ id: 'facebook', name: 'Facebook', icon: 'FB', color: '#1877f2', scopes: ['public_profile', 'email'], requiredEnvVars: ['FACEBOOK_CLIENT_ID', 'FACEBOOK_CLIENT_SECRET'] },
];
type FlowStep = 'idle' | 'redirect' | 'callback' | 'token' | 'profile' | 'done';
function OAuthFlowDemo() {
const [selectedProvider, setSelectedProvider] = useState<OAuthProvider | null>(null);
const [currentStep, setCurrentStep] = useState<FlowStep>('idle');
const [flowLog, setFlowLog] = useState<string[]>([]);
const steps: { step: FlowStep; label: string; desc: string }[] = [
{ step: 'redirect', label: '1. Redirect', desc: 'Przekierowanie do providera' },
{ step: 'callback', label: '2. Callback', desc: 'Provider zwraca code' },
{ step: 'token', label: '3. Token', desc: 'Wymiana code na token' },
{ step: 'profile', label: '4. Profile', desc: 'Pobranie profilu' },
{ step: 'done', label: '5. Done', desc: 'Sesja utworzona' },
];
const simulateFlow = async (provider: OAuthProvider) => {
setSelectedProvider(provider);
setFlowLog([]);
setCurrentStep('idle');
const addLog = (msg: string) => setFlowLog(prev => [...prev, msg]);
await new Promise(r => setTimeout(r, 400));
setCurrentStep('redirect');
addLog('[Client] Kliknieto "Zaloguj przez ' + provider.name + '"');
await new Promise(r => setTimeout(r, 1000));
setCurrentStep('callback');
addLog('[' + provider.name + '] Uzytkownik zatwierdzil dostep');
addLog('[Callback] GET /api/auth/callback?code=abc123');
await new Promise(r => setTimeout(r, 800));
setCurrentStep('token');
addLog('[Server] Wymiana authorization code na access_token');
await new Promise(r => setTimeout(r, 800));
setCurrentStep('profile');
addLog('[Server] Pobranie profilu uzytkownika z ' + provider.name);
await new Promise(r => setTimeout(r, 600));
setCurrentStep('done');
addLog('[Server] Sesja utworzona, uzytkownik zalogowany');
};
return (
<div style={{ background: '#0f0f23', minHeight: '100vh', padding: '20px', color: '#e0e0e0', fontFamily: 'system-ui' }}>
<h1 style={{ color: '#64ffda', marginBottom: '8px' }}>OAuth Providers Flow</h1>
<p style={{ color: '#8892b0', marginBottom: '24px' }}>Wizualizacja procesu logowania OAuth</p>
<div style={{ display: 'flex', gap: '16px', marginBottom: '32px', flexWrap: 'wrap' }}>
{providers.map(p => (
<button key={p.id} onClick={() => simulateFlow(p)} style={{
padding: '16px 24px', borderRadius: '12px', border: '2px solid',
borderColor: selectedProvider?.id === p.id ? p.color : '#333',
background: selectedProvider?.id === p.id ? p.color + '20' : '#1a1a2e',
color: '#fff', cursor: 'pointer', fontSize: '16px',
}}>
<div style={{ fontSize: '20px', fontWeight: 'bold' }}>{p.icon}</div>
<div style={{ marginTop: '4px' }}>{p.name}</div>
</button>
))}
</div>
{selectedProvider && (
<>
<div style={{ display: 'flex', gap: '8px', marginBottom: '24px', flexWrap: 'wrap' }}>
{steps.map(s => {
const stepIdx = steps.findIndex(x => x.step === currentStep);
const thisIdx = steps.findIndex(x => x.step === s.step);
return (
<div key={s.step} style={{
padding: '8px 16px', borderRadius: '8px', fontSize: '13px',
background: currentStep === s.step ? '#64ffda20' : thisIdx < stepIdx ? '#1a3a2e' : '#1a1a2e',
border: currentStep === s.step ? '1px solid #64ffda' : '1px solid #333',
color: currentStep === s.step ? '#64ffda' : '#8892b0',
}}>
<strong>{s.label}</strong>
<div style={{ fontSize: '11px', marginTop: '2px' }}>{s.desc}</div>
</div>
);
})}
</div>
<div style={{ background: '#1a1a2e', borderRadius: '8px', padding: '16px', border: '1px solid #333', maxHeight: '250px', overflow: 'auto' }}>
<h3 style={{ color: '#64ffda', margin: '0 0 12px 0', fontSize: '14px' }}>Flow Log:</h3>
{flowLog.map((log, i) => (
<div key={i} style={{ fontSize: '13px', padding: '4px 0', borderBottom: '1px solid #222', color: log.includes('[Server]') ? '#f59e0b' : log.includes('[Client]') ? '#64ffda' : '#8892b0' }}>
{log}
</div>
))}
</div>
<div style={{ marginTop: '16px', background: '#1a1a2e', padding: '12px', borderRadius: '8px', border: '1px solid #333' }}>
<strong style={{ color: '#f59e0b' }}>Wymagane zmienne .env:</strong>
<div style={{ marginTop: '8px', display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
{selectedProvider.requiredEnvVars.map(v => (
<code key={v} style={{ background: '#0f0f23', padding: '4px 8px', borderRadius: '4px', fontSize: '13px', color: '#64ffda' }}>{v}</code>
))}
</div>
</div>
</>
)}
</div>
);
}
export default OAuthFlowDemo;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. Session-based authentication przechowuje dane sesji:
2. Token-based authentication używa:
Zadania praktyczne w grze
- Edytor kodu
Utwórz plik [...nextauth].ts z podstawową konfiguracją providers, session i callbacks
- Układanie w pionie
Ułóż elementy w prawidłowej kolejności: import 'client-only' → export function →
- Klikanie w kolejności
Ułóż składnię importu getServerSession z NextAuth
- Edytor kodu
Skonfiguruj Google provider w NextAuth z odpowiednimi client ID, secret i scopes
Zadania po tej lekcji
- PytanieSession-based authentication przechowuje dane sesji:
- PytanieToken-based authentication używa:
- Zadanie z kodemPraktyka: Utwórz plik [...nextauth].ts z podstawową
- Ułóż w kolejnościKolejność: import 'client-only' → export function → ...
- Kliknij w kolejnościKolejność: import → { → getServerSession
- Zadanie z kodemPraktyka: Skonfiguruj Google provider w NextAuth z