// Generate event with zero boilerplate
php artisan verbs:event ContentViewed
 
class ContentViewed extends VerbEvent
{
    #[StateId(UserBehaviorState::class)]
    public int $user_id;
    
    public string $content_id;
    public array $context;
    
    public function validate()
    {
        Assert::that($this->user_id)->notEmpty();
        Assert::that($this->content_id)->notEmpty();
    }
    
    public function apply(UserBehaviorState $user)
    {
        // Build behavioral intelligence
        $category = $this->context['category'] ?? 'unknown';
        $user->category_preferences[$category] = 
            ($user->category_preferences[$category] ?? 0) + 1;
        
        // Track recent interactions for real-time recs
        $user->recent_content[] = [
            'content_id' => $this->content_id,
            'category' => $category,
            'viewed_at' => now(),
        ];
        
        // Keep performance optimal
        $user->recent_content = array_slice($user->recent_content, -50);
    }
    
    public function handle()
    {
        // Update read models
        UserContentInteraction::create([...]);
        
        // Trigger ML pipeline
        dispatch(new UpdateUserRecommendations($this->user_id));
    }
}
 
// Fire it and forget it
ContentViewed::fire(
    user_id: auth()->id(),
    content_id: $content->id,
    context: ['category' => $content->category, 'source' => 'homepage']
);

class UserBehaviorAggregate extends AggregateRoot
{
    public function viewContent(string $contentId, array $context = [])
    {
        $this->recordThat(new ContentViewed(
            userId: $this->uuid(),
            contentId: $contentId,
            timestamp: now(),
            context: $context
        ));
        
        return $this;
    }
}
 
// Usage with full enterprise features
UserBehaviorAggregate::retrieve($userId)
    ->viewContent($contentId, $context)
    ->persist();

// 📝 COMMAND: Capture behavioral gold
#[HandledBy(UserBehaviorAggregate::class)]
class RecordContentInteraction implements Command
{
    public function __construct(
        #[AggregateUuid] public string $userId,
        public string $contentId,
        public string $interactionType,
        public array $context,
        public Carbon $timestamp
    ) {}
}
 
// 📊 QUERY: Optimized recommendation projector
class RecommendationProjector extends Projector
{
    public function onContentViewed(ContentViewed $event)
    {
        // Build user preference matrix in real-time
        UserContentAffinity::updateOrCreate([
            'user_id' => $event->userId,
            'content_category' => $event->contentCategory,
        ], [
            'view_count' => DB::raw('view_count + 1'),
            'last_viewed_at' => $event->timestamp,
            'engagement_score' => $this->calculateEngagement($event),
        ]);
    }
}

class ContentInteractionOccurred implements ShouldBroadcast
{
    public function broadcastOn()
    {
        return new PrivateChannel("user.{$this->userId}.recommendations");
    }
    
    public function broadcastWith()
    {
        return [
            'interaction' => $this->interactionData,
            'recommendations' => $this->getUpdatedRecommendations(),
            'timestamp' => now()->toISOString(),
        ];
    }
}

// Frontend: Real-time recommendation magic ✨
Echo.private(`user.${userId}.recommendations`)
    .listen('ContentInteractionOccurred', (e) => {
        // Instant UI updates
        updateRecommendationCarousel(e.recommendations);
        
        // Track successful delivery
        trackRecommendationImpression(e.recommendations);
        
        // Smooth UX transitions
        animateContentDiscoveryChanges(e.interaction);
    });

class ProcessBehavioralDataListener implements ShouldQueue
{
    public $queue = 'behavioral-data';
    public $tries = 5;
    public $backoff = [1, 5, 10, 30, 60]; // Smart retry strategy
    
    public function handle(ContentViewed $event)
    {
        // 🔥 PRIORITY 1: Instant recommendations (< 50ms)
        dispatch(new UpdateRealtimeRecommendations($event))
            ->onQueue('real-time-recommendations');
        
        // ⚡ PRIORITY 2: ML preparation (< 5 minutes)
        dispatch(new PrepareMLTrainingData($event))
            ->onQueue('ml-training')
            ->delay(now()->addMinutes(5));
        
        // 📊 PRIORITY 3: Analytics (daily)
        dispatch(new UpdateAnalyticsDashboard($event))
            ->onQueue('analytics')
            ->delay(now()->addHours(24));
    }
}

# Install Verbs
composer require hirethunk/verbs
 
# Generate your first behavioral event
php artisan verbs:event ContentViewed

class ContentViewed extends VerbEvent
{
    #[StateId(UserBehaviorState::class)]
    public int $user_id;
    
    public string $content_id;
    public string $content_category;
    public array $context;
    
    public function apply(UserBehaviorState $userState)
    {
        // 🧠 Build behavioral intelligence
        $userState->category_views[$this->content_category] = 
            ($userState->category_views[$this->content_category] ?? 0) + 1;
        
        // ⚡ Store for real-time recommendations
        $userState->recent_content[] = [
            'content_id' => $this->content_id,
            'category' => $this->content_category,
            'viewed_at' => now(),
        ];
        
        // 🚀 Performance optimization
        $userState->recent_content = array_slice($userState->recent_content, -50);
    }
    
    public function handle()
    {
        // 📊 Update read models
        UserContentInteraction::create([...]);
        
        // 🤖 Trigger ML pipeline
        dispatch(new UpdateUserRecommendations($this->user_id));
    }
}

# Install Spatie Event Sourcing
composer require spatie/laravel-event-sourcing
php artisan event-sourcing:publish-migration
php artisan migrate

class UserBehaviorAggregate extends AggregateRoot
{
    public function recordContentView(string $contentId, array $context)
    {
        $this->recordThat(new ContentViewedEvent(
            userId: $this->uuid(),
            contentId: $contentId,
            context: $context,
            timestamp: now()
        ));
        
        return $this;
    }
}

class ProcessBehaviorForMLListener implements ShouldQueue
{
    public $queue = 'behavioral-ml';
    
    public function handle(ContentViewedEvent $event)
    {
        // 🧠 Extract ML features
        $features = $this->extractMLFeatures($event);
        
        // 💾 Store for batch training
        MLTrainingData::create([
            'user_id' => $event->userId,
            'features' => json_encode($features),
            'timestamp' => now(),
        ]);
        
        // 🎯 Trigger real-time updates
        dispatch(new UpdateRealtimeRecommendations($event->userId));
    }
}