SCALABLE_STRUCTURE.md•6.19 kB
# Estrutura Escalável com TypeORM
## Resumo das Melhorias
Removemos as funções `verificarEstruturaBanco` e `verificarEstruturaColunas` e criamos um sistema de **migrations** mais robusto e escalável.
## Por que Removemos as Funções?
### ❌ Problemas das Funções Antigas:
1. **Complexidade**: Para cada nova tabela, precisaríamos adicionar verificações
2. **Manutenção**: Código duplicado e difícil de manter
3. **Escalabilidade**: Não escalava bem com múltiplas tabelas
4. **Flexibilidade**: Não permitia rollbacks ou controle de versão
### ✅ Vantagens do Sistema de Migrations:
1. **Simplicidade**: Cada tabela tem sua própria migration
2. **Controle de Versão**: Sabe exatamente quais migrations foram executadas
3. **Rollbacks**: Pode reverter mudanças se necessário
4. **Escalabilidade**: Fácil adicionar novas tabelas
## Nova Estrutura
```
src/database/
├── connection.js # Inicialização simples
├── ormconfig.js # Configuração centralizada
├── migration-manager.js # Gerenciador de migrations
├── entities/ # Entidades TypeORM
│ ├── Product.js
│ └── Category.js
└── migrations/ # Migrations organizadas
├── 001_create_products_table.js
└── 002_create_categories_table.js
```
## Como Adicionar uma Nova Tabela
### 1. Criar a Entidade
```javascript
// src/database/entities/User.js
import { EntitySchema } from "typeorm";
export const User = new EntitySchema({
name: "User",
tableName: "USERS",
columns: {
id: {
primary: true,
name: "ID",
type: "uuid",
generated: "uuid",
},
name: {
name: "NAME",
type: "varchar",
length: 255,
nullable: false,
},
email: {
name: "EMAIL",
type: "varchar",
length: 255,
nullable: false,
unique: true,
},
},
});
```
### 2. Criar a Migration
```javascript
// src/database/migrations/003_create_users_table.js
export class CreateUsersTable1700000000002 {
constructor() {
this.name = "CreateUsersTable1700000000002";
}
async up(queryRunner) {
await queryRunner.query(`
CREATE TABLE "USERS" (
"ID" UUID DEFAULT uuid_generate_v4() PRIMARY KEY,
"NAME" VARCHAR(255) NOT NULL,
"EMAIL" VARCHAR(255) NOT NULL UNIQUE
)
`);
}
async down(queryRunner) {
await queryRunner.query(`DROP TABLE "USERS"`);
}
}
```
### 3. Atualizar ormconfig.js
```javascript
import { User } from "./entities/User.js";
import { CreateUsersTable1700000000002 } from "./migrations/003_create_users_table.js";
export const AppDataSource = new DataSource({
// ... outras configs
entities: [Product, Category, User],
migrations: [CreateProductsTable1700000000000, CreateCategoriesTable1700000000001, CreateUsersTable1700000000002],
});
```
### 4. Criar o Repository
```javascript
// src/database/users.js
import { AppDataSource } from "./ormconfig.js";
import { User } from "./entities/User.js";
export const UsersDB = {
async getAllUsers() {
try {
const userRepository = AppDataSource.getRepository(User);
const users = await userRepository.find();
return {
success: true,
data: users,
};
} catch (error) {
console.error("Erro ao buscar usuários:", error);
return {
success: false,
error: "Erro ao buscar usuários",
details: error.message,
};
}
},
async createUser(userData) {
try {
const userRepository = AppDataSource.getRepository(User);
const newUser = userRepository.create(userData);
const savedUser = await userRepository.save(newUser);
return {
success: true,
data: savedUser,
};
} catch (error) {
console.error("Erro ao criar usuário:", error);
return {
success: false,
error: "Erro ao criar usuário",
details: error.message,
};
}
},
};
```
## Comandos Úteis
### Executar Migrations
```javascript
// Automático na inicialização
await initializeDatabase();
// Manual
const migrationManager = new MigrationManager();
await migrationManager.runMigrations();
```
### Reverter Migration
```javascript
const migrationManager = new MigrationManager();
await migrationManager.revertMigration("CreateUsersTable1700000000002");
```
## Vantagens da Nova Estrutura
### 1. **Simplicidade**
- Cada tabela tem sua própria entidade e migration
- Código limpo e organizado
- Fácil de entender e manter
### 2. **Escalabilidade**
- Adicionar nova tabela é apenas 3 passos
- Não precisa modificar código existente
- Migrations são independentes
### 3. **Controle de Versão**
- Sabe exatamente quais mudanças foram aplicadas
- Pode reverter mudanças se necessário
- Histórico completo de alterações
### 4. **Flexibilidade**
- Pode executar migrations seletivamente
- Suporte a rollbacks
- Controle granular de mudanças
## Exemplo de Fluxo Completo
### Adicionando uma Nova Funcionalidade
1. **Criar Entidade** → Define a estrutura
2. **Criar Migration** → Define como criar a tabela
3. **Atualizar Config** → Registra no TypeORM
4. **Criar Repository** → Define as operações
5. **Testar** → Verifica se tudo funciona
### Resultado
- ✅ Código limpo e organizado
- ✅ Fácil de manter e expandir
- ✅ Controle total sobre mudanças
- ✅ Escalável para qualquer número de tabelas
## Próximos Passos
1. **Relacionamentos**: Adicionar relacionamentos entre entidades
2. **Validações**: Implementar validações customizadas
3. **Indexes**: Adicionar indexes para performance
4. **Soft Deletes**: Implementar soft deletes globais
5. **Audit Trail**: Adicionar logs de mudanças