1~
2Lorsqu'on travaille sur des projets logiciels complexes, le choix entre monorepo et polyrepo peut avoir un impact significatif sur la productivité de l'équipe et la scalabilité du code. Dans cet article, nous analysons les différences, les avantages et inconvénients de chaque approche, et vous aidons à comprendre laquelle est faite pour vous.
3~
4## Qu'est-ce qu'un Monorepo et un Polyrepo ?
5~
6### Monorepo
7~
8Un **monorepo** (monolithic repository) est un seul dépôt qui contient le code source de plusieurs projets, services ou packages, souvent liés entre eux.
9~
10```plaintext filename="Exemple de structure Monorepo"
11my-monorepo/
12  packages/
13    frontend/
14    backend/
15    shared/
16  package.json
17  turbo.json
18```
19~
20### Polyrepo
21~
22Un **polyrepo** (multiple repositories) signifie que chaque projet, service ou package possède son propre dépôt séparé.
23~
24```plaintext filename="Exemple de structure Polyrepo"
25repos/
26  frontend/
27    package.json
28  backend/
29    package.json
30  shared/
31    package.json
32```
33~
34## Différence visuelle
35~
36```mermaid
37flowchart TD
38    subgraph Monorepo
39        A1["frontend/"]
40        A2["backend/"]
41        A3["shared/"]
42    end
43    style Monorepo fill:#e0e7ff,stroke:#6366f1,stroke-width:2px
44```
45~
46```mermaid
47flowchart TD
48    subgraph Polyrepo
49        B1["frontend repo"]
50        B2["backend repo"]
51        B3["shared repo"]
52    end
53    style Polyrepo fill:#fee2e2,stroke:#ef4444,stroke-width:2px
54```
55~
56## Avantages et inconvénients
57~
58### Monorepo
59~
60**Avantages :**
61- Facilite le partage de code (ex. bibliothèques partagées).
62- Refactoring atomique sur plusieurs projets.
63- Gestion centralisée des dépendances et des configurations.
64~
65**Inconvénients :**
66- Peut devenir lourd à mesure que le code grandit.
67- Nécessite des outils pour gérer les builds/tests partiels (ex. Nx, Turborepo).
68~
69### Polyrepo
70~
71**Avantages :**
72- Chaque équipe/projet est indépendant.
73- Plus simple à gérer pour les petits projets.
74- Permet des politiques d'accès granulaires.
75~
76**Inconvénients :**
77- Partage de code difficile sans publier de packages.
78- Refactoring cross-repo plus complexe.
79- Possibles duplications de configurations.
80~
81## Exemple pratique : Monorepo avec Turborepo
82~
83Supposons que vous souhaitiez créer un monorepo avec frontend et backend en utilisant Turborepo.
84~
85### 1. Initialiser le monorepo
86~
87```bash
88npx create-turbo@latest
89```
90~
91### 2. Structure typique
92~
93```plaintext
94my-monorepo/
95  apps/
96    web/        # frontend Next.js
97    api/        # backend Node.js/Express
98  packages/
99    ui/         # bibliothèque de composants partagée
100    utils/      # fonctions partagées
101  turbo.json
102  package.json
103```
104~
105### 3. Exemple de workspace dans `package.json`
106~
107```json
108{
109  "private": true,
110  "workspaces": [
111    "apps/*",
112    "packages/*"
113  ]
114}
115```
116~
117### 4. Exemple d'import d'une bibliothèque partagée
118~
119Supposons que vous ayez une fonction dans `packages/utils/src/formatDate.ts` :
120~
121```ts
122// packages/utils/src/formatDate.ts
123export function formatDate(date: Date): string {
124  return date.toLocaleDateString('fr-FR');
125}
126```
127~
128Dans le frontend :
129~
130```ts
131// apps/web/pages/index.tsx
132import { formatDate } from '@myorg/utils';
133~
134export default function Home() {
135  return <div>Nous sommes le {formatDate(new Date())}</div>;
136}
137```
138~
139## Quand choisir Monorepo ?
140~
141- Équipes moyennes à grandes travaillant sur plusieurs projets liés.
142- Besoin de partager du code et de faire du refactoring à grande échelle.
143- Projets qui évoluent rapidement et nécessitent des builds/tests optimisés.
144~
145## Quand choisir Polyrepo ?
146~
147- Petits projets ou projets indépendants.
148- Équipes séparées travaillant sur des produits différents.
149- Politiques d'accès très restrictives.
150~
151## Conclusion
152~
153Il n'existe pas de solution parfaite pour tous. Le choix dépend de la taille de l'équipe, de la complexité des projets et des besoins de collaboration. L'important est d'être conscient des compromis et de choisir les bons outils pour gérer la complexité.