Programação B

Montando o Monorepo

No capítulo de ambiente de desenvolvimento, vimos que um monorepo agrupa todos os componentes da aplicação num único repositório Git. Vamos criar essa estrutura para o TamoJunto.

Abra o terminal e crie o diretório do projeto:

$ mkdir tamojunto
$ cd tamojunto
$ git init
Initialized empty Git repository in /home/maria/tamojunto/.git/

Agora, crie os três diretórios dos componentes:

$ mkdir backend web mobile

Cada diretório vai abrigar um componente independente, com suas próprias dependências e configuração:

• backend/ — o servidor HTTP e a conexão com o banco de dados.
• web/ — a interface web que roda no navegador.
• mobile/ — o aplicativo que roda em dispositivos Android e iOS.

Por enquanto, os diretórios estão vazios. O Git não rastreia diretórios vazios — ele rastreia arquivos. Para que os diretórios apareçam no repositório, uma convenção comum é colocar um arquivo .gitkeep em cada um:

$ touch backend/.gitkeep web/.gitkeep mobile/.gitkeep

O .gitkeep não tem significado especial para o Git. É apenas um arquivo vazio cujo nome, por convenção, sinaliza “este diretório precisa existir no repositório”. Quando adicionarmos código de verdade em cada diretório, o .gitkeep pode ser removido.

O .gitignore do TamoJunto

Antes do primeiro commit, vamos configurar o .gitignore. Os três componentes usam Node.js, então compartilham alguns padrões:

node_modules/
dist/
.env
*.log
.DS_Store

• node_modules/ — dependências instaladas pelo npm. Cada componente terá a sua pasta node_modules/, e nenhuma delas deve ir para o repositório (são grandes e reproduzíveis via npm install).
• dist/ — arquivos gerados pelo build (JavaScript compilado, bundles).
• .env — variáveis de ambiente com credenciais locais.
• *.log — logs gerados por ferramentas de desenvolvimento.
• .DS_Store — metadados do macOS que não interessam ao projeto.

Primeiro commit

Com a estrutura pronta, vamos registrar tudo:

$ git add .
$ git status
On branch main

No commits yet

Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
	new file:   .gitignore
	new file:   backend/.gitkeep
	new file:   mobile/.gitkeep
	new file:   web/.gitkeep

Quatro arquivos. Sem surpresas — o git status antes do commit é um hábito que evita incluir algo por acidente. Agora o commit:

$ git commit -m "Criar estrutura do monorepo com backend, web e mobile"
[main (root-commit) c4a1e8f] Criar estrutura do monorepo com backend, web e mobile
 4 files changed, 5 insertions(+)
 create mode 100644 .gitignore
 create mode 100644 backend/.gitkeep
 create mode 100644 mobile/.gitkeep
 create mode 100644 web/.gitkeep

A estrutura do repositório:

tamojunto/
├── backend/
│   └── .gitkeep
├── web/
│   └── .gitkeep
├── mobile/
│   └── .gitkeep
└── .gitignore

Não parece muito. E realmente não é — essa é a ideia. O repositório começa com o mínimo necessário para que todos os componentes tenham seu lugar. O código entra incrementalmente, a cada capítulo, começando pelo backend no próximo.