Pike Style API em C com PostgreSQL

Uma API REST simples implementada em C puro seguindo os princípios do Pike Style: código claro, direto e eficiente.

Características Pike Style Implementadas

• Simplicidade: Código direto, sem abstrações desnecessárias
• Clareza: Nomes de funções e variáveis descritivos
• Eficiência: Uso mínimo de recursos, sem overhead
• Robustez: Tratamento de erros explícito
• Legibilidade: Estrutura linear e fácil de seguir

Dependências

• libpq-dev: Cliente PostgreSQL
• libcjson-dev: Biblioteca JSON
• postgresql: Servidor de banco de dados

Instalação

Ubuntu/Debian

make install-deps-ubuntu

CentOS/RHEL/Fedora

make install-deps-fedora

macOS

make install-deps-macos

Configuração do Banco

1. Instalar PostgreSQL (se não estiver instalado)
2. Configurar banco:

make setup-db

3. Ou configurar manualmente:

CREATE DATABASE apidb;
CREATE USER apiuser WITH PASSWORD 'apipass';
GRANT ALL PRIVILEGES ON DATABASE apidb TO apiuser;

4. Editar configurações no arquivo main.c:

static db_config_t db_config = {
    .host = "localhost",
    .port = "5432",
    .dbname = "apidb",
    .user = "seu_usuario",
    .password = "sua_senha"
};

Compilação

# Compilação normal
make

# Compilação para debug
make debug

# Limpeza
make clean

Execução

# Executar servidor
./api_server

# Ou executar com logs
make run

O servidor iniciará na porta 8080.

Endpoints da API

GET /health

Verifica status do servidor e conexão com banco.

Resposta:

{
  "status": "OK",
  "database": "connected"
}

GET /users

Lista todos os usuários.

Resposta:

[
  {
    "id": "1",
    "name": "João Silva",
    "email": "joao@email.com",
    "created_at": "2025-05-28 10:30:00"
  }
]

POST /users

Cria um novo usuário.

Requisição:

{
  "name": "Maria Santos",
  "email": "maria@email.com"
}

Resposta (201):

{
  "message": "Usuario criado"
}

Testes

# Executar testes automatizados
make test

Ou testes manuais:

# Verificar saúde
curl http://localhost:8080/health

# Criar usuário
curl -X POST -H "Content-Type: application/json" \
  -d '{"name":"João","email":"joao@email.com"}' \
  http://localhost:8080/users

# Listar usuários
curl http://localhost:8080/users

Estrutura do Código

Princípios Pike Style Aplicados:

1. Funcões pequenas e focadas: Cada função tem uma responsabilidade clara
2. Variáveis globais simples: Estado mínimo necessário
3. Tratamento de erro explícito: Todos os returns são verificados
4. Sem abstrações desnecessárias: Comunicação direta com sockets e PostgreSQL
5. Código linear: Fluxo fácil de seguir, de cima para baixo

Arquitetura:

main() 
  ├── db_init()           // Conecta PostgreSQL
  ├── start_server()      // Inicia servidor HTTP
  │   ├── accept()        // Aceita conexões
  │   ├── parse_request() // Parse HTTP
  │   ├── handle_request() // Roteamento
  │   │   ├── handle_get_users()
  │   │   └── handle_post_users()
  │   └── create_response() // Monta resposta HTTP
  └── db_close()          // Cleanup

Extensões Possíveis

Para expandir a API mantendo o Pike Style:

1. Novos Endpoints

Adicione handlers simples no handle_request():

// GET /users/:id
else if (strncmp(req->path, "/users/", 7) == 0) {
    char *id = req->path + 7;
    char *json_data = get_user_by_id(id);
    // ... resposta
}

2. Autenticação Simples

int check_auth(const char *auth_header) {
    // Verificação simples de token
    return strncmp(auth_header, "Bearer valid_token", 18) == 0;
}

3. Log Simples

void log_request(const char *method, const char *path) {
    printf("[%s] %s %s\n", get_timestamp(), method, path);
}

Performance

• Conexão persistente com PostgreSQL
• Parsing HTTP manual (sem bibliotecas pesadas)
• JSON mínimo apenas para dados necessários
• Memory management explícito

Segurança

⚠️ Esta é uma implementação didática. Para produção, adicione:

• Validação de entrada rigorosa
• Prepared statements (SQL injection)
• Rate limiting
• HTTPS/TLS
• Headers de segurança
• Sanitização de dados

Filosofia Pike Style

"Simplicidade é a sofisticação definitiva" - Leonardo da Vinci

Rob Pike defende:

• Clareza sobre esperteza
• Simplicidade sobre complexidade
• Ferramentas pequenas que fazem uma coisa bem
• Código que humanos conseguem entender

Esta API segue esses princípios, priorizando legibilidade e manutenibilidade sobre "features" avançadas.