@stream-io/feeds-client 0.2.18 → 0.2.20

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

@@ -1,267 +0,0 @@
-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,
-  generateUserResponseCommonFields,
-  getHumanId,
-} from '../../../test-utils';
-import type { CommentResponse, UserResponseCommonFields } from '../../../gen/models';
-import { shouldUpdateState } from '../../../utils';
-import type { EventPayload } from '../../../types-internal';
-
-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);
-  });
-
-  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/utils/update-comment-count.test.ts

@@ -1,322 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import { updateCommentCount as updateCommentCountInternal } from './update-comment-count';
-import * as commentHandlers from '../handle-comment-updated';
-import * as activityHandlers from '../../activity';
-import { FeedsClient } from '../../../../feeds-client';
-import { Feed } from '../../../feed';
-import type { ActivityResponse, CommentResponse } from '../../../../gen/models';
-import {
-  generateCommentResponse,
-  generateFeedResponse,
-  generateOwnUser,
-  getHumanId,
-} from '../../../../test-utils';
-
-vi.mock('../../activity', async (importOriginal) => {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
-  const actual = await importOriginal<typeof import('../../activity')>();
-  return {
-    ...actual,
-    handleActivityUpdated: vi.fn(),
-  };
-});
-
-vi.mock('../handle-comment-updated', async (importOriginal) => {
-  // eslint-disable-next-line @typescript-eslint/consistent-type-imports
-  const actual = await importOriginal<typeof import('../handle-comment-updated')>();
-  return {
-    ...actual,
-    handleCommentUpdated: vi.fn(),
-  };
-});
-
-const handleCommentUpdated = commentHandlers.handleCommentUpdated as unknown as ReturnType<typeof vi.fn>;
-const handleActivityUpdated = activityHandlers.handleActivityUpdated as unknown as ReturnType<typeof vi.fn>;
-
-describe('updateCommentCount', () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let currentUserId: string;
-  let activityId: string;
-  let existingActivity: ActivityResponse;
-
-  let updateCommentCount: OmitThisParameter<typeof updateCommentCountInternal>;
-
-  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,
-    );
-    feed.state.partialNext({ watch: false });
-
-    updateCommentCount = updateCommentCountInternal.bind(feed);
-
-    activityId = `activity-${getHumanId()}`;
-    existingActivity = { id: activityId, comment_count: 0 } as ActivityResponse;
-
-    feed.state.partialNext({ activities: [existingActivity] });
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  })
-
-  it('correctly updates parent comment reply_count and comment_count (with watch: false)', () => {
-    const parentCommentId = 'c1';
-
-    const existingComment = generateCommentResponse({
-      id: parentCommentId,
-      object_id: activityId,
-      reply_count: 0,
-    });
-
-    feed.state.partialNext({
-      activities: [{ ...existingActivity, comment_count: 1 }],
-      comments_by_entity_id: {
-        [activityId]: {
-          comments: [existingComment],
-        },
-      },
-    });
-
-    const incomingReply = generateCommentResponse({
-      id: 'c2',
-      object_id: activityId,
-      parent_id: parentCommentId,
-      reply_count: 0,
-    });
-
-    updateCommentCount({
-      activity: { ...existingActivity, comment_count: 11 },
-      comment: incomingReply,
-      replyCountUpdater: (prev: number) => prev + 1,
-    });
-
-    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
-    const [commentArg, secondArg] = handleCommentUpdated.mock.calls[0];
-    expect(secondArg).toBe(false);
-    expect(commentArg).toEqual({
-      comment: {
-        ...existingComment,
-        reply_count: 1,
-      },
-    });
-
-    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
-    expect(handleActivityUpdated).toHaveBeenCalledWith({
-      activity: { id: activityId, comment_count: 11 },
-    }, false);
-  });
-
-  it('updates parent comment reply_count when grandparent is missing (falls back to activity store)', () => {
-    const parentCommentId = 'c1';
-
-    const existingComment = generateCommentResponse({
-      id: parentCommentId,
-      object_id: activityId,
-      reply_count: 5,
-    });
-
-    feed.state.partialNext({
-      activities: [{ ...existingActivity, comment_count: 0 }],
-      comments_by_entity_id: {
-        [activityId]: {
-          comments: [existingComment],
-          pagination: { sort: 'first' },
-        },
-      },
-    });
-
-    const incomingReply = generateCommentResponse({
-      id: 'c2',
-      object_id: activityId,
-      parent_id: parentCommentId,
-      reply_count: 0,
-    });
-
-    updateCommentCount({
-      activity: { ...existingActivity, comment_count: 1 },
-      comment: incomingReply,
-      replyCountUpdater: (prev: number) => prev - 2,
-    });
-
-    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
-    expect(handleCommentUpdated).toHaveBeenCalledWith(
-      { comment: { ...existingComment, reply_count: 3 } },
-      false,
-    );
-    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
-    expect(handleActivityUpdated).toHaveBeenCalledWith({
-      activity: { id: activityId, comment_count: 1 },
-    }, false);
-  });
-
-  it('updates the correct parent when replying to a depth-3 comment (entity_parent_id points to the parent comment store)', () => {
-    const c1: CommentResponse = generateCommentResponse({ id: 'c1', object_id: activityId, reply_count: 0 });
-    const c2: CommentResponse = generateCommentResponse({ id: 'c2', object_id: activityId, parent_id: 'c1', reply_count: 7 });
-
-    feed.state.partialNext({
-      activities: [{ ...existingActivity, comment_count: 1 }],
-      comments_by_entity_id: {
-        [activityId]: {
-          comments: [c1],
-        },
-        ['c1']: { entity_parent_id: activityId, comments: [c2] },
-        ['c2']: { entity_parent_id: 'c1', comments: [] },
-      },
-    });
-
-    const incomingReplyToC2: CommentResponse = generateCommentResponse({
-      id: 'c3',
-      object_id: activityId,
-      parent_id: 'c2',
-      reply_count: 0,
-    });
-
-    updateCommentCount({
-      activity: { ...existingActivity, comment_count: 1 },
-      comment: incomingReplyToC2,
-      replyCountUpdater: (prev: number) => prev + 5,
-    });
-
-    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
-    expect(handleCommentUpdated).toHaveBeenCalledWith(
-      { comment: { ...c2, reply_count: 12 } },
-      false,
-    );
-    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
-    expect(handleActivityUpdated).toHaveBeenCalledWith({
-      activity: { id: activityId, comment_count: 1 },
-    }, false);
-  });
-
-  it('does nothing on parent reply when parent comment is not found in the resolved store', () => {
-    feed.state.partialNext({
-      activities: [{ ...existingActivity, comment_count: 4 }],
-      comments_by_entity_id: {
-        [activityId]: { comments: [], },
-      },
-    });
-
-    const incomingReply: CommentResponse = generateCommentResponse({
-      id: 'child',
-      object_id: activityId,
-      parent_id: 'missing-parent',
-      reply_count: 0,
-    });
-
-    updateCommentCount({
-      activity: { ...existingActivity, comment_count: 5 },
-      comment: incomingReply,
-      replyCountUpdater: (prev: number) => prev + 1,
-    });
-
-    expect(handleCommentUpdated).not.toHaveBeenCalled();
-    // the activity still updates, as watch === true
-    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
-    expect(handleActivityUpdated).toHaveBeenCalledWith({
-      activity: { id: activityId, comment_count: 5 },
-    }, false);
-  });
-
-  it('skips parent reply update when comment has no parent_id (top-level comment)', () => {
-    feed.state.partialNext({
-      activities: [{ ...existingActivity, comment_count: 1 }],
-      comments_by_entity_id: {
-        [activityId]: { comments: [], },
-      },
-    });
-
-    const topLevel: CommentResponse = generateCommentResponse({
-      id: 'cTop',
-      object_id: activityId,
-      reply_count: 0,
-    });
-
-    updateCommentCount({
-      activity: { ...existingActivity, comment_count: 3 },
-      comment: topLevel,
-      replyCountUpdater: (prev: number) => prev + 100,
-    });
-
-    expect(handleCommentUpdated).not.toHaveBeenCalled();
-    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
-    expect(handleActivityUpdated).toHaveBeenCalledWith({
-      activity: { id: activityId, comment_count: 3 },
-    }, false);
-  });
-
-  it('no-ops any update if neither activity nor comment are found', () => {
-    feed.state.partialNext({
-      activities: [{ id: 'other-1', comment_count: 1 } as ActivityResponse, { id: 'other-2', comment_count: 3 } as ActivityResponse],
-      comments_by_entity_id: {},
-    });
-
-    const topLevel: CommentResponse = generateCommentResponse({
-      id: 'cTop',
-      object_id: 'missing-activity',
-      reply_count: 0,
-    });
-
-    updateCommentCount({
-      activity: { ...existingActivity, comment_count: 3 },
-      comment: topLevel,
-      replyCountUpdater: (prev: number) => prev + 1,
-    });
-
-    expect(handleActivityUpdated).not.toHaveBeenCalled();
-    expect(handleCommentUpdated).not.toHaveBeenCalled();
-  });
-
-  it('can update both parent reply_count and activity comment_count in the same call', () => {
-    const parentCommentId = 'c1';
-    const c1: CommentResponse = generateCommentResponse({ id: parentCommentId, object_id: activityId, reply_count: 10 });
-
-    feed.state.partialNext({
-      activities: [{ ...existingActivity, comment_count: 100 }],
-      comments_by_entity_id: {
-        [activityId]: { comments: [c1] },
-        [parentCommentId]: { entity_parent_id: activityId },
-      },
-    });
-
-    const incomingReply: CommentResponse = generateCommentResponse({
-      id: 'c2',
-      object_id: activityId,
-      parent_id: parentCommentId,
-      reply_count: 0,
-    });
-
-    updateCommentCount({
-      activity: { ...existingActivity, comment_count: 97 },
-      comment: incomingReply,
-      replyCountUpdater: (prev: number) => prev + 2,
-    });
-
-    expect(handleCommentUpdated).toHaveBeenCalledTimes(1);
-    expect(handleCommentUpdated).toHaveBeenCalledWith(
-      { comment: { ...c1, reply_count: 12 } },
-      false,
-    );
-    expect(handleActivityUpdated).toHaveBeenCalledTimes(1);
-    expect(handleActivityUpdated).toHaveBeenCalledWith({
-      activity: { id: activityId, comment_count: 97 },
-    }, false);
-  });
-});

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

@@ -1,75 +0,0 @@
-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);
-  });
-});