# Je codebase in React Native organiseren

By Tarik Pinarci (https://tarikpinarci.com). Published 2023-02-09. Canonical: https://tarikpinarci.com/nl/blog/organizing-react-native-codebase

## Een gids voor een codebase die kan meegroeien en onderhoudbaar blijft

In een React Native-app is het organiseren van de codebase cruciaal voor onderhoudbaarheid en schaalbaarheid. Hoe je je bestanden en mappen structureert, kan een grote invloed hebben op hoe makkelijk je in de toekomst met de codebase kunt werken.

In dit artikel bekijken we de **_feature-gebaseerde_** mappenstructuur voor een React Native-app en het doel van elke map.

### De src-map

De src-map is de hoofdmap voor alle broncode van je app. Binnen deze map vind je een aantal andere submappen die elk een specifiek doel hebben.

### Types

In de types-map definieer je de globale types van je app. Dat zijn onder andere module types, interfacedefinities en alle andere eigen types die je overal in de app nodig hebt.

Eén centrale plek voor al je types maakt het makkelijker om ze te beheren en te onderhouden naarmate je app groeit. Daarnaast zorgt het ervoor dat je types in alle features consistent worden gebruikt. Dat verkleint de kans op bugs rond types en maakt het makkelijker om ze te vinden als ze toch optreden.

### Lib

In de lib-map bewaar je app-specifieke bestanden die overal in de app worden gebruikt. Denk aan de axios-instance voor API-calls, services voor foutafhandeling, constanten, het opzetten van de query client in react-query enzovoort.

Als deze bestanden op één centrale plek staan, zijn ze makkelijker te onderhouden en blijven ze consistent in de hele app.

### Components

In de components-map bewaar je al je herbruikbare components. Deze components horen op zichzelf te staan en niet specifiek te zijn voor een bepaalde feature of een bepaald domein. Voorbeelden van zulke components zijn headers, knoppen en list items.

Door deze components gescheiden te houden van je feature-specifieke components, kun je ze makkelijker beheren en hergebruiken in je hele app, en heb je minder duplicatie in je code.

### Hooks

In de hooks-map bewaar je de custom hooks die op meerdere plekken in je app worden gebruikt. Een hook is een speciaal soort functie in React waarmee je logica met state kunt hergebruiken in je components.

Als al je **herbruikbare, op meerdere plekken gebruikte **custom hooks op één centrale plek staan, zijn ze makkelijker te beheren en te onderhouden. Het verkleint ook de kans op dubbele code en maakt het makkelijker om hooks te delen tussen verschillende delen van je app.

### Localization

In de localization-map bewaar je alle bestanden die met internationalisering in je app te maken hebben. Dat zijn onder andere taalbestanden, stringconstanten en alle andere resources die nodig zijn om meerdere talen in je app te ondersteunen.

Als deze bestanden op één centrale plek staan, zijn ze makkelijker te beheren en te onderhouden. Het verkleint ook de kans op dubbele code en maakt het makkelijker om meerdere talen in je app te ondersteunen.

### Navigation

In de navigation-map bewaar je alle code die met navigatie in je app te maken heeft. Dat zijn onder andere de stacks, types, routes en alle andere components of functies die nodig zijn voor navigatie.

Als al je navigatiecode op één centrale plek staat, is die makkelijker te beheren en te onderhouden. Het verkleint ook de kans op dubbele code en maakt het makkelijker om navigatiefunctionaliteit te delen tussen verschillende delen van je app.

### Services

In de services-map bewaar je alle code die te maken heeft met de onderliggende infrastructuur van je app. Denk aan code voor push notifications, foutmonitoring en alle andere services die de onderliggende functionaliteit van je app leveren.

### Theme

In de theme-map bewaar je de styling van je app, bijvoorbeeld een donker en een licht thema. Als je styling- en themabestanden op één plek staan, kun je de look en feel van je app makkelijker beheren en aanpassen wanneer dat nodig is.

### Utils

Utility-functies kunnen een belangrijk onderdeel van je React Native-app zijn, omdat je er code mee kunt hergebruiken op meerdere plekken in je app. De utils-map is een prima plek voor utility-functies die overal in je app worden gebruikt. Door deze functies op één plek te verzamelen, zorg je ervoor dat ze makkelijk te vinden en te gebruiken zijn in andere delen van je code. Bijvoorbeeld: utility-functies voor layout in react-native.

### Features

Als je complexe apps bouwt, is een duidelijke en overzichtelijke mappenstructuur essentieel, waarin alle code op één plek bij elkaar zit. Een features-map helpt daarbij, omdat die alle verschillende features van de app in aparte categorieën onderverdeelt. Zo kunnen developers snel een specifieke feature vinden en aanpassen zonder andere delen van de app te raken.

Bovendien blijft de mappenstructuur overzichtelijk naarmate de app groeit en er meer features bijkomen. Daardoor kunnen nieuwe developers makkelijker instappen en begrijpen hoe de app werkt. De duidelijke scheiding van verantwoordelijkheden helpt ook om de kans op bugs te verkleinen en verbetert de algehele performance van de app.

Zo zou een auth-map eruit kunnen zien:

```tsx
    src/
    ├── ...
    └── features/
        ├── auth/
        |   ├── api/
        |   ├── helpers/
        |   ├── hooks/
        |   ├── screens/
        |   ├── services/
        |   └── store/
        └── ... (other features)
```

Het belang van de features-map zit in het feit dat je de codebase ermee opdeelt in kleinere, beter beheersbare delen. Elke feature heeft zijn eigen submappen, zoals api, helpers (of utils), hooks, screens, services en store, die specifiek bij die feature horen. Zo is het makkelijker te begrijpen hoe elke feature werkt en hoe de features met elkaar samenwerken.

De api-map bevat alle API-code die specifiek is voor authenticatie. Zo zijn de API-calls makkelijker te beheren en blijven ze georganiseerd.

De helpers-map bevat hulpmethodes of utility-functies die specifiek zijn voor de authenticatie-feature. Ze worden alleen binnen de authenticatie-feature gebruikt en hoeven niet gedeeld te worden met andere delen van de app.

De hooks-map bevat hooks die specifiek met authenticatie te maken hebben. Omdat React sterk leunt op hooks, zijn de hooks zo makkelijker te beheren en blijven ze georganiseerd.

De screens-map bevat alle schermen van de authenticatie-feature. Daaronder vallen onder andere het inlogscherm, het registratiescherm en het scherm voor een vergeten wachtwoord.

De services-map bevat services die specifiek zijn voor de authenticatie-feature. Je hebt bijvoorbeeld een authenticatieservice die verantwoordelijk is voor het afhandelen van het inloggen en registreren van gebruikers.

Tot slot bevat de store-map de code voor state management die specifiek is voor de authenticatie-feature. Dat kan een Redux-store zijn, een Zustand-store of een andere library voor state management die je voorkeur heeft.

Door de app op te delen in kleinere, georganiseerde delen, wordt het veel makkelijker om de code te beheren en aan te passen wanneer dat nodig is. Het helpt ook om de code schoon en leesbaar te houden, zodat andere developers de code makkelijker begrijpen en ermee kunnen werken.

### Voorbeeldstructuur van de auth-featuremap

```tsx
    src/
    └── features/
        └── auth/
            ├── api/
            |   ├── login.ts
            |   ├── signup.ts
            |   └── refresh-token.ts
            ├── helpers/
            |   ├── validateToken.ts
            |   └── dataTransformer.ts
            ├── screens/
            |   ├── Login.tsx
            |   └── Signup.tsx
            ├── services/
            |   └── validation.ts
            └── store/
                └── auth.ts
```

De auth-map is de submap voor de authenticatie-feature van je app. De bestanden in deze map regelen alles wat met authenticatie en autorisatie te maken heeft, van de API's voor inloggen en registreren tot de UI-schermen waarmee de gebruiker werkt.

De api-map bevat de API's voor de authenticatie-feature, zoals de bestanden login.ts en signup.ts, die de requests en responses voor het inloggen en registreren van de gebruiker afhandelen. Het bestand refresh-token.ts regelt het verversen van de token.

De helpers-map bevat hulpfuncties die in het authenticatieproces worden gebruikt. Het bestand validateToken.ts wordt bijvoorbeeld gebruikt om de token te valideren, en het bestand dataTransformer.ts zet data om van en naar de authenticatie-API's.

De screens-map bevat de UI-components waarmee de gebruiker werkt. De bestanden Login.tsx en Signup.tsx bevatten bijvoorbeeld de UI-components waarmee de gebruiker respectievelijk inlogt en zich registreert.

De hooks-map bevat custom hooks rond authenticatie. De bestanden useLoginAction.ts en useSignupForm.ts bevatten bijvoorbeeld hooks die helpen bij het beheren van de state en acties van respectievelijk het inlogformulier en het registratieformulier.

De services-map bevat services rond authenticatie, zoals het bestand validation.ts, met functies om de invoer van de gebruiker te valideren.

De store-map bevat het state management rond authenticatie. Het bestand auth.ts bevat de state en acties rond authenticatie, met een library voor state management zoals Zustand, Redux of een andere.

### LET OP

> Het is belangrijk om te weten dat de naamgeving van mappen en bestanden kan verschillen per project en per developer. Het gaat om de structuur en organisatie van de mappen, niet om de exacte namen van elke map. De utils-map in de root van de app kan bijvoorbeeld ook helpers of utilities heten, en in plaats van _screens_ kun je ook _pages_ gebruiken of een andere naam die logisch is voor het specifieke project. Het doel is een duidelijke en consistente structuur die developers helpt de organisatie van de code te begrijpen en die het makkelijker maakt om de app te onderhouden en te laten groeien.

### Type-gebaseerde mappenstructuur tegenover feature-gebaseerde mappenstructuur

Een andere veelgebruikte manier om de codebase van een project te organiseren, is de type-gebaseerde mappenstructuur, met zijn eigen voor- en nadelen. In het volgende deel zetten we deze twee mappenstructuren visueel naast elkaar.

### Vergelijking

```tsx
    Feature-based folder structure:

    src/
    └── features/
        ├── auth/
        |   ├── api/
        |   │     ├── register.tsx
        |   │     ├── login.tsx
        |   │     ├── types.tsx
        |   │     └── helpers.tsx
        |   ├── helpers/
        |   ├── hooks/
        |   └── screens/
        |   │     ├── LoginScreen.tsx
        |   │     ├── SignupScreen.tsx
        |   │     ├── WelcomeScreen.tsx
        |   │     └── HomeScreen.tsx
        |   ├── services/
        |   └── store/
        ├── todo/
        |   └── screens/
        |   │    └── TodoListScreen.tsx
        |   ├── services/
        |   └── store/
        └── ... (other features)

    Type-based folder structure:

    src/
    ├── screens/
    |   ├── LoginScreen.tsx
    |   ├── SignupScreen.tsx
    |   ├── TodoListScreen.tsx
    |   ├── WelcomeScreen.tsx
    |   └── HomeScreen.tsx
    ├── api/
    |   └── auth/
    |       ├── register.ts
    |       ├── login.ts
    |       ├── types.ts
    |       └── helpers.ts
```

Zoals je hierboven ziet, zijn de schermen in de type-gebaseerde mappenstructuur gescheiden van de API-calls en helpers, wat de codebase moeilijker te begrijpen kan maken. Merk op dat we in de type-gebaseerde mappenstructuur ongerelateerde schermen zoals LoginScreen.tsx en TodoListScreen.tsx in dezelfde map kunnen laten belanden. Bovendien **_kan het de code ook moeilijker te onderhouden maken, omdat code die bij elkaar hoort niet op één plek gegroepeerd is._** In de feature-gebaseerde mappenstructuur is alle code rond authenticatie, inclusief de schermen, API-calls, helpers en services, juist samengebracht in één auth-map. Dat maakt de codebase makkelijker te begrijpen, omdat alle bij elkaar horende code op één plek staat. Deze aanpak zorgt voor betere encapsulatie van code en maakt het project schaalbaar en flexibel voor toekomstige wijzigingen.

### Het uiteindelijke beeld met een feature-gebaseerde mappenstructuur

Zo zou het er uiteindelijk uitzien met de feature-gebaseerde mappenstructuur en wat voorbeeldbestanden:

```tsx
    Feature-based folder structure:

    src/
    ├── components/
    │   ├── Button.tsx
    │   └── Header.tsx
    ├── hooks/
    │   └── useHeader.ts
    ├── localization/
    │   ├── languages.ts
    │   └── locales.ts
    ├── lib/
    │   ├── axios-instance.ts
    │   └── constants.ts
    ├── navigation/
    │   ├── root-navigator.tsx
    │   └── auth-stack.tsx
    ├── services/
    │   ├── notification.ts
    │   └── logging.ts
    ├── theme/
    │   └── index.ts
    ├── types/
    │   ├── env.d.ts
    │   └── react-augment.d.ts
    ├── utils/
    │   └── layout.ts
    └── features/
        ├── auth/
        │   ├── api/
        │   │   ├── login.ts
        │   │   ├── signup.ts
        │   │   └── refresh-token.ts
        │   ├── helpers/
        │   │   ├── validateToken.ts
        │   │   └── dataTransformer.ts
        │   ├── hooks/
        │   │   ├── useLoginAction.ts
        │   │   └── useSignupForm.ts
        │   ├── screens/
        │   │   ├── Login.tsx
        │   │   └── Signup.tsx
        │   ├── services/
        │   │   └── validation.ts
        │   └── store/
        │       └── auth.ts (zustand, redux, jotai etc.)
        └── ... (other features)
```

> De bestanden die hierboven aan de verschillende mappen zijn toegevoegd (bijvoorbeeld button.tsx en header.tsx in de components-map, useHeader.ts in de hooks-map, enzovoort) zijn bedoeld als voorbeeld en moeten niet als 100% kloppend worden opgevat. Ze staan erin om de mappenstructuur visueel weer te geven en de organisatie van de codebase beter te helpen begrijpen. De echte implementatie kan verschillen, afhankelijk van de specifieke eisen van het project. Dit artikel draait om de feature-gebaseerde mappenstructuur en hoe die helpt om een schaalbare en georganiseerde codebase te bouwen, niet om de details van afzonderlijke bestanden.

---

### Conclusie

Naar mijn mening is de feature-gebaseerde mappenstructuur een handige aanpak om React- en React Native-projecten te organiseren. Door de code op te delen in aparte features, vind ik de app makkelijker te onderhouden, te begrijpen en verder te ontwikkelen. Deze structuur zorgt voor betere encapsulatie van code, waardoor het project schaalbaar en flexibel blijft voor toekomstige wijzigingen. Natuurlijk is dit geen oplossing die overal past, en de exacte structuur kan verschillen afhankelijk van de grootte en complexiteit van het project. Het kernidee is wel om een duidelijke scheiding te houden tussen verschillende features en hun eigen components, services en data. In mijn ervaring heeft deze structuur me geholpen om goed georganiseerde projecten te bouwen en te onderhouden die groei en verandering in de loop van de tijd aankunnen. Ik wilde deze aanpak delen met anderen die er misschien ook iets aan hebben.

### Gepubliceerd op

Dit artikel is ook gepubliceerd op:

- [Medium](https://medium.com/gitconnected/how-to-structure-react-native-application-679e36c63efd)

