@stream-io/feeds-client 0.2.9 → 0.2.10

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

@@ -0,0 +1,343 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleCommentReactionDeleted } from './handle-comment-reaction-deleted';
+import {
+  generateCommentResponse,
+  generateFeedReactionResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+  generateCommentReactionDeletedEvent,
+} from '../../../test-utils';
+import { shouldUpdateState } from '../../../utils';
+import { CommentResponse, FeedsReactionResponse } from '../../../gen/models';
+import { EventPayload } from '../../../types-internal';
+
+describe(handleCommentReactionDeleted.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('removes from own_reactions when the target reaction belongs to the current user', () => {
+    const commentId = `comment-${getHumanId()}`;
+    const existingReaction = generateFeedReactionResponse({
+      type: 'heart',
+      user: { id: currentUserId },
+      activity_id: activityId,
+      comment_id: commentId,
+    });
+    const existingComment = generateCommentResponse({
+      id: commentId,
+      object_id: activityId,
+      own_reactions: [existingReaction],
+      latest_reactions: [],
+      reaction_groups: {},
+    });
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const event = generateCommentReactionDeletedEvent({
+      comment: {
+        ...existingComment,
+        latest_reactions: [],
+        reaction_groups: {},
+      },
+      reaction: {
+        type: 'heart',
+        user: { id: currentUserId },
+        activity_id: activityId,
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(
+      stateBefore.comments_by_entity_id[activityId]!.comments![0].own_reactions,
+    ).toHaveLength(1);
+    handleCommentReactionDeleted.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('does not remove from own_reactions when target reaction does not belong to the current user', () => {
+    const commentId = `comment-${getHumanId()}`;
+    const ownReaction = generateFeedReactionResponse({
+      type: 'wow',
+      user: { id: currentUserId },
+      activity_id: activityId,
+      comment_id: commentId,
+    });
+    const existingComment = generateCommentResponse({
+      id: commentId,
+      object_id: activityId,
+      own_reactions: [ownReaction],
+      latest_reactions: [],
+      reaction_groups: {},
+    });
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const event = generateCommentReactionDeletedEvent({
+      comment: {
+        ...existingComment,
+        latest_reactions: [],
+        reaction_groups: {},
+      },
+      reaction: {
+        type: 'wow',
+        user: { id: 'other-user' },
+        comment_id: existingComment.id,
+      },
+    });
+
+    handleCommentReactionDeleted.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(ownReaction);
+    expect(updated.latest_reactions).toBe(event.comment.latest_reactions);
+    expect(updated.reaction_groups).toBe(event.comment.reaction_groups);
+  });
+
+  it('does changes to the proper entity state (prefers parent_id)', () => {
+    const parentId = `comment-${getHumanId()}`;
+    const existingComment = generateCommentResponse({
+      object_id: activityId,
+      parent_id: parentId,
+      latest_reactions: [],
+      reaction_groups: {},
+      own_reactions: [],
+    });
+
+    const existingReaction = generateFeedReactionResponse({
+      type: 'like',
+      user: { id: currentUserId },
+      activity_id: activityId,
+      comment_id: existingComment.id,
+    });
+    existingComment.own_reactions = [existingReaction];
+
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [parentId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const deletedEvent = generateCommentReactionDeletedEvent({
+      comment: {
+        id: existingComment.id,
+        object_id: activityId,
+        parent_id: parentId,
+        latest_reactions: [],
+        reaction_groups: {},
+      },
+      reaction: {
+        type: 'like',
+        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);
+
+    handleCommentReactionDeleted.call(feed, deletedEvent);
+    const stateAfter = feed.currentState;
+    const [updated] = stateAfter.comments_by_entity_id[parentId]!.comments!;
+    expect(updated.own_reactions).toHaveLength(0);
+    expect(updated.latest_reactions).toBe(
+      deletedEvent.comment.latest_reactions,
+    );
+    expect(updated.reaction_groups).toBe(deletedEvent.comment.reaction_groups);
+  });
+
+  it('does nothing if comment is not found in state', () => {
+    const deletedEvent = generateCommentReactionDeletedEvent({
+      comment: { object_id: activityId },
+      reaction: { user: { id: currentUserId } },
+    });
+    const stateBefore = feed.currentState;
+
+    handleCommentReactionDeleted.call(feed, deletedEvent);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  describe(`Comment reaction deleted ${shouldUpdateState.name} integration`, () => {
+    let currentUserPayload: EventPayload<'feeds.comment.reaction.deleted'>;
+    let existingComment: CommentResponse;
+    let existingReaction: FeedsReactionResponse;
+    let commentId: string;
+
+    beforeEach(() => {
+      commentId = `comment-${getHumanId()}`;
+      existingReaction = generateFeedReactionResponse({
+        type: 'like',
+        user: { id: currentUserId },
+        activity_id: activityId,
+        comment_id: commentId,
+      });
+      existingComment = generateCommentResponse({
+        id: commentId,
+        object_id: activityId,
+        own_reactions: [existingReaction],
+      });
+
+      currentUserPayload = generateCommentReactionDeletedEvent({
+        comment: {
+          ...existingComment,
+          own_reactions: [],
+        },
+        reaction: existingReaction,
+      });
+
+      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
+
+      handleCommentReactionDeleted.call(feed, currentUserPayload, false);
+
+      let stateBefore = feed.currentState;
+
+      handleCommentReactionDeleted.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
+
+      handleCommentReactionDeleted.call(feed, currentUserPayload);
+
+      stateBefore = feed.currentState;
+
+      handleCommentReactionDeleted.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', () => {
+      handleCommentReactionDeleted.call(feed, currentUserPayload);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another WS event
+      handleCommentReactionDeleted.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 ?? [];
+
+      expect(comment?.own_reactions.length).toEqual(0);
+      expect(latestReaction).toBeUndefined();
+    });
+
+    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
+      handleCommentReactionDeleted.call(feed, currentUserPayload, false);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another HTTP response
+      handleCommentReactionDeleted.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 ?? [];
+
+      expect(comment?.own_reactions.length).toEqual(0);
+      expect(latestReaction).toBeUndefined();
+    });
+
+    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the comment reaction deletion', () => {
+      const otherUserPayload = generateCommentReactionDeletedEvent({
+        comment: {
+          ...existingComment,
+          own_reactions: [],
+        },
+        reaction: {
+          ...existingReaction,
+          user: {
+            id: getHumanId(),
+          },
+        },
+      });
+
+      handleCommentReactionDeleted.call(feed, otherUserPayload);
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+
+      handleCommentReactionDeleted.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).toBe(existingReaction);
+    });
+  });
+});

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

@@ -0,0 +1,74 @@
+import { Feed } from '../../feed';
+import { EventPayload, type PartializeAllBut } from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+
+export type CommentReactionDeletedPayload = PartializeAllBut<
+  EventPayload<'feeds.comment.reaction.deleted'>,
+  'comment' | 'reaction'
+>;
+
+export function handleCommentReactionDeleted(
+  this: Feed,
+  payload: CommentReactionDeletedPayload,
+  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-deleted',
+      ),
+      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 = ownReactions.filter(
+        (r) => r.type !== reaction.type,
+      );
+    }
+
+    newComments[commentIndex] = {
+      ...newComments[commentIndex],
+      reaction_count: comment.reaction_count ?? 0,
+      // TODO: FIXME this should be handled by the backend
+      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/handle-comment-updated.test.ts

@@ -7,8 +7,12 @@ import {
   generateCommentUpdatedEvent,
   generateFeedResponse,
   generateOwnUser,
+  generateUserResponseCommonFields,
   getHumanId,
-} from '../../../test-utils/response-generators';
+} from '../../../test-utils';
+import { CommentResponse, UserResponseCommonFields } from '../../../gen/models';
+import { shouldUpdateState } from '../../../utils';
+import { EventPayload } from '../../../types-internal';
 
 describe(handleCommentUpdated.name, () => {
   let feed: Feed;
@@ -128,4 +132,136 @@ describe(handleCommentUpdated.name, () => {
     const stateAfter = feed.currentState;
     expect(stateAfter).toBe(stateBefore);
   });
+
+  describe(`Comment updated ${shouldUpdateState.name} integration`, () => {
+    let currentUserPayload: EventPayload<'feeds.comment.updated'>;
+    let existingComment: CommentResponse;
+    let commentBeforeUpdate: CommentResponse;
+    let commentAfterUpdate: CommentResponse;
+    let commentId: string;
+
+    beforeEach(() => {
+      commentId = `comment-${getHumanId()}`;
+      commentBeforeUpdate = generateCommentResponse({
+        id: commentId,
+        object_id: activityId,
+      });
+      commentAfterUpdate = {
+        ...commentBeforeUpdate,
+        reply_count: commentBeforeUpdate.reply_count + 10,
+      };
+      existingComment = generateCommentResponse({
+        id: `comment-${getHumanId()}`,
+        object_id: activityId,
+      });
+
+      currentUserPayload = generateCommentUpdatedEvent({
+        comment: commentAfterUpdate,
+        user: client.state.getLatestValue()
+          .connected_user as UserResponseCommonFields,
+      });
+
+      feed.state.partialNext({
+        comments_by_entity_id: {
+          [activityId]: {
+            comments: [existingComment, commentBeforeUpdate],
+            pagination: { sort: 'first' },
+          },
+        },
+      });
+      feed.state.partialNext({ watch: true });
+    });
+
+    it(`skips update if ${shouldUpdateState.name} returns false`, () => {
+      // 1. HTTP and then WS
+
+      handleCommentUpdated.call(feed, currentUserPayload, false);
+
+      let stateBefore = feed.currentState;
+
+      handleCommentUpdated.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
+
+      handleCommentUpdated.call(feed, currentUserPayload);
+
+      stateBefore = feed.currentState;
+
+      handleCommentUpdated.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', () => {
+      handleCommentUpdated.call(feed, currentUserPayload);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another WS event
+      handleCommentUpdated.call(feed, currentUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment, previousComment] = (comments ?? []).toReversed();
+
+      expect(comments?.length).toEqual(2);
+      expect(latestComment).toMatchObject(commentAfterUpdate);
+      expect(previousComment).toMatchObject(existingComment);
+    });
+
+    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
+      handleCommentUpdated.call(feed, currentUserPayload, false);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another HTTP response
+      handleCommentUpdated.call(feed, currentUserPayload, false);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment, previousComment] = (comments ?? []).toReversed();
+
+      expect(comments?.length).toEqual(2);
+      expect(latestComment).toMatchObject(commentAfterUpdate);
+      expect(previousComment).toMatchObject(existingComment);
+    });
+
+    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the comment reaction deletion', () => {
+      const otherCommentUpdate = generateCommentResponse({
+        ...commentBeforeUpdate,
+        reply_count: commentBeforeUpdate.reply_count + 1,
+      });
+      const otherUserPayload = generateCommentUpdatedEvent({
+        comment: otherCommentUpdate,
+        user: generateUserResponseCommonFields({ id: getHumanId() }),
+      });
+
+      handleCommentUpdated.call(feed, otherUserPayload);
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+
+      handleCommentUpdated.call(feed, otherUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment, previousComment] = (comments ?? []).toReversed();
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+      expect(comments?.length).toEqual(2);
+      expect(latestComment).toMatchObject(otherCommentUpdate);
+      expect(previousComment).toMatchObject(existingComment);
+    });
+  });
 });

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

@@ -1,13 +1,38 @@
-import { Feed } from '../../../feed';
-import { EventPayload } from '../../../types-internal';
+import { Feed } from '../../feed';
+import { EventPayload, type PartializeAllBut } from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import {
+  eventTriggeredByConnectedUser
+} from '../../../utils/event-triggered-by-connected-user';
+
+export type CommentUpdatedPayload = PartializeAllBut<
+  EventPayload<'feeds.comment.updated'>,
+  'comment'
+>;
 
 export function handleCommentUpdated(
   this: Feed,
-  event: EventPayload<'feeds.comment.updated'>,
+  payload: CommentUpdatedPayload,
+  fromWs?: boolean,
 ) {
-  const { comment } = event;
+  const { comment } = payload;
   const entityId = comment.parent_id ?? comment.object_id;
 
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(
+        payload,
+        'comment-updated',
+      ),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(this, payload),
+    })
+  ) {
+    return;
+  }
+
   this.state.next((currentState) => {
     const entityState = currentState.comments_by_entity_id[entityId];
 

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

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

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

@@ -0,0 +1 @@
+export * from './update-comment-count';