@stream-io/feeds-client 0.1.10 → 0.2.0

package/src/{Feed.ts → feed/feed.ts}

@@ -8,55 +8,49 @@ import {
   ActivityResponse,
   CommentResponse,
   PagerResponse,
-  SingleFollowRequest,
-  CommentReactionAddedEvent,
-  CommentReactionDeletedEvent,
-  BookmarkAddedEvent,
-  BookmarkDeletedEvent,
-  BookmarkUpdatedEvent,
   QueryFeedMembersRequest,
   SortParamRequest,
-  FollowResponse,
   ThreadedCommentResponse,
-} from './gen/models';
-import { StateStore } from './common/StateStore';
-import { EventDispatcher } from './common/EventDispatcher';
-import { FeedApi } from './gen/feeds/FeedApi';
-import { FeedsClient } from './FeedsClient';
-import {
-  addActivitiesToState,
-  updateActivityInState,
-  removeActivityFromState,
-} from './state-updates/activity-utils';
-import {
-  addReactionToActivities,
-  removeReactionFromActivities,
-} from './state-updates/activity-reaction-utils';
-import {
-  addBookmarkToActivities,
-  removeBookmarkFromActivities,
-  updateBookmarkInActivities,
-} from './state-updates/bookmark-utils';
+  FollowRequest,
+} from '../gen/models';
+import { StreamResponse } from '../gen-imports';
+import { StateStore } from '../common/StateStore';
+import { EventDispatcher } from '../common/EventDispatcher';
+import { FeedApi } from '../gen/feeds/FeedApi';
+import { FeedsClient } from '../feeds-client';
 import {
+  handleFollowUpdated,
   handleFollowCreated,
   handleFollowDeleted,
-  handleFollowUpdated,
-} from './state-updates/follow-utils';
-import { StreamResponse } from './gen-imports';
-import { capitalize } from './common/utils';
+  handleCommentAdded,
+  handleCommentDeleted,
+  handleCommentUpdated,
+  handleBookmarkDeleted,
+  handleBookmarkUpdated,
+  handleActivityAdded,
+  addActivitiesToState,
+  handleActivityUpdated,
+  handleFeedMemberAdded,
+  handleFeedMemberRemoved,
+  handleFeedMemberUpdated,
+  handleCommentReaction,
+  handleBookmarkAdded,
+  handleActivityDeleted,
+  handleActivityRemovedFromFeed,
+  handleActivityReactionDeleted,
+  handleActivityReactionAdded,
+  handleFeedUpdated,
+  handleNotificationFeedUpdated,
+} from './event-handlers';
+import { capitalize } from '../common/utils';
 import type {
   ActivityIdOrCommentId,
   GetCommentsRepliesRequest,
   GetCommentsRequest,
   LoadingStates,
   PagerResponseWithLoadingStates,
-} from './types';
-import { checkHasAnotherPage, Constants, uniqueArrayMerge } from './utils';
-import {
-  getStateUpdateQueueIdForFollow,
-  getStateUpdateQueueIdForUnfollow,
-  shouldUpdateState,
-} from './state-updates/state-update-queue';
+} from '../types';
+import { checkHasAnotherPage, Constants, uniqueArrayMerge } from '../utils';
 
 export type FeedState = Omit<
   Partial<GetOrCreateFeedResponse & FeedResponse>,
@@ -143,293 +137,40 @@ type EventHandlerByEventType = {
 export class Feed extends FeedApi {
   readonly state: StateStore<FeedState>;
   private static readonly noop = () => {};
-  private readonly stateUpdateQueue: Set<string> = new Set();
+  protected readonly stateUpdateQueue: Set<string> = new Set();
 
   private readonly eventHandlers: EventHandlerByEventType = {
-    'feeds.activity.added': (event) => {
-      const currentActivities = this.currentState.activities;
-      const result = addActivitiesToState(
-        [event.activity],
-        currentActivities,
-        'start',
-      );
-      if (result.changed) {
-        this.client.hydratePollCache([event.activity]);
-        this.state.partialNext({ activities: result.activities });
-      }
-    },
-    'feeds.activity.deleted': (event) => {
-      const currentActivities = this.currentState.activities;
-      if (currentActivities) {
-        const result = removeActivityFromState(
-          event.activity,
-          currentActivities,
-        );
-        if (result.changed) {
-          this.state.partialNext({ activities: result.activities });
-        }
-      }
-    },
-    'feeds.activity.reaction.added': (event) => {
-      const currentActivities = this.currentState.activities;
-      const connectedUser = this.client.state.getLatestValue().connected_user;
-      const isCurrentUser = Boolean(
-        connectedUser && event.reaction.user.id === connectedUser.id,
-      );
-
-      const result = addReactionToActivities(
-        event,
-        currentActivities,
-        isCurrentUser,
-      );
-      if (result.changed) {
-        this.state.partialNext({ activities: result.activities });
-      }
-    },
-    'feeds.activity.reaction.deleted': (event) => {
-      const currentActivities = this.currentState.activities;
-      const connectedUser = this.client.state.getLatestValue().connected_user;
-      const isCurrentUser = Boolean(
-        connectedUser && event.reaction.user.id === connectedUser.id,
-      );
-
-      const result = removeReactionFromActivities(
-        event,
-        currentActivities,
-        isCurrentUser,
-      );
-      if (result.changed) {
-        this.state.partialNext({ activities: result.activities });
-      }
-    },
+    'feeds.activity.added': handleActivityAdded.bind(this),
+    'feeds.activity.deleted': handleActivityDeleted.bind(this),
+    'feeds.activity.reaction.added': handleActivityReactionAdded.bind(this),
+    'feeds.activity.reaction.deleted': handleActivityReactionDeleted.bind(this),
     'feeds.activity.reaction.updated': Feed.noop,
-    'feeds.activity.removed_from_feed': (event) => {
-      const currentActivities = this.currentState.activities;
-      if (currentActivities) {
-        const result = removeActivityFromState(
-          event.activity,
-          currentActivities,
-        );
-        if (result.changed) {
-          this.state.partialNext({ activities: result.activities });
-        }
-      }
-    },
-    'feeds.activity.updated': (event) => {
-      const currentActivities = this.currentState.activities;
-      if (currentActivities) {
-        const result = updateActivityInState(event.activity, currentActivities);
-        if (result.changed) {
-          this.client.hydratePollCache([event.activity]);
-          this.state.partialNext({ activities: result.activities });
-        }
-      }
-    },
-    'feeds.bookmark.added': this.handleBookmarkAdded.bind(this),
-    'feeds.bookmark.deleted': this.handleBookmarkDeleted.bind(this),
-    'feeds.bookmark.updated': this.handleBookmarkUpdated.bind(this),
+    'feeds.activity.removed_from_feed':
+      handleActivityRemovedFromFeed.bind(this),
+    'feeds.activity.updated': handleActivityUpdated.bind(this),
+    'feeds.bookmark.added': handleBookmarkAdded.bind(this),
+    'feeds.bookmark.deleted': handleBookmarkDeleted.bind(this),
+    'feeds.bookmark.updated': handleBookmarkUpdated.bind(this),
     'feeds.bookmark_folder.deleted': Feed.noop,
     'feeds.bookmark_folder.updated': Feed.noop,
-    'feeds.comment.added': (event) => {
-      const { comment } = event;
-      const forId = comment.parent_id ?? comment.object_id;
-
-      this.state.next((currentState) => {
-        const entityState = currentState.comments_by_entity_id[forId];
-        const newComments = entityState?.comments?.concat([]) ?? [];
-
-        if (
-          entityState?.pagination?.sort === 'last' &&
-          !checkHasAnotherPage(
-            entityState.comments,
-            entityState?.pagination.next,
-          )
-        ) {
-          newComments.unshift(comment);
-        } else if (entityState?.pagination?.sort === 'first') {
-          newComments.push(comment);
-        } else {
-          // no other sorting option is supported yet
-          return currentState;
-        }
-
-        return {
-          ...currentState,
-          comments_by_entity_id: {
-            ...currentState.comments_by_entity_id,
-            [forId]: {
-              ...currentState.comments_by_entity_id[forId],
-              comments: newComments,
-            },
-          },
-        };
-      });
-    },
-    'feeds.comment.deleted': ({ comment }) => {
-      const forId = comment.parent_id ?? comment.object_id;
-
-      this.state.next((currentState) => {
-        const newCommentsByEntityId = {
-          ...currentState.comments_by_entity_id,
-          [forId]: {
-            ...currentState.comments_by_entity_id[forId],
-          },
-        };
-
-        const index = this.getCommentIndex(comment, currentState);
-
-        if (newCommentsByEntityId?.[forId]?.comments?.length && index !== -1) {
-          newCommentsByEntityId[forId].comments = [
-            ...newCommentsByEntityId[forId].comments,
-          ];
-
-          newCommentsByEntityId[forId]?.comments?.splice(index, 1);
-        }
-
-        delete newCommentsByEntityId[comment.id];
-
-        return {
-          ...currentState,
-          comments_by_entity_id: newCommentsByEntityId,
-        };
-      });
-    },
-    'feeds.comment.updated': (event) => {
-      const { comment } = event;
-      const forId = comment.parent_id ?? comment.object_id;
-
-      this.state.next((currentState) => {
-        const entityState = currentState.comments_by_entity_id[forId];
-
-        if (!entityState?.comments?.length) return currentState;
-
-        const index = this.getCommentIndex(comment, currentState);
-
-        if (index === -1) return currentState;
-
-        const newComments = [...entityState.comments];
-
-        newComments[index] = comment;
-
-        return {
-          ...currentState,
-          comments_by_entity_id: {
-            ...currentState.comments_by_entity_id,
-            [forId]: {
-              ...currentState.comments_by_entity_id[forId],
-              comments: newComments,
-            },
-          },
-        };
-      });
-    },
+    'feeds.comment.added': handleCommentAdded.bind(this),
+    'feeds.comment.deleted': handleCommentDeleted.bind(this),
+    'feeds.comment.updated': handleCommentUpdated.bind(this),
     'feeds.feed.created': Feed.noop,
     'feeds.feed.deleted': Feed.noop,
-    'feeds.feed.updated': (event) => {
-      this.state.partialNext({ ...event.feed });
-    },
+    'feeds.feed.updated': handleFeedUpdated.bind(this),
     'feeds.feed_group.changed': Feed.noop,
     'feeds.feed_group.deleted': Feed.noop,
-    'feeds.follow.created': (event) => {
-      this.handleFollowCreated(event.follow);
-    },
-    'feeds.follow.deleted': (event) => {
-      this.handleFollowDeleted(event.follow);
-    },
-    'feeds.follow.updated': (_event) => {
-      const result = handleFollowUpdated(this.currentState);
-      if (result.changed) {
-        this.state.next(result.data);
-      }
-    },
-    'feeds.comment.reaction.added': this.handleCommentReactionEvent.bind(this),
-    'feeds.comment.reaction.deleted':
-      this.handleCommentReactionEvent.bind(this),
+    'feeds.follow.created': handleFollowCreated.bind(this),
+    'feeds.follow.deleted': handleFollowDeleted.bind(this),
+    'feeds.follow.updated': handleFollowUpdated.bind(this),
+    'feeds.comment.reaction.added': handleCommentReaction.bind(this),
+    'feeds.comment.reaction.deleted': handleCommentReaction.bind(this),
     'feeds.comment.reaction.updated': Feed.noop,
-    'feeds.feed_member.added': (event) => {
-      const { connected_user: connectedUser } =
-        this.client.state.getLatestValue();
-
-      this.state.next((currentState) => {
-        let newState: FeedState | undefined;
-
-        if (typeof currentState.members !== 'undefined') {
-          newState ??= {
-            ...currentState,
-          };
-
-          newState.members = [event.member, ...currentState.members];
-        }
-
-        if (connectedUser?.id === event.member.user.id) {
-          newState ??= {
-            ...currentState,
-          };
-
-          newState.own_membership = event.member;
-        }
-
-        return newState ?? currentState;
-      });
-    },
-    'feeds.feed_member.removed': (event) => {
-      const { connected_user: connectedUser } =
-        this.client.state.getLatestValue();
-
-      this.state.next((currentState) => {
-        const newState = {
-          ...currentState,
-          members: currentState.members?.filter(
-            (member) => member.user.id !== event.user?.id,
-          ),
-        };
-
-        if (connectedUser?.id === event.member_id) {
-          delete newState.own_membership;
-        }
-
-        return newState;
-      });
-    },
-    'feeds.feed_member.updated': (event) => {
-      const { connected_user: connectedUser } =
-        this.client.state.getLatestValue();
-
-      this.state.next((currentState) => {
-        const memberIndex =
-          currentState.members?.findIndex(
-            (member) => member.user.id === event.member.user.id,
-          ) ?? -1;
-
-        let newState: FeedState | undefined;
-
-        if (memberIndex !== -1) {
-          // if there's an index, there's a member to update
-          const newMembers = [...currentState.members!];
-          newMembers[memberIndex] = event.member;
-
-          newState ??= {
-            ...currentState,
-          };
-
-          newState.members = newMembers;
-        }
-
-        if (connectedUser?.id === event.member.user.id) {
-          newState ??= {
-            ...currentState,
-          };
-
-          newState.own_membership = event.member;
-        }
-
-        return newState ?? currentState;
-      });
-    },
-    'feeds.notification_feed.updated': (event) => {
-      console.info('notification feed updated', event);
-      // TODO: handle notification feed updates
-    },
+    'feeds.feed_member.added': handleFeedMemberAdded.bind(this),
+    'feeds.feed_member.removed': handleFeedMemberRemoved.bind(this),
+    'feeds.feed_member.updated': handleFeedMemberUpdated.bind(this),
+    'feeds.notification_feed.updated': handleNotificationFeedUpdated.bind(this),
     // the poll events should be removed from here
     'feeds.poll.closed': Feed.noop,
     'feeds.poll.deleted': Feed.noop,
@@ -464,7 +205,7 @@ export class Feed extends FeedApi {
   ) {
     super(client, groupId, id);
     this.state = new StateStore<FeedState>({
-      fid: `${groupId}:${id}`,
+      feed: `${groupId}:${id}`,
       group_id: groupId,
       id,
       ...(data ?? {}),
@@ -476,9 +217,9 @@ export class Feed extends FeedApi {
     this.client = client;
   }
 
-  private readonly client: FeedsClient;
+  protected readonly client: FeedsClient;
 
-  get fid() {
+  get feed() {
     return `${this.group}:${this.id}`;
   }
 
@@ -486,63 +227,6 @@ export class Feed extends FeedApi {
     return this.state.getLatestValue();
   }
 
-  private handleCommentReactionEvent(
-    event: (CommentReactionAddedEvent | CommentReactionDeletedEvent) & {
-      type: 'feeds.comment.reaction.added' | 'feeds.comment.reaction.deleted';
-    },
-  ) {
-    const { comment, reaction } = event;
-    const connectedUser = this.client.state.getLatestValue().connected_user;
-
-    this.state.next((currentState) => {
-      const forId = comment.parent_id ?? comment.object_id;
-      const entityState = currentState.comments_by_entity_id[forId];
-
-      const commentIndex = this.getCommentIndex(comment, currentState);
-
-      if (commentIndex === -1) return currentState;
-
-      const newComments = entityState?.comments?.concat([]) ?? [];
-
-      const commentCopy: Partial<CommentResponse> = { ...comment };
-
-      delete commentCopy.own_reactions;
-
-      const newComment: CommentResponse = {
-        ...newComments[commentIndex],
-        ...commentCopy,
-        // TODO: FIXME this should be handled by the backend
-        latest_reactions: commentCopy.latest_reactions ?? [],
-        reaction_groups: commentCopy.reaction_groups ?? {},
-      };
-
-      newComments[commentIndex] = newComment;
-
-      if (reaction.user.id === connectedUser?.id) {
-        if (event.type === 'feeds.comment.reaction.added') {
-          newComment.own_reactions = newComment.own_reactions.concat(
-            reaction,
-          ) ?? [reaction];
-        } else if (event.type === 'feeds.comment.reaction.deleted') {
-          newComment.own_reactions = newComment.own_reactions.filter(
-            (r) => r.type !== reaction.type,
-          );
-        }
-      }
-
-      return {
-        ...currentState,
-        comments_by_entity_id: {
-          ...currentState.comments_by_entity_id,
-          [forId]: {
-            ...entityState,
-            comments: newComments,
-          },
-        },
-      };
-    });
-  }
-
   async synchronize() {
     const { last_get_or_create_request_config } = this.state.getLatestValue();
     if (last_get_or_create_request_config?.watch) {
@@ -586,7 +270,7 @@ export class Feed extends FeedApi {
         this.stateUpdateQueue.clear();
         const responseCopy: Partial<
           StreamResponse<GetOrCreateFeedResponse>['feed'] &
-            StreamResponse<GetOrCreateFeedResponse>
+            StreamResponse<Omit<GetOrCreateFeedResponse, 'feed'>>
         > = {
           ...response,
           ...response.feed,
@@ -596,6 +280,8 @@ export class Feed extends FeedApi {
         delete responseCopy.metadata;
         delete responseCopy.duration;
 
+        // TODO: lazy-load comments from activities when comment_sort and comment_pagination are supported
+
         this.state.next((currentState) => {
           const nextState: FeedState = {
             ...currentState,
@@ -630,132 +316,10 @@ export class Feed extends FeedApi {
     }
   }
 
-  /**
-   * @internal
-   */
-  handleFollowCreated(follow: FollowResponse) {
-    if (
-      !shouldUpdateState({
-        stateUpdateId: getStateUpdateQueueIdForFollow(follow),
-        stateUpdateQueue: this.stateUpdateQueue,
-        watch: this.currentState.watch,
-      })
-    ) {
-      return;
-    }
-    const connectedUser = this.client.state.getLatestValue().connected_user;
-    const result = handleFollowCreated(
-      follow,
-      this.currentState,
-      this.fid,
-      connectedUser?.id,
-    );
-    if (result.changed) {
-      this.state.next(result.data);
-    }
-  }
-
-  /**
-   * @internal
-   */
-  handleFollowDeleted(
-    follow:
-      | FollowResponse
-      // Backend doesn't return the follow in delete follow response https://getstream.slack.com/archives/C06RK9WCR09/p1753176937507209
-      | { source_feed: { fid: string }; target_feed: { fid: string } },
-  ) {
-    if (
-      !shouldUpdateState({
-        stateUpdateId: getStateUpdateQueueIdForUnfollow(follow),
-        stateUpdateQueue: this.stateUpdateQueue,
-        watch: this.currentState.watch,
-      })
-    ) {
-      return;
-    }
-
-    const connectedUser = this.client.state.getLatestValue().connected_user;
-    const result = handleFollowDeleted(
-      follow,
-      this.currentState,
-      this.fid,
-      connectedUser?.id,
-    );
-    if (result.changed) {
-      this.state.next(result.data);
-    }
-  }
-
-  /**
-   * @internal
-   */
-  handleWatchStopped() {
-    this.state.partialNext({
-      watch: false,
-    });
-  }
-
-  /**
-   * @internal
-   */
-  handleWatchStarted() {
-    this.state.partialNext({
-      watch: true,
-    });
-  }
-
-  private handleBookmarkAdded(event: BookmarkAddedEvent) {
-    const currentActivities = this.currentState.activities;
-    const { connected_user: connectedUser } =
-      this.client.state.getLatestValue();
-    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-
-    const result = addBookmarkToActivities(
-      event,
-      currentActivities,
-      isCurrentUser,
-    );
-    if (result.changed) {
-      this.state.partialNext({ activities: result.activities });
-    }
-  }
-
-  private handleBookmarkDeleted(event: BookmarkDeletedEvent) {
-    const currentActivities = this.currentState.activities;
-    const { connected_user: connectedUser } =
-      this.client.state.getLatestValue();
-    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-
-    const result = removeBookmarkFromActivities(
-      event,
-      currentActivities,
-      isCurrentUser,
-    );
-    if (result.changed) {
-      this.state.partialNext({ activities: result.activities });
-    }
-  }
-
-  private handleBookmarkUpdated(event: BookmarkUpdatedEvent) {
-    const currentActivities = this.currentState.activities;
-    const { connected_user: connectedUser } =
-      this.client.state.getLatestValue();
-    const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
-
-    const result = updateBookmarkInActivities(
-      event,
-      currentActivities,
-      isCurrentUser,
-    );
-    if (result.changed) {
-      this.state.partialNext({ activities: result.activities });
-    }
-  }
-
   /**
    * Returns index of the provided comment object.
    */
-  private getCommentIndex(
+  protected getCommentIndex(
     comment: Pick<CommentResponse, 'object_id' | 'parent_id' | 'id'>,
     state?: FeedState,
   ) {
@@ -833,6 +397,8 @@ export class Feed extends FeedApi {
             restOfTheCommentResponse,
         );
 
+        const existingComments = newCommentsByEntityId[entityId]?.comments;
+
         newCommentsByEntityId[entityId] = {
           ...newCommentsByEntityId[entityId],
           entity_parent_id: item.entityParentId,
@@ -841,8 +407,12 @@ export class Feed extends FeedApi {
             next: item.next,
             sort: data.sort,
           },
-          comments: newCommentsByEntityId[entityId]?.comments
-            ? newCommentsByEntityId[entityId].comments?.concat(newComments)
+          comments: existingComments
+            ? uniqueArrayMerge(
+                existingComments,
+                newComments,
+                (comment) => comment.id,
+              )
             : newComments,
         };
       }
@@ -981,12 +551,9 @@ export class Feed extends FeedApi {
       base: () =>
         this.client.getCommentReplies({
           ...request,
-          comment_id: comment.id,
+          id: comment.id,
           // use known sort first (prevents broken pagination)
-          sort:
-            currentSort ??
-            request?.sort ??
-            Constants.DEFAULT_COMMENT_PAGINATION,
+          sort,
           next: currentNextCursor,
         }),
       entityParentId: comment.parent_id ?? comment.object_id,
@@ -1038,7 +605,7 @@ export class Feed extends FeedApi {
                   currentState[type],
                   follows,
                   (follow) =>
-                    `${follow.source_feed.fid}-${follow.target_feed.fid}`,
+                    `${follow.source_feed.feed}-${follow.target_feed.feed}`,
                 ),
           [paginationKey]: {
             ...currentState[paginationKey],
@@ -1112,7 +679,11 @@ export class Feed extends FeedApi {
       this.state.next((currentState) => ({
         ...currentState,
         members: currentState.members
-          ? uniqueArrayMerge(currentState.members, members, ({ user }) => user.id)
+          ? uniqueArrayMerge(
+              currentState.members,
+              members,
+              ({ user }) => user.id,
+            )
           : members,
         member_pagination: {
           ...currentState.member_pagination,
@@ -1145,7 +716,7 @@ export class Feed extends FeedApi {
    */
   async queryFollowers(request: Omit<QueryFollowsRequest, 'filter'>) {
     const filter: QueryFollowsRequest['filter'] = {
-      target_feed: this.fid,
+      target_feed: this.feed,
     };
 
     const response = await this.client.queryFollows({
@@ -1163,7 +734,7 @@ export class Feed extends FeedApi {
    */
   async queryFollowing(request: Omit<QueryFollowsRequest, 'filter'>) {
     const filter: QueryFollowsRequest['filter'] = {
-      source_feed: this.fid,
+      source_feed: this.feed,
     };
 
     const response = await this.client.queryFollows({
@@ -1176,13 +747,13 @@ export class Feed extends FeedApi {
 
   async follow(
     feedOrFid: Feed | string,
-    options?: Omit<SingleFollowRequest, 'source' | 'target'>,
+    options?: Omit<FollowRequest, 'source' | 'target'>,
   ) {
-    const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.fid;
+    const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.feed;
 
     const response = await this.client.follow({
       ...options,
-      source: this.fid,
+      source: this.feed,
       target: fid,
     });
 
@@ -1190,10 +761,10 @@ export class Feed extends FeedApi {
   }
 
   async unfollow(feedOrFid: Feed | string) {
-    const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.fid;
+    const fid = typeof feedOrFid === 'string' ? feedOrFid : feedOrFid.feed;
 
     const response = await this.client.unfollow({
-      source: this.fid,
+      source: this.feed,
       target: fid,
     });
 
@@ -1218,10 +789,10 @@ export class Feed extends FeedApi {
     });
   }
 
-  addActivity(request: Omit<ActivityRequest, 'fids'>) {
+  addActivity(request: Omit<ActivityRequest, 'feeds'>) {
     return this.feedsApi.addActivity({
       ...request,
-      fids: [this.fid],
+      feeds: [this.feed],
     });
   }