Blog

Organizando a codebase React Native

9 de fevereiro de 2023 7 min de leitura

Boas práticas para organizar e estruturar aplicações React Native grandes. Aprenda sobre estrutura de pastas, organização de componentes e padrões de código fáceis de manter.

Organizando a codebase React Native
React NativeArquiteturaOrganização de códigoBoas práticas

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:

    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

    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

    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:

    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: