@stream-io/feeds-client 0.2.1 → 0.2.3

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

@@ -0,0 +1,315 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleCommentReaction } from './handle-comment-reaction';
+import {
+  generateCommentResponse,
+  generateFeedReactionResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+  generateCommentReactionAddedEvent,
+  generateCommentReactionDeletedEvent,
+} from '../../../test-utils/response-generators';
+
+describe(handleCommentReaction.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('adds to own_reactions for current user and updates comment fields from the event', () => {
+    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 = generateCommentReactionAddedEvent({
+      comment: {
+        id: existingComment.id,
+        object_id: activityId,
+        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[activityId]?.comments?.[0]
+        ?.own_reactions,
+    ).toHaveLength(0);
+
+    handleCommentReaction.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 not add to 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 = generateCommentReactionAddedEvent({
+      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,
+      },
+    });
+
+    handleCommentReaction.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('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);
+    handleCommentReaction.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,
+      },
+    });
+
+    handleCommentReaction.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: [],
+    });
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [parentId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const addedEvent = generateCommentReactionAddedEvent({
+      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 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(0);
+
+    handleCommentReaction.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);
+
+    handleCommentReaction.call(feed, deletedEvent);
+    const stateAfter2 = feed.currentState;
+    const [updated2] = stateAfter2.comments_by_entity_id[parentId]!.comments!;
+    expect(updated2.own_reactions).toHaveLength(0);
+    expect(updated2.latest_reactions).toBe(
+      deletedEvent.comment.latest_reactions,
+    );
+    expect(updated2.reaction_groups).toBe(deletedEvent.comment.reaction_groups);
+  });
+
+  it('does nothing if comment is not found in state', () => {
+    const addedEvent = generateCommentReactionAddedEvent({
+      comment: { object_id: activityId },
+      reaction: { user: { id: currentUserId } },
+    });
+    const deletedEvent = generateCommentReactionDeletedEvent({
+      comment: { object_id: activityId },
+      reaction: { user: { id: currentUserId } },
+    });
+    const stateBefore = feed.currentState;
+
+    handleCommentReaction.call(feed, addedEvent);
+    const stateAfter1 = feed.currentState;
+    expect(stateAfter1).toBe(stateBefore);
+
+    handleCommentReaction.call(feed, deletedEvent);
+    const stateAfter2 = feed.currentState;
+    expect(stateAfter2).toBe(stateBefore);
+  });
+});

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

@@ -0,0 +1,131 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleCommentUpdated } from './handle-comment-updated';
+import {
+  generateCommentResponse,
+  generateCommentUpdatedEvent,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleCommentUpdated.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('replaces the existing comment (activity level)', () => {
+    const original = generateCommentResponse({ object_id: activityId });
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: { comments: [original], pagination: { sort: 'first' } },
+      },
+    });
+
+    const event = generateCommentUpdatedEvent({
+      comment: {
+        id: original.id,
+        object_id: activityId,
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    handleCommentUpdated.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter).not.toBe(stateBefore);
+    const commentsAfter =
+      stateAfter.comments_by_entity_id[activityId]?.comments;
+    const commentsBefore =
+      stateBefore.comments_by_entity_id[activityId]?.comments;
+    expect(commentsAfter).not.toBe(commentsBefore);
+    expect(commentsAfter).toHaveLength(1);
+    const [replaced] = commentsAfter!;
+    expect(replaced).toBe(event.comment);
+  });
+
+  it('updates the comment in the correct parent entity (prefers parent_id)', () => {
+    const parentId = `comment-${getHumanId()}`;
+    const reply = generateCommentResponse({
+      object_id: activityId,
+      parent_id: parentId,
+    });
+
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [parentId]: { comments: [reply], pagination: { sort: 'first' } },
+      },
+    });
+
+    const event = generateCommentUpdatedEvent({
+      comment: {
+        id: reply.id,
+        object_id: activityId,
+        parent_id: parentId,
+      },
+    });
+
+    const stateBefore = feed.currentState;
+    handleCommentUpdated.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).not.toBe(stateBefore);
+    const commentsBefore =
+      stateBefore.comments_by_entity_id[parentId]?.comments;
+    const commentsAfter = stateAfter.comments_by_entity_id[parentId]?.comments;
+    expect(commentsAfter).not.toBe(commentsBefore);
+    expect(commentsAfter).toHaveLength(1);
+    const [updatedReply] = commentsAfter!;
+    expect(updatedReply).toBe(event.comment);
+  });
+
+  it('does nothing if entity state does not exist', () => {
+    const event = generateCommentUpdatedEvent({
+      comment: { object_id: activityId },
+    });
+    const stateBefore = feed.currentState;
+    handleCommentUpdated.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  it('does nothing if comment not found in existing entity state', () => {
+    // set up state with different comment
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [generateCommentResponse({ object_id: activityId })],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+    const event = generateCommentUpdatedEvent({
+      comment: { object_id: activityId },
+    });
+    const stateBefore = feed.currentState;
+    handleCommentUpdated.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+});

package/src/feed/event-handlers/feed-member/handle-feed-member-added.test.ts

@@ -0,0 +1,75 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleFeedMemberAdded } from './handle-feed-member-added';
+import {
+  generateFeedResponse,
+  generateFeedMemberAddedEvent,
+  generateFeedMemberResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleFeedMemberAdded.name, () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let currentUserId: 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,
+    );
+  });
+
+  it('prepends to members if members array exists', () => {
+    const existingMember = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [existingMember] });
+
+    const event = generateFeedMemberAddedEvent();
+
+    handleFeedMemberAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.members).toHaveLength(2);
+    expect(stateAfter.members?.[0]).toBe(event.member);
+  });
+
+  it('does not create members array if it does not exist', () => {
+    const event = generateFeedMemberAddedEvent();
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.members).toBeUndefined();
+
+    handleFeedMemberAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  it('sets own_membership when the added member is the connected user', () => {
+    const event = generateFeedMemberAddedEvent({
+      member: { user: { id: currentUserId } },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.own_membership).toBeUndefined();
+
+    handleFeedMemberAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.own_membership).toBe(event.member);
+  });
+});

package/src/feed/event-handlers/feed-member/handle-feed-member-removed.test.ts

@@ -0,0 +1,82 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleFeedMemberRemoved } from './handle-feed-member-removed';
+import {
+  generateFeedResponse,
+  generateFeedMemberRemovedEvent,
+  generateFeedMemberResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleFeedMemberRemoved.name, () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let currentUserId: 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,
+    );
+  });
+
+  it('removes from members if present', () => {
+    const memberToRemove = generateFeedMemberResponse();
+    const memberToKeep = generateFeedMemberResponse();
+    feed.state.partialNext({ members: [memberToRemove, memberToKeep] });
+
+    const event = generateFeedMemberRemovedEvent({
+      member_id: memberToRemove.user.id,
+    });
+
+    handleFeedMemberRemoved.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.members).toHaveLength(1);
+    expect(stateAfter.members?.[0]).toBe(memberToKeep);
+  });
+
+  it('does not change state when members array is undefined', () => {
+    const event = generateFeedMemberRemovedEvent();
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.members).toBeUndefined();
+
+    handleFeedMemberRemoved.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+
+  it('deletes own_membership when the removed member is the connected user', () => {
+    const ownMember = generateFeedMemberResponse({
+      user: { id: currentUserId },
+    });
+    feed.state.partialNext({ own_membership: ownMember, members: [] });
+
+    const event = generateFeedMemberRemovedEvent({ member_id: currentUserId });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.own_membership).toBe(ownMember);
+
+    handleFeedMemberRemoved.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.own_membership).toBeUndefined();
+    expect(stateAfter.members).toBe(stateBefore.members);
+  });
+});

package/src/feed/event-handlers/feed-member/handle-feed-member-removed.ts

@@ -1,4 +1,4 @@
-import { Feed } from '../../../feed';
+import { Feed, FeedState } from '../../../feed';
 import { EventPayload } from '../../../types-internal';
 
 export function handleFeedMemberRemoved(
@@ -8,17 +8,27 @@ export function handleFeedMemberRemoved(
   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,
-      ),
-    };
+    let newState: FeedState | undefined;
 
-    if (connectedUser?.id === event.member_id) {
+    if (typeof currentState.members !== 'undefined') {
+      const filtered = currentState.members.filter(
+        (member) => member.user.id !== event.member_id,
+      );
+
+      if (filtered.length !== currentState.members.length) {
+        newState ??= { ...currentState };
+        newState.members = filtered;
+      }
+    }
+
+    if (
+      connectedUser?.id === event.member_id &&
+      typeof currentState.own_membership !== 'undefined'
+    ) {
+      newState ??= { ...currentState };
       delete newState.own_membership;
     }
 
-    return newState;
+    return newState ?? currentState;
   });
 }