Wat is het Repository patroon?

Question

Accepted Answer

Het **Repository** patroon abstraheert **data access** achter een collectie-achtige interface — het scheidt business logic van hoe data wordt opgeslagen en opgehaald. Het ontkoppelt de applicatie van gegevensbronnen (databases, API's), wat testbaarheid en onderhoudbaarheid verbetert.

## Wat het Repository patroon doet

```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
```

## Voorbeeld

```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
```

## Voordelen

```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
```

## Waarom het belangrijk is

Het Repository patroon begrijpen is waardevol omdat het een **veel gebruikt, praktisch patroon** is voor het schoon scheiden van business logic van data access, dus het is relevante designkennis.

Het Repository patroon abstraheert data access achter een collectie-achtige interface (findById, save, delete), **verbergt hoe en waar data wordt opgeslagen** zodat business logic de repository gebruikt in plaats van rechtstreeks de database.

Begrijpen wat het doet (een schone data-access interface bieden die de werkelijke opslag verbergt, waarbij *wat* data-operaties worden gescheiden van *hoe* zij worden geïmplementeerd) is de kernkennis.

Het begrijpen van de **voordelen** is essentieel: **ontkoppeling** (business logic die niet afhangt van data-access details zoals de specifieke database, ORM of API, zodat je gegevensbronnen kunt vervangen zonder business logic aan te passen — een waardevol architectuurvoordeel), **testbaarheid** (mock/fake repositories gebruiken in tests zodat geen echte database nodig is — belangrijk voor unit testen van business logic), **gecentraliseerde data access** (querylogica op één plaats voor onderhoudbaarheid en consistentie), en **schonere architectuur** (duidelijke scheiding tussen domain/business logic en data).

Deze voordelen maken het Repository patroon praktisch waardevol voor onderhoudbare, testbare applicaties.

Begrijpen dat het veel voorkomt in **gelaagde/schone architecturen** en werkt met dependency injection verduidelijkt zijn plaats in moderne architectuur.

Het Repository patroon wordt veel gebruikt omdat het scheiden van business logic van data access (voor testbaarheid, onderhoudbaarheid en flexibiliteit) een veelgebruikt, belangrijk behoefte is.

Omdat het Repository patroon een veel gebruikt, praktisch patroon is voor het schoon scheiden van business logic van data access (ontkoppeling, testbaarheid, gecentraliseerde data access, schonere architectuur) — een veelgebruikt, belangrijk behoefte — en centraal staat in gelaagde/schone architecturen, en omdat het begrijpen wat het doet en de voordelen ervan relevant is voor het bouwen van onderhoudbare applicaties, is het begrijpen van het Repository patroon waardevol, praktisch relevante designkennis — een veel gebruikt patroon voor het scheiden van business logic van data access, dat ontkoppeling en testbaarheid biedt, centraal staat in schone/gelaagde architecturen, en belangrijke designkennis is voor het bouwen van onderhoudbare, testbare applicaties met schone scheiding tussen logic en data.