Architecture en Couches

Construire une API /api/tasks avec Routes → Service → Storage

Utilisez les flèches, cliquez ou glissez pour naviguer

Objectifs de la leçon

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

Plan du cours

1

Le problème : tout dans un seul fichier

Validation, stockage, HTTP mélangés

2

Les 3 couches

Routes (HTTP) → Service (logique) → Storage (données)

3

Live coding

Repository de S10, TaskService de S11, routes Express

4

Assembler le tout

Créer storage, passer au service, passer aux routes dans app.ts

5

Le moment clé

"Et si je veux changer de stockage ?" — changer UNE ligne

1. Le problème : tout mélangé

❌ Le code "spaghetti"

Quand tout est dans un seul fichier, le code devient :

  • • Difficile à tester
  • • Impossible à réutiliser
  • • Cauchemar à maintenir

// ❌ 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);

});

2. Les 3 Couches

Séparation des responsabilités

Routes

HTTP

→

Service

Logique

→

Storage

Données

Couche 1 : Routes (HTTP)

Responsabilité unique : parler HTTP

Les routes ne font QUE :

  • ✓ Recevoir la requête HTTP
  • ✓ Appeler le service
  • ✓ Envoyer la réponse HTTP

// routes/tasks.ts

router.get('/', async (req, res) => {

const tasks = await taskService.getAll();

res.json(tasks);

});

Couche 2 : Service (Logique)

Responsabilité unique : appliquer les règles

Le service ne sait RIEN d'HTTP :

  • ✗ Pas de req, pas de res
  • ✗ Pas de codes de statut HTTP
  • ✓ Validation métier
  • ✓ Logique de transformation

// 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);

}

}

Couche 3 : Storage (Données)

Responsabilité unique : gérer les données

Le storage ne sait RIEN de la logique :

  • ✗ Pas de validation métier
  • ✗ Pas de transformation
  • ✓ CRUD basique
  • ✓ Interface interchangeable

// 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;

}

}

Règle d'or

❌ 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);

3. Live coding - Étape 1

Reprendre le Repository de la semaine 10

// 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.

3. Live coding - Étape 2

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

}

3. Live coding - Étape 3

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

}

3. Live coding - Étape 4

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;

};

4. Assembler le tout dans app.ts

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);

Injection de Dépendances

On injecte chaque couche dans la suivante

new InMemoryTaskRepository()

Storage

↓

new TaskService(storage)

Service reçoit storage

↓

createTaskRoutes(service)

Routes reçoivent service

5. Le Moment Clé

"Et si je veux changer de stockage ?"

Passer de InMemory → PostgreSQL

Combien de fichiers dois-je modifier ?

La réponse : UNE seule ligne !

✅ 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, pas de l'implémentation !

Pourquoi ça marche ?

Le Service dépend de l'INTERFACE, pas de l'IMPLÉMENTATION

// services/TaskService.ts

class TaskService {

// Dépend de l'interface Repository, pas de InMemoryTaskRepository

constructor(private storage: Repository<Task>) {}

// Peut recevoir InMemoryTaskRepository OU PostgresTaskRepository

async getAll(): Promise<Task[]> {

return await this.storage.getAll();

}

}

Piège 1 : Logique dans les routes

❌ 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)

Piège 2 : "Trop compliqué"

❌ 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...

  • ✓ Changer de base de données = 1 ligne
  • ✓ Ajouter de la validation = changer le service
  • ✓ Tests unitaires faciles (service sans HTTP)

Piège 3 : Assemblage "magique"

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 !

À retenir !

🎯 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 est la clé de la flexibilité !