Event Laravel Package

Technical Evaluation

Architecture Fit

• Event-Driven Patterns: Sabre/Event’s EventEmitter and Promise implementations align with Laravel’s event system but extend it with asynchronous primitives (e.g., coroutines, event loop). Ideal for non-HTTP contexts where Laravel’s synchronous Bus/Events fall short (e.g., WebSocket servers, CLI async workflows).
• Promise Integration: Compatible with ECMAScript 6 Promises, enabling interoperability with libraries like Guzzle or ReactPHP if needed. Laravel’s Bus uses Promises under the hood, but Sabre/Event’s event loop adds non-blocking I/O capabilities.
• Coroutines & Event Loop: Enables cooperative multitasking (e.g., yield for async waits), useful for high-throughput tasks (e.g., API polling, batch processing) where synchronous loops would bottleneck.
• Wildcard Listeners: Supports dynamic event routing (e.g., *), useful for plugin systems or modular architectures.

Integration Feasibility

• Laravel Compatibility:
  • HTTP Requests: Not recommended—the EventLoop can block PHP’s SAPI (e.g., Apache/Nginx). Use only in CLI/Artisan commands or custom workers.
  • Queues/Jobs: Can replace Laravel Queues for async task coordination (e.g., EventLoop::run() to process jobs without Redis).
  • Service Providers: Register Emitter instances as singletons for global event propagation.
• PHP 8.2 Requirement: Hard blocker for projects on older PHP versions. Laravel 10+ supports PHP 8.2, so this aligns with modern stacks.
• Type Safety: Strict typing (v6+) improves IDE support and reduces runtime errors, but requires adapting existing code to use typed listeners/Promises.

Technical Risk

Key Questions

1. Use Case Clarity:
   • Where will this be used? (CLI, WebSocket server, plugin system?)
   • Why not Laravel’s built-in Bus/Events? (Performance? Async primitives?)
2. PHP/Laravel Version:
   • Can the team migrate to PHP 8.2+ and Laravel 10+?
   • If not, is v6.0.x (PHP 7.4–8.1) a viable alternative?
3. Architecture Impact:
   • Will the EventLoop run in background processes (e.g., supervisor) or blocking HTTP?
   • How will this interact with Laravel’s dependency injection and service container?
4. Error Handling:
   • How will Promise rejections and event loop errors be logged/handled? (Laravel’s App\Exceptions\Handler may need extension.)
5. Testing:
   • Are there existing async tests (e.g., for Promises)? How will they adapt to Sabre/Event?
6. Maintenance:
   • Who will monitor updates (e.g., PHP 8.3+ compatibility)?
   • Is commercial support (via fruux) needed for enterprise use?

Integration Approach

Stack Fit

Migration Path

1. Assess PHP/Laravel Version:

   • PHP 8.2+: Use sabre/event:^6.1 (latest).
   • PHP 7.4–8.1: Use sabre/event:^6.0 (backported fixes).
   • PHP <7.4: Avoid; use ReactPHP or custom solutions.

2. Isolate Integration:

   • Step 1: Add to composer.json:

     composer require sabre/event "^6.1" --dev  # or "^6.0" for legacy
     

   • Step 2: Register Emitter in a service provider:

     $this->app->singleton(Sabre\Event\EmitterInterface::class, function () {
         return new Sabre\Event\Emitter();
     });
     

3. Bridge Laravel Events (Optional):

   • Create a facade to emit Laravel events via Sabre/Event:

     class SabreEventFacade {
         public static function emit(string $event, $data = null) {
             $emitter = app(Sabre\Event\EmitterInterface::class);
             $emitter->emit($event, $data);
         }
     }
     

4. Replace Synchronous Logic:

   • Before (synchronous):

     $result = someBlockingFunction();
     

   • After (async with coroutines):

     $generator = function () {
         $result = yield Sabre\Event\coroutine(function () {
             return someBlockingFunction();
         });
         return $result;
     };
     $result = Sabre\Event\EventLoop::run($generator());
     

5. Adapt Promises:

   • Replace Laravel’s Bus Promises with Sabre/Event’s:

     use Sabre\Event\Promise;
     
     $promise = Promise\resolve('data')
         ->then(function ($data) {
             return process($data);
         })
         ->otherwise(function (Throwable $e) {
             log($e);
         });
     

6. Event Loop for Workers:

   • Run async tasks in a separate process (e.g., artisan sabre:worker):

     // In a custom Artisan command
     Sabre\Event\EventLoop::run(function () {
         $emitter = app(Sabre\Event\EmitterInterface::class);
         $emitter->on('task', function ($data) {
             // Process async
         });
     });
     

Compatibility