Swell

Authentification

Système d'authentification complet dans Swell avec Laravel 12 - login, register, 2FA, mot de passe oublié, vérification email et gestion de profil.

Système d'authentification complet

Swell intègre un système d'authentification moderne et sécurisé basé sur Laravel 12, offrant toutes les fonctionnalités essentielles pour gérer les utilisateurs de votre application e-commerce.

Le système couvre l'ensemble du cycle de vie utilisateur : inscription, connexion, vérification d'email, authentification à deux facteurs (2FA), récupération de mot de passe et gestion de profil.

Fonctionnalités d'authentification

Inscription (Register)

L'inscription permet aux nouveaux utilisateurs de créer un compte avec validation des données et vérification d'email optionnelle.

Route : GET /register et POST /register

Champs requis :

  • Nom
  • Adresse email (unique)
  • Mot de passe (avec confirmation)
app/Http/Controllers/Auth/RegisteredController.php
public function store(Request $request): RedirectResponse
{
    $request->validate([
        'name' => 'required|string|max:255',
        'email' => 'required|string|lowercase|email|max:255|unique:'.User::class,
        'password' => ['required', 'confirmed', Rules\Password::defaults()],
    ], [
        'name.required' => 'Le nom est requis',
        'name.max' => 'Le nom ne peut pas dépasser 255 caractères',
        'email.required' => 'L\'adresse e-mail est requise',
        'email.email' => 'L\'adresse e-mail doit être valide',
        'email.lowercase' => 'L\'adresse e-mail doit être en minuscules',
        'email.max' => 'L\'adresse e-mail ne peut pas dépasser 255 caractères',
        'email.unique' => 'Cette adresse e-mail est déjà utilisée',
        'password.required' => 'Le mot de passe est requis',
        'password.confirmed' => 'La confirmation du mot de passe ne correspond pas',
    ]);

    $user = User::create([
        'name' => $request->name,
        'email' => $request->email,
        'password' => Hash::make($request->password),
    ]);

    event(new Registered($user));

    Auth::login($user);

    return redirect()->intended(route('dashboard', absolute: false));
}

Connexion (Login)

La connexion supporte l'authentification par email/mot de passe avec option "Se souvenir de moi" et protection contre les attaques par force brute.

Route : GET /login et POST /login

app/Http/Controllers/Auth/AuthenticatedSessionController.php
public function store(LoginRequest $request): RedirectResponse
{
    $request->authenticate();

    $request->session()->regenerate();

    return redirect()->intended(route('dashboard', absolute: false));
}

Protection contre les attaques :

  • Limitation du nombre de tentatives
  • Verrouillage temporaire après échecs répétés

Mot de passe oublié

Système de récupération de mot de passe par email avec tokens sécurisés et expiration.

Demande de réinitialisation :

app/Http/Controllers/Auth/PasswordResetLinkController.php
public function store(Request $request): RedirectResponse
{
    $request->validate([
        'email' => 'required|email',
    ]);

    Password::sendResetLink(
        $request->only('email')
    );

    return back()->with('status', __('A reset link will be sent if the account exists.'));
}

Réinitialisation du mot de passe :

app/Http/Controllers/Auth/NewPasswordController.php
public function store(Request $request): RedirectResponse
{
    $request->validate([
        'token' => 'required',
        'email' => 'required|email',
        'password' => ['required', 'confirmed', Rules\Password::defaults()],
    ]);

    $status = Password::reset(
        $request->only('email', 'password', 'password_confirmation', 'token'),
        function ($user) use ($request) {
            $user->forceFill([
                'password' => Hash::make($request->password),
                'remember_token' => Str::random(60),
            ])->save();

            event(new PasswordReset($user));
        }
    );

    if ($status == Password::PASSWORD_RESET) {
        return to_route('login')->with('status', __($status));
    }

    throw ValidationException::withMessages([
        'email' => [__($status)],
    ]);
}

Vérification d'email

Système de vérification d'email obligatoire ou optionnel selon les pages via middleware.

Middleware de vérification :

app/Http/Middleware/EnsureEmailIsVerified.php
public function handle($request, Closure $next, $redirectToRoute = null)
{
    if (! $request->user() ||
        ($request->user() instanceof MustVerifyEmail &&
        ! $request->user()->hasVerifiedEmail())) {
        return $request->expectsJson()
            ? abort(403, 'Your email address is not verified.')
            : Redirect::guest(URL::route($redirectToRoute ?: 'verification.notice'));
    }

    return $next($request);
}

Renvoi de l'email de vérification :

app/Http/Controllers/Auth/EmailVerificationNotificationController.php
public function store(Request $request): RedirectResponse
{
    if ($request->user()->hasVerifiedEmail()) {
        return redirect()->intended(route('dashboard', absolute: false));
    }

    $request->user()->sendEmailVerificationNotification();

    return back()->with('status', 'verification-link-sent');
}

Gestion de profil utilisateur

Modification des informations personnelles

app/Http/Controllers/Settings/ProfileController.php
public function update(ProfileUpdateRequest $request): RedirectResponse
{
    $request->user()->fill($request->validated());

    if ($request->user()->isDirty('email')) {
        $request->user()->email_verified_at = null;
    }

    if ($request->hasFile('avatar')) {
        $request->user()->update(['avatar' => $request->file('avatar')->store('avatars', 'public')]);
    }

    $request->user()->save();

    return to_route('profile.edit');
}

Changement de mot de passe

app/Http/Controllers/Settings/PasswordController.php
public function update(Request $request): RedirectResponse
{
    $validated = $request->validate([
        'current_password' => ['required', 'current_password'],
        'password' => ['required', Password::defaults(), 'confirmed'],
    ]);

    $request->user()->update([
        'password' => Hash::make($validated['password']),
    ]);

    return back();
}

Suppression de compte

app/Http/Controllers/Settings/ProfileController.php
public function destroy(Request $request): RedirectResponse
{
    $request->validate([
        'password' => ['required', 'current_password'],
    ]);

    $user = $request->user();

    Auth::logout();

    $user->delete();

    $request->session()->invalidate();
    $request->session()->regenerateToken();

    return redirect('/');
}

Configuration et sécurité

Variables d'environnement

.env
# Session
SESSION_LIFETIME=120
SESSION_ENCRYPT=true
SESSION_SECURE_COOKIE=true

Middleware de sécurité

Protection des routes authentifiées :

routes/web.php
Route::middleware(['auth', 'verified'])->group(function () {
    Route::get('/dashboard', [DashboardController::class, 'index'])->name('dashboard');
    Route::get('/profile', [ProfileController::class, 'edit'])->name('profile.edit');
});

Interface utilisateur

Composants React d'authentification

Swell fournit des composants React prêts à l'emploi pour toutes les fonctionnalités d'authentification :

  • auth/login - Page de connexion
  • auth/register - Page d'inscription
  • auth/forgot-password - Page de réinitialisation du mot de passe
  • auth/reset-password - Nouveau mot de passe
  • auth/verify-email - Invitation à vérifier l'email
  • settings/profile - Modification du profil
  • settings/password - Changement de mot de passe

Layouts d'authentification

Plusieurs layouts sont disponibles selon le design souhaité :

resources/js/layouts/auth/
- auth-card-layout.tsx
- auth-simple-layout.tsx
- auth-split-layout.tsx

Plus d'info sur la documentation de Laravel

Tests

Swell inclut une suite de tests complète pour l'authentification dans le dossier tests/Feature/Auth/.

Structure des tests

tests/Feature/Auth/
├── AuthenticationTest.php          # Tests de connexion/déconnexion
├── EmailVerificationTest.php       # Tests de vérification d'email
├── PasswordConfirmationTest.php    # Tests de confirmation de mot de passe
├── PasswordResetTest.php           # Tests de réinitialisation
├── RegistrationTest.php            # Tests d'inscription

Exemples de tests

Test d'inscription :

tests/Feature/Auth/RegistrationTest.php
test('new users can register', function () {
    $response = $this->post('/register', [
        'name' => 'Test User',
        'email' => 'test@example.com',
        'password' => 'password',
        'password_confirmation' => 'password',
    ]);

    $this->assertAuthenticated();
    $response->assertRedirect(route('dashboard', absolute: false));
});

Test de connexion :

tests/Feature/Auth/AuthenticationTest.php
test('users can authenticate using the login screen', function () {
    $user = User::factory()->create();

    $response = $this->post('/login', [
        'email' => $user->email,
        'password' => 'password',
    ]);

    $this->assertAuthenticated();
    $response->assertRedirect(route('dashboard', absolute: false));
});

Exécution des tests

# Tous les tests d'authentification
php artisan test tests/Feature/Auth/

# Test spécifique
php artisan test tests/Feature/Auth/RegistrationTest.php

# Avec couverture de code
php artisan test --coverage tests/Feature/Auth/

Les tests couvrent tous les scénarios : connexion, inscription, 2FA, récupération de mot de passe, vérification d'email et gestion de profil avec validation des cas d'erreur et de succès.