Next.js + Supabase Auth
Intégration experte de Supabase Auth avec le App Router de Next.js
Capacités
- nextjs-auth
- supabase-auth-nextjs
- auth-middleware
- auth-callback
Prérequis
- Compétences requises : nextjs-app-router, supabase-backend
Patterns
Configuration du client Supabase
Créez des clients Supabase correctement configurés pour différents contextes
Quand utiliser : Mise en place de l'authentification dans un projet Next.js
// lib/supabase/client.ts (Client navigateur)
'use client'
import { createBrowserClient } from '@supabase/ssr'
export function createClient() {
return createBrowserClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!
)
}
// lib/supabase/server.ts (Client serveur)
import { createServerClient } from '@supabase/ssr'
import { cookies } from 'next/headers'
export async function createClient() {
const cookieStore = await cookies()
return createServerClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
{
cookies: {
getAll() {
return cookieStore.getAll()
},
setAll(cookiesToSet) {
cookiesToSet.forEach(({ name, value, options }) => {
cookieStore.set(name, value, options)
})
},
},
}
)
}
Middleware d'authentification
Protégez les routes et rafraîchissez les sessions dans le middleware
Quand utiliser : Vous avez besoin de protection de route ou de rafraîchissement de session
// middleware.ts
import { createServerClient } from '@supabase/ssr'
import { NextResponse, type NextRequest } from 'next/server'
export async function middleware(request: NextRequest) {
let response = NextResponse.next({ request })
const supabase = createServerClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
{
cookies: {
getAll() {
return request.cookies.getAll()
},
setAll(cookiesToSet) {
cookiesToSet.forEach(({ name, value, options }) => {
response.cookies.set(name, value, options)
})
},
},
}
)
// Rafraîchir la session si expirée
const { data: { user } } = await supabase.auth.getUser()
// Protéger les routes du tableau de bord
if (request.nextUrl.pathname.startsWith('/dashboard') && !user) {
return NextResponse.redirect(new URL('/login', request.url))
}
return response
}
export const config = {
matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
}
Route de callback d'authentification
Gérez le callback OAuth et échangez le code contre une session
Quand utiliser : Utilisation de fournisseurs OAuth (Google, GitHub, etc.)
// app/auth/callback/route.ts
import { createClient } from '@/lib/supabase/server'
import { NextResponse } from 'next/server'
export async function GET(request: Request) {
const { searchParams, origin } = new URL(request.url)
const code = searchParams.get('code')
const next = searchParams.get('next') ?? '/'
if (code) {
const supabase = await createClient()
const { error } = await supabase.auth.exchangeCodeForSession(code)
if (!error) {
return NextResponse.redirect(`${origin}${next}`)
}
}
return NextResponse.redirect(`${origin}/auth/error`)
}
Authentification dans une Server Action
Gérez les opérations d'authentification dans les Server Actions
Quand utiliser : Connexion, déconnexion ou inscription depuis les Server Components
// app/actions/auth.ts
'use server'
import { createClient } from '@/lib/supabase/server'
import { redirect } from 'next/navigation'
import { revalidatePath } from 'next/cache'
export async function signIn(formData: FormData) {
const supabase = await createClient()
const { error } = await supabase.auth.signInWithPassword({
email: formData.get('email') as string,
password: formData.get('password') as string,
})
if (error) {
return { error: error.message }
}
revalidatePath('/', 'layout')
redirect('/dashboard')
}
export async function signOut() {
const supabase = await createClient()
await supabase.auth.signOut()
revalidatePath('/', 'layout')
redirect('/')
}
Obtenir l'utilisateur dans un Server Component
Accédez à l'utilisateur authentifié dans les Server Components
Quand utiliser : Affichage de contenu spécifique à l'utilisateur côté serveur
// app/dashboard/page.tsx
import { createClient } from '@/lib/supabase/server'
import { redirect } from 'next/navigation'
export default async function DashboardPage() {
const supabase = await createClient()
const { data: { user } } = await supabase.auth.getUser()
if (!user) {
redirect('/login')
}
return (
<div>
<h1>Bienvenue, {user.email}</h1>
</div>
)
}
Validations
Utilisation de getSession() pour les vérifications d'authentification
Sévérité : ERREUR
Message : getSession() ne vérifie pas le JWT. Utilisez getUser() pour des vérifications d'authentification sécurisées.
Action corrective : Remplacez getSession() par getUser() pour les vérifications critiques pour la sécurité
OAuth sans route de callback
Sévérité : ERREUR
Message : Utilisation d'OAuth mais absence de route de callback à app/auth/callback/route.ts
Action corrective : Créez app/auth/callback/route.ts pour gérer les redirections OAuth
Client navigateur dans un contexte serveur
Sévérité : ERREUR
Message : Client navigateur utilisé dans un contexte serveur. Utilisez createServerClient à la place.
Action corrective : Importez et utilisez createServerClient depuis @supabase/ssr
Routes protégées sans middleware
Sévérité : AVERTISSEMENT
Message : Aucun fichier middleware.ts trouvé. Envisagez d'ajouter un middleware pour la protection des routes.
Action corrective : Créez middleware.ts pour protéger les routes et rafraîchir les sessions
URL de redirection d'authentification codée en dur
Sévérité : AVERTISSEMENT
Message : Redirection localhost codée en dur. Utilisez l'origine pour une flexibilité d'environnement.
Action corrective : Utilisez window.location.origin ou process.env.NEXT_PUBLIC_SITE_URL
Appel d'authentification sans gestion d'erreur
Sévérité : AVERTISSEMENT
Message : Opération d'authentification sans gestion d'erreur. Vérifiez toujours les erreurs.
Action corrective : Déstructurez { data, error } et gérez le cas d'erreur
Action d'authentification sans revalidation
Sévérité : AVERTISSEMENT
Message : Action d'authentification sans revalidatePath. Le cache peut afficher un état d'authentification obsolète.
Action corrective : Ajoutez revalidatePath('/', 'layout') après les opérations d'authentification
Protection de route côté client uniquement
Sévérité : AVERTISSEMENT
Message : La protection de route côté client affiche un flash de contenu. Utilisez le middleware.
Action corrective : Déplacez la protection dans middleware.ts pour une meilleure expérience utilisateur
Collaboration
Déclencheurs de délégation
- database|rls|queries|tables -> supabase-backend (L'authentification a besoin de la couche base de données)
- route|page|component|layout -> nextjs-app-router (L'authentification a besoin des patterns Next.js)
- deploy|production|vercel -> vercel-deployment (L'authentification a besoin de la configuration de déploiement)
- ui|form|button|design -> frontend (L'authentification a besoin de composants d'interface)
Pile d'authentification complète
Compétences : nextjs-supabase-auth, supabase-backend, nextjs-app-router, vercel-deployment
Workflow :
1. Configuration de la base de données (supabase-backend)
2. Implémentation de l'authentification (nextjs-supabase-auth)
3. Protection des routes (nextjs-app-router)
4. Configuration du déploiement (vercel-deployment)
SaaS protégé
Compétences : nextjs-supabase-auth, stripe-integration, supabase-backend
Workflow :
1. Authentification utilisateur (nextjs-supabase-auth)
2. Synchronisation des clients (stripe-integration)
3. Abonnement (supabase-backend)
Compétences associées
Fonctionne bien avec : nextjs-app-router, supabase-backend
Quand l'utiliser
- L'utilisateur mentionne ou sous-entend : supabase auth next
- L'utilisateur mentionne ou sous-entend : authentication next.js
- L'utilisateur mentionne ou sous-entend : login supabase
- L'utilisateur mentionne ou sous-entend : auth middleware
- L'utilisateur mentionne ou sous-entend : protected route
- L'utilisateur mentionne ou sous-entend : auth callback
- L'utilisateur mentionne ou sous-entend : session management
Limitations
- Utilisez cette compétence uniquement lorsque la tâche correspond clairement à la portée décrite ci-dessus.
- Ne traitez pas la sortie comme un substitut à une validation, un test ou une révision experte spécifique à l'environnement.
- Arrêtez-vous et demandez des clarifications si les entrées, autorisations, limites de sécurité ou critères de succès requis sont manquants.