@stream-io/feeds-client 0.2.18 → 0.2.19

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

@@ -1,82 +0,0 @@
-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-updated.test.ts

@@ -1,84 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { Feed } from '../../../feed';
-import { FeedsClient } from '../../../feeds-client';
-import { handleFeedMemberUpdated } from './handle-feed-member-updated';
-import {
-  generateFeedResponse,
-  generateFeedMemberUpdatedEvent,
-  generateFeedMemberResponse,
-  generateOwnUser,
-  getHumanId,
-} from '../../../test-utils/response-generators';
-
-describe(handleFeedMemberUpdated.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 an existing member in members array', () => {
-    const member1 = generateFeedMemberResponse();
-    const member2 = generateFeedMemberResponse();
-    feed.state.partialNext({ members: [member1, member2] });
-
-    const event = generateFeedMemberUpdatedEvent({
-      member: { user: { id: member1.user.id }, role: 'admin' },
-    });
-
-    handleFeedMemberUpdated.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter.members).toHaveLength(2);
-    expect(stateAfter.members?.[0]).toBe(event.member);
-    expect(stateAfter.members?.[1]).toBe(member2);
-  });
-
-  it('does not modify members when target is not present', () => {
-    const existingMember = generateFeedMemberResponse();
-    feed.state.partialNext({ members: [existingMember] });
-
-    const event = generateFeedMemberUpdatedEvent();
-
-    const stateBefore = feed.currentState;
-    handleFeedMemberUpdated.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter).toBe(stateBefore);
-  });
-
-  it('sets own_membership when the updated member is the connected user', () => {
-    const event = generateFeedMemberUpdatedEvent({
-      member: {
-        user: { id: currentUserId },
-        role: 'owner',
-        status: 'member',
-      },
-    });
-
-    const stateBefore = feed.currentState;
-    expect(stateBefore.own_membership).toBeUndefined();
-
-    handleFeedMemberUpdated.call(feed, event);
-
-    const stateAfter = feed.currentState;
-    expect(stateAfter.own_membership).toBe(event.member);
-  });
-});

package/src/feed/event-handlers/follow/follow-state-update-queue.test.ts

@@ -1,219 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import type { FollowResponse } from '../../../gen/models';
-import { shouldUpdateState } from '../../../utils/state-update-queue';
-import { handleFollowUpdated } from './handle-follow-updated';
-import { Feed, handleFollowCreated, handleFollowDeleted } from '../../../feed';
-import { FeedsClient } from '../../../feeds-client';
-import {
-  generateFeedResponse,
-  generateFollowResponse,
-  generateOwnUser,
-  getHumanId,
-} from '../../../test-utils';
-
-describe(`Follow ${shouldUpdateState.name} integration`, () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let follow: FollowResponse;
-  let otherFollow: FollowResponse;
-  let ownFollow: FollowResponse;
-  let userId: string;
-
-  beforeEach(() => {
-    userId = getHumanId();
-    client = new FeedsClient('mock-api-key');
-
-    client.state.partialNext({
-      connected_user: generateOwnUser({ id: userId }),
-    });
-
-    const feedResponse = generateFeedResponse({
-      id: 'main',
-      group_id: 'user',
-      created_by: { id: userId },
-    });
-    feed = new Feed(client, 'user', 'main', feedResponse);
-    // Setup follows
-    follow = generateFollowResponse({
-      source_feed: generateFeedResponse({
-        id: 'main',
-        group_id: 'user',
-        created_by: { id: userId },
-      }),
-      target_feed: generateFeedResponse({
-        id: 'target',
-        group_id: 'user',
-      }),
-    });
-
-    otherFollow = generateFollowResponse({
-      source_feed: generateFeedResponse({
-        id: 'other',
-        group_id: 'user',
-        created_by: { id: getHumanId() },
-      }),
-      target_feed: generateFeedResponse({
-        id: 'main',
-        group_id: 'user',
-      }),
-    });
-
-    ownFollow = generateFollowResponse({
-      source_feed: generateFeedResponse({
-        id: 'other',
-        group_id: 'user',
-        created_by: { id: userId },
-      }),
-      target_feed: generateFeedResponse({
-        id: 'main',
-        group_id: 'user',
-      }),
-    });
-    // Set up initial state
-    feed.state.next((currentState) => ({
-      ...currentState,
-      following: [follow],
-      followers: [otherFollow],
-      own_follows: [ownFollow],
-    }));
-  });
-
-  describe.each(
-    [
-      {
-        handler: handleFollowCreated,
-        state: {
-          status: 'accepted',
-        },
-        count: 2,
-      },
-      {
-        handler: handleFollowUpdated,
-        state: {
-          status: 'accepted',
-        },
-        count: 1,
-      },
-      { handler: handleFollowDeleted, state: undefined, count: 0 },
-    ].map(({ handler, state, count }) => [
-      handler.name,
-      handler,
-      state as Partial<FollowResponse>,
-      count,
-    ]),
-  )(`%s`, (_name, handler, state, count) => {
-    it(`skips update if ${shouldUpdateState.name} returns false`, () => {
-      // Prepare feed, set as watched
-      feed.state.partialNext({ watch: true });
-
-      const updatedFollow: FollowResponse = { ...follow, status: 'pending' };
-
-      // 1. HTTP and then WS event
-
-      // Call once as HTTP response to populate the queue
-      handler.call(
-        feed,
-        {
-          follow: { ...updatedFollow, ...state },
-        },
-        false,
-      );
-
-      // Call again as WS event, should be skipped
-      let stateBefore = feed.currentState;
-      handler.call(feed, { follow: updatedFollow });
-
-      // State should not change
-      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 then HTTP
-
-      // Call once as WS event to populate the queue
-      handler.call(
-        feed,
-        {
-          follow: { ...updatedFollow, ...state },
-        },
-      );
-
-      // Call again as HTTP response, should be skipped
-      stateBefore = feed.currentState;
-      handler.call(feed, { follow: updatedFollow }, false);
-
-      // State should not change
-      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', () => {
-      const updatedFollow: FollowResponse = { ...follow, status: 'pending' };
-
-      handler.call(feed, { follow: updatedFollow });
-
-      // Clear the queue
-      (feed as any).stateUpdateQueue.clear();
-
-      // Now update should be allowed from another WS event
-      handler.call(feed, {
-        follow: { ...updatedFollow, ...state },
-      });
-
-      const following = feed.currentState.following!;
-      const [updatedFollowAfter] = following;
-
-      expect(following.length).toEqual(count);
-      expect(updatedFollowAfter).toMatchObject(state!);
-    });
-
-    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
-      const updatedFollow: FollowResponse = { ...follow, status: 'pending' };
-
-      handler.call(feed, { follow: updatedFollow }, false);
-
-      // Clear the queue
-      (feed as any).stateUpdateQueue.clear();
-
-      // Now update should be allowed from another HTTP response
-      handler.call(
-        feed,
-        {
-          follow: { ...updatedFollow, ...state },
-        },
-        false,
-      );
-
-      const following = feed.currentState.following!;
-      const [updatedFollowAfter] = following;
-
-      expect(following.length).toEqual(count);
-      expect(updatedFollowAfter).toMatchObject(state!);
-    });
-
-    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the follow', () => {
-      const updatedFollow: FollowResponse = {
-        ...otherFollow,
-        status: 'pending',
-      };
-
-      handler.call(feed, { follow: updatedFollow });
-
-      expect((feed as any).stateUpdateQueue).toEqual(new Set());
-
-      handler.call(feed, {
-        follow: { ...updatedFollow, ...state },
-      });
-
-      const following = feed.currentState.following!;
-      const [updatedFollowAfter] = following;
-
-      expect((feed as any).stateUpdateQueue).toEqual(new Set());
-      expect(following.length).toEqual(1);
-      expect(updatedFollowAfter).toMatchObject(follow);
-    });
-  });
-});

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

@@ -1,250 +0,0 @@
-import type {
-  FeedResponse,
-  FollowResponse,
-  UserResponse,
-} from '../../../gen/models';
-import { generateFollowResponse } from '../../../test-utils';
-import { updateStateFollowCreated } from './handle-follow-created';
-
-import { describe, it, expect, beforeEach } from 'vitest';
-
-describe('handle-follow-created', () => {
-  describe(updateStateFollowCreated.name, () => {
-    let mockFollow: FollowResponse;
-    let mockFeed: FeedResponse;
-    let mockUser: UserResponse;
-
-    beforeEach(() => {
-      mockFollow = generateFollowResponse();
-      mockFeed = mockFollow.source_feed;
-      mockUser = mockFeed.created_by;
-    });
-
-    it('should return unchanged state for non-accepted follows', () => {
-      const follow: FollowResponse = {
-        ...mockFollow,
-        status: 'pending',
-      };
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: [],
-        following: [],
-      };
-
-      const result = updateStateFollowCreated(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(false);
-    });
-
-    it('should handle when this feed follows someone', () => {
-      const follow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'feed-x',
-          feed: 'user:feed-x',
-          created_by: {
-            ...mockUser,
-            id: 'user-x',
-          },
-          following_count: 1,
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'other-feed',
-          feed: 'user:other-feed',
-          created_by: mockUser,
-        },
-      };
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        following: [],
-        following_count: 0,
-      };
-
-      const result = updateStateFollowCreated(
-        follow,
-        currentState,
-        'user:feed-x',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.following).toHaveLength(1);
-      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).toBe(1);
-    });
-
-    it('should handle when someone follows this feed', () => {
-      const follow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'other-feed',
-          feed: 'user:other-feed',
-          created_by: {
-            ...mockUser,
-            id: 'other-user',
-          },
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: mockUser,
-          follower_count: 1,
-        },
-      };
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: [],
-        follower_count: 0,
-      };
-
-      const result = updateStateFollowCreated(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.followers).toHaveLength(1);
-      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).toBe(1);
-    });
-
-    it('should add to own_follows when connected user is the source', () => {
-      const follow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: { ...mockUser, id: 'user-1' },
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'feed-x',
-          feed: 'user:feed-x',
-          created_by: {
-            ...mockUser,
-            id: 'user-x',
-          },
-        },
-      };
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: [],
-        own_follows: [],
-      };
-
-      const result = updateStateFollowCreated(
-        follow,
-        currentState,
-        'user:feed-x',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.own_follows).toHaveLength(1);
-      expect(result.data.own_follows?.[0]).toBe(follow);
-    });
-
-    it('should not update followers/following when they are undefined', () => {
-      const follow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'other-feed',
-          feed: 'user:other-feed',
-          created_by: mockUser,
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: mockUser,
-        },
-      };
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: undefined,
-        following: undefined,
-        own_follows: undefined,
-      };
-
-      const result = updateStateFollowCreated(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.followers).toBeUndefined();
-      expect(result.data).toMatchObject(follow.target_feed);
-    });
-
-    it('should add new followers to the top of existing arrays', () => {
-      const existingFollow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'existing-feed',
-          feed: 'user:existing-feed',
-          created_by: mockUser,
-        },
-      };
-
-      const follow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'other-feed',
-          feed: 'user:other-feed',
-          created_by: mockUser,
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: mockUser,
-        },
-      };
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: [existingFollow],
-        following: undefined,
-        own_follows: undefined,
-      };
-
-      const result = updateStateFollowCreated(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.followers).toHaveLength(2);
-      expect(result.data.followers?.[0]).toBe(follow);
-      expect(result.data.followers?.[1]).toBe(existingFollow);
-    });
-  });
-});