@stream-io/feeds-client 0.2.15 → 0.2.17

package/src/feed/event-handlers/comment/handle-comment-reaction-updated.test.ts

@@ -0,0 +1,350 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed, handleCommentReactionUpdated } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import {
+  generateCommentResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+  generateFeedReactionResponse,
+  generateCommentReactionUpdatedEvent,
+} from '../../../test-utils';
+import type {
+  CommentResponse,
+  FeedsReactionResponse,
+} from '../../../gen/models';
+import { shouldUpdateState } from '../../../utils';
+import type { EventPayload } from '../../../types-internal';
+
+describe(handleCommentReactionUpdated.name, () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let currentUserId: string;
+  let activityId: string;
+
+  beforeEach(() => {
+    client = new FeedsClient('mock-api-key');
+    currentUserId = getHumanId();
+    client.state.partialNext({
+      connected_user: generateOwnUser({ id: currentUserId }),
+    });
+    const feedResponse = generateFeedResponse({
+      id: 'main',
+      group_id: 'user',
+      created_by: { id: currentUserId },
+    });
+    feed = new Feed(
+      client,
+      feedResponse.group_id,
+      feedResponse.id,
+      feedResponse,
+    );
+    activityId = `activity-${getHumanId()}`;
+  });
+
+  it('updates own_reactions for current user and updates comment fields from the event', () => {
+    const existingCommentId = `comment-${getHumanId()}`;
+    const existingReaction = generateFeedReactionResponse({
+      type: 'like',
+      user: { id: currentUserId },
+      activity_id: activityId,
+      comment_id: existingCommentId,
+    });
+    const existingComment = generateCommentResponse({
+      id: existingCommentId,
+      object_id: activityId,
+      latest_reactions: [],
+      reaction_groups: {},
+      own_reactions: [existingReaction],
+    });
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const event = generateCommentReactionUpdatedEvent({
+      comment: {
+        id: existingComment.id,
+        object_id: activityId,
+        latest_reactions: [],
+        reaction_groups: {},
+      },
+      reaction: {
+        type: 'downvote',
+        user: { id: currentUserId },
+        activity_id: activityId,
+        comment_id: existingCommentId,
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    const [initialReaction] = (stateBefore.comments_by_entity_id[activityId]
+      ?.comments ?? [])[0].own_reactions;
+    expect(
+      stateBefore.comments_by_entity_id[activityId]?.comments?.[0]
+        ?.own_reactions,
+    ).toHaveLength(1);
+    expect(initialReaction).toBe(existingReaction);
+
+    handleCommentReactionUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    const [updated] = stateAfter.comments_by_entity_id[activityId]!.comments!;
+    expect(updated.own_reactions).toHaveLength(1);
+    expect(updated.own_reactions[0]).toBe(event.reaction);
+    // ensure we used event's latest_reactions & reaction_groups (Object.is check)
+    expect(updated.latest_reactions).toBe(event.comment.latest_reactions);
+    expect(updated.reaction_groups).toBe(event.comment.reaction_groups);
+  });
+
+  it('does modify own_reactions if the target reaction belongs to another user', () => {
+    const existingComment = generateCommentResponse({
+      object_id: activityId,
+      latest_reactions: [],
+      reaction_groups: {},
+      own_reactions: [],
+    });
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const event = generateCommentReactionUpdatedEvent({
+      comment: {
+        id: existingComment.id,
+        object_id: activityId,
+        latest_reactions: [],
+        reaction_groups: {},
+      },
+      reaction: {
+        type: 'laugh',
+        user: { id: 'other-user' },
+        activity_id: activityId,
+        comment_id: existingComment.id,
+      },
+    });
+
+    handleCommentReactionUpdated.call(feed, event);
+    const stateAfter = feed.currentState;
+    const [updated] = stateAfter.comments_by_entity_id[activityId]!.comments!;
+    expect(updated.own_reactions).toHaveLength(0);
+    expect(updated.latest_reactions).toBe(event.comment.latest_reactions);
+    expect(updated.reaction_groups).toBe(event.comment.reaction_groups);
+  });
+
+  it('updates the proper entity state (prefers parent_id)', () => {
+    const parentId = `comment-${getHumanId()}`;
+    const existingCommentId = `comment-${getHumanId()}`;
+    const existingReaction = generateFeedReactionResponse({
+      type: 'like',
+      user: { id: currentUserId },
+      activity_id: activityId,
+      comment_id: existingCommentId,
+    });
+    const existingComment = generateCommentResponse({
+      id: existingCommentId,
+      object_id: activityId,
+      parent_id: parentId,
+      latest_reactions: [],
+      reaction_groups: {},
+      own_reactions: [existingReaction],
+    });
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [parentId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const addedEvent = generateCommentReactionUpdatedEvent({
+      comment: {
+        id: existingComment.id,
+        object_id: activityId,
+        parent_id: parentId,
+        latest_reactions: [],
+        reaction_groups: {},
+      },
+      reaction: {
+        type: 'downvote',
+        user: { id: currentUserId },
+        activity_id: activityId,
+        comment_id: existingComment.id,
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(
+      stateBefore.comments_by_entity_id[parentId]?.comments?.[0]?.own_reactions,
+    ).toHaveLength(1);
+    const [initialReaction] = (stateBefore.comments_by_entity_id[parentId]
+      ?.comments ?? [])[0].own_reactions;
+    expect(initialReaction).toBe(existingReaction);
+
+    handleCommentReactionUpdated.call(feed, addedEvent);
+    const stateAfter1 = feed.currentState;
+    const [updated1] = stateAfter1.comments_by_entity_id[parentId]!.comments!;
+    expect(updated1.own_reactions).toHaveLength(1);
+    expect(updated1.own_reactions[0]).toBe(addedEvent.reaction);
+    expect(updated1.latest_reactions).toBe(addedEvent.comment.latest_reactions);
+    expect(updated1.reaction_groups).toBe(addedEvent.comment.reaction_groups);
+  });
+
+  it('does nothing if comment is not found in state', () => {
+    const addedEvent = generateCommentReactionUpdatedEvent({
+      comment: { object_id: activityId },
+      reaction: { user: { id: currentUserId } },
+    });
+    const stateBefore = feed.currentState;
+
+    handleCommentReactionUpdated.call(feed, addedEvent);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  describe(`Comment reaction updated ${shouldUpdateState.name} integration`, () => {
+    let currentUserPayload: EventPayload<'feeds.comment.reaction.updated'>;
+    let existingComment: CommentResponse;
+    let existingReaction: FeedsReactionResponse;
+    let newReaction: FeedsReactionResponse;
+    let commentId: string;
+
+    beforeEach(() => {
+      commentId = `comment-${getHumanId()}`;
+      existingReaction = generateFeedReactionResponse({
+        type: 'heart',
+        user: { id: currentUserId },
+        activity_id: activityId,
+        comment_id: commentId,
+      });
+      newReaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: currentUserId },
+        activity_id: activityId,
+        comment_id: commentId,
+      });
+      existingComment = generateCommentResponse({
+        id: commentId,
+        object_id: activityId,
+        own_reactions: [existingReaction],
+      });
+
+      currentUserPayload = generateCommentReactionUpdatedEvent({
+        comment: existingComment,
+        reaction: newReaction,
+      });
+
+      feed.state.partialNext({
+        comments_by_entity_id: {
+          [activityId]: {
+            comments: [existingComment],
+            pagination: { sort: 'first' },
+          },
+        },
+      });
+      feed.state.partialNext({ watch: true });
+    });
+
+    it(`skips update if ${shouldUpdateState.name} returns false`, () => {
+      // 1. HTTP and then WS
+
+      handleCommentReactionUpdated.call(feed, currentUserPayload, false);
+
+      let stateBefore = feed.currentState;
+
+      handleCommentReactionUpdated.call(feed, currentUserPayload);
+
+      let stateAfter = feed.currentState;
+
+      expect(stateAfter).toBe(stateBefore);
+      // @ts-expect-error Using Feed internals for tests only
+      expect(feed.stateUpdateQueue.size).toEqual(0);
+
+      // 2. WS and the HTTP
+
+      handleCommentReactionUpdated.call(feed, currentUserPayload);
+
+      stateBefore = feed.currentState;
+
+      handleCommentReactionUpdated.call(feed, currentUserPayload, false);
+
+      stateAfter = feed.currentState;
+
+      expect(stateAfter).toBe(stateBefore);
+      // @ts-expect-error Using Feed internals for tests only
+      expect(feed.stateUpdateQueue.size).toEqual(0);
+    });
+
+    it('allows update again from WS after clearing the stateUpdateQueue', () => {
+      handleCommentReactionUpdated.call(feed, currentUserPayload);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another WS event
+      handleCommentReactionUpdated.call(feed, currentUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const comment = comments?.find((a) => a.id === commentId);
+      const [latestReaction] = (comment?.own_reactions ?? []).toReversed();
+
+      expect(comment?.own_reactions.length).toEqual(1);
+      expect(latestReaction).toMatchObject(newReaction);
+    });
+
+    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
+      handleCommentReactionUpdated.call(feed, currentUserPayload, false);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another HTTP response
+      handleCommentReactionUpdated.call(feed, currentUserPayload, false);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const comment = comments?.find((a) => a.id === commentId);
+      const [latestReaction] = (comment?.own_reactions ?? []).toReversed();
+
+      expect(comment?.own_reactions.length).toEqual(1);
+      expect(latestReaction).toMatchObject(newReaction);
+    });
+
+    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the comment reaction deletion', () => {
+      const otherUserPayload = generateCommentReactionUpdatedEvent({
+        comment: existingComment,
+        reaction: {
+          ...existingReaction,
+          user: {
+            id: getHumanId(),
+          },
+        },
+      });
+
+      handleCommentReactionUpdated.call(feed, otherUserPayload);
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+
+      handleCommentReactionUpdated.call(feed, otherUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const comment = comments?.find((a) => a.id === commentId);
+      const [latestReaction] = comment?.own_reactions ?? [];
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+      expect(comment?.own_reactions.length).toEqual(1);
+      expect(latestReaction).toMatchObject(existingReaction);
+    });
+  });
+});

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

@@ -0,0 +1,72 @@
+import type { Feed } from '../../feed';
+import type { EventPayload } from '../../../types-internal';
+import { type PartializeAllBut } from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+
+export type CommentReactionUpdatedPayload = PartializeAllBut<
+  EventPayload<'feeds.comment.reaction.updated'>,
+  'comment' | 'reaction'
+>;
+
+export function handleCommentReactionUpdated(
+  this: Feed,
+  payload: CommentReactionUpdatedPayload,
+  fromWs?: boolean,
+) {
+  const { comment, reaction } = payload;
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+
+  const isOwnReaction = reaction.user.id === connectedUser?.id;
+
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(
+        payload,
+        'comment-reaction-updated',
+      ),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: isOwnReaction,
+    })
+  ) {
+    return;
+  }
+
+  this.state.next((currentState) => {
+    const commentIndex = this.getCommentIndex(comment, currentState);
+
+    if (commentIndex === -1) return currentState;
+
+    const forId = comment.parent_id ?? comment.object_id;
+
+    const entityState = currentState.comments_by_entity_id[forId];
+
+    const newComments = entityState?.comments?.concat([]) ?? [];
+
+    let ownReactions = newComments[commentIndex].own_reactions;
+
+    if (isOwnReaction) {
+      ownReactions = [reaction];
+    }
+
+    newComments[commentIndex] = {
+      ...newComments[commentIndex],
+      reaction_count: comment.reaction_count ?? 0,
+      latest_reactions: comment.latest_reactions ?? [],
+      reaction_groups: comment.reaction_groups ?? {},
+      own_reactions: ownReactions,
+    };
+
+    return {
+      ...currentState,
+      comments_by_entity_id: {
+        ...currentState.comments_by_entity_id,
+        [forId]: {
+          ...entityState,
+          comments: newComments,
+        },
+      },
+    };
+  });
+}

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

@@ -3,4 +3,4 @@ export * from './handle-comment-deleted';
 export * from './handle-comment-updated';
 export * from './handle-comment-reaction-added';
 export * from './handle-comment-reaction-deleted';
-// export * from './handle-comment-reaction';
+export * from './handle-comment-reaction-updated';

package/src/feed/feed.ts

@@ -42,8 +42,10 @@ import {
   handleActivityMarked,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
+  handleActivityReactionUpdated,
   handleCommentReactionAdded,
   handleCommentReactionDeleted,
+  handleCommentReactionUpdated,
   addAggregatedActivitiesToState,
   updateNotificationStatus,
   handleStoriesFeedUpdated,
@@ -151,7 +153,7 @@ export class Feed extends FeedApi {
     '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.reaction.updated': handleActivityReactionUpdated.bind(this),
     'feeds.activity.removed_from_feed':
       handleActivityRemovedFromFeed.bind(this),
     'feeds.activity.updated': handleActivityUpdated.bind(this),
@@ -173,7 +175,7 @@ export class Feed extends FeedApi {
     'feeds.follow.updated': handleFollowUpdated.bind(this),
     'feeds.comment.reaction.added': handleCommentReactionAdded.bind(this),
     'feeds.comment.reaction.deleted': handleCommentReactionDeleted.bind(this),
-    'feeds.comment.reaction.updated': Feed.noop,
+    'feeds.comment.reaction.updated': handleCommentReactionUpdated.bind(this),
     'feeds.feed_member.added': handleFeedMemberAdded.bind(this),
     'feeds.feed_member.removed': handleFeedMemberRemoved.bind(this),
     'feeds.feed_member.updated': handleFeedMemberUpdated.bind(this),

package/src/feeds-client/feeds-client.ts

@@ -51,6 +51,7 @@ import {
   Feed,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
+  handleActivityReactionUpdated,
   handleActivityUpdated,
   handleCommentAdded,
   handleCommentDeleted,
@@ -68,7 +69,8 @@ import { handleUserUpdated } from './event-handlers';
 import type { SyncFailure } from '../common/real-time/event-models';
 import { UnhandledErrorType } from '../common/real-time/event-models';
 import { updateCommentCount } from '../feed/event-handlers/comment/utils';
-import { configureLoggers } from '../utils/logger';
+import { configureLoggers } from '../utils';
+import { handleCommentReactionUpdated } from '../feed/event-handlers/comment/handle-comment-reaction-updated';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
@@ -417,9 +419,14 @@ export class FeedsClient extends FeedsApi {
       activity_id: string;
     },
   ) => {
+    const shouldEnforceUnique = request.enforce_unique;
     const response = await super.addActivityReaction(request);
     for (const feed of Object.values(this.activeFeeds)) {
-      handleActivityReactionAdded.bind(feed)(response, false);
+      if (shouldEnforceUnique) {
+        handleActivityReactionUpdated.bind(feed)(response, false);
+      } else {
+        handleActivityReactionAdded.bind(feed)(response, false);
+      }
     }
     return response;
   };
@@ -449,9 +456,14 @@ export class FeedsClient extends FeedsApi {
   addCommentReaction = async (
     request: AddCommentReactionRequest & { id: string },
   ): Promise<StreamResponse<AddCommentReactionResponse>> => {
+    const shouldEnforceUnique = request.enforce_unique;
     const response = await super.addCommentReaction(request);
     for (const feed of Object.values(this.activeFeeds)) {
-      handleCommentReactionAdded.bind(feed)(response, false);
+      if (shouldEnforceUnique) {
+        handleCommentReactionUpdated.bind(feed)(response, false);
+      } else {
+        handleCommentReactionAdded.bind(feed)(response, false);
+      }
     }
     return response;
   };

package/src/gen/feeds/FeedsApi.ts

@@ -59,6 +59,8 @@ import type {
   ListBlockListResponse,
   ListDevicesResponse,
   MarkActivityRequest,
+  OwnCapabilitiesBatchRequest,
+  OwnCapabilitiesBatchResponse,
   PinActivityRequest,
   PinActivityResponse,
   PollOptionResponse,
@@ -1523,6 +1525,32 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async ownCapabilitiesBatch(
+    request: OwnCapabilitiesBatchRequest & { connection_id?: string },
+  ): Promise<StreamResponse<OwnCapabilitiesBatchResponse>> {
+    const queryParams = {
+      connection_id: request?.connection_id,
+    };
+    const body = {
+      feeds: request?.feeds,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<OwnCapabilitiesBatchResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feeds/own_capabilities/batch',
+      undefined,
+      queryParams,
+      body,
+      'application/json',
+    );
+
+    decoders.OwnCapabilitiesBatchResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   protected async _queryFeeds(
     request?: QueryFeedsRequest & { connection_id?: string },
   ): Promise<StreamResponse<QueryFeedsResponse>> {

package/src/gen/models/index.ts

@@ -4177,6 +4177,16 @@ export interface OnlyUserID {
   id: string;
 }
 
+export interface OwnCapabilitiesBatchRequest {
+  feeds: string[];
+}
+
+export interface OwnCapabilitiesBatchResponse {
+  duration: string;
+
+  capabilities: Record<string, FeedOwnCapability[]>;
+}
+
 export interface OwnUser {
   banned: boolean;
 

package/src/test-utils/response-generators.ts

@@ -283,6 +283,32 @@ export function generateActivityReactionAddedEvent(
   };
 }
 
+export function generateActivityReactionUpdatedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.activity.reaction.updated'>>,
+    'activity' | 'type' | 'reaction' | 'user'
+  > & {
+    activity?: Parameters<typeof generateActivityResponse>[0];
+    reaction?: Parameters<typeof generateFeedReactionResponse>[0];
+    user?: Parameters<typeof generateUserResponse>[0];
+  } = {},
+): EventPayload<'feeds.activity.reaction.updated'> {
+  const activity = generateActivityResponse(overrides.activity);
+  const reaction = generateFeedReactionResponse(overrides.reaction);
+  const user = generateUserResponse(overrides.user);
+
+  return {
+    type: 'feeds.activity.reaction.updated',
+    created_at: new Date(),
+    fid: '',
+    custom: {},
+    ...overrides,
+    user,
+    reaction,
+    activity,
+  };
+}
+
 export function generateActivityReactionDeletedEvent(
   overrides: Omit<
     Partial<EventPayload<'feeds.activity.reaction.deleted'>>,
@@ -532,6 +558,32 @@ export function generateCommentReactionDeletedEvent(
   };
 }
 
+export function generateCommentReactionUpdatedEvent(
+  overrides: Omit<
+    Partial<EventPayload<'feeds.comment.reaction.updated'>>,
+    'comment' | 'reaction' | 'activity' | 'type'
+  > & {
+    comment?: Parameters<typeof generateCommentResponse>[0];
+    reaction?: Parameters<typeof generateFeedReactionResponse>[0];
+    activity?: Parameters<typeof generateActivityResponse>[0];
+  } = {},
+): EventPayload<'feeds.comment.reaction.updated'> {
+  const comment = generateCommentResponse(overrides.comment);
+  const reaction = generateFeedReactionResponse(overrides.reaction);
+  const activity = generateActivityResponse(overrides.activity);
+
+  return {
+    type: 'feeds.comment.reaction.updated',
+    created_at: new Date(),
+    fid: '',
+    custom: {},
+    ...overrides,
+    comment,
+    reaction,
+    activity,
+  };
+}
+
 export function generateFeedMemberAddedEvent(
   overrides: Omit<
     Partial<EventPayload<'feeds.feed_member.added'>>,

package/src/utils/state-update-queue.ts

@@ -12,13 +12,21 @@ import type {
   CommentUpdatedPayload,
 } from '../feed';
 import { ensureExhausted } from './ensure-exhausted';
+import type {
+  CommentReactionUpdatedPayload
+} from '../feed/event-handlers/comment/handle-comment-reaction-updated';
+import type {
+  ActivityReactionUpdatedPayload
+} from '../feed/event-handlers/activity/handle-activity-reaction-updated';
 
 export type StateUpdateQueuePrefix =
   | 'activity-updated'
   | 'activity-reaction-created'
   | 'activity-reaction-deleted'
+  | 'activity-reaction-updated'
   | 'comment-reaction-created'
   | 'comment-reaction-deleted'
+  | 'comment-reaction-updated'
   | 'follow-created'
   | 'follow-deleted'
   | 'follow-updated'
@@ -30,8 +38,10 @@ type StateUpdateQueuePayloadByPrefix = {
   'activity-updated': ActivityUpdatedPayload;
   'activity-reaction-created': ActivityReactionAddedPayload;
   'activity-reaction-deleted': ActivityReactionDeletedPayload;
+  'activity-reaction-updated': ActivityReactionUpdatedPayload;
   'comment-reaction-created': CommentReactionAddedPayload;
   'comment-reaction-deleted': CommentReactionDeletedPayload;
+  'comment-reaction-updated': CommentReactionUpdatedPayload;
   'follow-created': FollowResponse;
   'follow-deleted': FollowResponse;
   'follow-updated': FollowResponse;
@@ -163,7 +173,8 @@ export function getStateUpdateQueueId(
       return toJoin.concat([data.activity.id]).join('-')
     }
     case 'activity-reaction-created':
-    case 'activity-reaction-deleted': {
+    case 'activity-reaction-deleted':
+    case 'activity-reaction-updated': {
       return toJoin
         .concat([
           data.activity.id,
@@ -172,7 +183,8 @@ export function getStateUpdateQueueId(
         .join('-');
     }
     case 'comment-reaction-created':
-    case 'comment-reaction-deleted': {
+    case 'comment-reaction-deleted':
+    case 'comment-reaction-updated': {
       return toJoin
         .concat([
           data.comment.id,