@stream-io/feeds-client 1.0.0 → 1.2.0

package/src/feed/event-handlers/feed-member/handle-feed-member-updated.ts

@@ -1,10 +1,33 @@
 import type { Feed, FeedState } from '../../../feed';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+
+export type FeedMemberUpdatedPayload = PartializeAllBut<
+  EventPayload<'feeds.feed_member.updated'>,
+  'member'
+>;
 
 export function handleFeedMemberUpdated(
   this: Feed,
-  event: EventPayload<'feeds.feed_member.updated'>,
+  event: FeedMemberUpdatedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'feed-member-updated'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        event,
+      ),
+    })
+  ) {
+    return;
+  }
+
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
 
   this.state.next((currentState) => {

package/src/feed/event-handlers/follow/handle-follow-updated.ts

@@ -37,6 +37,13 @@ export function handleFollowUpdated(
         ...currentState,
         // Update FeedResponse fields, that has the new follower/following count
         ...follow.source_feed,
+        ...(follow.source_feed.own_capabilities !== undefined
+          ? {
+              own_capabilities: follow.source_feed.own_capabilities,
+              own_follows: follow.source_feed.own_follows,
+              own_followings: follow.source_feed.own_followings,
+            }
+          : {}),
       };
 
       const index =
@@ -58,6 +65,13 @@ export function handleFollowUpdated(
         ...currentState,
         // Update FeedResponse fields, that has the new follower/following count
         ...follow.target_feed,
+        ...(follow.target_feed.own_capabilities !== undefined
+          ? {
+              own_capabilities: follow.target_feed.own_capabilities,
+              own_follows: follow.target_feed.own_follows,
+              own_followings: follow.target_feed.own_followings,
+            }
+          : {}),
       };
 
       if (

package/src/feed/event-handlers/notification-feed/handle-notification-feed-updated.ts

@@ -1,5 +1,6 @@
 import type { Feed } from '../..';
 import type {
+  ActivityResponse,
   AggregatedActivityResponse,
   NotificationFeedUpdatedEvent,
   NotificationStatusResponse,
@@ -35,15 +36,18 @@ export const updateNotificationFeedFromEvent = (
   event: NotificationFeedUpdatedEvent,
   currentAggregatedActivities?: AggregatedActivityResponse[],
   currentNotificationStatus?: NotificationStatusResponse,
+  currentActivities?: ActivityResponse[],
 ): UpdateStateResult<{
   data?: {
     notification_status?: NotificationStatusResponse;
     aggregated_activities?: AggregatedActivityResponse[];
+    activities?: ActivityResponse[];
   };
 }> => {
   const updates: {
     notification_status?: NotificationStatusResponse;
     aggregated_activities?: AggregatedActivityResponse[];
+    activities?: ActivityResponse[];
   } = {};
 
   if (event.notification_status) {
@@ -58,11 +62,67 @@ export const updateNotificationFeedFromEvent = (
     }
   }
 
+  // Determine effective notification status (prefer new from event, fall back to current)
+  const effectiveStatus =
+    event.notification_status ?? currentNotificationStatus;
+  const lastReadAt = effectiveStatus?.last_read_at;
+  const lastSeenAt = effectiveStatus?.last_seen_at;
+  const readActivities = effectiveStatus?.read_activities ?? [];
+  const seenActivities = effectiveStatus?.seen_activities ?? [];
+
+  // For flat feeds — update currentActivities with is_read/is_seen
+  if (currentActivities?.length && effectiveStatus) {
+    let anyChanged = false;
+    const updatedActivities = currentActivities.map((activity) => {
+      const isRead =
+        (lastReadAt != null &&
+          activity.updated_at.getTime() < lastReadAt.getTime()) ||
+        readActivities.includes(activity.id);
+      const isSeen =
+        (lastSeenAt != null &&
+          activity.updated_at.getTime() < lastSeenAt.getTime()) ||
+        seenActivities.includes(activity.id);
+      if (activity.is_read !== isRead || activity.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...activity, is_read: isRead, is_seen: isSeen };
+      }
+      return activity;
+    });
+    if (anyChanged) {
+      updates.activities = updatedActivities;
+    }
+  }
+
+  // For aggregated feeds — update aggregated_activities with is_read/is_seen
+  if (currentAggregatedActivities?.length && effectiveStatus) {
+    const baseAggregated = currentAggregatedActivities;
+    let anyChanged = false;
+    const updatedAggregated = baseAggregated.map((group) => {
+      const isRead =
+        (lastReadAt != null &&
+          group.updated_at.getTime() < lastReadAt.getTime()) ||
+        readActivities.includes(group.group);
+      const isSeen =
+        (lastSeenAt != null &&
+          group.updated_at.getTime() < lastSeenAt.getTime()) ||
+        seenActivities.includes(group.group);
+      if (group.is_read !== isRead || group.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...group, is_read: isRead, is_seen: isSeen };
+      }
+      return group;
+    });
+    if (anyChanged) {
+      updates.aggregated_activities = updatedAggregated;
+    }
+  }
+
+  // Leave this to the end, because notification_status may not be 100% accurate (only includes last 100 activities)
   if (event.aggregated_activities && currentAggregatedActivities) {
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
-      currentAggregatedActivities,
-      'start',
+      updates.aggregated_activities ?? currentAggregatedActivities,
+      'replace-then-start',
     );
 
     if (aggregatedActivitiesResult.changed) {
@@ -91,11 +151,13 @@ export function handleNotificationFeedUpdated(
     event,
     this.currentState.aggregated_activities,
     this.currentState.notification_status,
+    this.currentState.activities,
   );
   if (result.changed) {
     this.state.partialNext({
       notification_status: result.data?.notification_status,
       aggregated_activities: result.data?.aggregated_activities,
+      activities: result.data?.activities ?? this.currentState.activities,
     });
   }
 }

package/src/feed/event-handlers/story-feeds/handle-story-feeds-updated.ts

@@ -79,7 +79,7 @@ export function updateStoriesFeedFromEvent(
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
       aggregatedActivities,
-      'replace',
+      'replace-then-end',
     );
 
     if (aggregatedActivitiesResult.changed) {

package/src/feed/feed.ts

@@ -38,9 +38,9 @@ import {
   handleBookmarkAdded,
   handleActivityDeleted,
   handleActivityRemovedFromFeed,
+  handleFeedDeleted,
   handleFeedUpdated,
   handleNotificationFeedUpdated,
-  handleActivityMarked,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
   handleActivityReactionUpdated,
@@ -50,6 +50,8 @@ import {
   addAggregatedActivitiesToState,
   updateNotificationStatus,
   handleStoriesFeedUpdated,
+  handleActivityPinned,
+  handleActivityUnpinned,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
@@ -181,7 +183,7 @@ export class Feed extends FeedApi {
     'feeds.comment.deleted': handleCommentDeleted.bind(this),
     'feeds.comment.updated': handleCommentUpdated.bind(this),
     'feeds.feed.created': Feed.noop,
-    'feeds.feed.deleted': Feed.noop,
+    'feeds.feed.deleted': handleFeedDeleted.bind(this),
     'feeds.feed.updated': handleFeedUpdated.bind(this),
     'feeds.feed_group.changed': Feed.noop,
     'feeds.feed_group.deleted': Feed.noop,
@@ -204,9 +206,9 @@ export class Feed extends FeedApi {
     'feeds.poll.vote_casted': Feed.noop,
     'feeds.poll.vote_changed': Feed.noop,
     'feeds.poll.vote_removed': Feed.noop,
-    'feeds.activity.pinned': Feed.noop,
-    'feeds.activity.unpinned': Feed.noop,
-    'feeds.activity.marked': handleActivityMarked.bind(this),
+    'feeds.activity.pinned': handleActivityPinned.bind(this),
+    'feeds.activity.unpinned': handleActivityUnpinned.bind(this),
+    'feeds.activity.marked': Feed.noop,
     'moderation.custom_action': Feed.noop,
     'moderation.flagged': Feed.noop,
     'moderation.mark_reviewed': Feed.noop,