L'API d'Atelier.

Créer l'API Laravel

Avoir un projet Laravel « atelier-api » qui tourne sur ta machine, avec le mode API activé dès le départ.

1. Vérifie PHP : php -v (8.2+) et composer -V. Sinon installe-les.
2. Crée le projet avec Composer.
3. Active les routes API (crée routes/api.php + Sanctum), puis lance le serveur.

terminalcomposer create-project laravel/laravel atelier-api
cd atelier-api
php artisan install:api   # crée routes/api.php + installe Sanctum
php artisan serve      # → http://localhost:8000

• localhost:8000 affiche la page d'accueil Laravel.
• routes/api.php existe ; GET /api/user répond 401 sans token — c'est normal, la route est protégée.

MVC & la première route JSON

Comprendre le trajet d'une requête — route → contrôleur → réponse JSON — et la différence entre web.php et api.php.

1. Génère un contrôleur.
2. Déclare une route dans routes/api.php.
3. Renvoie un tableau : Laravel le sérialise en JSON tout seul.

terminalphp artisan make:controller ClientController

routes/api.phpuse App\Http\Controllers\ClientController;

Route::get('/clients', [ClientController::class, 'index']);

app/Http/Controllers/ClientController.phppublic function index()
{
    return response()->json([
        ['id' => 1, 'nom' => 'Boulangerie Zitoun'],
    ]);
}

• GET localhost:8000/api/clients renvoie le JSON (statut 200, en-tête Content-Type: application/json).
• Tu sais expliquer : api.php est préfixé par /api et renvoie des données ; web.php renvoie des pages.

Routes de ressource & codes de statut

Exposer les cinq points d'entrée REST d'une ressource proprement, avec les bons verbes HTTP et les bons codes de statut.

1. Régénère le contrôleur en contrôleur de ressource API (--api).
2. Déclare la ressource en une ligne avec apiResource.
3. Renvoie les codes qui comptent : 201 (créé), 204 (supprimé), 404 (introuvable).

terminalphp artisan make:controller ClientController --api

routes/api.phpRoute::apiResource('clients', ClientController::class);
// → GET /clients · POST /clients · GET /clients/{id}
//   PUT/PATCH /clients/{id} · DELETE /clients/{id}

les codes de statut qui comptentreturn response()->json($client, 201);   // créé
return response()->noContent();          // 204, après delete
abort(404);                            // introuvable

• php artisan route:list montre les cinq routes clients.
• Un POST réussi renvoie 201 ; un GET sur un id inconnu renvoie 404.

Laravel en API pure

Comprendre la différence entre une vue Blade (HTML rendu serveur) et une API (JSON pour une SPA) — et renvoyer les clients au même format que json-server, pour qu'Angular ne voie aucune différence.

1. Garde web.php pour une page d'accueil simple, api.php pour les données.
2. Renvoie une liste de clients aux mêmes clés que db.json.
3. Note que le client de cette API, c'est le front Angular.

web.php vs api.php// web.php — une VUE (HTML rendu serveur, Blade)
Route::get('/', fn () => view('welcome'));

// api.php — des DONNÉES (JSON pour la SPA Angular)
Route::get('/clients', fn () => [
    ['id' => 1, 'nom' => 'Boulangerie Zitoun',
     'email' => 'z@ex.tn', 'telephone' => '22 000 111'],
]);   // Laravel sérialise le tableau en JSON

• GET /api/clients renvoie exactement la forme attendue par Angular (mêmes clés que db.json).
• Tu sais dire pourquoi Atelier n'utilise pas Blade côté produit : le front, c'est Angular ; Laravel ne sert que des données.

Authentification (Sanctum)

Une connexion qui renvoie un token, et des routes protégées — exactement le token que l'intercepteur Angular envoie.

1. Sanctum est déjà installé (étape 1). Crée un AuthController.
2. login vérifie les identifiants et renvoie un token.
3. Protège les routes de ressource avec auth:sanctum.

app/Http/Controllers/AuthController.phppublic function login(Request $request)
{
    $request->validate(['email' => 'required|email', 'password' => 'required']);

    $user = User::where('email', $request->email)->first();
    if (! $user || ! Hash::check($request->password, $user->password)) {
        return response()->json(['message' => 'Identifiants invalides'], 401);
    }
    return ['token' => $user->createToken('atelier')->plainTextToken];
}

routes/api.php — protéger la ressourceRoute::post('/login', [AuthController::class, 'login']);

Route::middleware('auth:sanctum')->group(function () {
    Route::apiResource('clients', ClientController::class);
    Route::get('/user', fn (Request $r) => $r->user());
});

• POST /api/login avec de bons identifiants renvoie un token ; sinon 401.
• Appeler /api/clients sans l'en-tête Authorization: Bearer … renvoie 401 ; avec, ça passe.

CORS, throttle & rate limiting

Laisser passer le front Angular (CORS) et limiter les abus — un plafond strict sur le login pour couper le brute-force.

1. Publie et règle la config CORS pour autoriser l'origine du front.
2. Applique un limiteur de débit strict sur /login.
3. Comprends la réponse 429 Too Many Requests.

terminal — publier la config CORSphp artisan config:publish cors

config/cors.php — autoriser Angular'paths' => ['api/*', 'login'],
'allowed_methods' => ['*'],
'allowed_origins' => [
    'http://localhost:4200',   // le dev Angular
    'https://atelier.tn',      // le front en prod
],

routes/api.php — limiter le loginRoute::post('/login', [AuthController::class, 'login'])
    ->middleware('throttle:5,1');   // 5 essais/min → 429 ensuite

• Depuis Angular (localhost:4200), les requêtes passent — aucune erreur CORS dans la console.
• Marteler /login renvoie 429 après cinq essais dans la minute.

Performance : N+1, pagination, index

Une API qui reste rapide en grandissant : tuer le N+1 avec l'eager loading, paginer, et indexer les clés étrangères.

1. Eager-load les relations dans index pour tuer le N+1.
2. Pagine la liste au lieu de tout renvoyer.
3. Indexe client_id sur projets et factures.

ClientController@index — 2 requêtes, paginépublic function index()
{
    return ClientResource::collection(
        Client::with(['projets', 'factures'])->paginate(15)
    );
}

migration — indexer la clé étrangèreSchema::table('projets', function (Blueprint $table) {
    $table->index('client_id');   // recherches par client → instantanées
});

• Laravel Debugbar montre 2 requêtes au lieu de 20+ pour la liste des clients.
• La réponse est paginée (data, meta, links) — ce que le front sait déjà lire.

Déployer & brancher Angular — l'épreuve finale

Mettre l'API en ligne, puis pointer le front Angular dessus et retirer json-server. Le produit full-stack, livré.

1. Prépare la prod : .env de production, APP_ENV=production, APP_DEBUG=false.
2. Héberge l'API en HTTPS (VPS, Forge…) ; migre la base sur le serveur.
3. Dans Angular, change environment.prod.ts → l'URL de la vraie API.
4. Supprime json-server : il ne sert plus à rien.

sur le serveur de prodphp artisan migrate --force   # migre sans confirmation interactive
php artisan config:cache
php artisan route:cache

ANGULAR — src/environments/environment.prod.tsexport const environment = {
  production: true,
  apiUrl: 'https://api.atelier.tn/api',   // la VRAIE API Laravel
};
// json-server : supprimé. Le contrat JSON n'a pas changé.

• L'API Laravel répond en HTTPS à une vraie URL.
• Le front Angular liste, crée et cherche des clients via l'API Laravel, sans json-server.
• Le même code Angular fonctionne — on n'a changé que l'apiUrl.
• Login → token → l'intercepteur envoie Authorization → l'API protège ses routes.