README

🚀 O que é o PivotPHP?

PivotPHP é um microframework moderno, leve e seguro, inspirado no Express.js, especialmente projetado para provas de conceito, prototipagem rápida e estudos. Oferece uma API familiar e produtiva para validar ideias rapidamente, com arquitetura desacoplada e extensibilidade real quando necessário.

⚡ Setup Instantâneo: API funcionando em menos de 5 minutos, perfeito para validar ideias rapidamente.
🎯 Foco em Produtividade: Sintaxe familiar (Express.js) que acelera o desenvolvimento de protótipos.
📚 Documentação Automática: Geração automática de OpenAPI/Swagger - essencial para apresentar provas de conceito.
🛡️ Segurança Integrada: Middlewares prontos para CSRF, XSS, JWT - protótipos seguros desde o início.
🔧 Extensibilidade Simples: Sistema de plugins e providers para expandir funcionalidades conforme necessário.
📊 Performance Adequada: footprint de ~1.61MB - suficiente para demonstrações. (Número histórico de microbenchmark interno da v1.1.3 — 44,092 ops/sec — reportado desde então como "mantido"; não revalidado para a série 2.x. Veja PERFORMANCE_RESULTS.md.)
🎨 v2.0.0: Legacy Cleanup Edition - 18% code reduction, modern namespaces, routing externalized, zero deprecated code.

✨ Principais Recursos

🏗️ DI Container & Providers
🎪 Event System
🧩 Sistema de Extensões
🔧 Configuração flexível
🔐 Autenticação Multi-método
🛡️ Segurança Avançada
📡 Streaming & SSE
📚 OpenAPI/Swagger Automático (v2.0.0 Middleware)
🔄 PSR-7 Híbrido
♻️ Object Pooling
🚀 JSON Optimization (Intelligent Caching)
🎯 Array Callables (Native Support)
🔍 Enhanced Error Diagnostics
⚡ Performance Extrema
🧪 Qualidade e Testes
🎯 Simplicidade sobre Otimização
🧹 v2.0.0 Legacy Cleanup (18% code reduction)
🔌 Modular Routing (External package pivotphp/core-routing, extraído na v2.0.0)

💡 Casos de Uso Ideais

🔬 Provas de Conceito: Validar ideias de API rapidamente com setup mínimo
🎯 Prototipagem Rápida: Demonstrar funcionalidades para stakeholders e clientes
📚 Estudos e Aprendizado: Compreender arquiteturas de microframework e PSR standards
🧪 Testes de Integração: Criar APIs mock para testar integrações frontend/mobile
🎨 MVPs Educacionais: Projetos acadêmicos e de portfólio com qualidade profissional
🔗 APIs Bridge: Conectar sistemas legacy com interfaces modernas

Ideal para: Desenvolvedores que precisam validar conceitos rapidamente sem a complexidade de frameworks enterprise.

Veja exemplos práticos em examples/ e documentação técnica completa.

🚀 Início Rápido

Instalação

composer require pivotphp/core

Exemplo Básico

<?php
require_once 'vendor/autoload.php';

use PivotPHP\Core\Core\Application;
use PivotPHP\Core\Middleware\Security\{SecurityHeadersMiddleware, AuthMiddleware};
use PivotPHP\Core\Middleware\Http\CorsMiddleware;

$app = new Application();

// Middlewares de segurança (PSR-15)
$app->use(new SecurityHeadersMiddleware());
$app->use(new CorsMiddleware());
$app->use(new AuthMiddleware([
    'authMethods' => ['jwt'],
    'jwtSecret' => 'sua_chave_secreta'
]));

// API RESTful
$app->get('/api/users', function($req, $res) {
    $res->json(['users' => $userService->getAll()]);
});

$app->post('/api/users', function($req, $res) {
    $user = $userService->create($req->body);
    $res->status(201)->json(['user' => $user]);
});

// Rotas com validação regex
$app->get('/api/users/:id<\d+>', function($req, $res) {
    // Aceita apenas IDs numéricos
    $res->json(['user_id' => $req->param('id')]);
});

$app->get('/posts/:year<\d{4}>/:month<\d{2}>/:slug<slug>', function($req, $res) {
    // Validação de data e slug na rota
    $res->json([
        'year' => $req->param('year'),
        'month' => $req->param('month'),
        'slug' => $req->param('slug')
    ]);
});

$app->run();

🛣️ Sintaxes de Roteamento Suportadas

O PivotPHP oferece suporte robusto para múltiplas sintaxes de roteamento:

✅ Sintaxes Suportadas

// 1. Closure/Função Anônima (Recomendado para APIs simples)
$app->get('/users', function($req, $res) {
    return $res->json(['users' => User::all()]);
});

// 2. Array Callable (Recomendado para Controllers)
$app->get('/users', [UserController::class, 'index']);           // Método estático/instância
$app->post('/users', [$userController, 'store']);                // Instância específica
$app->get('/users/:id<\d+>', [UserController::class, 'show']);   // Com validação regex

// 3. Função nomeada (Para helpers simples)
function getUsersHandler($req, $res) {
    return $res->json(['users' => User::all()]);
}
$app->get('/users', 'getUsersHandler');

❌ Sintaxes NÃO Suportadas

// ❌ String Controller@method - NÃO FUNCIONA!
$app->get('/users', 'UserController@index'); // TypeError!

// ❌ Brace syntax - Use colon syntax
$app->get('/users/{id}', [Controller::class, 'show']); // Erro - use :id

// ✅ CORRETO: Use colon syntax
$app->get('/users/:id', [Controller::class, 'show']);

🎯 Exemplo Completo com Controller

<?php

namespace App\Controllers;

class UserController
{
    // ✅ Métodos devem ser PÚBLICOS
    public function index($req, $res)
    {
        $users = User::paginate($req->query('limit', 10));
        return $res->json(['users' => $users]);
    }

    public function show($req, $res)
    {
        $id = $req->param('id');
        $user = User::find($id);

        if (!$user) {
            return $res->status(404)->json(['error' => 'User not found']);
        }

        return $res->json(['user' => $user]);
    }

    public function store($req, $res)
    {
        $data = $req->body();
        $user = User::create($data);

        return $res->status(201)->json(['user' => $user]);
    }
}

// ✅ Registrar rotas com array callable
$app->get('/users', [UserController::class, 'index']);
$app->get('/users/:id<\d+>', [UserController::class, 'show']);    // Apenas números
$app->post('/users', [UserController::class, 'store']);

// ⚠️ Middleware: $app->middleware() é um alias de $app->use() — registra middleware
// GLOBAL, não escopado à rota encadeada. Para middleware por rota/grupo, use o Router
// subjacente diretamente (PivotPHP\Core\Routing\Router::group($prefix, $callback, $middlewares)).
$app->put('/users/:id', [UserController::class, 'update']);
$app->middleware($authMiddleware); // aplica-se a todas as rotas, não só a essa

⚡ Validação Automática

// O PivotPHP valida automaticamente array callables:

// ✅ Método público - ACEITO
class PublicController {
    public function handle($req, $res) { return $res->json(['ok' => true]); }
}

// ❌ Método privado - REJEITADO com erro descritivo
class PrivateController {
    private function handle($req, $res) { return $res->json(['ok' => true]); }
}

$app->get('/public', [PublicController::class, 'handle']);   // ✅ Funciona
$app->get('/private', [PrivateController::class, 'handle']); // ❌ Erro claro

// Erro: "Route handler validation failed: Method 'handle' is not accessible"

📖 Documentação completa: Guia de Sintaxe de Rotas

🔄 Suporte PSR-7 Híbrido

O PivotPHP oferece compatibilidade híbrida com PSR-7, mantendo a facilidade da API Express.js enquanto implementa completamente as interfaces PSR-7:

// API Express.js (familiar e produtiva)
$app->get('/api/users', function($req, $res) {
    $id = $req->param('id');
    $name = $req->input('name');
    return $res->json(['user' => $userService->find($id)]);
});

// PSR-7 nativo (para middleware PSR-15)
$app->use(function(ServerRequestInterface $request, ResponseInterface $response, $next) {
    $method = $request->getMethod();
    $uri = $request->getUri();
    $newRequest = $request->withAttribute('processed', true);
    return $next($newRequest, $response);
});

// Lazy loading e Object Pooling automático
use PivotPHP\Core\Http\Factory\OptimizedHttpFactory;

OptimizedHttpFactory::initialize([
    'enable_pooling' => true,
    'warm_up_pools' => true,
    'max_pool_size' => 100,
]);

// Objetos PSR-7 são reutilizados automaticamente
$request = OptimizedHttpFactory::createRequest('GET', '/api/users', '/api/users');
$response = OptimizedHttpFactory::createResponse();

Benefícios da Implementação Híbrida:

✅ 100% compatível com middleware PSR-15
✅ Imutabilidade respeitada nos métodos with*()
✅ Lazy loading - objetos PSR-7 criados apenas quando necessário
✅ Object pooling - reutilização inteligente para melhor performance
✅ API Express.js mantida para produtividade
✅ Zero breaking changes - código existente funciona sem alterações

🚀 JSON Optimization (Intelligent System)

O PivotPHP usa thresholds automáticos por tipo de dado no sistema de otimização JSON, eliminando overhead para payloads pequenos (JsonBufferPool::shouldUsePooling(), ver src/Json/Pool/JsonBufferPool.php):

Arrays com 10+ elementos (POOLING_ARRAY_THRESHOLD) — ou qualquer array com estrutura aninhada (array/objeto dentro)
Objetos com 5+ propriedades públicas (POOLING_OBJECT_THRESHOLD)
Strings com 1024+ bytes (POOLING_STRING_THRESHOLD)

Abaixo desses limites, o sistema usa json_encode() direto.

⚡ Sistema Inteligente Automático

// ✅ OTIMIZAÇÃO AUTOMÁTICA - Zero configuração necessária
$app->get('/api/users', function($req, $res) {
    $users = User::all();

    // Sistema decide automaticamente com base no tipo/tamanho dos dados
    // (array com 10+ itens, objeto com 5+ propriedades, string com 1KB+)
    return $res->json($users); // Sempre otimizado!
});

🔧 Configuração Avançada (Opcional)

use PivotPHP\Core\Json\Pool\JsonBufferPool;

// Chaves aceitas por configure(): max_pool_size, default_capacity, size_categories
// (não existe opção para customizar os thresholds de pooling em si)
JsonBufferPool::configure([
    'max_pool_size' => 200,        // Máximo 200 buffers
    'default_capacity' => 8192,    // Buffers de 8KB
]);

// Verificar se o pooling será aplicado para um dado específico
if (JsonBufferPool::shouldUsePooling($data)) {
    echo "Pool será usado\n";
} else {
    echo "json_encode() direto\n";
}

// Monitoramento em tempo real
$stats = JsonBufferPool::getStatistics();
echo "Taxa de reuso: {$stats['reuse_rate']}%\n";
echo "Operações: {$stats['total_operations']}\n";

✨ Características

✅ Thresholds automáticos por tipo - array/objeto/string, sem overhead para dados pequenos
✅ Detecção Automática - Sistema decide quando usar pooling
✅ Zero Configuração - Funciona perfeitamente out-of-the-box
✅ Monitoramento Integrado - Estatísticas em tempo real via getStatistics()
✅ Compatibilidade Total - Drop-in replacement transparente

🔍 Enhanced Error Diagnostics

PivotPHP v2.0.0 mantém ContextualException para diagnósticos avançados de erros:

⚡ Sistema de Erro Inteligente

use PivotPHP\Core\Exceptions\Enhanced\ContextualException;

// Captura automática de contexto e sugestões
try {
    $app->get('/users/:id', [Controller::class, 'privateMethod']);
} catch (ContextualException $e) {
    echo "Erro: " . $e->getMessage() . "\n";
    echo "Contexto: " . json_encode($e->getContext()) . "\n";
    echo "Sugestão: " . $e->getSuggestion() . "\n";
    echo "Categoria: " . $e->getCategory() . "\n";
}

// Output example:
// Erro: Route handler validation failed
// Contexto: {"method":"privateMethod","class":"Controller","visibility":"private"}
// Sugestão: Make the method public or use a public method instead
// Categoria: ROUTING

🎯 Categorias de Erro Disponíveis

// Automaticamente detectadas pelo sistema
ContextualException::CATEGORY_ROUTING      // Problemas de roteamento
ContextualException::CATEGORY_PARAMETER    // Validação de parâmetros
ContextualException::CATEGORY_VALIDATION   // Validação de dados
ContextualException::CATEGORY_MIDDLEWARE   // Problemas de middleware
ContextualException::CATEGORY_HTTP         // Erros HTTP
ContextualException::CATEGORY_SECURITY     // Questões de segurança
ContextualException::CATEGORY_PERFORMANCE  // Problemas de performance

🔧 Configuração de Ambiente

// Desenvolvimento - máximo de informações
ContextualException::setEnvironment('development');

// Produção - informações limitadas por segurança
ContextualException::setEnvironment('production');

// Personalizada
ContextualException::configure([
    'show_suggestions' => true,
    'show_context' => false,
    'log_errors' => true,
    'max_context_size' => 1024
]);

✨ Recursos v2.0.0

✅ Erro IDs Únicos - Rastreamento facilitado para debugging
✅ Sugestões Inteligentes - Orientações específicas para resolver problemas
✅ Contexto Rico - Informações detalhadas sobre o estado quando o erro ocorreu
✅ Categorização Automática - Classificação inteligente do tipo de erro
✅ Segurança por Ambiente - Detalhes reduzidos em produção
✅ Logging Integrado - Registro automático para análise posterior

📖 Documentação completa:

📖 Documentação OpenAPI/Swagger Automática (v2.0.0+)

O PivotPHP v2.0.0+ inclui middleware automático para geração de documentação OpenAPI/Swagger:

use PivotPHP\Core\Middleware\Http\ApiDocumentationMiddleware;

// v2.0.0: Documentação automática em 3 linhas!
$app = new Application();

// Adicionar middleware de documentação automática
$app->use(new ApiDocumentationMiddleware([
    'docs_path' => '/docs',        // Endpoint JSON OpenAPI
    'swagger_path' => '/swagger',  // Interface Swagger UI
    'base_url' => 'http://localhost:8080'
]));

// Registrar rotas normalmente
$app->get('/users', function($req, $res) {
    return $res->json(['users' => User::all()]);
});

$app->get('/users/:id', function($req, $res) {
    $userId = $req->param('id');
    return $res->json(['user' => User::find($userId)]);
});

// Pronto! Acesse:
// http://localhost:8080/swagger - Interface Swagger UI completa
// http://localhost:8080/docs    - JSON OpenAPI 3.0.0

🎯 Recursos do Middleware de Documentação

✅ Geração automática de OpenAPI 3.0.0 de todas as rotas registradas
✅ Interface Swagger UI integrada (zero configuração)
✅ Endpoints automáticos /docs e /swagger
✅ Configuração flexível de paths e URLs
✅ Zero dependências externas
✅ Compatibilidade total com todas as rotas

Nota: O middleware gera paths básicos (método HTTP + caminho) a partir das rotas registradas. Metadados adicionais (descrições, tags, parâmetros) devem ser configurados manualmente no objeto OpenAPI retornado, ou via extensão futura.

📝 Exemplo Completo

Veja o exemplo funcional em examples/api_documentation_example.php:

# Rodar o exemplo
php examples/api_documentation_example.php

# Acessar documentação
open http://localhost:8080/swagger

📚 Documentação Completa

Acesse o Índice da Documentação para navegar por todos os guias técnicos, exemplos, referências de API, middlewares, autenticação, performance e mais.

Principais links:

🧩 Extensões Oficiais

O PivotPHP possui um ecossistema rico de extensões que adicionam funcionalidades poderosas ao framework:

🗄️ Cycle ORM Extension

composer require pivotphp/cycle-orm

Integração completa com Cycle ORM para gerenciamento de banco de dados:

Migrações automáticas
Repositórios com query builder
Relacionamentos (HasOne, HasMany, BelongsTo, ManyToMany)
Suporte a transações
Múltiplas conexões de banco

use PivotPHP\CycleORM\CycleServiceProvider;

$app->register(new CycleServiceProvider([
    'dbal' => [
        'databases' => [
            'default' => ['connection' => 'mysql://user:pass@localhost/db']
        ]
    ]
]));

// Usar em rotas
$app->get('/users', function($req, $res) use ($container) {
    $users = $container->get('orm')
        ->getRepository(User::class)
        ->findAll();
    $res->json($users);
});

⚡ ReactPHP Extension

composer require pivotphp/reactphp

Runtime assíncrono para aplicações de longa duração:

Servidor HTTP contínuo sem reinicializações
Suporte a WebSocket (em breve)
Operações I/O assíncronas
Arquitetura orientada a eventos
Timers e tarefas periódicas

use PivotPHP\ReactPHP\ReactServiceProvider;

$app->register(new ReactServiceProvider([
    'server' => [
        'host' => '0.0.0.0',
        'port' => 8080
    ]
]));

// O provider assume o ciclo de vida do servidor; a forma de iniciá-lo
// (comando, script de bootstrap, etc.) é definida pelo pacote pivotphp/reactphp —
// consulte a documentação desse pacote. `Application::run()` continua sendo o
// ponto de entrada padrão para o runtime tradicional (não-ReactPHP).

🌐 Extensões da Comunidade

A comunidade PivotPHP está crescendo! Estamos animados para ver as extensões que serão criadas.

Extensões Planejadas:

Gerador de documentação OpenAPI/Swagger
Sistema de filas para jobs em background
Cache avançado com múltiplos drivers
Abstração para envio de emails
Servidor WebSocket
Suporte GraphQL

🔧 Criando Sua Própria Extensão

namespace MeuProjeto\Providers;

use PivotPHP\Core\Providers\ServiceProvider;

class MinhaExtensaoServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // Registrar serviços
        $this->container->singleton('meu.servico', function() {
            return new MeuServico();
        });
    }

    public function boot(): void
    {
        // Lógica de inicialização
        $this->app->get('/minha-rota', function($req, $res) {
            $res->json(['extensao' => 'ativa']);
        });
    }
}

Diretrizes para Extensões:

Seguir convenção de nome: pivotphp-{nome}
Fornecer ServiceProvider estendendo ServiceProvider
Incluir testes de integração
Documentar no /docs/extensions/
Publicar no Packagist com tag pivotphp-extension

🔄 Compatibilidade PSR-7

O PivotPHP oferece suporte duplo para PSR-7, permitindo uso com projetos modernos (v2.x) e compatibilidade com ReactPHP (v1.x).

v2.1.1: o suporte a psr/http-message ^1.1 e ^2.0 funciona nativamente, sem necessidade de rodar o script abaixo — ele corrige uma regressão introduzida na v2.1.0 em que a instalação da v2.0 (permitida pelo próprio composer.json) quebrava a aplicação com erro fatal em toda rota. Veja o changelog da v2.1.1. O script switch-psr7-version.php abaixo permanece disponível, mas não é mais um pré-requisito para compatibilidade básica com as duas versões.

Verificar versão atual

php scripts/utils/switch-psr7-version.php --check

Alternar entre versões

# Mudar para PSR-7 v1.x (compatível com ReactPHP)
php scripts/utils/switch-psr7-version.php 1

# Mudar para PSR-7 v2.x (padrão moderno)
php scripts/utils/switch-psr7-version.php 2

Após alternar versões

# Atualizar dependências
composer update

# Validar o projeto
./scripts/validation/validate_all.sh

Veja a documentação completa sobre PSR-7 para mais detalhes.

🏗️ Arquitetura v2.0.0 (Legacy Cleanup Edition)

O PivotPHP v2.0.0 simplifica a arquitetura seguindo o princípio "Simplicidade sobre Otimização Prematura", priorizando facilidade de uso para provas de conceito:

Nota: a estrutura descrita abaixo (namespaces de middleware, array callables, JsonBufferPool, ContextualException) segue válida na v2.1.1. As versões 2.1.0 e 2.1.1 não mudaram essa arquitetura — trouxeram correções pontuais (emissão única de resposta em Application::run(), vazamento de dados em objetos pooled, compatibilidade real com psr/http-message ^2.0) e um ciclo de depreciação (Core\Container, LoadShedder/RateLimitMiddleware, Request::getIp(), Providers\Logger/EventDispatcher — remoção prevista para v3.0.0). Veja o CHANGELOG para o histórico completo.

🎯 Recursos v2.0.0

🚀 Array Callables Nativos

// Suporte nativo a array callables
$app->get('/users', [UserController::class, 'index']);
$app->post('/users', [$userController, 'store']);

// Validação automática de métodos
// Se método for privado/protegido, erro claro com sugestão

// Integração total com IDE
// Autocomplete, refactoring, jump-to-definition

🧠 JsonBufferPool Inteligente

// Sistema com threshold de 256 bytes
// Dados pequenos: json_encode() direto (performance máxima)
// Dados grandes: pooling automático (otimização máxima)

$response = $res->json($anyData); // Sempre otimizado!

🔍 Enhanced Error Diagnostics

// ContextualException com sugestões inteligentes
// Contexto rico, categorização automática, logging integrado

try {
    $app->get('/route', [Controller::class, 'privateMethod']);
} catch (ContextualException $e) {
    // Erro específico com sugestão clara de como resolver
}

🎯 Estrutura de Middlewares Organizada

src/Middleware/
├── Security/              # Middlewares de segurança
│   ├── AuthMiddleware.php
│   ├── CsrfMiddleware.php
│   ├── SecurityHeadersMiddleware.php
│   └── XssMiddleware.php
├── Performance/           # Middlewares de performance
│   ├── CacheMiddleware.php
│   └── RateLimitMiddleware.php
└── Http/                 # Middlewares HTTP
    ├── CorsMiddleware.php
    └── ErrorMiddleware.php

✅ Melhorias da v2.0.0 (Legacy Cleanup)

🧹 18% code reduction - 11,871 linhas removidas, código limpo e direto
🎯 Orientado a Protótipos - Arquitetura simplificada para desenvolvimento rápido
🔧 Setup Mínimo - Configuração zero para começar imediatamente
💡 Conceitos Claros - Estrutura lógica e intuitiva para estudos
🛡️ Qualidade - PHPStan Level 9, PSR-12 100%, todos os testes passando

🔄 Migração para v2.0.0

// Imports v1.x (não funcionam mais — aliases removidos na v2.0.0)
use PivotPHP\Core\Http\Psr15\Middleware\CorsMiddleware; // REMOVIDO

// Imports corretos (namespace atual)
use PivotPHP\Core\Middleware\Http\CorsMiddleware;
use PivotPHP\Core\Utils\Arr;

Veja o Overview Estrutural v2.0.0 para detalhes completos.

⚠️ Importante: Manutenção do Projeto

PivotPHP Core é mantido por apenas uma pessoa e pode não receber atualizações constantemente. Este projeto é ideal para:

🔬 Provas de conceito e protótipos
📚 Estudos e aprendizado de arquitetura
🧪 Testes e validação de ideias
🎓 Projetos educacionais e acadêmicos

Não recomendado para:

🏢 Aplicações enterprise críticas
📈 Sistemas de produção que exigem suporte 24/7
🔄 Projetos que precisam de atualizações frequentes

Se você precisa de um framework com equipe dedicada e suporte empresarial, considere alternativas como Laravel, Symfony ou Slim 4.

🤝 Comunidade

Junte-se à nossa comunidade crescente de desenvolvedores:

GitHub Discussions: Inicie uma discussão - Compartilhe feedback e ideias

🤝 Como Contribuir

Quer ajudar a evoluir o PivotPHP? Veja o Guia de Contribuição ou acesse docs/contributing/ para saber como abrir issues, enviar PRs ou criar extensões.

Contribuições são especialmente bem-vindas! Por ser mantido por uma pessoa, o projeto se beneficia muito da colaboração da comunidade.

📄 Licença

Este projeto está licenciado sob a Licença MIT. Veja o arquivo LICENSE para detalhes.

Desenvolvido com ❤️ para a comunidade PHP

pivotphp / core

Maintainers

Package info

Fund package maintenance!

Statistics

Security

README

🚀 O que é o PivotPHP?

✨ Principais Recursos

💡 Casos de Uso Ideais

🚀 Início Rápido

Instalação

Exemplo Básico

🛣️ Sintaxes de Roteamento Suportadas

✅ Sintaxes Suportadas

❌ Sintaxes NÃO Suportadas

🎯 Exemplo Completo com Controller

⚡ Validação Automática

🔄 Suporte PSR-7 Híbrido

🚀 JSON Optimization (Intelligent System)

⚡ Sistema Inteligente Automático

🔧 Configuração Avançada (Opcional)

✨ Características

🔍 Enhanced Error Diagnostics

⚡ Sistema de Erro Inteligente

🎯 Categorias de Erro Disponíveis

🔧 Configuração de Ambiente

✨ Recursos v2.0.0

📖 Documentação OpenAPI/Swagger Automática (v2.0.0+)

🎯 Recursos do Middleware de Documentação

📝 Exemplo Completo

📚 Documentação Completa

🧩 Extensões Oficiais

🗄️ Cycle ORM Extension

⚡ ReactPHP Extension

🌐 Extensões da Comunidade

🔧 Criando Sua Própria Extensão

🔄 Compatibilidade PSR-7

Verificar versão atual

Alternar entre versões

Após alternar versões

🏗️ Arquitetura v2.0.0 (Legacy Cleanup Edition)

🎯 Recursos v2.0.0

🚀 Array Callables Nativos

🧠 JsonBufferPool Inteligente

🔍 Enhanced Error Diagnostics

🎯 Estrutura de Middlewares Organizada

✅ Melhorias da v2.0.0 (Legacy Cleanup)

🔄 Migração para v2.0.0

⚠️ Importante: Manutenção do Projeto

🤝 Comunidade

🤝 Como Contribuir

📄 Licença