👨‍🍳 Cuisiner ta première API REST : Le Secret de la Sauce Express, Prisma et Postgres

Salut à toi, futur(e) pro du Backend ! 🚀

Tu viens de dompter React, tu sais créer des interfaces qui déchirent, mais maintenant, tu te demandes : "Où vont mes données quand je clique sur Envoyer ?". Bienvenue dans les coulisses !

Aujourd'hui, on va construire le moteur d'une application de gestion de présence pour un centre de formation. On va gérer des Programmes (Web Dev, Marketing, etc.), des Coachs et des Apprenants.

💡 L'analogie du Chef Cuistot

Pour comprendre comment fonctionne une API en architecture MVC (Modèle-Vue-Contrôleur), imagine qu'on prépare une Pâte de maïs (Foufou) :

1. La Base de Données (Le Garde-manger) : C'est là où sont stockés tes sacs de maïs et ton eau.
2. Le Modèle (La Recette) : C'est le plan qui dit : "Pour faire la pâte, il faut tel ingrédient avec tel type de mesure".
3. Le Contrôleur (Le Chef) : C'est celui qui mélange, surveille le feu et décide quand c'est prêt. C'est la logique.
4. Le Routeur (Le Serveur de salle) : Il prend la commande du client ("Je veux un plat de Foufou !") et l'apporte au Chef.
5. La Vue (Le Plat servi) : En API, on ne sert pas une assiette décorée, mais un fichier JSON (de la donnée pure) que ton React pourra ensuite "dresser" sur l'écran.

---

🛠️ La Boîte à Outils

Oublie les outils complexes comme Docker pour l'instant, on va tout installer en local pour bien voir ce qui se passe "sous le capot".

1. Node.js (ton moteur JS).
2. PostgreSQL : Télécharge-le (via Postgres.app sur Mac ou l'installeur officiel sur Windows/Linux).
3. Un client API : Postman ou l'extension Thunder Client dans VS Code.

---

🏗️ Étape 1 : Initialisation du Projet (Préparer la cuisine)

Avant de lancer le feu, on doit préparer notre plan de travail. Ouvre ton terminal et tape ces commandes. C'est ici qu'on définit les règles du jeu :

mkdir gestion-presence-api # Crée le dossier du projet
cd gestion-presence-api    # Entre dans le dossier
npm init -y                # Crée le fichier package.json (Ton carnet de recettes)

# Installation des ingrédients principaux (Dépendances de production)
npm install express @prisma/client bcrypt jsonwebtoken

# Installation des ustensiles (Dépendances de développement)
npm install -D prisma nodemon

🥘 À quoi servent ces ingrédients ?

Si on compare notre API à la préparation d'une Pâte de maïs (Foufou), voici le rôle de chaque outil :

• Express.js (Le Réchaud) : C'est ton moteur. Sans lui, rien ne chauffe. Il reçoit les demandes des clients (ex: "Je veux la liste des élèves") et s'assure que la réponse arrive à bon port.
• Prisma & @prisma/client (Le Traducteur) : Ta base de données parle le "SQL", mais toi tu parles le "JavaScript". Prisma est le traducteur magique qui te permet de commander tes ingrédients sans apprendre une langue complexe. C'est l'ORM (Object-Relational Mapping).
• Bcrypt (Le Pilon de sécurité) : Imagine que tu veuilles cacher une épice secrète. Avec Bcrypt, on "écrase" les mots de passe des coachs pour les transformer en une poudre illisible. Même si quelqu'un regarde dans ton garde-manger, il ne pourra jamais retrouver le mot de passe original. C'est le hachage.
• JSON Web Token / JWT (Le Ticket de caisse) : Une fois que le coach est connecté, on lui donne un ticket (le token). À chaque fois qu'il veut "faire l'appel", il montre ce ticket pour prouver qu'il a bien le droit d'être là.
• Nodemon (Le Commis de cuisine) : Normalement, à chaque fois que tu changes un ingrédient dans ton code, tu dois éteindre et rallumer le réchaud. Nodemon le fait automatiquement pour toi dès que tu sauvegardes un fichier. Un gain de temps fou !

💡 Astuce de chef : Ouvre ton fichier package.json et ajoute la ligne "type": "module",. Cela permet d'utiliser les commandes import et export exactement comme tu le faisais avec React. On reste en terrain connu !

---

🗄️ Étape 2 : Le Schéma (Le Plan d'Architecte ou La Recette)

Avant de toucher au code, on doit définir la structure de nos données. C'est ici qu'entre en scène Prisma.

🤔 C'est quoi un ORM ?

Imagine que tu cuisines pour un invité qui ne parle que SQL (le langage des bases de données), alors que toi tu ne parles que JavaScript. L'ORM (Object-Relational Mapping) est ton interprète personnel.
Au lieu d'écrire des requêtes complexes comme SELECT * FROM Student WHERE id = ..., tu vas simplement écrire du JavaScript : prisma.student.findUnique(...). C'est plus propre, plus rapide et plus sûr !

🛡️ Un mot sur la sécurité et la doc

Prisma est puissant, mais comme un couteau de chef, mal utilisé, il peut être dangereux. Une mauvaise configuration peut exposer tes données ou créer des failles (comme les injections SQL).
👉 Ton premier réflexe de pro : Lis la Documentation Officielle de Prisma. C'est ta bible. Prends le temps de comprendre comment les relations fonctionnent pour construire des applications robustes.

🆔 Pourquoi utiliser des CUID au lieu de chiffres (1, 2, 3) ?

Dans notre centre de formation, on utilise des CUID (ex: clh1abc...). Pourquoi ?

1. Sécurité : Si ton ID est 1, n'importe qui peut deviner que l'étudiant suivant est le 2 et tenter d'accéder à ses infos. Avec un CUID, c'est impossible à deviner.
2. Évolutivité : C'est beaucoup plus pratique quand on commence à avoir des milliers de données réparties partout.

---

🏗️ Mise en place

Initialise Prisma dans ton projet :

npx prisma init

Ouvre le fichier prisma/schema.prisma qui vient d'apparaître et remplace tout par notre "recette" :

datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

// 🏫 Le programme (Web Dev, Marketing, etc.)
model Program {
  id        String    @id @default(cuid())
  name      String    @unique
  coaches   Coach[]
  students  Student[]
}

// 👨‍🏫 Le Coach (Il gère un programme)
model Coach {
  id        String   @id @default(cuid())
  name      String
  email     String   @unique
  password  String   // Chut ! Ce sera haché !
  program   Program  @relation(fields: [programId], references: [id])
  programId String
}

// 🧑‍🎓 L'Apprenant
model Student {
  id        String   @id @default(cuid())
  name      String
  program   Program  @relation(fields: [programId], references: [id])
  programId String
  attendances Attendance[]
}

// 📝 La feuille d'appel (Présence)
model Attendance {
  id        String   @id @default(cuid())
  date      DateTime @default(now())
  isPresent Boolean  @default(false)
  student   Student  @relation(fields: [studentId], references: [id])
  studentId String
}

🚀 Action !

1. Crée une base de données vide (appelée presence_db) dans ton logiciel Postgres (ou via pgAdmin).
2. Dans ton fichier .env, mets à jour l'URL : DATABASE_URL="postgresql://USER:PASSWORD@localhost:5432/presence_db?schema=public". Remplace USER par le nom d'utiliseur que tu as créé avec ta base de données, même choses pour PASSWRD
3. Envoie ce plan à ta base de données pour créer les tables :

npx prisma migrate dev --name init_db

Cette commande génère aussi le "Prisma Client", l'outil qui te permettra de manipuler ces données en JS !

---

📂 Étape 3 : L'Architecture MVC (Organises ta cuisine)

Imagine que tu prépares le foufou : si le sac de farine est sous le lit, l'eau dans le garage et le réchaud au salon, tu vas perdre un temps fou et ta cuisine sera un désordre total. C’est ce qu’on appelle le "Code Spaghetti" : un mélange emmêlé où plus personne ne s'y retrouve.

Pour éviter cela, on utilise une Architecture. C'est le plan de rangement de ton logiciel.

🏰 Pourquoi MVC ?

Il existe plusieurs façons d'organiser un projet (on appelle ça des Design Patterns) :

• Les Microservices : On sépare chaque fonction dans des mini-serveurs différents (très puissant mais très complexe).
• La Clean Architecture : On crée des couches ultra-étanches pour que le code soit indépendant de tout (très rigoureux, mais lourd pour débuter).
• Le MVC (Modèle-Vue-Contrôleur) : C'est le standard de l'industrie pour les applications web. C'est l'équilibre parfait entre simplicité et propreté.

Pourquoi on le choisit ? Parce qu'il sépare les responsabilités : celui qui gère les données (le garde-manger) ne doit pas être celui qui décide des chemins (le serveur de salle).

🏗️ Notre structure de fichiers

Crée les dossiers suivants dans ton dossier src/. Voici comment on va répartir les tâches :

• lib/ (Le placard à outils) : Contient la configuration de Prisma. C'est ici qu'on prépare notre connexion à la base de données pour qu'elle soit prête à l'emploi.
• routes/ (Le Menu/Le Serveur de salle) : C'est ici qu'on définit les URLs (ex: /api/students). Son seul rôle est de prendre la commande du client et de la passer au bon chef.
• controllers/ (Le Chef de cuisine) : C'est le cerveau ! C'est ici que réside la logique métier. Le chef reçoit la commande, vérifie les ingrédients dans la base de données, prépare le plat et le renvoie.
• middlewares/ (Le Vigile à l'entrée) : Avant d'entrer en cuisine, on vérifie si tu as ton badge (JWT). Si tu n'es pas un coach autorisé, le vigile te bloque ici.
• index.js (La Porte principale) : C'est le point d'entrée. C'est lui qui allume le réchaud et lance le serveur.

---

⚙️ Création du client Prisma (src/lib/prisma.js)

Dans notre cuisine, on veut une seule instance de Prisma pour tout le monde (on appelle ça un Singleton). Cela évite de saturer ta base de données avec trop de connexions ouvertes.

Crée le fichier src/lib/prisma.js :

import { PrismaClient } from '@prisma/client';

// On crée l'instance qui nous permettra de parler à la DB
export const prisma = new PrismaClient();

// C'est cet objet "prisma" qu'on importera dans nos contrôleurs 
// pour faire nos opérations CRUD (Create, Read, Update, Delete)

---

Avec cette structure, ton code est "pro", facile à tester et surtout, facile à maintenir. Si tu as un bug sur une URL, tu sais qu'il faut regarder dans routes/. Si le calcul de présence est faux, tu vas dans controllers/ !

---

🔐 Étape 4 : L'Authentification (Le Badge d'accès du Coach)

Dans notre centre de formation, n'importe qui ne peut pas entrer en cuisine pour modifier la liste des élèves ou faire l'appel. Seuls les Coachs ont ce droit. Pour cela, on a besoin de deux choses :

1. Le Hachage : Pour ne jamais stocker les mots de passe en clair (sécurité maximale).
2. Le JWT (Token) : C'est le fameux "badge" que le coach porte après s'être connecté.

Imagine que le mot de passe du coach soit un piment entier. Si quelqu'un vole ton garde-manger, il voit le piment. Le hachage (Bcrypt), c'est comme passer ce piment au mixeur avec d'autres ingrédients pour en faire une sauce très forte. On peut goûter la sauce pour vérifier que c'est bien le bon piment, mais il est impossible de reconstruire le piment original à partir de la sauce. C'est ça, la magie du hachage !

🧑‍🍳 Le Contrôleur d'Authentification (src/controllers/authController.js)

Crée ce fichier. Il va contenir la logique pour Inscrire un coach (Register) et le Connecter (Login).

import bcrypt from 'bcrypt';
import jwt from 'jsonwebtoken';
import { prisma } from '../lib/prisma.js';

// --- INSCRIPTION D'UN NOUVEAU COACH ---
export const register = async (req, res) => {
  try {
    const { name, email, password, programId } = req.body;

    // 1. On "pilonne" le mot de passe (Hachage)
    // Le chiffre 10 est le "Salt" : plus il est élevé, plus le hachage est solide
    const hashedPassword = await bcrypt.hash(password, 10);

    // 2. On enregistre le coach dans la base de données via Prisma
    const newCoach = await prisma.coach.create({
      data: {
        name,
        email,
        password: hashedPassword, // On stocke la version "sauce", pas le piment !
        programId // Rappelle-toi, c'est un CUID (ex: clh1...)
      }
    });

    // 3. On renvoie le coach créé (sans son mot de passe par sécurité)
    const { password: _, ...coachWithoutPassword } = newCoach;
    res.status(201).json(coachWithoutPassword);

  } catch (error) {
    res.status(400).json({ error: "L'inscription a échoué. L'email est peut-être déjà utilisé." });
  }
};

// --- CONNEXION DU COACH (LOGIN) ---
export const login = async (req, res) => {
  try {
    const { email, password } = req.body;

    // 1. On cherche le coach dans le garde-manger (DB) par son email
    const coach = await prisma.coach.findUnique({ where: { email } });

    if (!coach) {
      return res.status(401).json({ error: "Email ou mot de passe incorrect." });
    }

    // 2. On compare le mot de passe reçu avec la sauce (hash) stockée
    const isPasswordValid = await bcrypt.compare(password, coach.password);

    if (!isPasswordValid) {
      return res.status(401).json({ error: "Email ou mot de passe incorrect." });
    }

    // 3. Si tout est bon, on fabrique le "Badge d'accès" (JWT)
    // Ce badge contient l'ID du coach et expire après 24h
    const token = jwt.sign(
      { coachId: coach.id }, 
      'VOTRE_CLE_SECRETE_SUPER_SECURISEE', // À mettre dans ton .env plus tard !
      { expiresIn: '24h' }
    );

    res.json({
      message: "Connexion réussie ! Voici votre badge.",
      token: token,
      coach: { id: coach.id, name: coach.name }
    });

  } catch (error) {
    res.status(500).json({ error: "Erreur lors de la connexion." });
  }
};

---

🧐 Ce qu'il faut retenir pour ta carrière :

1. Ne jamais stocker en clair : Si tu vois password: "123456" dans une base de données, c'est une faute grave. Utilise toujours Bcrypt.
2. JWT est comme un ticket de cinéma : Une fois que tu l'as, tu n'as plus besoin de redonner tes identifiants à chaque porte (route). Tu montres juste ton ticket.
3. Gestion des erreurs : Remarque comment on utilise try { ... } catch { ... }. En Backend, il faut toujours prévoir que la base de données puisse être indisponible ou qu'un email existe déjà. C'est ce qui différencie un développeur junior d'un pro !

---

📝 Étape 5 : Le CRUD des Apprenants (Gérer tes ingrédients)

Le mot CRUD est le pain quotidien du développeur Backend. C'est un acronyme qui résume les 4 actions de base que tu peux faire sur n'importe quelle donnée dans ton garde-manger (Base de données) :

1. Create (Créer) : Ajouter un nouvel apprenant.
2. Read (Lire) : Afficher la liste ou les détails.
3. Update (Modifier) : Changer le nom d'un apprenant.
4. Delete (Supprimer) : Retirer un apprenant du centre.

🧑‍🍳 Le Chef en action (src/controllers/studentController.js)

Dans notre architecture MVC, ce fichier est le Contrôleur. Il reçoit la commande, demande à Prisma (le commis) de chercher ou modifier les ingrédients, et renvoie le résultat au client.

import { prisma } from '../lib/prisma.js';

/**
 * LIRE (Read) : Récupérer tous les apprenants
 * C'est comme sortir tous les sacs de maïs pour vérifier le stock.
 */
export const getStudents = async (req, res) => {
  try {
    // On demande à Prisma de trouver tous les étudiants
    const students = await prisma.student.findMany({
      include: { 
        program: true // "Jointure" : On récupère aussi les détails du programme (Web Dev, etc.)
      }
    });

    // On renvoie la liste en format JSON (Le plat est servi !)
    res.json(students);
  } catch (error) {
    res.status(500).json({ error: "Impossible de récupérer les apprenants." });
  }
};

/**
 * CRÉER (Create) : Ajouter un nouvel apprenant
 * C'est comme ajouter un nouveau sac de semoule dans le placard.
 */
export const createStudent = async (req, res) => {
  try {
    // On récupère les données envoyées depuis le front-end (React)
    const { name, programId } = req.body;

    // On utilise Prisma pour créer l'entrée dans PostgreSQL
    const newStudent = await prisma.student.create({
      data: { 
        name, 
        programId // On lie l'apprenant à un programme via son CUID
      }
    });

    // 201 : Code HTTP qui signifie "Créé avec succès !"
    res.status(201).json(newStudent);
  } catch (error) {
    res.status(400).json({ error: "Erreur lors de la création. Vérifie l'ID du programme." });
  }
};

/**
 * MODIFIER (Update) : Mettre à jour les infos
 * Si on s'est trompé sur le nom de l'apprenant.
 */
export const updateStudent = async (req, res) => {
  try {
    const { id } = req.params; // On récupère l'ID dans l'URL
    const { name } = req.body;

    const updatedStudent = await prisma.student.update({
      where: { id }, // On cherche l'apprenant par son CUID unique
      data: { name }
    });

    res.json(updatedStudent);
  } catch (error) {
    res.status(404).json({ error: "Apprenant non trouvé." });
  }
};

/**
 * SUPPRIMER (Delete) : Retirer un apprenant
 * On vide l'assiette !
 */
export const deleteStudent = async (req, res) => {
  try {
    const { id } = req.params;

    await prisma.student.delete({
      where: { id }
    });

    res.json({ message: "Apprenant supprimé avec succès." });
  } catch (error) {
    res.status(404).json({ error: "Impossible de supprimer. L'apprenant n'existe pas." });
  }
};

---

🔥 Pourquoi c'est important d'être explicite ici ?

1. Le try...catch : En cuisine, on peut renverser de l'eau. En code, une base de données peut planter. Le try...catch permet de "rattraper" l'erreur proprement au lieu de faire crash tout le restaurant (ton serveur).
2. Les codes de statut (res.status) :
   • 200 : OK (Tout va bien).
   • 201 : Created (Nouveau plat créé).
   • 400 : Bad Request (Tu as oublié un ingrédient dans ta demande).
   • 404 : Not Found (Le plat ou l'étudiant n'existe pas).
   • 500 : Server Error (Le réchaud a explosé).
3. L'inclusion (include) : C'est la force de Prisma. En une seule ligne, tu lies l'Apprenant à son Programme. En SQL pur, cela aurait nécessité une commande "JOIN" beaucoup plus complexe.

Félicitations ! Tu as maintenant un système complet pour gérer tes apprenants. Dans la prochaine étape, on va voir comment le Coach peut utiliser ces fonctions pour "faire l'appel". 🚀

---

📢 Étape 6 : "Faire l'appel" (La fonctionnalité spéciale)

Où met-on ce code ?
Puisque cette action concerne la présence, nous allons créer un nouveau fichier : src/controllers/attendanceController.js.

Pourquoi un nouveau fichier ?
Dans une bonne architecture MVC, on essaie de séparer les responsabilités. Un contrôleur pour les étudiants, un pour les coachs, et un pour les feuilles de présence. C'est plus propre !

📝 Le code commenté (src/controllers/attendanceController.js) :

import { prisma } from '../lib/prisma.js';

/**
 * Faire l'appel : Enregistrer si un étudiant est présent ou absent.
 * Analogie : C'est comme si le Chef cochait une liste pour savoir 
 * quel ingrédient a été utilisé aujourd'hui.
 */
export const takeAttendance = async (req, res) => {
  try {
    // 1. On récupère les infos envoyées par le front (ID de l'étudiant et son état)
    const { studentId, isPresent } = req.body;

    // 2. On utilise Prisma pour créer une nouvelle ligne dans la table Attendance
    const attendance = await prisma.attendance.create({
      data: {
        studentId, // Le CUID de l'étudiant (ex: "clh1...")
        isPresent  // true pour présent, false pour absent (un Boolean)
      }
    });

    // 3. On confirme que tout s'est bien passé
    res.json({ 
      message: "Présence enregistrée avec succès !", 
      attendance 
    });
  } catch (error) {
    // Si l'étudiant n'existe pas ou s'il y a un bug serveur
    res.status(500).json({ error: "Impossible d'enregistrer la présence." });
  }
};

---

🚦 Étape 7 : Les Routes (Le Serveur de salle)

Imagine que ton API est un grand restaurant.

• Le Contrôleur, c'est le Chef en cuisine. Il sait comment préparer le plat.
• La Route, c'est le Serveur qui prend la commande. Il se tient à l'entrée et dit : "Si vous demandez le menu Étudiants, je vais voir le Chef des étudiants. Si vous demandez la Feuille d'appel, je vais voir le Chef de la présence."

Sans les routes, personne ne peut communiquer avec tes chefs !

🛤️ Configuration des routes (src/routes/studentRoutes.js) :

C'est ici qu'on associe une URL et une Méthode HTTP (GET, POST, etc.) à une fonction de notre contrôleur.

import express from 'express';
// On importe les fonctions (logique) depuis le contrôleur
import { getStudents, createStudent, updateStudent, deleteStudent } from '../controllers/studentController.js';

const router = express.Router();

/**
 * Le Routeur est comme un aiguillage de train.
 * Il regarde l'URL et la méthode, puis envoie la requête au bon endroit.
 */

// Si on reçoit une requête GET sur "/" (qui sera http://localhost:3000/api/students)
router.get('/', getStudents);  

// Si on reçoit une requête POST sur "/" pour créer un étudiant
router.post('/', createStudent); 

// Si on reçoit une requête PUT avec un ID (ex: /api/students/clh1...) pour modifier
router.put('/:id', updateStudent);

// Si on reçoit une requête DELETE avec un ID pour supprimer
router.delete('/:id', deleteStudent);

export default router;

🏗️ Le point final : Assembler tout dans src/index.js

C'est le fichier principal. C'est ici qu'on dit à notre application Express d'utiliser les routes que nous venons de créer.

import express from 'express';
import studentRoutes from './routes/studentRoutes.js';
// (Imagine qu'on a aussi créé attendanceRoutes.js sur le même modèle)
import attendanceRoutes from './routes/attendanceRoutes.js';

const app = express();

// Middleware pour permettre à Express de lire le JSON envoyé par React (très important !)
app.use(express.json());

/**
 * On "monte" nos routes sur des préfixes.
 * Toutes les routes d'étudiants commenceront par /api/students
 */
app.use('/api/students', studentRoutes);

/**
 * Toutes les routes de présence commenceront par /api/attendance
 */
app.use('/api/attendance', attendanceRoutes);

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`🚀 Le restaurant est ouvert sur http://localhost:${PORT}`);
  console.log(`📡 Prêt à recevoir les commandes !`);
});

---

🔥 Résumé pour bien comprendre :

1. Le Client (React) envoie une requête : POST http://localhost:3000/api/students.
2. index.js voit passer la requête, reconnaît le préfixe /api/students et l'envoie vers studentRoutes.js.
3. studentRoutes.js voit que c'est une méthode POST et appelle la fonction createStudent dans le Contrôleur.
4. studentController.js prend les données, demande à Prisma de les enregistrer dans PostgreSQL.
5. Prisma répond "C'est fait !", et le Contrôleur renvoie un message de succès (JSON) au client.

La boucle est bouclée ! Tu as maintenant une architecture professionnelle, organisée et prête à évoluer. 🏆

---

🏆 Pourquoi cette approche est-elle "Pro" ?

En terminant ce projet, tu n'as pas juste écrit du code, tu as construit une véritable infrastructure logicielle. Voici pourquoi ton travail est de qualité professionnelle :

1. L'Identifiant CUID : Tes IDs ne sont plus de simples chiffres prévisibles (1, 2, 3), mais des chaînes uniques et sécurisées (ckjvw12340000...). C'est la norme pour éviter les fuites de données.
2. L'Architecture MVC : Ta "cuisine" est parfaitement rangée.
   • Un bug sur une URL ? Direction routes/.
   • Une erreur de calcul ou de logique ? Direction controllers/.
   • Un problème de structure de données ? Direction le Modèle (schema.prisma).
3. Sécurité Maximale : Grâce au hachage avec Bcrypt, même si un petit malin accède à ta base de données, il ne verra jamais les mots de passe des coachs, seulement une suite de caractères indéchiffrables.

---

📂 Rappel de ton architecture (Ton plan de travail)

Pour que tout fonctionne, ton dossier src/ doit ressembler à ça :

• lib/prisma.js : Ta connexion unique à la base de données.
• controllers/ : Tes "Chefs" (auth, students, attendance).
• routes/ : Tes "Serveurs" qui dirigent les requêtes.
• index.js : Ton "Réchaud" qui lance tout le système.

---

🧪 À toi de jouer : Le test final avec Postman !

Une API sans test, c'est comme un plat qu'on ne goûte pas avant de servir.

1. Lance le feu : npx nodemon src/index.js.
2. Prépare le terrain : Crée d'abord un Programme (ex: "Développement Web") via une requête POST sur /api/programs (si tu as créé la route).
3. Inscris le Coach : Fais un POST sur /api/auth/register avec l'ID du programme.
4. Ajoute les Apprenants : Utilise l'ID du programme pour créer tes étudiants.
5. Fais l'appel : Utilise le contrôleur takeAttendance pour marquer qui est là !

---

📚 Pour approfondir (Tes sources de savoir)

Ne t'arrête pas en si bon chemin ! Pour devenir un véritable expert, dévore ces ressources :

• Documentation Officielle de Prisma : Indispensable pour maîtriser les relations complexes.
• MDN Web Docs - Express : La base pour comprendre le fonctionnement des serveurs.
• FreeCodeCamp (Backend Development) : Des exercices interactifs gratuits.
• Grafikart.fr : D'excellents tutoriels vidéo en français sur Node.js et les ORM.

---

🚀 Prochaines étapes & Communauté

Maintenant que tu as une API solide, les possibilités sont infinies :

• Validation : Utilise une bibliothèque comme Zod ou Joi pour vérifier que les données reçues sont correctes avant de les envoyer à Prisma.
• Frontend : Connecte ton application React à cette API en utilisant fetch ou Axios.
• Déploiement : Apprends à mettre ta base de données en ligne (sur Supabase ou Render).

Une question ? Un bug ? Une suggestion ?
N'hésite pas à proposer des améliorations ou des correctifs dans les commentaires ! Si ce format vous plaît, je pourrais en faire une version vidéo pour détailler chaque ligne de code en direct.

Dis-moi aussi en commentaire : Quel sujet aimerais-tu que j'aborde dans le prochain article ? (La validation de données ? Le déploiement ? L'upload d'images ?).

Bravo encore, tu viens de passer du côté puissant de la force : le Backend. 🚀🍲