🚀 Criando um Projeto Node.js do Zero e Estruturação de Pastas

Olá, futuros desenvolvedores Node.js! 👋 Nesta aula prática, vamos dar os primeiros passos no mundo do Node.js, aprendendo a criar um projeto do zero e a organizá-lo de forma eficiente. Uma boa estrutura de pastas é crucial para a manutenibilidade e escalabilidade do seu código, mesmo em projetos pequenos.

Vamos colocar a mão na massa e construir nossa base sólida! 🧱

🎯 Objetivos da Aula

Ao final desta aula, você será capaz de:

Inicializar um novo projeto Node.js usando o npm.
Compreender a função do arquivo package.json.
Criar e executar seu primeiro arquivo Node.js.
Aplicar uma estrutura de pastas comum e eficaz para projetos Node.js.
Configurar arquivos essenciais como .gitignore e README.md.

1. ⚙️ Inicializando Seu Projeto Node.js

Todo projeto Node.js começa com a inicialização de um package.json. Este arquivo é o coração do seu projeto, contendo metadados como nome, versão, descrição, scripts de execução, dependências e muito mais. Ele é gerenciado pelo npm (Node Package Manager).

1.1. Criando a Pasta do Projeto

Primeiro, crie uma pasta para o seu novo projeto. É uma boa prática usar nomes em kebab-case (tudo minúsculo, palavras separadas por hífens).

# Crie um diretório para o seu projeto
mkdir meu-primeiro-projeto-node
 
# Navegue para dentro do diretório
cd meu-primeiro-projeto-node

1.2. Usando `npm init`

Dentro da pasta do projeto, execute o comando npm init. Este comando irá guiá-lo através de uma série de perguntas para preencher as informações do seu package.json.

npm init

Você verá algo parecido com isto:

This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sensible defaults.

See `npm help init` for definitive documentation on these fields
and exactly what they do.

Use `npm install <pkg>` afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
package name: (meu-primeiro-projeto-node)
version: (1.0.0)
description: Meu primeiro projeto Node.js
entry point: (index.js)
test command:
git repository:
keywords: nodejs, iniciante, projeto
author: Seu Nome <seu.email@example.com>
license: (ISC)
About to write to /home/user/meu-primeiro-projeto-node/package.json:

{
  "name": "meu-primeiro-projeto-node",
  "version": "1.0.0",
  "description": "Meu primeiro projeto Node.js",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "nodejs",
    "iniciante",
    "projeto"
  ],
  "author": "Seu Nome <seu.email@example.com>",
  "license": "ISC"
}


Is this OK? (yes)

Você pode simplesmente pressionar Enter para aceitar os valores padrão na maioria das perguntas.

👉 Dica: Se você quiser aceitar todos os padrões sem ser perguntado, use npm init --yes ou npm init -y.

Após a conclusão, um arquivo package.json será criado na raiz do seu projeto:

// meu-primeiro-projeto-node/package.json
{
  "name": "meu-primeiro-projeto-node",
  "version": "1.0.0",
  "description": "Meu primeiro projeto Node.js",
  "main": "index.js", // Ponto de entrada principal da sua aplicação
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "nodejs",
    "iniciante",
    "projeto"
  ],
  "author": "Seu Nome <seu.email@example.com>",
  "license": "ISC"
}

name: Nome do seu pacote.
version: Versão atual do seu projeto.
description: Uma breve descrição do que seu projeto faz.
main: O arquivo de entrada principal da sua aplicação (por padrão, index.js).
scripts: Permite definir comandos personalizados para executar tarefas (como iniciar o servidor, rodar testes, etc.).
keywords: Palavras-chave que descrevem seu projeto.
author: Seu nome ou da sua organização.
license: Tipo de licença do seu projeto.

2. 🎬 O Ponto de Entrada da Sua Aplicação

O arquivo especificado em main no package.json (geralmente index.js ou app.js) é onde sua aplicação Node.js começa a ser executada. Vamos criar um arquivo simples para testar.

2.1. Criando `index.js`

Na raiz do seu projeto (meu-primeiro-projeto-node), crie um novo arquivo chamado index.js.

// meu-primeiro-projeto-node/index.js
console.log('Olá, Node.js! Este é o meu primeiro projeto. 🚀');

2.2. Executando Seu Projeto

Para executar este arquivo, use o comando node seguido do nome do arquivo:

node index.js

Você deverá ver a seguinte saída no seu terminal:

Olá, Node.js! Este é o meu primeiro projeto. 🚀

Parabéns! Você acabou de criar e executar seu primeiro script Node.js. 🎉

3. 📂 Estruturação de Pastas Comum

À medida que seu projeto cresce, ter uma estrutura de pastas bem definida é essencial para organizar seu código, facilitar a colaboração e tornar a manutenção mais simples. Não existe uma "estrutura oficial" única, mas algumas convenções são amplamente aceitas na comunidade Node.js.

Vamos explorar uma estrutura comum e bastante utilizada:

meu-primeiro-projeto-node/
├── src/
│   ├── config/             # Configurações globais (banco de dados, variáveis de ambiente)
│   ├── controllers/        # Lógica de manipulação de requisições (recebe requisição, chama serviço)
│   ├── models/             # Definição de modelos de dados (interação com o banco de dados)
│   ├── routes/             # Definição de rotas da API (URLs e métodos HTTP)
│   ├── services/           # Lógica de negócio principal (regras de negócio, orquestração)
│   └── utils/              # Funções utilitárias, helpers (autenticação, formatação)
├── tests/                  # Testes unitários e de integração
├── .env                    # Variáveis de ambiente (não versionadas!)
├── .gitignore              # Arquivos e pastas a serem ignorados pelo Git
├── index.js                # Ponto de entrada da aplicação (muitas vezes apenas importa 'src/app.js')
├── package.json            # Metadados do projeto e dependências
├── package-lock.json       # Bloqueio de versões exatas das dependências
└── README.md               # Documentação do projeto

3.1. Explicação das Pastas e Arquivos

src/: Esta pasta contém todo o código-fonte da sua aplicação. É uma boa prática separar o código da aplicação de outros arquivos do projeto (como configurações de build, testes, etc.).
- config/: Armazena arquivos de configuração para diferentes ambientes (desenvolvimento, produção), conexão com banco de dados, chaves de API, etc.
- controllers/: Contém a lógica que processa as requisições HTTP. Eles recebem a requisição, validam dados, chamam os services e enviam a resposta.
- models/: Define a estrutura dos dados e a lógica de interação com o banco de dados (ex: usando Mongoose para MongoDB, Sequelize para SQL).
- routes/: Define as rotas da sua API, mapeando URLs para funções de controller.
- services/: Contém a lógica de negócio principal da sua aplicação. Os controllers chamam os services para executar operações complexas.
- utils/: Funções utilitárias e helpers que podem ser reutilizados em várias partes da aplicação (ex: formatadores de data, validadores, middlewares de autenticação genéricos).
tests/: Pasta dedicada aos testes da sua aplicação (unitários, de integração, end-to-end).
.env: Arquivo para armazenar variáveis de ambiente sensíveis (senhas de banco de dados, chaves de API). Nunca deve ser versionado no Git!
.gitignore: Lista de arquivos e pastas que o Git deve ignorar (ex: node_modules, .env).
index.js: O ponto de entrada principal. Em projetos maiores, ele pode apenas inicializar o servidor e importar a lógica principal de src/app.js ou src/index.js.
package.json: Metadados do projeto e lista de dependências.
package-lock.json: Garante que todos os desenvolvedores usem as mesmas versões exatas das dependências.
README.md: Documentação essencial do projeto (como instalar, como rodar, o que faz, etc.).

4. 📝 Boas Práticas Iniciais

4.1. `.gitignore`

É fundamental criar um arquivo .gitignore logo no início do projeto para evitar que arquivos desnecessários ou sensíveis sejam enviados para o seu repositório Git.

Crie um arquivo chamado .gitignore na raiz do seu projeto:

# meu-primeiro-projeto-node/.gitignore
# Dependências do Node.js
node_modules/
 
# Variáveis de ambiente
.env
 
# Logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*
 
# Arquivos de sistema operacional
.DS_Store
Thumbs.db
 
# Build artifacts
dist/
build/

4.2. `README.md`

Um README.md é a porta de entrada para o seu projeto. Ele deve fornecer informações claras e concisas sobre o que o projeto faz, como instalá-lo, como executá-lo e quaisquer outras informações importantes.

Crie um arquivo chamado README.md na raiz do seu projeto:

# Meu Primeiro Projeto Node.js 🚀
 
Este é um projeto Node.js inicial criado para fins de aprendizado no curso de Fundamentos do Node.js.
 
## ✨ Funcionalidades
 
*   Exemplo básico de um servidor Node.js (a ser implementado).
*   Estrutura de pastas organizada para escalabilidade.
 
## 🛠️ Instalação
 
1.  Clone este repositório:
    ```bash
    git clone https://github.com/seu-usuario/meu-primeiro-projeto-node.git

Navegue até o diretório do projeto:
```
cd meu-primeiro-projeto-node
```
Instale as dependências (se houver):
```
npm install
```

🚀 Como Rodar

Certifique-se de ter o Node.js instalado.
Execute o arquivo principal:
```
node index.js
```

📄 Licença

Este projeto está licenciado sob a licença ISC.


---

## 5. 🧑‍💻 Exercício Prático: Construindo Sua Primeira Aplicação Estruturada

Agora é a sua vez de aplicar o que aprendemos! Siga os passos abaixo para criar um projeto Node.js com uma estrutura básica.

### Tarefas:

- [ ] 1. Crie um novo diretório para o seu projeto, por exemplo, `minha-api-simples`.
- [ ] 2. Navegue para dentro deste diretório.
- [ ] 3. Inicialize um novo projeto Node.js usando `npm init -y`.
- [ ] 4. Crie o arquivo `.gitignore` na raiz do projeto e adicione `node_modules/` e `.env`.
- [ ] 5. Crie o arquivo `README.md` na raiz do projeto com um título e uma breve descrição.
- [ ] 6. Crie a seguinte estrutura de pastas dentro do diretório `minha-api-simples`:

minha-api-simples/ ├── src/ │ ├── controllers/ │ ├── models/ │ ├── routes/ │ └── services/ ├── .gitignore ├── index.js ├── package.json └── README.md

- [ ] 7. Crie um arquivo `index.js` na raiz do projeto com o seguinte conteúdo:

```javascript
// minha-api-simples/index.js
console.log('Servidor Node.js iniciado! 🚀');
// Em aulas futuras, aqui teremos a inicialização do Express, banco de dados, etc.

8. Crie um arquivo src/routes/home.js com o seguinte conteúdo (ainda não será executado, mas já estabelece a estrutura):

// minha-api-simples/src/routes/home.js
// Este arquivo definirá rotas para a página inicial
const getHomePage = () => {
    return "Bem-vindo à minha API simples! 🎉";
};
 
module.exports = {
    getHomePage
};

9. Crie um arquivo src/controllers/homeController.js com o seguinte conteúdo:

// minha-api-simples/src/controllers/homeController.js
const homeService = require('../services/homeService'); // Iremos criar este em breve
 
const getHome = (req, res) => {
    // Por enquanto, apenas retornamos uma string
    console.log(homeService.getWelcomeMessage());
    // Em um projeto real, 'res' seria usado para enviar a resposta HTTP
    return homeService.getWelcomeMessage();
};
 
module.exports = {
    getHome
};

10. Crie um arquivo src/services/homeService.js com o seguinte conteúdo:

// minha-api-simples/src/services/homeService.js
const getWelcomeMessage = () => {
    return "Esta é a lógica de negócio do serviço de boas-vindas.";
};
 
module.exports = {
    getWelcomeMessage
};

11. Execute o arquivo index.js para ver a mensagem inicial no console.
```
node index.js
```
Você deverá ver: Servidor Node.js iniciado! 🚀

Observação: Os arquivos dentro de src/ ainda não estão sendo "chamados" ou executados por index.js de forma significativa. Isso é normal nesta etapa. O objetivo é apenas criar a estrutura. Nas próximas aulas, aprenderemos a integrar esses módulos usando frameworks como o Express.js.

6. 📚 Resumo

Nesta aula, você aprendeu a iniciar um projeto Node.js do zero, compreendendo a importância do package.json e como executar um script simples. Exploramos uma estrutura de pastas comum que promove a organização e a escalabilidade, e configuramos arquivos essenciais como .gitignore e README.md.

Uma base bem estruturada é o segredo para projetos Node.js robustos e fáceis de manter. Continue praticando!

7. ⏭️ Próximos Passos

Na próxima aula, vamos mergulhar mais fundo no desenvolvimento web com Node.js, introduzindo o framework Express.js. Você aprenderá a:

Instalar e configurar o Express.js.
Criar rotas HTTP básicas (GET, POST).
Configurar um servidor web simples.

Prepare-se para construir sua primeira API RESTful! 🌐

Fundamentos do Node.js

Criando um Projeto Node.js do Zero e Estruturação de Pastas