PHP [LARAVEL] - Crie ciclo de vidas para seus processos complexos.

Eae pessoal!

Durante alguns anos de carreira, me deparei com vários desafios de arquitetura: soluções que resolvem problemas, mas ao mesmo tempo trazem uma curva de aprendizado que acaba afastando parte da equipe de implementá-las corretamente.

Trabalhando com Laravel e times de experiência mista, resolvi criar um padrão de arquitetura mais simplificado e direto ao ponto para as situações em que realmente vale a pena aplicá-lo.

Laravel LifeCycle Hooks

A ideia é expor pontos de ciclo de vida dentro dos serviços, onde outros times podem plugar sua lógica sem precisar alterar o core.
É inspirado no microkernel, mas adaptado para o dia a dia com Laravel.

Exemplo simples:

use PhpDiffused\Lifecycle\Attributes\LifeCyclePoint;
use PhpDiffused\Lifecycle\Traits\HasLifecycle;

#[LifeCyclePoint('before_payment', ['user_id', 'amount'])]
#[LifeCyclePoint('after_payment', ['user_id', 'amount', 'payment_id'])]
class PaymentService
{
    use HasLifecycle;
    
    public function process(int $userId, float $amount): string
    {
        runHook($this, 'before_payment', $userId, $amount);
        
        $paymentId = $this->doPayment($userId, $amount);
        
        runHook($this, 'after_payment', $userId, $amount, $paymentId);
        
        return $paymentId;
    }
}

Agora qualquer dev pode criar um hook plugável:

use PhpDiffused\Lifecycle\Attributes\Hook;
use PhpDiffused\Lifecycle\Attributes\Severity;

#[Hook(scope: 'PaymentService', point: 'before_payment', severity: Severity::Critical)]
class FraudDetectionHook
{
    use Hookable;
    
    public function handle(array &$args): void
    {
        if ($this->isFraudulent($args)) {
            throw new FraudException('Suspicious activity detected');
        }
    }
}

Benefícios principais

Core sempre limpo e mínimo

Extensões sem tocar na lógica central

Hooks críticos podem cancelar a operação, opcionais não quebram o fluxo

Logs estruturados mostrando quais variáveis foram modificadas

Kernel centralizado com ordem explícita de execução

Comando lifecycle:analyze para detectar conflitos automaticamente

Repositório no GitHub: https://github.com/jeffleyd/Laravel-Lifecycle

1. Por que não usar Action Pattern?
   Actions ajudam a organizar, mas ainda exigem alterar o core.
   Os hooks permitem extensão sem tocar no core, com ordem, severidade e logs.

2. Isso deixa o sistema mais lento?
   O overhead é mínimo. Hooks só rodam se existirem.
   O ganho em segurança e governança compensa facilmente.

3. Por que usar referência (&)?
   Permite que múltiplos hooks modifiquem os mesmos dados em cadeia.
   Também gera logs automáticos mostrando o que mudou antes/depois.

4. Isso não é só um Event/Observer disfarçado?
   Não. Events são “fire-and-forget”, sem garantia de ordem ou mutabilidade.
   Hooks têm ordem controlada, severidade (crítico/opcional) e rastreamento de mudanças.

5. Quando faz sentido usar?
   Use nos 20% críticos: pagamentos, checkout, integrações complexas.
   Evite em CRUD simples, microserviços pequenos ou cenários de performance extrema.

6. Qual a principal vantagem em times grandes?
   Cada dev/time cria seus próprios hooks sem arriscar o core.
   O Kernel mostra toda a ordem de execução.
   E o comando lifecycle:analyze detecta conflitos automaticamente.

Feedbacks são bem-vindos!