@stream-io/feeds-client 0.2.17 → 0.2.19

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

@@ -1,188 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { Feed } from '../../../feed';
-import { FeedsClient } from '../../../feeds-client';
-import { handleBookmarkDeleted } from './handle-bookmark-deleted';
-import {
-  generateActivityPinResponse,
-  generateActivityResponse,
-  generateFeedResponse,
-  generateOwnUser,
-  getHumanId,
-  generateFeedReactionResponse,
-  generateBookmarkDeletedEvent,
-  generateBookmarkResponse,
-} from '../../../test-utils/response-generators';
-
-describe(handleBookmarkDeleted.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 a bookmark for the current user and updates activities', () => {
-    const event = generateBookmarkDeletedEvent({
-      bookmark: {
-        activity: {
-          own_reactions: [],
-          bookmark_count: 0,
-        },
-        user: { id: currentUserId },
-      },
-    });
-    const activity = generateActivityResponse({
-      id: event.bookmark.activity.id,
-      bookmark_count: 1,
-      own_bookmarks: [
-        generateBookmarkResponse({
-          activity: { id: event.bookmark.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;
-    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,
-    );
-
-    handleBookmarkDeleted.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter.activities![0].own_bookmarks).toHaveLength(0);
-    expect(
-      stateAfter.pinned_activities![0].activity.own_bookmarks,
-    ).toHaveLength(0);
-    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(0);
-    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(0);
-  });
-
-  it('does not remove from own_bookmarks if bookmark is from another user but still updates activity', () => {
-    const event = generateBookmarkDeletedEvent({
-      bookmark: {
-        activity: {
-          own_reactions: [],
-          bookmark_count: 0,
-        },
-        user: { id: 'other-user-id' },
-      },
-    });
-    const activity = generateActivityResponse({
-      id: event.bookmark.activity.id,
-      bookmark_count: 1,
-      own_bookmarks: [
-        generateBookmarkResponse({
-          activity: { id: event.bookmark.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;
-    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,
-    );
-
-    handleBookmarkDeleted.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(0);
-    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(0);
-  });
-
-  it('does nothing if activity is not found', () => {
-    const event = generateBookmarkDeletedEvent({
-      bookmark: {
-        activity: {
-          own_reactions: [],
-          bookmark_count: 0,
-        },
-        user: { id: currentUserId },
-      },
-    });
-    const activity = generateActivityResponse({
-      id: 'another-activity-id',
-      bookmark_count: 1,
-      own_bookmarks: [
-        generateBookmarkResponse({
-          activity: { id: 'another-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;
-    handleBookmarkDeleted.call(feed, event);
-    const stateAfter = feed.currentState;
-    expect(stateAfter).toBe(stateBefore);
-  });
-});

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

@@ -1,196 +0,0 @@
-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/comment/handle-comment-added.test.ts

@@ -1,271 +0,0 @@
-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,
-  generateUserResponseCommonFields,
-} from '../../../test-utils';
-import type { CommentResponse, UserResponseCommonFields } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
-import { shouldUpdateState } from '../../../utils';
-
-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);
-  });
-
-  describe(`Comment added ${shouldUpdateState.name} integration`, () => {
-    let currentUserPayload: EventPayload<'feeds.comment.added'>;
-    let existingComment: CommentResponse;
-    let newComment: CommentResponse;
-    let commentId: string;
-
-    beforeEach(() => {
-      commentId = `comment-${getHumanId()}`;
-      existingComment = generateCommentResponse({
-        id: commentId,
-        object_id: activityId,
-      });
-      newComment = generateCommentResponse({
-        id: `comment-${getHumanId()}`,
-        object_id: activityId,
-      });
-
-      currentUserPayload = generateCommentAddedEvent({
-        comment: newComment,
-        user: client.state.getLatestValue()
-          .connected_user as UserResponseCommonFields,
-      });
-
-      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
-
-      handleCommentAdded.call(feed, currentUserPayload, false);
-
-      let stateBefore = feed.currentState;
-
-      handleCommentAdded.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
-
-      handleCommentAdded.call(feed, currentUserPayload);
-
-      stateBefore = feed.currentState;
-
-      handleCommentAdded.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', () => {
-      handleCommentAdded.call(feed, currentUserPayload);
-
-      // Clear the queue
-      (feed as any).stateUpdateQueue.clear();
-
-      // Now update should be allowed from another WS event
-      handleCommentAdded.call(feed, currentUserPayload);
-
-      const comments =
-        feed.currentState.comments_by_entity_id[activityId]?.comments;
-      const [latestComment] = (comments ?? []).toReversed();
-
-      expect(comments?.length).toEqual(3);
-      expect(latestComment).toMatchObject(newComment);
-    });
-
-    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
-      handleCommentAdded.call(feed, currentUserPayload, false);
-
-      // Clear the queue
-      (feed as any).stateUpdateQueue.clear();
-
-      // Now update should be allowed from another HTTP response
-      handleCommentAdded.call(feed, currentUserPayload, false);
-
-      const comments =
-        feed.currentState.comments_by_entity_id[activityId]?.comments;
-      const [latestComment] = (comments ?? []).toReversed();
-
-      expect(comments?.length).toEqual(3);
-      expect(latestComment).toMatchObject(newComment);
-    });
-
-    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the comment reaction deletion', () => {
-      const otherUserPayload = generateCommentAddedEvent({
-        comment: newComment,
-        user: generateUserResponseCommonFields({ id: getHumanId() }),
-      });
-
-      handleCommentAdded.call(feed, otherUserPayload);
-
-      expect((feed as any).stateUpdateQueue).toEqual(new Set());
-
-      handleCommentAdded.call(feed, otherUserPayload);
-
-      const comments =
-        feed.currentState.comments_by_entity_id[activityId]?.comments;
-      const [latestComment] = (comments ?? []).toReversed();
-
-      expect((feed as any).stateUpdateQueue).toEqual(new Set());
-      expect(comments?.length).toEqual(3);
-      expect(latestComment).toMatchObject(newComment);
-    });
-  });
-});