@stream-io/feeds-client 0.2.16 → 0.2.18

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/event-handlers/index.ts

@@ -4,5 +4,7 @@ export * from './feed-member';
 export * from './bookmark';
 export * from './activity';
 export * from './feed';
-export * from './aggregated-feed';
+export * from './notification-feed';
+export * from './story-feeds';
 export * from './watch';
+export * from './add-aggregated-activities-to-state';

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

@@ -0,0 +1,182 @@
+import { describe, it, expect } from 'vitest';
+import {
+  updateNotificationFeedFromEvent,
+  updateNotificationStatus,
+} from './handle-notification-feed-updated';
+import {
+  createMockAggregatedActivity,
+  createMockNotificationFeedUpdatedEvent,
+  createMockNotificationStatus,
+} from '../../../test-utils';
+
+describe('notification-feed-utils', () => {
+  describe('updateNotificationFeedFromEvent', () => {
+    it('should return unchanged if event has no notification_status or aggregated_activities', () => {
+      const event = createMockNotificationFeedUpdatedEvent();
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(false);
+    });
+
+    it(`should update notification_status when event has notification_status and currentNotificationStatus is undefined`, () => {
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: createMockNotificationStatus(),
+      });
+      const result = updateNotificationFeedFromEvent(event, [], undefined);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toStrictEqual(
+        event.notification_status,
+      );
+    });
+
+    it(`shouldn't update aggregated_activities when event has aggregated_activities but currentAggregatedActivities is undefined`, () => {
+      const event = createMockNotificationFeedUpdatedEvent({
+        aggregated_activities: [createMockAggregatedActivity()],
+      });
+      const result = updateNotificationFeedFromEvent(
+        event,
+        undefined,
+        createMockNotificationStatus(),
+      );
+
+      expect(result.changed).toBe(false);
+    });
+
+    it('should update notification_status when event has notification_status', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['activity1', 'activity2'],
+        seen_activities: [],
+      });
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+      });
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toStrictEqual(
+        notificationStatus,
+      );
+      expect(result.data?.aggregated_activities).toBeUndefined();
+    });
+
+    it('should update aggregated_activities when event has aggregated_activities', () => {
+      const aggregatedActivities = [
+        createMockAggregatedActivity({ group: 'group1' }),
+        createMockAggregatedActivity({ group: 'group2' }),
+      ];
+      const event = createMockNotificationFeedUpdatedEvent({
+        aggregated_activities: aggregatedActivities,
+      });
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.aggregated_activities).toStrictEqual(
+        aggregatedActivities,
+      );
+      expect(result.data?.notification_status).toBeUndefined();
+    });
+
+    it('should update both notification_status and aggregated_activities when event has both', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 2,
+        unseen: 1,
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity({ group: 'group1' }),
+      ];
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+        aggregated_activities: aggregatedActivities,
+      });
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status?.unread).toBe(
+        notificationStatus.unread,
+      );
+      expect(result.data?.notification_status?.unseen).toBe(
+        notificationStatus.unseen,
+      );
+      expect(result.data?.aggregated_activities).toStrictEqual(
+        aggregatedActivities,
+      );
+    });
+
+    it('should handle notification_status with all fields', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 10,
+        unseen: 5,
+        last_seen_at: new Date('2023-01-01'),
+        seen_activities: [],
+        read_activities: ['activity1', 'activity2', 'activity3'],
+      });
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+      });
+
+      const result = updateNotificationFeedFromEvent(event, [], {
+        unread: 0,
+        unseen: 0,
+        read_activities: [],
+        seen_activities: [],
+      });
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toStrictEqual(
+        notificationStatus,
+      );
+    });
+  });
+
+  describe('updateNotificationStatus', () => {
+    it('should replace old state with new one', () => {
+      const newNotificationStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['activity1', 'activity2'],
+        seen_activities: ['activity3', 'activity4'],
+      });
+
+      const currentNotificationStatus = createMockNotificationStatus({
+        unread: 2,
+        unseen: 1,
+        read_activities: ['activity5', 'activity6'],
+        seen_activities: ['activity7', 'activity8'],
+      });
+
+      const result = updateNotificationStatus(
+        newNotificationStatus,
+        currentNotificationStatus,
+      );
+
+      expect(result.notification_status).toStrictEqual(newNotificationStatus);
+    });
+  });
+});