fix: three real bugs found in PR #82's post-merge code review

- MessageCreated and ParticipantCreated notifications had the same
  relation-loss-through-serialization bug ThreadCreated was fixed for
  in #82, but were never patched themselves: their models' "user"
  relation, attached only via setRelation(), is dropped when the
  ShouldQueue notification round-trips through SerializesModels (even
  on the sync connection). Every live-broadcast message/participant
  event was silently missing "user", breaking Thread.vue's sender name
  and MessageBubble's online dot. Fixed with the same explicit ->load().

- MessageService::threads() gained a 'messages' => latest()->limit(1)
  eager-load in #82 to power the Dashboard's message preview, but the
  method is shared with MessageController::index() (the GET /message
  JSON API), which silently started returning only 1 message per
  thread instead of the full history. Added an $onlyLatestMessage flag
  so only the Dashboard opts into the preview behavior; the API keeps
  its original full-list contract.

- Dashboard.vue's live-update handlers under- and over-reported unread
  counts: a live ThreadCreated always showed unread_count 0 even when
  the recipient (not the creator) genuinely had 1 unread opening
  message, and a live MessageCreated bumped unread_count even for
  messages the viewer sent themselves in another tab. Both now compare
  the message's sender against the current user.

All three came out of a code review of the already-merged #82; caught
via CI-matching PHPUnit runs (no local Reverb server) plus TDD-style
verification that each new test fails without its corresponding fix.

Author: ikidnapmyself

app/Http/Controllers/FrontEnd/DashboardController.php

@@ -22,7 +22,7 @@ public function index(MessageServiceInterface $messages)
     {
         /** @var User $user */
         $user = Auth::user();
-        $threads = $messages->threads($user);
+        $threads = $messages->threads($user, onlyLatestMessage: true);
 
         return view('dashboard', [
             'threads' => $threads->map(fn ($thread) => [

app/Interfaces/MessageServiceInterface.php

@@ -15,9 +15,11 @@ interface MessageServiceInterface
     /**
      * All threads that user is participating in.
      *
+     * @param  bool  $onlyLatestMessage  Eager-load only each thread's single latest message
+     *                                   (for a preview), instead of its full message history.
      * @return LengthAwarePaginator<int, Thread>
      */
-    public function threads(User $user): LengthAwarePaginator;
+    public function threads(User $user, bool $onlyLatestMessage = false): LengthAwarePaginator;
 
     /**
      * All threads that user is participating in, with new messages.

app/Notifications/MessageCreated.php

@@ -46,7 +46,7 @@ public function via($notifiable)
     public function toArray($notifiable)
     {
         return [
-            'payload' => (new MessageResource($this->message))->resolve(),
+            'payload' => (new MessageResource($this->message->load('user')))->resolve(),
         ];
     }
 

app/Notifications/ParticipantCreated.php

@@ -45,7 +45,7 @@ public function via($notifiable)
     public function toArray($notifiable)
     {
         return [
-            'payload' => (new ParticipantResource($this->participant))->resolve(),
+            'payload' => (new ParticipantResource($this->participant->load('user')))->resolve(),
         ];
     }
 }

app/Services/MessageService.php

@@ -33,12 +33,18 @@ public function __construct(ContactServiceInterface $contactService)
     /**
      * All threads that user is participating in.
      *
+     * @param  bool  $onlyLatestMessage  Eager-load only each thread's single latest message
+     *                                   (for a preview), instead of its full message history.
      * @return LengthAwarePaginator<int, Thread>
      */
-    public function threads(User $user): LengthAwarePaginator
+    public function threads(User $user, bool $onlyLatestMessage = false): LengthAwarePaginator
     {
+        $messagesRelation = $onlyLatestMessage
+            ? ['messages' => fn (Relation $query) => $query->latest()->limit(1)]
+            : ['messages'];
+
         return Thread::forUser($user->id)
-            ->with(['participants.user', 'messages' => fn (Relation $query) => $query->latest()->limit(1)])
+            ->with(array_merge(['participants.user'], $messagesRelation))
             ->withCount('messages')
             ->latest('updated_at')
             ->paginate();

resources/js/pages/Dashboard.vue

@@ -14,13 +14,15 @@ const threads = ref(props.threads)
 const { onlineUserIds } = useOnlinePresence()
 
 function transformThread(payload) {
+    const openingMessage = payload.attributes.messages?.[0]
+
     return {
         id: payload.id,
         subject: payload.attributes.subject,
         updated_at: 'just now',
-        unread_count: 0,
+        unread_count: openingMessage?.attributes?.user_id === props.auth?.id ? 0 : 1,
         messages_count: payload.attributes.messages?.length ?? 0,
-        last_message: payload.attributes.messages?.[0]?.attributes?.body ?? null,
+        last_message: openingMessage?.attributes?.body ?? null,
         participants: (payload.attributes.participants ?? []).map((p) => ({
             user: { id: p.attributes?.user?.attributes?.id, name: p.attributes?.user?.attributes?.name },
         })),
@@ -47,10 +49,14 @@ if (props.auth) {
                 return
             }
 
+            const isOwnMessage = payload.attributes?.user_id === props.auth?.id
+
             const updated = {
                 ...threads.value[index],
                 updated_at: 'just now',
-                unread_count: (threads.value[index].unread_count ?? 0) + 1,
+                unread_count: isOwnMessage
+                    ? (threads.value[index].unread_count ?? 0)
+                    : (threads.value[index].unread_count ?? 0) + 1,
                 messages_count: (threads.value[index].messages_count ?? 0) + 1,
                 last_message: payload.attributes?.body ?? threads.value[index].last_message,
             }

tests/Feature/MessageTest.php

@@ -50,6 +50,44 @@ public function test_message_controller_index_method()
         ]);
     }
 
+    /**
+     * The index endpoint must return each thread's full message history, not
+     * just a preview — MessageService::threads() is shared with the
+     * dashboard, which only wants a single-message preview, but this API
+     * endpoint (consumed outside the web dashboard) must keep receiving the
+     * complete list it always has.
+     *
+     * @return void
+     */
+    public function test_message_controller_index_method_returns_full_message_history()
+    {
+        $sender = User::factory()->create(['notify_via' => []]);
+        $recipient = User::factory()->create(['notify_via' => []]);
+
+        $thread = $this->service->newThread(
+            'Full history',
+            $sender,
+            ['type' => 'mood', 'payload' => ['mood' => 'happy', 'intensity' => 1], 'version' => '1.0'],
+            [$recipient->id]
+        );
+        $this->service->newMessage($thread, $sender, ['type' => 'mood', 'payload' => ['mood' => 'happy', 'intensity' => 2], 'version' => '1.0']);
+        $this->service->newMessage($thread, $sender, ['type' => 'mood', 'payload' => ['mood' => 'happy', 'intensity' => 3], 'version' => '1.0']);
+
+        $response = $this
+            ->actingAs($sender, 'api')
+            ->get(route('message'));
+
+        $response->assertOk();
+        $response->assertJson([
+            'data' => [
+                [
+                    'id' => $thread->id,
+                ],
+            ],
+        ]);
+        $response->assertJsonCount(3, 'data.0.attributes.messages');
+    }
+
     /**
      * Check store method of MessageController.
      *

tests/Unit/MessageTest.php

@@ -4,6 +4,7 @@
 
 use App\Interfaces\ContactServiceInterface;
 use App\Interfaces\MessageServiceInterface;
+use App\Models\Message;
 use App\Models\Participant;
 use App\Models\Thread;
 use App\Models\User;
@@ -294,6 +295,26 @@ public function test_service_method_new_message()
         $this->assertEquals($lastMessage, $lastInsertedMessage);
     }
 
+    /**
+     * Sending a message must not leave it counted as unread for its own
+     * sender — without marking the sender's own participant as read,
+     * userUnreadMessagesCount() would count the sender's own message against
+     * themselves.
+     *
+     * @return void
+     */
+    public function test_new_message_does_not_count_as_unread_for_its_sender()
+    {
+        $sender = User::factory()->create();
+        $recipient = User::factory()->create();
+
+        $thread = $this->service->newThread('Own message', $sender, $this->envelope(), [$recipient->id]);
+        $this->service->newMessage($thread, $sender, $this->envelope('meh'));
+
+        $this->assertSame(0, $thread->userUnreadMessagesCount($sender->id));
+        $this->assertSame(2, $thread->userUnreadMessagesCount($recipient->id));
+    }
+
     /**
      * Check if markAsRead method updates last read attribute.
      *
@@ -482,4 +503,61 @@ public function test_thread_created_toarray_reloads_participant_user_after_seria
 
         $this->assertCount(2, $participantUserNames);
     }
+
+    /**
+     * Same serialization round-trip gap as ThreadCreated, but for the
+     * message's "user" relation: MessageService::newMessage() only attaches
+     * it via setRelation(), so MessageCreated::toArray() must reload it
+     * itself rather than assume it survives dispatch.
+     *
+     * @return void
+     */
+    public function test_message_created_toarray_reloads_user_after_serialization_round_trip()
+    {
+        Notification::fake();
+
+        $sender = User::factory()->create(['notify_via' => ['broadcast']]);
+        $recipient = User::factory()->create(['notify_via' => ['broadcast']]);
+
+        $thread = $this->service->newThread('Serialization Round Trip', $sender, $this->envelope(), [$recipient->id]);
+        $message = $this->service->newMessage($thread, $sender, $this->envelope('meh'));
+
+        // Fetch a bare copy with "user" NOT loaded, mirroring what
+        // SerializesModels restores after unserialize().
+        $bareMessage = Message::findOrFail($message->id);
+
+        $notification = new MessageCreated($bareMessage);
+        $payload = $this->resolvedPayload($notification->toArray($recipient));
+
+        $this->assertSame($sender->name, Arr::get($payload, 'payload.attributes.user.attributes.name'));
+    }
+
+    /**
+     * Same serialization round-trip gap as ThreadCreated, but for the
+     * participant's "user" relation: MessageService::addParticipant() only
+     * attaches it via setRelation(), so ParticipantCreated::toArray() must
+     * reload it itself rather than assume it survives dispatch.
+     *
+     * @return void
+     */
+    public function test_participant_created_toarray_reloads_user_after_serialization_round_trip()
+    {
+        Notification::fake();
+
+        $sender = User::factory()->create(['notify_via' => ['broadcast']]);
+        $recipient = User::factory()->create(['notify_via' => ['broadcast']]);
+        $newParticipant = User::factory()->create(['notify_via' => ['broadcast']]);
+
+        $thread = $this->service->newThread('Serialization Round Trip', $sender, $this->envelope(), [$recipient->id]);
+        $participant = $this->service->addParticipant($thread, $newParticipant);
+
+        // Fetch a bare copy with "user" NOT loaded, mirroring what
+        // SerializesModels restores after unserialize().
+        $bareParticipant = Participant::findOrFail($participant->id);
+
+        $notification = new ParticipantCreated($bareParticipant);
+        $payload = $this->resolvedPayload($notification->toArray($recipient));
+
+        $this->assertSame($newParticipant->name, Arr::get($payload, 'payload.attributes.user.attributes.name'));
+    }
 }