# Organizando a codebase React Native

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

# Organizando a sua codebase React Native

## Um guia para criar uma codebase escalável e fácil de manter

Em uma aplicação React Native, organizar a codebase é crucial para a manutenção e a escalabilidade. A forma como você estrutura os arquivos e pastas pode influenciar muito a facilidade de trabalhar com a codebase no futuro.

Este artigo explora a estrutura de pastas **_baseada em features_** para uma aplicação React Native e o propósito de cada pasta.

### A pasta src

A pasta src é o diretório raiz de todo o código-fonte da aplicação. Dentro dela, você encontra várias outras subpastas, cada uma com um propósito específico.

### Types

A pasta types é onde você define os tipos globais da aplicação. Isso inclui tipos de módulos, definições de interfaces e quaisquer outros tipos personalizados que você precise usar em toda a aplicação.

Ter um lugar central para todos os seus tipos facilita gerenciá-los e mantê-los conforme a aplicação cresce. Além disso, garante que os tipos sejam usados de forma consistente em todas as features, reduzindo o risco de bugs relacionados a tipos e facilitando encontrá-los quando aparecem.

### Lib

A pasta lib é onde você pode guardar arquivos específicos da aplicação que são usados globalmente no app. Isso pode incluir a instância do axios para chamadas de API, serviços de tratamento de erros, constantes, a configuração do query client do react-query etc.

Ter esses arquivos em um lugar centralizado facilita a manutenção e garante que eles sejam consistentes na aplicação inteira.

### Components

A pasta components é onde você guarda todos os seus componentes reutilizáveis. Esses componentes devem ser isolados e não específicos de nenhuma feature ou domínio em particular. Exemplos desse tipo de componente são headers, botões e itens de lista.

Manter esses componentes separados dos componentes específicos de cada feature facilita gerenciá-los e reutilizá-los em toda a aplicação, além de reduzir a duplicação no código.

### Hooks

A pasta hooks é onde você guarda os hooks personalizados usados na aplicação. Um hook é um tipo especial de função no React que permite reutilizar lógica com state entre os componentes.

Ter todos os seus hooks personalizados **reutilizáveis ou usados em vários lugares** em um lugar centralizado facilita gerenciá-los e mantê-los, além de reduzir o risco de duplicação de código e facilitar o compartilhamento de hooks entre diferentes partes da aplicação.

### Localization

A pasta localization é onde você guarda todos os arquivos relacionados à internacionalização da aplicação. Isso inclui arquivos de idioma, constantes de strings e quaisquer outros recursos necessários para suportar vários idiomas na aplicação.

Ter esses arquivos em um lugar centralizado facilita gerenciá-los e mantê-los, além de reduzir o risco de duplicação de código e facilitar o suporte a vários idiomas na aplicação.

### Navigation

A pasta navigation é onde você guarda todo o código relacionado à navegação da aplicação. Isso inclui as stacks, os tipos, as rotas e quaisquer outros componentes ou funções necessários para a navegação.

Ter todo o código de navegação em um lugar centralizado facilita gerenciá-lo e mantê-lo, além de reduzir o risco de duplicação de código e facilitar o compartilhamento da navegação entre diferentes partes da aplicação.

### Services

A pasta services é onde você guarda todo o código relacionado à infraestrutura por trás da aplicação. Isso inclui código para push notifications, monitoramento de erros e quaisquer outros serviços usados para fornecer a funcionalidade de base da aplicação.

### Theme

A pasta theme é onde você deve guardar a estilização do app, por exemplo o tema escuro/claro. Manter os arquivos de estilo e de tema em um só lugar facilita gerenciar e atualizar o visual do app quando necessário.

### Utils

Funções utilitárias podem ser uma parte importante da sua aplicação React Native, porque oferecem uma forma de reutilizar código em várias partes da aplicação. A pasta utils é um ótimo lugar para guardar as funções utilitárias usadas em toda a aplicação. Centralizando essas funções em um só lugar, você garante que elas sejam fáceis de encontrar e usar em outras partes do código. Por exemplo: funções utilitárias relacionadas a layout no react-native.

### Features

Na hora de construir aplicações complexas, é essencial ter uma estrutura de pastas clara e concisa que reúna todo o código em um só lugar. Ter uma pasta features ajuda nisso, porque separa as diferentes features da aplicação em categorias distintas. Isso permite que os desenvolvedores encontrem e alterem rapidamente uma feature específica sem afetar outras partes da aplicação.

Além disso, conforme a aplicação cresce e mais features são adicionadas, a estrutura de pastas continua organizada, o que facilita para novos desenvolvedores chegarem e entenderem como a aplicação funciona. A separação clara de responsabilidades também ajuda a reduzir o risco de bugs e melhora a performance geral da aplicação.

Veja como uma pasta auth poderia ficar:

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

A importância da pasta features está na capacidade de dividir a codebase em partes menores e mais fáceis de gerenciar. Cada feature tem as suas próprias subpastas, como api, helpers (ou utils), hooks, screens, services e store, específicas daquela feature. Isso facilita entender como cada feature funciona e como elas interagem entre si.

A pasta api contém todo o código de API específico da autenticação. Isso facilita gerenciar as chamadas de API e mantê-las organizadas.

A pasta helpers contém métodos auxiliares ou funções utilitárias específicas da feature de autenticação. Eles podem ser usados exclusivamente dentro da feature de autenticação e não precisam ser compartilhados com outras partes da aplicação.

A pasta hooks contém hooks relacionados especificamente à autenticação. Como o React depende muito de hooks, isso facilita gerenciá-los e mantê-los organizados.

A pasta screens contém todas as telas da feature de autenticação. Isso inclui a tela de login, a tela de cadastro e a tela de esqueci a senha, entre outras.

A pasta services contém serviços específicos da feature de autenticação. Por exemplo, você pode ter um serviço de autenticação responsável por cuidar do login e do cadastro dos usuários.

Por fim, a pasta store contém o código de gerenciamento de estado específico da feature de autenticação. Pode ser uma store Redux, uma store Zustand ou qualquer outra biblioteca de gerenciamento de estado que você prefira.

Dividindo a aplicação em partes menores e organizadas, fica muito mais fácil gerenciar o código e alterá-lo quando necessário. Isso também ajuda a manter o código limpo e legível, o que facilita para outros desenvolvedores entenderem e trabalharem com ele.

### Exemplo de estrutura da pasta da feature auth

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

A pasta auth é a subpasta dedicada à feature de autenticação da aplicação. Os arquivos dessa pasta cuidam de tudo relacionado a autenticação e autorização, das APIs de login e cadastro às telas de UI com as quais o usuário interage.

A pasta api guarda as APIs da feature de autenticação, como os arquivos login.ts e signup.ts, que tratam as requisições e respostas de login e cadastro do usuário. O arquivo refresh-token.ts cuida da renovação do token.

A pasta helpers guarda funções auxiliares usadas no processo de autenticação. Por exemplo, o arquivo validateToken.ts é usado para validar o token, e o arquivo dataTransformer.ts transforma os dados que vão para as APIs de autenticação e que vêm delas.

A pasta screens guarda os componentes de UI com os quais o usuário interage. Por exemplo, os arquivos Login.tsx e Signup.tsx contêm os componentes de UI para o usuário fazer login e se cadastrar, respectivamente.

A pasta hooks guarda hooks personalizados relacionados à autenticação. Por exemplo, os arquivos useLoginAction.ts e useSignupForm.ts contêm hooks que ajudam a gerenciar o state e as ações dos formulários de login e cadastro, respectivamente.

A pasta services guarda serviços relacionados à autenticação, como o arquivo validation.ts, que contém funções para validar o input do usuário.

A pasta store guarda o gerenciamento de estado relacionado à autenticação. O arquivo auth.ts contém o state e as ações relacionadas à autenticação, usando uma biblioteca de gerenciamento de estado como Zustand, Redux ou outra.

### ATENÇÃO

> É importante notar que as convenções de nomes das pastas e arquivos podem variar de projeto para projeto e de desenvolvedor para desenvolvedor. O que importa é a estrutura e a organização das pastas, e não os nomes exatos usados em cada uma. Por exemplo, a pasta utils na raiz do app também poderia se chamar helpers ou utilities, ou, em vez de _screens_, poderia se chamar _pages_ ou qualquer outro nome que faça sentido para o projeto. O objetivo é ter uma estrutura clara e consistente que ajude os desenvolvedores a entender a organização do código e facilite manter e escalar a aplicação.

### Estrutura de pastas por tipo vs estrutura de pastas por feature

Outro método muito adotado para organizar a codebase de um projeto é a estrutura de pastas por tipo, que tem os seus próprios prós e contras. Na seção a seguir, vamos comparar visualmente essas duas estruturas de pastas.

### Comparação

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

Como dá para ver acima, na estrutura de pastas por tipo, as telas ficam separadas das chamadas de API e dos helpers, o que pode dificultar o entendimento da codebase. Repare como podemos acabar colocando telas sem relação entre si, como LoginScreen.tsx e TodoListScreen.tsx, na mesma pasta na estrutura por tipo. Além disso, **_isso também pode dificultar a manutenção do código, já que o código relacionado não fica agrupado em um só lugar._** Já na estrutura de pastas por feature, todo o código relacionado à autenticação, incluindo as telas, as chamadas de API, os helpers e os serviços, fica agrupado em uma única pasta auth. Isso facilita entender a codebase, já que todo o código relacionado está em um só lugar. Essa abordagem permite um encapsulamento melhor do código e torna o projeto escalável e flexível para mudanças futuras.

### Resultado final com uma estrutura de pastas por feature

Veja abaixo como ficaria no fim a estrutura de pastas por feature, com arquivos de exemplo:

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

> Os arquivos adicionados às várias pastas acima (por exemplo, button.tsx e header.tsx na pasta components, useHeader.ts na pasta hooks etc.) servem apenas como exemplo e não devem ser tomados como 100% precisos. O objetivo de incluir esses arquivos é dar uma representação visual da estrutura de pastas e ajudar a entender melhor a organização da codebase. A implementação real pode variar de acordo com os requisitos específicos do projeto. O foco deste artigo é a estrutura de pastas por feature e como ela pode ajudar a construir uma codebase escalável e organizada, e não os detalhes específicos de cada arquivo.

---

### Conclusão

Na minha opinião, a estrutura de pastas por feature é uma abordagem útil para organizar projetos React/React Native. Dividindo o código em features separadas, acho mais fácil manter, entender e desenvolver a aplicação. Essa estrutura permite um encapsulamento melhor do código, tornando o projeto escalável e flexível para mudanças futuras. Claro que não é uma solução que serve para tudo, e a estrutura exata pode variar de acordo com o tamanho e a complexidade do projeto. Mas a ideia principal é manter uma separação clara entre as diferentes features e os seus respectivos componentes, serviços e dados. Na minha experiência, essa estrutura me ajudou a construir e manter projetos bem organizados, capazes de lidar com crescimento e mudanças ao longo do tempo. Quis compartilhar essa abordagem com outras pessoas que também possam achá-la útil.

### Publicado em

Este artigo também foi publicado em:

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

