@stream-io/feeds-client 0.2.0 → 0.2.2

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/follow/handle-follow-created.test.ts

@@ -78,10 +78,10 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.following).toHaveLength(1);
-      expect(result.data.following?.[0]).toEqual(follow);
+      expect(result.data.following?.[0]).toBe(follow);
       expect(result.data).toMatchObject(follow.source_feed);
       expect(result.data.own_follows).toBeUndefined();
-      expect(result.data.following_count).toEqual(1);
+      expect(result.data.following_count).toBe(1);
     });
 
     it('should handle when someone follows this feed', () => {
@@ -120,10 +120,10 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.followers).toHaveLength(1);
-      expect(result.data.followers?.[0]).toEqual(follow);
+      expect(result.data.followers?.[0]).toBe(follow);
       expect(result.data).toMatchObject(follow.target_feed);
       expect(result.data.own_follows).toBeUndefined();
-      expect(result.data.follower_count).toEqual(1);
+      expect(result.data.follower_count).toBe(1);
     });
 
     it('should add to own_follows when connected user is the source', () => {
@@ -161,7 +161,7 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.own_follows).toHaveLength(1);
-      expect(result.data.own_follows?.[0]).toEqual(follow);
+      expect(result.data.own_follows?.[0]).toBe(follow);
     });
 
     it('should not update followers/following when they are undefined', () => {
@@ -243,8 +243,8 @@ describe('handle-follow-created', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.followers).toHaveLength(2);
-      expect(result.data.followers?.[0]).toEqual(follow);
-      expect(result.data.followers?.[1]).toEqual(existingFollow);
+      expect(result.data.followers?.[0]).toBe(follow);
+      expect(result.data.followers?.[1]).toBe(existingFollow);
     });
   });
 });

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

@@ -95,7 +95,7 @@ describe('handle-follow-deleted', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.followers).toHaveLength(0);
-      expect(result.data.own_follows).toEqual(currentState.own_follows);
+      expect(result.data.own_follows).toBe(currentState.own_follows);
       expect(result.data).toMatchObject(follow.target_feed);
     });
 
@@ -262,7 +262,7 @@ describe('handle-follow-deleted', () => {
 
       expect(result.changed).toBe(true);
       expect(result.data.following).toHaveLength(1);
-      expect(result.data.following?.[0]).toEqual(followToKeep);
+      expect(result.data.following?.[0]).toBe(followToKeep);
     });
   });
 });

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

@@ -148,7 +148,7 @@ describe(handleFollowUpdated.name, () => {
 
       // State should not change
       const stateAfter = feed.currentState;
-      expect(stateAfter).toEqual(stateBefore);
+      expect(stateAfter).toBe(stateBefore);
     });
 
     it('allows update again after clearing stateUpdateQueue', () => {

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

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import {
+  NotificationFeedUpdatedEvent,
+  NotificationStatusResponse,
+  AggregatedActivityResponse,
+} from '../../../gen/models';
+import { updateNotificationFeedFromEvent } from './handle-notification-feed-updated';
+
+const createMockNotificationFeedUpdatedEvent = (
+  overrides: Partial<NotificationFeedUpdatedEvent> = {},
+): NotificationFeedUpdatedEvent => ({
+  created_at: new Date(),
+  fid: 'user:notification',
+  custom: {},
+  type: 'feeds.notification_feed.updated',
+  ...overrides,
+});
+
+const createMockNotificationStatus = (
+  overrides: Partial<NotificationStatusResponse> = {},
+): NotificationStatusResponse => ({
+  unread: 0,
+  unseen: 0,
+  ...overrides,
+});
+
+const createMockAggregatedActivity = (
+  overrides: Partial<AggregatedActivityResponse> = {},
+): AggregatedActivityResponse => ({
+  activity_count: 1,
+  created_at: new Date(),
+  group: 'test-group',
+  score: 1,
+  updated_at: new Date(),
+  user_count: 1,
+  activities: [],
+  ...overrides,
+});
+
+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);
+
+      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'],
+      });
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+      });
+
+      const result = updateNotificationFeedFromEvent(event);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toBe(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);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.aggregated_activities).toBe(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);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toBe(notificationStatus);
+      expect(result.data?.aggregated_activities).toBe(aggregatedActivities);
+    });
+
+    it('should handle notification_status with all fields', () => {
+      const notificationStatus = createMockNotificationStatus({
+        unread: 10,
+        unseen: 5,
+        last_seen_at: new Date('2023-01-01'),
+        read_activities: ['activity1', 'activity2', 'activity3'],
+      });
+      const event = createMockNotificationFeedUpdatedEvent({
+        notification_status: notificationStatus,
+      });
+
+      const result = updateNotificationFeedFromEvent(event);
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status).toBe(notificationStatus);
+    });
+  });
+});

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

@@ -1,10 +1,54 @@
 import type { Feed } from '../../../feed';
-import type { EventPayload } from '../../../types-internal';
+import {
+  AggregatedActivityResponse,
+  NotificationFeedUpdatedEvent,
+  NotificationStatusResponse,
+} from '../../../gen/models';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+
+export const updateNotificationFeedFromEvent = (
+  event: NotificationFeedUpdatedEvent,
+): UpdateStateResult<{
+  data?: {
+    notification_status?: NotificationStatusResponse;
+    aggregated_activities?: AggregatedActivityResponse[];
+  };
+}> => {
+  const updates: {
+    notification_status?: NotificationStatusResponse;
+    aggregated_activities?: AggregatedActivityResponse[];
+  } = {};
+
+  if (event.notification_status) {
+    updates.notification_status = event.notification_status;
+  }
+
+  if (event.aggregated_activities) {
+    updates.aggregated_activities = event.aggregated_activities;
+  }
+
+  // Only return changed if we have actual updates
+  if (Object.keys(updates).length > 0) {
+    return {
+      changed: true,
+      data: updates,
+    };
+  }
+
+  return {
+    changed: false,
+  };
+};
 
 export function handleNotificationFeedUpdated(
   this: Feed,
   event: EventPayload<'feeds.notification_feed.updated'>,
 ) {
-  console.info('notification feed updated', event);
-  // TODO: handle notification feed updates
+  const result = updateNotificationFeedFromEvent(event);
+  if (result.changed) {
+    this.state.partialNext({
+      notification_status: result.data?.notification_status,
+      aggregated_activities: result.data?.aggregated_activities,
+    });
+  }
 }