Event Laravel Package

Product Decisions This Supports

• Build vs. Buy: Buy – Accelerates development of event-driven architectures (e.g., real-time systems, async workflows) by providing a mature, maintained alternative to custom implementations or heavier frameworks like ReactPHP. Reduces technical debt in PHP 8.2+ projects by eliminating the need to build and maintain Promises, Event Loops, or Coroutines from scratch.

  • Example: Replace a custom WebSocket server built with pthreads or pcntl with a type-safe, scalable solution backed by SabreIO.
  • Example: Avoid reinventing async task coordination in CLI tools by leveraging the Event Loop and Promises.

• Feature Enablement: Async-first Laravel extensions – Enables non-blocking I/O and real-time capabilities where Laravel’s synchronous stack falls short:

  • Real-time APIs/WebSockets: Build low-latency systems (e.g., live collaboration tools, IoT dashboards) without external services like Pusher or Socket.io.
  • CLI Async Workflows: Process high-volume batch jobs (e.g., data scraping, API polling) without blocking threads or using queues.
  • Decoupled Microservices: Implement event-driven communication between services in a Laravel-first architecture (e.g., publish/subscribe patterns).
  • Coroutines for Complex Workflows: Simplify nested async operations (e.g., sequential API calls with retries) using yield-based coroutines.

• Roadmap Alignment: PHP 8.2+ Migration – Forces alignment with modern PHP practices (strict typing, attributes, fibers) and reduces friction when upgrading Laravel or other dependencies. The PHP 8.2 requirement ensures compatibility with:

  • Laravel’s async improvements (e.g., PendingDispatch, Fiber-based queues).
  • New PHP features like native coroutines (PHP 8.1+) or enums (used internally in SabreIO’s codebase).
  • Future-proofing against deprecated PHP 7.x features in Laravel.

• Performance Optimization: Event Loop for High-Throughput Async – Replaces synchronous loops or external queues (e.g., Redis) for CPU-bound or I/O-bound tasks:

  • Example: Process 10K+ API requests concurrently in a CLI tool without blocking.
  • Example: Replace Laravel Queues for short-lived async tasks (e.g., sending emails, logging) where queue overhead is unnecessary.
  • Example: Build a custom HTTP server (e.g., for internal tools) with non-blocking request handling.

• Architectural Flexibility: Hybrid Sync/Async Systems – Integrate selectively with Laravel’s sync stack:

  • Use Promises for async operations (e.g., database calls, external APIs) in Artisan commands or console kernels.
  • Use EventEmitter for decoupled event propagation (e.g., plugin systems, observability).
  • Avoid blocking the HTTP layer by isolating the Event Loop to non-web contexts.

When to Consider This Package

Adopt When:

• PHP 8.2+ Projects: Mandatory for new development; leverages modern PHP features (e.g., attributes, fibers) and avoids legacy constraints.
• Non-Blocking I/O Requirements: Building systems where blocking calls (e.g., file I/O, network requests) would degrade performance:
  • Real-time systems: WebSocket servers, live updates, or interactive CLI tools.
  • High-throughput CLI tools: Batch processing, scraping, or API polling with low latency.
  • Custom HTTP servers: Internal tools or microservices where Laravel’s HTTP stack is overkill.
• Async Workflows Outside HTTP: Tasks that cannot use Laravel’s queues/events (e.g., Artisan commands, daemons, or plugins).
• Replacing Custom Async Code: Eliminating ad-hoc event systems, pcntl/pthreads hacks, or ReactPHP for a lighter-weight alternative.
• Coroutines for Complex Async Logic: Need to sequence async operations elegantly (e.g., retries, timeouts, or conditional flows) without callbacks or Promises hell.
• Decoupled Event Systems: Building plugin architectures or observability layers where events must propagate dynamically (e.g., wildcard listeners).
• Performance-Critical Async: Tasks where synchronous code would bottleneck (e.g., streaming, high-frequency polling, or parallel processing).

Avoid When:

• PHP <8.2: Use v6.0.x (PHP 7.4–8.1) or alternatives like ReactPHP for legacy stacks. The PHP 8.2 requirement is non-negotiable for v6.1+.
• Laravel’s Queues/Events Suffice: For most HTTP workflows, Laravel’s Bus or Events are simpler and more integrated. Overkill for:
  • Background jobs (use queue:work).
  • Simple event propagation (use Laravel’s Event facade).
  • HTTP request/response cycles (avoid blocking the Event Loop).
• Minimal Async Needs: One-off scripts or cron jobs don’t justify the complexity. Use synchronous code or Laravel Queues instead.
• Tight Laravel Integration: The Event Loop can block HTTP requests if misused. Avoid in:
  • Route handlers (use middleware or queues).
  • Middleware (risk of deadlocks).
  • Service containers (prefer Laravel’s DI).
• No PHP 8.2 Upgrade Path: Migration costs may outweigh benefits for teams stuck on PHP 7.x or earlier.
• Existing Async Frameworks: If already using ReactPHP, Swoole, or RoadRunner, evaluate integration risks before switching.
• Simple Promises: For basic Promise usage, Laravel’s Promise facade or native PHP Promises (PHP 8.1+) may suffice.

How to Pitch It (Stakeholders)

For Executives:

*"This package future-proofs our async capabilities by enforcing PHP 8.2+, aligning with Laravel’s roadmap and reducing legacy maintenance costs. It’s a turnkey solution for building real-time systems (e.g., live dashboards, WebSocket APIs) or high-performance CLI tools—cutting development time by 30% compared to custom async code.

Key Benefits:

• Reduces technical debt: Eliminates reinventing Promises, Event Loops, or Coroutines.
• Scales async workflows: Handles 10K+ concurrent operations without external services (e.g., Redis).
• Low-risk adoption: Backed by SabreIO (350+ stars), with enterprise support available.
• PHP 8.2+ requirement simplifies long-term upgrades and aligns with Laravel’s async improvements.

Use Cases:

• Real-time APIs: Replace Pusher/Socket.io with a self-hosted WebSocket server.
• CLI automation: Process batch jobs 10x faster than synchronous loops.
• Microservices: Decouple services with event-driven communication.

ROI: $X saved in dev time and $Y in infrastructure (no Redis/queue costs for simple async tasks). Payback period: <6 months for high-impact projects."*

For Engineering:

*"Sabre/event is a lightweight, modern alternative to ReactPHP or custom async code, with PHP 8.2+ focus and strict typing. Here’s how to leverage it:

---

When to Use It

Scenario	Solution	Avoid
WebSocket server	Event Loop + Promises	Laravel HTTP layer
CLI async batch jobs	Coroutines + Event Loop	Synchronous loops
Plugin event system	WildcardEmitterTrait	Laravel Events (if simple)
High-throughput API polling	Promise\all + Event Loop	Queues (if latency is critical)
Custom HTTP server	EmitterTrait + non-blocking I/O	Laravel routes

---

Key Trade-offs

Pros:

• Modern PHP 8.2+: Aligns with Laravel’s async roadmap (e.g., Fibers, PendingDispatch).
• Batteries-included: Promises, Event Loop, Coroutines—no dependencies beyond PHP.
• Performance: Non-blocking I/O outperforms synchronous code for async tasks.
• Type safety: Strict typing reduces runtime errors.
• Lightweight: Smaller footprint than ReactPHP/Swo