Mise en place de l'authentification sur Laravel

Pour rapidement mettre en place l'authentification pour une API Laravel, nous allons utiliser la librairie Laravel Sanctum :

Laravel Sanctum est une bibliothèque qui simplifie la mise en place de l'authentification par API dans les applications Laravel. Elle utilise des jetons API pour permettre l'authentification et la protection des routes de votre application.

Voici les étapes de base pour mettre en place l'authentification par API avec Laravel Sanctum :

1. Installation de Laravel Sanctum :

composer require laravel/sanctum

2. Configuration de Sanctum :

Après avoir installé Sanctum, ajoutez le service provider dans le fichier config/app.php :

'providers' => [
    // ...
    Laravel\Sanctum\SanctumServiceProvider::class,
],

Ensuite, exécutez la commande artisan pour publier la configuration de Sanctum :

php artisan vendor:publish --provider="Laravel\Sanctum\SanctumServiceProvider"

3. Configuration de CORS (facultatif) :

Si votre application front-end est hébergée sur un domaine différent, assurez-vous de configurer les paramètres CORS dans le fichier config/sanctum.php. Ajoutez votre domaine dans la section stateful :

'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', sprintf(
        '%s%s',
        'localhost,localhost:3000,127.0.0.1,127.0.0.1:8000,::1,https://abdoulaye-diallo.com',
        Sanctum::currentApplicationUrlWithPort()
    ))),

4. Migration de la base de données :

Exécutez la migration pour créer les tables nécessaires à Sanctum :

php artisan migrate

5. Configuration du modèle User : Assurez-vous que votre modèle User utilise le trait HasApiTokens fourni par Sanctum. Ce trait permet de générer des jetons API pour les utilisateurs.

use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, Notifiable;
    // ...
}

6. Configuration des routes API :

Dans votre fichier de routes API (routes/api.php), vous pouvez utiliser les méthodes Sanctum::routes() pour définir les routes d'authentification :

use Laravel\Sanctum\Sanctum;

Sanctum::routes();

Route::middleware('auth:sanctum')->group(function () {
    // Routes protégées par Sanctum
});

7. Routes API :

Dans votre fichier routes/api.php, vous pouvez définir les routes pour ces fonctionnalités. Voici un exemple :

use App\Http\Controllers\Auth\LoginController;
use App\Http\Controllers\Auth\RegisterController;
use App\Http\Controllers\Auth\ForgotPasswordController;
use App\Http\Controllers\Auth\ResetPasswordController;

// Connexion
Route::post('/login', [LoginController::class, 'login']);

// Inscription
Route::post('/register', [RegisterController::class, 'register']);

// Mot de passe oublié
Route::post('/forgot-password', [ForgotPasswordController::class, 'sendResetLinkEmail']);

// Réinitialisation du mot de passe
Route::post('/reset-password', [ResetPasswordController::class, 'reset']);

8. Contrôleurs :

Créez les contrôleurs correspondants pour ces routes. Utilisez la commande artisan pour générer ces contrôleurs :

php artisan make:controller Auth\LoginController
php artisan make:controller Auth\RegisterController
php artisan make:controller Auth\ForgotPasswordController
php artisan make:controller Auth\ResetPasswordController

Dans ces contrôleurs, vous implémenterez la logique nécessaire pour gérer l'authentification et la réinitialisation du mot de passe.

Exemple de Contrôleur de Connexion (LoginController.php) :

namespace App\Http\Controllers\Auth;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Auth;

class LoginController extends Controller
{
    public function login(Request $request)
    {
        $credentials = $request->only('email', 'password');

        if (Auth::attempt($credentials)) {
            $user = Auth::user();
            $token = $user->createToken('token-name')->plainTextToken;

            return response()->json(['token' => $token]);
        }

        return response()->json(['message' => 'Invalid credentials'], 401);
    }
}

Exemple de Contrôleur d'Inscription (RegisterController.php) :

namespace App\Http\Controllers\Auth;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\Models\User;
use Illuminate\Support\Facades\Hash;

class RegisterController extends Controller
{
    public function register(Request $request)
    {
        $request->validate([
            'name' => 'required|string',
            'email' => 'required|email|unique:users,email',
            'password' => 'required|min:8',
        ]);

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

        return response()->json(['message' => 'Registration successful', 'user' => $user]);
    }
}

Exemple de Contrôleur de Mot de Passe Oublié (ForgotPasswordController.php) :

namespace App\Http\Controllers\Auth;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Password;

class ForgotPasswordController extends Controller
{
    public function sendResetLinkEmail(Request $request)
    {
        $request->validate(['email' => 'required|email']);

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

        return $status === Password::RESET_LINK_SENT
            ? response()->json(['message' => __($status)])
            : response()->json(['error' => __($status)], 500);
    }
}

Exemple de Contrôleur de Réinitialisation du Mot de Passe (ResetPasswordController.php) :

namespace App\Http\Controllers\Auth;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Password;
use Illuminate\Support\Facades\Hash;

class ResetPasswordController extends Controller
{
    public function reset(Request $request)
    {
        $request->validate([
            'token' => 'required|string',
            'email' => 'required|email',
            'password' => 'required|min:8|confirmed',
        ]);

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

        return $status === Password::PASSWORD_RESET
            ? response()->json(['message' => __($status)])
            : response()->json(['error' => __($status)], 500);
    }
}