# ⬆️ Dependency Inversion — Renverser le contrôle **Dependency Inversion Principle (DIP)** = le code métier (haut niveau) **ne dépend JAMAIS** des détails techniques (bas niveau). Les deux dépendent d'abstractions. > **Haut niveau dicte. Bas niveau obéit.** --- ## 🎯 Le principe ### ❌ Dépendance classique (mauvaise) --- ### ✅ Dependency Inversion (bonne) --- ## 🧠 Pourquoi c'est crucial ? Sans DIP : - Haut niveau **esclave** du bas niveau - Changement technique = **cascade de réécritures** - Tests **impossibles** (couplage aux détails) Avec DIP : - Haut niveau **indépendant** - Bas niveau **plug-and-play** - Tests **faciles** (mock l'abstraction) > 💡 **L'invariant** : "High-level module should not depend on low-level module. Both should depend on abstractions." --- ## 📊 Architecture classique vs DIP --- ## 🔍 Exemple concret ### ❌ Sans Dependency Inversion ```ts // Business logic couplée aux détails class OrderService { async createOrder(data: OrderData) { // Dépendance directe à PostgreSQL const db = new Pool({ connectionString: DATABASE_URL }); await db.query('INSERT INTO orders...', [data]); // Dépendance directe à Stripe const stripe = require('stripe')(STRIPE_KEY); await stripe.charges.create({ amount: data.total }); // Dépendance directe à NodeMailer const transporter = nodemailer.createTransport({...}); await transporter.sendMail({...}); } } ``` **Problèmes** : - 3 dépendances concrètes → **impossible de tester** sans vraie DB/API/SMTP - Changer Stripe → **réécrire** OrderService - OrderService **connaît** les détails techniques --- ### ✅ Avec Dependency Inversion ```ts // 1. Définir les abstractions (interfaces) interface IDatabase { insert(table: string, data: any): Promise; } interface IPaymentProvider { charge(amount: number): Promise; } interface IEmailService { send(to: string, subject: string, body: string): Promise; } // 2. Business logic dépend des ABSTRACTIONS class OrderService { constructor( private db: IDatabase, private payment: IPaymentProvider, private email: IEmailService ) {} async createOrder(data: OrderData) { // 0 connaissance des détails techniques await this.db.insert('orders', data); await this.payment.charge(data.total); await this.email.send(data.email, 'Order confirmed', 'Thanks!'); } } // 3. Implémentations bas niveau (détails) class PostgresDatabase implements IDatabase { async insert(table: string, data: any) { const pool = new Pool({...}); await pool.query(`INSERT INTO ${table}...`); } } class StripePayment implements IPaymentProvider { async charge(amount: number) { const stripe = require('stripe')(STRIPE_KEY); return stripe.charges.create({ amount }); } } class NodemailerEmail implements IEmailService { async send(to: string, subject: string, body: string) { const transporter = nodemailer.createTransport({...}); await transporter.sendMail({ to, subject, text: body }); } } // 4. Injection (composition root) const orderService = new OrderService( new PostgresDatabase(), new StripePayment(), new NodemailerEmail() ); ``` **Bénéfices** : - ✅ **Tests** : `new OrderService(mockDB, mockPayment, mockEmail)` - ✅ **Swap** : `new MongoDatabase()` → 0 impact sur OrderService - ✅ **Indépendance** : OrderService ne connaît QUE les abstractions --- ; query: Record; body: any; } interface HttpResponse { json(data: any): void; status(code: number): void; } class UserController { async getUser(req: HttpRequest, res: HttpResponse) { const user = await db.findUser(req.params.id); res.json(user); } }`, description: "Controller indépendant du framework" } }, { title: "Factory qui retourne un type concret", badExample: { code: `class DatabaseFactory { static create(): PostgresClient { return new PostgresClient(config); } } // Usage const db: PostgresClient = DatabaseFactory.create();`, description: "Factory expose PostgresClient (type concret)" }, problem: "Consumer dépend toujours de PostgresClient, pas d'abstraction", solution: "Factory retourne une interface", goodExample: { code: `interface IDatabase { query(sql: string): Promise; } class DatabaseFactory { static create(): IDatabase { return new PostgresClient(config); } } // Usage const db: IDatabase = DatabaseFactory.create();`, description: "Consumer ne connaît QUE l'interface" } }, { title: "Abstraction qui fuit les détails", badExample: { code: `interface ICache { // ❌ Expose des détails Redis getRedisClient(): RedisClient; expire(key: string, ttl: number): void; // Redis-specific hgetall(key: string): any; // Redis hashes }`, description: "Interface révèle que c'est Redis" }, problem: "Impossible de swap vers Memcached sans changer l'interface", solution: "Abstraction pure, indépendante de l'implémentation", goodExample: { code: `interface ICache { get(key: string): Promise; set(key: string, value: T, ttl?: number): Promise; delete(key: string): Promise; }`, description: "Abstrait, pourrait être Redis/Memcached/Memory" } } ]} /> --- ## 🧪 Techniques d'inversion de dépendance ### 1. **Constructor Injection** ```ts // ✅ Injection par constructeur class UserService { constructor( private userRepo: IUserRepository, private emailService: IEmailService ) {} } // Composition root const userService = new UserService( new PostgresUserRepository(), new SendGridEmailService() ); ``` **Avantages** : - Dépendances **explicites** - **Immutables** après construction - **Testable** (inject mocks) --- ### 2. **Abstract Factory** ```ts interface IDatabase { /* ... */ } interface IDatabaseFactory { create(): IDatabase; } class PostgresFactory implements IDatabaseFactory { create(): IDatabase { return new PostgresClient(config); } } class MongoFactory implements IDatabaseFactory { create(): IDatabase { return new MongoClient(config); } } // Consumer class OrderService { constructor(private dbFactory: IDatabaseFactory) {} async init() { this.db = this.dbFactory.create(); // IDatabase, pas de type concret } } ``` --- ### 3. **Dependency Injection Container** ```ts // Container (ex: tsyringe, inversify) @injectable() class UserService { constructor( @inject("IUserRepository") private userRepo: IUserRepository, @inject("IEmailService") private emailService: IEmailService ) {} } // Configuration container.register("IUserRepository", { useClass: PostgresUserRepository, }); // Resolution const userService = container.resolve(UserService); // Dépendances injectées automatiquement ``` --- --- --- ## 🗺️ Carte mentale de synthèse --- ## 🚀 Résultat attendu En maîtrisant Dependency Inversion, tu deviens capable de : - **Concevoir** des systèmes où la logique métier est **souveraine** - **Tester** sans aucune dépendance externe - **Changer** d'infrastructure sans réécrire le code métier - **Composer** des modules indépendants et interchangeables Et surtout : Tu cesses de subir les contraintes techniques. **Tu les inverses.** Le haut niveau dicte. Le bas niveau obéit.