feat: handle missing events in Feed

Author: xsahil03x

packages/stream_feeds/lib/src/state/event/handler/feed_event_handler.dart

@@ -10,7 +10,11 @@ import '../../../models/feed_data.dart';
 import '../../../models/feeds_reaction_data.dart';
 import '../../../models/follow_data.dart';
 import '../../../models/mark_activity_data.dart';
+import '../../../models/poll_data.dart';
+import '../../../models/poll_vote_data.dart';
 import '../../../repository/capabilities_repository.dart';
+import '../../../resolvers/resolvers.dart';
+import '../../../utils/filter.dart';
 import '../../feed_state.dart';
 
 import '../../query/feed_query.dart';
@@ -37,16 +41,8 @@ class FeedEventHandler with FeedCapabilitiesMixin implements StateEventHandler {
 
   @override
   Future<void> handleEvent(WsEvent event) async {
-    final fid = query.fid;
-
-    bool matchesQueryFilter(ActivityData activity) {
-      final filter = query.activityFilter;
-      if (filter == null) return true;
-      return filter.matches(activity);
-    }
-
     if (event is api.ActivityAddedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
       final activity = event.activity.toModel();
 
       final insertionAction = onNewActivity(query, activity, currentUserId);
@@ -59,10 +55,10 @@ class FeedEventHandler with FeedCapabilitiesMixin implements StateEventHandler {
     }
 
     if (event is api.ActivityUpdatedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
 
       final activity = event.activity.toModel();
-      if (!matchesQueryFilter(activity)) {
+      if (!activity.matches(query.activityFilter)) {
         // If the updated activity no longer matches the filter, remove it
         return state.onActivityRemoved(activity);
       }
@@ -72,169 +68,206 @@ class FeedEventHandler with FeedCapabilitiesMixin implements StateEventHandler {
     }
 
     if (event is api.ActivityDeletedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
       return state.onActivityRemoved(event.activity.toModel());
     }
 
-    if (event is api.ActivityReactionAddedEvent) {
-      if (event.fid != fid.rawValue) return;
+    if (event is api.ActivityRemovedFromFeedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+      return state.onActivityRemoved(event.activity.toModel());
+    }
 
-      final activity = event.activity.toModel();
-      if (!matchesQueryFilter(activity)) {
-        // If the reaction's activity no longer matches the filter, remove it
-        return state.onActivityRemoved(activity);
+    if (event is api.ActivityPinnedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+      return state.onActivityPinned(event.pinnedActivity.toModel());
+    }
+
+    if (event is api.ActivityUnpinnedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+      return state.onActivityUnpinned(event.pinnedActivity.activity.id);
+    }
+
+    if (event is api.ActivityFeedbackEvent) {
+      final payload = event.activityFeedback;
+      final userId = payload.user.id;
+
+      // Only process events for the current user
+      if (userId != currentUserId) return;
+
+      // Only handle hide action for now
+      if (payload.action == api.ActivityFeedbackEventPayloadAction.hide) {
+        return state.onActivityHidden(
+          activityId: payload.activityId,
+          hidden: payload.value == 'true',
+        );
       }
+    }
 
+    if (event is api.ActivityMarkEvent) {
+      if (event.fid != query.fid.rawValue) return;
+      return state.onActivityMarked(event.toModel());
+    }
+
+    if (event is api.ActivityReactionAddedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+
+      final activity = event.activity.toModel();
       final reaction = event.reaction.toModel();
       return state.onReactionAdded(activity, reaction);
     }
 
     if (event is api.ActivityReactionUpdatedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
 
       final activity = event.activity.toModel();
-      if (!matchesQueryFilter(activity)) {
-        // If the reaction's activity no longer matches the filter, remove it
-        return state.onActivityRemoved(activity);
-      }
-
       final reaction = event.reaction.toModel();
       return state.onReactionUpdated(activity, reaction);
     }
 
     if (event is api.ActivityReactionDeletedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
 
       final activity = event.activity.toModel();
-      if (!matchesQueryFilter(activity)) {
-        // If the reaction's activity no longer matches the filter, remove it
-        return state.onActivityRemoved(activity);
-      }
-
       final reaction = event.reaction.toModel();
       return state.onReactionRemoved(activity, reaction);
     }
 
-    if (event is api.ActivityPinnedEvent) {
-      if (event.fid != fid.rawValue) return;
-
-      final activity = event.pinnedActivity.activity.toModel();
-      if (!matchesQueryFilter(activity)) {
-        // If the pinned activity no longer matches the filter, remove it
-        return state.onActivityRemoved(activity);
-      }
-
-      return state.onActivityPinned(event.pinnedActivity.toModel());
-    }
-
-    if (event is api.ActivityUnpinnedEvent) {
-      if (event.fid != fid.rawValue) return;
-
-      final activity = event.pinnedActivity.activity.toModel();
-      if (!matchesQueryFilter(activity)) {
-        // If the unpinned activity no longer matches the filter, remove it
-        return state.onActivityRemoved(activity);
-      }
-
-      return state.onActivityUnpinned(event.pinnedActivity.activity.id);
-    }
-
-    if (event is api.ActivityMarkEvent) {
-      if (event.fid != fid.rawValue) return;
-      return state.onActivityMarked(event.toModel());
-    }
-
-    if (event is api.NotificationFeedUpdatedEvent) {
-      if (event.fid != fid.rawValue) return;
-      return state.onNotificationFeedUpdated(
-        event.aggregatedActivities?.map((it) => it.toModel()).toList(),
-        event.notificationStatus,
-      );
-    }
-
     if (event is api.BookmarkAddedEvent) {
       return state.onBookmarkAdded(event.bookmark.toModel());
     }
 
+    if (event is api.BookmarkUpdatedEvent) {
+      return state.onBookmarkUpdated(event.bookmark.toModel());
+    }
+
     if (event is api.BookmarkDeletedEvent) {
       return state.onBookmarkRemoved(event.bookmark.toModel());
     }
 
     if (event is api.CommentAddedEvent) {
-      if (event.fid != fid.rawValue) return;
-
-      final activity = event.activity.toModel();
-      if (!matchesQueryFilter(activity)) {
-        // If the comment's activity no longer matches the filter, remove it
-        return state.onActivityRemoved(activity);
-      }
-
+      if (event.fid != query.fid.rawValue) return;
       return state.onCommentAdded(event.comment.toModel());
     }
 
     if (event is api.CommentUpdatedEvent) {
-      if (event.fid != fid.rawValue) return;
-      // TODO: Match event activity against filter once available in the event
+      if (event.fid != query.fid.rawValue) return;
       return state.onCommentUpdated(event.comment.toModel());
     }
 
     if (event is api.CommentDeletedEvent) {
-      if (event.fid != fid.rawValue) return;
-      // TODO: Match event activity against filter once available in the event
+      if (event.fid != query.fid.rawValue) return;
       return state.onCommentRemoved(event.comment.toModel());
     }
 
+    if (event is api.CommentReactionAddedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+
+      final comment = event.comment.toModel();
+      final reaction = event.reaction.toModel();
+      return state.onCommentReactionAdded(comment, reaction);
+    }
+
+    if (event is api.CommentReactionUpdatedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+
+      final comment = event.comment.toModel();
+      final reaction = event.reaction.toModel();
+      return state.onCommentReactionUpdated(comment, reaction);
+    }
+
+    if (event is api.CommentReactionDeletedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+
+      final comment = event.comment.toModel();
+      final reaction = event.reaction.toModel();
+      return state.onCommentReactionRemoved(comment, reaction);
+    }
+
     if (event is api.FeedDeletedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
       return state.onFeedDeleted();
     }
 
     if (event is api.FeedUpdatedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
       return state.onFeedUpdated(event.feed.toModel());
     }
 
     if (event is api.FollowCreatedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
       return state.onFollowAdded(event.follow.toModel());
     }
 
     if (event is api.FollowDeletedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
       return state.onFollowRemoved(event.follow.toModel());
     }
 
     if (event is api.FollowUpdatedEvent) {
-      if (event.fid != fid.rawValue) return;
+      if (event.fid != query.fid.rawValue) return;
       return state.onFollowUpdated(event.follow.toModel());
     }
 
     // Member events are already handled in MemberListEventHandler
     if (event is api.FeedMemberRemovedEvent) return;
     if (event is api.FeedMemberUpdatedEvent) return;
 
-    if (event is api.StoriesFeedUpdatedEvent) {
-      if (event.fid != fid.rawValue) return;
+    if (event is api.NotificationFeedUpdatedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+      return state.onNotificationFeedUpdated(
+        event.notificationStatus,
+        event.aggregatedActivities?.map((it) => it.toModel()).toList(),
+      );
+    }
 
-      return state.onAggregatedActivitiesUpdated(
+    if (event is api.StoriesFeedUpdatedEvent) {
+      if (event.fid != query.fid.rawValue) return;
+      return state.onStoriesFeedUpdated(
         event.aggregatedActivities?.map((it) => it.toModel()).toList(),
       );
     }
 
-    if (event is api.ActivityFeedbackEvent) {
-      final payload = event.activityFeedback;
-      final userId = payload.user.id;
+    if (event is api.PollClosedFeedEvent) {
+      return state.onPollClosed(event.poll.id);
+    }
 
-      // Only process events for the current user
-      if (userId != currentUserId) return;
+    if (event is api.PollDeletedFeedEvent) {
+      return state.onPollDeleted(event.poll.id);
+    }
 
-      // Only handle hide action for now
-      if (payload.action == api.ActivityFeedbackEventPayloadAction.hide) {
-        return state.onActivityHidden(
-          activityId: payload.activityId,
-          hidden: payload.value == 'true',
-        );
-      }
+    if (event is api.PollUpdatedFeedEvent) {
+      final poll = event.poll.toModel();
+      return state.onPollUpdated(poll);
+    }
+
+    if (event is PollAnswerCastedFeedEvent) {
+      final poll = event.poll.toModel();
+      final answer = event.pollVote.toModel();
+      return state.onPollAnswerCasted(poll, answer);
+    }
+
+    if (event is api.PollVoteCastedFeedEvent) {
+      final poll = event.poll.toModel();
+      final vote = event.pollVote.toModel();
+      return state.onPollVoteCasted(poll, vote);
+    }
+
+    if (event is api.PollVoteChangedFeedEvent) {
+      final poll = event.poll.toModel();
+      final vote = event.pollVote.toModel();
+      return state.onPollVoteChanged(poll, vote);
+    }
+
+    if (event is PollAnswerRemovedFeedEvent) {
+      final poll = event.poll.toModel();
+      final answer = event.pollVote.toModel();
+      return state.onPollAnswerRemoved(poll, answer);
+    }
+
+    if (event is api.PollVoteRemovedFeedEvent) {
+      final poll = event.poll.toModel();
+      final vote = event.pollVote.toModel();
+      return state.onPollVoteRemoved(poll, vote);
     }
 
     // Handle other events if necessary