Qu'est-ce que le pattern Repository ?

Question

Accepted Answer

Le pattern **Repository** abstrait l'**accès aux données** derrière une interface de type collection — séparant la logique métier de la façon dont les données sont stockées et récupérées. Il découple l'application des sources de données (bases de données, APIs), améliorant la testabilité et la maintenabilité.

## Ce que le pattern Repository fait

```text
REPOSITORY → an abstraction layer between business logic and DATA ACCESS:
  → provides a clean interface (like a collection: findById, save, delete, findAll)
  → HIDES how/where data is actually stored (database, API, cache, files)
  → business logic uses the repository, NOT the database directly
→ separate WHAT data operations from HOW they're implemented
```

## Exemple

```js
// repository interface — business logic depends on THIS, not the DB
class UserRepository {
  async findById(id) { /* query the database (hidden behind here) */ }
  async save(user) { /* insert/update */ }
  async findByEmail(email) { /* ... */ }
}
// business logic uses the repository, unaware of the data source
const user = await userRepository.findById(42);
// → swap the DB, or use a mock in tests, without changing business logic
```

## Avantages

```text
✓ DECOUPLING → business logic doesn't depend on data-access details (DB, ORM, API) →
  swap data sources without changing business logic
✓ TESTABILITY → use a MOCK/fake repository in tests (no real database needed)
✓ CENTRALIZED data access → query logic in one place (maintainable, consistent)
✓ CLEANER architecture → clear separation between domain/business logic and data
→ common in layered/clean architectures; works with DI
```

## Pourquoi c'est important

Comprendre le pattern Repository est précieux car c'est un **pattern courant et pratique** pour bien séparer la logique métier de l'accès aux données, c'est donc une connaissance en architecture pertinente.

Le pattern Repository abstrait l'accès aux données derrière une interface de type collection (findById, save, delete), **cachant comment et où les données sont stockées** afin que la logique métier utilise le repository plutôt que la base de données directement.

Comprendre ce qu'il fait (fournir une interface d'accès aux données propre qui cache le stockage réel, séparant *quelles* opérations de données de *comment* elles sont implémentées) est la connaissance centrale.

Comprendre les **avantages** est clé : **découplage** (la logique métier ne dépend pas des détails d'accès aux données comme la base de données spécifique, l'ORM ou l'API, donc vous pouvez échanger les sources de données sans changer la logique métier — un avantage architectural précieux), **testabilité** (utiliser des repositories simulés/faux dans les tests afin qu'aucune base de données réelle ne soit nécessaire — important pour les tests unitaires de la logique métier), **accès aux données centralisé** (logique de requête en un seul endroit pour la maintenabilité et la cohérence), et **architecture plus propre** (séparation claire entre la logique domaine/métier et les données).

Ces avantages rendent le pattern Repository pratiquement précieux pour les applications maintenables et testables.

Comprendre qu'il est courant dans les **architectures en couches/propres** et fonctionne avec l'injection de dépendances clarifie sa place dans l'architecture moderne.

Le pattern Repository est largement utilisé car séparer la logique métier de l'accès aux données (pour la testabilité, la maintenabilité et la flexibilité) est un besoin courant et important.

Puisque le pattern Repository est un pattern courant et pratique pour bien séparer la logique métier de l'accès aux données (découplage, testabilité, accès aux données centralisé, architecture plus propre) — un besoin courant et important — et est central aux architectures en couches/propres, et puisque comprendre ce qu'il fait et ses avantages est pertinent pour construire des applications maintenables, comprendre le pattern Repository est une connaissance en architecture précieuse et pratiquement pertinente — un pattern fréquemment utilisé pour séparer la logique métier de l'accès aux données, fournissant du découplage et de la testabilité, central aux architectures propres/en couches, et une connaissance architecturale importante pour construire des applications maintenables et testables avec une séparation propre entre la logique et les données.