NextAuth + Django JWT: jednolita autoryzacja

Integracja NextAuth z Django JWT: jednolita autoryzacja bez powielania

NextAuth w Next.js i Django REST Framework z JWT często konfliktują przy autoryzacji. Użytkownik loguje się raz na froncie, otrzymuje access i refresh tokeny od Django, po czym wszystkie zapytania API używają jednego klienta z auto-odświeżaniem tokenów. Dostawcy OAuth synchronizują się z backendem bez drugiej formy logowania.

Podział ról w architekturze

NextAuth zarządza sesją UI, formularzami logowania i OAuth. Django odpowiada za model domenowy użytkownika, wydawanie JWT i ochronę API przez JWTAuthentication. Frontend nie generuje tokenów samodzielnie — tylko Django jest źródłem dostępu do API. Tokeny są przechowywane w sesji NextAuth.

Kluczowe zalety schematu:

• Brak ręcznego localStorage dla access token
• Automatyczny refresh bez błędów 401
• Synchronizacja OAuth bez powielającego logowania
• Jeden axios-klient dla wszystkich zapytań

Django: użytkownik email-first i niestandardowy JWT

Model użytkownika używa email jako USERNAME_FIELD. To upraszcza integrację z OAuth, gdzie nazwa użytkownika nie zawsze jest dostępna.

# auth_app/models.py
from django.contrib.auth.models import AbstractUser
from django.db import models
from django.contrib.auth.models import BaseUserManager

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError("The Email field must be set")
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password=None, **extra_fields):
        extra_fields.setdefault("is_staff", True)
        extra_fields.setdefault("is_superuser", True)
        return self.create_user(email, password, **extra_fields)


class User(AbstractUser):
    email = models.EmailField(unique=True)
    name = models.CharField(max_length=100, blank=True)
    provider = models.CharField(max_length=50, default="credentials", blank=True, null=True)

    USERNAME_FIELD = "email"
    REQUIRED_FIELDS = []

    objects = CustomUserManager()

W settings.py: AUTH_USER_MODEL = "auth_app.User". Podłączone są rest_framework_simplejwt, dj_rest_auth, allauth.

Niestandardowy TokenObtainPairSerializer dodaje do tokenu pola email, name, provider:

# auth_app/serializers.py
from rest_framework_simplejwt.serializers import TokenObtainPairSerializer

class CustomTokenObtainPairSerializer(TokenObtainPairSerializer):
    @classmethod
    def get_token(cls, user):
        token = super().get_token(user)
        token["email"] = user.email
        token["name"] = user.name
        token["provider"] = user.provider
        return token

    def validate(self, attrs):
        credentials = {
            "email": attrs.get("email"),
            "password": attrs.get("password"),
        }
        return super().validate(credentials)

Widok logowania sprawdza weryfikację email i zwraca tokeny + dane użytkownika:

# auth_app/views.py
class CustomTokenObtainPairView(TokenObtainPairView):
    serializer_class = CustomTokenObtainPairSerializer

    def post(self, request, *args, **kwargs):
        serializer = self.get_serializer(data=request.data)
        serializer.is_valid(raise_exception=True)

        user = serializer.user
        email_address = EmailAddress.objects.filter(user=user, email=user.email).first()
        if not email_address or not email_address.verified:
            raise AuthenticationFailed(detail="Email address is not verified.")

        return Response(
            {
                "access": serializer.validated_data["access"],
                "refresh": serializer.validated_data["refresh"],
                "user": {
                    "email": user.email,
                    "name": user.name,
                    "id": user.id,
                },
            },
            status=status.HTTP_200_OK,
        )

Next.js: Dostawca Credentials jako proxy do Django

Dostawca Credentials przekazuje email/hasło do Django i zapisuje otrzymane tokeny w sesji:

// src/lib/auth/authOptions.ts
import { NextAuthOptions } from "next-auth";
import GoogleProvider from "next-auth/providers/google";
import CredentialsProvider from "next-auth/providers/credentials";
import apiClient from "@/services/authClientService";

const baseURL = process.env.NEXT_PUBLIC_API_BASE_URL;

export const authOptions: NextAuthOptions = {
  providers: [
    GoogleProvider({
      clientId: process.env.GOOGLE_CLIENT_ID as string,
      clientSecret: process.env.GOOGLE_CLIENT_SECRET as string,
    }),
    CredentialsProvider({
      name: "Credentials",
      credentials: {
        email: { label: "Email", type: "text" },
        password: { label: "Password", type: "password" },
      },
      async authorize(credentials) {
        if (!credentials?.email || !credentials.password) {
          throw new Error("Email and password must be provided");
        }

        const { data } = await apiClient.post(`${baseURL}/api/auth/custom/login/`, {
          email: credentials.email,
          password: credentials.password,
        });

        if (data?.user) {
          const { id, name, email } = data.user;
          return {
            id: id.toString(),
            name,
            email,
            accessToken: data.access || null,
            refreshToken: data.refresh || null,
          };
        }

        return null;
      },
    }),
  ],

Synchronizacja OAuth: endpoint register-or-login

Po OAuth Google wykonywane jest zapytanie register-or-login. Django tworzy lub aktualizuje użytkownika i wydaje JWT:

callbacks: {
  async signIn({ user, account }) {
    const allowedProviders = ["google", "apple"];

    if (account?.provider && allowedProviders.includes(account.provider)) {
      const res = await apiClient.post(
        `${baseURL}/api/auth/custom/oauth/register-or-login/`,
        {
          id: user.id,
          name: user.name,
          email: user.email,
          provider: account.provider,
        }
      );

      if (res.status === 200) {
        user.accessToken = res.data.access;
        user.refreshToken = res.data.refresh;
        return true;
      }

      return false;
    }

    return true;
  },
},

Endpoint Django:

class CustomOAuthRegisterOrLoginView(APIView):
    permission_classes = [AllowAny]

    def post(self, request, *args, **kwargs):
        serializer = OAuthUserSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        data = serializer.validated_data

        provider = data["provider"]
        email = data["email"]
        name = data["name"]
        user_id = data["id"]

        user, created = User.objects.get_or_create(
            email=email,
            defaults={
                "name": name,
                "provider": provider,
                "username": user_id,
            },
        )

        if not created:
            user.name = name
            user.provider = provider
            user.save()

        refresh = RefreshToken.for_user(user)
        access = str(refresh.access_token)

        return Response(
            {
                "message": "User successfully synchronized.",
                "user": {
                    "email": user.email,
                    "name": user.name,
                    "provider": user.provider,
                },
                "access": access,
                "refresh": str(refresh),
            },
            status=status.HTTP_200_OK,
        )

Optymalizacja JWT i callbacks sesji

W JWT i sesji zapisywane są tylko id, accessToken, refreshToken. Nadmiarowe dane są wykluczane dla minimalizacji rozmiaru:

async jwt({ token, user }) {
  if (user) {
    token.id = user.id.toString();
    token.accessToken = user.accessToken || null;
    token.refreshToken = user.refreshToken || null;
  }
  return token;
},

async session({ session, token }) {
  session.user = {
    ...session.user,
    id: token.id as string,
  };
  session.accessToken = token.accessToken || null;
  session.refreshToken = token.refreshToken || null;
  return session;
},

Co jest ważne

• Jedno źródło tokenów: Django JWT — jedyne źródło dostępu do API
• Auto-synchronizacja OAuth: register-or-login eliminuje powielające logowanie
• Minimalna sesja: tylko id + tokeny, bez zbędnych pól
• Weryfikacja email: wbudowana w logowanie dla spójności
• Interceptor Axios: automatyczny refresh i wylogowanie przy 401

— Editorial Team