Construire une API /api/tasks avec Routes → Service → Storage
Utilisez les flèches, cliquez ou glissez pour naviguer
1. Comprendre la séparation en couches
Pourquoi séparer routes, service et storage
2. Construire une API CRUD
Architecture routes → service → storage
3. Réutiliser Repository
Pattern de la semaine 10
4. Changer le stockage facilement
Modifier UNE ligne dans app.ts
Le problème : tout dans un seul fichier
Validation, stockage, HTTP mélangés
Les 3 couches
Routes (HTTP) → Service (logique) → Storage (données)
Live coding
Repository
Assembler le tout
Créer storage, passer au service, passer aux routes dans app.ts
Le moment clé
"Et si je veux changer de stockage ?" — changer UNE ligne
❌ Le code "spaghetti"
Quand tout est dans un seul fichier, le code devient :
// ❌ Tout mélangé dans app.ts
app.post('/api/tasks', async (req, res) => {
const data = req.body;
// Validation HTTP
if (!data.title) return res.status(400).json({ error: 'Title required' });
// Logique métier
const task = { id: Date.now(), title: data.title, done: false };
// Stockage direct
tasks.push(task);
res.json(task);
});
Séparation des responsabilités
Routes
HTTP
Service
Logique
Storage
Données
Responsabilité unique : parler HTTP
Les routes ne font QUE :
// routes/tasks.ts
router.get('/', async (req, res) => {
const tasks = await taskService.getAll();
res.json(tasks);
});
Responsabilité unique : appliquer les règles
Le service ne sait RIEN d'HTTP :
// services/TaskService.ts
class TaskService {
constructor(private storage: Repository<Task>) {}
async create(data: CreateTaskDTO): Promise<Task> {
if (!data.title?.trim()) {
throw new Error('Title required');
}
return await this.storage.create(data);
}
}
Responsabilité unique : gérer les données
Le storage ne sait RIEN de la logique :
// storage/InMemoryRepository.ts
class InMemoryRepository<T> implements Repository<T> {
private items: T[] = [];
async getAll(): Promise<T[]> {
return [...this.items];
}
async create(item: T): Promise<T> {
this.items.push(item);
return item;
}
}
❌ INTERDIT
La route NE touche JAMAIS au storage directement
// ❌ Mauvais
res.json(storage.getAll());
✅ CORRECT
La route passe TOUJOURS par le service
// ✅ Bon
const tasks = await service.getAll();
res.json(tasks);
Reprendre le Repository
// repository/Repository.ts
interface Repository<T> {
getAll(): Promise<T[]>;
getById(id: string): Promise<T | null>;
create(item: T): Promise<T>;
update(id: string, item: Partial<T>): Promise<T | null>;
delete(id: string): Promise<boolean>;
}
💡 Ce pattern est déjà réutilisable !
On peut l'utiliser pour Task, User, Product, etc.
Implémenter InMemoryRepository
// storage/TaskRepository.ts
class InMemoryTaskRepository implements Repository<Task> {
private tasks: Task[] = [];
async getAll(): Promise<Task[]> {
return [...this.tasks];
}
async create(task: Task): Promise<Task> {
this.tasks.push(task);
return task;
}
// ... getById, update, delete
}
Créer TaskService avec logique métier
// services/TaskService.ts
class TaskService {
constructor(private storage: Repository<Task>) {}
async getAll(): Promise<Task[]> {
return await this.storage.getAll();
}
async create(data: { title: string }): Promise<Task> {
if (!data.title?.trim()) {
throw new Error('Title required');
}
const task: Task = { id: crypto.randomUUID(), title: data.title, done: false };
return await this.storage.create(task);
}
// ... getById, update, delete
}
Créer les routes Express
// routes/tasks.ts
import { Router } from 'express';
const router = Router();
export const createTaskRoutes = (taskService: TaskService) => {
router.get('/', async (req, res) => {
const tasks = await taskService.getAll();
res.json(tasks);
});
router.post('/', async (req, res) => {
try {
const task = await taskService.create(req.body);
res.status(201).json(task);
} catch (error) {
res.status(400).json({ error: (error as Error).message });
}
});
// ... PUT, DELETE
return router;
};
L'ordre d'assemblage est crucial
// app.ts
import express from 'express';
const app = express();
app.use(express.json());
// 1️⃣ Créer le storage
const taskStorage = new InMemoryTaskRepository();
// 2️⃣ Créer le service (avec le storage)
const taskService = new TaskService(taskStorage);
// 3️⃣ Créer les routes (avec le service)
app.use('/api/tasks', createTaskRoutes(taskService));
app.listen(3000);
On injecte chaque couche dans la suivante
new InMemoryTaskRepository()
Storage
new TaskService(storage)
Service reçoit storage
createTaskRoutes(service)
Routes reçoivent service
"Et si je veux changer de stockage ?"
Passer de InMemory → PostgreSQL
Combien de fichiers dois-je modifier ?
✅ Magie de l'architecture en couches
Seulement app.ts change. Le service et les routes ne bougent pas.
// ❌ Avant
const taskStorage = new InMemoryTaskRepository();
// ✅ Après
const taskStorage = new PostgresTaskRepository();
💡 Le service continue de fonctionner car il dépend de l'interface Repository
Le Service dépend de l'INTERFACE, pas de l'IMPLÉMENTATION
// services/TaskService.ts
class TaskService {
// Dépend de l'interface Repository
constructor(private storage: Repository<Task>) {}
// Peut recevoir InMemoryTaskRepository OU PostgresTaskRepository
async getAll(): Promise<Task[]> {
return await this.storage.getAll();
}
}
❌ L'erreur
Les étudiants veulent mettre la logique dans les routes
router.post('/', (req, res) => {
if (!req.body.title) return res.status(400);
// Logique ici...
});
✅ La solution
Les routes sont "bêtes", elles appellent le service
router.post('/', async (req, res) => {
const task = await taskService.create(req.body);
res.json(task);
});
💡 Rappel : Les routes ne font QUE HTTP (req → service → res)
❌ La pensée
"C'est trop de fichiers pour un petit projet"
"Je peux tout mettre dans app.ts"
✅ La réalité
"Ça scale"
Quand le projet grandit, cette architecture sauve des vies
Exemple : Quand tu as 50 routes...
L'assemblage dans app.ts peut sembler magique
Bien montrer l'ordre : storage → service → routes
// app.ts - L'ordre MATIERE
// 1️⃣ D'abord, créer le storage (le plus bas dans la chaîne)
const taskStorage = new InMemoryTaskRepository();
// 2️⃣ Ensuite, créer le service (besoin du storage)
const taskService = new TaskService(taskStorage);
// 3️⃣ Enfin, créer les routes (besoin du service)
app.use('/api/tasks', createTaskRoutes(taskService));
💡 On ne peut pas créer le service sans le storage, ni les routes sans le service !
🎯 Responsabilité unique
Routes = HTTP, Service = Logique, Storage = Données
🚫 Pas de court-circuit
La route ne touche JAMAIS au storage directement
🔄 Injection de dépendances
On injecte storage → service → routes
✨ Flexibilité
Changer le stockage = UNE ligne dans app.ts
L'interface Repository