PHP code example of pivotphp / core

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

/* Start to develop here. Best regards https://php-download.com/ */

    

pivotphp / core example snippets

PivotPHP\Core\Core\Application;
use PivotPHP\Core\Http\Psr15\Middleware\{SecurityMiddleware, CorsMiddleware, AuthMiddleware};

$app = new Application();

// Middlewares de segurança (PSR-15)
$app->use(new SecurityMiddleware());
$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();

// 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');

// ❌ 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']);

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 v1.2.0
$app->get('/users', [UserController::class, 'index']);
$app->get('/users/:id<\d+>', [UserController::class, 'show']);    // Apenas números
$app->post('/users', [UserController::class, 'store']);

// ✅ Com middleware
$app->put('/users/:id', [UserController::class, 'update'])
    ->middleware($authMiddleware);

// O PivotPHP v1.2.0 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"

// 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();

// ✅ OTIMIZAÇÃO AUTOMÁTICA - Zero configuração necessária
$app->get('/api/users', function($req, $res) {
    $users = User::all();
    
    // Sistema decide automaticamente:
    // • Poucos usuários (<256 bytes): json_encode() direto
    // • Muitos usuários (≥256 bytes): pooling automático
    return $res->json($users); // Sempre otimizado!
});

// Dados pequenos (<256 bytes) - json_encode() direto
$smallData = ['status' => 'ok', 'count' => 42];
$json = JsonBufferPool::encodeWithPool($smallData); 
// Performance: 500K+ ops/sec (sem overhead)

// Dados médios (256 bytes - 10KB) - pooling automático  
$mediumData = User::paginate(20);
$json = JsonBufferPool::encodeWithPool($mediumData);
// Performance: 119K+ ops/sec (15-30% ganho)

// Dados grandes (>10KB) - pooling otimizado
$largeData = Report::getAllWithRelations();
$json = JsonBufferPool::encodeWithPool($largeData);
// Performance: 214K+ ops/sec (98%+ ganho)

use PivotPHP\Core\Json\Pool\JsonBufferPool;

// Personalizar threshold (padrão: 256 bytes)
JsonBufferPool::configure([
    'threshold_bytes' => 512,      // Usar pool apenas para dados >512 bytes
    'max_pool_size' => 200,        // Máximo 200 buffers
    'default_capacity' => 8192,    // Buffers de 8KB
]);

// Verificar se threshold será aplicado
if (JsonBufferPool::shouldUsePooling($data)) {
    echo "Pool será usado (dados grandes)\n";
} else {
    echo "json_encode() direto (dados pequenos)\n";
}

// Monitoramento em tempo real
$stats = JsonBufferPool::getStatistics();
echo "Eficiência: {$stats['efficiency']}%\n";
echo "Operações: {$stats['total_operations']}\n";

use PivotPHP\Core\Exceptions\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

// 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

// 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
]);

use PivotPHP\Core\Middleware\Http\ApiDocumentationMiddleware;

// ✅ NOVO v1.2.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'
]));

// Suas rotas com documentação PHPDoc
$app->get('/users', function($req, $res) {
    /**
     * @summary List all users
     * @description Returns a list of all users in the system
     * @tags Users
     * @response 200 array List of users
     */
    return $res->json(['users' => User::all()]);
});

$app->get('/users/:id', function($req, $res) {
    /**
     * @summary Get user by ID
     * @description Returns a single user by their ID
     * @tags Users
     * @param int id User ID
     * @response 200 object User object
     * @response 404 object User not found
     */
    $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

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);
});

use PivotPHP\ReactPHP\ReactServiceProvider;

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

// Executar servidor assíncrono
$app->runAsync(); // Em vez de $app->run()

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']);
        });
    }
}

// ✅ MANTIDO v1.2.0: 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

// ✅ 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!

// ✅ 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
}

// Imports antigos (ainda funcionam via aliases)
use PivotPHP\Core\Http\Psr15\Middleware\CorsMiddleware;
use PivotPHP\Core\Support\Arr;

// Imports recomendados (nova estrutura)
use PivotPHP\Core\Middleware\Http\CorsMiddleware;
use PivotPHP\Core\Utils\Arr;

bash
# Rodar o exemplo
php examples/api_documentation_example.php

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

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

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

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

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