@stream-io/feeds-client 1.0.0 → 1.1.0

package/src/bindings/react/hooks/feed-state-hooks/useIsAggregatedActivitySeen.ts

@@ -1,30 +1,16 @@
-import { useMemo } from 'react';
-
-import { useFeedContext } from '../../contexts/StreamFeedContext';
-import { useNotificationStatus } from './useNotificationStatus';
 import type { Feed } from '../../../../feed';
 import type { AggregatedActivityResponse } from '../../../../gen/models';
 
+/**
+ * @deprecated use aggregatedActivity.is_seen instead
+ * @returns
+ */
 export const useIsAggregatedActivitySeen = ({
-  feed: feedFromProps,
+  feed: _,
   aggregatedActivity,
 }: {
   feed?: Feed;
   aggregatedActivity: AggregatedActivityResponse;
 }) => {
-  const feedFromContext = useFeedContext();
-  const feed = feedFromProps ?? feedFromContext;
-
-  const { seen_activities: seenActivities, last_seen_at: lastSeenAt } =
-    useNotificationStatus(feed) ?? {};
-
-  const group = aggregatedActivity.group;
-
-  return useMemo(
-    () =>
-      (lastSeenAt &&
-        aggregatedActivity.updated_at.getTime() < lastSeenAt.getTime()) ||
-      (seenActivities ?? []).includes(group),
-    [lastSeenAt, aggregatedActivity.updated_at, seenActivities, group],
-  );
+  return aggregatedActivity.is_seen;
 };

package/src/feed/event-handlers/activity/handle-activity-deleted.ts

@@ -3,7 +3,13 @@ import type {
   ActivityPinResponse,
   ActivityResponse,
 } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import type {
+  EventPayload,
+  PartializeAllBut,
+  UpdateStateResult,
+} from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
 
 export function removeActivityFromState(
   this: Feed,
@@ -45,10 +51,30 @@ export const removePinnedActivityFromState = (
   }
 };
 
+export type ActivityDeletedPayload = PartializeAllBut<
+  EventPayload<'feeds.activity.deleted'>,
+  'activity'
+>;
+
 export function handleActivityDeleted(
   this: Feed,
-  event: EventPayload<'feeds.activity.deleted'>,
+  event: ActivityDeletedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'activity-deleted'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        event,
+      ),
+    })
+  ) {
+    return;
+  }
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities,

package/src/feed/event-handlers/activity/handle-activity-feedback.ts

@@ -2,12 +2,16 @@ import { updateEntityInArray } from '../../../utils';
 import { isPin } from '../is-activity-pin';
 import type { Feed } from '../../feed';
 import type { EventPayload } from '../../../types-internal';
-import type { ActivityFeedbackEventPayload, ActivityPinResponse, ActivityResponse } from '../../../gen/models';
+import type {
+  ActivityFeedbackEventPayload,
+  ActivityPinResponse,
+  ActivityResponse,
+} from '../../../gen/models';
 
-const updateActivityFromFeedback = <
+export const updateActivityFromFeedback = <
   T extends ActivityResponse | ActivityPinResponse,
 >(
-  feedback: ActivityFeedbackEventPayload,
+  feedback: Pick<ActivityFeedbackEventPayload, 'activity_id' | 'value'>,
   activities: T[] | undefined,
 ) => {
   if (!activities) {
@@ -18,10 +22,16 @@ const updateActivityFromFeedback = <
   }
   return updateEntityInArray<T>({
     entities: activities,
-    matcher: (e) =>
-      isPin(e)
-        ? e.activity.id === feedback.activity_id
-        : e.id === feedback.activity_id,
+    matcher: (e) => {
+      const newHidden = feedback.value === 'true';
+      if (isPin(e)) {
+        return (
+          e.activity.id === feedback.activity_id &&
+          e.activity.hidden !== newHidden
+        );
+      }
+      return e.id === feedback.activity_id && e.hidden !== newHidden;
+    },
     updater: (e) => {
       if (isPin(e)) {
         return {

package/src/feed/event-handlers/activity/handle-activity-pinned.ts

@@ -1,11 +1,34 @@
 import type { ActivityPinResponse } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import type { Feed } from '../../feed';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+
+export type ActivityPinnedPayload = PartializeAllBut<
+  EventPayload<'feeds.activity.pinned'>,
+  'pinned_activity'
+>;
 
 export function handleActivityPinned(
   this: Feed,
-  event: EventPayload<'feeds.activity.pinned'>,
+  event: ActivityPinnedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'activity-pinned'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        event,
+      ),
+    })
+  ) {
+    return;
+  }
+
   this.state.next((currentState) => {
     const newState = {
       ...currentState,
@@ -17,7 +40,6 @@ export function handleActivityPinned(
     const pinnedActivity: ActivityPinResponse = {
       ...event.pinned_activity,
       user: event.user!,
-      feed: event.fid,
       updated_at: new Date(),
     };
 

package/src/feed/event-handlers/activity/handle-activity-unpinned.ts

@@ -1,10 +1,33 @@
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import type { Feed, FeedState } from '../../feed';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+
+export type ActivityUnpinnedPayload = PartializeAllBut<
+  EventPayload<'feeds.activity.unpinned'>,
+  'pinned_activity'
+>;
 
 export function handleActivityUnpinned(
   this: Feed,
-  event: EventPayload<'feeds.activity.unpinned'>,
+  event: ActivityUnpinnedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'activity-unpinned'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        event,
+      ),
+    })
+  ) {
+    return;
+  }
+
   this.state.next((currentState) => {
     let newState: FeedState | undefined;
 

package/src/feed/event-handlers/activity/index.ts

@@ -5,4 +5,6 @@ export * from './handle-activity-updated';
 export * from './handle-activity-reaction-added';
 export * from './handle-activity-reaction-deleted';
 export * from './handle-activity-reaction-updated';
-export * from './handle-activity-marked';
+export * from './handle-activity-pinned';
+export * from './handle-activity-unpinned';
+export * from './handle-activity-feedback';

package/src/feed/event-handlers/add-aggregated-activities-to-state.ts

@@ -6,7 +6,7 @@ import { updateActivity } from './activity-updater';
 export const addAggregatedActivitiesToState = (
   newAggregatedActivities: AggregatedActivityResponse[],
   aggregatedActivities: AggregatedActivityResponse[] | undefined,
-  position: 'start' | 'end' | 'replace',
+  position: 'start' | 'end' | 'replace-then-end' | 'replace-then-start',
 ) => {
   let result: UpdateStateResult<{
     aggregated_activities: AggregatedActivityResponse[];
@@ -58,11 +58,20 @@ export const addAggregatedActivitiesToState = (
           (a) => a.group,
         );
         break;
-      case 'replace':
+      case 'replace-then-end':
         result.aggregated_activities = replaceUniqueArrayMerge(
           aggregatedActivities ?? [],
           newAggregatedActivities,
           (a) => a.group,
+          'end',
+        );
+        break;
+      case 'replace-then-start':
+        result.aggregated_activities = replaceUniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group,
+          'start',
         );
         break;
     }

package/src/feed/event-handlers/bookmark/handle-bookmark-added.ts

@@ -2,10 +2,15 @@ import type { Feed } from '../../../feed';
 import type {
   ActivityPinResponse,
   ActivityResponse,
-  BookmarkAddedEvent,
 } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import { updateEntityInArray } from '../../../utils';
+import { isSameBookmark } from './handle-bookmark-deleted';
+
+export type BookmarkAddedPayload = PartializeAllBut<
+  EventPayload<'feeds.bookmark.added'>,
+  'bookmark'
+>;
 
 const sharedUpdateActivity = ({
   currentActivity,
@@ -13,7 +18,7 @@ const sharedUpdateActivity = ({
   eventBelongsToCurrentUser,
 }: {
   currentActivity: ActivityResponse;
-  event: BookmarkAddedEvent;
+  event: BookmarkAddedPayload;
   eventBelongsToCurrentUser: boolean;
 }): ActivityResponse => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
@@ -30,13 +35,16 @@ const sharedUpdateActivity = ({
 };
 
 export const addBookmarkToActivities = (
-  event: BookmarkAddedEvent,
+  event: BookmarkAddedPayload,
   activities: ActivityResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: activities,
-    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    matcher: (activity) =>
+      activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        !activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
     updater: (matchedActivity) =>
       sharedUpdateActivity({
         currentActivity: matchedActivity,
@@ -46,14 +54,18 @@ export const addBookmarkToActivities = (
   });
 
 export const addBookmarkToPinnedActivities = (
-  event: BookmarkAddedEvent,
+  event: BookmarkAddedPayload,
   pinnedActivities: ActivityPinResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: pinnedActivities,
     matcher: (pinnedActivity) =>
-      pinnedActivity.activity.id === event.bookmark.activity.id,
+      pinnedActivity.activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        !pinnedActivity.activity.own_bookmarks.some((b) =>
+          isSameBookmark(b, event.bookmark),
+        )),
     updater: (matchedPinnedActivity) => {
       const newActivity = sharedUpdateActivity({
         currentActivity: matchedPinnedActivity.activity,
@@ -72,10 +84,7 @@ export const addBookmarkToPinnedActivities = (
     },
   });
 
-export function handleBookmarkAdded(
-  this: Feed,
-  event: EventPayload<'feeds.bookmark.added'>,
-) {
+export function handleBookmarkAdded(this: Feed, event: BookmarkAddedPayload) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities,

package/src/feed/event-handlers/bookmark/handle-bookmark-deleted.ts

@@ -2,14 +2,16 @@ import type { Feed } from '../../../feed';
 import type {
   ActivityPinResponse,
   ActivityResponse,
-  BookmarkDeletedEvent,
   BookmarkResponse,
 } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import { updateEntityInArray } from '../../../utils';
 
-// Helper function to check if two bookmarks are the same
-// A bookmark is identified by activity_id + folder_id + user_id
+export type BookmarkDeletedPayload = PartializeAllBut<
+  EventPayload<'feeds.bookmark.deleted'>,
+  'bookmark'
+>;
+
 export const isSameBookmark = (
   bookmark1: BookmarkResponse,
   bookmark2: BookmarkResponse,
@@ -17,7 +19,8 @@ export const isSameBookmark = (
   return (
     bookmark1.user.id === bookmark2.user.id &&
     bookmark1.activity.id === bookmark2.activity.id &&
-    bookmark1.folder?.id === bookmark2.folder?.id
+    bookmark1.folder?.id === bookmark2.folder?.id &&
+    bookmark1.updated_at.getTime() === bookmark2.updated_at.getTime()
   );
 };
 
@@ -27,7 +30,7 @@ const sharedUpdateActivity = ({
   eventBelongsToCurrentUser,
 }: {
   currentActivity: ActivityResponse;
-  event: BookmarkDeletedEvent;
+  event: BookmarkDeletedPayload;
   eventBelongsToCurrentUser: boolean;
 }): ActivityResponse => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
@@ -46,13 +49,16 @@ const sharedUpdateActivity = ({
 };
 
 export const removeBookmarkFromActivities = (
-  event: BookmarkDeletedEvent,
+  event: BookmarkDeletedPayload,
   activities: ActivityResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: activities,
-    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    matcher: (activity) =>
+      activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
     updater: (matchedActivity) =>
       sharedUpdateActivity({
         currentActivity: matchedActivity,
@@ -62,14 +68,18 @@ export const removeBookmarkFromActivities = (
   });
 
 export const removeBookmarkFromPinnedActivities = (
-  event: BookmarkDeletedEvent,
+  event: BookmarkDeletedPayload,
   pinnedActivities: ActivityPinResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: pinnedActivities,
     matcher: (pinnedActivity) =>
-      pinnedActivity.activity.id === event.bookmark.activity.id,
+      pinnedActivity.activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        pinnedActivity.activity.own_bookmarks.some((b) =>
+          isSameBookmark(b, event.bookmark),
+        )),
     updater: (matchedPinnedActivity) => {
       const newActivity = sharedUpdateActivity({
         currentActivity: matchedPinnedActivity.activity,
@@ -90,7 +100,7 @@ export const removeBookmarkFromPinnedActivities = (
 
 export function handleBookmarkDeleted(
   this: Feed,
-  event: EventPayload<'feeds.bookmark.deleted'>,
+  event: BookmarkDeletedPayload,
 ) {
   const {
     activities: currentActivities,

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

@@ -2,27 +2,34 @@ import type { Feed } from '../../../feed';
 import type {
   ActivityPinResponse,
   ActivityResponse,
-  BookmarkUpdatedEvent,
 } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
 import { updateEntityInArray } from '../../../utils';
 
 import { isSameBookmark } from './handle-bookmark-deleted';
 
+export type BookmarkUpdatedPayload = PartializeAllBut<
+  EventPayload<'feeds.bookmark.updated'>,
+  'bookmark'
+>;
+
 const sharedUpdateActivity = ({
   currentActivity,
   event,
   eventBelongsToCurrentUser,
 }: {
   currentActivity: ActivityResponse;
-  event: BookmarkUpdatedEvent;
+  event: BookmarkUpdatedPayload;
   eventBelongsToCurrentUser: boolean;
 }): ActivityResponse => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
 
   if (eventBelongsToCurrentUser) {
-    const bookmarkIndex = newOwnBookmarks.findIndex((bookmark) =>
-      isSameBookmark(bookmark, event.bookmark),
+    const bookmarkIndex = newOwnBookmarks.findIndex(
+      (bookmark) =>
+        bookmark.user.id === event.bookmark.user.id &&
+        bookmark.activity.id === event.bookmark.activity.id &&
+        bookmark.folder?.id === event.bookmark.folder?.id,
     );
 
     if (bookmarkIndex !== -1) {
@@ -39,13 +46,16 @@ const sharedUpdateActivity = ({
 };
 
 export const updateBookmarkInActivities = (
-  event: BookmarkUpdatedEvent,
+  event: BookmarkUpdatedPayload,
   activities: ActivityResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: activities,
-    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    matcher: (activity) =>
+      activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        !activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
     updater: (matchedActivity) =>
       sharedUpdateActivity({
         currentActivity: matchedActivity,
@@ -55,14 +65,18 @@ export const updateBookmarkInActivities = (
   });
 
 export const updateBookmarkInPinnedActivities = (
-  event: BookmarkUpdatedEvent,
+  event: BookmarkUpdatedPayload,
   pinnedActivities: ActivityPinResponse[] | undefined,
   eventBelongsToCurrentUser: boolean,
 ) =>
   updateEntityInArray({
     entities: pinnedActivities,
     matcher: (pinnedActivity) =>
-      pinnedActivity.activity.id === event.bookmark.activity.id,
+      pinnedActivity.activity.id === event.bookmark.activity.id &&
+      (!eventBelongsToCurrentUser ||
+        !pinnedActivity.activity.own_bookmarks.some((b) =>
+          isSameBookmark(b, event.bookmark),
+        )),
     updater: (matchedPinnedActivity) => {
       const newActivity = sharedUpdateActivity({
         currentActivity: matchedPinnedActivity.activity,
@@ -83,7 +97,7 @@ export const updateBookmarkInPinnedActivities = (
 
 export function handleBookmarkUpdated(
   this: Feed,
-  event: EventPayload<'feeds.bookmark.updated'>,
+  event: BookmarkUpdatedPayload,
 ) {
   const {
     activities: currentActivities,

package/src/feed/event-handlers/feed/handle-feed-deleted.ts

@@ -0,0 +1,12 @@
+import type { Feed } from '../../../feed';
+import type { EventPayload } from '../../../types-internal';
+
+export function handleFeedDeleted(
+  this: Feed,
+  event: Pick<EventPayload<'feeds.feed.deleted'>, 'created_at'>,
+) {
+  if (this.currentState.deleted_at) {
+    return;
+  }
+  this.state.partialNext({ deleted_at: event.created_at });
+}

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

@@ -5,5 +5,13 @@ export function handleFeedUpdated(
   this: Feed,
   event: PartializeAllBut<EventPayload<'feeds.feed.updated'>, 'feed'>,
 ) {
+  const currentUpdatedAt = this.currentState.updated_at;
+  if (
+    currentUpdatedAt &&
+    event.feed.updated_at &&
+    currentUpdatedAt.getTime() >= event.feed.updated_at.getTime()
+  ) {
+    return;
+  }
   this.state.partialNext({ ...event.feed });
 }

package/src/feed/event-handlers/feed/index.ts

@@ -1 +1,2 @@
+export * from './handle-feed-deleted';
 export * from './handle-feed-updated';

package/src/feed/event-handlers/feed-member/handle-feed-member-added.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 FeedMemberAddedPayload = PartializeAllBut<
+  EventPayload<'feeds.feed_member.added'>,
+  'member'
+>;
 
 export function handleFeedMemberAdded(
   this: Feed,
-  event: EventPayload<'feeds.feed_member.added'>,
+  event: FeedMemberAddedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'feed-member-added'),
+      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/feed-member/handle-feed-member-removed.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 FeedMemberRemovedPayload = PartializeAllBut<
+  EventPayload<'feeds.feed_member.removed'>,
+  'member_id'
+>;
 
 export function handleFeedMemberRemoved(
   this: Feed,
-  event: EventPayload<'feeds.feed_member.removed'>,
+  event: FeedMemberRemovedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(event, 'feed-member-removed'),
+      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/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 (