Organiser la codebase de votre application React Native
Un guide pour créer une codebase scalable et maintenable
Dans une application React Native, l’organisation de la codebase est essentielle pour la maintenabilité et la scalabilité. La façon dont vous structurez vos fichiers et dossiers peut avoir un impact important sur la facilité avec laquelle vous travaillerez sur la codebase à l’avenir.
Cet article explore la structure de dossiers par fonctionnalité (feature-based) pour une application React Native, ainsi que le rôle de chaque dossier.
Le dossier src
Le dossier src est le répertoire racine de tout le code source de votre application. Il contient plusieurs sous-dossiers, chacun ayant un rôle précis.
Types
Le dossier types est l’endroit où vous définissez les types globaux de votre application. Cela inclut les types de modules, les définitions d’interfaces et tous les autres types personnalisés dont vous avez besoin dans l’application.
Avoir un emplacement central pour tous vos types facilite leur gestion et leur maintenance à mesure que l’application grandit. Cela garantit aussi que vos types sont utilisés de façon cohérente dans toutes les fonctionnalités, ce qui réduit le risque de bugs liés aux types et permet de les repérer plus facilement quand ils surviennent.
Lib
Le dossier lib est l’endroit où vous pouvez placer les fichiers propres à l’application qui sont utilisés globalement. Cela peut inclure l’instance axios pour les appels API, les services de gestion des erreurs, les constantes, la configuration du query client de react-query, etc.
Avoir ces fichiers au même endroit facilite leur maintenance et garantit leur cohérence dans toute l’application.
Components
Le dossier components est l’endroit où vous gardez tous vos composants réutilisables. Ces composants doivent être isolés et ne pas dépendre d’une fonctionnalité ou d’un domaine particulier. Les headers, les boutons et les éléments de liste en sont des exemples.
Séparer ces composants de vos composants propres à une fonctionnalité facilite leur gestion et leur réutilisation dans toute l’application, et réduit la duplication de code.
Hooks
Le dossier hooks est l’endroit où vous gardez les hooks personnalisés utilisés dans toute l’application. Un hook est un type de fonction particulier dans React qui permet de réutiliser de la logique avec state entre vos composants.
Regrouper au même endroit tous vos hooks personnalisés **réutilisables, utilisés à plusieurs endroits, **facilite leur gestion et leur maintenance, réduit le risque de duplication de code et permet de partager plus facilement les hooks entre les différentes parties de l’application.
Localization
Le dossier localization est l’endroit où vous gardez tous les fichiers liés à l’internationalisation de votre application. Cela inclut les fichiers de langue, les constantes de chaînes et toutes les autres ressources nécessaires pour prendre en charge plusieurs langues.
Avoir ces fichiers au même endroit facilite leur gestion et leur maintenance, réduit le risque de duplication de code et simplifie la prise en charge de plusieurs langues dans votre application.
Navigation
Le dossier navigation est l’endroit où vous gardez tout le code lié à la navigation de votre application. Cela inclut les stacks, les types, les routes et tous les autres composants ou fonctions nécessaires à la navigation.
Regrouper tout votre code de navigation au même endroit facilite sa gestion et sa maintenance, réduit le risque de duplication de code et permet de partager plus facilement les fonctionnalités de navigation entre les différentes parties de l’application.
Services
Le dossier services est l’endroit où vous gardez tout le code lié à l’infrastructure sous-jacente de votre application. Cela inclut le code pour les notifications push, le monitoring des erreurs et tous les autres services qui fournissent les fonctionnalités de fond de votre application.
Theme
Le dossier theme est l’endroit où vous devriez stocker le style de votre application, par exemple le thème sombre/clair. Garder vos fichiers de style et de thème au même endroit facilite la gestion et la mise à jour de l’apparence de votre application.
Utils
Les fonctions utilitaires peuvent être une partie importante de votre application React Native, car elles permettent de réutiliser du code dans plusieurs parties de l’application. Le dossier utils est un excellent endroit pour stocker les fonctions utilitaires utilisées dans toute l’application. En centralisant ces fonctions au même endroit, vous vous assurez qu’elles sont faciles à trouver et à utiliser ailleurs dans votre code. Par exemple : les fonctions utilitaires liées au layout react-native.
Features
Quand on construit des applications complexes, il est essentiel d’avoir une structure de dossiers claire et concise qui regroupe tout le code au même endroit. Un dossier features aide à y parvenir, car il sépare les différentes fonctionnalités de l’application en catégories distinctes. Les développeurs peuvent ainsi trouver rapidement une fonctionnalité précise et la modifier sans affecter les autres parties de l’application.
De plus, à mesure que l’application grandit et que de nouvelles fonctionnalités s’ajoutent, la structure de dossiers reste organisée, ce qui permet aux nouveaux développeurs de prendre le projet en main plus facilement et de comprendre comment l’application fonctionne. La séparation claire des responsabilités aide aussi à réduire le risque de bugs et améliore les performances globales de l’application.
Voici à quoi pourrait ressembler un dossier auth :
src/
├── ...
└── features/
├── auth/
| ├── api/
| ├── helpers/
| ├── hooks/
| ├── screens/
| ├── services/
| └── store/
└── ... (other features)
L’intérêt du dossier features est qu’il aide à diviser la codebase en parties plus petites et plus faciles à gérer. Chaque fonctionnalité a ses propres sous-dossiers, comme api, helpers (ou utils), hooks, screens, services et store, qui lui sont propres. Il devient ainsi plus facile de comprendre comment chaque fonctionnalité fonctionne et comment elles interagissent entre elles.
Le dossier api contient tout le code lié aux API propre à l’authentification. Les appels API sont ainsi plus faciles à gérer et restent organisés.
Le dossier helpers contient des méthodes helper ou des fonctions utilitaires propres à la fonctionnalité d’authentification. Elles peuvent être utilisées uniquement au sein de cette fonctionnalité et n’ont pas besoin d’être partagées avec d’autres parties de l’application.
Le dossier hooks contient les hooks liés spécifiquement à l’authentification. Comme React repose fortement sur les hooks, cela facilite leur gestion et leur organisation.
Le dossier screens contient tous les écrans de la fonctionnalité d’authentification. Cela inclut notamment l’écran de connexion, l’écran d’inscription et l’écran de mot de passe oublié.
Le dossier services contient les services propres à la fonctionnalité d’authentification. Par exemple, vous pourriez avoir un service d’authentification chargé de gérer les connexions et les inscriptions des utilisateurs.
Enfin, le dossier store contient le code de state management propre à la fonctionnalité d’authentification. Il peut s’agir d’un store Redux, d’un store Zustand ou de n’importe quelle autre bibliothèque de state management que vous préférez.
En découpant l’application en parties plus petites et organisées, il devient beaucoup plus facile de gérer le code et de le modifier quand c’est nécessaire. Cela aide aussi à garder un code propre et lisible, que les autres développeurs comprennent et manipulent plus facilement.
Exemple de structure du dossier de la fonctionnalité auth
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
Le dossier auth est le sous-dossier dédié à la fonctionnalité d’authentification de votre application. Ses fichiers gèrent tout ce qui touche à l’authentification et à l’autorisation, des API de connexion et d’inscription jusqu’aux écrans avec lesquels l’utilisateur interagit.
Le dossier api contient les API de la fonctionnalité d’authentification, comme les fichiers login.ts et signup.ts, qui gèrent les requêtes et les réponses des demandes de connexion et d’inscription de l’utilisateur. Le fichier refresh-token.ts gère le rafraîchissement du token.
Le dossier helpers contient les fonctions helper utilisées dans le processus d’authentification. Par exemple, le fichier validateToken.ts sert à valider le token, et le fichier dataTransformer.ts transforme les données envoyées aux API d’authentification et reçues de celles-ci.
Le dossier screens contient les composants d’interface avec lesquels l’utilisateur interagit. Par exemple, les fichiers Login.tsx et Signup.tsx contiennent respectivement les composants permettant à l’utilisateur de se connecter et de s’inscrire.
Le dossier hooks contient les hooks personnalisés liés à l’authentification. Par exemple, les fichiers useLoginAction.ts et useSignupForm.ts contiennent des hooks qui aident à gérer le state et les actions des formulaires de connexion et d’inscription.
Le dossier services contient les services liés à l’authentification, comme le fichier validation.ts, qui regroupe les fonctions de validation des saisies de l’utilisateur.
Le dossier store contient le state management lié à l’authentification. Le fichier auth.ts contient le state et les actions liés à l’authentification, avec une bibliothèque de state management comme Zustand, Redux ou une autre.
ATTENTION
Il est important de noter que les conventions de nommage des dossiers et des fichiers peuvent varier d’un projet à l’autre et d’un développeur à l’autre. Ce qui compte, c’est la structure et l’organisation des dossiers, plutôt que les noms exacts utilisés. Par exemple, le dossier utils à la racine de l’application pourrait aussi s’appeler helpers ou utilities, et au lieu de screens on pourrait aussi parler de pages ou de tout autre nom qui a du sens pour le projet. L’objectif est d’avoir une structure claire et cohérente qui aide les développeurs à comprendre l’organisation du code et facilite la maintenance et l’évolution de l’application.
Structure de dossiers par type ou par fonctionnalité
Une autre méthode largement adoptée pour organiser la codebase d’un projet est la structure de dossiers par type, qui a ses propres avantages et inconvénients. Dans la section suivante, nous allons comparer visuellement ces deux structures.
Comparaison
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
Comme on le voit ci-dessus, dans la structure par type, les écrans sont séparés des appels API et des helpers, ce qui peut rendre la codebase plus difficile à comprendre. Remarquez qu’on risque de placer des écrans sans rapport, comme LoginScreen.tsx et TodoListScreen.tsx, dans le même dossier avec une structure par type. De plus, le code peut aussi devenir plus difficile à maintenir, puisque le code lié n’est pas regroupé au même endroit. Avec la structure par fonctionnalité, en revanche, tout le code lié à l’authentification, y compris les écrans, les appels API, les helpers et les services, est regroupé dans un seul dossier auth. La codebase est ainsi plus facile à comprendre, puisque tout le code lié se trouve au même endroit. Cette approche offre une meilleure encapsulation du code et rend le projet scalable et flexible face aux évolutions futures.
Le résultat final avec une structure par fonctionnalité
Voici à quoi ressemblerait le résultat final avec la structure par fonctionnalité et des fichiers d’exemple :
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)
Les fichiers ajoutés dans les différents dossiers ci-dessus (par exemple button.tsx et header.tsx dans le dossier components, useHeader.ts dans le dossier hooks, etc.) servent d’exemples et ne doivent pas être pris comme exacts à 100 %. Ils sont là pour donner une représentation visuelle de la structure de dossiers et aider à mieux comprendre l’organisation de la codebase. L’implémentation réelle peut varier selon les besoins précis du projet. Cet article se concentre sur la structure par fonctionnalité et sur la façon dont elle aide à construire une codebase scalable et organisée, plutôt que sur le détail de chaque fichier.
Conclusion
À mon avis, la structure de dossiers par fonctionnalité est une approche utile pour organiser les projets React/React Native. En découpant le code en fonctionnalités distinctes, je trouve l’application plus facile à maintenir, à comprendre et à développer. Cette structure offre une meilleure encapsulation du code, ce qui rend le projet scalable et flexible face aux évolutions futures. Bien sûr, ce n’est pas une solution universelle, et la structure exacte peut varier selon la taille et la complexité du projet. Mais l’idée clé est de garder une séparation claire entre les différentes fonctionnalités et leurs composants, services et données respectifs. Dans mon expérience, cette structure m’a aidé à construire et à maintenir des projets bien organisés, capables d’absorber la croissance et les changements au fil du temps. Je voulais partager cette approche avec ceux qui pourraient eux aussi la trouver utile.
Publié sur
Cet article est également publié sur :