Modularizando com Models e Repositories

Agora, vamos incluir o padrão repository para lidar com a lógica de acesso ao banco de dados, enquanto os models representarão os dados que manipulamos.

Nova Estrutura do Projeto

1. Vamos adicionar duas novas pastas:
   • models: para definir os esquemas de dados.
   • repositories: para manipulação dos dados no banco.
2. A estrutura final do projeto ficará assim:

src/
│
├── config/
│   └── database.ts
│
├── controllers/
│   └── userController.ts
│
├── models/
│   └── userModel.ts
│
├── repositories/
│   └── userRepository.ts
│
├── routes/
│   └── userRoutes.ts
│
├── migrations/
│   └── migrations.ts
│
├── server.ts

Passos para Implementação de Models e Repositories

1. Definindo o Model em models/userModel.ts

O model vai representar a estrutura dos nossos dados. Vamos criar um modelo simples para o usuário:

export interface User {
  id: number;
  name: string;
  email: string;
}

2. Implementando o Repositório em repositories/userRepository.ts

O repository vai concentrar a lógica de interação com o banco de dados, isolando a camada de acesso ao banco do restante da aplicação:

import { Pool } from 'pg';
import pool from '../config/database';
import { User } from '../models/userModel';

export class UserRepository {
  private pool: Pool;

  constructor() {
    this.pool = pool;
  }

  // Método para buscar todos os usuários
  async getAllUsers(): Promise<User[]> {
    const { rows } = await this.pool.query('SELECT * FROM users');
    return rows;
  }

  // Método para adicionar um novo usuário
  async addUser(name: string, email: string): Promise<User> {
    const queryText = 'INSERT INTO users(name, email) VALUES($1, $2) RETURNING *';
    const { rows } = await this.pool.query(queryText, [name, email]);
    return rows[0];
  }
}

3. Atualizando o Controller em controllers/userController.ts

Agora, o controller utilizará o UserRepository para manipular os dados:

import { Request, Response } from 'express';
import { UserRepository } from '../repositories/userRepository';

const userRepository = new UserRepository();

export const getUsers = async (req: Request, res: Response) => {
  try {
    const users = await userRepository.getAllUsers();
    res.status(200).json(users);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Erro ao buscar usuários' });
  }
};

export const addUser = async (req: Request, res: Response) => {
  const { name, email } = req.body;
  try {
    const user = await userRepository.addUser(name, email);
    res.status(201).json(user);
  } catch (err) {
    console.error(err);
    res.status(500).json({ error: 'Erro ao adicionar usuário' });
  }
};

4. Mantendo as Rotas em routes/userRoutes.ts

As rotas permanecem simples, sem mudanças:

import { Router } from 'express';
import { getUsers, addUser } from '../controllers/userController';

const router = Router();

router.get('/users', getUsers);
router.post('/users', addUser);

export default router;

5. Servidor e Migrations