Communitygithub.com

ASoudy/AGS

Intégration experte de Supabase Auth avec le App Router de Next.js

Qu'est-ce que AGS ?

Cette compétence fournit une intégration experte de l'authentification Supabase avec le App Router de Next.js. Elle inclut des configurations client et serveur, un middleware de protection de routes et de rafraîchissement de sessions, une route de callback OAuth, des opérations d'authentification dans les Server Actions, et l'accès à l'utilisateur connecté dans les Server Components. Le skill est destiné aux développeurs utilisant Next.js App Router et souhaitant implémenter une authentification robuste avec Supabase. Il propose également des validations pour détecter les erreurs courantes comme l'utilisation de `getSession()` au lieu de `getUser()`, l'absence de route de callback OAuth, ou l'utilisation d'un client navigateur dans un contexte serveur. Le skill collabore avec `nextjs-app-router`, `supabase-backend` et d'autres compétences pour une pile d'authentification complète.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/ASoudy/AGS/tree/HEAD/AGAS/plugins/antigravity-awesome-skills-claude/skills/nextjs-supabase-auth

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

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.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

ASoudy/AGS

Advanced JavaScript animation library skill for creating complex, high-performance web animations.

ASoudy/AGS

Astropy is the core Python package for astronomy, providing essential functionality for astronomical research and data analysis.

ASoudy/AGS

Build content-focused websites with Astro — zero JS by default, islands architecture, multi-framework components, and Markdown/MDX support.

ASoudy/AGS

One sentence - what this skill does and when to invoke it

ASoudy/AGS

Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects. Use when animations stutter, transitions jank, or reviewing CSS/JS animation performance.

ASoudy/AGS

Internationalization and localization patterns. Detecting hardcoded strings, managing translations, locale files, RTL support.

ASoudy/AGS

Pull a YouTube video transcript into a queryable markdown vault with yt-dlp subtitle discovery, VTT cleanup, metadata frontmatter, and capture-seed stubs.

ASoudy/AGS

Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences. Covers developer portfolios, designer portfolios, creative portfolios, and portfolios that convert visitors into opportunities.

ASoudy/AGS

Generates high-converting Next.js/React landing pages with Tailwind CSS. Uses PAS, AIDA, and BAB frameworks for optimized copy/components (Heroes, Features, Pricing). Focuses on Core Web Vitals/SEO.

ASoudy/AGS

AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

ASoudy/AGS

CRITICAL: Use for Makepad animation system. Triggers on: makepad animation, makepad animator, makepad hover, makepad state, makepad transition, "from: { all: Forward", makepad pressed, makepad 动画, makepad 状态, makepad 过渡, makepad 悬停效果

ASoudy/AGS

Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

ASoudy/AGS

Next.js App Router principles. Server Components, data fetching, routing patterns.

ASoudy/AGS

React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

ASoudy/AGS

Best practices for Remotion - Video creation in React

ASoudy/AGS

Generate walkthrough videos from Stitch projects using Remotion with smooth transitions, zooming, and text overlays

ASoudy/AGS

Seek and analyze video content using Memories.ai Large Visual Memory Model for persistent video intelligence

ASoudy/AGS

Writes complete, structured landing pages optimized for SEO ranking, AEO citation, and visitor conversion. Activate when the user wants to write or generate a landing page for a product, service, or offer.

ASoudy/AGS

Three.js animation - keyframe animation, skeletal animation, morph targets, animation mixing. Use when animating objects, playing GLTF animations, creating procedural motion, or blending animations.

ASoudy/AGS

Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Skills associés