Projeto final: aplicação full-stack com Node.js e React

1. Planejamento e Arquitetura do Projeto

Neste artigo, construiremos uma aplicação full-stack completa de gerenciamento de tarefas (Task Manager) utilizando Node.js no backend e React no frontend. O escopo inclui operações CRUD completas, validação de dados, tratamento de erros e uma interface responsiva e acessível.

A arquitetura segue o padrão monorepo, com duas pastas principais:

task-manager/
├── client/          # Frontend React (Vite)
└── server/          # Backend Node.js (Express)

O fluxo de dados é direto: o frontend React faz requisições HTTP para a API REST do backend, que por sua vez interage com um banco de dados SQLite (via Knex.js). Essa separação clara de responsabilidades facilita manutenção, testes e deploy independente de cada camada.

2. Configuração do Backend com Node.js e Express

Iniciamos criando a pasta server/ e configurando o projeto:

// Terminal
mkdir server && cd server
npm init -y
npm install express cors dotenv knex sqlite3
npm install --save-dev nodemon

Criamos o arquivo principal do servidor:

// server/index.js
require('dotenv').config();
const express = require('express');
const cors = require('cors');
const taskRoutes = require('./routes/taskRoutes');

const app = express();
const PORT = process.env.PORT || 3001;

app.use(cors());
app.use(express.json());
app.use('/api/tasks', taskRoutes);

app.listen(PORT, () => {
  console.log(`Servidor rodando na porta ${PORT}`);
});

Configuramos o Knex.js para gerenciar o banco de dados:

// server/knexfile.js
module.exports = {
  development: {
    client: 'sqlite3',
    connection: {
      filename: './dev.sqlite3'
    },
    useNullAsDefault: true,
    migrations: {
      directory: './migrations'
    }
  }
};

Criamos a migration para a tabela de tarefas:

// server/migrations/20240101000000_create_tasks.js
exports.up = function(knex) {
  return knex.schema.createTable('tasks', (table) => {
    table.increments('id').primary();
    table.string('title').notNullable();
    table.text('description');
    table.boolean('completed').defaultTo(false);
    table.timestamp('created_at').defaultTo(knex.fn.now());
    table.timestamp('updated_at').defaultTo(knex.fn.now());
  });
};

exports.down = function(knex) {
  return knex.schema.dropTable('tasks');
};

3. Implementação da API RESTful

Criamos os endpoints CRUD para tarefas:

// server/routes/taskRoutes.js
const express = require('express');
const router = express.Router();
const knex = require('knex')(require('../knexfile').development);

// GET /api/tasks - Listar todas as tarefas
router.get('/', async (req, res) => {
  try {
    const tasks = await knex('tasks').orderBy('created_at', 'desc');
    res.json(tasks);
  } catch (error) {
    res.status(500).json({ error: 'Erro ao buscar tarefas' });
  }
});

// POST /api/tasks - Criar nova tarefa
router.post('/', async (req, res) => {
  const { title, description } = req.body;

  if (!title || title.trim().length === 0) {
    return res.status(400).json({ error: 'Título é obrigatório' });
  }

  try {
    const [id] = await knex('tasks').insert({
      title: title.trim(),
      description: description?.trim() || ''
    });
    const task = await knex('tasks').where({ id }).first();
    res.status(201).json(task);
  } catch (error) {
    res.status(500).json({ error: 'Erro ao criar tarefa' });
  }
});

// PUT /api/tasks/:id - Atualizar tarefa
router.put('/:id', async (req, res) => {
  const { id } = req.params;
  const { title, description, completed } = req.body;

  try {
    const existingTask = await knex('tasks').where({ id }).first();
    if (!existingTask) {
      return res.status(404).json({ error: 'Tarefa não encontrada' });
    }

    await knex('tasks').where({ id }).update({
      title: title?.trim() || existingTask.title,
      description: description?.trim() || existingTask.description,
      completed: completed !== undefined ? completed : existingTask.completed,
      updated_at: knex.fn.now()
    });

    const updatedTask = await knex('tasks').where({ id }).first();
    res.json(updatedTask);
  } catch (error) {
    res.status(500).json({ error: 'Erro ao atualizar tarefa' });
  }
});

// DELETE /api/tasks/:id - Excluir tarefa
router.delete('/:id', async (req, res) => {
  const { id } = req.params;

  try {
    const deleted = await knex('tasks').where({ id }).del();
    if (deleted === 0) {
      return res.status(404).json({ error: 'Tarefa não encontrada' });
    }
    res.status(204).send();
  } catch (error) {
    res.status(500).json({ error: 'Erro ao excluir tarefa' });
  }
});

module.exports = router;

Para testar a API, criamos um script de seed:

// server/seeds/seed_tasks.js
exports.seed = async function(knex) {
  await knex('tasks').del();
  await knex('tasks').insert([
    { title: 'Estudar Node.js', description: 'Revisar Express e Knex.js', completed: false },
    { title: 'Configurar Vite', description: 'Inicializar projeto React', completed: true },
    { title: 'Fazer deploy', description: 'Publicar no Vercel e Railway', completed: false }
  ]);
};

4. Criação do Frontend com React (Vite)

Inicializamos o frontend na pasta client/:

// Terminal
cd ..
npm create vite@latest client -- --template react
cd client
npm install axios react-router-dom

Estrutura de componentes:

// client/src/App.jsx
import { BrowserRouter, Routes, Route } from 'react-router-dom';
import TaskList from './components/TaskList';
import TaskForm from './components/TaskForm';

function App() {
  return (
    <BrowserRouter>
      <div className="app-container">
        <h1>Gerenciador de Tarefas</h1>
        <Routes>
          <Route path="/" element={<TaskList />} />
          <Route path="/nova" element={<TaskForm />} />
          <Route path="/editar/:id" element={<TaskForm />} />
        </Routes>
      </div>
    </BrowserRouter>
  );
}

export default App;

Componente de listagem com hook customizado:

// client/src/hooks/useTasks.js
import { useState, useEffect, useReducer } from 'react';
import axios from 'axios';

const API_URL = import.meta.env.VITE_API_URL || 'http://localhost:3001/api';

const taskReducer = (state, action) => {
  switch (action.type) {
    case 'FETCH_START':
      return { ...state, loading: true, error: null };
    case 'FETCH_SUCCESS':
      return { ...state, loading: false, tasks: action.payload };
    case 'FETCH_ERROR':
      return { ...state, loading: false, error: action.payload };
    case 'DELETE_TASK':
      return {
        ...state,
        tasks: state.tasks.filter(task => task.id !== action.payload)
      };
    default:
      return state;
  }
};

export function useTasks() {
  const [state, dispatch] = useReducer(taskReducer, {
    tasks: [],
    loading: false,
    error: null
  });

  const fetchTasks = async () => {
    dispatch({ type: 'FETCH_START' });
    try {
      const response = await axios.get(`${API_URL}/tasks`);
      dispatch({ type: 'FETCH_SUCCESS', payload: response.data });
    } catch (error) {
      dispatch({ type: 'FETCH_ERROR', payload: error.message });
    }
  };

  const deleteTask = async (id) => {
    try {
      await axios.delete(`${API_URL}/tasks/${id}`);
      dispatch({ type: 'DELETE_TASK', payload: id });
    } catch (error) {
      console.error('Erro ao excluir tarefa:', error);
    }
  };

  useEffect(() => {
    fetchTasks();
  }, []);

  return { ...state, deleteTask, refetch: fetchTasks };
}

5. Integração Frontend-Backend

Componente TaskList completo:

// client/src/components/TaskList.jsx
import { useTasks } from '../hooks/useTasks';
import { Link } from 'react-router-dom';
import TaskItem from './TaskItem';

export default function TaskList() {
  const { tasks, loading, error, deleteTask } = useTasks();

  if (loading) return <div className="loading">Carregando tarefas...</div>;
  if (error) return <div className="error">Erro: {error}</div>;

  return (
    <div className="task-list">
      <Link to="/nova" className="btn-add">Nova Tarefa</Link>
      {tasks.length === 0 ? (
        <p className="empty">Nenhuma tarefa encontrada</p>
      ) : (
        tasks.map(task => (
          <TaskItem key={task.id} task={task} onDelete={deleteTask} />
        ))
      )}
    </div>
  );
}

Componente TaskItem com feedback visual:

// client/src/components/TaskItem.jsx
import { useState } from 'react';
import { Link } from 'react-router-dom';
import axios from 'axios';

const API_URL = import.meta.env.VITE_API_URL || 'http://localhost:3001/api';

export default function TaskItem({ task, onDelete }) {
  const [completed, setCompleted] = useState(task.completed);
  const [deleting, setDeleting] = useState(false);

  const toggleComplete = async () => {
    try {
      const response = await axios.put(`${API_URL}/tasks/${task.id}`, {
        completed: !completed
      });
      setCompleted(response.data.completed);
    } catch (error) {
      console.error('Erro ao atualizar tarefa:', error);
    }
  };

  const handleDelete = async () => {
    if (window.confirm('Excluir esta tarefa?')) {
      setDeleting(true);
      await onDelete(task.id);
    }
  };

  return (
    <div className={`task-item ${completed ? 'completed' : ''} ${deleting ? 'deleting' : ''}`}>
      <input
        type="checkbox"
        checked={completed}
        onChange={toggleComplete}
        aria-label={`Marcar "${task.title}" como ${completed ? 'não concluída' : 'concluída'}`}
      />
      <div className="task-content">
        <h3>{task.title}</h3>
        {task.description && <p>{task.description}</p>}
      </div>
      <div className="task-actions">
        <Link to={`/editar/${task.id}`} className="btn-edit">Editar</Link>
        <button onClick={handleDelete} className="btn-delete" aria-label={`Excluir ${task.title}`}>
          Excluir
        </button>
      </div>
    </div>
  );
}

6. Estilização e Experiência do Usuário

Utilizamos CSS Modules para estilização modular e responsiva:

// client/src/components/TaskItem.module.css
.taskItem {
  background: white;
  border: 1px solid #e0e0e0;
  border-radius: 8px;
  padding: 1rem;
  margin-bottom: 0.75rem;
  display: flex;
  align-items: center;
  gap: 1rem;
  transition: all 0.3s ease;
  animation: slideIn 0.3s ease;
}

.taskItem:hover {
  box-shadow: 0 2px 8px rgba(0,0,0,0.1);
  transform: translateY(-2px);
}

.completed {
  opacity: 0.7;
  background: #f5f5f5;
}

.completed h3 {
  text-decoration: line-through;
  color: #888;
}

.deleting {
  animation: slideOut 0.3s ease forwards;
}

@keyframes slideIn {
  from {
    opacity: 0;
    transform: translateX(-20px);
  }
  to {
    opacity: 1;
    transform: translateX(0);
  }
}

@keyframes slideOut {
  from {
    opacity: 1;
    transform: translateX(0);
  }
  to {
    opacity: 0;
    transform: translateX(20px);
  }
}

Para acessibilidade, garantimos labels descritivos e navegação por teclado em todos os componentes interativos.

7. Deploy e Considerações Finais

Deploy do Backend (Railway)

  1. Crie um arquivo server/Procfile com o conteúdo: web: node index.js
  2. Conecte o repositório ao Railway e configure a variável de ambiente PORT=3001
  3. Execute as migrations com o comando: npx knex migrate:latest

Deploy do Frontend (Vercel)

  1. No Vercel, importe o projeto e configure:
  2. Root Directory: client
  3. Build Command: npm run build
  4. Output Directory: dist
  5. Adicione a variável de ambiente VITE_API_URL apontando para a URL do backend em produção

Checklist de Boas Práticas

  • Segurança: Utilize helmet no backend para headers de segurança
  • Logs: Implemente logging com morgan ou winston
  • Versionamento: Mantenha o código no GitHub com commits semânticos
  • Testes: Adicione testes unitários com Jest e testes de integração com Supertest
  • Documentação: Documente a API com Swagger/OpenAPI

Esta aplicação full-stack demonstra os conceitos fundamentais de desenvolvimento com Node.js e React: arquitetura cliente-servidor, API RESTful, gerenciamento de estado, componentização e boas práticas de deploy. O código completo está disponível no repositório do projeto, servindo como base sólida para aplicações mais complexas.

Referências