@stream-io/feeds-client 0.2.0 → 0.2.2

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

@@ -0,0 +1,196 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleBookmarkUpdated } from './handle-bookmark-updated';
+import {
+  generateActivityPinResponse,
+  generateActivityResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+  generateFeedReactionResponse,
+  generateBookmarkUpdatedEvent,
+  generateBookmarkResponse,
+} from '../../../test-utils/response-generators';
+
+describe(handleBookmarkUpdated.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('updates a bookmark for the current user and updates activities', () => {
+    const event = generateBookmarkUpdatedEvent({
+      bookmark: {
+        activity: {
+          own_reactions: [],
+          bookmark_count: 1,
+        },
+        user: { id: currentUserId },
+        updated_at: new Date('2025-08-06T12:00:00Z'),
+      },
+    });
+    const activity = generateActivityResponse({
+      id: event.bookmark.activity.id,
+      bookmark_count: 1,
+      own_bookmarks: [
+        generateBookmarkResponse({
+          activity: { id: event.bookmark.activity.id },
+          user: { id: currentUserId },
+          updated_at: new Date('2025-08-05T12:00:00Z'),
+        }),
+      ],
+      own_reactions: [generateFeedReactionResponse()],
+    });
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.activities![0].own_bookmarks).toHaveLength(1);
+    expect(
+      stateBefore.pinned_activities![0].activity.own_bookmarks,
+    ).toHaveLength(1);
+    expect(stateBefore.activities![0].own_bookmarks[0].updated_at).not.toBe(
+      event.bookmark.updated_at,
+    );
+    expect(
+      stateBefore.pinned_activities![0].activity.own_bookmarks[0].updated_at,
+    ).not.toBe(event.bookmark.updated_at);
+
+    handleBookmarkUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities![0].own_bookmarks).toHaveLength(1);
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toHaveLength(1);
+    expect(stateAfter.activities![0].own_bookmarks[0]).toBe(event.bookmark);
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks[0]).toBe(
+      event.bookmark,
+    );
+    expect(stateAfter.activities![0].own_reactions).toBe(
+      stateBefore.activities![0].own_reactions,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
+      stateBefore.pinned_activities![0].activity.own_reactions,
+    );
+    expect(stateAfter.activities![0].bookmark_count).toBe(1);
+    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(1);
+  });
+
+  it('does not update own_bookmarks if bookmark is from another user but still updates activity', () => {
+    const event = generateBookmarkUpdatedEvent({
+      bookmark: {
+        activity: {
+          own_reactions: [],
+          bookmark_count: 2,
+        },
+        user: { id: 'other-user-id' },
+        updated_at: new Date('2025-08-06T12:00:00Z'),
+      },
+    });
+    const activity = generateActivityResponse({
+      id: event.bookmark.activity.id,
+      bookmark_count: 1,
+      own_bookmarks: [
+        generateBookmarkResponse({
+          activity: { id: event.bookmark.activity.id },
+          user: { id: currentUserId },
+          updated_at: new Date('2025-08-05T12:00:00Z'),
+        }),
+      ],
+      own_reactions: [generateFeedReactionResponse()],
+    });
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.activities![0].own_bookmarks).toHaveLength(1);
+    expect(
+      stateBefore.pinned_activities![0].activity.own_bookmarks,
+    ).toHaveLength(1);
+    expect(stateBefore.activities![0].bookmark_count).toBe(1);
+    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toBe(
+      1,
+    );
+
+    handleBookmarkUpdated.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
+      stateBefore.activities![0].own_bookmarks,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
+      stateBefore.pinned_activities![0].activity.own_bookmarks,
+    );
+    expect(stateAfter.activities![0].own_reactions).toBe(
+      stateBefore.activities![0].own_reactions,
+    );
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
+      stateBefore.pinned_activities![0].activity.own_reactions,
+    );
+    expect(stateAfter.activities![0].bookmark_count).toBe(2);
+    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(2);
+  });
+
+  it('does nothing if activity is not found', () => {
+    const event = generateBookmarkUpdatedEvent({
+      bookmark: {
+        activity: {
+          own_reactions: [],
+          bookmark_count: 1,
+        },
+        user: { id: currentUserId },
+      },
+    });
+    const activity = generateActivityResponse({
+      id: 'unrelated-activity-id',
+      bookmark_count: 1,
+      own_bookmarks: [
+        generateBookmarkResponse({
+          activity: { id: 'unrelated-activity-id' },
+          user: { id: currentUserId },
+        }),
+      ],
+      own_reactions: [generateFeedReactionResponse()],
+    });
+    const activityPin = generateActivityPinResponse({
+      activity: { ...activity },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [activityPin],
+    });
+
+    const stateBefore = feed.currentState;
+    handleBookmarkUpdated.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+});

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

@@ -1,76 +1,115 @@
 import type { Feed } from '../../../feed';
 import type {
+  ActivityPinResponse,
   ActivityResponse,
   BookmarkUpdatedEvent,
 } from '../../../gen/models';
-import type { EventPayload, UpdateStateResult } from '../../../types-internal';
+import type { EventPayload } from '../../../types-internal';
+import { updateEntityInArray } from '../../../utils';
 
-import { updateActivityInState } from '../activity';
 import { isSameBookmark } from './handle-bookmark-deleted';
 
-export const updateBookmarkInActivity = (
-  event: BookmarkUpdatedEvent,
-  activity: ActivityResponse,
-  isCurrentUser: boolean,
-): UpdateStateResult<ActivityResponse> => {
-  // Update own_bookmarks if the bookmark is from the current user
-  let ownBookmarks = activity.own_bookmarks || [];
-  if (isCurrentUser) {
-    const bookmarkIndex = ownBookmarks.findIndex((bookmark) =>
+const sharedUpdateActivity = ({
+  currentActivity,
+  event,
+  eventBelongsToCurrentUser,
+}: {
+  currentActivity: ActivityResponse;
+  event: BookmarkUpdatedEvent;
+  eventBelongsToCurrentUser: boolean;
+}): ActivityResponse => {
+  let newOwnBookmarks = currentActivity.own_bookmarks;
+
+  if (eventBelongsToCurrentUser) {
+    const bookmarkIndex = newOwnBookmarks.findIndex((bookmark) =>
       isSameBookmark(bookmark, event.bookmark),
     );
+
     if (bookmarkIndex !== -1) {
-      ownBookmarks = [...ownBookmarks];
-      ownBookmarks[bookmarkIndex] = event.bookmark;
+      newOwnBookmarks = [...newOwnBookmarks];
+      newOwnBookmarks[bookmarkIndex] = event.bookmark;
     }
   }
 
   return {
-    ...activity,
-    own_bookmarks: ownBookmarks,
-    changed: true,
+    ...event.bookmark.activity,
+    own_bookmarks: newOwnBookmarks,
+    own_reactions: currentActivity.own_reactions,
   };
 };
 
 export const updateBookmarkInActivities = (
   event: BookmarkUpdatedEvent,
   activities: ActivityResponse[] | undefined,
-  isCurrentUser: boolean,
-): UpdateStateResult<{ activities: ActivityResponse[] }> => {
-  if (!activities) {
-    return { changed: false, activities: [] };
-  }
+  eventBelongsToCurrentUser: boolean,
+) =>
+  updateEntityInArray({
+    entities: activities,
+    matcher: (activity) => activity.id === event.bookmark.activity.id,
+    updater: (matchedActivity) =>
+      sharedUpdateActivity({
+        currentActivity: matchedActivity,
+        event,
+        eventBelongsToCurrentUser,
+      }),
+  });
 
-  const activityIndex = activities.findIndex(
-    (a) => a.id === event.bookmark.activity.id,
-  );
-  if (activityIndex === -1) {
-    return { changed: false, activities };
-  }
+export const updateBookmarkInPinnedActivities = (
+  event: BookmarkUpdatedEvent,
+  pinnedActivities: ActivityPinResponse[] | undefined,
+  eventBelongsToCurrentUser: boolean,
+) =>
+  updateEntityInArray({
+    entities: pinnedActivities,
+    matcher: (pinnedActivity) =>
+      pinnedActivity.activity.id === event.bookmark.activity.id,
+    updater: (matchedPinnedActivity) => {
+      const newActivity = sharedUpdateActivity({
+        currentActivity: matchedPinnedActivity.activity,
+        event,
+        eventBelongsToCurrentUser,
+      });
 
-  const activity = activities[activityIndex];
-  const updatedActivity = updateBookmarkInActivity(
-    event,
-    activity,
-    isCurrentUser,
-  );
-  return updateActivityInState(updatedActivity, activities, true);
-};
+      if (newActivity === matchedPinnedActivity.activity) {
+        return matchedPinnedActivity;
+      }
+
+      return {
+        ...matchedPinnedActivity,
+        activity: newActivity,
+      };
+    },
+  });
 
 export function handleBookmarkUpdated(
   this: Feed,
   event: EventPayload<'feeds.bookmark.updated'>,
 ) {
-  const currentActivities = this.currentState.activities;
+  const {
+    activities: currentActivities,
+    pinned_activities: currentPinnedActivities,
+  } = this.currentState;
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
-  const isCurrentUser = event.bookmark.user.id === connectedUser?.id;
+  const eventBelongsToCurrentUser =
+    event.bookmark.user.id === connectedUser?.id;
+
+  const [result1, result2] = [
+    updateBookmarkInActivities(
+      event,
+      currentActivities,
+      eventBelongsToCurrentUser,
+    ),
+    updateBookmarkInPinnedActivities(
+      event,
+      currentPinnedActivities,
+      eventBelongsToCurrentUser,
+    ),
+  ];
 
-  const result = updateBookmarkInActivities(
-    event,
-    currentActivities,
-    isCurrentUser,
-  );
-  if (result.changed) {
-    this.state.partialNext({ activities: result.activities });
+  if (result1.changed || result2.changed) {
+    this.state.partialNext({
+      activities: result1.entities,
+      pinned_activities: result2.entities,
+    });
   }
 }

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

@@ -0,0 +1,147 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleCommentAdded } from './handle-comment-added';
+import {
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+  generateCommentAddedEvent,
+  generateCommentResponse,
+} from '../../../test-utils/response-generators';
+
+describe(handleCommentAdded.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('appends a new comment when pagination.sort is not "last"', () => {
+    const existingComment = generateCommentResponse({
+      object_id: activityId,
+    });
+
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const event = generateCommentAddedEvent({
+      comment: { object_id: activityId },
+    });
+
+    const stateBefore = feed.currentState;
+    handleCommentAdded.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.comments_by_entity_id[activityId]!.comments).not.toBe(
+      stateBefore.comments_by_entity_id[activityId]!.comments,
+    );
+    expect(stateAfter.comments_by_entity_id[activityId]!.comments).toHaveLength(
+      2,
+    );
+    expect(
+      stateAfter.comments_by_entity_id[activityId]!.comments!.at(-1),
+    ).toBe(event.comment);
+  });
+
+  it('prepends a new comment when pagination.sort is "last"', () => {
+    const existingComment = generateCommentResponse({
+      object_id: activityId,
+    });
+
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [existingComment],
+          pagination: { sort: 'last' },
+        },
+      },
+    });
+
+    const event = generateCommentAddedEvent({
+      comment: { object_id: activityId },
+    });
+
+    const stateBefore = feed.currentState;
+    handleCommentAdded.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.comments_by_entity_id[activityId]!.comments).not.toBe(
+      stateBefore.comments_by_entity_id[activityId]!.comments,
+    );
+    expect(stateAfter.comments_by_entity_id[activityId]!.comments).toHaveLength(
+      2,
+    );
+    expect(
+      stateAfter.comments_by_entity_id[activityId]!.comments!.at(0),
+    ).toBe(event.comment);
+  });
+
+  it('stores the comment in the correct parent entity state (prefers parent_id)', () => {
+    const parentId = `comment-${getHumanId()}`;
+    const existingComment = generateCommentResponse({
+      object_id: activityId,
+      parent_id: parentId,
+    });
+
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [parentId]: {
+          comments: [existingComment],
+          pagination: { sort: 'best' },
+        },
+      },
+    });
+
+    const event = generateCommentAddedEvent({
+      comment: { parent_id: parentId, object_id: activityId },
+    });
+
+    const prevState = feed.currentState;
+    handleCommentAdded.call(feed, event);
+    const nextState = feed.currentState;
+
+    expect(nextState.comments_by_entity_id[parentId]!.comments).not.toBe(
+      prevState.comments_by_entity_id[parentId]!.comments,
+    );
+    expect(nextState.comments_by_entity_id[parentId]!.comments).toHaveLength(2);
+    expect(nextState.comments_by_entity_id[parentId]!.comments!.at(-1)).toBe(
+      event.comment,
+    );
+  });
+
+  it('does nothing if entity state does not exist (comments have not been loaded yet)', () => {
+    const event = generateCommentAddedEvent({
+      comment: { object_id: activityId },
+    });
+    const stateBefore = feed.currentState;
+    handleCommentAdded.call(feed, event);
+    const stateAfter = feed.currentState;
+    expect(stateAfter).toBe(stateBefore);
+  });
+});

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

@@ -0,0 +1,133 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleCommentDeleted } from './handle-comment-deleted';
+import {
+  generateCommentDeletedEvent,
+  generateCommentResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleCommentDeleted.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 the comment from the entity state (activity level)', () => {
+    const comment = generateCommentResponse({ object_id: activityId });
+
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [comment],
+          pagination: { sort: 'first' },
+        },
+        // should be removed by id cleanup
+        [comment.id]: {
+          comments: [],
+          pagination: { sort: 'first' },
+        },
+      },
+    });
+
+    const event = generateCommentDeletedEvent({
+      comment: { id: comment.id, object_id: activityId },
+    });
+
+    const stateBefore = feed.currentState;
+
+    handleCommentDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.comments_by_entity_id[activityId]?.comments).not.toBe(
+      stateBefore.comments_by_entity_id[activityId]?.comments,
+    );
+    expect(stateAfter.comments_by_entity_id[activityId]?.comments).toHaveLength(
+      0,
+    );
+    expect(stateAfter.comments_by_entity_id).not.toHaveProperty(comment.id);
+  });
+
+  it('removes the comment from the correct parent entity (comment reply)', () => {
+    const parentComment = generateCommentResponse({ object_id: activityId });
+    const reply = generateCommentResponse({
+      object_id: activityId,
+      parent_id: parentComment.id,
+    });
+
+    feed.state.partialNext({
+      comments_by_entity_id: {
+        [activityId]: {
+          comments: [parentComment],
+          pagination: { sort: 'first' },
+        },
+        [parentComment.id]: {
+          comments: [reply],
+          pagination: { sort: 'first' },
+        },
+        [reply.id]: { comments: [], pagination: { sort: 'first' } },
+      },
+    });
+
+    const event = generateCommentDeletedEvent({
+      comment: {
+        id: reply.id,
+        object_id: activityId,
+        parent_id: parentComment.id,
+      },
+    });
+
+    const stateBefore = feed.currentState;
+
+    handleCommentDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter).not.toBe(stateBefore);
+    expect(
+      stateAfter.comments_by_entity_id[parentComment.id]?.comments,
+    ).not.toBe(
+      stateBefore.comments_by_entity_id[parentComment.id]?.comments,
+    );
+    expect(
+      stateAfter.comments_by_entity_id[parentComment.id]?.comments,
+    ).toHaveLength(0);
+    expect(stateAfter.comments_by_entity_id).not.toHaveProperty(reply.id);
+    expect(stateAfter.comments_by_entity_id).toHaveProperty(activityId);
+  });
+
+  it('does not change the state if the deleted comment is not in state', () => {
+    const event = generateCommentDeletedEvent({
+      comment: { object_id: activityId },
+    });
+
+    const stateBefore = feed.currentState;
+    handleCommentDeleted.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter).toBe(stateBefore);
+  });
+});

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

@@ -8,24 +8,38 @@ export function handleCommentDeleted(
   const entityId = comment.parent_id ?? comment.object_id;
 
   this.state.next((currentState) => {
-    const newCommentsByEntityId = {
-      ...currentState.comments_by_entity_id,
-      [entityId]: {
-        ...currentState.comments_by_entity_id[entityId],
-      },
-    };
+    let newCommentsByEntityId:
+      | typeof currentState.comments_by_entity_id
+      | undefined;
 
     const index = this.getCommentIndex(comment, currentState);
 
-    if (newCommentsByEntityId?.[entityId]?.comments?.length && index !== -1) {
-      newCommentsByEntityId[entityId].comments = [
-        ...newCommentsByEntityId[entityId].comments,
+    if (index !== -1) {
+      newCommentsByEntityId ??= {
+        ...currentState.comments_by_entity_id,
+        [entityId]: {
+          ...currentState.comments_by_entity_id[entityId],
+        },
+      };
+
+      newCommentsByEntityId[entityId]!.comments = [
+        ...newCommentsByEntityId[entityId]!.comments!,
       ];
 
       newCommentsByEntityId[entityId]?.comments?.splice(index, 1);
     }
 
-    delete newCommentsByEntityId[comment.id];
+    if (typeof currentState.comments_by_entity_id[comment.id] !== 'undefined') {
+      newCommentsByEntityId ??= {
+        ...currentState.comments_by_entity_id,
+      };
+
+      delete newCommentsByEntityId[comment.id];
+    }
+
+    if (!newCommentsByEntityId) {
+      return currentState;
+    }
 
     return {
       ...currentState,