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

Podłączanie dostawców (Google, GitHub, Facebook)

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

  1. Lepsze doświadczenie użytkownika - szybszy i wygodniejszy proces logowania, bez konieczności wymyślania i zapamiętywania nowych danych logowania
  2. Wyższy współczynnik rejestracji - mniejsza liczba porzuconych rejestracji dzięki uproszczonemu procesowi
  3. Większe bezpieczeństwo - dostawcy jak Google czy Facebook stosują zaawansowane mechanizmy ochrony kont
  4. Dodatkowe informacje - możliwość pozyskania dodatkowych danych o użytkowniku (za jego zgodą), takich jak zdjęcie profilowe czy informacje kontaktowe
  5. 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

  1. Przejdź do Google Cloud Console
  2. Utwórz nowy projekt lub wybierz istniejący
  3. Przejdź do "APIs & Services" > "Credentials"
  4. Kliknij "Create Credentials" > "OAuth client ID"
  5. Wybierz typ aplikacji (Web application)
  6. 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)
  7. Zapisz ID klienta (Client ID) i tajny klucz klienta (Client Secret)

GitHub OAuth

  1. Zaloguj się na GitHub
  2. Przejdź do Settings > Developer settings > OAuth Apps
  3. Kliknij "New OAuth App"
  4. Wypełnij formularz:
    • Application name: nazwa twojej aplikacji
    • Homepage URL: np. http://localhost:3000
    • Authorization callback URL: http://localhost:3000/api/auth/callback/github
  5. Zarejestruj aplikację
  6. Wygeneruj nowy Client Secret i zapisz go wraz z Client ID

Facebook OAuth

  1. Przejdź do Facebook Developers
  2. Utwórz nową aplikację (wybierz "For Everything Else" jako typ)
  3. W panelu aplikacji dodaj "Facebook Login" i wybierz "Web"
  4. W ustawieniach dodaj dozwolone domeny:
    • localhost (dla środowiska deweloperskiego)
    • twoja-domena.com (dla produkcji)
  5. W ustawieniach uwierzytelniania dodaj przekierowanie OAuth:
    • http://localhost:3000/api/auth/callback/facebook
  6. 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_secret

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

  1. Proces rejestracji aplikacji u dostawców OAuth i uzyskiwania kluczy
  2. Konfigurację NextAuth.js / Auth.js z różnymi dostawcami
  3. Tworzenie interfejsu użytkownika do logowania i rejestracji
  4. Zabezpieczanie tras za pomocą middleware
  5. Dostosowywanie procesu uwierzytelniania do naszych potrzeb
  6. 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. 1. Session-based authentication przechowuje dane sesji:

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

  1. PytanieSession-based authentication przechowuje dane sesji:
  2. PytanieToken-based authentication używa:
  3. Zadanie z kodemPraktyka: Utwórz plik [...nextauth].ts z podstawową
  4. Ułóż w kolejnościKolejność: import 'client-only' → export function → ...
  5. Kliknij w kolejnościKolejność: import → { → getServerSession
  6. Zadanie z kodemPraktyka: Skonfiguruj Google provider w NextAuth z

Przydatne artykuły