Middlewares

<?php
use Src\Kernel\Auth;

// Rota pública — sem proteção
$router->get('/api/produtos', [Controller::class, 'listar']);

// Rota privada — qualquer usuário logado
$router->get('/api/perfil', [Controller::class, 'perfil'], Auth::user());

// Rota admin — só admin_system
$router->post('/api/admin/produtos', [Controller::class, 'criar'], Auth::admin());

// Rota com rate limit (10 req/min) + auth
$router->post('/api/produtos', [Controller::class, 'criar'], Auth::user(limit: 10));

// Rota admin com rate limit + proteção de banco
$router->delete('/api/admin/produtos/{id}', [Controller::class, 'deletar'], Auth::admin(limit: 5, db: true));

// Rota de API (token machine-to-machine)
$router->post('/api/webhook', [Controller::class, 'receber'], Auth::api());

// Rota pública com conteúdo diferente para logados
$router->get('/api/feed', [Controller::class, 'feed'], Auth::optional());

// Só rate limit — sem autenticação
$router->post('/api/contato', [Controller::class, 'enviar'], Auth::limit(5));

<?php
use Src\Kernel\Auth;

class ProdutoController
{
    public function criar(Request $request): Response
    {
        // Obtém o usuário logado (ou null se não autenticado)
        $user = Auth::current($request);

        // Obtém só o ID
        $userId = Auth::id($request);

        // Obtém o nível de acesso
        $role = Auth::role($request);

        // Lança 401 se não autenticado, retorna o usuário se sim
        $user = Auth::check($request);

        // Lança 403 se não for admin_system
        $user = Auth::checkAdmin($request);

        // Lança 403 se não tiver um dos papéis informados
        $user = Auth::checkRole($request, 'admin', 'moderador');

        return Response::json(['criado_por' => $userId]);
    }
}

<?php
use Src\Kernel\Middlewares\AuthHybridMiddleware;
use Src\Kernel\Middlewares\AdminOnlyMiddleware;
use Src\Kernel\Middlewares\RateLimitMiddleware;

$rateLimit = [RateLimitMiddleware::class, ['limit' => 5, 'window' => 60, 'key' => 'recurso.criar']];
$router->post('/api/admin/recurso', [Controller::class, 'criar'], [
    $rateLimit,
    AuthHybridMiddleware::class,
    AdminOnlyMiddleware::class,
]);

use Src\Kernel\Middlewares\AuthHybridMiddleware;

// Rota que exige qualquer usuário logado
$router->get('/api/perfil', [MeuController::class, 'perfil'], [AuthHybridMiddleware::class]);

// No Controller — acessa o usuário autenticado
public function perfil(Request $request): Response
{
    $usuario = $request->attribute('auth_user'); // objeto Usuario
    $payload = $request->attribute('auth_payload'); // stdClass com sub, nivel_acesso, etc.

    return Response::json(['nome' => $usuario->getNomeCompleto()]);
}

// Respostas possíveis:
// 401 — token ausente, expirado ou revogado
// 200 — usuário autenticado, requisição passa para o Controller

use Src\Kernel\Middlewares\AuthHybridMiddleware;
use Src\Kernel\Middlewares\AdminOnlyMiddleware;

// Sempre use AuthHybridMiddleware ANTES do AdminOnlyMiddleware
$router->get('/api/admin/usuarios', [Controller::class, 'listar'], [
    AuthHybridMiddleware::class,  // 1º: valida o JWT
    AdminOnlyMiddleware::class,   // 2º: verifica se é admin_system
]);

// Respostas possíveis:
// 401 — token ausente ou inválido (AuthHybridMiddleware)
// 403 — usuário autenticado mas não é admin_system
// 200 — admin autenticado, requisição passa

use Src\Kernel\Middlewares\RateLimitMiddleware;

// 5 requisições por minuto por IP — ideal para registro
$registroLimit = [RateLimitMiddleware::class, [
    'limit'  => 5,
    'window' => 60,
    'key'    => 'meu.registro',
]];
$router->post('/api/registrar', [Controller::class, 'criar'], [$registroLimit]);

// 10 req/min por IP, 3 por usuário autenticado
$loginLimit = [RateLimitMiddleware::class, [
    'limit'      => 10,
    'window'     => 60,
    'key'        => 'meu.login',
    'user_limit' => 3,
]];
$router->post('/api/login', [Controller::class, 'login'], [$loginLimit]);

// Respostas possíveis:
// 429 — limite atingido, com header Retry-After indicando quando tentar novamente
// Headers adicionados em toda resposta:
//   X-RateLimit-Limit: 10
//   X-RateLimit-Remaining: 7
//   X-RateLimit-Reset: 1712345678 (timestamp Unix)

use Src\Kernel\Middlewares\CircuitBreakerMiddleware;

// Protege rotas que dependem do banco — abre após 5 falhas, cooldown de 20s
$dbCircuit = [CircuitBreakerMiddleware::class, [
    'service'   => 'database',
    'threshold' => 5,
    'cooldown'  => 20,
]];
$router->post('/api/registrar', [Controller::class, 'criar'], [$dbCircuit]);

// Protege chamadas a serviço externo (ex: API de pagamento)
$pagCircuit = [CircuitBreakerMiddleware::class, [
    'service'   => 'pagamento',
    'threshold' => 3,
    'cooldown'  => 60,
]];
$router->post('/api/pagamento', [Controller::class, 'pagar'], [$pagCircuit]);

// Respostas possíveis:
// 503 — circuito aberto, com header Retry-After
// Passa normalmente quando CLOSED ou HALF

use Src\Kernel\Middlewares\ApiTokenMiddleware;

// Rota acessível apenas por tokens de API (integrações, webhooks, etc.)
$router->post('/api/webhook/pagamento', [Controller::class, 'receber'], [ApiTokenMiddleware::class]);

// Respostas possíveis:
// 401 — token ausente ou inválido
// 403 — token válido mas não é de API (é de usuário)
// 500 — JWT_API_SECRET não configurado no .env

# Abre o menu interativo e escolha a opção 11
php vupi setup

# Ou direto, sem menu:
php vupi setup --auto --api-token=generate

{
  "sub": "api_user_id",
  "exp": 1712345678,
  "api_access": true,
  "tipo": "api"
}

# curl
curl -X POST http://localhost:3005/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"email":"[email protected]","senha":"admin123"}'

# HTTPie
http POST http://localhost:3005/api/auth/login \
  [email protected] senha=admin123

// Resposta — copie o "access_token":
{
  "status": "success",
  "access_token": "eyJ...",   // ← use este nas rotas admin
  "token_type": "Bearer",
  "expires_in": 900
}

// Use assim nas requisições:
// Authorization: Bearer eyJ...

<?php
require __DIR__ . '/vendor/autoload.php';

use Firebase\JWT\JWT;

$secret = $_ENV['JWT_API_SECRET'] ?? 'seu_jwt_api_secret_aqui';

// Token de API (para ApiTokenMiddleware)
$tokenApi = JWT::encode([
    'sub'        => 'minha_integracao',
    'exp'        => time() + 3600,  // expira em 1 hora
    'api_access' => true,
    'tipo'       => 'api',
], $secret, 'HS256');

echo "Token de API:\n" . $tokenApi . "\n";

use Src\Kernel\Middlewares\OptionalAuthHybridMiddleware;

// Rota pública, mas com conteúdo extra para usuários logados
$router->get('/api/feed', [Controller::class, 'feed'], [OptionalAuthHybridMiddleware::class]);

// No Controller — verifica se o usuário está autenticado
public function feed(Request $request): Response
{
    $usuario = $request->attribute('auth_user'); // null se não autenticado

    if ($usuario !== null) {
        // Retorna feed personalizado para o usuário logado
        return Response::json(['feed' => $this->feedPersonalizado($usuario)]);
    }

    // Retorna feed público genérico
    return Response::json(['feed' => $this->feedPublico()]);
}

use Src\Kernel\Middlewares\AuthCookieMiddleware;

// Rota que autentica via cookie (ex: endpoint chamado por página HTML)
$router->get('/api/minha-conta', [Controller::class, 'conta'], [AuthCookieMiddleware::class]);

// O token deve estar no cookie 'auth_token' — definido pelo módulo Auth no login
// Respostas possíveis:
// 401 — cookie ausente, token expirado ou revogado

use Src\Kernel\Middlewares\AuthPageMiddleware;

// Rota de página HTML protegida — redireciona para / se não autenticado
$router->get('/meu-painel', [PainelController::class, 'index'], [AuthPageMiddleware::class]);

// Comportamento:
// Não autenticado → redirect 302 para /
// Autenticado mas não admin_system → redirect 302 para /
// Autenticado como admin_system → passa para o Controller

use Src\Kernel\Middlewares\RouteProtectionMiddleware;

// Sem restrição de papel — qualquer token válido passa
$router->get('/api/recurso', [Controller::class, 'listar'], [RouteProtectionMiddleware::class]);

// Restrito a um papel específico
$request = $request->withAttribute('roles', ['admin', 'moderador']);
$router->put('/api/recurso/{id}', [Controller::class, 'atualizar'], [RouteProtectionMiddleware::class]);

// Respostas possíveis:
// 401 — token ausente ou inválido
// 403 — papel do usuário não está na lista de roles permitidos

# Ativa no .env para forçar HTTPS em produção
COOKIE_SECURE=true
COOKIE_HTTPONLY=true