7. Middlewares e Autenticação

Passo 1: Como os Middlewares Funcionam

No framework Mad Rest, um middleware é uma classe com um método handle que intercepta requisições. O fluxo funciona assim:

Requisição chega → Middleware intercepta
Middleware verifica → Se inválida, retorna erro imediatamente
Se válida → Chama $next($request) para continuar
Controller executa → Processa a requisição normalmente

// Estrutura básica de um middleware
class MeuMiddleware
{
    public function handle(Request $request, callable $next)
    {
        // Lógica de verificação aqui
        if ($falhouVerificacao) {
            return (new Response())->json(['error' => 'Acesso negado'], 401);
        }
        
        // Se passou na verificação, continua o fluxo
        return $next($request);
    }
}

Passo 2: Middlewares Disponíveis no Projeto

O projeto já possui dois middlewares prontos para uso:

BasicAuthMiddleware

Usado para autenticação via chave REST simples, configurada no arquivo de configuração do sistema. Como funciona:

Verifica o header Authorization: Basic {rest_key}
A rest_key deve estar definida no arquivo de configuração
Ideal para acesso de aplicações confiáveis

Aplicando nas rotas:

// Em: app/routes/api.php

Router::group([
    'prefix' => '/api',
    'middleware' => ['BasicAuthMiddleware']  // Aplica o middleware
], function () {
    Router::get('/dados-protegidos', 'MeuController::getDados');
});

Configurando Autenticação no Arquivo de Configuração

Para usar o BasicAuthMiddleware, você precisa definir a rest_key no arquivo de configuração:

; Em: app/config/application.ini

[general]
rest_key = "minha-chave-super-secreta-123"

Testando no Postman:

Na aba Authorization, selecione “API Key”
Na aba Headers, adicione:
- Key: Authorization
- Value: Basic sua_chave_rest_aqui

E inserindo uma chave inválida: Teste BasicAuthMiddleware chave errada

Importante: nunca exponha essa chave publicamente. Use chaves diferentes para desenvolvimento e produção.

BearerAuthMiddleware

Usado para autenticação via tokens Bearer JWT, integrado com o sistema de autenticação do Adianti Framework. Como funciona:

Verifica o header Authorization: Bearer {token}
Valida tokens JWT usando ApplicationAuthenticationService
Ideal para autenticação de usuários logados
Importante: Os tokens têm tempo de vida de 3 horas após serem gerados

Para usar o BearerAuthMiddleware, primeiro é necessário obter um token JWT válido através de login. O sistema já possui um controller pronto (ApiAuthController) com o método authenticate. Criando as rotas necessárias:

// Em: app/routes/api.php

Router::group([
    'prefix' => '/api'
], function () {
    // Rota para obter token (sem middleware - acesso público)
    Router::post('/auth/login', 'ApiAuthController::authenticate');
});

Router::group([
    'prefix' => '/api',
    'middleware' => ['BearerAuthMiddleware']  // Aplica o middleware
], function () {
    // Rotas protegidas que exigem token válido
    Router::get('/pedido-venda', 'ApiPedidovendaController::index');
});

Após criar as rotas, é possível obter nosso token de sessão (login). No Postman, basta enviar uma requisição POST para /api/auth/login com o corpo da requisição contendo o login e senha do usuário. Login com credenciais válidas

Note que é necessário fornecer informações de um usuário válido para obter um token de sessão. O método ApiAuthController::authenticate não é capaz de criar um usuário, ele apenas valida as credenciais de um usuário existente. Ao tentar obter um token com credenciais inválidas, recebemos um erro: Alt text

Testando Rotas Protegidas

Para usar o token: na aba Authorization, selecione “Bearer Token” e cole o token obtido: Teste com Bearer token válido

Com um token inválido: Teste com Bearer token inválido

Dica: Você pode combinar múltiplos middlewares: 'middleware' => ['BasicAuthMiddleware', 'MeuMiddleware']

Passo 3: Criando Seus Próprios Middlewares

Você pode criar middlewares personalizados para necessidades específicas. Vamos criar um exemplo prático:

Exemplo: Middleware de Header Personalizado

Crie o arquivo app/middleware/TestKeyMiddleware.php:

// Em: app/middleware/TestKeyMiddleware.php

<?php
use Mad\Rest\Request;
use Mad\Rest\Response;

/**
 * Middleware que verifica se foi enviado um header X-API-Key
 */
class TestKeyMiddleware
{
    public function handle(Request $request, callable $next)
    {
        // Obtém o valor do header personalizado
        $apiKey = $request->getHeaders()['X-API-Key'] ?? null;
        
        // Verifica se o header foi enviado
        if (empty($apiKey)) {
            return (new Response())->json([
                'error' => 'Header X-API-Key é obrigatório'
            ], 400);
        }
        
        // Verifica se a chave é válida (exemplo simples)
        if ($apiKey !== 'minha-api-key-123') {
            return (new Response())->json([
                'error' => 'API Key inválida'
            ], 401);
        }
        
        // Se passou nas verificações, continua
        return $next($request);
    }
}

Aplicando o Middleware Personalizado

// Em: app/routes/api.php

Router::group([
    'prefix' => '/api/pedido-venda',
    'middleware' => ['TestKeyMiddleware']
], function () {
    Router::get('/', 'ApiPedidovendaController::index');
});

Testando no Postman:

Na aba Headers, adicione:
- Key: X-API-Key
- Value: minha-api-key-123

Enviando a chave errada: Teste Middleware personalizado chave errada

Observação: Use middlewares estrategicamente. Nem todos os endpoints precisam de autenticação (ex: login, documentação pública).

Com middlewares bem configurados, sua API fica segura e organizada, permitindo controle fino sobre quem pode acessar cada endpoint.

​Passo 1: Como os Middlewares Funcionam

​Passo 2: Middlewares Disponíveis no Projeto

​BasicAuthMiddleware

​Configurando Autenticação no Arquivo de Configuração

​BearerAuthMiddleware

​Obtendo um Token de Sessão (Login)

​Testando Rotas Protegidas

​Passo 3: Criando Seus Próprios Middlewares

​Exemplo: Middleware de Header Personalizado

​Aplicando o Middleware Personalizado