templates

# {{.ProjectName}}

Projeto criado com **Gaver Framework** - Um framework web em Go com CLI, geração de código e ORM estilo Django.

## 🚀 Começando

### Pré-requisitos

- Go 1.24.3 ou superior
- {{.DatabaseDriver}} ({{if eq .DatabaseDriver "postgres"}}PostgreSQL{{else if eq .DatabaseDriver "mysql"}}MySQL{{else}}SQLite{{end}})

### Instalação

1. Instalar dependências:
```bash
go mod tidy
```

2. Configurar variáveis de ambiente:
```bash
cp .env .env.local
# Edite .env com suas configurações
```

3. Executar migrations:
```bash
gaver migrate
```

4. Iniciar servidor:
```bash
go run cmd/server/main.go
```

## 📁 Estrutura do Projeto

```
{{.ProjectName}}/
├── cmd/
│   └── server/          # Aplicação principal
├── config/
│   ├── cors/           # Configuração CORS
│   ├── database/       # Conexão com banco
│   ├── env/            # Variáveis de ambiente
│   ├── middlewares/    # Middlewares HTTP
│   └── routines/       # Tarefas agendadas
├── internal/
│   └── app/
│       ├── handlers/   # Controllers HTTP
│       ├── models/     # Models do banco
│       ├── repositories/ # Camada de dados
│       └── services/   # Lógica de negócio
└── migrations/         # Migrations SQL
```

## 🔄 Sistema de Rotinas

O projeto inclui um sistema de **rotinas agendadas** (tarefas em background) que rodam automaticamente em intervalos definidos.

### Como funciona

As rotinas são definidas em `config/routines/routines.go` e são iniciadas automaticamente com o servidor.

### Exemplos de uso

```go
// Em config/routines/routines.go
func (m *Manager) RegisterDefaultRoutines() {
    // Limpeza de dados a cada 24 horas
    m.Register("cleanup", 24*time.Hour, func() {
        log.Println("Limpando dados antigos...")
        // Seu código aqui
    })

    // Sincronização a cada 1 hora
    m.Register("sync", 1*time.Hour, func() {
        log.Println("Sincronizando dados...")
        // Seu código aqui
    })

    // Verificação a cada 5 minutos
    m.Register("check", 5*time.Minute, func() {
        log.Println("Verificando sistema...")
        // Seu código aqui
    })
}
```

### Casos de uso comuns

- ✅ Limpeza de dados antigos
- ✅ Sincronização com APIs externas
- ✅ Envio de emails/notificações agendadas
- ✅ Geração de relatórios
- ✅ Processamento de filas
- ✅ Health checks do sistema
- ✅ Backup de dados

### Desabilitar rotinas

Para desabilitar o sistema de rotinas, comente as linhas no `main.go`:

```go
// routineManager := routines.NewManager()
// routineManager.RegisterDefaultRoutines()
// routineManager.Start()
// defer routineManager.Stop()
```

## 🛠️ Comandos Gaver

### Gerar Model

```bash
gaver generate model User name:string email:string:unique age:int
```

### Gerar Handler

```bash
gaver generate handler User
```

### Migrations

```bash
# Criar migration
gaver migrate:create nome_da_migration

# Executar migrations pendentes
gaver migrate

# Ver status
gaver migrate:status

# Reverter última migration
gaver migrate:rollback
```

## 📝 API Endpoints

### Rotas Básicas

- `GET /` - Página inicial
- `GET /health` - Health check
- `GET /api/v1/ping` - Teste de conectividade

### Adicionar novas rotas

Em `cmd/server/main.go`:

```go
api := router.Group("/api/v1")
{
    // Suas rotas aqui
    api.GET("/users", userHandler.List)
    api.POST("/users", userHandler.Create)
    api.GET("/users/:id", userHandler.Get)
    api.PUT("/users/:id", userHandler.Update)
    api.DELETE("/users/:id", userHandler.Delete)
}
```

## 🔐 Middlewares

### Disponíveis

- **Logger** - Registra todas as requisições
- **CORS** - Configuração de CORS
- **Auth** - Autenticação (implementar)
- **RateLimiter** - Limite de requisições (implementar)
- **APIKeyAuth** - Autenticação via API Key (implementar)

### Aplicar middleware

```go
// Global
router.Use(middlewares.Auth())

// Em grupo específico
api := router.Group("/api/v1")
api.Use(middlewares.APIKeyAuth())
{
    api.GET("/protected", handler)
}

// Em rota específica
router.GET("/admin", middlewares.Auth(), adminHandler)
```

## 🗄️ Banco de Dados

### Configuração

Configure em `.env`:

```env
DB_HOST=localhost
DB_PORT={{.DatabasePort}}
DB_USER={{.DatabaseUser}}
DB_PASSWORD=sua_senha
DB_NAME={{.ProjectName}}
```

### Conexão

A conexão é estabelecida automaticamente no `main.go`. Para usar em outros arquivos:

```go
import "{{.ProjectName}}/config/database"

// Usar a instância global
database.DB.Find(&users)
```

## 📦 Dependências

- **Gin** - Framework HTTP
- **GORM** - ORM
- **godotenv** - Variáveis de ambiente

## 🤝 Contribuindo

1. Fork o projeto
2. Crie uma branch (`git checkout -b feature/MinhaFeature`)
3. Commit suas mudanças (`git commit -m 'Adiciona MinhaFeature'`)
4. Push para a branch (`git push origin feature/MinhaFeature`)
5. Abra um Pull Request

## 📄 Licença

Este projeto está sob a licença MIT.

---

**Desenvolvido com ❤️ usando Gaver Framework**